
    0RjA                        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 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j0                  Zej4                  Zej8                  Zej<                  Zej@                  Z!ejD                  Z#eeefZ$ee!e#fZ% G d dej,                        Z&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e&jb                  de&jd                  de&jf                  de&jh                  de&jj                  diZ6de7d<   e&jN                  e&jP                  e&jR                  e&jT                  e&jZ                  e&j\                  e&j^                  e&j`                  e&jb                  e&jd                  e&jf                  e&jh                  hZ8e&jN                  e&jP                  e&jV                  hZ9ejt                   G d d              Z;ejt                   G d! d"             Z<	 	 d%	 	 	 	 	 	 	 d&d#Z=dd$l>m?Z? y# e$ r
 ddlmZ Y 9w xY w)'    )annotationsN)	GeneratorSequence)Callable   )PayloadTooBigProtocolError)	BytesLike)
apply_mask)OpcodeOP_CONTOP_TEXT	OP_BINARYOP_CLOSEOP_PINGOP_PONGDATA_OPCODESCTRL_OPCODES	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     Y/var/www/html/meridian/meridian-ai/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   8   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getr=   
_data_reprlenr>   r@   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)rb   rc   r   r(   r   s     rL   c              3  $   K   | ]  }|d  
 yw)02xNr'   ).0bytes     r)   	<genexpr>z#Frame._data_repr.<locals>.<genexpr>   s      B4D: Bs   z...)r>   rN   rO   r=   r   strr   parser	   UnicodeDecodeErrorrQ   MAX_LOG_SIZEbytesis_utf8_fragmentr   r@   reprdecoderR   )rU   
data_startdata_endrX   rW   r>   rI   cuts           r)   rP   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&!%!7  ##xx   *x"7!?!?y!?!QR	 #D&!%!7#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!Qr_   )rv   )
structunpackr   
ValueErrorr	   r   r   reversedrr   check)cls
read_exactmaskrv   rw   r>   head1head2r@   rA   rB   rC   r=   excrZ   
mask_bytesframe	extensions                     r)   rl   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rw   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.

        rz   r   r{   r|   r}   r   ry   i   z!BBHz!BBQr   r_   )r   encodeioBytesIOr@   rA   rB   rC   r=   rQ   r>   writer   packsecretstoken_bytesr   getvalue)
rU   r   rw   r   outputr   r   rZ   r   r>   s
             r)   	serializezFrame.serializeC  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)	rA   rB   rC   r	   r=   r   rQ   r>   r@   rU   s    r)   r   zFrame.check  sh     99		TYY 9::;;,&499~##$<==88#$>??  'r(   returnrk   )r   ztuple[str, bool | None])
r   z9Callable[[int], Generator[None, None, bytes | bytearray]]r   r?   rv   z
int | Nonerw   %Sequence[extensions.Extension] | Noner   zGenerator[None, None, Frame])r   r?   rw   r   r   ro   r   None)r   r   r   r    __annotations__r@   rA   rB   rC   intosenvironrO   rn   r   r   r   rN   r]   rP   classmethodrl   r   r   r'   r(   r)   r   r   z   s      N
OCD$D$D$ rzz~~&?FGLi$GO>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coderk   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 ()rL   )r   r;   rO   r   )rU   explanationresults      r)   r]   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   r   Nr   rG   zclose frame too short)
isinstance
memoryviewAssertionErrorrQ   r   r   rr   r   r   r/   r	   )r   r>   r   r   closes        r)   rl   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.

        r   )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   )r>   r
   r   r   )r   ro   r   )
r   r   r   r    r   r]   r   rl   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   r`      rz   r   r_      r         z\xF)rQ   minmaxrr   rq   rm   )
r>   rb   rc   startend	max_startri   min_endseq_lenrH   s
             r)   rp   rp     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)r>   ro   rb   r?   rc   r?   r   r?   )@
__future__r   dataclassesenumr   r   r   r   collections.abcr   r   typingr   
exceptionsr   r	   r
   speedupsr   ImportErrorutils__all__IntEnumr   r!   r   r"   r   r#   r   r$   r   r%   r   r&   r   r   r   r   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r;   r   r   OK_CLOSE_CODES	dataclassr   r   rp   rG   rw   r'   r(   r)   <module>r      s   "   	 	   /  4 "$
 )T\\ ) ++
++MM	<<
++
++*') . d,. 2= =8 20!!#8.00=?+  , !! "  S@ S@ S@l J7 J7 J7^ # E'
E'E' E' 
	E'R m  "!!"s   I. .I=<I=