
    ,h              
          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     Y/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/trio/_highlevel_generic.pyaclose_forcefullyr      sL     2 
			  r
		oo      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Es   '%'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5i@@@@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   