File: //lib64/python3.6/site-packages/zmq/sugar/__pycache__/socket.cpython-36.pyc
3
VS�_;l � @ s* d Z ddlZddlZddlZddlZddlmZ ddlZddlm Z
ddl m Z ddl
mZ ddlmZ dd lmZmZ dd
lmZ dd lmZmZmZ dd lmZmZm Z m Z m Z m Z m Z yddl!Z!e!Z"W n dZ!ddl"Z"Y nX y
e"j#Z#W n e$k
�r e"j%Z#Y nX G d
d� de
e�Z dgZ&dS )z 0MQ Socket pure Python methods.� N)�contextmanager)�Socket� )�Poller)� constants)�AttributeSetter)�ZMQError� ZMQBindError)�jsonapi)�bytes�unicode�
basestring)�SNDMORE�ENOTSUP�POLLIN�int64_sockopt_names�int_sockopt_names�bytes_sockopt_names�fd_sockopt_namesc s� e Zd ZdZdZdZ� fdd�Zdd� Zdd � Zd
d � Z dUd d
�Z
e
Z e dd� �Z
dV� fdd� Zedd� �Zedd� �Z� fdd�Z� fdd�Zedd� �Zd d � ZejZejZ� fd d �Z d d!� Z d"d#� Z d$d%� Z dWd'd(�Z e Z!Z"dXd)d*�Z#e# Z$Z%dYd.d/�Z&d0d1� Z'd2d3� Z(ee'e(d4�Z)dZ� fd7d8� Z*d[d9d:�Z+d\d;d<�Z,d=d>� Z-d]d?d@�Z.d^dAdB�Z/d_dCdD�Z0e0Z1d`dEdF�Z2e2Z3d5e4fdGdH�Z5dadIdJ�Z6dbdKdL�Z7dcdMdN�Z8e9Z:de;fdOdP�Z<dddQdR�Z=dSdT� Z>� Z?S )er z�The ZMQ socket object
To create a Socket, first create a Context::
ctx = zmq.Context.instance()
then call ``ctx.socket(socket_type)``::
s = ctx.socket(zmq.ROUTER)
FNc s, t t| �j||� d|kr"d| _nd| _d S )N�shadowTF)�superr �__init__�_shadow)�self�a�kw)� __class__� � /usr/lib64/python3.6/socket.pyr ; s zSocket.__init__c C s | j s| j� d S )N)r �close)r r r r �__del__B s zSocket.__del__c C s | S )zMSockets are context managers
.. versionadded:: 14.4
r )r r r r � __enter__G s zSocket.__enter__c O s | j � d S )N)r )r �args�kwargsr r r �__exit__N s zSocket.__exit__c C s | j j| j�S )z&Copying a Socket creates a shadow copy)r r Z
underlying)r �memor r r �__copy__U s zSocket.__copy__c C s ddl m} ||�}| |d�S )z�Shadow an existing libzmq socket
address is the integer address of the libzmq socket
or an FFI pointer to it.
.. versionadded:: 14.1
r )�
cast_int_addr)r )Zzmq.utils.interopr' )�clsZaddressr' r r r r [ s z
Socket.shadowc s( | j r| j j| � tt| �j|d� dS )a8
Close the socket.
If linger is specified, LINGER sockopt will be set prior to closing.
Note: closing a zmq Socket may not close the underlying sockets
if there are undelivered messages.
Only after all messages are delivered or discarded by reaching the socket's LINGER timeout
(default: forever)
will the underlying sockets be closed.
This can be called to close the socket by hand. If this is not
called, the socket will automatically be closed when it is
garbage collected.
)�lingerN)�contextZ
_rm_socketr r r )r r) )r r r r h s z Socket.closec c s z
dV W d| j |� X dS )zVContext manager to disconnect on exit
.. versionadded:: 20.0
N)Z
disconnect)r �addrr r r � _connect_cm� s
zSocket._connect_cmc c s z
dV W d| j |� X dS )zRContext manager to unbind on exit
.. versionadded:: 20.0
N)Zunbind)r r+ r r r �_bind_cm� s
zSocket._bind_cmc s t � j|� | j|�S )a� s.bind(addr)
Bind the socket to an address.
This causes the socket to listen on a network port. Sockets on the
other side of this connection will use ``Socket.connect(addr)`` to
connect to this socket.
Returns a context manager which will call unbind on exit.
.. versionadded:: 20.0
Can be used as a context manager.
Parameters
----------
addr : str
The address string. This has the form 'protocol://interface:port',
for example 'tcp://127.0.0.1:5555'. Protocols supported include
tcp, udp, pgm, epgm, inproc and ipc. If the address is unicode, it is
encoded to utf-8 first.
)r �bindr- )r r+ )r r r r. � s z Socket.bindc s t � j|� | j|�S )a$ s.connect(addr)
Connect to a remote 0MQ socket.
Returns a context manager which will call disconnect on exit.
.. versionadded:: 20.0
Can be used as a context manager.
Parameters
----------
addr : str
The address string. This has the form 'protocol://interface:port',
for example 'tcp://127.0.0.1:5555'. Protocols supported are
tcp, upd, pgm, inproc and ipc. If the address is unicode, it is
encoded to utf-8 first.
)r �connectr, )r r+ )r r r r/ � s zSocket.connectc C s t jdt� | jS )Nz1Socket.socket_type is deprecated, use Socket.type)�warnings�warn�DeprecationWarning�type)r r r r � socket_type� s zSocket.socket_typec C s. t | j�}x ttttfD ]}|j|� qW |S )N)�dirr r r r r �extend)r �keysZ
collectionr r r �__dir__� s
zSocket.__dir__c s� || j kr tj| ||� dS |j� }|dkrjt|t�r@|jd�}|dkrX| jtj |� n| jtj
|� dS t t | �j||� dS )zROverride to allow setting zmq.[UN]SUBSCRIBE even though we have a subscribe methodN� subscribe� unsubscribe�utf8)r9 r: )
�__dict__�object� __setattr__�lower�
isinstancer �encode�set�zmq� SUBSCRIBE� UNSUBSCRIBEr r )r �key�valueZ_key)r r r r> � s
zSocket.__setattr__c C s | j S )a\ Return edge-triggered file descriptor for this socket.
This is a read-only edge-triggered file descriptor for both read and write events on this socket.
It is important that all available events be consumed when an event is detected,
otherwise the read event will not trigger again.
.. versionadded:: 17.0
)�FD)r r r r �fileno� s z
Socket.filenoc C s& t |t�r|jd�}| jtj|� dS )z\Subscribe to a topic
Only for SUB sockets.
.. versionadded:: 15.3
r; N)r@ r rA rB rC rD )r �topicr r r r9 s
zSocket.subscribec C s& t |t�r|jd�}| jtj|� dS )z`Unsubscribe from a topic
Only for SUB sockets.
.. versionadded:: 15.3
r; N)r@ r rA rB rC rE )r rJ r r r r:
s
zSocket.unsubscribe�utf-8c C s$ t |t�std��| j||j|��S )a4 Set socket options with a unicode object.
This is simply a wrapper for setsockopt to protect from encoding ambiguity.
See the 0MQ documentation for details on specific options.
Parameters
----------
option : int
The name of the option to set. Can be any of: SUBSCRIBE,
UNSUBSCRIBE, IDENTITY
optval : unicode string (unicode on py2, str on py3)
The value of the option to set.
encoding : str
The encoding to be used, default is utf8
zunicode strings only)r@ r � TypeErrorrB rA )r �optionZoptval�encodingr r r �
set_string s
zSocket.set_stringc C s& |t jkrtd| ��| j|�j|�S )ae Get the value of a socket option.
See the 0MQ documentation for details on specific options.
Parameters
----------
option : int
The option to retrieve.
Returns
-------
optval : unicode string (unicode on py2, str on py3)
The value of the option as a unicode string.
z0option %i will not return a string to be decoded)r Zbytes_sockoptsrL �
getsockopt�decode)r rM rN r r r �
get_string/ s
zSocket.get_string� � � �d c C s� t td�rN|dkrN|dkrN| jd| � | jjdd�}|jdd�\}}t|�S x�t|�D ]|}y"tj ||�} | jd || f � W nP t
k
r� }
z4|
j } | t j
kr�wXntjd
kr�| t jkr�wXn� W Y d d }
~
X qXX | S qXW td ��d S )
a Bind this socket to a random port in a range.
If the port range is unspecified, the system will choose the port.
Parameters
----------
addr : str
The address string without the port to pass to ``Socket.bind()``.
min_port : int, optional
The minimum port in the range of ports to try (inclusive).
max_port : int, optional
The maximum port in the range of ports to try (exclusive).
max_tries : int, optional
The maximum number of bind attempts to make.
Returns
-------
port : int
The port the socket was bound to.
Raises
------
ZMQBindError
if `max_tries` reached before successful bind
Z
LAST_ENDPOINTi � i z%s:*�ascii�replace�:r z%s:%sZwin32Nz%Could not bind socket to random port.)�hasattrr r. Z
last_endpointrQ �rsplit�int�range�randomZ randranger �errnorC Z
EADDRINUSE�sys�platformZEACCESr ) r r+ Zmin_portZmax_portZ max_triesZurl�_Zport_s�iZportZ exceptionZenr r r �bind_to_random_portE s$
zSocket.bind_to_random_portc C sT t j� d }|dkrDy | jt j�S t jk
r6 Y nX | jt j�S | jt j�S dS )us Get the High Water Mark.
On libzmq ≥ 3, this gets SNDHWM if available, otherwise RCVHWM
r � N)rC �zmq_version_inforP ZSNDHWMr ZRCVHWM�HWM)r �majorr r r �get_hwmw s zSocket.get_hwmc C s� t j� d }|dkr�d}y
|| _W n& tk
rH } z
|}W Y dd}~X nX y
|| _W n& tk
rz } z
|}W Y dd}~X nX |r�|�n| jt j|�S dS )u� Set the High Water Mark.
On libzmq ≥ 3, this sets both SNDHWM and RCVHWM
.. warning::
New values only take effect for subsequent socket
bind/connects.
r rd N)rC re Zsndhwm� ExceptionZrcvhwm�
setsockoptrf )r rG rg Zraised�er r r �set_hwm� s
zSocket.set_hwmz�Property for High Water Mark.
Setting hwm sets both SNDHWM and RCVHWM as appropriate.
It gets SNDHWM if available, otherwise RCVHWM.
r Tc s| |dk r2t |tj�s,tj|||p"d| jd�}||_|dk rdt |tj�s^tj|||pTd| jd�}||_tt| �j||||d�S )a� Send a single zmq message frame on this socket.
This queues the message to be sent by the IO thread at a later time.
With flags=NOBLOCK, this raises :class:`ZMQError` if the queue is full;
otherwise, this waits until space is available.
See :class:`Poller` for more general non-blocking I/O.
Parameters
----------
data : bytes, Frame, memoryview
The content of the message. This can be any object that provides
the Python buffer API (i.e. `memoryview(data)` can be called).
flags : int
0, NOBLOCK, SNDMORE, or NOBLOCK|SNDMORE.
copy : bool
Should the message be sent in a copying or non-copying manner.
track : bool
Should the message be tracked for notification that ZMQ has
finished with it? (ignored if copy=True)
routing_id : int
For use with SERVER sockets
group : str
For use with RADIO sockets
Returns
-------
None : if `copy` or not track
None if message was sent, raises an exception otherwise.
MessageTracker : if track and not copy
a MessageTracker object, whose `pending` property will
be True until the send is completed.
Raises
------
TypeError
If a unicode object is passed
ValueError
If `track=True`, but an untracked Frame is passed.
ZMQError
If the send does not succeed for any reason (including
if NOBLOCK is set and the outgoing queue is full).
.. versionchanged:: 17.0
DRAFT support for routing_id and group arguments.
N)�track�copy�copy_threshold)�flagsrn rm ) r@ rC �Framero �
routing_id�groupr r �send)r �datarp rn rm rr rs )r r r rt � s 1
z Socket.sendc K s� x~t |�D ]r\}}t|tjttf�r&q
y t|� W q
tk
rz t|�}t|�dkrf|dd� d }t d||f ��Y q
X q
W x*|dd� D ]}| j
|t |B ||d� q�W | j
|d |||d�S ) a] Send a sequence of buffers as a multipart message.
The zmq.SNDMORE flag is added to all msg parts before the last.
Parameters
----------
msg_parts : iterable
A sequence of objects to send as a multipart message. Each element
can be any sendable object (Frame, bytes, buffer-providers)
flags : int, optional
Any valid flags for :func:`Socket.send`.
SNDMORE is added automatically for frames before the last.
copy : bool, optional
Should the frame(s) be sent in a copying or non-copying manner.
If copy=False, frames smaller than self.copy_threshold bytes
will be copied anyway.
track : bool, optional
Should the frame(s) be tracked for notification that ZMQ has
finished with it (ignored if copy=True).
Returns
-------
None : if copy or not track
MessageTracker : if track and not copy
a MessageTracker object, whose `pending` property will
be True until the last send is completed.
� Nz...z4Frame %i (%s) does not support the buffer interface.r )rn rm ���rw ) � enumerater@ rC rq r �
memoryviewri �repr�lenrL rt r ) r Z msg_partsrp rn rm r# rb �msgZrmsgr r r �send_multipart� s zSocket.send_multipartc C sB | j |||d�g}x*| jtj�r<| j |||d�}|j|� qW |S )a� Receive a multipart message as a list of bytes or Frame objects
Parameters
----------
flags : int, optional
Any valid flags for :func:`Socket.recv`.
copy : bool, optional
Should the message frame(s) be received in a copying or non-copying manner?
If False a Frame object is returned for each part, if True a copy of
the bytes is made for each frame.
track : bool, optional
Should the message frame(s) be tracked for notification that ZMQ has
finished with it? (ignored if copy=True)
Returns
-------
msg_parts : list
A list of frames in the multipart message; either Frames or bytes,
depending on `copy`.
Raises
------
ZMQError
for any of the reasons :func:`~Socket.recv` might fail
)rn rm )�recvrP rC ZRCVMORE�append)r rp rn rm �parts�partr r r �recv_multipart s
zSocket.recv_multipartc C s ||�S )a� Deserialize a received message
Override in subclass (e.g. Futures) if recvd is not the raw bytes.
The default implementation expects bytes and returns the deserialized message immediately.
Parameters
----------
load: callable
Callable that deserializes bytes
recvd:
The object returned by self.recv
r )r Zrecvd�loadr r r � _deserialize> s zSocket._deserializec K s ||�}| j |f||d�|��S )aW Send a message with a custom serialization function.
.. versionadded:: 17
Parameters
----------
msg : The message to be sent. Can be any object serializable by `serialize`.
serialize : callable
The serialization function to use.
serialize(msg) should return an iterable of sendable message frames
(e.g. bytes objects), which will be passed to send_multipart.
flags : int, optional
Any valid flags for :func:`Socket.send`.
copy : bool, optional
Whether to copy the frames.
)rp rn )r} )r r| Z serializerp rn r# �framesr r r �send_serializedP s zSocket.send_serializedc C s | j ||d�}| j||�S )a� Receive a message with a custom deserialization function.
.. versionadded:: 17
Parameters
----------
deserialize : callable
The deserialization function to use.
deserialize will be called with one argument: the list of frames
returned by recv_multipart() and can return any object.
flags : int, optional
Any valid flags for :func:`Socket.recv`.
copy : bool, optional
Whether to recv bytes or Frame objects.
Returns
-------
obj : object
The object returned by the deserialization function.
Raises
------
ZMQError
for any of the reasons :func:`~Socket.recv` might fail
)rp rn )r� r� )r Z deserializerp rn r� r r r �recv_serializede s zSocket.recv_serializedc K s0 t |t�std��| j|j|�f||d�|��S )a� Send a Python unicode string as a message with an encoding.
0MQ communicates with raw bytes, so you must encode/decode
text (unicode on py2, str on py3) around 0MQ.
Parameters
----------
u : Python unicode string (unicode on py2, str on py3)
The unicode string to send.
flags : int, optional
Any valid flags for :func:`Socket.send`.
encoding : str [default: 'utf-8']
The encoding to be used
zunicode/str objects only)rp rn )r@ r
rL rt rA )r �urp rn rN r# r r r � send_string� s
zSocket.send_stringc s | j |d�}| j|� fdd��S )a
Receive a unicode string, as sent by send_string.
Parameters
----------
flags : int
Any valid flags for :func:`Socket.recv`.
encoding : str [default: 'utf-8']
The encoding to be used
Returns
-------
s : unicode string (unicode on py2, str on py3)
The Python unicode string that arrives as encoded bytes.
Raises
------
ZMQError
for any of the reasons :func:`~Socket.recv` might fail
)rp c s
| j � �S )N)rQ )�buf)rN r r �<lambda>� s z$Socket.recv_string.<locals>.<lambda>)r~ r� )r rp rN r| r )rN r � recv_string� s zSocket.recv_stringc K s" t j||�}| j|fd|i|��S )a� Send a Python object as a message using pickle to serialize.
Parameters
----------
obj : Python object
The Python object to send.
flags : int
Any valid flags for :func:`Socket.send`.
protocol : int
The pickle protocol number to use. The default is pickle.DEFAULT_PROTOCOL
where defined, and pickle.HIGHEST_PROTOCOL elsewhere.
rp )�pickle�dumpsrt )r �objrp Zprotocolr# r| r r r �
send_pyobj� s
zSocket.send_pyobjc C s | j |�}| j|tj�S )a� Receive a Python object as a message using pickle to serialize.
Parameters
----------
flags : int
Any valid flags for :func:`Socket.recv`.
Returns
-------
obj : Python object
The Python object that arrives as a message.
Raises
------
ZMQError
for any of the reasons :func:`~Socket.recv` might fail
)r~ r� r� �loads)r rp r| r r r �
recv_pyobj� s
zSocket.recv_pyobjc K sL i }x"dD ]}||kr
|j |�||< q
W tj|f|�}| j|fd|i|��S )a; Send a Python object as a message using json to serialize.
Keyword arguments are passed on to json.dumps
Parameters
----------
obj : Python object
The Python object to send
flags : int
Any valid flags for :func:`Socket.send`
rr rs rp )rr rs )�popr
r� rt )r r� rp r# Z send_kwargsrF r| r r r � send_json� s
zSocket.send_jsonc s | j |�}| j|� fdd��S )a� Receive a Python object as a message using json to serialize.
Keyword arguments are passed on to json.loads
Parameters
----------
flags : int
Any valid flags for :func:`Socket.recv`.
Returns
-------
obj : Python object
The Python object that arrives as a message.
Raises
------
ZMQError
for any of the reasons :func:`~Socket.recv` might fail
c s t j| f� �S )N)r
r� )r� )r# r r r� � s z"Socket.recv_json.<locals>.<lambda>)r~ r� )r rp r# r| r )r# r � recv_json� s
zSocket.recv_jsonc C s< | j rtt��| j� }|j| |� t|j|��}|j| d�S )a^ Poll the socket for events.
See :class:`Poller` to wait for multiple sockets at once.
Parameters
----------
timeout : int [default: None]
The timeout (in milliseconds) to wait for an event. If unspecified
(or specified None), will wait forever for an event.
flags : int [default: POLLIN]
POLLIN, POLLOUT, or POLLIN|POLLOUT. The event flags to poll for.
Returns
-------
event_mask : int
The poll event mask (POLLIN, POLLOUT),
0 if the timeout was reached without an event.
r )�closedr r �
_poller_class�register�dict�poll�get)r Ztimeoutrp �pZevtsr r r r� s z Socket.pollc C s� t j� dk r tdt j� ��| jr8| jjr2d| _n| jS |dkrJd| j }|dkrXt j}| j||� | j j
t j �| _| jj |� | jS )a Return a connected PAIR socket ready to receive the event notifications.
.. versionadded:: libzmq-4.0
.. versionadded:: 14.0
Parameters
----------
events : int [default: ZMQ_EVENT_ALL]
The bitmask defining which events are wanted.
addr : string [default: None]
The optional endpoint for the monitoring sockets.
Returns
-------
socket : (PAIR)
The socket is already connected and ready to receive messages.
� z0get_monitor_socket requires libzmq >= 4, have %sNzinproc://monitor.s-%d)r� )
rC re �NotImplementedErrorZ zmq_version�_monitor_socketr� rH Z EVENT_ALL�monitorr* ZsocketZPAIRr/ )r Zeventsr+ r r r �get_monitor_socket s
zSocket.get_monitor_socketc C s d| _ | jdd� dS )z�Shutdown the PAIR socket (created using get_monitor_socket)
that is serving socket events.
.. versionadded:: 14.4
Nr )r� r� )r r r r �disable_monitorG s zSocket.disable_monitor)N)N)rK )rK )rS rT rU )r TFNN)r TF)r TF)r T)r T)r TrK )r rK )r )r )r )NN)@�__name__�
__module__� __qualname__�__doc__r r� r r r! r$ r& � __deepcopy__� classmethodr r r r, r- r. r/ �propertyr4 r8 �
SocketBaserB rj r� rP r> rI r9 r: rO Zsetsockopt_unicodeZsetsockopt_stringrR Zgetsockopt_unicodeZgetsockopt_stringrc rh rl Zhwmrt r} r� r� r� r� r� Z send_unicoder� Z recv_unicode�DEFAULT_PROTOCOLr� r� r� r� r r� r r� r� r� �
__classcell__r r )r r r , sd
2 =
/
"
*r )'r� r^ r] r_ r0 �
contextlibr rC Z zmq.backendr r� r� r � r Z attrsettrr Z zmq.errorr r Z zmq.utilsr
Zzmq.utils.strtypesr r r
r r r r r r r ZcPickler� r� �AttributeErrorZHIGHEST_PROTOCOL�__all__r r r r �<module> s@ $
+