a
    õ£Be>Z  ã                   @   sü   d 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	m
Z
mZmZmZmZ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.é    N)ÚFuture)Údeque)Úchain)ÚAnyÚ	AwaitableÚCallableÚDictÚListÚ
NamedTupleÚOptionalÚTupleÚTypeÚTypeVarÚUnionÚcastÚoverload)ÚEVENTSÚPOLLINÚPOLLOUT)ÚLiteralc                   @   s6   e Zd ZU eed< eed< eed< eed< eed< dS )Ú_FutureEventÚfutureÚkindÚkwargsÚmsgÚtimerN)Ú__name__Ú
__module__Ú__qualname__r   Ú__annotations__Ústrr   r   © r!   r!   úN/home/yuhw/wc/wire-cell-python/wcpy/lib/python3.9/site-packages/zmq/_future.pyr      s
   
r   c                   @   sV   e Zd ZU dZdZeed< ee ed< edœdd„Z	edœdd	„Z
dddœd
d„ZdS )Ú_AsynczMixin for common async logicNÚ_current_loopÚ_Future©Úreturnc                 C   sL   | j du r&|  ¡ | _ |  | j ¡ | j S |  ¡ }|| j urH|| _ |  |¡ |S )z‡Get 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)ÚselfÚcurrent_loopr!   r!   r"   Ú	_get_loop6   s    



z_Async._get_loopc                 C   s   t dƒ‚d S )Nz!Must be implemented in a subclass©ÚNotImplementedError©r*   r!   r!   r"   r(   G   s    z_Async._default_loopc                 C   s   d S ©Nr!   ©r*   Úloopr!   r!   r"   r)   J   s    z_Async._init_io_state)N)r   r   r   Ú__doc__r$   r   r   r   r   r,   r(   r)   r!   r!   r!   r"   r#   0   s   
r#   c                       sŠ   e Zd ZU dZed ed< eed< eed< ee ed< eeee	ddœd	d
„Z
eeddœdd„Zdeeeeef   dœ‡ fdd„Z‡  ZS )Ú_AsyncPollerz:Poller that returns a Future on poll, instead of blocking.Ú_AsyncSocketÚ_socket_classÚ_READÚ_WRITEÚraw_socketsN)r2   ÚsocketÚevtÚfr'   c                 C   s
   t ƒ ‚dS )z"Schedule callback for a raw socketNr-   )r*   r2   r:   r;   r<   r!   r!   r"   Ú_watch_raw_socketV   s    z_AsyncPoller._watch_raw_socket)r2   Úsocketsr'   c                 G   s
   t ƒ ‚dS )z$Unschedule callback for a raw socketNr-   )r*   r2   r>   r!   r!   r"   Ú_unwatch_raw_socketsZ   s    z!_AsyncPoller._unwatch_raw_socketséÿÿÿÿr&   c              
      sÂ  ˆ  ¡ ‰ |dkr^ztƒ  d¡}W n. tyN } zˆ  |¡ W Y d}~nd}~0 0 ˆ  |¡ ˆ S ˆ ¡ ‰ˆ  ¡ ‰g ‰‡fdd„}ˆ ‡‡‡fdd„¡ ˆjD ]¨\}}t	|t
jƒrøt	|ˆjƒsÆˆj |¡}|t
j@ rÞ|jdˆd� |t
j@ rö|jdˆd� qšˆ |¡ d}|t
j@ �r|ˆjO }|t
j@ �r2|ˆjO }ˆ ˆ|||¡ qš‡‡ ‡‡fd	d
„}ˆ |¡ |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   ˆ   ¡ sˆ  d ¡ d S r0   ©ÚdoneÚ
set_result)Úargs©Úwatcherr!   r"   Úwake_rawr   s    z#_AsyncPoller.poll.<locals>.wake_rawc                    s   ˆj ˆ gˆ¢R Ž S r0   )r?   ©r<   )r2   r9   r*   r!   r"   Ú<lambda>w   ó    z#_AsyncPoller.poll.<locals>.<lambda>Úpoll©r   c              
      s¢   ˆ  ¡ rd S ˆ ¡ r8zˆ ¡  W n ty2   Y n0 d S ˆ ¡ rPˆ ˆ ¡ ¡ nNzttˆƒ d¡}W n. t	y’ } zˆ |¡ W Y d }~nd }~0 0 ˆ 
