jj~eddlmZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z m Z ddlmZmZddlmZddlmZmZddlmZd d lmZd d lmZej8r2dd lmZmZdd l m!Z!ddl"m#Z#ddlm$Z$d dlm%Z%ejLdZ'ejPdk(Z)dZ*dZ+Gdde,Z-GddZ.dddZ/dZ0e1dk(re0yy)) annotationsN)suppress)displaysignals)Command command_map)INPUT_DESCRIPTORS_CHANGED)StoppingContextis_mouse_event) PopUpTarget) ExitMainLoop)SelectEventLoop)CallableIterable)Self) BaseScreen)Widget) EventLoop_Twin32i)CantUseExternalLoopMainLoopc eZdZy)rN)__name__ __module__ __qualname__c/home/ubuntu/.cache/pipx/cdb5059130eadca/lib/python3.12/site-packages/urwid/event_loop/main_loop.pyrr>srrcveZdZdZ d d!dZed"dZejd#dZd#dZed$dZ e jd%dZ d%d Z d&d'd Z d&d(d Z d$d Z esd)d Zd*dZd+dZdZd,dZdZd-dZd,dZd,dZd,dZd.dZd,dZdZd/dZdZd0dZd1dZd,dZ d,dZ!y)2ra 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 @tjtj|jj|_||_||_d|_||_ |stjj}|r|j|||_d|_||_||_t%|ds|t'd|d| t)}||_t%|jdr%|j*j,|j_i|_y)NFhook_event_loopzscreen object passed z& does not support external event loopssignal_handler_setter)logging getLoggerrgetChild __class__logger_widget handle_mouse_pop_upspop_upsrrawScreenregister_palettescreen screen_size_unhandled_input _input_filterhasattrNotImplementedErrorr event_loopset_signal_handlerr$ _watch_pipes) selfwidgetpaletter1r+ input_filterunhandled_inputr7r-s r __init__zMainLoop.__init__ps''1::4>>;R;RS  (  [['')F   # #G ,"( 37 /)v01j6L%(=fZGm&no o  (*J%/ 4;; 7 8150R0RDKK -MOrc|jS)zm Property for the topmost widget used to draw the screen. This must be a box widget. )r*r:s r r;zMainLoop.widgets ||rc||_|jr|j|j_y|j|_yN)r*r-_topmost_widgetoriginal_widgetr:r;s r r;zMainLoop.widgets. <<37<>22342 2    rc|jSrC)r,rAs r r-zMainLoop.pop_upss }}rcn||_|rt|j|_y|j|_yrC)r,r r*rDr:r-s r r-zMainLoop.pop_upss) #.t||#>22342 2    rcjjd|ddfd }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 :param user_data: optional user data to pass to the callback :type user_data: object Setting alarm in  seconds with callback cyrCrcallbackr: user_datasr cbz!MainLoop.set_alarm_in..cb T9 %rreturnNone)r)debugr7alarm)r:secrZr[r\s` `` r set_alarm_inzMainLoop.set_alarm_insD -cW4KH<XY &$$S"--rc|tjz }jjd|ddfd }jj ||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 :param user_data: optional user data to pass to the callback :type user_data: object rVrWcyrCrrYsr r\z!MainLoop.set_alarm_at..cbr]rr^)timer)rar7rb)r:tmrZr[rcr\s` `` r set_alarm_atzMainLoop.set_alarm_atsT499; -cW4KH<XY &$$S"--rc8|jj|S)zf Remove an alarm. Return ``True`` if *handle* was found, ``False`` otherwise. )r7 remove_alarmr:handles r rkzMainLoop.remove_alarms ++F33rc ddl}tj\}|j|jtjddfd }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)``. rNctjt}|dur1jj tj yyNF)osreadPIPE_BUFFER_READ_SIZEr7remove_watch_fileclose)datarZpipe_rdr: watch_handles r r\zMainLoop.watch_pipe..cbsCwww(=>D>U*OO55lCHHW%+rr^)fcntlrqpipeF_SETFL O_NONBLOCKr7 watch_filer9)r:rZrypipe_wrr\rwrxs`` @@r watch_pipezMainLoop.watch_pipesq. !wwy GW KK >L & &  ??55grBL*6)@D  g &Nrc |jj|\}}|jj |syt j |y#t$rYywxYw)a  Close the read end of the pipe and remove the watch created by :meth:`watch_pipe`. ..note:: You are responsible for closing the write end of the pipe. Returns ``True`` if the watch pipe exists, ``False`` otherwise FT)r9popKeyErrorr7rtrqru)r:write_fdrxrws r remove_watch_pipezMainLoop.remove_watch_pipe&s\ (,(9(9(=(=h(G% g??44\B HHW    sA AAc||jjd|d||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`. zSetting watch file descriptor z with )r)rar7r})r:fdrZs r r}zMainLoop.watch_file8s; :2&xlST))"h77rc8|jj|S)zn Remove a watch file. Returns ``True`` if the watch file exists, ``False`` otherwise. )r7rtrls r rtzMainLoop.remove_watch_fileBs 0088rcltt5|jdddy#1swYyxYw)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)rr_runrAs r runz MainLoop.runIs*l #  IIK   s*3cy)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') NrrAs r _test_runzMainLoop._test_runUrc|jjd|jjjd|j j |jr|j jt|j dstd|j dtt5tj|j t|j ddd|j!|jj#|j$|_|jj)d|j$t+|S#1swYtxYw)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. zStarting event loop z to manage display.r#zScreen z% doesn't support external event loopsNr)r)rar7r(rr1startr+set_mouse_trackingr5rr NameErrorrconnect_signalr _reset_input_descriptors enter_idle entering_idle idle_handlerbr rAs r rzMainLoop.startrs& 01J1J1S1S0VVijk     KK * * ,t{{$56% >c&de e i  j  " "4;;0I4KhKh i j %%'??55d6H6HI a!3!34t$$ j js <0EE(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) r7remove_enter_idlerrdisconnect_signalr1r runhook_event_loopstoprAs r rz MainLoop.stopse ))$*:*:;  !!$++/H$JgJgh %%doo6 rc|jj|j|jj|j|jyrC)r1rr7r#_updaterAs r rz!MainLoop._reset_input_descriptorss4 %%doo6 ##DOOT\\Brcp |j |j j |j y#t$rN |j |jj Yy#|jj wxYwwxYw#|jj xYwrC)rr_run_screen_event_loopr1rr7rrAs r rz MainLoop._runs # JJL  OO   ! # # #++-   "   "  #  KK    s,>B BA5B5BBB5ch|j||x}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)r= process_inputr2r:keysr.s r rzMainLoop._updatesD$$$T3/ /4 /   t $$&#' ' 0rc|jjd|jdd} |j|s?|jj r)t j|jj }g}g}|s|r@td|dtjz }|jj|n|jjd|jjd\}}|s |r|dtjz dkrn|s|j||x}r|j||rp|dtjz dkDrnR|\}}}||jj r*t j|jj }nd}|rpd|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. zStarting screen z event loopNTgrr)r)rar1 draw_screenr7_alarmsheapqheappopmaxrgset_input_timeouts get_inputr=rr2)r: next_alarmrr.rc_tm _tie_breakrZs r rzMainLoop._run_screen_event_loops ,T[[O;GH     $//"9"9"]]4??+B+BC  DCc:a=499;#>?CKK2237KK2248 KK11$7 c z!}tyy{/Ja/O((s33t3""4(qMDIIK/14,6)Z ??**!&t/F/F!GJ!%J$&#' Crcy)as >>> 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.0) screen.get_input(True) NrrAs r _test_run_screen_event_loopz$MainLoop._test_run_screen_event_looprrc |jjd||js|jj |_d}|D]}|dk(r t |t rH|jjr|jj|j|x}r|}ngd}bt|rK|\}}}}t|jdr<|jj|j||||drd}t|d|rVt|tj k(r|jj#d}|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. zProcessing input: keys=FrT mouse_eventfocusz' is not str | tuple[str, int, int, int])r)rar2r1 get_cols_rows isinstancestrrD selectablekeypressr r5r TypeErrorrr REDRAW_SCREENclearboolr>) r:rsomething_handledkey handled_keyeventbuttoncolrows r rzMainLoop.process_inputs} 3D8<=#{{88:D !$ )Co%#s#''224&*&:&:&C&CDDTDTVY&ZZ{Z)-1) $*-'vsC4//?DDXDXDdDd$$ EeE)-% 3')P QRRs#w'<'<<KK%%'(,%%d.B.B3.G)HH%$(!I$ )L! 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 NrrAs r _test_process_inputzMainLoop._test_process_inputSrrcB|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. )r4rs r r=zMainLoop.input_filterbs%   %%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. F)r3)r:rvs r r>zMainLoop.unhandled_inputns!  ((. .rc|jjr|jy|jj d|jdy)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. zNo redrawing screen: z is not started.N)r1startedrr)rarAs r rzMainLoop.entering_idle~s> ;;       KK   5dkk_DTU VrcD|jsG|jj|_|jj d|j|j j |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. zScreen size recalculated: TrN)r2r1rr)rarDrenderr)r:canvass r rzMainLoop.draw_screens~#{{88:D  KK   :4;K;K:NO P%%,,T-=-=T,J  0 0&9r)rNTNNNF)r;rr<zrIterable[tuple[str, str] | tuple[str, str, str] | tuple[str, str, str, str] | tuple[str, str, str, str, str, str]]r1zBaseScreen | Noner+rr=z2Callable[[list[str], list[int]], list[str]] | Noner>z?Callable[[str | tuple[str, int, int, int]], bool | None] | Noner7zEventLoop | Noner-r)r_r)r;rr_r`)r_r)r-rr_r`rC)rcfloatrZ Callable[[Self, _T], typing.Any]r[r)rhrrZrr[r)rZzCallable[[bytes], bool | None]r_int)rrr_r)rrrZzCallable[[], typing.Any]r^)r_r )r list[str]r. list[int]r_r`)rz)Iterable[str | tuple[str, int, int, int]]r_r)rrr.rr_r)rvzstr | tuple[str, int, int, int]r_z bool | None)"rrr__doc__r?propertyr;setterrOr-rTrdrirk IS_WINDOWSrrr}rtrrrrrrrrrrrr=r>rrrrr rrBsY+d $(!KO[_'+*P*P *P " *P*PI*PY*P%*P*PX ]]00 ^^00.(.,4 % N $89  :)%V C"(.,(\ *8!t    W:rrc0Gfdd|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,eZdZdddZfdZfdZy)_refl..ReflectNc ||_||_yrC)_name_rval)r:namervals r r?z_refl..Reflect.__init__sDJDJrc Vdj|Dcgc] }t|c}}|r|r|d}|dj|jDcgc] \}}|d|c}}z }t|jd|dr t |j Scc}wcc}}w)Nz, =())joinrepritemsprintrrr)r:arglargdaargskv loop_exits r __call__z_refl..Reflect.__call__s99t4!d1g45Dr{ DII E1!AaU|EF FD TZZL$q) *"n$:: 5Fs B B% c|jdr tt||dr%|jd|t ||dS|jd|S)Nr.)endswithAttributeErrorr5rgetattr)r:attrReflects r __getattr__z"_refl..Reflect.__getattr__sk}}W%$&&tvU^,$**Qtf5wtvU^7TUUdjj\4&12 2rrCrr)rrrr?rr)rrsr rrs   3rrr)rrrrs `@r _reflrs"33. 4=rc,ddl}|jy)Nr)doctesttestmod)rs r _testrs OOr__main__rpr)2 __future__rrr%rqsysrgtypingrL contextlibrurwidrrurwid.command_maprrurwid.display.commonr urwid.utilr r urwid.widgetr abstract_loopr select_loopr TYPE_CHECKINGcollections.abcrrtyping_extensionsr urwid.displayrrrTypeVarrplatformrrs__all__ Exceptionrrrrrrrr rs.#  "2:6$'( 2&(#(  B\\W $  - ) U :U :p(V  z Gr