
    Gg1                       d dl mZ d dlZd dlZd dlZd dlZd dlmZmZ d dl	m
Z
 d dlmZ d dlmZmZ ddlmZmZmZmZ dd	lmZmZ dd
lmZmZmZmZ ej:                  dk\  r	d dlmZmZ nd dl mZmZ  ed      Z! ed      Z"e#e#e$e$f   df   Z%e#e%df   Z& G d de      Z' e
d       G d de             Z( e
d       G d dee(                Z)y)    )annotationsN)CallableMapping)	dataclass)wraps)AnyTypeVar   )BrokenResourceErrorEndOfStreamaclose_forcefullyget_cancelled_exc_class)TypedAttributeSettyped_attribute)AnyByteStream
ByteStreamListener	TaskGroup)      )TypeVarTupleUnpackT_RetvalPosArgsT.c                     e Zd ZU dZ e       Zded<    e       Zded<    e       Zded<    e       Z	ded	<    e       Z
d
ed<    e       Zded<    e       Zded<    e       Zded<    e       Zded<    e       Zded<   y)TLSAttributez5Contains Transport Layer Security related attributes.
str | Nonealpn_protocolbyteschannel_binding_tls_uniqueztuple[str, str, int]cipherz*None | dict[str, str | _PCTRTTT | _PCTRTT]peer_certificatezbytes | Nonepeer_certificate_binaryboolserver_sidez!list[tuple[str, str, int]] | Noneshared_ciphersssl.SSLObject
ssl_objectstandard_compatiblestrtls_versionN)__name__
__module____qualname____doc__r   r   __annotations__r    r!   r"   r#   r%   r&   r(   r)   r+        F/var/www/openai/venv/lib/python3.12/site-packages/anyio/streams/tls.pyr   r       s    ? !0 1M:1(7(99#2#4F 4 FUEVBV,;,=\=')K) 9H8IN5I / 1J1 !0 11&(K(r2   r   F)eqc                      e Zd ZU dZded<   ded<   ded<   ded	<   ded
<   eddddd	 	 	 	 	 	 	 	 	 	 	 dd       Z	 	 	 	 	 	 ddZddZddZ	dddZ
ddZddZedd       Zy)	TLSStreama  
    A stream wrapper that encrypts all sent data and decrypts received data.

    This class has no public initializer; use :meth:`wrap` instead.
    All extra attributes from :class:`~TLSAttribute` are supported.

    :var AnyByteStream transport_stream: the wrapped stream

    r   transport_streamr$   r)   r'   _ssl_objectzssl.MemoryBIO	_read_bio
_write_bioNT)r%   hostnamessl_contextr)   c                 K   || }|s|rt         j                  j                  nt         j                  j                  }t        j                  |      }t        t         d      r$|xj                  t         j                   z  c_        t        j                         }t        j                         }|j                  ||||      }	 | |||	||      }
|
j                  |	j                         d{    |
S 7 w)a  
        Wrap an existing stream with Transport Layer Security.

        This performs a TLS handshake with the peer.

        :param transport_stream: a bytes-transporting stream to wrap
        :param server_side: ``True`` if this is the server side of the connection,
            ``False`` if this is the client side (if omitted, will be set to ``False``
            if ``hostname`` has been provided, ``False`` otherwise). Used only to create
            a default context when an explicit context has not been provided.
        :param hostname: host name of the peer (if host name checking is desired)
        :param ssl_context: the SSLContext object to use (if not provided, a secure
            default will be created)
        :param standard_compatible: if ``False``, skip the closing handshake when
            closing the connection, and don't raise an exception if the peer does the
            same
        :raises ~ssl.SSLError: if the TLS handshake fails

        NOP_IGNORE_UNEXPECTED_EOF)r%   server_hostname)r7   r)   r8   r9   r:   )sslPurposeCLIENT_AUTHSERVER_AUTHcreate_default_contexthasattroptionsr>   	MemoryBIOwrap_bio_call_sslobject_methoddo_handshake)clsr7   r%   r;   r<   r)   purposebio_inbio_outr(   wrappers              r3   wrapzTLSStream.wrapN   s     : &,K+6''CKK<S<S  44W=K s67##(D(D'DD#--/ ))Gh * 

 - 3"
 ,,Z-D-DEEE 	Fs   C/C:1C82C:c                t  K   	 	  || }| j                   j                  r;| j                  j                  | j                   j	                                d {    |S 7 # t
        j                  $ r 	 | j                   j                  r<| j                  j                  | j                   j	                                d {  7   | j                  j                          d {  7  }| j                  j                  |       np# t        $ r | j                  j                          Y nKt        $ r@}| j                  j                          | j                   j                          t        |d }~ww xY wY n>t
        j                  $ r? | j                  j                  | j                   j	                                d {  7   Y nt
        j                  $ r@}| j                  j                          | j                   j                          t        |d }~wt
        j                   $ r}| j                  j                          | j                   j                          t#        |t
        j$                        s|j&                  r(d|j&                  v r| j(                  rt        |t        d  d }~ww xY ww)NUNEXPECTED_EOF_WHILE_READING)r:   pendingr7   sendreadr@   SSLWantReadErrorreceiver9   writer   	write_eofOSErrorr   SSLWantWriteErrorSSLSyscallErrorSSLError
