HEX

File: //proc/thread-self/root/lib64/python3.6/site-packages/zmq/utils/__pycache__/win32.cpython-36.pyc
3

VS�_�@s�dZddlZGdd�de�Zejdkr�ddlmZmZddlm	Z	m
Z
ejd�Zee	e
�Z
ejZe
e	fe_e	e_Gd	d
�d
e�ZnGdd
�d
e�ZdS)zWin32 compatibility utilities.�Nc@s2eZdZdZddd�Zdd�Zdd�Zd	d
�ZdS)�_allow_interruptaDUtility for fixing CTRL-C events on Windows.

    On Windows, the Python interpreter intercepts CTRL-C events in order to
    translate them into ``KeyboardInterrupt`` exceptions.  It (presumably)
    does this by setting a flag in its "console control handler" and
    checking it later at a convenient location in the interpreter.

    However, when the Python interpreter is blocked waiting for the ZMQ
    poll operation to complete, it must wait for ZMQ's ``select()``
    operation to complete before translating the CTRL-C event into the
    ``KeyboardInterrupt`` exception.

    The only way to fix this seems to be to add our own "console control
    handler" and perform some application-defined operation that will
    unblock the ZMQ polling operation in order to force ZMQ to pass control
    back to the Python interpreter.

    This context manager performs all that Windows-y stuff, providing you
    with a hook that is called when a CTRL-C event is intercepted.  This
    hook allows you to unblock your ZMQ poll operation immediately, which
    will then result in the expected ``KeyboardInterrupt`` exception.

    Without this context manager, your ZMQ-based application will not
    respond normally to CTRL-C events on Windows.  If a CTRL-C event occurs
    while blocked on ZMQ socket polling, the translation to a
    ``KeyboardInterrupt`` exception will be delayed until the I/O completes
    and control returns to the Python interpreter (this may never happen if
    you use an infinite timeout).

    A no-op implementation is provided on non-Win32 systems to avoid the
    application from having to conditionally use it.

    Example usage:

    .. sourcecode:: python

       def stop_my_application():
           # ...

       with allow_interrupt(stop_my_application):
           # main polling loop.

    In a typical ZMQ application, you would use the "self pipe trick" to
    send message to a ``PAIR`` socket in order to interrupt your blocking
    socket polling operation.

    In a Tornado event loop, you can use the ``IOLoop.stop`` method to
    unblock your I/O loop.
    NcCs|j|�dS)aTranslate ``action`` into a CTRL-C handler.

        ``action`` is a callable that takes no arguments and returns no
        value (returned value is ignored).  It must *NEVER* raise an
        exception.
        
        If unspecified, a no-op will be used.
        N)�_init_action)�self�action�r�/usr/lib64/python3.6/win32.py�__init__>s	z_allow_interrupt.__init__cCsdS)Nr)rrrrrrIsz_allow_interrupt._init_actioncCs|S)Nr)rrrr�	__enter__Lsz_allow_interrupt.__enter__cGsdS)Nr)r�argsrrr�__exit__Osz_allow_interrupt.__exit__)N)�__name__�
__module__�__qualname__�__doc__rrr	rrrrrrs
1
r�nt)�WINFUNCTYPE�windll)�BOOL�DWORD�kernel32c@s*eZdZejZdd�Zdd�Zdd�ZdS)�allow_interruptcs0�dkrdd���|_t�fdd��}||_dS)NcSsdS)Nrrrrr�<lambda>csz.allow_interrupt._init_action.<locals>.<lambda>cs|dkr��dS)Nrr)Zevent)rrr�handleesz,allow_interrupt._init_action.<locals>.handle)r�PHANDLER_ROUTINEr)rrrr)rrras
zallow_interrupt._init_actioncCst|jd�}|dkrt��dS)z"Install the custom CTRL-C handler.�rN)�SetConsoleCtrlHandlerr�WindowsError)r�resultrrrr	rszallow_interrupt.__enter__cGst|jd�}|dkrt��dS)z!Remove the custom CTRL-C handler.rN)rrr)rr
rrrrrzszallow_interrupt.__exit__N)rr
rrrrr	rrrrrr^src@seZdZejZdS)rN)rr
rrrrrrrr�s)r�os�objectr�nameZctypesrrZctypes.wintypesrrZLoadLibraryrrrZargtypesZrestyperrrrr�<module>sG



$