|¡ d S ©Nr   )rB   Ú	cancelledÚcancelÚRuntimeErrorÚ	exceptionÚset_exceptionÚsuperr4   rK   Ú	ExceptionrC   )r<   ÚresultÚe)Ú	__class__r   r*   rF   r!   r"   Úon_poll_readyŒ   s     z(_AsyncPoller.poll.<locals>.on_poll_readyc                      s   ˆ   ¡ sˆ  d ¡ d S r0   rA   r!   rE   r!   r"   Útrigger_timeout¤   s    z*_AsyncPoller.poll.<locals>.trigger_timeoutçü©ñÒMbP?c                    s"   t ˆdƒrˆ ¡  n
ˆ  ˆ¡ d S )NrO   )ÚhasattrrO   Zremove_timeoutrH   )r2   Útimeout_handler!   r"   Úcancel_timeoutª   s    

z)_AsyncPoller.poll.<locals>.cancel_timeoutc                    s   ˆ   ¡ sˆ  ¡  d S r0   )rB   rO   rH   rE   r!   r"   Úcancel_watcher²   s    z)_AsyncPoller.poll.<locals>.cancel_watcher)r%   rS   rK   rT   rR   rC   r,   Úadd_done_callbackr>   Ú
isinstanceÚ_zmqÚSocketr6   Úfrom_socketr   Ú_add_recv_eventr   Ú_add_send_eventÚappendr7   r8   r=   Ú
call_later)r*   ÚtimeoutrU   rV   rG   r:   Úmaskr;   rX   rY   r]   r^   ©rW   )r   r2   r9   r*   r\   rF   r"   rK   ^   sP     
ÿ







z_AsyncPoller.poll)r@   )r   r   r   r3   r   r   Úintr	   r   r   r=   r?   r   r   rK   Ú__classcell__r!   r!   rj   r"   r4   N   s   
r4   c                   @   s   e Zd Zedd„ ƒZdS )Ú_NoTimerc                   C   s   d S r0   r!   r!   r!   r!   r"   rO   ¼   s    z_NoTimer.cancelN)r   r   r   ÚstaticmethodrO   r!   r!   r!   r"   rm   »   s   rm   ÚTr5   )Úboundc                
       s¼  e Zd ZU dZdZdZded< eZdZ	dKe
