3

VS�_z�@sldZdZ
ddlmZ
ddlZddlmZ
Gdd�de�ZGd	d
�d
e�Z	Gdd�de�Z
d
d
�Zdd�ZdS)ai
Decorators for running functions with context/sockets.

.. versionadded:: 15.3

Like using Contexts and Sockets as context managers, but with decorator syntax.
Context and sockets are closed at the end of the function.

For example::

    from zmq.decorators import context, socket
    
    @context()
    @socket(zmq.PUSH)
    def work(ctx, push):
        ...
�context�socket�)
�wrapsN)
�
basestringc@s2eZ
dZd
Zddd�
Zdd�Zdd�Zd	d
�ZdS)�
_DecoratorzThe mini decorator factoryNcCs
|
|_dS)
N)
�_target)�self�target�r
�"/usr/lib64/python3.6/decorators.py�__init__#s
z_Decorator.__init__c
s(�j��
�
\���
��
��fd
d�}|S)a�

        The main logic of decorator

        Here is how those arguments works::

            @out_decorator(*dec_args, *dec_kwargs)
            def func(*wrap_args, **wrap_kwargs):
                ...

        And in the ``wrapper``, we simply create ``self.target`` instance via
        ``with``::
            
            target = self.get_target(*args, **kwargs)
            with target(*dec_args, **dec_kwargs) as obj:
                ...

        c
s t��
�
����fd
d��
}
|
S)Ncsl�j||
�
}|��
�
�L}�r.�|
kr.||
�<n*�rN�|
krNt
d
j�j���
�
n
||f
}�||
�
SQRXdS)Nz,{0}() got multiple values for argument '{1}')�
get_target�	TypeError�format�__name__)�args�kwargsr	�obj)�dec_args�
dec_kwargs�func�kw_namerr
r�wrapper;s





z7_Decorator.__call__.<locals>.decorator.<locals>.wrapper)
r)rr)rrrr)
rr�	decorator:s
z&_Decorator.__call__.<locals>.decorator)
�process_decorator_args)rrrrr
)rrrrr�__call__&sz_Decorator.__call__c

Os|jS)
z_Return the target function
        
        Allows modifying args/kwargs to be passed.
        )
r)rrrr
r
rr
Qsz_Decorator.get_targetc
OsXd
}t|j
d�
t�r |jd�
}n.t|
�
dkrNt|
dt�rN|
d}|
dd
�}
||
|fS)z�Process args passed to the decorator.
        
        args not consumed by the decorator will be passed to the target factory
        (Context/Socket constructor).
        N�name�
r)�
isinstance�getr�pop�len)rrrrr
r
rrXs



z!_Decorator.process_decorator_args)
N)r�
__module__�__qualname__�__doc__rrr
rr
r
r
rr s


+rcs eZ
dZd
Z�f
dd�Z�ZS)�_ContextDecoratorzDecorator subclass for Contextsc

stt
|�jtj�

dS)
N)�superr%r�zmq�Context)
r)
�	__class__r
rrks
z_ContextDecorator.__init__)rr"r#r$r�
__classcell__r
r
)
r)rr%is

r%cs0eZ
dZd
Z�f
dd�Zdd�Zdd�Z�ZS)�_SocketDecoratorzNDecorator subclass for sockets
    
    Gets the context from other args.
    c
s0tt
|�j|
|�
\}}
}|jd
d�|_||
|fS)z$Also grab context_name out of kwargs�context_namer
)r&r+rr r,)rrrr)
r)r
rrus

z'_SocketDecorator.process_decorator_argsc
Os|j|
|�
}|j
S)
z$Get context, based on call-time args)�_get_contextr)rrrr
r
r
rr
{s
z_SocketDecorator.get_targetc
OsL|j|kr$||j}t
|tj�r$|Sx|
D]}t
|tj�r*|Sq*Wtjj�S)
a�

        Find the ``zmq.Context`` from ``args`` and ``kwargs`` at call time.

        First, if there is an keyword argument named ``context`` and it is a
        ``zmq.Context`` instance , we will take it.

        Second, we check all the ``args``, take the first ``zmq.Context``
        instance.

        Finally, we will provide default Context -- ``zmq.Context.instance``

        :return: a ``zmq.Context`` instance
        )r,rr'r(�instance)rrrZctx�argr
r
rr-�s






z_SocketDecorator._get_context)rr"r#r$rr
r-r*r
r
)
r)rr+osr+cOst�||
�
S)
z�Decorator for adding a Context to a function.
    
    Usage::
    
        @context()
        def foo(ctx):
            ...

    .. versionadded:: 15.3

    :param str name: the keyword argument passed to decorated function
    )
r%)rrr
r
rr
�s
cOst�||
�
S)
a_
Decorator for adding a socket to a function.
    
    Usage::
    
        @socket(zmq.PUSH)
        def foo(push):
            ...
    
    .. versionadded:: 15.3

    :param str name: the keyword argument passed to decorated function
    :param str context_name: the keyword only argument to identify context
                             object
    )
r+)rrr
r
rr�s)r
r)
r$�__all__�	functoolsrr'Zzmq.utils.strtypesr�objectrr%r+r
rr
r
r
r�<module>s

I,