
    fWa                    H   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e      Z G d d      Z G d deej:                        Z G d d      Z edd      Z  G d deejB                  e         Z"y)z%Future-returning APIs for coroutines.    )annotationsN)Future)deque)partial)chain)Any	AwaitableCallable
NamedTupleTypeVarcastoverload)EVENTSPOLLINPOLLOUT)Literalc                  @    e Zd ZU ded<   ded<   ded<   ded<   ded	<   y
)_FutureEventr   futurestrkinddictkwargsr   msgtimerN)__name__
__module____qualname____annotations__     F/var/www/cvtools/html/venv/lib/python3.12/site-packages/zmq/_future.pyr   r      s    N
IL	HJr!   r   c                  D    e Zd ZU dZdZded<   ded<   d
dZd
dZddd	Zy)_AsynczMixin for common async logicNr   _current_loopztype[Future]_Futurec                   | j                   <| j                         | _         | j                  | j                          | j                   S | j                         }|| j                   ur|| _         | j                  |       |S )zGet event loop

        Notice if event loop has changed,
        and register init_io_state on activation of a new event loop
        )r%   _default_loop_init_io_state)selfcurrent_loops     r"   	_get_loopz_Async._get_loop*   sy     %!%!3!3!5D 2 23%%%))+t111!-D-r!   c                    t        d      )Nz!Must be implemented in a subclassNotImplementedError)r*   s    r"   r(   z_Async._default_loop;   s    !"EFFr!   c                     y Nr    r*   loops     r"   r)   z_Async._init_io_state>   s    r!   )returnr   r1   )r4   None)	r   r   r   __doc__r%   r   r,   r(   r)   r    r!   r"   r$   r$   $   s%    &M3"Gr!   r$   c                  `     e Zd ZU dZded<   ded<   ded<   ded<   dd	Zdd
Zdd fdZ xZS )_AsyncPollerz:Poller that returns a Future on poll, instead of blocking.ztype[_AsyncSocket]_socket_classint_READ_WRITEz	list[Any]raw_socketsc                    t               )z"Schedule callback for a raw socketr.   )r*   r3   socketevtfs        r"   _watch_raw_socketz_AsyncPoller._watch_raw_socketJ       !##r!   c                    t               )z$Unschedule callback for a raw socketr.   )r*   r3   socketss      r"   _unwatch_raw_socketsz!_AsyncPoller._unwatch_raw_socketsN   rC   r!   c                     j                         |dk(  r#	 t         	  d      }j                  |       S  j                          j                         g fd}j                   fd       g fd} j                  D ]  \  }}t        |t        j                        rt        | j                        s, j                  j                  |      }j                  |       |t        j                  z  r|j!                  d       |t        j"                  z  s|j%                  d       j                  |       d}|t        j                  z  r| j&                  z  }|t        j"                  z  r| j(                  z  } j+                  |||         fd}	j                  |	       rj                  |       |6|dkD  r1fd	}
j-                  d
|z  |
      fd}j                  |       fd}j                  |       S # t        $ r}j                  |       Y d}~S d}~ww xY w)z Return a Future for a poll eventr   Nc                 J    j                         sj                  d        y y r1   done
set_result)argswatchers    r"   wake_rawz#_AsyncPoller.poll.<locals>.wake_rawf   s    <<>""4( "r!   c                *     j                   g S r1   )rF   )rA   r3   r=   r*   s    r"   <lambda>z#_AsyncPoller.poll.<locals>.<lambda>k   s    /d//C{C r!   c                4    D ]  }|j                           y r1   )_clear_io_state)rA   swrapped_socketss     r"   _clear_wrapper_ioz,_AsyncPoller.poll.<locals>._clear_wrapper_iop   s    $ $!!#$r!   pollr   c                   j                         ry j                         r	 j                          y j	                         r j                  j	                                y 	 t        t        #  d      }j                  |       y # t        $ r Y y w xY w# t        $ r}j                  |       Y d }~y d }~ww xY wNr   )rJ   	cancelledcancelRuntimeError	exceptionset_exceptionsuperr8   rV   rK   	Exception)rA   resulte	__class__r   r*   rM   s      r"   on_poll_readyz(_AsyncPoller.poll.<locals>.on_poll_ready   s    {{}  "MMO   "$$W%6%6%89."<;A>F %%f- $  ! ,((++,s)   B &B 	BB	B>#B99B>c                 J     j                         s j                  d        y y r1   rI   )rM   s   r"   trigger_timeoutz*_AsyncPoller.poll.<locals>.trigger_timeout   s    ||~&&t, &r!   MbP?c                b    t        d      rj                          y j                         y )Nr[   )hasattrr[   remove_timeout)rA   r3   timeout_handles    r"   cancel_timeoutz)_AsyncPoller.poll.<locals>.cancel_timeout   s'    >84"))+''7r!   c                H    j                         sj                          y y r1   )rJ   r[   )rA   rM   s    r"   cancel_watcherz)_AsyncPoller.poll.<locals>.cancel_watcher   s    <<>  "r!   )r&   r_   rV   rK   r`   r^   r,   add_done_callbackrE   
isinstance_zmqSocketr9   from_socketappendr   _add_recv_eventr   _add_send_eventr;   r<   rB   
call_later)r*   timeoutra   rb   rN   rU   r?   maskr@   rd   rf   rl   rn   r   r3   r=   rk   rM   rT   rc   s   `            @@@@@@r"   rV   z_AsyncPoller.pollR   s   a<*a !!&)M~~ ,,. "$	) 	!!C	
 /1	$ !LL 	DLFD&$++.!&$*<*<=!//;;FCF#**62$++%**6'*B$,,&**6'*B""6*$++%4::%C$,,&4;;&C&&tVS(C#	D&	.( 	!!-0%%&787Q;- "__TG^_MN8 $$^4	! 	  0}  ($$Q'' M	(s   H, ,	I5II)
r3   r   r?   r   r@   r:   rA   r
   r4   r5   )r3   r   rE   r   r4   r5   ))r4   z Awaitable[list[tuple[Any, int]]])	r   r   r   r6   r   rB   rF   rV   __classcell__rc   s   @r"   r8   r8   B   s2    D%%JK$$d dr!   r8   c                      e Zd Zed        Zy)_NoTimerc                      y r1   r    r    r!   r"   r[   z_NoTimer.cancel   s    r!   N)r   r   r   staticmethodr[   r    r!   r"   r~   r~      s     r!   r~   T_AsyncSocket)boundc                  L    e Zd ZU dZdZdZded<   eZdZ		 	 	 	 d(	 	 	 d) fdZ
ed*d+d       Zd*d, fdZej                  j                  j                   e_         fdZej                  j"                  j                   e_        e	 d-d	d
	 	 	 	 	 d.d       Ze	 d-d	d
	 	 	 	 	 	 	 d/d       Ze	 d-d	d
	 	 	 	 	 	 	 d0d       Ze	 d1	 	 	 	 	 	 	 d2d       Z	 d1	 	 	 	 	 	 	 d2dZed-d	d
d3d       Ze	 d-d	d
	 	 	 	 	 	 	 d4d       Ze	 d-d	d
	 	 	 	 	 	 	 d5d       Z	 d1	 	 	 	 	 	 	 d6dZ	 d1	 	 	 	 	 	 	 d7dZ	 	 	 d1	 	 	 	 	 	 	 	 	 	 	 d8dZd Zdej0                  fd9dZd: fdZ	 d;	 	 	 	 	 	 	 d< fdZd Zd Zed*d       Zd=dZ d>dZ!d Z"d  Z#d?d!Z$d*d"Z%d# Z&d$ Z'd% Z(d*d&Z)d' Z* xZ+S )@r   Nr   _zmq.Socket_shadow_sockc                   t        |t        j                        rd |}}|"t        |   |j
                         || _        n?t        |   ||fi | t        j                  j                  | j
                        | _        |3t        j                  | j                  j                   dt        d       t               | _        t               | _        d| _        | j                  j"                  | _        y )N)shadowz^(io_loop) argument is deprecated in pyzmq 22.2. The currently active loop will always be used.   )
stacklevelr   )rp   rq   rr   r_   __init__
underlyingr   r   warningswarnrc   r   DeprecationWarningr   _recv_futures_send_futures_stateFD_fd)r*   contextsocket_typeio_loop_from_socketr   rc   s         r"   r   z_AsyncSocket.__init__   s     gt{{+%)7\G#GL$;$;< ,DGWk<V< $ 2 24?? CDMM>>**+ ,B B"	 #W"W$$''r!   c                     | ||      S )z.Create an async socket from an existing Socket)r   r   r    )clsr?   r   s      r"   rs   z_AsyncSocket.from_socket   s     88r!   c                p   | j                   s| j                  ~t        t        | j                  xs g | j
                  xs g             }|D ]8  }|j                  j                         r	 |j                  j                          : | j                          t        | 1  |       y # t        $ r Y gw xY w)N)linger)closedr   listr   r   r   r   rJ   r[   r\   rR   r_   close)r*   r   
event_listeventrc   s       r"   r   z_AsyncSocket.close   s    {{txx3-1d((.B0B0B0HbI.J $ ||((*++-   "V$	 ( s   ,B))	B54B5c                Z    t         |   |      }|t        k(  r| j                  |       |S r1   )r_   getr   _schedule_remaining_events)r*   keyra   rc   s      r"   r   z_AsyncSocket.get   s+    S!&=++F3r!   F)trackc                    y r1   r    r*   flagsr   s      r"   recv_multipartz_AsyncSocket.recv_multipart       "%r!   c                    y r1   r    r*   r   copyr   s       r"   r   z_AsyncSocket.recv_multipart  r   r!   c                    y r1   r    r   s       r"   r   z_AsyncSocket.recv_multipart  s     	r!   c                     y r1   r    r   s       r"   r   z_AsyncSocket.recv_multipart  s     58r!   c                >    | j                  dt        |||            S )zvReceive a complete multipart zmq message.

        Returns a Future whose result will be a multipart message.
        r   r   r   r   ru   r   r   s       r"   r   z_AsyncSocket.recv_multipart  s%     ##dTG
 	
r!   c                    y r1   r    r   s      r"   recvz_AsyncSocket.recv'  s    PSr!   c                    y r1   r    r   s       r"   r   z_AsyncSocket.recv*  s     r!   c                    y r1   r    r   s       r"   r   z_AsyncSocket.recv/  s     !$r!   c                >    | j                  dt        |||            S )zReceive a single zmq frame.

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

        Recommend using recv_multipart instead.
        r   r   r   r   s       r"   r   z_AsyncSocket.recv4  s      ##FDu4u,UVVr!   c                H    ||d<   ||d<   ||d<   | j                  d||      S )zqSend a complete multipart zmq message.

        Returns a Future that resolves when sending is complete.
        r   r   r   send_multipartr   r   )rv   )r*   	msg_partsr   r   r   r   s         r"   r   z_AsyncSocket.send_multipart?  s8      wvw##$4)F#SSr!   c                    ||d<   ||d<   ||d<   |j                  t        |||             | j                  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   rv   )r*   datar   r   r   r   s         r"   r   z_AsyncSocket.sendK  sL      wvwdT?@##FV#DDr!   c                    | j                         fd}j                  |       fd}j                  |       S )zDeserialize with Futuresc                   j                         rBj                         s1j                         !t        j                  d d dt
               yj                         r j                  j                                yj                         }	  |      }j                  |       y# t        $ r}j                  |       Y d}~yd}~ww xY w)z+Chain result through serialization to recvdNzFuture z completed while awaiting z. A message has been dropped!)
rJ   rZ   r]   r   r   RuntimeWarningr^   ra   rK   r`   )_bufloadedrb   rA   loadrecvds       r"   _chainz)_AsyncSocket._deserialize.<locals>._chainc  s    vvx (U__->-FMM "!$>ugEbc&	   12lln)!#YF LL( ! 'OOA&&'s   B/ /	C8CCc                j    j                         ryj                         rj                          yy)z"Chain cancellation from f to recvdN)rJ   rZ   r[   )r   rA   r   s    r"   _chain_cancelz0_AsyncSocket._deserialize.<locals>._chain_cancel~  s&    zz|{{} r!   )r&   ro   )r*   r   r   r   r   rA   s    ``  @r"   _deserializez_AsyncSocket._deserialize_  s=    LLN	)2 	'	 	
M*r!   c                     j                   r#t        j                  t        j                         j	                         }|j                   |       t        t        |j                  |             j                          fd}j                         r	 |       nj                  |       fd}j                  |       S )zSpoll the socket for events

        returns a Future for the poll results.
        c                ^   j                         ry j                         r	 j                          y | j	                         r j                  j	                                y t        j                               }j                  |j                  d             y # t        $ r Y y w xY wrY   )
