;OOf6ddlmZmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZ ddlZddlmZmZddlmZmZddlmZmZdd lmZdd lmZdd lmZd Z Gd de!Z"Gdde!Z#Gdde$Z%Gdde$Z&Gdde&Z'Gdde&Z(Gdde&Z) ddl*m+Z+Gdde+Z,Gdde&Z-Gd d!e&Z.ej^d"k\rd#d$l0m1Z1d(d%Z2d&Z3e4d'k(re3yy#e$rYwxYw#e$re$Z+Y_wxYw)))divisionprint_functionNwraps)count)WeakKeyDictionary)StoppingContextis_mouse_event)PYTHON3reraise) command_map REDRAW_SCREEN) PopUpTarget)signals)INPUT_DESCRIPTORS_CHANGEDiceZdZdZy) ExitMainLoopz_ When this exception is raised within a main loop the main loop will exit cleanly. N)__name__ __module__ __qualname____doc__P/var/www/premiumrankchecker/venv/lib/python3.12/site-packages/urwid/main_loop.pyrr2s  rrc eZdZy)CantUseExternalLoopN)rrrrrrrr9srrceZdZdZ d dZdZededZdZed eZ d!d Z d!d Z d Z d Z dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZy)"MainLoopa This is the standard main loop implementation for a single interactive session. :param widget: the topmost widget used for painting the screen, stored as :attr:`widget` and may be modified. Must be a box widget. :type widget: widget instance :param palette: initial palette for screen :type palette: iterable of palette entries :param screen: screen to use, default is a new :class:`raw_display.Screen` instance; stored as :attr:`screen` :type screen: display module screen instance :param handle_mouse: ``True`` to ask :attr:`.screen` to process mouse events :type handle_mouse: bool :param input_filter: a function to filter input before sending it to :attr:`.widget`, called from :meth:`.input_filter` :type input_filter: callable :param unhandled_input: a function called when input is not handled by :attr:`.widget`, called from :meth:`.unhandled_input` :type unhandled_input: callable :param event_loop: if :attr:`.screen` supports external an event loop it may be given here, default is a new :class:`SelectEventLoop` instance; stored as :attr:`.event_loop` :type event_loop: event loop instance :param pop_ups: `True` to wrap :attr:`.widget` with a :class:`PopUpTarget` instance to allow any widget to open a pop-up anywhere on the screen :type pop_ups: boolean .. attribute:: screen The screen object this main loop uses for screen updates and reading input .. attribute:: event_loop The event loop object this main loop uses for waiting on alarms and IO Nc ||_||_||_|sddlm} | j }|r|j |||_d|_||_ ||_ t|ds|td|d| t}||_t|jdr%|jj|j_i|_y)Nr) raw_displayhook_event_loopzscreen object passed z& does not support external event loopssignal_handler_setter)_widget handle_mousepop_upsurwidr Screenregister_palettescreen screen_size_unhandled_input _input_filterhasattrNotImplementedErrorSelectEventLoop event_loopset_signal_handlerr" _watch_pipes) selfwidgetpaletter)r$ input_filterunhandled_inputr0r%r s r__init__zMainLoop.__init__js (  ) '')F   # #G ,  /)v0 ,%>D'GH H  (*J$ 4;; 7 8150R0RDKK -rc||_|jr|j|j_y|j|_yN)r#r%_topmost_widgetoriginal_widget)r3r4s r _set_widgetzMainLoop._set_widgets. <<37<zMainLoop.s $,,rzj Property for the topmost widget used to draw the screen. This must be a box widget. )doccn||_|rt|j|_y|j|_yr:)_pop_upsrr#r;)r3r%s r _set_pop_upszMainLoop._set_pop_upss) #.t||#s 4==rcNfd}jj||S)a_ Schedule an alarm in *sec* seconds that will call *callback* from the within the :meth:`run` method. :param sec: seconds until alarm :type sec: float :param callback: function to call with two parameters: this main loop object and *user_data* :type callback: callable cyr:rcallbackr3 user_datasrcbz!MainLoop.set_alarm_in..cb T9 %r)r0alarm)r3secrIrJrKs` `` r set_alarm_inzMainLoop.set_alarm_ins &$$S"--rcxfd}jj|tjz |S)a Schedule an alarm at *tm* time that will call *callback* from the within the :meth:`run` function. Returns a handle that may be passed to :meth:`remove_alarm`. :param tm: time to call callback e.g. ``time.time() + 5`` :type tm: float :param callback: function to call with two parameters: this main loop object and *user_data* :type callback: callable cyr:rrHsrrKz!MainLoop.set_alarm_at..cbrLr)r0rMtime)r3tmrIrJrKs` `` r set_alarm_atzMainLoop.set_alarm_ats* &$$R$))+%5r::rc8|jj|S)zf Remove an alarm. Return ``True`` if *handle* was found, ``False`` otherwise. )r0 remove_alarmr3handles rrVzMainLoop.remove_alarms ++F33rctj\}tjtjtjdfd}j j |fj|<|S)a Create a pipe for use by a subprocess or thread to trigger a callback in the process/thread running the main loop. :param callback: function taking one parameter to call from within the process/thread running the main loop :type callback: callable This method returns a file descriptor attached to the write end of a pipe. The read end of the pipe is added to the list of files :attr:`event_loop` is watching. When data is written to the pipe the callback function will be called and passed a single value containing data read from the pipe. This method may be used any time you want to update widgets from another thread or subprocess. Data may be written to the returned file descriptor with ``os.write(fd, data)``. Ensure that data is less than 512 bytes (or 4K on Linux) so that the callback will be triggered just once with the complete value of data passed in. If the callback returns ``False`` then the watch will be removed from :attr:`event_loop` and the read end of the pipe will be closed. You are responsible for closing the write end of the pipe with ``os.close(fd)``. Nctjt}|}|dur1jj tj yyNF)osreadPIPE_BUFFER_READ_SIZEr0remove_watch_fileclose)datarvalrIpipe_rdr3 watch_handles rrKzMainLoop.watch_pipe..cbsG777$9:DD>Du}11,?!r)r\pipefcntlF_SETFL O_NONBLOCKr0 watch_filer2)r3rIpipe_wrrKrcrds`` @@r watch_pipezMainLoop.watch_pipesi8779 GU]]BMM:  "11'2> &2G%<'"rc |jj|\}}|jj |syt j |y#t$rYywxYw)z Close the read end of the pipe and remove the watch created by :meth:`watch_pipe`. You are responsible for closing the write end of the pipe. Returns ``True`` if the watch pipe exists, ``False`` otherwise FT)r2popKeyErrorr0r_r\r`)r3write_fdrdrcs rremove_watch_pipezMainLoop.remove_watch_pipes\ $($5$5$9$9($C !L'00>    sA AAc:|jj||S)z Call *callback* when *fd* has some data to read. No parameters are passed to callback. Returns a handle that may be passed to :meth:`remove_watch_file`. )r0rir3fdrIs rrizMainLoop.watch_files))"h77rc8|jj|S)zn Remove a watch file. Returns ``True`` if the watch file exists, ``False`` otherwise. )r0r_rWs rr_zMainLoop.remove_watch_file s 0088rcD |jy#t$rYywxYw)an Start the main loop handling input events and updating the screen. The loop will continue until an :exc:`ExitMainLoop` exception is raised. If you would prefer to manage the event loop yourself, don't use this method. Instead, call :meth:`start` before starting the event loop, and :meth:`stop` once it's finished. N)_runrr?s rrunz MainLoop.runs"  IIK   s  cy)a- >>> w = _refl("widget") # _refl prints out function calls >>> w.render_rval = "fake canvas" # *_rval is used for return values >>> scr = _refl("screen") >>> scr.get_input_descriptors_rval = [42] >>> scr.get_cols_rows_rval = (20, 10) >>> scr.started = True >>> scr._urwid_signals = {} >>> evl = _refl("event_loop") >>> evl.enter_idle_rval = 1 >>> evl.watch_file_rval = 2 >>> ml = MainLoop(w, [], scr, event_loop=evl) >>> ml.run() # doctest:+ELLIPSIS screen.start() screen.set_mouse_tracking() screen.unhook_event_loop(...) screen.hook_event_loop(...) event_loop.enter_idle() event_loop.run() event_loop.remove_enter_idle(1) screen.unhook_event_loop(...) screen.stop() >>> ml.draw_screen() # doctest:+ELLIPSIS screen.get_cols_rows() widget.render((20, 10), focus=True) screen.draw_screen((20, 10), 'fake canvas') Nrr?s r _test_runzMainLoop._test_run#rc|jj|jr|jjt |jds t d t j|jt|j|j|jj|j|_t|S#t$rYPwxYw)a Sets up the main loop, hooking into the event loop where necessary. Starts the :attr:`screen` if it hasn't already been started. If you want to control starting and stopping the event loop yourself, you should call this method before starting, and call `stop` once the loop has finished. You may also use this method as a context manager, which will stop the loop automatically at the end of the block: with main_loop.start(): ... Note that some event loop implementations don't handle exceptions specially if you manage the event loop yourself. In particular, the Twisted and asyncio loops won't stop automatically when :exc:`ExitMainLoop` (or anything else) is raised. r!z1Screen {0!r} doesn't support external event loops)r)startr$set_mouse_trackingr-rrconnect_signalr_reset_input_descriptors NameErrorr0 enter_idle entering_idle idle_handler r?s rr|zMainLoop.start@s$     KK * * ,t{{$56%CE E   " "4;;0I-- / %%'??55d6H6HIt$$    s#/C C#"C#c.|jj|j|`tj|j t |j|j j|j|j jy)z Cleans up any hooks added to the event loop. Only call this if you're managing the event loop yourself, after the loop stops. N) r0remove_enter_idlerrdisconnect_signalr)rrunhook_event_loopstopr?s rrz MainLoop.stopfsh ))$*:*:;  !!$++/H  ) ) + %%doo6 rc|jj|j|jj|j|jyr:)r)rr0r!_updater?s rrz!MainLoop._reset_input_descriptorsss4 %%doo6 ##DOOT\\Brcn |j |j j |j y#t$rM |j|jj cYS#|jj wxYwwxYw#|jj xYwr:)r|r_run_screen_event_loopr)rr0rwr?s rrvz MainLoop._runws # JJL  OO   ! # # #224   "   "  #  KK    s,>B BA4B4BBB4ch|j||}|r|j|d|vrd|_yyy)a >>> w = _refl("widget") >>> w.selectable_rval = True >>> w.mouse_event_rval = True >>> scr = _refl("screen") >>> scr.get_cols_rows_rval = (15, 5) >>> evl = _refl("event_loop") >>> ml = MainLoop(w, [], scr, event_loop=evl) >>> ml._input_timeout = "old timeout" >>> ml._update(['y'], [121]) # doctest:+ELLIPSIS screen.get_cols_rows() widget.selectable() widget.keypress((15, 5), 'y') >>> ml._update([("mouse press", 1, 5, 4)], []) widget.mouse_event((15, 5), 'mouse press', 1, 5, 4, focus=True) >>> ml._update([], []) window resizeN)r6 process_inputr*r3keysraws rrzMainLoop._updatesA$  s+    t $$&#' ' rcBd} |j|s?|jjr)tj|jj}d}|s|r@t d|dt j z }|jj|n|jjd|jjd\}}|s"|r |dt j z }|dkrn|s|j|}|r|j||rr|dt j z }|dkDrnR|\}}}||jjr*tj|jj}nd}|rrd|vrd|_ )z This method is used when the screen does not support using external event loops. The alarms stored in the SelectEventLoop in :attr:`event_loop` are modified by this method. NTrr) draw_screenr0_alarmsheapqheappopmaxrRr)set_input_timeouts get_inputr6rr*)r3 next_alarmrrNrrS tie_breakrIs rrzMainLoop._run_screen_event_loopsg     $//"9"9"]]4??+B+BC DaA!<=CKK2237KK2248 KK11$7 c $Q-$))+5Cax$$T3/D""4( mdiik17*4'Ix ??**!&t/F/F!GJ!%J$&#' Krcy)aq >>> w = _refl("widget") >>> scr = _refl("screen") >>> scr.get_cols_rows_rval = (10, 5) >>> scr.get_input_rval = [], [] >>> ml = MainLoop(w, screen=scr) >>> def stop_now(loop, data): ... raise ExitMainLoop() >>> handle = ml.set_alarm_in(0, stop_now) >>> try: ... ml._run_screen_event_loop() ... except ExitMainLoop: ... pass screen.get_cols_rows() widget.render((10, 5), focus=True) screen.draw_screen((10, 5), None) screen.set_input_timeouts(0) screen.get_input(True) Nrr?s r_test_run_screen_event_loopz$MainLoop._test_run_screen_event_looprzrc D|js|jj|_d}|D]}|dk(r t|rK|\}}}}t |j drn|j j |j||||drCd}n@|j jr&|j j|j|}|rKt|tk(r|jjd}|t|j|z}d}|S)a This method will pass keyboard input and mouse events to :attr:`widget`. This method is called automatically from the :meth:`run` method when there is input, but may also be called to simulate input from the user. *keys* is a list of input returned from :attr:`screen`'s get_input() or get_input_nonblocking() methods. Returns ``True`` if any key was handled by a widget or the :meth:`unhandled_input` method. Fr mouse_eventTfocusN)r*r) get_cols_rowsr r-r;r selectablekeypressr rclearboolr7)r3rsomething_handledkeventbuttoncolrows rrzMainLoop.process_inputs#{{88:D ! )AO#a *+'vsC4//?++778H8H!6348A %%002((11$2B2BAFq>]2KK%%'(,%%d.B.B1.E)FF%$(!% )(! rcy)a >>> w = _refl("widget") >>> w.selectable_rval = True >>> scr = _refl("screen") >>> scr.get_cols_rows_rval = (10, 5) >>> ml = MainLoop(w, [], scr) >>> ml.process_input(['enter', ('mouse drag', 1, 14, 20)]) screen.get_cols_rows() widget.selectable() widget.keypress((10, 5), 'enter') widget.mouse_event((10, 5), 'mouse drag', 1, 14, 20, focus=True) True Nrr?s r_test_process_inputzMainLoop._test_process_input rzrcB|jr|j||S|S)av This function is passed each all the input events and raw keystroke values. These values are passed to the *input_filter* function passed to the constructor. That function must return a list of keys to be passed to the widgets to handle. If no *input_filter* was defined this implementation will return all the input events. )r,rs rr6zMainLoop.input_filters%   %%dC0 0 rc>|jr|j|Sy)a This function is called with any input that was not handled by the widgets, and calls the *unhandled_input* function passed to the constructor. If no *unhandled_input* was defined then the input will be ignored. *input* is the keyboard or mouse input. The *unhandled_input* function should return ``True`` if it handled the input. N)r+)r3inputs rr7zMainLoop.unhandled_input(s#  ((/ / !rcR|jjr|jyy)z This method is called whenever the event loop is about to enter the idle state. :meth:`draw_screen` is called here to update the screen when anything has changed. N)r)startedrr?s rrzMainLoop.entering_idle7s" ;;       rc|js|jj|_|jj |jd}|jj |j|y)a5 Render the widgets and paint the screen. This method is called automatically from :meth:`entering_idle`. If you modify the widgets displayed outside of handling input or responding to an alarm you will need to call this method yourself to repaint the screen. TrN)r*r)rr;renderr)r3canvass rrzMainLoop.draw_screen@s]#{{88:D %%,,T-=-=T,J  0 0&9r)rNTNNNFr:) rrrrr8r=propertyr4rDr%rOrTrVrkrprir_rwryr|rrrvrrrrrr6r7rrrrrrr<s+Z37BF%*!F0 .   F 0 0,?G .; 4)V$89  :$%L C (2/(b *%!N    0 :rrc@eZdZdZdZdZdZdZdZdZ dZ d Z y ) EventLoopzT Abstract class representing an event loop to be used by :class:`MainLoop`. ct)aW Call callback() a given time from now. No parameters are passed to callback. This method has no default implementation. Returns a handle that may be passed to remove_alarm() seconds -- floating point time to wait before calling callback callback -- function to call from event loop r.r3secondsrIs rrMzEventLoop.alarmU "##rct)z Add a callback for entering idle. This method has no default implementation. Returns a handle that may be passed to remove_idle() rr3rIs rrzEventLoop.enter_idlec "##rct)z Remove an alarm. This method has no default implementation. Returns True if the alarm exists, False otherwise rrWs rrVzEventLoop.remove_alarmmrrct)z Remove an idle callback. This method has no default implementation. Returns True if the handle was removed. rrWs rrzEventLoop.remove_enter_idlewrrct)z Remove an input file. This method has no default implementation. Returns True if the input file exists, False otherwise rrWs rr_zEventLoop.remove_watch_filerrct)z Start the event loop. Exit the loop when any callback raises an exception. If ExitMainLoop is raised, exit cleanly. This method has no default implementation. rr?s rrwz EventLoop.runs "##rct)aV Call callback() when fd has some data to read. No parameters are passed to callback. This method has no default implementation. Returns a handle that may be passed to remove_watch_file() fd -- file descriptor to watch for input callback -- function to call when input is available rrrs rrizEventLoop.watch_filerrc.tj||S)a Sets the signal handler for signal signum. The default implementation of :meth:`set_signal_handler` is simply a proxy function that calls :func:`signal.signal()` and returns the resulting value. signum -- signal number handler -- function (taking signum as its single argument), or `signal.SIG_IGN`, or `signal.SIG_DFL` )signal)r3signumhandlers rr1zEventLoop.set_signal_handlers}}VW--rN) rrrrrMrrVrr_rwrir1rrrrrPs/ $$$$$$ $ .rrcLeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z y ) r/z3 Event loop based on :func:`select.select` cZg|_i|_d|_i|_t |_yNr)r _watch_files _idle_handle_idle_callbacksr _tie_breakr?s rr8zSelectEventLoop.__init__s* !'rctj|z}|t|j|f}tj|j ||S# Call callback() a given time from now. No parameters are passed to callback. Returns a handle that may be passed to remove_alarm() seconds -- floating point time to wait before calling callback callback -- function to call from event loop )rRnextrrheappushr)r3rrIrSrXs rrMzSelectEventLoop.alarms@YY[7 "d4??+X6 t||V, rc |jj|tj|jy#t$rYywxYw)] Remove an alarm. Returns True if the alarm exists, False otherwise TF)rremoverheapify ValueErrorrWs rrVzSelectEventLoop.remove_alarms>   LL   ' MM$,, '  s:= A A c$||j|<|S" Call callback() when fd has some data to read. No parameters are passed to callback. Returns a handle that may be passed to remove_watch_file() fd -- file descriptor to watch for input callback -- function to call when input is available rrrs rrizSelectEventLoop.watch_files!)" rc<||jvr|j|=yyg Remove an input file. Returns True if the input file exists, False otherwise TFrrWs rr_z!SelectEventLoop.remove_watch_files& T&& &!!&)rcv|xjdz c_||j|j<|jS)q Add a callback for entering idle. Returns a handle that may be passed to remove_idle() rrrs rrzSelectEventLoop.enter_idle7 Q2:T../   rc> |j|=y#t$rYywxYw[ Remove an idle callback. Returns True if the handle was removed. FTrrnrWs rrz!SelectEventLoop.remove_enter_idle.  $$V,    cP|jjD] }| y)z9 Call all the registered idle callbacks. N)rvaluesrs r_entering_idlezSelectEventLoop._entering_idles',,335 H J rc d|_ |j#tj$r}|jddk7rYd}~,d}~wwxYw#t $rYywxYw) Start the event loop. Exit the loop when any callback raises an exception. If ExitMainLoop is raised, exit cleanly. TrN)_did_something_loopselecterrorargsr)r3es rrwzSelectEventLoop.run se "&D JJL||vvayA~&   s6AAA AAA  A AAct|jj}|js |jr|jr3|jdd}t d|t j z }|jr!|jr|jr dkDrd}d}tj|g|\}}}nd}tj|g|\}}}|sPdk(r|jd|_n3|1tj|j\}}}|d|_|D]} |j| d|_y)z6 A single iteration of the event loop ridleNFT) listrrrrrrRrrrr) r3fdsrStimeoutreadywerrralarm_callbackrss rrzSelectEventLoop._loops-4$$))+, <<4..||\\!_Q'adiik!12""DLL\\gk"MM#r3@ME1cB"MM#r37ME1cV|##%&+#05 dll0K-I~ &*# 'B !D  b ! #"&D  'rN)rrrrr8rMrVrir_rrrrwrrrrr/r/s9"    ! "'rr/cXeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd Zy) GLibEventLoopz+ Event loop based on GLib.MainLoop cddlm}||_g|_i|_d|_d|_i|_|j|_d|_ |ji|_ y)Nr)GLibF) gi.repositoryrrrr_glib_idle_enabledrrr _exc_info_enable_glib_idle_signal_handlers)r3rs rr8zGLibEventLoop.__init__Ds[&  "'!]]_   "rcjfd}jjt|dz|}jj ||fS)rc4jyr[r )rIr3sr ret_falsez&GLibEventLoop.alarm..ret_false[s J  " " $ri) handle_exitr timeout_addintrappend)r3rrIrrss` ` rrMzGLibEventLoop.alarmQsZ      YY " "3wt|#4i @ BH~rctjtjtjtjtj g}j jddds|jtj||vry|jvr4j jjj|tjk(rdntjk(ryfd}j jj j |||}|j|<y)a Sets the signal handler for signal signum. .. WARNING:: Because this method uses the `GLib`-specific `unix_signal_add` function, its behaviour is different than `signal.signal().` If `signum` is not `SIGHUP`, `SIGINT`, `SIGTERM`, `SIGUSR1`, `SIGUSR2` or `SIGWINCH`, this method performs no actions and immediately returns None. Returns None in all cases (unlike :func:`signal.signal()`). .. signum -- signal number handler -- function (taking signum as its single argument), or `signal.SIG_IGN`, or `signal.SIG_DFL` 6rNcyr:r)xs rr@z2GLibEventLoop.set_signal_handler..rzrc@|jjSr:)rSOURCE_CONTINUE) signal_numberrr3s r final_handlerz7GLibEventLoop.set_signal_handler..final_handlers M "99,, ,r)rSIGHUPSIGINTSIGTERMSIGUSR1SIGUSR2r check_versionrSIGWINCHr  source_removermSIG_IGNSIG_DFLunix_signal_addPRIORITY_DEFAULT)r3rr glib_signalsrsources` ` rr1z GLibEventLoop.set_signal_handlerds( MM MM NN NN NN  yy&&q"a0    0  %  T** * II # #D$9$9$=$=f$E F fnn $$G  &  -**499+E+Ev}^de(.f%rc |jj|d|jj|dy#t$rYywxYw)rrTF)rrrr%rrWs rrVzGLibEventLoop.remove_alarmsH   LL  q * II # #F1I .  s.io_callbacks J  " " $r)rr io_add_watchIO_INr)r3rsrIr1s` ` rrizGLibEventLoop.watch_filesR       YY # #Btyy{ C " rc||jvr6|jj|j||j|=yyr)rrr%rWs rr_zGLibEventLoop.remove_watch_filesC T&& & II # #D$5$5f$= >!!&)rcv|xjdz c_||j|j<|jSzw Add a callback for entering idle. Returns a handle that may be passed to remove_enter_idle() rrrs rrzGLibEventLoop.enter_idlerrcv|jry|jj|jd|_yr/)r ridle_add_glib_idle_callbackr?s rr zGLibEventLoop._enable_glib_idles.  " "  4334"&rc^|jjD] }| d|_yr[)rrr rs rr9z!GLibEventLoop._glib_idle_callbacks0,,335 H J "'rc> |j|=y#t$rYywxYwrrrWs rrzGLibEventLoop.remove_enter_idlerrch |jj|jjr|jj |jr|j}d|_t |yy#|jjr|jjwwxYwrN)rrw is_runningquitr r r3exc_infos rrwzGLibEventLoop.runs~  " JJNN zz$$& ! >>~~H!DN X  zz$$& !'s A::7B1cfd}|S)a, Decorator that cleanly exits the :class:`GLibEventLoop` if :exc:`ExitMainLoop` is thrown inside of the wrapped function. Store the exception info if some other exception occurs, it will be reraised after the loop quits. *f* -- function to be wrapped c |i|S#t$rjjYyddl}|j_jj rjjYyxYw)NrF)rrr?sysrAr r>)rkargsrDfr3s rwrapperz*GLibEventLoop.handle_exit..wrappersn &$''' " !   &!-::((*JJOO%s #BABr)r3rFrGs`` rrzGLibEventLoop.handle_exits rN)rrrrr8rMr1rVrir_rr r9rrwrrrrrr?sD #&0/d & !'   rrceZdZdZeZdZGddeZe dZ ddZ dZ d Z d Zd Zd Zd ZdZdZy)TornadoEventLoopa^ This is an Urwid-specific event loop to plug into its MainLoop. It acts as an adaptor for Tornado's IOLoop which does all heavy lifting except idle-callbacks. Notice, since Tornado has no concept of idle callbacks we monkey patch ioloop._impl.poll() function to be able to detect potential idle periods. rc"eZdZdZdZdZdZy)TornadoEventLoop.PollProxyz A simple proxy for a Python's poll object that wraps the .poll() method in order to detect idle periods and call Urwid callbacks c<||_||_d|_d|_y)NFr)_PollProxy__poll_obj_PollProxy__idle_map _idle_done _prev_timeout)r3poll_objidle_maps rr8z#TornadoEventLoop.PollProxy.__init__s&DO&DO#DO!"D rc.t|j|Sr:)getattrrM)r3names r __getattr__z&TornadoEventLoop.PollProxy.__getattr__!s4??D1 1rc ||jkDrd|_||_tj}|jj d}|r d|_|S|js-|j j D] }| d|_tdt|||ztjz }|jj |}|rd|_|S)NFrT) rPrOrRrMpollrNrrmin)r3rr|eventsrIs rrXzTornadoEventLoop.PollProxy.poll$s+++"'!(D IIKE__))!,F"' ?? $ 6 6 8HJ"&!S'E/DIIK*GHIG__))'2F"'MrN)rrrrr8rVrXrrr PollProxyrKs  #  2 rr[c||jvryix|j|<}|j|j||_y)z@ Wraps original poll object in the IOLoop's poll object N)_ioloop_registryr[_impl)clsiolooprRs r_patch_poll_implz!TornadoEventLoop._patch_poll_impl>s@ S)) ) 244V$x}}V\\8< rNc|sddlm}|j}||_|j |i|_i|_d|_d|_y)NrIOLoop) tornado.iolooprdinstance_ioloopra_pending_alarms_watch_handles_max_watch_handle _exception)r3r`rds rr8zTornadoEventLoop.__init__IsH -__&F  f%!!#!"!%rcj}fd}|j|j|z|dj<S)Ncl j=jy#t$rY"wxYwr:)rhrnr)rIrXr3srwrappedz'TornadoEventLoop.alarm..wrappedVs? ((0 'D  X & (  s ' 33r)rg add_timeoutrRrh)r3secsrIr`rnrXs` ` @rrMzTornadoEventLoop.alarmTsE,, ) ##FKKMD$8'B'(V$ rct|jj| |j|=y#t$rYywxYw)NTF)rgremove_timeoutrhrnrWs rrVzTornadoEventLoop.remove_alarm`s@ ##F+ $$V,  s + 77cddlm}fd}jj|||jxj dz c_j }|j |<|S)Nrrcc0jSr:)r)rsrZrIr3s rr@z-TornadoEventLoop.watch_file..ks$>D$4$4X$>$@rr)rerdrg add_handlerREADrjri)r3rsrIrdrrXs` ` rrizTornadoEventLoop.watch_fileisV)@   Wfkk: !#''&(F# rcx|jj|d}|y|jj|y)NFT)rirmrgremove_handler)r3rXrss rr_z"TornadoEventLoop.remove_watch_filers7  $ $VT 2 : LL ' ' +rc|xjdz c_|j}|j|j}|||<|S)Nr)_max_idle_handler]rg)r3rIrXrRs rrzTornadoEventLoop.enter_idlezsA "((((6# rc`|j|j}|j|d}|duSr:)r]rgrm)r3rXrRrKs rrz"TornadoEventLoop.remove_enter_idles0((6 \\&$ '~rc2tfd}|S)Nc |i|S#t$rjjYyt$r+}|_jjYd}~yd}~wwxYwr[)rrgr Exceptionrk)rkwexcfuncr3s rrGz-TornadoEventLoop.handle_exit..wrappersd $T(R(( $ !!# $"% !!## $s #A#A#!AA#r)r3rrGs`` rrzTornadoEventLoop.handle_exits t   rc||jj|jr|jdc}|_|yr:)rgr|rk)r3rs rrwzTornadoEventLoop.runs5  ??#'??D CI rr:)rrrrrr]rzobjectr[ classmethodrar8rMrVrir_rrrrwrrrrIrI sf)*%F%N== &  rrI)FileDescriptorceZdZdZdZdZy)TwistedInputDescriptorcL||_||_tj||yr:)_filenorKrr8)r3reactorrsrKs rr8zTwistedInputDescriptor.__init__s  g.rc|jSr:)rr?s rfilenozTwistedInputDescriptor.filenos ||rc"|jSr:)rKr?s rdoReadzTwistedInputDescriptor.doReadswwyrN)rrrr8rrrrrrrs/ rrcZeZdZdZdZddZdZdZdZdZ d Z d Z d Z d Z d ZddZy)TwistedEventLoopz& Event loop based on Twisted_ gp?Nc|ddl}|jj}||_g|_i|_d|_d|_i|_d|_||_ |jy)a- :param reactor: reactor to use :type reactor: :class:`twisted.internet.reactor`. :param: manage_reactor: `True` if you want this event loop to run and stop the reactor. :type manage_reactor: boolean .. WARNING:: Twisted's reactor doesn't like to be stopped and run again. If you need to stop and run your :class:`MainLoop`, consider setting ``manage_reactor=False`` and take care of running/stopping the reactor at the beginning/ending of your program yourself. You can also forego using :class:`MainLoop`'s run() entirely, and instead call start() and stop() before and after starting the reactor. .. _Twisted: http://twistedmatrix.com/trac/ NrF) twisted.internet.reactorinternetrrrr_twisted_idle_enabledrr manage_reactor_enable_twisted_idle)r3rrtwisteds rr8zTwistedEventLoop.__init__sf( ? +&&..G  %*"!, !!#rc\|jj||j|}|Sr)r callLaterr)r3rrIrXs rrMzTwistedEventLoop.alarms*''1A1A(1KL rcXddlm}m} |jy#|$rYy|$rYywxYw)rr)AlreadyCancelled AlreadyCalledTF)twisted.internet.errorrrcancel)r3rXrrs rrVzTwistedEventLoop.remove_alarms6 K  MMO   s)))ct|j||j|}||j|<|jj ||Sr)rrrr addReader)r3rsrIinds rrizTwistedEventLoop.watch_filesK%T\\2   X &( #" s# rc||jvr6|jj|j||j|=yyr)rr removeReaderrWs rr_z"TwistedEventLoop.remove_watch_filesC T&& & LL % %d&7&7&? @!!&)rcv|xjdz c_||j|j<|jSr6rrs rrzTwistedEventLoop.enter_idle rrc|jry|jj|j|j |j dd|_y)aU Twisted's reactors don't have an idle or enter-idle callback so the best we can do for now is to set a timer event in a very short time to approximate an enter-idle callback. .. WARNING:: This will perform worse than the other event loops until we can find a fix or workaround NF) enable_idleT)rrr_idle_emulation_delayr_twisted_idle_callbackr?s rrz%TwistedEventLoop._enable_twisted_idlesL  % %  t99   T88e  L N%)"rc^|jjD] }| d|_yr[)rrrrs rrz'TwistedEventLoop._twisted_idle_callback%s-,,335 H J %*"rc> |j|=y#t$rYywxYwrrrWs rrz"TwistedEventLoop.remove_enter_idle*rrc|jsy|jj|jr|j}d|_t |yyr=)rrrwr r r@s rrwzTwistedEventLoop.run6sD ""   >>~~H!DN X  rcfd}|S)a1 Decorator that cleanly exits the :class:`TwistedEventLoop` if :class:`ExitMainLoop` is thrown inside of the wrapped function. Store the exception info if some other exception occurs, it will be reraised after the loop quits. *f* -- function to be wrapped cdd} |i|}rj|S#t$r)jrjjYEddl}t |j |j _jrjjYxYwr) rrrrrDprintrAr crashr)rrErbrDrrFr3s rrGz-TwistedEventLoop.handle_exit..wrapperMsD )$''))+K  (&&LL%%' )lclln%!-&&LL&&(s!/B/AB/r)r3rFrrGs``` rrzTwistedEventLoop.handle_exitDs  rr/)T)rrrrrr8rMrVrir_rrrrrwrrrrrrsG$$B   !* +  rrcReZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd Zy )AsyncioEventLoopa# Event loop based on the standard library ``asyncio`` module. ``asyncio`` is new in Python 3.4, but also exists as a backport on PyPI for Python 3.3. The ``trollius`` package is available for older Pythons with slightly different syntax, but also works with this loop. Fg?c ld|vr|jd|_yddl}|j|_y)Nloopr)rmrasyncioget_event_loop)r3kwargsrs rr8zAsyncioEventLoop.__init__ls- V F+DJ  //1DJrc:|jj||S)a Call callback() a given time from now. No parameters are passed to callback. Returns a handle that may be passed to remove_alarm() seconds -- time in seconds to wait before calling callback callback -- function to call from event loop )r call_laterrs rrMzAsyncioEventLoop.alarmsszz$$Wh77rc~t|ddr|jn |j}| }|j|S)r cancelledN)rTr _cancelledr)r3rXrexisteds rrVzAsyncioEventLoop.remove_alarmsCv{D1    ""   - rc>|jj|||Sr)r add_readerrrs rrizAsyncioEventLoop.watch_files b(+ rc8|jj|S)r)r remove_readerrWs rr_z"AsyncioEventLoop.remove_watch_files zz''//rcvdgfdjjjd<S)rNcfjjjd<yrrrr)rIfaux_idle_callbackmutable_handler3srrz7AsyncioEventLoop.enter_idle..faux_idle_callbacks. J $ 5 5**,>!@N1 rrr)r3rIrrs``@@rrzAsyncioEventLoop.enter_idlesA @ !JJ11  & &(:<qrc*|j|dS)rr)rVrWs rrz"AsyncioEventLoop.remove_enter_idles  ++rNc|jd}|r?|jt|tst |||j f|_yy|j|y)N exception)getr isinstancertype __traceback__r default_exception_handler)r3rcontextrs r_exception_handlerz#AsyncioEventLoop._exception_handlersSkk+&  IIKc<0"&s)S#2C2C!D1  * *7 3rc|jj|j|jj|jr|j}d|_t |yyr=)rset_exception_handlerr run_foreverr r r@s rrwzAsyncioEventLoop.runsP (()@)@A  >>~~H!DN X  r)rrrr_we_started_event_looprr8rMrVrir_rrr rrwrrrrr`sI#"2 8  0(,I4 rr)r) TrioEventLoopc:Gfddt|S)aO This function is used to test the main loop classes. >>> scr = _refl("screen") >>> scr.function("argument") screen.function('argument') >>> scr.callme(when="now") screen.callme(when='now') >>> scr.want_something_rval = 42 >>> x = scr.want_something() screen.want_something() >>> x 42 c*eZdZddZfdZfdZy)_refl..ReflectNc ||_||_yr:)_name_rval)r3rUrbs rr8z_refl..Reflect.__init__sDJDJrc pdj|Dcgc] }t|c}}|r|r|dz}|dj|jDcgc]\}}|dzt|zc}}z}t|jdz|zdzr t |j Scc}wcc}}w)Nz, =())joinrepritemsrrrr)r3arglargdarrvexits r__call__z_refl..Reflect.__call__s99t4!d1g45Dd{$))djjl$KsqQsU47]$KLLD $**S.%c) *"n$:: 5%Ls B-B2 c|jdr tt||dzr&|jdz|zt ||dzS|jdz|zS)Nr.)endswithAttributeErrorr-rrT)r3attrReflects rrVz"_refl..Reflect.__getattr__sc}}W%$&&tT'\*tzz#~d2GD$w,4OPP4::c>$./ /rr:)rrrr8rrV)rrsrrrs   0rr)r)rUrbrrs `@r_reflrs 0&0( 4=rc,ddl}|jyr)doctesttestmod)rs r_testrs OOr__main__r[)5 __future__rrrRrrr\rrD functoolsr itertoolsrweakrefrrf ImportError urwid.utilr r urwid.compatr r urwid.command_mapr r urwid.wimprr&rurwid.display_commonrr^r~rrrrrr/rrItwisted.internet.abstractrrrr version_info_async_kw_event_looprrrrrrrrs900 % 7)8": 9  ) Q:vQ:h^.^.@L'iL'^IIIXLyL^8 ^ qyqhvyvvv3$L Z GG/  l#Ns#D2DD  D DD