
     f              
         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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     Z/var/www/api.educacionweb.es/myenv/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hash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   r0   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.   r3   s     r   r7   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)   r1   s    r   r   zStapledStream.aclose|   s      	/"))+++++++++%,,...........$%,,..........s   A !A%)r*   r+   r   r   )r   r   )N)r3   r4   r   r5   )
__name__
__module____qualname____doc____annotations__r-   r0   r   r7   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>rF      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)???       <' ' ' '
 U%000H/ H/ H/ H/ H/K'(H/ H/ 10 H/ H/ H/r"   