Current Dir: /snap/core22/2437/usr/lib/python3/dist-packages/urwid/__pycache__/

[FILE] canvas.cpython-310.pyc [ edit | delete | rename ]
[FILE] command_map.cpython-310.pyc [ edit | delete | rename ]
[FILE] compat.cpython-310.pyc [ edit | delete | rename ]
[FILE] container.cpython-310.pyc [ edit | delete | rename ]
[FILE] curses_display.cpython-310.pyc [ edit | delete | rename ]
[FILE] decoration.cpython-310.pyc [ edit | delete | rename ]
[FILE] display_common.cpython-310.pyc [ edit | delete | rename ]
[FILE] escape.cpython-310.pyc [ edit | delete | rename ]
[FILE] font.cpython-310.pyc [ edit | delete | rename ]
[FILE] graphics.cpython-310.pyc [ edit | delete | rename ]
[FILE] html_fragment.cpython-310.pyc [ edit | delete | rename ]
[FILE] lcd_display.cpython-310.pyc [ edit | delete | rename ]
[FILE] listbox.cpython-310.pyc [ edit | delete | rename ]
[FILE] main_loop.cpython-310.pyc [ edit | delete | rename ]
[FILE] monitored_list.cpython-310.pyc [ edit | delete | rename ]
[FILE] numedit.cpython-310.pyc [ edit | delete | rename ]
[FILE] old_str_util.cpython-310.pyc [ edit | delete | rename ]
[FILE] raw_display.cpython-310.pyc [ edit | delete | rename ]
[FILE] signals.cpython-310.pyc [ edit | delete | rename ]
[FILE] split_repr.cpython-310.pyc [ edit | delete | rename ]
[FILE] text_layout.cpython-310.pyc [ edit | delete | rename ]
[FILE] treetools.cpython-310.pyc [ edit | delete | rename ]
[FILE] util.cpython-310.pyc [ edit | delete | rename ]
[FILE] version.cpython-310.pyc [ edit | delete | rename ]
[FILE] vterm.cpython-310.pyc [ edit | delete | rename ]
[FILE] web_display.cpython-310.pyc [ edit | delete | rename ]
[FILE] widget.cpython-310.pyc [ edit | delete | rename ]
[FILE] wimp.cpython-310.pyc [ edit | delete | rename ]
[FILE] _async_kw_event_loop.cpython-310.pyc [ edit | delete | rename ]
[FILE] __init__.cpython-310.pyc [ edit | delete | rename ]

Viewing: /snap/core22/2437/usr/lib/python3/dist-packages/urwid/__pycache__/main_loop.cpython-310.pyc

o

��o_���@s�ddlmZmZddlZddlZddlZddlZddlZddlZddl	m
Z
ddlmZddl
mZzddlZWn	eyAYnwddlmZmZddlmZmZddlmZmZdd	lmZdd
lmZddlmZdZ Gd
d�de!�Z"Gdd�de!�Z#Gdd�de$�Z%Gdd�de$�Z&Gdd�de&�Z'Gdd�de&�Z(Gdd�de&�Z)zddl*m+Z+Wney�e$Z+YnwGdd�de+�Z,Gdd�de&�Z-Gd d!�d!e&�Z.ej/d"kr�d#d$l0m1Z1d+d&d'�Z2d(d)�Z3e4d*kr�e3�dSdS),�)�division�print_functionN��wraps)�count)�WeakKeyDictionary)�StoppingContext�is_mouse_event)�PYTHON3�reraise)�command_map�
REDRAW_SCREEN)�PopUpTarget)�signals)�INPUT_DESCRIPTORS_CHANGEDic@seZdZdZdS)�ExitMainLoopz_
    When this exception is raised within a main loop the main loop
    will exit cleanly.
    N)�__name__�
__module__�__qualname__�__doc__�rr�1/usr/lib/python3/dist-packages/urwid/main_loop.pyr2src@seZdZdS)�CantUseExternalLoopN)rrrrrrrr9src@seZdZdZ			d=dd�Zdd	�Zed
d�edd
�Zdd�Zedd�e�Z	d>dd�Z
d>dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;d<�ZdS)?�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
    rNTFc	