d ddœ‡ fdd„ZedLee deed	œd
d„ƒZdMe
e ddœ‡ fdd„Zejjje_‡ fdd„Zejjje_edNddœeeeee  dœdd„ƒZedOddœeed eeee  dœdd„ƒZedPddœeed eeeej  dœdd„ƒZedQeeeeeee eej f  dœdd„ƒZdReeeeeee eej f  dœdd„ZdSeeeeeeejf  dœdd„Z dTeeeee
ej!  dœdd „Z"dUeeeeeee
ej!  d!œd"d#„Z#d$d%„ Z$dej%fee d&œd'd(„Z&ee' d&œ‡ fd)d*„Z(dVe'ee'ed d,œ‡ fd-d.„Z)d/d0„ Z*d1d2„ Z+e,d3d4„ ƒZ-dWd5d6„Z.dXd7d8„Z/d9d:„ Z0d;d<„ Z1dYd=d>„Z2dZd?d@„Z3dAdB„ Z4dCdD„ Z5dEdF„ Z6d[dGdH„Z7dIdJ„ Z8‡  Z9S )\r5   Nr   z_zmq.SocketÚ_shadow_sockr@   )Ú_from_socketr'   c                    s¢   t |tjƒrd | }}|d ur6tƒ 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   )r`   ra   rb   rS   Ú__init__Z
underlyingrq   rs   ÚwarningsÚwarnrW   r   ÚDeprecationWarningr   Ú_recv_futuresÚ_send_futuresÚ_stateZFDÚ_fd)r*   ÚcontextÚsocket_typeÚio_looprr   r   rj   r!   r"   rv   Î   s"    
üz_AsyncSocket.__init__)Úclsr:   r€   r'   c                 C   s   | ||d�S )z.Create an async socket from an existing Socket)rr   r€   r!   )r�   r:   r€   r!   r!   r"   rc   ë   s    z_AsyncSocket.from_socket)Úlingerr'   c              	      sz   | j sh| jd urhtt| jpg | jp$g ƒƒ}|D ]0}|j ¡ s.z|j ¡  W q. t	y\   Y q.0 q.|  
¡  tƒ j|d� d S )N)r‚   )Úclosedr}   Úlistr   rz   r{   r   rB   rO   rP   Ú_clear_io_staterS   Úclose)r*   r‚   Ú
event_listÚeventrj   r!   r"   r†   ð   s    ÿ
z_AsyncSocket.closec                    s"   t ƒ  |¡}|tkr|  |¡ |S r0   )rS   Úgetr   Ú_schedule_remaining_events)r*   ÚkeyrU   rj   r!   r"   r‰     s    
z_AsyncSocket.getF)Útrack)ÚflagsrŒ   r'   c                C   s   d S r0   r!   )r*   r�   rŒ   r!   r!   r"   Úrecv_multipart	  s    z_AsyncSocket.recv_multipartT)r�   ÚcopyrŒ   r'   c                C   s   d S r0   r!   ©r*   r�   r�   rŒ   r!   r!   r"   rŽ     s    c                C   s   d S r0   r!   r�   r!   r!   r"   rŽ     s    c                 C   s   d S r0   r!   r�   r!   r!   r"   rŽ     s    c                 C   s   |   dt|||d�¡S )zvReceive a complete multipart zmq message.

        Returns a Future whose result will be a multipart message.
        rŽ   ©r�   r�   rŒ   ©rd   Údictr�   r!   r!   r"   rŽ   !  s    ÿc                 C   s   |   dt|||d�¡S )z™Receive a single zmq frame.

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

        Recommend using recv_multipart instead.
        Úrecvr‘   r’   r�   r!   r!   r"   r”   ,  s    	z_AsyncSocket.recv)Ú	msg_partsr�   r�   r'   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   )re   )r*   r•   r�   r�   rŒ   r   r!   r!   r"   r–   7  s    z_AsyncSocket.send_multipart)Údatar�   r�   rŒ   r   r'   c                 K   s<   ||d< ||d< ||d< |  t|||d�¡ | jd||d�S )z”Send a single zmq frame.

        Returns a Future that resolves when sending is complete.

        Recommend using send_multipart instead.
        r�   r�   rŒ   r‘   Úsendr—   )Úupdater“   re   )r*   r˜   r�   r�   rŒ   r   r!   r!   r"   r™   C  s
    z_AsyncSocket.sendc                    s>   |   ¡ ‰ ‡ ‡‡fdd„}ˆ |¡ ‡ ‡fdd„}ˆ  |¡ ˆ S )zDeserialize with Futuresc              
      sv   ˆ   ¡ rdS ˆ ¡ r$ˆ  ˆ ¡ ¡ nNˆ ¡ }zˆ|ƒ}W n. tyf } zˆ  |¡ W Y d}~nd}~0 0 ˆ  |¡ dS )z+Chain result through serialization to recvdN)rB   rQ   rR   rU   rT   rC   )Ú_ÚbufZloadedrV   ©r<   ÚloadÚrecvdr!   r"   Ú_chain[  s     z)_AsyncSocket._deserialize.<locals>._chainc                    s    ˆ  ¡ rdS ˆ  ¡ rˆ ¡  dS )z"Chain cancellation from f to recvdN)rB   rN   rO   )r›   )r<   rŸ   r!   r"   Ú_chain_cancell  s    z0_AsyncSocket._deserialize.<locals>._chain_cancel)r%   r_   )r*   rŸ   rž   r    r¡   r!   r�   r"   Ú_deserializeW  s    

