Ë
    _§1h—  ã            
      óú   — d dl mZ d dlmZmZmZ d dlZd dlZd dlm	Z	 ddl
mZmZmZmZ erd dlmZ  ede¬	«      Z ed
e¬	«      Zdd„Zdd„Ze	 ej*                  dd¬«       G d„ deeeef   «      «       «       Zy)é    )Úannotations)ÚTYPE_CHECKINGÚGenericÚTypeVarN)Úfinalé   )ÚAsyncResourceÚHalfCloseableStreamÚReceiveStreamÚ
SendStream)Ú	TypeGuardÚSendStreamT)ÚboundÚReceiveStreamTc              ƒ  ó²   K  — t        j                  «       5 }|j                  «        | j                  «       ƒ d{  –—†  ddd«       y7 Œ# 1 sw Y   yxY w­w)aë  Close an async resource or async generator immediately, without
    blocking to do any graceful cleanup.

    :class:`~trio.abc.AsyncResource` objects guarantee that if their
    :meth:`~trio.abc.AsyncResource.aclose` method is cancelled, then they will
    still close the resource (albeit in a potentially ungraceful
    fashion). :func:`aclose_forcefully` is a convenience function that
    exploits this behavior to let you force a resource to be closed without
    blocking: it works by calling ``await resource.aclose()`` and then
    cancelling it immediately.

    Most users won't need this, but it may be useful on cleanup paths where
    you can't afford to block, or if you want to close a resource and don't
    care about handling it gracefully. For example, if
    :class:`~trio.SSLStream` encounters an error and cannot perform its
    own graceful close, then there's no point in waiting to gracefully shut
    down the underlying transport either, so it calls ``await
    aclose_forcefully(self.transport_stream)``.

    Note that this function is async, and that it acts as a checkpoint, but
    unlike most async functions it cannot block indefinitely (at least,
    assuming the underlying resource object is correctly implemented).

    N)ÚtrioÚCancelScopeÚcancelÚaclose)ÚresourceÚcss     úU/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/trio/_highlevel_generic.pyÚaclose_forcefullyr      sL   è ø€ ô2 
×	Ñ	Ó	ð  ˜rØ
�	‰	ŒØ�o‰oÓ×Ð÷ ð  àø÷ ð  üs,   ‚A—$A»A	¼AÁ 	AÁ	AÁAÁAc                ó   — t        | d«      S )z,Check if the stream has a send_eof() method.Úsend_eof)Úhasattr)Ústreams    r   Ú_is_halfclosabler   2   s   € ä�6˜:Ó&Ð&ó    F)ÚeqÚslotsc                  óP   — e Zd ZU dZded<   ded<   dd„Zdd„Zdd„Zddd
„Zdd„Z	y	)ÚStapledStreama–  This class `staples <https://en.wikipedia.org/wiki/Staple_(fastener)>`__
    together two unidirectional streams to make single bidirectional stream.

    Args:
      send_stream (~trio.abc.SendStream): The stream to use for sending.
      receive_stream (~trio.abc.ReceiveStream): The stream to use for
          receiving.

    Example:

       A silly way to make a stream that echoes back whatever you write to
       it::

          left, right = trio.testing.memory_stream_pair()
          echo_stream = StapledStream(SocketStream(left), SocketStream(right))
          await echo_stream.send_all(b"x")
          assert await echo_stream.receive_some() == b"x"

    :class:`StapledStream` objects implement the methods in the
    :class:`~trio.abc.HalfCloseableStream` interface. They also have two
    additional public attributes:

    .. attribute:: send_stream

       The underlying :class:`~trio.abc.SendStream`. :meth:`send_all` and
       :meth:`wait_send_all_might_not_block` are delegated to this object.

    .. attribute:: receive_stream

       The underlying :class:`~trio.abc.ReceiveStream`. :meth:`receive_some`
       is delegated to this object.

    r   Úsend_streamr   Úreceive_streamc              ƒ  óT   K  — | j                   j                  |«      ƒ d{  –—† S 7 Œ­w)z$Calls ``self.send_stream.send_all``.N)r$   Úsend_all)ÚselfÚdatas     r   r'   zStapledStream.send_allb   s#   è ø€ à×%Ñ%×.Ñ.¨tÓ4×4Ð4Ð4úó   ‚(¡&¢(c              ƒ  óR   K  — | j                   j                  «       ƒ d{  –—† S 7 Œ­w)z9Calls ``self.send_stream.wait_send_all_might_not_block``.N)r$   Úwait_send_all_might_not_block©r(   s    r   r,   z+StapledStream.wait_send_all_might_not_blockf   s!   è ø€ à×%Ñ%×CÑCÓE×EÐEÐEús   ‚' %¡'c              ƒ  ó    K  — | j                   }t        |«      r|j                  «       ƒ d{  –—† S |j                  «       ƒ d{  –—† S 7 Œ7 Œ­w)a  Shuts down the send side of the stream.

        If :meth:`self.send_stream.send_eof() <trio.abc.HalfCloseableStream.send_eof>` exists,
        then this calls it. Otherwise, this calls
        :meth:`self.send_stream.aclose() <trio.abc.AsyncResource.aclose>`.
        N)r$   r   r   r   )r(   r   s     r   r   zStapledStream.send_eofj   sC   è ø€ ð ×!Ñ!ˆÜ˜FÔ#ØŸ™Ó*×*Ð*àŸ™›×(Ð(ð +øà(ús!   ‚+A­A
®AÁAÁAÁANc              ƒ  óT   K  — | j                   j                  |«      ƒ d{  –—† S 7 Œ­w)z+Calls ``self.receive_stream.receive_some``.N)r%   Úreceive_some)r(   Ú	max_bytess     r   r0   zStapledStream.receive_somex   s#   è ø€ à×(Ñ(×5Ñ5°iÓ@×@Ð@Ð@úr*   c              ƒ  óî   K  — 	 | j                   j                  «       ƒ d{  –—†  | j                  j                  «       ƒ d{  –—†  y7 Œ'7 Œ# | j                  j                  «       ƒ d{  –—†7   w xY w­w)z,Calls ``aclose`` on both underlying streams.N)r$   r   r%   r-   s    r   r   zStapledStream.aclose|   s\   è ø€ ð	/Ø×"Ñ"×)Ñ)Ó+×+Ð+à×%Ñ%×,Ñ,Ó.×.Ñ.ð ,øà.ù�$×%Ñ%×,Ñ,Ó.×.Ò.üsI   ‚A5„A ¡A	¢A ¦A5ÁAÁA5Á	A ÁA5ÁA2Á+A.Á,A2Á2A5)r)   zbytes | bytearray | memoryviewÚreturnÚNone)r3   r4   )N)r1   z
int | Noner3   Úbytes)
Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r'   r,   r   r0   r   © r   r   r#   r#   7   s1   … ñ ðD ÓØ"Ó"ó5óFó)ôAô/r   r#   )r   r	   r3   r4   )r   r   r3   zTypeGuard[HalfCloseableStream])Ú
__future__r   Útypingr   r   r   Úattrsr   Ú
trio._utilr   Úabcr	   r
   r   r   Útyping_extensionsr   r   r   r   r   Údefiner#   r;   r   r   ú<module>rC      s‰   ðÝ "ç 2Ñ 2ã ã Ý ç NÓ NáÝ+ñ �m¨:Ô6€ÙÐ)°Ô?€ó ó<'ð
 Ø€‡��˜eÔ$ôH/ØØˆK˜Ð'Ñ(óH/ó %ó ñH/r   