Cs�||_||_||_|sddlm}	|	��}|r|�|�||_d|_||_	||_
t|d�s8|dur8td|f��|dur?t
�}||_t|jd�rN|jj|j_i|_dS)Nr)�raw_display�hook_event_loopz=screen object passed %r does not support external event loops�signal_handler_setter)�_widget�handle_mouse�pop_ups�urwidr�Screen�register_palette�screen�screen_size�_unhandled_input�
_input_filter�hasattr�NotImplementedError�SelectEventLoop�
event_loop�set_signal_handlerr�_watch_pipes)
�self�widget�paletter#r�input_filter�unhandled_inputr*rrrrr�__init__js.

�
zMainLoop.__init__cCs&||_|jr
|j|j_dS|j|_dS�N)rr�_topmost_widget�original_widget)r-r.rrr�_set_widget�szMainLoop._set_widgetcC�|jSr3)r�r-rrr�<lambda>��zMainLoop.<lambda>zj
       Property for the topmost widget used to draw the screen.
       This must be a box widget.
       )�doccCs&||_|r
t|j�|_dS|j|_dSr3)�_pop_upsrrr4)r-rrrr�_set_pop_ups�szMainLoop._set_pop_upscCr7r3)r<r8rrrr9�r:cs���fdd�}�j�||�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
        c�����dSr3rr��callbackr-�	user_datarr�cb��z!MainLoop.set_alarm_in.<locals>.cb)r*�alarm)r-�secr@rArBrr?r�set_alarm_in�szMainLoop.set_alarm_incs&���fdd�}�j�|t��|�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
        cr>r3rrr?rrrB�rCz!MainLoop.set_alarm_at.<locals>.cb)r*rD�time)r-�tmr@rArBrr?r�set_alarm_at�szMainLoop.set_alarm_atcC�|j�|�S)zf
        Remove an alarm. Return ``True`` if *handle* was found, ``False``
        otherwise.
        )r*�remove_alarm�r-�handlerrrrK��zMainLoop.remove_alarmcsTt��\�}t��tjtj�d�����fdd�}�j��|����f�j|<|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)``.
        Ncs:t��t�}�|�}|dur�j���t���dSdS�NF)�os�read�PIPE_BUFFER_READ_SIZEr*�remove_watch_file�close)�data�rval�r@�pipe_rdr-�watch_handlerrrB�s�zMainLoop.watch_pipe.<locals>.cb)rP�pipe�fcntl�F_SETFL�
O_NONBLOCKr*�
watch_filer,)r-r@�pipe_wrrBrrWr�
watch_pipe�szMainLoop.watch_pipecCsHz
|j�|�\}}Wn
tyYdSw|j�|�sdSt�|�dS)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)r,�pop�KeyErrorr*rSrPrT)r-�write_fdrYrXrrr�remove_watch_pipe�s�
zMainLoop.remove_watch_pipecC�|j�||�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`.
        )r*r^�r-�fdr@rrrr^�zMainLoop.watch_filecCrJ)zn
        Remove a watch file. Returns ``True`` if the watch file
        exists, ``False`` otherwise.
        )r*rSrLrrrrS
rNzMainLoop.remove_watch_filecCs$z|��WdStyYdSw)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)�_runrr8rrr�runs
	�zMainLoop.runcC�dS)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(<bound method MainLoop.entering_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')
        Nrr8rrr�	_test_run#�zMainLoop._test_runcCsx|j��|jr
|j��t|jd�std��zt�|jt|j	�Wn	t
y+Ynw|�	�|j�|j
�|_t|�S)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.
        rz1Screen {0!r} doesn't support external event loops)r#�startr�set_mouse_trackingr'rr�connect_signalr�_reset_input_descriptors�	NameErrorr*�
enter_idle�
entering_idle�idle_handlerr8rrrrn@s"

�
��zMainLoop.startcCs@|j�|j�|`t�|jt|j�|j�|j�|j�	�dS)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)
r*�remove_enter_idlerur�disconnect_signalr#rrq�unhook_event_loop�stopr8rrrryfs
�z
MainLoop.stopcCs$|j�|j�|j�|j|j�dSr3)r#rxr*r�_updater8rrrrqssz!MainLoop._reset_input_descriptorscCspz|��Wnty z|��W|j��YS|j��wwz|j��Wn	|j���|��dSr3)rnr�_run_screen_event_loopr#ryr*rjr8rrrriws�
z
MainLoop._runcCs4|�||�}|r|�|�d|vrd|_dSdSdS)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)r0�
process_inputr$�r-�keys�rawrrrrz�s

