.PhtdZddlZddlZ ddlmZn#e$rGddZYnwxYw ddlmZed Zn#e $r e ZYnwxYwd Z d Z d Z Gd dZGddejZGddeZGddeZGddejeZGddZGddeZGddeZGddeZdS)asAt its heart, Python can be viewed as an extension of the C programming language. Springing from the most popular systems programming language has made Python itself a great language for systems programming. One key to success in this domain is Python's very serviceable :mod:`socket` module and its :class:`socket.socket` type. The ``socketutils`` module provides natural next steps to the ``socket`` builtin: straightforward, tested building blocks for higher-level protocols. The :class:`BufferedSocket` wraps an ordinary socket, providing a layer of intuitive buffering for both sending and receiving. This facilitates parsing messages from streams, i.e., all sockets with type ``SOCK_STREAM``. The BufferedSocket enables receiving until the next relevant token, up to a certain size, or until the connection is closed. For all of these, it provides consistent APIs to size limiting, as well as timeouts that are compatible with multiple concurrency paradigms. Use it to parse the next one-off text or binary socket protocol you encounter. This module also provides the :class:`NetstringSocket`, a pure-Python implementation of `the Netstring protocol`_, built on top of the :class:`BufferedSocket`, serving as a ready-made, production-grade example. Special thanks to `Kurt Rose`_ for his original authorship and all his contributions on this module. Also thanks to `Daniel J. Bernstein`_, the original author of `Netstring`_. .. _the Netstring protocol: https://en.wikipedia.org/wiki/Netstring .. _Kurt Rose: https://github.com/doublereedkurt .. _Daniel J. Bernstein: https://cr.yp.to/ .. _Netstring: https://cr.yp.to/proto/netstrings.txt N)RLockceZdZdZdZdZdS)rz/Dummy reentrant lock for builds without threadscdSNselfs S/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/boltons/socketutils.py __enter__zRLock.__enter__K DcdSrr)r exctypeexcinstexctbs r __exit__zRLock.__exit__Nr r N)__name__ __module__ __qualname____doc__r rrr r rrIs899        r r) make_sentinel_UNSET)var_name il ceZdZdZeeefdZdZdZdZ dZ dZ dZ d efd Z efd Zeefd Zeed fdZefdZd efdZd efdZdZdZdZdZddZdZedZedZedZdZdZdZ dS) BufferedSocketa Mainly provides recv_until and recv_size. recv, send, sendall, and peek all function as similarly as possible to the built-in socket API. This type has been tested against both the built-in socket type as well as those from gevent and eventlet. It also features support for sockets with timeouts set to 0 (aka nonblocking), provided the caller is prepared to handle the EWOULDBLOCK exceptions. Args: sock (socket): The connected socket to be wrapped. timeout (float): The default timeout for sends and recvs, in seconds. Set to ``None`` for no timeout, and 0 for nonblocking. Defaults to *sock*'s own timeout if already set, and 10 seconds otherwise. maxsize (int): The default maximum number of bytes to be received into the buffer before it is considered full and raises an exception. Defaults to 32 kilobytes. recvsize (int): The number of bytes to recv for every lower-level :meth:`socket.recv` call. Defaults to *maxsize*. *timeout* and *maxsize* can both be overridden on individual socket operations. All ``recv`` methods return bytestrings (:class:`bytes`) and can raise :exc:`socket.error`. :exc:`Timeout`, :exc:`ConnectionClosed`, and :exc:`MessageTooLong` all inherit from :exc:`socket.error` and exist to provide better error messages. Received bytes are always buffered, even if an exception is raised. Use :meth:`BufferedSocket.getrecvbuffer` to retrieve partial recvs. BufferedSocket does not replace the built-in socket by any means. While the overlapping parts of the API are kept parallel to the built-in :class:`socket.socket`, BufferedSocket does not inherit from socket, and most socket functionality is only available on the underlying socket. :meth:`socket.getpeername`, :meth:`socket.getsockname`, :meth:`socket.fileno`, and others are only available on the underlying socket that is wrapped. Use the ``BufferedSocket.sock`` attribute to access it. See the examples for more information on how to use BufferedSockets with built-in sockets. The BufferedSocket is threadsafe, but consider the semantics of your protocol before accessing a single socket from multiple threads. Similarly, once the BufferedSocket is constructed, avoid using the underlying socket directly. Only use it for operations unrelated to messages, e.g., :meth:`socket.getpeername`. c||_d|_g|_t||_|t urE|j t|_n=|j|_n|||_nt||_|t ur |j|_ nt||_ t|_ t|_ dS)Nr )sockrbufsbufintmaxsizer gettimeoutDEFAULT_TIMEOUTtimeoutfloat _recvsizer _send_lock _recv_lock)r rr&r#recvsizes r __init__zBufferedSocket.__init__s   7|| f  y##%%-. #y3355 & $W~~ v  !\DNN ]]DN''''r c||_dS)z ' ' 'g&&& '4yy4"&uu+tDEE{di# ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;$ s6A"D17D1D16CD1C550D11D58D5c|j5t|j|kr|jd|cdddS|||}||jz|_dddn #1swxYwY|S)aReturns *size* bytes from the socket and/or internal buffer. Bytes are retained in BufferedSocket's internal recv buffer. To only see bytes in the recv buffer, use :meth:`getrecvbuffer`. Args: size (int): The exact number of bytes to peek at timeout (float): The timeout for this operation. Can be 0 for nonblocking and None for no timeout. Defaults to the value set in the constructor of BufferedSocket. If the appropriate number of bytes cannot be fetched from the buffer and socket before *timeout* expires, then a :exc:`Timeout` will be raised. If the connection is closed, a :exc:`ConnectionClosed` will be raised. Nr.)r*r@r recv_size)r rDr&rFs r peekzBufferedSocket.peeks _ ) )49~~%%y$' ) ) ) ) ) ) ) )>>$>88Dty(DI  ) ) ) ) ) ) ) ) ) ) ) ) ) ) )  s'A.&A..A25A2cj|j5|tur|j}|t} ||dz|}||jz|_t |t|j}t|#t$r|jdc}|_YnwxYw dddn #1swxYwY|S)zReceive until the connection is closed, up to *maxsize* bytes. If more than *maxsize* bytes are received, raises :exc:`MessageTooLong`. Nrr ) r*rr#_RECV_LARGE_MAXSIZErIr minr@MessageTooLongConnectionClosed)r r&r#recvd size_readrGs r recv_closezBufferedSocket.recv_closes_ 0 0&  ,- 0w{G<< "DI- TY88 $Y/// $ 0 0 0!%CTYYY 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 s4B(A<AB(<BB(BB((B,/B,Fc|j5|tur|j}|t}|tur|j}t |}|j}t|j}tj }d} |s| | | || |} | dkr|r| |z } | } n| |z} nt ||krt|||rG|tj |z z } | dkrtj| | ||j} | s%t ||f}d|z}t!||| t |  |z dz} nj#tj$r:t%||_dt |d|}t'||t($rt%||_wxYwt%|d| t%|| dc}|_dddn #1swxYwY|S) a:Receive until *delimiter* is found, *maxsize* bytes have been read, or *timeout* is exceeded. Args: delimiter (bytes): One or more bytes to be searched for in the socket stream. timeout (float): The timeout for this operation. Can be 0 for nonblocking and None for no timeout. Defaults to the value set in the constructor of BufferedSocket. maxsize (int): The maximum size for the internal buffer. Defaults to the value set in the constructor. with_delimiter (bool): Whether or not to include the delimiter in the output. ``False`` by default, but ``True`` is useful in cases where one is simply forwarding the messages. ``recv_until`` will raise the following exceptions: * :exc:`Timeout` if more than *timeout* seconds expire. * :exc:`ConnectionClosed` if the underlying socket is closed by the sending end. * :exc:`MessageTooLong` if the delimiter is not found in the first *maxsize* bytes. * :exc:`socket.error` if operating in nonblocking mode (*timeout* equal to 0), or if some unexpected socket error occurs, such as operating on a closed socket. Nrrr3zCconnection closed after reading %s bytes without finding symbol: %rread z" bytes without finding delimiter: )r*rr#rLr&r@r bytearrayr timer0findrNrBrAr(rOextendbytesrC Exception)r delimiterr&r#with_delimiter len_delimiterrrPstartfind_offset_startoffset rbuf_offset cur_timeoutnxtargsmsgvals r recv_untilzBufferedSocket.recv_untils<_1 O1 O&  ,-&  , NNM9Ddi((EIKKE !  )((( F"ZZ 3DgNNF||)A"m3F*0KK*0=*@KUg--,Wi@@@5&-u1D&E &#--"(."2"22 444))DN33C4 #E I6 =?C D.s333LL%%%),S M(AA(E%/F > , , ,!%LL e****ii1gs+++   !%LL  #5&>22E% :M4N4NNCc1 O1 O1 O1 O1 O1 O1 O1 O1 O1 O1 O1 O1 O1 O1 Od s,BH< DFH<A'G997H<<IIc|j5|tur|j}g}d} tj}|j||jp|j|j}|r|t|z }||krn| ||rL|tj|z z }|dkrtj|j||j|j}|d|d|d}t|nj#tj$r4d ||_d|d|d}t||t$rd ||_wxYw||z } | r|d | || d c} |_n |dc} |_| | d d d n #1swxYwYd |S) aRead off of the internal buffer, then off the socket, until *size* bytes have been read. Args: size (int): number of bytes to read before returning. timeout (float): The timeout for this operation. Can be 0 for nonblocking and None for no timeout. Defaults to the value set in the constructor of BufferedSocket. If the appropriate number of bytes cannot be fetched from the buffer and socket before *timeout* expires, then a :exc:`Timeout` will be raised. If the connection is closed, a :exc:`ConnectionClosed` will be raised. rr3z connection closed after reading z of z requested bytesr rUz bytesN)r*rr&rWrr0r rAr(r@appendrBrOr<rCr[) r rDr&chunks total_bytesr_rdrcrf extra_byteslasts r rIzBufferedSocket.recv_sizens|_% % &  ,FK   $$W---iA49>>$.#A#A03s88+K"d**MM#&&&:&-u1D&E &#--"(."2"22 ,,[999)..88C0(3{{DDD:C*3///> , , ,HHV,, ;k;;t;;;gs+++   HHV,,  &,K +"%m |m"4c;,--6Hdii"%sdi MM$   K% % % % % % % % % % % % % % % Lxxs+G"D D)(G")A'FAG""G&)G&c .|j5|tur|j}|rtd|j}||t |dkr%dd|Dg|dd<|j |tj d}} |dr|j |d}||z }|d|d|d<|rL|tj |z z }|dkrtj|j ||dn9#tj$r't|dt |dzwxYwdddn #1swxYwY|S) a_Send the contents of the internal send buffer, as well as *data*, to the receiving end of the connection. Returns the total number of bytes sent. If no exception is raised, all of *data* was sent and the internal send buffer is empty. Args: data (bytes): The bytes to send. flags (int): Kept for API compatibility with sockets. Only the default 0 is valid. timeout (float): The timeout for this operation. Can be 0 for nonblocking and None for no timeout. Defaults to the value set in the constructor of BufferedSocket. Will raise :exc:`Timeout` if the send operation fails to complete before *timeout*. In the event of an exception, use :meth:`BufferedSocket.getsendbuffer` to see which data was unsent. znon-zero flags not supportedrr cg|]}||Srr).0ss r z'BufferedSocket.send..s$:$:$:1$:Q$:$:$:r Nrr3z%s bytes unsent)r)rr&r?r!rjr@r<rr0rWsendrBrC) r rFrEr&r!r_ total_sentsentrcs r rtzBufferedSocket.sends&_ I I&  , A !?@@@9D KK   4yy1}}88$:$:$:$:$:;;<QQQ I  ) ) ) $ Q:E I1g:9>>$q'22D$&J"1gdeenDG:&-u1D&E &#--"(."2"22 ,,[9991g:> I I Ig'83tAw<<'GHHH I+ I I I I I I I I I I I I I I I.s+B%F .BEF 6E;;F  FFc0||||S)z{A passthrough to :meth:`~BufferedSocket.send`, retained for parallelism to the :class:`socket.socket` API. )rt)r rFrEr&s r sendallzBufferedSocket.sendallsyyug...r cn|j5|ddddn #1swxYwYdS)z.Send the contents of the internal send buffer.r N)r)rtrs r flushzBufferedSocket.flushss _   IIcNNN               s *..cx|j5|j|dddn #1swxYwYdS)z0Buffer *data* bytes for the next send operation.N)r)r!rj)r rFs r bufferzBufferedSocket.buffersz _ # # I  T " " " # # # # # # # # # # # # # # #s /33c4|jS)zConvenience function to return the wrapped socket's own address. See :meth:`socket.getsockname` for more details. )r getsocknamers r r~zBufferedSocket.getsocknamesy$$&&&r c4|jS)zConvenience function to return the remote address to which the wrapped socket is connected. See :meth:`socket.getpeername` for more details. )r getpeernamers r rzBufferedSocket.getpeernames y$$&&&r Nc8||f}|||fz }|jj|S)zhConvenience function passing through to the wrapped socket's :meth:`socket.getsockopt`. )r getsockopt)r leveloptnamebuflenres r rzBufferedSocket.getsockopts2w   VI D#ty#T**r c:|j|||S)zhConvenience function passing through to the wrapped socket's :meth:`socket.setsockopt`. )r setsockopt)r rrvalues r rzBufferedSocket.setsockoptsy##E7E:::r c|jjS)zzA passthrough to the wrapped socket's type. Valid usages should only ever see :data:`socket.SOCK_STREAM`. )rtypers r rzBufferedSocket.types y~r c|jjS)aA passthrough to the wrapped socket's family. BufferedSocket supports all widely-used families, so this read-only attribute can be one of :data:`socket.AF_INET` for IP, :data:`socket.AF_INET6` for IPv6, and :data:`socket.AF_UNIX` for UDS. )rfamilyrs r rzBufferedSocket.family syr c|jjS)aaA passthrough to the wrapped socket's protocol. The ``proto`` attribute is very rarely used, so it's always 0, meaning "the default" protocol. Pretty much all the practical information is in :attr:`~BufferedSocket.type` and :attr:`~BufferedSocket.family`, so you can go back to never thinking about this. )rprotors r rzBufferedSocket.protosyr c4|jS)aReturns the file descriptor of the wrapped socket. -1 if it has been closed on this end. Note that this makes the BufferedSocket selectable, i.e., usable for operating system event loops without any external libraries. Keep in mind that the operating system cannot know about data in BufferedSocket's internal buffer. Exercise discipline with calling ``recv*`` functions. )rfilenors r rzBufferedSocket.fileno#sy!!!r c|j5|j5d|_|j|_g|jdd<|jdddn #1swxYwYdddn #1swxYwYdS)auCloses the wrapped socket, and empties the internal buffers. The send buffer is not flushed automatically, so if you have been calling :meth:`~BufferedSocket.buffer`, be sure to call :meth:`~BufferedSocket.flush` before calling this method. After calling this method, future socket operations will raise :exc:`socket.error`. r N)r*r)r rbuf_unconsumedr!rclosers r rzBufferedSocket.close/s_ " " " " '+y$! !!!  !!!  " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " s4A,9A A,A A,A A,,A03A0c|j5|j5|j|dddn #1swxYwYdddn #1swxYwYdS)aConvenience method which passes through to the wrapped socket's :meth:`~socket.shutdown`. Semantics vary by platform, so no special internal handling is done with the buffers. This method exists to facilitate the most common usage, wherein a full ``shutdown`` is followed by a :meth:`~BufferedSocket.close`. Developers requiring more support, please open `an issue`_. .. _an issue: https://github.com/mahmoud/boltons/issues N)r*r)rshutdown)r hows r rzBufferedSocket.shutdown?s_ ( ( ( ( ""3''' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( s,A7 A; A; AAAr)!rrrrrDEFAULT_MAXSIZEr,r0r$r5r8r:r=rArJrRrhrIrtrxrzr|r~rrrpropertyrrrrrrrr r rr^s811d&,(6""""4111  ''' !&&&&&P"(."(0-3F"'PPPPd'-5 5 5 5 n !&****X#$V////  ''' '''++++;;; X   X X " " " r rceZdZdZdS)ErroraA subclass of :exc:`socket.error` from which all other ``socketutils`` exceptions inherit. When using :class:`BufferedSocket` and other ``socketutils`` types, generally you want to catch one of the specific exception types below, or :exc:`socket.error`. Nrrrrrr r rrR Dr rceZdZdZdS)rOaTRaised when receiving and the connection is unexpectedly closed from the sending end. Raised from :class:`BufferedSocket`'s :meth:`~BufferedSocket.peek`, :meth:`~BufferedSocket.recv_until`, and :meth:`~BufferedSocket.recv_size`, and never from its :meth:`~BufferedSocket.recv` or :meth:`~BufferedSocket.recv_close`. Nrrr r rOrO]rr rOc$eZdZdZdfd ZxZS)rNzRaised from :meth:`BufferedSocket.recv_until` and :meth:`BufferedSocket.recv_closed` when more than *maxsize* bytes are read without encountering the delimiter or a closed connection, respectively. Ncxd}| |d|dz }||d|z }t|dS)Nzmessage exceeded maximum sizez. z bytes readz. Delimiter not found: superr,)r bytes_readr\rf __class__s r r,zMessageTooLong.__init__ns[-  ! / /// /C  :Y:: :C r )NNrrrrr, __classcell__rs@r rNrNhG r rNc$eZdZdZdfd ZxZS)rCzInheriting from :exc:`socket.timeout`, Timeout is used to indicate when a socket operation did not complete within the time specified. Raised from any of :class:`BufferedSocket`'s ``recv`` methods. c|d}| |d|dzzz }|r|d|zz }t|dS)Nzsocket operation timed outz after %sms.i r)r r&extrarfrs r r,zTimeout.__init__}sU*   >Wt^4 4C   3; C r )rrrs@r rCrCwrr rCcHeZdZdZeefdZdZdZdZ dZ e e fdZ dZ d S) NetstringSocketz Reads and writes using the netstring protocol. More info: https://en.wikipedia.org/wiki/Netstring Even more info: http://cr.yp.to/proto/netstrings.txt ct||_||_||_t t |dz|_dSNr)rbsockr&r#r@str_msgsize_maxsize)r rr&r#s r r,zNetstringSocket.__init__s@#D))   #CLL 1 1A 5r c4|jSr)rrrs r rzNetstringSocket.filenosz  """r c||_dSrr.r/s r r0zNetstringSocket.settimeouts  r cH||_|||_dSr)r#_calc_msgsize_maxsizerr7s r r8zNetstringSocket.setmaxsizes% $ : :7 C Cr c@tt|dzSr)r@rr7s r rz%NetstringSocket._calc_msgsize_maxsizes3w<<  1$$r c|tur|j}|tur|j}|j}n||}|jd||} t|}n #t$rtd|zwxYw||krt|||j |}|j ddkrtd|S)N:)r&r#z4netstring message size must be valid integer, not %rr,z#expected trailing ',' after message)rr&r#rrrrhr"r?NetstringInvalidSizeNetstringMessageTooLongrIrANetstringProtocolError)r r&r#msgsize_maxsize size_prefixrDpayloads r read_nszNetstringSocket.read_nss f  lG f  lG"3OO"88AAOj++D4;4C,EE  I{##DD I I I&(:>)$88 8*&&t,, :??1   % %()NOO Os A,,B ct|}||jkrt||jt|ddz|zdz}|j|dS)Nasciirr)r@r#rrencoderrt)r rrDrFs r write_nszNetstringSocket.write_nssn7|| $,  )$ == =4yy((4/'9D@ r N)rrrrr%rr,rr0r8rrrrrr r rrs &5o6666 ###DDD%%%%f6r rceZdZdZdS)rz=Base class for all of socketutils' Netstring exception types.Nrrr r rrsCCDr rc"eZdZdZfdZxZS)raRNetstringInvalidSize is raised when the ``:``-delimited size prefix of the message does not contain a valid integer. Message showing valid size:: 5:hello, Here the ``5`` is the size. Anything in this prefix position that is not parsable as a Python integer (i.e., :class:`int`) will raise this exception. cJt|dSrr)r rfrs r r,zNetstringInvalidSize.__init__s! r rrs@r rrsB  r rc"eZdZdZfdZxZS)ra(NetstringMessageTooLong is raised when the size prefix contains a valid integer, but that integer is larger than the :class:`NetstringSocket`'s configured *maxsize*. When this exception is raised, it's recommended to simply close the connection instead of trying to recover. cZd|d|}t|dS)Nz5netstring message length exceeds configured maxsize: z > r)r rDr#rfrs r r,z NetstringMessageTooLong.__init__s5$$! r rrs@r rrsBr r)rrWrB threadingrr[ typeutilsrr ImportErrorobjectr%rrLrerrorrrOrNr&rCrrrrrr r rs>""H  (((((( ]H - - -FF VXXFFFooooooooh     FL        u        U        fne   ::::::::z     U       1        4   s((?AA