g| JUdZddlZddlZddlmZmZmZmZddlm Z m Z ddl m Z m Z mZmZmZmZmZdZdZd Zd Zd Zej0d Zej0d Zej0dZej0dZej0dZej0dZej0dZGddZ GddZ!GddZ"Gdde!e Z#Gdde"e Z$Gdde Z%Gdd e Z&Gd!d"e!e Z'Gd#d$e Z(Gd%d&e Z)Gd'd(e Z*Gd)d*e!e"e Z+Gd+d,e Z,Gd-d.e Z-Gd/d0e Z.d1e e/d2e0fd3Z1e#e+e$e%e&e'e(e)e*e,e-g Z2eee e3d4<e2Dcic]}|jh|c}Z5ycc}w)5z hyperframe/frame ~~~~~~~~~~~~~~~~ Defines framing logic for HTTP/2. Provides both classes to represent framed data and logic for aiding the connection when it comes to reading from the socket. N)UnknownFrameErrorInvalidPaddingErrorInvalidFrameErrorInvalidDataError)FlagFlags)OptionalTupleListIterableAnyDictTypei@iz has-streamz no-streameitherz>HBBBLz>LLz>HLz>LBz>Lz>Hz>Bc eZdZUdZgZeeed<dZe e ed<dZ e e ed<dde de e ddfd Zde fd Zde fd Zed edede ffd Zeddededede ffdZde defdZdefdZdefdZd eddfdZy)Framez/ The base class for all HTTP/2 frames. defined_flagsNtypestream_association stream_idflagsreturnc||_t|j|_d|_|D]}|jj ||js@|j tk(r-tdjt|j|jrL|j tk(r8tdjt|j|jyy)Nrz!Stream ID must be non-zero for {}z/Stream ID must be zero for {} with stream_id={}) rr rrbody_lenaddr_STREAM_ASSOC_HAS_STREAMrformatr__name___STREAM_ASSOC_NO_STREAM)selfrrflags E/var/www/openai/venv/lib/python3.12/site-packages/hyperframe/frame.py__init__zFrame.__init__8s#4--.  D JJNN4   " "&> >"3::J''  NN  " "&= ="AHHJ''NN  > cdjt|j|jt |j |j S)Nz{}(stream_id={}, flags={}): {})rrrrreprr _body_reprr!s r#__repr__zFrame.__repr__Vs> , & J   NN   OO    r%c4t|jSN)_raw_data_reprserialize_bodyr)s r#r(zFrame._body_repr`sd11344r%datactj|dd\}}|j|dd|zt|||fS)a> Takes a bytestring and tries to parse a single frame and print it. This function is only provided for debugging purposes. :param data: A memoryview object containing the raw data of at least one complete frame (header and body). .. versionadded:: 6.0.0 N )rparse_frame_header parse_bodyprint)r/framelengths r#explainz Frame.explainesH00bq: v aF +, e f}r%headerstrictcN tj|}|ddz|dz}|d}|d}|ddz} t ||}|j|||fS#tj$r t dwxYw#t $r|r t||t|| }Y]wxYw) a Takes a 9-byte frame header and returns a tuple of the appropriate Frame object and the length that needs to be read from the socket. This populates the flags field, and determines how long the body is. :param header: A memoryview object containing the 9-byte frame header data of a frame. Must not contain more or less. :param strict: Whether to raise an exception when encountering a frame not defined by spec and implemented by hyperframe. :raises hyperframe.exceptions.UnknownFrameError: If a frame of unknown type is received. .. versionchanged:: 5.0.0 Added :param:`strict` to accommodate :class:`ExtensionFrame` zInvalid frame headerrr)rr) _STRUCT_HBBBLunpackstructerrorrFRAMESKeyErrorrExtensionFrame parse_flags)r8r9fieldsr6rrrr5s r#r2zFrame.parse_frame_headervs( <"))&1F )q.F1I-ayq 1I *  C4L+E % v#|| <#$:; ; < C'f55" BE CsAA=A:=$B$#B$ flag_bytec|jD]&\}}||zs |jj|(|jSr,)rrr)r!rIr"flag_bits r#rGzFrame.parse_flagss:"00ND(8# t$1zzr%c:|j}t||_d}|jD]\}}||jvs||z}t j |jdz dz|jdz|j||jdz}||zS)zk Convert a frame into a bytestring, representing the serialized form of the frame. rr;r?) r.lenrrrr@packrr)r!bodyrr"rKr8s r# serializezFrame.serializes ""$D  "00ND(tzz!!1## ]]a 6 ) MMD II  NNZ '  }r%ctr,NotImplementedErrorr)s r#r.zFrame.serialize_bodys !##r%ct)a Given the body of a frame, parses it into frame data. This populates the non-header parts of the frame: that is, it does not populate the stream ID or flags. :param data: A memoryview object containing the body data of the frame. Must not contain *more* data than the length returned by :meth:`parse_frame_header `. rTr!r/s r#r3zFrame.parse_bodys "##r%))F)r __module__ __qualname____doc__rr r__annotations__rr intrstrr r$r*r( staticmethod memoryviewr r7boolr2r rGbytesrRr.r3rXr%r#rr*s !#M4:"D(3-)- ,#hsmT< # 5C5 jU7C<%8 &:&t&gWZlH[&&PSU54$$ $z $d $r%rc heZdZdZd dedededdffd ZdefdZd e defd Z e defd Z xZ S) Paddingz Mixin for frames that contain padding. Defines extra fields that can be used and set by frames that can be padded. r pad_lengthkwargsrNc 4t||fi|||_yr,)superr$re)r!rrerf __class__s r#r$zPadding.__init__ -f-%r%c^d|jvrtj|jSy)NPADDEDr%)r _STRUCT_BrPrer)s r#serialize_padding_datazPadding.serialize_padding_datas$ tzz !>>$//2 2r%r/cd|jvr# tjd|ddd|_yy#tj$r t dwxYw)Nrlz!BrrzInvalid Padding data)rrBrArerCrrWs r#parse_padding_datazPadding.parse_padding_datas\ tzz ! @"(--d2Ah"?"B<< @'(>?? @s !3AcNddl}|jdt|jS)Nrz:total_padding contains the same information as pad_length.)warningswarnDeprecationWarningre)r!rrs r# total_paddingzPadding.total_paddings# H  r%r)rrYrZr[r]rr$rbrnr`rppropertyru __classcell__ris@r#rdrdsc%#%3%c%d%  zcsr%rdc `eZdZdZ d dedededededdf fd Zdefd Z d e defd Z xZ S)Priorityz Mixin for frames that contain priority data. Defines extra fields that can be used and set by frames that contain priority data. r depends_on stream_weight exclusiverfrNc Pt||fi|||_||_||_yr,)rhr$r|r}r~)r!rr|r}r~rfris r#r$zPriority.__init__s3 -f-%+#r%cxtj|j|jrdndz|jS)Nlr) _STRUCT_LBrPr|r~r}r)s r#serialize_priority_dataz Priority.serialize_priority_data s0 OOT^^z C     r%r/c tj|dd\|_|_|jdz rdnd|_|xjdzc_y#tj $r t dwxYw)NzInvalid Priority dataTFr?)rrAr|r}rBrCrr~rWs r#parse_priority_datazPriority.parse_priority_dataso =2<2C2CD!H2M /DOT/"&B!6E :% || =#$;< < =s %AA4)rrF) rrYrZr[r]rarr$rbrr`rrxrys@r#r{r{so $'&)#( ## #!$#! #  # $( #"   sr%r{c eZdZdZeddeddgZdZeZdde de d e d d ffd Z d e fd Z ded d fdZed e fdZxZS) DataFramez DATA frames convey arbitrary, variable-length sequences of octets associated with a stream. One or more DATA frames are used, for instance, to carry HTTP request or response payloads. END_STREAMrrlr;rrr/rfrNc 4t||fi|||_yr,rhr$r/r!rr/rfris r#r$zDataFrame.__init__. -f- r%c|j}d|jz}t|jtr|jj |_dj ||j|gSNr%)rnre isinstancer/r`tobytesjoin)r! padding_datapaddings r#r.zDataFrame.serialize_body4sZ224 $//) dii , ))+DIxxtyy':;;r%c|j|}||t||jz j|_t||_|jr%|j|j k\r t dyy)NPadding is too long.)rprOrerr/rrr!r/padding_data_lengths r#r3zDataFrame.parse_body;sr"55d; $SYt%> ? G G I D  ??t$--?%&<= = @?r%cpd}d|jvr|jdz}t|j|zS)zo The length of the frame that needs to be accounted for when considering flow control. rrlr)rrerOr/)r! padding_lens r#flow_controlled_lengthz DataFrame.flow_controlled_lengthEs8  tzz !//A-K499~ ++r%r%)rrYrZr[rrrrrr]rbrr$r.r`r3rwrrxrys@r#rrs \4  XtM D1#UCD <<>z>d> , , ,r%rcVeZdZUdZgZeeed<dZe Z de fdZ de fdZdeddfd Zy) PriorityFramez The PRIORITY frame specifies the sender-advised priority of a stream. It can be sent at any time for an existing stream. This enables reprioritisation of existing streams. rr<rcddj|j|j|jS)Nz-exclusive={}, depends_on={}, stream_weight={})rr~r|r}r)s r#r(zPriorityFrame._body_repras,>EE NN OO     r%c"|jSr,)rr)s r#r.zPriorityFrame.serialize_bodyhs++--r%r/Nc~t|dkDrtdt|z|j|d|_y)Nrz1PRIORITY must have 5 byte body: actual length %s.)rOrrrrWs r#r3zPriorityFrame.parse_bodyks@ t9q=#CD     & r%)rrYrZr[rr rr\rrrr^r(rbr.r`r3rXr%r#rrSsO !#M4:" D1 C ..zdr%rc |eZdZUdZgZeeed<dZe Z dde de de ddffd Z defd Zdefd Zd eddfd ZxZS)RstStreamFramea The RST_STREAM frame allows for abnormal termination of a stream. When sent by the initiator of a stream, it indicates that they wish to cancel the stream or that an error condition has occurred. When sent by the receiver of a stream, it indicates that either the receiver is rejecting the stream, requesting that the stream be cancelled or that an error condition has occurred. rr=r error_coderfrNc 4t||fi|||_yr,)rhr$r)r!rrrfris r#r$zRstStreamFrame.__init__rjr%c8dj|jS)Nz error_code={})rrr)s r#r(zRstStreamFrame._body_reprs%% OO  r%c@tj|jSr,) _STRUCT_LrPrr)s r#r.zRstStreamFrame.serialize_bodys~~doo..r%r/ct|dk7rtdt|z tj|d|_d|_y#t j $r tdwxYw)Nr>z3RST_STREAM must have 4 byte body: actual length %s.rzInvalid RST_STREAM body)rOrrrArrBrCrrWs r#r3zRstStreamFrame.parse_bodyso t9>#ED    ?'..t4Q7DO || ?#$=> > ?s A A+rv)rrYrZr[rr rr\rrrr]rr$r^r(rbr.r`r3rxrys@r#rrvsq!#M4:" D1%#%3%c%d%  C // z d r%rc eZdZdZeddgZdZeZdZ dZ dZ dZ dZ dZd Zdd ed eeeefd edd ffd ZdefdZdefdZdedd fdZxZS) SettingsFramea  The SETTINGS frame conveys configuration parameters that affect how endpoints communicate. The parameters are either constraints on peer behavior or preferences. Settings are not negotiated. Settings describe characteristics of the sending peer, which are used by the receiving peer. Different values for the same setting can be advertised by each peer. For example, a client might set a high initial flow control window, whereas a server might set a lower value to conserve resources. ACKrr>r<r=rr;Nrsettingsrfrc ~t||fi||rd|jddvr td|xsi|_y)NrrrXz*Settings must be empty if ACK flag is set.)rhr$getrr)r!rrrfris r#r$zSettingsFrame.__init__sG -f- GR!88"<  !B r%c8dj|jS)Nz settings={})rrr)s r#r(zSettingsFrame._body_reprs## MM  r%c dj|jjDcgc]\}}tj |dz| c}}Scc}}w)Nr%rN)rritems _STRUCT_HLrP)r!settingvalues r#r.zSettingsFrame.serialize_bodysXxx/3}}/B/B/DF/D^We$4?/DFG GFs#A r/c\d|jvr%t|dkDrtdt|zd}tdt|dD]5} tj |||dz\}}||j|<|dz }7||_ y#t j$r tdwxYw)Nrrz6SETTINGS ack frame must not have payload: got %s bytesrzInvalid SETTINGS body) rrOrrangerrArBrCrrr)r!r/rinamers r#r3zSettingsFrame.parse_bodys DJJ 3t9q="HD   q#d)Q'A A(//Qqs < e#(DMM$  MH(! << A'(?@@ As B  B+)rN)rrYrZr[rrrr rHEADER_TABLE_SIZE ENABLE_PUSHMAX_CONCURRENT_STREAMSINITIAL_WINDOW_SIZEMAX_FRAME_SIZEMAX_HEADER_LIST_SIZEENABLE_CONNECT_PROTOCOLr]r rrr$r^r(rbr.r`r3rxrys@r#rrs %&'M D0 K!N" '# 'Xd38n5M '`c 'hl ' C GG!z!d!r%rc eZdZdZeddeddgZdZeZdde de d e d e d d f fd Z d e fdZd e fdZd ed d fdZxZS)PushPromiseFramez~ The PUSH_PROMISE frame is used to notify the peer endpoint in advance of streams the sender intends to initiate. END_HEADERSr>rlr;rrpromised_stream_idr/rfrNc Bt||fi|||_||_yr,)rhr$rr/)r!rrr/rfris r#r$zPushPromiseFrame.__init__s( -f-#5 r%c`dj|jt|jS)Nzpromised_stream_id={}, data={})rrr-r/r)s r#r(zPushPromiseFrame._body_repr s*/66  # # 499 %  r%c|j}d|jz}tj|j}dj |||j |gSr)rnrerrPrrr/)r!rrr/s r#r.zPushPromiseFrame.serialize_bodysN224 $//)~~d556xxtTYY@AAr%c|j|} tj|||dzd|_||dzt||jz j|_ t||_ |jdk(s|jdzdk7rtd|jz|jr%|j|jk\r tdyy#tj $r t dwxYw)Nr>rzInvalid PUSH_PROMISE bodyr<z+Invalid PUSH_PROMISE promised stream id: %sr)rprrArrBrCrrOrerr/rrrrs r#r3zPushPromiseFrame.parse_bodys"55d; A&/&6&6()z>d>r%rc zeZdZdZeddgZdZeZdde de de dd ffd Z de fd Zde fd Zd edd fdZxZS) PingFramez The PING frame is a mechanism for measuring a minimal round-trip time from the sender, as well as determining whether an idle connection is still functional. PING frames can be sent from any endpoint. rrrr opaque_datarfrNc 4t||fi|||_yr,)rhr$r)r!rrrfris r#r$zPingFrame.__init__>s -f-'r%c8dj|jS)Nzopaque_data={!r})rrr)s r#r(zPingFrame._body_reprDs!((     r%ct|jdkDrtd|jz|j}|ddt|jz zz }|S)Nr;z9PING frame may not have more than 8 bytes of data, got %rr)rOrrrWs r#r.zPingFrame.serialize_bodyIsd t 1 $#K  !   1s4#3#34455 r%r/ct|dk7rtdt|z|j|_d|_y)Nr;z*PING frame must have 8 byte length: got %s)rOrrrrrWs r#r3zPingFrame.parse_bodyTs= t9># r%r)rrYrZr[rrrr rr]rbrr$r^r(r.r`r3rxrys@r#rr0ss %&'M D0'#''s'W['  C  zdr%rc eZdZUdZgZeeed<dZe Z dde de de de de d d f fd Zd efd Zd e fd Zded d fdZxZS) GoAwayFramez The GOAWAY frame informs the remote peer to stop creating streams on this connection. It can be sent from the client or the server. Once sent, the sender will ignore frames sent on new streams for the remainder of the connection. rrlast_stream_idradditional_datarfrNc Pt||fi|||_||_||_yr,)rhr$rrr)r!rrrrrfris r#r$zGoAwayFrame.__init__ms4 -f--% /r%cddj|j|j|jS)Nz6last_stream_id={}, error_code={}, additional_data={!r})rrrrr)s r#r(zGoAwayFrame._body_repr~s.GNN    OO    r%c~tj|jdz|j}||jz }|SNr?) _STRUCT_LLrPrrrrWs r#r.zGoAwayFrame.serialize_bodys<   * , OO  $$$ r%r/c tj|dd\|_|_t||_t|dkDr|ddj|_ yy#tj $r t dwxYw)Nr;zInvalid GOAWAY body.) rrArrrBrCrrOrrrrWs r#r3zGoAwayFrame.parse_bodys <3=3D3DRa4 0D  D  t9q=#'8#3#3#5D   || <#$:; ; )rrrr%)rrYrZr[rr rr\rr rr]rbrr$r^r(r.r`r3rxrys@r#rr^s!#M4:" D0#$'(#$*- //!$/!/#( /  / $( /" C  6z 6d 6r%rc |eZdZUdZgZeeed<dZe Z dde de de ddffd Z defd Zdefd Zd eddfd ZxZS)WindowUpdateFramea The WINDOW_UPDATE frame is used to implement flow control. Flow control operates at two levels: on each individual stream and on the entire connection. Both types of flow control are hop by hop; that is, only between the two endpoints. Intermediaries do not forward WINDOW_UPDATE frames between dependent connections. However, throttling of data transfer by any receiver can indirectly cause the propagation of flow control information toward the original sender. rr;rwindow_incrementrfrNc 4t||fi|||_yr,)rhr$r)r!rrrfris r#r$zWindowUpdateFrame.__init__s -f-!1r%c8dj|jS)Nzwindow_increment={})rrr)s r#r(zWindowUpdateFrame._body_reprs$++  ! !  r%cFtj|jdzSr)rrPrr)s r#r.z WindowUpdateFrame.serialize_bodys~~d33j@AAr%r/c4t|dkDrtdt|z tj|d|_d|jcxkrdkstdtdd|_y#t j $r tdwxYw)Nr>z3WINDOW_UPDATE frame must have 4 byte length: got %srzInvalid WINDOW_UPDATE bodyrr?z3WINDOW_UPDATE increment must be between 1 to 2^31-1) rOrrrArrBrCrrrWs r#r3zWindowUpdateFrame.parse_bodys t9q=#ED    B$-$4$4T$:1$=D !D))4W4"E 5"E  || B#$@A A Bs A88Brv)rrYrZr[rr rr\r_STREAM_ASSOC_EITHERrr]rr$r^r(rbr.r`r3rxrys@r#rrst !#M4:" D-1#11C1TX1  C BBzdr%rc eZdZdZeddeddeddedd gZdZeZdd e d e d e d dffd Z d e fdZd e fdZd ed dfdZxZS) HeadersFramea" The HEADERS frame carries name-value pairs. It is used to open a stream. HEADERS frames can be sent on a stream in the "open" or "half closed (remote)" states. The HeadersFrame class is actually basically a data frame in this implementation, because of the requirement to control the sizes of frames. A header block fragment that doesn't fit in an entire HEADERS frame needs to be followed with CONTINUATION frames. From the perspective of the frame building code the header block is an opaque data segment. rrrr>rlr;PRIORITY rr/rfrNc 4t||fi|||_yr,rrs r#r$zHeadersFrame.__init__rr%cdj|j|j|jt |j S)Nz6exclusive={}, depends_on={}, stream_weight={}, data={})rr~r|r}r-r/r)s r#r(zHeadersFrame._body_reprs8GNN NN OO    499 %   r%c|j}d|jz}d|jvr|j}nd}dj |||j |gS)Nrrr%)rnrerrrr/)r!rr priority_datas r#r.zHeadersFrame.serialize_bodysY224 $//)  # 88:MMxx}diiIJJr%cR|j|}||d}d|jvr|j|}nd}t||_||t||j z j |_|j r%|j |jk\r tdyy)Nrrr) rprrrOrrerr/r)r!r/rpriority_data_lengths r#r3zHeadersFrame.parse_bodys"55d;'()  ##'#;#;D#A #$ D  %c$i&? @ H H J  ??t$--?%&<= = @?r%rrrys@r#rrs  \4  ]D! Xt Z M D1#UCD  C  K K>z>d>r%rc zeZdZdZeddgZdZeZdde de de dd ffd Z de fd Zde fd Zdedd fd ZxZS)ContinuationFramea The CONTINUATION frame is used to continue a sequence of header block fragments. Any number of CONTINUATION frames can be sent on an existing stream, as long as the preceding frame on the same stream is one of HEADERS, PUSH_PROMISE or CONTINUATION without the END_HEADERS flag set. Much like the HEADERS frame, hyper treats this as an opaque data frame with different flags and a different type. rr>r1rr/rfrNc 4t||fi|||_yr,rrs r#r$zContinuationFrame.__init__)rr%cJdjt|jS)Nzdata={})rr-r/r)s r#r(zContinuationFrame._body_repr/s! 499 %  r%c|jSr,)r/r)s r#r.z ContinuationFrame.serialize_body4s yyr%cN|j|_t||_yr,)rr/rOrrWs r#r3zContinuationFrame.parse_body7LLN D  r%rrrys@r#rrsr-./M D1#UCD  C "z"d"r%rc jeZdZdZdZeZddededede ddf fd Z de fd Z defd Z d eddfd ZxZS) AltSvcFramea The ALTSVC frame is used to advertise alternate services that the current host, or a different one, can understand. This frame is standardised as part of RFC 7838. This frame does no work to validate that the ALTSVC field parameter is acceptable per the rules of RFC 7838. .. note:: If the ``stream_id`` of this frame is nonzero, the origin field must have zero length. Conversely, if the ``stream_id`` of this frame is zero, the origin field must have nonzero length. Put another way, a valid ALTSVC frame has ``stream_id != 0`` XOR ``len(origin) != 0``. roriginfieldrfrNc t||fi|t|ts t dt|ts t d||_||_y)Nz!AltSvc origin must be bytestring.z"AltSvc field must be a bytestring.)rhr$rrbrrr)r!rrrrfris r#r$zAltSvcFrame.__init__OsO -f-&%("#FG G%'"#GH H  r%cNdj|j|jS)Nzorigin={!r}, field={!r})rrrr)s r#r(zAltSvcFrame._body_reprYs#(// KK JJ  r%ctjt|j}dj ||j|j gS)Nr%) _STRUCT_HrPrOrrr)r! origin_lens r#r.zAltSvcFrame.serialize_body_s7^^C $45 xxT[[$**=>>r%r/c^ tj|ddd}|dd|zj|_t |j|k7r t d|d|zdj|_t ||_ y#tjtf$r t dwxYw)Nrr<zInvalid ALTSVC frame body.) rrArrrOrrrBrC ValueErrorr)r!r/rs r#r3zAltSvcFrame.parse_bodycs B"))$q)4Q7Jq:.668DK4;;:-'(DEEa lm,446DJD   j) B#$@A A Bs A4B%B,)r%r%)rrYrZr[rrrr]rbrr$r^r(r.r`r3rxrys@r#rr<sj  D-#u5Z]bf C ?? "z "d "r%rc zeZdZdZeZddedededededdf fd Z de fd Z deddfd Z d e ddfd ZdefdZxZS)rFaM ExtensionFrame is used to wrap frames which are not natively interpretable by hyperframe. Although certain byte prefixes are ordained by specification to have certain contextual meanings, frames with other prefixes are not prohibited, and may be used to communicate arbitrary meaning between HTTP/2 peers. Thus, hyperframe, rather than raising an exception when such a frame is encountered, wraps it in a generic frame to be properly acted upon by upstream consumers which might have additional context on how to use it. .. versionadded:: 5.0.0 rrrIrQrfrNc Pt||fi|||_||_||_yr,)rhr$rrIrQ)r!rrrIrQrfris r#r$zExtensionFrame.__init__s* -f- " r%cvdj|j|jt|jS)Nztype={}, flag_byte={}, body={})rrrIr-rQr)s r#r(zExtensionFrame._body_reprs//66 II NN 499 %  r%c||_y)zW For extension frames, we parse the flags by just storing a flag byte. N)rI)r!rIs r#rGzExtensionFrame.parse_flagss #r%r/cN|j|_t||_yr,)rrQrOrrWs r#r3zExtensionFrame.parse_bodyrr%c|j}tj|jdz dz|jdz|j||j dz}||j zS)a A broad override of the serialize method that ensures that the data comes back out exactly as it came in. This should not be used in most user code: it exists only as a helper method if frames need to be reconstituted. r;rMrNr?)rIr@rPrrrrQ)r!rr8s r#rRzExtensionFrame.serializesa## ]]a 6 ) MMD II  NNZ '   !!r%r)rrYrZr[rrr]rbrr$r^r(rGr`r3rRrxrys@r#rFrFrs .SSSeehmq  C #S#T# "z"d""5"r%rFr/rc|sytj|jd}t|dkDr|dddz}d|zdzS)NNoneasciiz...z)binasciihexlifydecoderO)r/rs r#r-r-sL %%g.A 1v{ crFUN Q; r%_FRAME_CLASSES)6r[rBr exceptionsrrrrrrr typingr r r r rrr FRAME_MAX_LENFRAME_MAX_ALLOWED_LENrr rStructr@rrrrrrmrrdr{rrrrrrrrrrrrFrbr^r-rr\rrD)clss0r#rsCCC  &(% h' V]]5 ! V]]5 ! V]]5 ! FMM$  FMM$  FMM$  d$d$N""J$$N3,3,l He F+U+\J!EJ!Z<>w<>~++\;6%;6|44nA>7HeA>H""""J3"%3"l<"U<"~%S  %T%[! $2 2>C#((C-> 2 2sF