�zMainLoop._updatecCsd}	|��|s|jjrt�|jj�}d}|sM|r,td|dt���}|j�|�n|j�d�|j�	d�\}}|sK|rK|dt��}|dkrKn|r|�
||�}|rZ|�|�|r�|dt��}|dkrin|\}}}|�|jjr}t�|jj�}nd}|s\d|vr�d|_q)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_screenr*�_alarms�heapq�heappop�maxrGr#�set_input_timeouts�	get_inputr0r}r$)r-�
next_alarmrrEr�rH�	tie_breakr@rrrr{�sB�

��zMainLoop._run_screen_event_loopcCrk)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)
        Nrr8rrr�_test_run_screen_event_loop�rmz$MainLoop._test_run_screen_event_loopc	Cs�|js	|j��|_d}|D]P}|dkrq
t|�r4|\}}}}t|jd�r3|jj|j||||dd�r3d}n
|j��rA|j�|j|�}|r[t	|t
krQ|j��d}q
|t|�
|��O}q
d}q
|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_eventT��focusN)r$r#�
get_cols_rowsr	r'r4r��
selectable�keypressrr
�clear�boolr1)r-r�something_handled�k�event�button�col�rowrrrr}�s.

��

zMainLoop.process_inputcCrk)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
        Nrr8rrr�_test_process_input
rmzMainLoop._test_process_inputcCs|jr	|�||�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&r~rrrr0szMainLoop.input_filtercCs|jr|�|�SdS)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%)r-�inputrrrr1(s
�zMainLoop.unhandled_inputcCs|jjr
|��dSdS)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#�startedr�r8rrrrt7s�zMainLoop.entering_idlecCs8|js	|j��|_|jj|jdd�}|j�|j|�dS)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.
        Tr�N)r$r#r�r4�renderr�)r-�canvasrrrr�@s	zMainLoop.draw_screen)rNTNNNFr3) rrrrr2r6�propertyr.r=rrFrIrKr`rdr^rSrjrlrnryrqrirzr{r�r}r�r0r1rtr�rrrrr<sD-
�#
�

+	&
1'	rc@sPeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�	EventLoopzT
    Abstract class representing an event loop to be used by :class:`MainLoop`.
    cC�t��)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(�r-�secondsr@rrrrDU�zEventLoop.alarmcCr�)z�
        Add a callback for entering idle.

        This method has no default implementation.

        Returns a handle that may be passed to remove_idle()
        r��r-r@rrrrsc�zEventLoop.enter_idlecCr�)z�
        Remove an alarm.

        This method has no default implementation.

        Returns True if the alarm exists, False otherwise
        r�rLrrrrKmr�zEventLoop.remove_alarmcCr�)z�
        Remove an idle callback.

        This method has no default implementation.

        Returns True if the handle was removed.
        r�rLrrrrvwr�zEventLoop.remove_enter_idlecCr�)z�
        Remove an input file.

        This method has no default implementation.

        Returns True if the input file exists, False otherwise
        r�rLrrrrS�r�zEventLoop.remove_watch_filecCr�)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.
        r�r8rrrrj�sz