isinstanceSSLEOFErrorstrerrorr)   )selffuncargsresultdataexcs         r3   rI   z TLSStream._call_sslobject_method   s
     (tH ??**//44T__5I5I5KLLL MI '' //.."33889M9M9OPPP!%!6!6!>!>!@@@D NN((. # /NN,,. 7NN,,.OO--/-367 (( I++001E1E1GHHH&& 3((*))+)s2<< ((*))+c3??3LL%Cs||%S//1s:)t31 s   J8A AJ8AJ8J34AD C"D#C&$D)J3#E2(J3*E22;E--E22J35J88AJ3 GJ3J8J3;HJ3+BJ..J33J8c                  K   | j                  | j                  j                         d{    | j                  j	                          | j
                  j	                          | j                  | j                  j                         fS 7 ^w)z
        Does the TLS closing handshake.

        :return: a tuple of (wrapped byte stream, bytes left in the read buffer)

        N)rI   r8   unwrapr9   rY   r:   r7   rU   ra   s    r3   rh   zTLSStream.unwrap   sl      ))$*:*:*A*ABBB  "!!#$$dnn&9&9&;;; 	Cs   )BB
ABc                   K   | j                   r	 | j                          d {    | j                  j                          d {    y 7 '# t        $ r  t        | j                         d {  7    w xY w7 3wN)r)   rh   BaseExceptionr   r7   acloseri   s    r3   rm   zTLSStream.aclose   sm     ##kkm##
 ##**,,, $  '(=(=>>> 	-sC   A;A AA A;A9A;A !A6.A1/A66A;c                ~   K   | j                  | j                  j                  |       d {   }|st        |S 7 wrk   )rI   r8   rU   r   )ra   	max_bytesre   s      r3   rW   zTLSStream.receive   s;     001A1A1F1F	RR	 Ss   *=;=c                l   K   | j                  | j                  j                  |       d {    y 7 wrk   )rI   r8   rX   )ra   items     r3   rT   zTLSStream.send   s(     ))$*:*:*@*@$GGGs   *424c                (  K   | j                  t        j                        }t        j                  d|      }|rMt        |j                  d            t        |j                  d      xs d      }}||fdk  rt        d|       t        d      w)NzTLSv(\d+)(?:\.(\d+))?   r
   r   )rs   r   z;send_eof() requires at least TLSv1.3; current session uses z7send_eof() has not yet been implemented for TLS streams)extrar   r+   rematchintgroupNotImplementedError)ra   r+   rv   majorminors        r3   send_eofzTLSStream.send_eof   s     jj!9!9:1;?u{{1~.EKKN4Ga0H5Eu~&)$$/=2 
 "E
 	
s   BBc                <    i  j                   j                  t        j                   j                  j
                  t        j                   j                  j                  t        j                   j                  j                  t        j                   fdt        j                   fdt        j                   fdt        j                   fdt        j                   fdt        j                   fdt        j                   j                  j                   i
S )Nc                 :     j                   j                  d      S )NFr8   getpeercertri   s   r3   <lambda>z,TLSStream.extra_attributes.<locals>.<lambda>   s    43C3C3O3OPU3Vr2   c                 :     j                   j                  d      S )NTr   ri   s   r3   r   z,TLSStream.extra_attributes.<locals>.<lambda>   s    $:J:J:V:V;r2   c                 0     j                   j                  S rk   )r8   r%   ri   s   r3   r   z,TLSStream.extra_attributes.<locals>.<lambda>   s    d.>.>.J.Jr2   c                 h     j                   j                  r j                   j                         S d S rk   )r8   r%   r&   ri   s   r3   r   z,TLSStream.extra_attributes.<locals>.<lambda>   s3    ++ 261A1A1P1P1R 22r2   c                      j                   S rk   r)   ri   s   r3   r   z,TLSStream.extra_attributes.<locals>.<lambda>       d6N6Nr2   c                      j                   S rk   )r8   ri   s   r3   r   z,TLSStream.extra_attributes.<locals>.<lambda>   s    T-=-=r2   )r7   extra_attributesr   r   r8   selected_alpn_protocolr    get_channel_bindingr!   r"   r#   r%   r&   r)   r(   r+   versionri   s   `r3   r   zTLSStream.extra_attributes   s    
##44
&&(8(8(O(O33  44!1!1!8!8))+V00 3 $$&J'' * ,,.N##%=$$d&6&6&>&>#
 	
r2   )r7   r   r%   zbool | Noner;   r   r<   zssl.SSLContext | Noner)   r$   returnr6   )rb   z&Callable[[Unpack[PosArgsT]], T_Retval]rc   zUnpack[PosArgsT]r   r   )r   ztuple[AnyByteStream, bytes]r   None)i   )ro   rw   r   r   )rq   r   r   r   r   zMapping[Any, Callable[[], Any]])r,   r-   r.   r/   r0   classmethodrP   rI   rh   rm   rW   rT   r|   propertyr   r1   r2   r3   r6   r6   <   s     $#
 $(#-1$(6'6 !	6
 6 +6 "6 
6 6p,:,CS,	,\
<-H
 
 
r2   r6   c                      e Zd ZU dZded<   ded<   dZded<   d	Zd
ed<   edd       Z	 d	 	 	 	 	 ddZ	ddZ
edd       Zy)TLSListenera  
    A convenience listener that wraps another listener and auto-negotiates a TLS session
    on every accepted connection.

    If the TLS handshake times out or raises an exception,
    :meth:`handle_handshake_error` is called to do whatever post-mortem processing is
    deemed necessary.

    Supports only the :attr:`~TLSAttribute.standard_compatible` extra attribute.

    :param Listener listener: the listener to wrap
    :param ssl_context: the SSL context object
    :param standard_compatible: a flag passed through to :meth:`TLSStream.wrap`
    :param handshake_timeout: time limit for the TLS handshake
        (passed to :func:`~anyio.fail_after`)
    zListener[Any]listenerzssl.SSLContextr<   Tr$   r)      floathandshake_timeoutc                   K   t        |       d{    t        | t                     s*t        j                  t
              j                  d|        t        | t              rt        | t                     r y7 hw)a  
        Handle an exception raised during the TLS handshake.

        This method does 3 things:

        #. Forcefully closes the original stream
        #. Logs the exception (unless it was a cancellation exception) using the
           ``anyio.streams.tls`` logger
        #. Reraises the exception if it was a base exception or a cancellation exception

        :param exc: the exception
        :param stream: the original stream

        NzError during TLS handshake)exc_info)r   r^   r   logging	getLoggerr,   	exception	Exception)rf   streams     r3   handle_handshake_errorz"TLSListener.handle_handshake_error  sr        ''' #689
 h'11,s 2 
 #y)Z=T=V-W .X 	(s   A<A:A)A<Nc                    K   t              d fd       } j                  j                  ||       d {    y 7 w)Nc                \  K   ddl m} 	  |j                        5  t        j	                  | j
                  j                         d {   }d d d                d {    y 7 # 1 sw Y   xY w7 # t        $ r%}j                  ||        d {  7   Y d }~y d }~ww xY ww)Nr
   )
