o
    ZhWa                     @  s   d Z ddlmZ ddlZddlmZ ddlmZ ddlm	Z	 ddl
mZ ddlmZmZmZmZmZmZmZ ddlZdd	lmZmZmZ dd
lmZ G dd deZG dd dZG dd deejZG dd dZedddZ G dd deej!e Z"dS )z%Future-returning APIs for coroutines.    )annotationsN)Future)deque)partial)chain)Any	AwaitableCallable
NamedTupleTypeVarcastoverload)EVENTSPOLLINPOLLOUT)Literalc                   @  s6   e Zd ZU ded< ded< ded< ded< ded	< d
S )_FutureEventr   futurestrkinddictkwargsr   msgtimerN)__name__
__module____qualname____annotations__ r   r   B/var/www/html/lang_env/lib/python3.10/site-packages/zmq/_future.pyr      s   
 r   c                   @  sF   e Zd ZU dZdZded< ded< ddd	Zdd
dZddddZdS )_AsynczMixin for common async logicNr   _current_loopztype[Future]_Futurereturnc                 C  sL   | j du r|  | _ | | j  | j S |  }|| j ur$|| _ | | |S )zGet event loop

        Notice if event loop has changed,
        and register init_io_state on activation of a new event loop
        N)r!   _default_loop_init_io_state)selfZcurrent_loopr   r   r   	_get_loop*   s   



z_Async._get_loopc                 C  s   t d)Nz!Must be implemented in a subclassNotImplementedError)r&   r   r   r   r$   ;   s   z_Async._default_loopNonec                 C     d S Nr   r&   loopr   r   r   r%   >      z_Async._init_io_state)r#   r   r,   )r#   r*   )	r   r   r   __doc__r!   r   r'   r$   r%   r   r   r   r   r    $   s   
 

r    c                      sZ   e Zd ZU dZded< ded< ded< ded< dddZdddZdd fddZ  ZS )_AsyncPollerz:Poller that returns a Future on poll, instead of blocking.ztype[_AsyncSocket]_socket_classint_READ_WRITEz	list[Any]raw_socketsr.   r   socketevtfr	   r#   r*   c                 C     t  )z"Schedule callback for a raw socketr(   )r&   r.   r7   r8   r9   r   r   r   _watch_raw_socketJ      z_AsyncPoller._watch_raw_socketsocketsc                 G  r:   )z$Unschedule callback for a raw socketr(   )r&   r.   r=   r   r   r   _unwatch_raw_socketsN   r<   z!_AsyncPoller._unwatch_raw_sockets Awaitable[list[tuple[Any, int]]]c              
     s     |dkr0zt d}W n ty( } z | W Y d}~ S d}~ww  |  S    g fdd}fdd g fdd}jD ]W\}}t	|t
jrt	|jsqj|}| |t
j@ r}|jd	d
 |t
j@ r|jd	d
 qV| d}|t
j@ r|jO }|t
j@ r|jO }||| qV fdd}	|	 rÈ| |dur|dkrfdd}
d| |
fdd} | fdd} |  S )z Return a Future for a poll eventr   Nc                          s d  d S d S r,   done
set_result)argswatcherr   r   wake_rawf      z#_AsyncPoller.poll.<locals>.wake_rawc                   s   j  gR  S r,   )r>   r9   )r.   r6   r&   r   r   <lambda>k   s    z#_AsyncPoller.poll.<locals>.<lambda>c                   s    D ]}|   qd S r,   )_clear_io_state)r9   s)wrapped_socketsr   r   _clear_wrapper_iop   s   
z,_AsyncPoller.poll.<locals>._clear_wrapper_iopollr   c              
     s     rd S  rz  W d S  ty   Y d S w  r)  d S z