EventLoop.runcCr�)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
        r�rfrrrr^�r�zEventLoop.watch_filecCst�||�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)r-�signum�handlerrrrr+�szEventLoop.set_signal_handlerN)rrrrrDrsrKrvrSrjr^r+rrrrr�Ps



	r�c@s`eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dS)r)z3
    Event loop based on :func:`select.select`
    cCs$g|_i|_d|_i|_t�|_dS�Nr)r��_watch_files�_idle_handle�_idle_callbacksr�
_tie_breakr8rrrr2�s
zSelectEventLoop.__init__cCs.t��|}|t|j�|f}t�|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
        )rG�nextr�r��heappushr�)r-r�r@rHrMrrrrD�s
zSelectEventLoop.alarmcCs4z|j�|�t�|j�WdStyYdSw)�]
        Remove an alarm.

        Returns True if the alarm exists, False otherwise
        TF)r��remover��heapify�
ValueErrorrLrrrrK�s�zSelectEventLoop.remove_alarmcCs||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
        �r�rfrrrr^�s

zSelectEventLoop.watch_filecCs||jvr|j|=dSdS��g
        Remove an input file.

        Returns True if the input file exists, False otherwise
        TFr�rLrrrrS�s
z!SelectEventLoop.remove_watch_filecC� |jd7_||j|j<|jS)�q
        Add a callback for entering idle.

        Returns a handle that may be passed to remove_idle()
        ��r�r�r�rrrrs��zSelectEventLoop.enter_idlecC�$z|j|=WdStyYdSw��[
        Remove an idle callback.

        Returns True if the handle was removed.
        FT�r�rbrLrrrrv��
��z!SelectEventLoop.remove_enter_idlecCs|j��D]}|�qdS)z9
        Call all the registered idle callbacks.
        N)r��valuesr�rrr�_entering_idles�zSelectEventLoop._entering_idlec
Csdz'd|_	z|��Wntjy&}z|jddkr�WYd}~nd}~wwqty1YdSw)��
        Start the event loop.  Exit the loop when any callback raises
        an exception.  If ExitMainLoop is raised, exit cleanly.
        Tr�N)�_did_something�_loop�select�error�argsr)r-�errrrj
s�����zSelectEventLoop.runc
Cs�t|j���}|js
|jr=|jr |jdd}td|t���}|jr1|jr-|jr1|dkr1d}d}t�|g||�\}}}nd}t�|g|�\}}}|sj|dkrW|��d|_n|durjt	�
|j�\}}}|�d|_|D]}	|j|	�d|_qldS)z6
        A single iteration of the event loop
        r�idleNFT)�listr�rr�r�r�rGr�r�r�r�)
r-�fdsrH�timeout�ready�w�errr��alarm_callbackrgrrrr�s4��zSelectEventLoop._loopN)rrrrr2rDrKr^rSrsrvr�rjr�rrrrr)�s


r)c@speZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�ZdS)�
GLibEventLoopz+
    Event loop based on GLib.MainLoop
    cCsRddlm}||_g|_i|_d|_d|_i|_|��|_d|_	|�
�i|_dS)Nr)�GLibF)�
gi.repositoryr�r�r�r��_glib_idle_enabledr�rr��	_exc_info�_enable_glib_idle�_signal_handlers)r-r�rrrr2Ds

zGLibEventLoop.__init__cs>�j��fdd��}�j�t|d�|�}�j�|�|�fS)r�c������dSrO�r�r�r@r-rr�	ret_false[�z&GLibEventLoop.alarm.<locals>.ret_falsei�)�handle_exitr��timeout_add�intr��append)r-r�r@r�rgrr�rrDQs

zGLibEventLoop.alarmcs�tjtjtjtjtjg}�j�ddd�s|�tj	�||vr dS|�j
vr/�j��j
�|���tj
kr9dd��n�tjkr@dS��fdd�}�j��jj|||�}|�j
|<dS)	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`
        ��6rNcSsdSr3r)�xrrrr9�rmz2GLibEventLoop.set_signal_handler.<locals>.<lambda>cs�|��jjSr3)r��SOURCE_CONTINUE)�
signal_number�r�r-rr�
final_handler�sz7GLibEventLoop.set_signal_handler.<locals>.final_handler)r��SIGHUP�SIGINT�SIGTERM�SIGUSR1�SIGUSR2r��
check_versionr��SIGWINCHr��
source_removera�SIG_IGN�SIG_DFL�unix_signal_add�PRIORITY_DEFAULT)r-r�r��glib_signalsr��sourcerr�rr+ds&�	