rJ   rZ   r[   r\   r]   r^   r   ra   rK   r   )rA   evtsr   poll_futurer*   s     r"   unwrap_resultz(_AsyncSocket.poll.<locals>.unwrap_result  s    {{}$$&MMO {{}$$[%:%:%<=K..01!!$((4"34 $ s   B   	B,+B,c                h    j                         s	 j                          yy# t        $ r Y yw xY w)z4Cancel underlying poll if request has been cancelledN)rJ   r[   r\   )r   r   s    r"   cancel_pollz&_AsyncSocket.poll.<locals>.cancel_poll  s9    ##%&&( & $ s   % 	11)r   rq   ZMQErrorENOTSUP_poller_classregisterr   r   rV   r&   rJ   ro   )r*   rx   r   pr   r   r   r   s   `     @@r"   rV   z_AsyncSocket.poll  s     ;;---- 	

46166'?3	5  +&))-8	 	  -r!   c                "    t        |   |i |S r1   )r_   recv_string)r*   rL   r   rc   s      r"   r   z_AsyncSocket.recv_string  s    w"D3F33r!   c                (    t         |   |||      S )N)r   encoding)r_   send_string)r*   rS   r   r   rc   s       r"   r   z_AsyncSocket.send_string  s     w"1EH"EEr!   c                2    fd}| j                  ||      S )z'Add a timeout for a send or recv Futurec                 n     j                         ry  j                  t        j                                y r1   )rJ   r^   rq   AgainrW   s   r"   future_timeoutz1_AsyncSocket._add_timeout.<locals>.future_timeout  s%    {{}   .r!   )_call_later)r*   r   rx   r   s    `  r"   _add_timeoutz_AsyncSocket._add_timeout  s    	/ 88r!   c                B    | j                         j                  ||      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,   rw   )r*   delaycallbacks      r"   r   z_AsyncSocket._call_later  s     ~~**5(;;r!   c                L    |sy	 |j                  |       y# t        $ r Y yw xY 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   s      r"   _remove_finished_futurez$_AsyncSocket._remove_finished_future  s/     	e$ 		s    	##c                X   |xs | j                         }|j                  d      rU|j                  dd      t        j                  z  r2t        | j                  |      }	  |d	i |}|j                  |       |S t        }t        t        d      r0| j                  j                  }	|	dk\  r| j                  ||	dz        }t        |||d|      }
| j                  j!                  |
       | j                  j                  t"              t$        z  r| j'                          | j                  rT|