ttd}W n t	yK } z| W Y d }~d S d }~ww 
| d S Nr   )rC   	cancelledcancelRuntimeError	exceptionset_exceptionsuperr1   rP   	ExceptionrD   )r9   resulte)	__class__r   r&   rG   r   r   on_poll_ready   s&   
z(_AsyncPoller.poll.<locals>.on_poll_readyc                     rA   r,   rB   r   rF   r   r   trigger_timeout   rI   z*_AsyncPoller.poll.<locals>.trigger_timeoutMbP?c                   s$   t dr  d S   d S )NrT   )hasattrrT   Zremove_timeoutrJ   )r.   timeout_handler   r   cancel_timeout   s   
z)_AsyncPoller.poll.<locals>.cancel_timeoutc                   s      s
   d S d S r,   )rC   rT   rJ   rF   r   r   cancel_watcher   s   z)_AsyncPoller.poll.<locals>.cancel_watcher)r"   rX   rP   rY   rW   rD   r'   add_done_callbackr=   
isinstance_zmqSocketr2   from_socketappendr   _add_recv_eventr   _add_send_eventr4   r5   r;   
call_later)r&   timeoutrZ   r[   rH   rO   r7   maskr8   r]   r^   rb   rc   r\   )r   r.   r6   r&   ra   rG   rN   r   rP   R   sb   












z_AsyncPoller.poll)
r.   r   r7   r   r8   r3   r9   r	   r#   r*   )r.   r   r=   r   r#   r*   )r?   )r#   r@   )	r   r   r   r0   r   r;   r>   rP   __classcell__r   r   ro   r   r1   B   s   
 

r1   c                   @  s   e Zd Zedd ZdS )_NoTimerc                   C  r+   r,   r   r   r   r   r   rT      s   z_NoTimer.cancelN)r   r   r   staticmethodrT   r   r   r   r   rq      s    rq   T_AsyncSocket)boundc                      s   e Zd ZU dZdZdZded< eZdZ					dhdi fd
dZ
edjdkddZdjdl fddZejjje_ fddZejjje_e	dmdddnd!d"Ze	dmdddod%d"Ze	dmdddpd(d"Ze	dqdrd+d"Z	dqdrd,d"Zedmdddsd.d/Ze	dmdddtd0d/Ze	dmdddud2d/Z	dqdvd4d/Z	dqdwd7d8Z		)	dqdxd;d<Zd=d> Zdejfdyd@dAZdz fdCdDZ	Ed{d| fdJdKZdLdM ZdNdO ZedjdPdQZd}dRdSZ d~dTdUZ!dVdW Z"dXdY Z#ddZd[Z$djd\d]Z%d^d_ Z&d`da Z'dbdc Z(djdddeZ)dfdg Z*  Z+S )rt   Nr   _zmq.Socket_shadow_sockr?   _from_socket_zmq.Socket | Noner#   r*   c                   s   t |tjrd |}}|d urt j|jd || _nt j||fi | tj| j| _|d ur?tj	| j
j dtdd t | _t | _d| _| jj| _d S )N)shadowz^(io_loop) argument is deprecated in pyzmq 22.2. The currently active loop will always be used.   )
stacklevelr   )re   rf   rg   rX   __init__Z
underlyingrw   rz   warningswarnr\   r   DeprecationWarningr   _recv_futures_send_futures_stateZFD_fd)r&   contextsocket_typeio_looprx   r   ro   r   r   r}      s"   
z_AsyncSocket.__init__clstype[T]r7   r   r   rs   c                 C  s   | ||dS )z.Create an async socket from an existing Socket)rx   r   r   )r   r7   r   r   r   r   rh      s   z_AsyncSocket.from_socketlinger
int | Nonec              	     sz   | j s4| jd ur4tt| jpg | jpg }|D ]}|j s/z|j  W q t	y.   Y qw q| 
  t j|d d S )N)r   )closedr   listr   r   r   r   rC   rT   rU   rL   rX   close)r&   r   
