a (j @sddlmZddlmZmZmZddlZddlZddlm Z ddl m Z m Z m Z mZerdddlmZeded Zed e d Zd d d ddZdddddZe ejdddGddde eeefZdS)) annotations) TYPE_CHECKINGGenericTypeVarN)final) AsyncResourceHalfCloseableStream ReceiveStream SendStream) TypeGuard SendStreamT)boundReceiveStreamTrNone)resourcereturncsFt*}|jdd|IdHWdn1s80YdS)aClose 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). z"cancelled during aclose_forcefully)reasonN)trioZ CancelScopecancelaclose)rcsr=E:\soccer\ml_env\Lib\site-packages\trio/_highlevel_generic.pyaclose_forcefullys  rr zTypeGuard[HalfCloseableStream])streamrcCs t|dS)z,Check if the stream has a send_eof() method.send_eof)hasattr)rrrr_is_halfclosable2srF)eqslotsc@sneZdZUdZded<ded<dddd d Zdd d d Zdd ddZddddddZdd ddZ dS) StapledStreamaThis class `staples `__ 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_streamrreceive_streamzbytes | bytearray | memoryviewr)datarcs|j|IdHS)z$Calls ``self.send_stream.send_all``.N)r"send_all)selfr$rrrr%bszStapledStream.send_all)rcs|jIdHS)z9Calls ``self.send_stream.wait_send_all_might_not_block``.N)r"wait_send_all_might_not_blockr&rrrr'fsz+StapledStream.wait_send_all_might_not_blockcs.|j}t|r|IdHS|IdHSdS)a Shuts down the send side of the stream. If :meth:`self.send_stream.send_eof() ` exists, then this calls it. Otherwise, this calls :meth:`self.send_stream.aclose() `. N)r"rrr)r&rrrrrjszStapledStream.send_eofNz int | Nonebytes) max_bytesrcs|j|IdHS)z+Calls ``self.receive_stream.receive_some``.N)r# receive_some)r&r*rrrr+xszStapledStream.receive_somecs<z$|jIdHW|jIdHn|jIdH0dS)z,Calls ``aclose`` on both underlying streams.N)r"rr#r(rrrr|szStapledStream.aclose)N) __name__ __module__ __qualname____doc____annotations__r%r'rr+rrrrrr!7s "r!) __future__rtypingrrrattrsrZ trio._utilrabcrr r r Ztyping_extensionsr r rrrZdefiner!rrrrs"