| j                  v rF|j)                  t+        | j,                  | j                  |
             | j/                  t$               |S # t        $ r}|j                  |       Y d}~|S d}~ww xY w)
z4Add a recv event, returning the corresponding Futurer   r   r   NRCVTIMEOrg   )r   r   r   r   r    )r&   
startswithr   rq   DONTWAITgetattrr   rK   r`   r^   r~   ri   rcvtimeor   r   r   rt   r   r   _handle_recvro   r   r   _add_io_state)r*   r   r   r   rA   r   rrb   r   
timeout_ms_future_events              r"   ru   z_AsyncSocket._add_recv_event  st   $dlln??6"vzz'1'='M4,,d3D N6N QH4$**33JQ))!Z$->? %Qf$eL!!-0  (61-43E3E"E 00#11' v&A  #"" H	#s    F 	F)F$$F)c                   |xs | j                         }|dv r| j                  s|j                  dd      }|j                         }|t        j
                  z  |d<   t        | j                  |      }d}		  ||fi |}
|j                  |
       |	r| j                  r| j                          |S t        }t        t        d      rC| j                  j                  t        j                         }|dk\  r| j#                  ||dz        }t%        |||||	      }| j                  j'                  |       |j)                  t+        | j,                  | j                  |
             | j/                  t0               |S # t        j                  $ r2}|t        j
                  z  r|j                  |       nd}	Y d}~,d}~wt        $ r}|j                  |       Y d}~Od}~ww xY w)z4Add a send event, returning the corresponding Future)r   r   r   r   TFNSNDTIMEOrg   )r   r   r   r   )r&   r   r   r   rq   r   r   r   rK   r   r^   r`   r   r   r~   ri   r   r   r   rt   ro   r   r   r   r   )r*   r   r   r   r   rA   r   nowait_kwargsr   finish_earlyr   rb   r   r   r   s                  r"   rv   z_AsyncSocket._add_send_event  s   $dlln --d6H6HJJw*E"KKMM%*T]]%:M'" 4,,d3D  L .. Q %%3354$**..t}}=JQ))!Z$->? %QVER!!-0	,,--#	
 	7#O :: )4==(OOA& $)L #""#s$   6	E< <G$'F<<G$GG$c                   | j                   j                  t              t        z  syd}| j                  rA| j                  j                         \  }}}}}|j                         rd}nn| j                  rA| j                  s| j                  t               |yj                          dk(  r|j                  d       y|dk(  r| j                   j                  }n*|dk(  r| j                   j                  }nt        d|      dxx   t        j                  z  cc<   	  |di |}|j                  |       y# t        $ r}|j!                  |       Y d}~yd}~ww xY w)zHandle recv eventsNrV   r   r   zUnhandled recv event type: r   r    )r   r   r   r   r   popleftrJ   _drop_io_stater[   rK   r   r   r   rq   r   r`   r^   )	r*   rA   r   r   r   r   r   ra   rb   s	            r"   r   z_AsyncSocket._handle_recvR  s=     $$V,v5  (,(:(:(B(B(D%AtVQvvx    !!'96>LL%%$$33DV^$$))D:4(CDDw4==(	!^F^F LL   	OOA	s   $D> >	E"EE"c                   | j                   j                  t              t        z  sy d }| j                  rA| j                  j                         \  }}}}}|j                         rd }nn| j                  rA| j                  s| j                  t               |y j                          dk(  r|j                  d        y |dk(  r| j                   j                  }n*|dk(  r| j                   j                  }nt        d|      dxx   t        j                  z  cc<   	  |fi |}|j                  |       y # t        $ r}|j!                  |       Y d }~y d }~ww xY w)NrV   r   r   zUnhandled send event type: r   )r   r   r   r   r   r   rJ   r   r[   rK   r   r   r   rq   r   r`   r^   )	r*   rA   r   r   r   r   r   ra   rb   s	            r"   _handle_sendz_AsyncSocket._handle_send{  sA     $$V,w6  *.*<*<*D*D*F'AtVS%vvx    !!(96>LL%%$$33DV^$$))D:4(CDDw4==(	!#((F LL   	OOA	s   $	D? ?	E#EE#c                   | j                   j                  ry| j                   j                  t              }|t        j
                  z  r| j                          |t        j                  z  r| j                          | j                          y)z(Dispatch IO events to _handle_recv, etc.N)