event_listeventro   r   r   r      s   
z_AsyncSocket.closec                   s"   t  |}|tkr| | |S r,   )rX   getr   _schedule_remaining_events)r&   keyrZ   ro   r   r   r      s   
z_AsyncSocket.getF)trackflagsr3   r   boolAwaitable[list[bytes]]c                C  r+   r,   r   r&   r   r   r   r   r   recv_multipart     z_AsyncSocket.recv_multipartcopyLiteral[True]c                C  r+   r,   r   r&   r   r   r   r   r   r   r     r   Literal[False]Awaitable[list[_zmq.Frame]]c                C  r+   r,   r   r   r   r   r   r     s   T)Awaitable[list[bytes] | list[_zmq.Frame]]c                 C  r+   r,   r   r   r   r   r   r     r   c                 C     |  dt|||dS )zvReceive a complete multipart zmq message.

        Returns a Future whose result will be a multipart message.
        r   r   r   r   rj   r   r   r   r   r   r     s   Awaitable[bytes]c                C  r+   r,   r   r   r   r   r   recv'  r/   z_AsyncSocket.recvc                C  r+   r,   r   r   r   r   r   r   *  r   Awaitable[_zmq.Frame]c                C  r+   r,   r   r   r   r   r   r   /  r   Awaitable[bytes | _zmq.Frame]c                 C  r   )zReceive a single zmq frame.

        Returns a Future, whose result will be the received frame.

        Recommend using recv_multipart instead.
        r   r   r   r   r   r   r   r   4  s   		msg_parts%Awaitable[_zmq.MessageTracker | None]c                 K  s(   ||d< ||d< ||d< | j d||dS )zqSend a complete multipart zmq message.

        Returns a Future that resolves when sending is complete.
        r   r   r   send_multipartr   r   )rk   )r&   r   r   r   r   r   r   r   r   r   ?  s   z_AsyncSocket.send_multipartdatar   c                 K  s<   ||d< ||d< ||d< | t|||d | jd||dS )zSend a single zmq frame.

        Returns a Future that resolves when sending is complete.

        Recommend using send_multipart instead.
        r   r   r   r   sendr   )updater   rk   )r&   r   r   r   r   r   r   r   r   r   K  s
   z_AsyncSocket.sendc                   s>   |     fdd}|  fdd} |  S )zDeserialize with Futuresc              
     s      r s du rtd  d dt dS  r*   dS  }z|}W n tyL } z | W Y d}~dS d}~ww  	| dS )z+Chain result through serialization to recvdNzFuture z completed while awaiting z. A message has been dropped!)
rC   rS   rV   r~   r   RuntimeWarningrW   rZ   rY   rD   )_bufZloadedr[   r9   loadrecvdr   r   _chainc  s"   z)_AsyncSocket._deserialize.<locals>._chainc                   s$     rdS   r  dS dS )z"Chain cancellation from f to recvdN)rC   rS   rT   )r   )r9   r   r   r   _chain_cancel~  s
   z0_AsyncSocket._deserialize.<locals>._chain_cancel)r"   rd   )r&   r   r   r   r   r   r   r   _deserialize_  s   

z_AsyncSocket._deserializeAwaitable[int]c                   s   j r	ttj }|| tt||	   fdd}
 r0| n| fdd} |  S )zSpoll the socket for events

        returns a Future for the poll results.
        c                   st      rd S  rz   W d S  ty   Y d S w |  r)   d S t } |	d d S rR   )
