
    A>qjEA                       U d dl mZ d dlZd dl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mZ ddlmZmZ ddlmZ 	 ddlmZ g d	Z G d
 dej.                        Zej2                  Zej4                  Zej6                  Zej8                  Zej:                  Zej<                  ZeeefZeeefZ  G d dej.                        Z!e!jD                  de!jF                  de!jH                  de!jJ                  de!jL                  de!jN                  de!jP                  de!jR                  de!jT                  de!jV                  de!jX                  de!jZ                  de!j\                  de!j^                  de!j`                  diZ1de2d<   e!jD                  e!jF                  e!jH                  e!jJ                  e!jP                  e!jR                  e!jT                  e!jV                  e!jX                  e!jZ                  e!j\                  e!j^                  hZ3e!jD                  e!jF                  e!jL                  hZ4ejj                   G d d              Z6ejj                   G d! d"             Z7	 	 d%	 	 	 	 	 	 	 d&d#Z8dd$l9m:Z: y# e$ r
 ddlmZ Y 9w xY w)'    )annotationsN)	GeneratorSequence)CallableSelf   )PayloadTooBigProtocolError)	BytesLike)
apply_mask)Opcode	CloseCodeFrameClosec                  (    e Zd ZdZd\  ZZZd\  ZZZ	y)r   z#Opcode values for WebSocket frames.)r   r      )   	   
   N)
__name__
__module____qualname____doc__CONTTEXTBINARYCLOSEPINGPONG     P/opt/rentech/trading_bot/.venv/lib/python3.12/site-packages/websockets/frames.pyr   r      s    -)D$(E4r!   r   c                  L    e Zd ZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZdZdZdZdZdZy)r   z-Close code values for WebSocket close frames.i  i  i  i  i  i  i  i  i  i  i  i  i  i  i  N)r   r   r   r   NORMAL_CLOSURE
GOING_AWAYPROTOCOL_ERRORUNSUPPORTED_DATANO_STATUS_RCVDABNORMAL_CLOSUREINVALID_DATAPOLICY_VIOLATIONMESSAGE_TOO_BIGMANDATORY_EXTENSIONINTERNAL_ERRORSERVICE_RESTARTTRY_AGAIN_LATERBAD_GATEWAYTLS_HANDSHAKEr    r!   r"   r   r   0   sT    7NJNNLONOOKMr!   r   OKz
going awayzprotocol errorzunsupported datazno status received [internal]zabnormal closure [internal]zinvalid frame payload datazpolicy violationzmessage too bigzmandatory extensionzinternal errorzservice restartztry again laterzbad gatewayz TLS handshake failure [internal]zdict[int, str]CLOSE_CODE_EXPLANATIONSc                     e Zd ZU dZded<   ded<   dZded<   d	Zded
<   d	Zded<   d	Zded<    e	e
j                  j                  dd            Zeded	ediZddZddZeddd	 	 	 	 	 	 	 	 	 dd       Zdd	 	 	 	 	 ddZddZy)r   aN  
    WebSocket frame.

    Attributes:
        opcode: Opcode.
        data: Payload data.
        fin: FIN bit.
        rsv1: RSV1 bit.
        rsv2: RSV2 bit.
        rsv3: RSV3 bit.

    Only these fields are needed. The MASK bit, payload length and masking-key
    are handled on the fly when parsing and serializing frames.

    r   opcoder   dataTboolfinFrsv1rsv2rsv3WEBSOCKETS_MAX_LOG_SIZE75c                   | j                   j                  | j                        }| j                         \  }}||k(  rdn|rdnd}t	        | j
                         dt	        | j
                        dk(  rdnd }| j                  rdnd}dj                  t        d	|||g            }| j                  j                   d
| d| dS )ax  
        Return a human-readable representation of a frame.

        This function is intended for logging and debugging. It doesn't aim to
        support round-tripping because payloads can be too long for displaying
        conveniently. Instead, it shows the beginning and the end. It's robust
        to incorrect data.

        It attempts to decode UTF-8 payloads whenever possible, even for binary
        frames and control frames, because those frequently contain UTF-8 data.
        It applies the same logic to continuation frames, because we don't know
        if they continue a text frame or a binary frame.

         textbinaryz byter   s	continuedz, N z [])
DEFAULT_IS_TEXTgetr6   
_data_reprlenr7   r9   joinfiltername)selfexpect_text	data_repris_text	data_typelength	non_finalmetadatas           r"   __str__zFrame.__str__   s     **..t{{;!__.	7%0Bvh			N#5s499~/B(LM((B	99VD9fi*HIJ++""#1YKr(1==r!   c                   | j                   s'd| j                  j                  | j                        fS | j                  t        u r+	 t        t        j                  | j                               dfS t        | j                         d| j                  z  kD  rt        | j                   dd| j                  z  dz         }t        | j                   d| j                  z  dz  d       }t        || j                  t        k7        xr t        || j                  	      }|rzt!        ||z   j#                  d
            }n[t        | j                         }t        || j                  t        k7  | j                        }|rt!        |j#                  d
            }|sr| j                   }t        |      | j                  dz  kD  r3| j                  dz  dz
  dz  }dj%                  |dd|z   d|| d g      }dj%                  d |D              }t              | j                  kD  r$| j                  dz  dz
  }|dd|z   dz   || d z   }||fS # t        t        f$ r Y w xY w)z
        Return a human-readable representation of the payload.

        Also returns whether the payload is text.

        The representation is elided to fit ``MAX_LOG_SIZE``.

        This is a helper for the __str__ method.

        z''T   Nr      )must_start_clean)must_end_cleanreplace)errors)r[   r\   r   r!   r   s     rE   c              3  $   K   | ]  }|d  
 yw)02xNr    ).0bytes     r"   	<genexpr>z#Frame._data_repr.<locals>.<genexpr>   s      B4D: Bs   z...)r7   rG   rH   r6   r   strr   parser
   UnicodeDecodeErrorrJ   MAX_LOG_SIZEbytesis_utf8_fragmentr   r9   reprdecoderK   )rN   
data_startdata_endrQ   rP   r7   rB   cuts           r"   rI   zFrame._data_repr   sT    yy--11$++>>>
 ;;%5;;tyy12D88 tyy>A 1 111 tyy)E1t/@/@+@A+EFGJTYYrD,=,='='B'DEFH&!%!4  ##xx   *x"7!?!?y!?!QR	 #D&!%!4#xxG
  I!>?	
 YYF6{T..!33((A-1a76)AG#4k63$%="QR B6 BBI y>D---##q(1,C!)AG,u4y#7GGI'!!e "#56 s   )I I I N)max_size
extensionsc             #    K    |d      E d{   }t        j                  d|      \  }}|dz  rdnd}|dz  rdnd}	|dz  rdnd}
|d	z  rdnd}	 t        |d
z        }|dz  rdnd|k7  rt	        d      |dz  }|dk(  r) |d      E d{   }t        j                  d|      \  }n-|dk(  r( |d      E d{   }t        j                  d|      \  }|||kD  rt        ||      |r |d      E d{   } ||      E d{   }|rt        |      } | ||||	|
|      }|g }t        |      D ]  }|j                  ||      } |j                          |S 7 Q# t        $ r}t	        d      |d}~ww xY w7 7 7 7 ~w)a  
        Parse a WebSocket frame.

        This is a generator-based coroutine.

        Args:
            read_exact: Generator-based coroutine that reads the requested
                bytes or raises an exception if there isn't enough data.
            mask: Whether the frame should be masked i.e. whether the read
                happens on the server side.
            max_size: Maximum payload size in bytes.
            extensions: List of extensions, applied in reverse order.

        Raises:
            EOFError: If the connection is closed without a full WebSocket frame.
            PayloadTooBig: If the frame's payload size exceeds ``max_size``.
            ProtocolError: If the frame contains incorrect values.

        r   N!BB   TF@             zinvalid opcodezincorrect masking   ~   !Hr   z!QrX   )ro   )
structunpackr   
ValueErrorr
   r	   r   reversedrk   check)cls
read_exactmaskro   rp   r7   head1head2r9   r:   r;   r<   r6   excrS   
mask_bytesframe	extensions                     r"   re   zFrame.parse   s    : %Q-'}}UD1u j(dez)tuz)tuz)tu	;EJ./F J&DEd: 344#S=(m+DdD1IVs](m+DdD1IVFX$511$.qM1J %V,,dJ/DFD#tT48J!*- 	?I$$UX$>E	? 	W (  	; 01s:	; , ,
 2 -sw   FEAFE" ,FE?-F9F:<F6F7FFAF"	E<+E77E<<FFFFrp   c               F   | j                          |g }|D ]  }|j                  |       }  t        j                         }| j                  rdnd| j
                  rdndz  | j                  rdndz  | j                  rdndz  | j                  z  }|rdnd}t        | j                        }|dk  r*|j                  t        j                  d|||z               nZ|dk  r+|j                  t        j                  d	||dz  |             n*|j                  t        j                  d
||dz  |             |r&t        j                  d      }|j                  |       |rt!        | j                        }	n| j                  }	|j                  |	       |j#                         S )aH  
        Serialize a WebSocket frame.

        Args:
            mask: Whether the frame should be masked i.e. whether the write
                happens on the client side.
            extensions: List of extensions, applied in order.

        Raises:
            ProtocolError: If the frame contains incorrect values.

        rs   r   rt   ru   rv   ry   rr   i   z!BBHz!BBQrx   rX   )r   encodeioBytesIOr9   r:   r;   r<   r6   rJ   r7   writer{   packsecretstoken_bytesr   getvalue)
rN   r   rp   r   outputr   r   rS   r   r7   s
             r"   	serializezFrame.serialize;  sm   $ 	

J# 	*I##D)D	*   88Z!YYzA/!YYzA/ "YYzA/ kk	 	 #
TYYC<LLUE56>BCe^LLVUECKHILLVUECKHI ,,Q/JLL$ dii4D99DT  r!   c                    | j                   s| j                  s| j                  rt        d      | j                  t
        v r;t        | j                        dkD  rt        d      | j                  st        d      yy)z
        Check that reserved bits and opcode have acceptable values.

        Raises:
            ProtocolError: If a reserved bit or the opcode is invalid.

        zreserved bits must be 0}   zcontrol frame too longzfragmented control frameN)	r:   r;   r<   r
   r6   CTRL_OPCODESrJ   r7   r9   rN   s    r"   r   zFrame.checkw  sh     99		TYY 9::;;,&499~##$<==88#$>??  'r!   returnrd   )r   ztuple[str, bool | None])
r   z9Callable[[int], Generator[None, None, bytes | bytearray]]r   r8   ro   z
int | Nonerp   %Sequence[extensions.Extension] | Noner   zGenerator[None, None, Frame])r   r8   rp   r   r   rh   r   None)r   r   r   r   __annotations__r9   r:   r;   r<   intosenvironrH   rg   r   r   r   rG   rV   rI   classmethodre   r   r   r    r!   r"   r   r   r   s      N
OCD$D$D$ rzz~~&?FGLT65%>O>2F"P   $<@GMG 	G
 G :G 
&G GZ =A	:! :! :	:!
 
:!x@r!   r   c                  P    e Zd ZU dZded<   ded<   ddZedd       ZddZdd	Z	y
)r   z
    Code and reason for WebSocket close frames.

    Attributes:
        code: Close code.
        reason: Close reason.

    zCloseCode | intcoderd   reasonc                   d| j                   cxk  rdk  rn nd}n;d| j                   cxk  rdk  rn nd}n t        j                  | j                   d      }| j                    d| d}| j                  r| d	| j                   }|S )
zU
        Return a human-readable representation of a close code and reason.

          i  
registered  zprivate useunknownz ()rE   )r   r4   rH   r   )rN   explanationresults      r"   rV   zClose.__str__  s|    
 499#t#&KTYY%%'K155diiKKII;bQ/;;xq.Fr!   c                F   t        |t              rt        d      t        |      dk\  rIt	        j
                  d|dd       \  }|dd j                         } | ||      }|j                          |S t        |      dk(  r | t        j                  d      S t        d      )z
        Parse the payload of a close frame.

        Args:
            data: Payload of the close frame.

        Raises:
            ProtocolError: If data is ill-formed.
            UnicodeDecodeError: If the reason isn't valid UTF-8.

        z.only compressed outgoing frames use memoryviewr   rz   Nr   r@   zclose frame too short)
isinstance
memoryviewAssertionErrorrJ   r{   r|   rk   r   r   r(   r
   )r   r7   r   r   closes        r"   re   zClose.parse  s     dJ' !QRRt9>mmD$r(3GT!"X__&Ff%EKKMLY!^y//44 788r!   c                    | j                          t        j                  d| j                        | j                  j                         z   S )z:
        Serialize the payload of a close frame.

        rz   )r   r{   r   r   r   r   r   s    r"   r   zClose.serialize  s4    
 	

{{4+dkk.@.@.BBBr!   c                    | j                   t        v s-d| j                   cxk  rdk  st        d       t        d      yy)z
        Check that the close code has a valid value for a close frame.

        Raises:
            ProtocolError: If the close code is invalid.

        r   r   zinvalid status codeN)r   EXTERNAL_CLOSE_CODESr
   r   s    r"   r   zClose.check  sH     		11TTYY5M5M 566 6N 566 6N1r!   Nr   )r7   r   r   r   )r   rh   r   )
r   r   r   r   r   rV   r   re   r   r   r    r!   r"   r   r     s8     K$ 9 92C	7r!   r   c                   dt        |       }}|s.t        dt        |             }||k  r| |   }|dz  dk(  r|dz  }	 |s|dz  }t        t        |       dz
  |      }||k\  r^| |   }|dz  dk(  r|dz  }|dz  dk(  rd}n#|dz  dk(  rd}n|d	z  dk(  rd}n|d
z  d	k(  rd}nd}|t        |       |z
  k  rt        |       }	 	 | || j                         }	dt	        |	      vS # t
        $ r Y yw xY w)z*Guess if data is a fragment of UTF-8 text.r   rY      rs   r   rX      r         z\xF)rJ   minmaxrk   rj   rf   )
r7   r[   r\   startend	max_startrb   min_endseq_lenrA   s
             r"   ri   ri     sI    CI3E3t9%	i;D j J.
qc$i!mU+Wn9Dj J.q j J.
"j0
"j0
"j0  #d)c/)$i'E#%%'
 DJ&&	  s   C! !	C-,C-r   )FF)r7   rh   r[   r8   r\   r8   r   r8   );
__future__r   dataclassesenumr   r   r   r{   collections.abcr   r   typingr   r   
exceptionsr	   r
   r   speedupsr   ImportErrorutils__all__IntEnumr   r   r   r   r   r   r   DATA_OPCODESr   r   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r4   r   r   OK_CLOSE_CODES	dataclassr   r   ri   r@   rp   r    r!   r"   <module>r      s   "   	 	   / ! 4 "$
)T\\ ) {{{{	{{{{T6!dD  . d,. 2= =8 20!!#8.00=?+  , !! "  S@ S@ S@l J7 J7 J7^ # E'
E'E' E' 
	E'R ]  "!!"s   I0 0I?>I?