r   r   r   r   rq   r   r   r   r   r   )r*   fdevents
zmq_eventss       r"   _handle_eventsz_AsyncSocket._handle_events  sf    ##&&**62
#$'')r!   c                    | j                   dk(  ry|| j                  j                  t              }|| j                   z  r| j	                  d| j
                         yy)zkSchedule a call to handle_events next loop iteration

        If there are still events to handle.
        r   N)r   r   r   r   r   r  )r*   r  s     r"   r   z'_AsyncSocket._schedule_remaining_events  sU     ;;!>&&**62FDKKQ 3 34  r!   c                    | j                   |k7  r| j                   |z  x}| _         | j                  | j                          y)zAdd io_state to poller.Nr   _update_handlerr*   states     r"   r   z_AsyncSocket._add_io_state  s5    ;;%"&++"55EDKT[[)r!   c                    | j                   |z  r| j                   | z  | _         | j                  | j                          y)z&Stop poller from watching an io_state.Nr  r	  s     r"   r   z_AsyncSocket._drop_io_state  s2    ;;++%0DKT[[)r!   c                H    |r| j                          | j                          y)zOUpdate IOLoop handler with state.

        zmq FD is always read-only.
        N)r,   r   r	  s     r"   r  z_AsyncSocket._update_handler  s     NN'')r!   c                    || j                         }|j                  | j                  | j                  | j                         | j                  d| j                         y)z#initialize the ioloop event handlerNr   )r,   add_handlerr   r  r;   r   r2   s     r"   r)   z_AsyncSocket._init_io_state  sK    <>>#D**D,?,?LD//0r!   c                    | j                   }| j                   j                  r| j                  }| j                  | j                  j	                  |       yy)zNunregister the ioloop event handler

        called once during close
        N)r   r   r   r%   remove_handler)r*   r  s     r"   rR   z_AsyncSocket._clear_io_state  sL    
 ##B)--b1 *r!   )Nrz   NN)r   z_zmq.Socket | Noner4   r5   r1   )r   ztype[T]r?   r   r   r   r4   r   )r   z