z GLibEventLoop.set_signal_handlercCs<z|j�|d�|j�|d�WdStyYdSw)r�rTF)r�r�r�r�r�rLrrrrK�s�zGLibEventLoop.remove_alarmcs2�j��fdd��}�j�|�jj|��j|<|S)r�cr��NTr�)r��cb_conditionr�rr�io_callback�r�z-GLibEventLoop.watch_file.<locals>.io_callback)r�r��io_add_watch�IO_INr�)r-rgr@r�rr�rr^�s

�zGLibEventLoop.watch_filecC�,||jvr|j�|j|�|j|=dSdSr�)r�r�r�rLrrrrS��

zGLibEventLoop.remove_watch_filecCr��zw
        Add a callback for entering idle.

        Returns a handle that may be passed to remove_enter_idle()
        r�r�r�rrrrs�r�zGLibEventLoop.enter_idlecCs"|jrdS|j�|j�d|_dSr�)r�r��idle_add�_glib_idle_callbackr8rrrr��s
zGLibEventLoop._enable_glib_idlecCs |j��D]}|�qd|_dSrO)r�r�r�r�rrrr�sz!GLibEventLoop._glib_idle_callbackcCr�r�r�rLrrrrv�r�zGLibEventLoop.remove_enter_idlecCs^z|j��W|j��r|j��n|j��r|j��ww|jr-|j}d|_t|�dSdS�r�N)r�rj�
is_running�quitr�r�r-�exc_inforrrrj�s

�
���zGLibEventLoop.runcs��fdd�}|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
        csfz�|i|��WSty�j��YdSddl}|���_�j��r0�j��YdSYdS)NrF)rr�r	�sysrr�r)r��kargsr��fr-rr�wrapper�s�

�z*GLibEventLoop.handle_exit.<locals>.wrapperr)r-rrrrrr��s	zGLibEventLoop.handle_exitN)rrrrr2rDr+rKr^rSrsr�rrvrjr�rrrrr�?s
2

r�c@s�eZdZdZe�ZdZGdd�de�Ze	dd��Z
ddd	�Zd
d�Zdd
�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd�ZdS)�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@s(eZdZdZdd�Zdd�Zdd�ZdS)	zTornadoEventLoop.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
        cCs||_||_d|_d|_dS)NFr)�_PollProxy__poll_obj�_PollProxy__idle_map�
_idle_done�
_prev_timeout)r-�poll_obj�idle_maprrrr2s
z#TornadoEventLoop.PollProxy.__init__cCst|j|�Sr3)�getattrr)r-�namerrr�__getattr__!sz&TornadoEventLoop.PollProxy.__getattr__cCs�||jkrd|_||_t��}|j�d�}|rd|_|S|js-|j��D]}|�q$d|_tdt|||t����}|j�|�}|rFd|_|S)NFrT)	rrrGr�pollrr�r��min)r-r�rn�eventsr@rrrr$s"
zTornadoEventLoop.PollProxy.pollN)rrrrr2rrrrrr�	PollProxys
rcCs0||jvrdSi|j|<}|�|j|�|_dS)z@ Wraps original poll object in the IOLoop's poll object
        N)�_ioloop_registryr�_impl)�cls�iolooprrrr�_patch_poll_impl>s
z!TornadoEventLoop._patch_poll_implNcCsD|sddlm}|��}||_|�|�i|_i|_d|_d|_dS)Nr��IOLoop)	�tornado.ioloopr%�instance�_ioloopr#�_pending_alarms�_watch_handles�_max_watch_handle�
_exception)r-r"r%rrrr2Is

zTornadoEventLoop.__init__cs8�j}���fdd�}|�|��||��d�j�<�S)Ncs0z�j�=Wn	tyYnw�����dSr3)r)rbr�r�r@rMr-rr�wrappedVs�z'TornadoEventLoop.alarm.<locals>.wrappedr�)r(�add_timeoutrGr))r-�secsr@r"r.rr-rrDTs