rC   rS   rT   rU   rV   rW   r   rZ   rD   r   )r9   Zevtsr   poll_futurer&   r   r   unwrap_result  s   
z(_AsyncSocket.poll.<locals>.unwrap_resultc                   s0      sz   W dS  ty   Y dS w dS )z4Cancel underlying poll if request has been cancelledN)rC   rT   rU   rQ   )r   r   r   cancel_poll  s   z&_AsyncSocket.poll.<locals>.cancel_poll)r   rf   ZZMQErrorENOTSUP_poller_classregisterr   r   rP   r"   rC   rd   )r&   rm   r   pr   r   r   r   r   rP     s   


	z_AsyncSocket.pollAwaitable[str]c                   s   t  j|i |S r,   )rX   recv_string)r&   rE   r   ro   r   r   r     s   z_AsyncSocket.recv_stringutf-8rM   r   encodingAwaitable[None]c                   s   t  j|||dS )N)r   r   )rX   send_string)r&   rM   r   r   ro   r   r   r     s   z_AsyncSocket.send_stringc                   s    fdd}|  ||S )z'Add a timeout for a send or recv Futurec                     s      rd S  t  d S r,   )rC   rW   rf   Againr   rQ   r   r   future_timeout  s   z1_AsyncSocket._add_timeout.<locals>.future_timeout)_call_later)r&   r   rm   r   r   rQ   r   _add_timeout  s   z_AsyncSocket._add_timeoutc                 C  s   |   ||S )zSchedule a function to be called later

        Override for different IOLoop implementations

        Tornado and asyncio happen to both have ioloop.call_later
        with the same signature.
        )r'   rl   )r&   delaycallbackr   r   r   r     s   z_AsyncSocket._call_laterc                 C  s.   |sdS z| | W dS  ty   Y dS w )zMake sure that futures are removed from the event list when they resolve

        Avoids delaying cleanup until the next send/recv event,
        which may never come.
        N)remove
ValueError)r   r   r   r   r   r   _remove_finished_future  s   z$_AsyncSocket._remove_finished_futurec              
   C  s   |p|   }|drC|ddtj@ rCt| j|}z	|d	i |}W n ty; } z|| W Y d}~|S d}~ww |	| |S t
}ttdrZ| jj}	|	dkrZ| ||	d }t|||d|d}
| j|
 | jtt@ ru|   | jr|
| jv r|t| j| j|
d | t |S )
z4Add a recv event, returning the corresponding Futurer   r   r   NZRCVTIMEOr_   )r   r   r   r   r   )r"   
startswithr   rf   DONTWAITgetattrrw   rY   rW   rD   rq   r`   Zrcvtimeor   r   r   ri   r   r   _handle_recvrd   r   r   _add_io_state)r&   r   r   r   r9   r   rr[   r   
timeout_ms_future_eventr   r   r   rj     s>   


z_AsyncSocket._add_recv_eventc              
   C  sf  |p|   }|dv rw| jsw|dd}| }|tjB |d< t| j|}d}	z
||fi |}
W n6 tjyP } z|tj@ rD|	| nd}	W Y d}~n d}~w t
yf } z|	| W Y d}~n
d}~ww ||
 |	rw| jru|   |S t}ttdr| jtj}|dkr| ||d }t|||||d	}| j| |t| j| j|d
 | t |S )z4Add a send event, returning the corresponding Future)r   r   r   r   TFNSNDTIMEOr_   )r   r   r   r   )r"   r   r   r   rf   r   r   rw   r   rW   rY   rD   r   r   rq   r`   r   r   r   ri   rd   r   r   r   r   )r&   r   r   r   r   r9   r   Znowait_kwargsr   Zfinish_earlyr   r[   r   r   r   r   r   r   rk     sN   



z_AsyncSocket._add_send_eventc           	   
   C  s  | j tt@ s
dS d}| jr$| j \}}}}}| r d}nn| js| js,| t |du r2dS |  |dkrA|	d dS |dkrJ| j j
}n|dkrS| j j}ntd||d  tjO  < z	|di |}W n ty } z|| W Y d}~dS d}~ww |	| dS )zHandle recv eventsNrP   r   r   zUnhandled recv event type: r   r   )rw   r   r   r   r   popleftrC   _drop_io_staterT   rD   r   r   r   rf   r   rY   rW   )	r&   r9   r   r   r   r   r   rZ   r[   r   r   r   r   R  s<   



z_AsyncSocket._handle_recvc           	   
   C  s  | j tt@ s
d S d }| jr$| j \}}}}}| r d }nn| js| js,| t |d u r2d S |  |dkrA|	d  d S |dkrJ| j j
}n|dkrS| j j}ntd||d  tjO  < z
||fi |}W n ty } z|| W Y d }~d S d }~ww |	| d S )NrP   r   r   zUnhandled send event type: r   )rw   r   r   r   r   r   rC   r   rT   rD   r   r   r   rf   r   rY   rW   )	r&   r9   r   r   r   r   r   rZ   r[   r   r   r   _handle_send{  s<   



z_AsyncSocket._handle_sendc                 C  sH   | j jrdS | j t}|tj@ r|   |tj@ r|   | 	  dS )z(Dispatch IO events to _handle_recv, etc.N)
rw   r   r   r   rf   r   r   r   r   r   )r&   fdeventsZ
zmq_eventsr   r   r   _handle_events  s   