int | Noner4   r5   )r   )r   r:   r   boolr4   Awaitable[list[bytes]])r   r:   r   Literal[True]r   r  r4   r  )r   r:   r   Literal[False]r   r  r4   zAwaitable[list[_zmq.Frame]])r   TF)r   r:   r   r  r   r  r4   z)Awaitable[list[bytes] | list[_zmq.Frame]])r   r:   r   r  r4   Awaitable[bytes])r   r:   r   r  r   r  r4   r  )r   r:   r   r  r   r  r4   zAwaitable[_zmq.Frame])r   r:   r   r  r   r  r4   zAwaitable[bytes | _zmq.Frame])r   r   r   r:   r   r  r4   %Awaitable[_zmq.MessageTracker | None])r   r   r   r:   r   r  r   r  r   r   r4   r  )r4   zAwaitable[int])r4   zAwaitable[str])r   zutf-8)rS   r   r   r:   r   r   r4   zAwaitable[None])NN)NNN)r   r   ),r   r   r   r   r   r   r   r8   r   r   r   classmethodrs   r   rq   rr   r6   r   r   r   r   r   r   r   r   rV   r   r   r   r   r   r   ru   rv   r   r   r  r   r   r   r  r)   rR   r{   r|   s   @r"   r   r      s    MMF M
C +/(
 )( 
(: 9 9% KK%%--EM ++//))CK%/4%%(,%	% % %DI%%'4%=A%	% % EJ'5>B	$ 
 ?D88$(88<8	28 8
 @E	
	
$(	
8<	
	2	
 SES SDI'4=A	  $EJ$$'5$>B$	$ $
 @E	W	W$(	W8<	W	&	W HM
T
T%(
T48
T	.
T EE E 	E
 E E 
/E((T  t{{ 0f4 7>FF F03F	F
9<  "(T9v'!R&!R
*5 **	*1	2r!   )#r6   
__future__r   r   asyncior   collectionsr   	functoolsr   	itertoolsr   typingr   r	   r
   r   r   r   r   zmqrq   r   r   r   zmq._typingr   r   r$   Pollerr8   r~   r   rr   r   r    r!   r"   <module>r!     s    + #      P P P  ' ' : " <t64;; tn  C~&e264;;v. e2r!   