fail_after)r<   r)   )	 r   r   r6   rP   r<   r)   rl   r   )r   r   wrapped_streamrf   handlerra   s       r3   handler_wrapperz*TLSListener.serve.<locals>.handler_wrapper8  s     %
. 6 67+4>>$($4$4,0,D,D ,: , &N 8 n---& 87 . ! ?11#v>>>?su   B,A; 0A-A+A-A; B,%A9&B,+A--A62A; 9B,;	B)B$BB$B,$B))B,)r   r   r   r   )r   r   serve)ra   r   
task_groupr   s   ``  r3   r   zTLSListener.serve3  s;     
 
w	. 
	. mm!!/:>>>s   5A?Ac                T   K   | j                   j                          d {    y 7 wrk   )r   rm   ri   s    r3   rm   zTLSListener.acloseJ  s     mm""$$$s   (&(c                .     t         j                   fdiS )Nc                      j                   S rk   r   ri   s   r3   r   z.TLSListener.extra_attributes.<locals>.<lambda>P  r   r2   )r   r)   ri   s   `r3   r   zTLSListener.extra_attributesM  s     ,,.N
 	
r2   )rf   rl   r   r   r   r   rk   )r   zCallable[[TLSStream], Any]r   zTaskGroup | Noner   r   r   r   )r,   r-   r.   r/   r0   r)   r   staticmethodr   r   rm   r   r   r1   r2   r3   r   r      s}    "  $$!u! D (,?+? %? 
	?.% 
 
r2   r   )*
__future__r   r   ru   r@   syscollections.abcr   r   dataclassesr   	functoolsr   typingr   r	   r   r   r   r   r   _core._typedattrr   r   abcr   r   r   r   version_infor   r   typing_extensionsr   r   tupler*   _PCTRTT_PCTRTTTr   r6   r   r1   r2   r3   <module>r      s    "  	 
 
 - !    B @ @w++6:
#
c3h$
%#)$ )8 e{

 {
 {
| eU
(9% U
 U
r2   