zTornadoEventLoop.alarmcCs0|j�|�z|j|=WdStyYdSw�NFT)r(�remove_timeoutr)rbrLrrrrK`s
��zTornadoEventLoop.remove_alarmcsNddlm}��fdd�}�j�|||j��jd7_�j}|�j|<|S)Nrr$cs�����Sr3)r�)rgrr�rrr9ksz-TornadoEventLoop.watch_file.<locals>.<lambda>r�)r&r%r(�add_handler�READr+r*)r-rgr@r%r�rMrr�rr^is
zTornadoEventLoop.watch_filecCs*|j�|d�}|dur
dS|j�|�dSr1)r*rar(�remove_handler)r-rMrgrrrrSrs
z"TornadoEventLoop.remove_watch_filecCs,|jd7_|j}|j|j}|||<|S)Nr�)�_max_idle_handlerr()r-r@rMrrrrrszs
zTornadoEventLoop.enter_idlecCs |j|j}|�|d�}|duSr3)rr(ra)r-rMrrBrrrrv�sz"TornadoEventLoop.remove_enter_idlecst����fdd��}|S)Nc
sdz�|i|��WSty�j��YdSty1}z|�_�j��WYd}~dSd}~wwrO)rr(ry�	Exceptionr,)r��kw�exc��funcr-rrr�s���z-TornadoEventLoop.handle_exit.<locals>.wrapperr)r-r;rrr:rr��s	zTornadoEventLoop.handle_exitcCs&|j��|jr|jd}|_|�dSr3)r(rnr,)r-r9rrrrj�s

�zTornadoEventLoop.runr3)rrrrrrr6�objectr�classmethodr#r2rDrKr^rSrsrvr�rjrrrrrs '


		
r)�FileDescriptorc@s$eZdZdd�Zdd�Zdd�ZdS)�TwistedInputDescriptorcCs||_||_t�||�dSr3)�_filenorBr>r2)r-�reactorrgrBrrrr2�szTwistedInputDescriptor.__init__cCr7r3)r@r8rrr�fileno�szTwistedInputDescriptor.filenocCs|��Sr3)rBr8rrr�doRead�szTwistedInputDescriptor.doReadN)rrrr2rBrCrrrrr?�sr?c@speZdZdZdZddd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zddd�ZdS)�TwistedEventLoopz&
    Event loop based on Twisted_
    gp?NTcCsT|durddl}|jj}||_g|_i|_d|_d|_i|_d|_||_	|�
�dS)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.reactor�internetrAr�r�r��_twisted_idle_enabledr�r��manage_reactor�_enable_twisted_idle)r-rArH�twistedrrrr2�szTwistedEventLoop.__init__cCs|j�||�|��}|Sr�)rA�	callLaterr�)r-r�r@rMrrrrD�s
zTwistedEventLoop.alarmcCsFddlm}m}z|��WdS|yYdS|y"YdSw)r�r)�AlreadyCancelled�
AlreadyCalledTF)�twisted.internet.errorrLrM�cancel)r-rMrLrMrrrrK�s�zTwistedEventLoop.remove_alarmcCs.t|j||�|��}||j|<|j�|�|Sr�)r?rAr�r��	addReader)r-rgr@�indrrrr^�s
�
zTwistedEventLoop.watch_filecCrr�)r�rA�removeReaderrLrrrrS�rz"TwistedEventLoop.remove_watch_filecCr�rr�r�rrrrsr�zTwistedEventLoop.enter_idlecCs0|jrdS|j�|j|j|jdd��d|_dS)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)rGrArK�_idle_emulation_delayr��_twisted_idle_callbackr8rrrrIs

�
z%TwistedEventLoop._enable_twisted_idlecCs |j��D]}|�qd|_dSrO)r�r�rGr�rrrrU%s
z'TwistedEventLoop._twisted_idle_callbackcCr�r�r�rLrrrrv*r�z"TwistedEventLoop.remove_enter_idlecCs6|jsdS|j��|jr|j}d|_t|�dSdSr)rHrArjr�rr
rrrrj6s
�zTwistedEventLoop.runcs���fdd�}|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
        cs~d}z	�|i|��}Wn+ty�jr�j��Ynddl}t|���|���_�jr6�j��Y�r=��	�|Sr�)
rrHrAryr�printrr��crashrI)r�r
rVr�rSrr-rrrMs"
�

�z-TwistedEventLoop.handle_exit.<locals>.wrapperr)r-rrSrrrXrr�Ds	zTwistedEventLoop.handle_exitr�)T)rrrrrTr2rDrKr^rSrsrIrUrvrjr�rrrrrD�s
!

rDc@sdeZdZdZdZdZdd�Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�ZdZ
dd�Zdd�ZdS)�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�?cKs.d|vr|�d�|_dSddl}|��|_dS)N�loopr)rar��asyncio�get_event_loop)r-�kwargsr[rrrr2lszAsyncioEventLoop.__init__cCre)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_laterr�rrrrDss
zAsyncioEventLoop.alarmcCs,t|dd�r
|��n|j}|}|��|S)r��	cancelledN)rr_�
_cancelledrO)r-rMr_�existedrrrrKs

��zAsyncioEventLoop.remove_alarmcCs|j�||�|Sr�)r��
add_readerrfrrrr^�s
zAsyncioEventLoop.watch_filecCrJ)r�)r��
remove_readerrLrrrrS�sz"AsyncioEventLoop.remove_watch_filecs0dg�����fdd���j��j���d<�S)r�Ncs���j��j���d<dSr��r�r^rTr�r@�faux_idle_callback�mutable_handler-rrrf�s�z7AsyncioEventLoop.enter_idle.<locals>.faux_idle_callbackrrdr�rrerrs�s	�zAsyncioEventLoop.enter_idlecCs|�|d�S)r�r)rKrLrrrrv�rhz"AsyncioEventLoop.remove_enter_idleNcCsH|�d�}|r|��t|t�st|�||jf|_dSdS|�|�dS)N�	exception)�getry�
isinstancer�type�
__traceback__r��default_exception_handler)r-rZ�contextr9rrr�_exception_handler�s

�z#AsyncioEventLoop._exception_handlercCs:|j�|j�|j��|jr|j}d|_t|�dSdSr)r��set_exception_handlerro�run_foreverr�rr
rrrrj�s
�zAsyncioEventLoop.run)rrrr�_we_started_event_looprTr2rDrKr^rSrsrvr�rorjrrrrrY`s
	