z_AsyncSocket._deserializer&   c                    s„   ˆj rt tj¡‚ˆ ¡ }| ˆ|¡ tt| |¡ƒ‰ˆ 	¡ ‰ ‡ ‡‡fdd„}ˆ 
¡ r`|ˆƒ n
ˆ |¡ ‡fdd„}ˆ  |¡ ˆ S )zSpoll the socket for events

        returns a Future for the poll results.
        c                    sr   ˆ   ¡ rd S ˆ ¡ r8zˆ  ¡  W n ty2   Y n0 d S |  ¡ rPˆ  ˆ ¡ ¡ ntˆ ¡ ƒ}ˆ  | 	ˆd¡¡ d S rM   )
rB   rN   rO   rP   rQ   rR   r“   rU   rC   r‰   )r<   Zevts©r   Úpoll_futurer*   r!   r"   Úunwrap_result†  s    z(_AsyncSocket.poll.<locals>.unwrap_resultc                    s,   ˆ   ¡ s(zˆ  ¡  W n ty&   Y n0 dS )z4Cancel underlying poll if request has been cancelledN)rB   rO   rP   rL   )r¤   r!   r"   Úcancel_pollœ  s
    z&_AsyncSocket.poll.<locals>.cancel_poll)rƒ   ra   ZZMQErrorÚENOTSUPÚ_poller_classÚregisterr   r   rK   r%   rB   r_   )r*   rh   r�   Úpr¥   r¦   r!   r£   r"   rK   w  s    

	
z_AsyncSocket.pollc                    s   t ƒ j|i |¤ŽS r0   )rS   Úrecv_string)r*   rD   r   rj   r!   r"   r«   ª  s    z_AsyncSocket.recv_stringúutf-8)Úsr�   Úencodingr'   c                    s   t ƒ j|||d�S )N)r�   r®   )rS   Úsend_string)r*   r­   r�   r®   rj   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 r0   )rB   rR   ra   ÚAgainr!   rL   r!   r"   Úfuture_timeout³  s    z1_AsyncSocket._add_timeout.<locals>.future_timeout)Ú_call_later)r*   r   rh   r±   r!   rL   r"   Ú_add_timeout°  s    z_AsyncSocket._add_timeoutc                 C   s   |   ¡  ||¡S )zÊSchedule 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,   rg   )r*   ÚdelayÚcallbackr!   r!   r"   r²   ½  s    z_AsyncSocket._call_laterc                 C   s6   t |ƒD ]\}}|j| u r q$qdS | || ¡ dS )z°Make 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)Ú	enumerater   Úremove)r   r‡   Zf_idxrˆ   r!   r!   r"   Ú_remove_finished_futureÇ  s
    
z$_AsyncSocket._remove_finished_futurec           
   
      s  |p
ˆ   ¡ }| d¡r„| dd¡tj@ r„tˆ j|ƒ}z|f i |¤Ž}W n. tyt } z| |¡ W Y d}~nd}~0 0 | 	|¡ |S t
}ttdƒr²ˆ jj}	|	dkr²ˆ  ||	d ¡}ˆ j t|||d|d�¡ | ‡ fdd	„¡ ˆ j t¡t@ röˆ  ¡  ˆ j�rˆ  t¡ |S )
z4Add a recv event, returning the corresponding Futurer”   r�   r   NZRCVTIMEOrZ   )r   r   c                    s   ˆ   | ˆ j¡S r0   )r¸   rz   rH   r/   r!   r"   rI   ñ  rJ   z._AsyncSocket._add_recv_event.<locals>.<lambda>)r%   Ú
startswithr‰   ra   ÚDONTWAITÚgetattrrq   rT   rR   rC   rm   r[   Zrcvtimeor³   rz   rf   r   r_   r   r   Ú_handle_recvÚ_add_io_state)
r*   r   r   r   r<   r”   ÚrrV   r   Ú
timeout_msr!   r/   r"   rd   ×  s.     


ÿ
z_AsyncSocket._add_recv_eventc              
      s`  |p