z_AsyncSocket._handle_eventsc                 C  sB   | j dkrdS |du r| jt}|| j @ r| d| j dS dS )zkSchedule a call to handle_events next loop iteration

        If there are still events to handle.
        r   N)r   rw   r   r   r   r   )r&   r   r   r   r   r     s   

z'_AsyncSocket._schedule_remaining_eventsc                 C  s*   | j |kr| j |B  }| _ | | j  dS )zAdd io_state to poller.Nr   _update_handlerr&   stater   r   r   r     s   
z_AsyncSocket._add_io_statec                 C  s(   | j |@ r| j | @ | _ | | j  dS )z&Stop poller from watching an io_state.Nr   r   r   r   r   r     s   
z_AsyncSocket._drop_io_statec                 C  s   |r|    |   dS )zOUpdate IOLoop handler with state.

        zmq FD is always read-only.
        N)r'   r   r   r   r   r   r     s   z_AsyncSocket._update_handlerc                 C  s6   |du r|   }|| j| j| j | d| j dS )z#initialize the ioloop event handlerNr   )r'   add_handlerrw   r   r4   r   r-   r   r   r   r%     s   z_AsyncSocket._init_io_statec                 C  s2   | j }| j jr
| j}| jdur| j| dS dS )zNunregister the ioloop event handler

        called once during close
        N)rw   r   r   r!   Zremove_handler)r&   r   r   r   r   rL     s   
z_AsyncSocket._clear_io_state)Nr?   NN)rx   ry   r#   r*   r,   )r   r   r7   rv   r   r   r#   rs   )r   r   r#   r*   )r   )r   r3   r   r   r#   r   )r   r3   r   r   r   r   r#   r   )r   r3   r   r   r   r   r#   r   )r   TF)r   r3   r   r   r   r   r#   r   )r   r3   r   r   r#   r   )r   r3   r   r   r   r   r#   r   )r   r3   r   r   r   r   r#   r   )r   r3   r   r   r   r   r#   r   )r   r   r   r3   r   r   r#   r   )r   r   r   r3   r   r   r   r   r   r   r#   r   )r#   r   )r#   r   )r   r   )rM   r   r   r3   r   r   r#   r   )NN)NNN)r   r   ),r   r   r   r   r   r   r   r1   r   r   r}   classmethodrh   r   rf   rg   r0   r   r   r   r   r   r   r   r   rP   r   r   r   r   rr   r   rj   rk   r   r   r   r   r   r   r   r%   rL   rp   r   r   ro   r   rt      s   
 *3


*;)
)

)#r0   
__future__r   r~   Zasyncior   collectionsr   	functoolsr   	itertoolsr   typingr   r   r	   r
   r   r   r   Zzmqrf   r   r   r   Zzmq._typingr   r   r    ZPollerr1   rq   rs   rg   rt   r   r   r   r   <module>   s"    $w