rY)��r�)�
TrioEventLoopFcsG��fdd�dt���|�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

    cs.eZdZddd�Z�fdd�Z�fdd�ZdS)	z_refl.<locals>.ReflectNcSs||_||_dSr3)�_name�_rval)r-rrVrrrr2�s
z_refl.<locals>.Reflect.__init__csfd�dd�|D��}|r|r|d}|d�dd�|��D��}t|jd|d��r0t��|jS)Nz, cSsg|]}t|��qSr��repr)�.0�arrr�
<listcomp>�sz3_refl.<locals>.Reflect.__call__.<locals>.<listcomp>cSs g|]\}}|dt|��qS)�=rx)rzr��vrrrr|�s �(�))�join�itemsrVrvrrw)r-�argl�argdr�)�exitrr�__call__�sz_refl.<locals>.Reflect.__call__csN|�d�rt��t||d�r�|jd|t||d��S�|jd|�S)Nrw�.)�endswith�AttributeErrorr'rvr)r-�attr)�Reflectrrr�s

z"_refl.<locals>.Reflect.__getattr__r3)rrrr2r�rr�r�r�rrr��s
	r�)r<)rrVr�rr�r�_refl�sr�cCsddl}|��dSr�)�doctest�testmod)r�rrr�_testsr��__main__rO)5�
__future__rrrGr�r�rPr�r�	functoolsr�	itertoolsr�weakrefrr[�ImportError�
urwid.utilrr	�urwid.compatr
r�urwid.command_maprr
�
urwid.wimprr r�urwid.display_commonrrRr7rrr<rr�r)r�r�twisted.internet.abstractr>r?rDrY�version_info�_async_kw_event_looprur�r�rrrrr�<module>sh�`M�
5
{
&
�

Upload File: