
    g              
         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dS )    )annotations)TYPE_CHECKINGGenericTypeVarN)final   )AsyncResourceHalfCloseableStreamReceiveStream
SendStream)	TypeGuardSendStreamT)boundReceiveStreamTresourcer	   returnNonec                   K   t          j                    5 }|                                 |                                  d{V  ddd           dS # 1 swxY w Y   dS )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)r   css     c/var/www/html/nodeJS/PythonScripts/venv3.11/lib/python3.11/site-packages/trio/_highlevel_generic.pyaclose_forcefullyr      s      2 
			  r
		oo                                   s   /AAAstreamr   TypeGuard[HalfCloseableStream]c                "    t          | d          S )z,Check if the stream has a send_eof() method.send_eof)hasattr)r   s    r   _is_halfclosabler!   2   s    6:&&&    F)eqslotsc                  R    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	dS )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_streamdatabytes | bytearray | memoryviewr   r   c                F   K   | j                             |           d{V S )z$Calls ``self.send_stream.send_all``.N)r'   send_all)selfr)   s     r   r,   zStapledStream.send_allb   s/      %..t444444444r"   c                D   K   | j                                          d{V S )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EEEEEr"   c                   K   | j         }t          |          r|                                 d{V S |                                 d{V S )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   sb       !F## 	)*********(((((((r"   N	max_bytes
int | Nonebytesc                F   K   | j                             |           d{V S )z+Calls ``self.receive_stream.receive_some``.N)r(   receive_some)r-   r2   s     r   r6   zStapledStream.receive_somex   s/      (55i@@@@@@@@@r"   c                   K   	 | j                                          d{V  | j                                         d{V  dS # | j                                         d{V  w xY w)z,Calls ``aclose`` on both underlying streams.N)r'   r   r(   r0   s    r   r   zStapledStream.aclose|   s      	/"))+++++++++%,,...........$%,,..........s   A !A%)r)   r*   r   r   )r   r   )N)r2   r3   r   r4   )
__name__
__module____qualname____doc____annotations__r,   r/   r   r6   r    r"   r   r&   r&   7   s            D """"5 5 5 5F F F F) ) ) )A A A A A/ / / / / /r"   r&   )r   r	   r   r   )r   r   r   r   )
__future__r   typingr   r   r   attrsr   
trio._utilr   abcr	   r
   r   r   typing_extensionsr   r   r   r   r!   definer&   r=   r"   r   <module>rE      s^   " " " " " " 2 2 2 2 2 2 2 2 2 2         N N N N N N N N N N N N ,++++++ gm:666)???       <' ' ' '
 e$$$H/ H/ H/ H/ H/K'(H/ H/ %$ H/ H/ H/r"   