ˆ   ¡ }|dv rîˆ jsî| dd¡}| ¡ }|tjB |d< tˆ j|ƒ}d}	z||fi |¤Ž}
W nl tjy  } z&|tj@ rˆ| 	|¡ nd}	W Y d}~n@d}~0  t
yÌ } z| 	|¡ W Y d}~nd}~0 0 | |
¡ |	rîˆ jrêˆ  ¡  |S t}ttdƒ�r&ˆ j tj¡}|dk�r&ˆ  ||d ¡}ˆ j t|||||d	�¡ | ‡ fd
d„¡ ˆ  t¡ |S )z4Add a send event, returning the corresponding Future)r™   r–   r�   r   TFNÚSNDTIMEOrZ   )r   r   r   c                    s   ˆ   | ˆ j¡S r0   )r¸   r{   rH   r/   r!   r"   rI   -  rJ   z._AsyncSocket._add_send_event.<locals>.<lambda>)r%   r{   r‰   r�   ra   rº   r»   rq   r°   rR   rT   rC   rz   rŠ   rm   r[   rÀ   r³   rf   r   r_   r½   r   )r*   r   r   r   r   r<   r�   Znowait_kwargsr™   Zfinish_earlyr¾   rV   r   r¿   r!   r/   r"   re   û  sB    
 

ÿ
ÿ
z_AsyncSocket._add_send_eventc           	   
   C   s  | j  t¡t@ sdS d}| jrD| j ¡ \}}}}}| ¡ rDd}qqDq| jsT|  t¡ |du r`dS | ¡  |dkr~| 	d¡ dS |dkr�| j j
}n|dkr¢| j j}ntd| ƒ‚|d  tjO  < z|f i |¤Ž}W n0 t�y } z| |¡ W Y d}~nd}~0 0 | 	|¡ dS )zHandle recv eventsNrK   rŽ   r”   zUnhandled recv event type: %rr�   )rq   r‰   r   r   rz   ÚpopleftrB   Ú_drop_io_staterO   rC   rŽ   r”   Ú
ValueErrorra   rº   rT   rR   )	r*   r<   r   r   r›   r   r”   rU   rV   r!   r!   r"   r¼   3  s6    



 z_AsyncSocket._handle_recvc           	   
   C   s  | j  t¡t@ sd S d }| jrD| j ¡ \}}}}}| ¡ rDd }qqDq| jsT|  t¡ |d u r`d S | ¡  |dkr~| 	d ¡ d S |dkr�| j j
}n|dkr¢| j j}ntd| ƒ‚|d  tjO  < z||fi |¤Ž}W n0 t�y } z| |¡ W Y d }~nd }~0 0 | 	|¡ d S )NrK   r–   r™   zUnhandled send event type: %rr�   )rq   r‰   r   r   r{   rÁ   rB   rÂ   rO   rC   r–   r™   rÃ   ra   rº   rT   rR   )	r*   r<   r   r   r   r   r™   rU   rV   r!   r!   r"   Ú_handle_send\  s6    



 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)
rq   rƒ   r‰   r   ra   r   r¼   r   rÄ   rŠ   )r*   ÚfdÚeventsZ
zmq_eventsr!   r!   r"   Ú_handle_events…  s    

z_AsyncSocket._handle_eventsc                 C   s>   | j dkrdS |du r"| j t¡}|| j @ r:|  d| j¡ dS )zkSchedule a call to handle_events next loop iteration

        If there are still events to handle.
        r   N)r|   rq   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_handlerrq   rÇ   r7   r²   r1   r!   r!   r"   r)   ¸  s    z_AsyncSocket._init_io_statec                 C   s.   | j }| j jr| j}| jdur*| j |¡ dS )zNunregister the ioloop event handler

        called once during close
        N)rq   rƒ   r}   r$   Zremove_handler)r*   rÅ   r!   r!   r"   r…   ¿  s
    
z_AsyncSocket._clear_io_state)Nr@   NN)N)N)r   )r   )r   )r   TF)r   TF)r   TF)r   TF)r   TF)r   r¬   )NN)NNN)r   r   )N)N):r   r   r   rz   r{   r|   r   r4   r¨   r}   r   rv   Úclassmethodr   ro   r   rc   rk   r†   ra   rb   r3   r‰   r   Úboolr   r	   ÚbytesrŽ   r   ÚFramer   r”   ZMessageTrackerr–   r™   r¢   r   rK   r    r«   r¯   r³   r²   rn   r¸   rd   re   r¼   rÄ   rÇ   rŠ   r½   rÂ   rÉ   r)   r…   rl   r!   r!   rj   r"   r5   Ä   s¾   
    ûù ÿÿ
þ ÿÿ

þ ÿÿ
þ ÿþ ÿþ ÿþ ÿþ   ûù 3


$
8))


)%r3   rw   Úasyncior   Úcollectionsr   Ú	itertoolsr   Útypingr   r   r   r   r	   r
   r   r   r   r   r   r   r   Zzmqra   r   r   r   Zzmq._typingr   r   r#   ZPollerr4   rm   ro   rb   r5   r!   r!   r!   r"   Ú<module>   s   <m