o US`cX@sVddlZddlZddlmZddlmZddZejdddGd d d eed ZdS) N)HalfCloseableStream)FinalcsFt}||IdHWddS1swYdS)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). N)trioZ CancelScopecancelaclose)resourcecsr B/usr/local/lib/python3.10/dist-packages/trio/_highlevel_generic.pyaclose_forcefully s  "r F)eqhashc@sJeZdZdZeZeZddZddZ ddZ d d d Z d d Z 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. c|j|IdHS)z$Calls ``self.send_stream.send_all``.N) send_streamsend_all)selfdatar r r rNzStapledStream.send_allcs|jIdHS)z9Calls ``self.send_stream.wait_send_all_might_not_block``.N)rwait_send_all_might_not_blockrr r r rRsz+StapledStream.wait_send_all_might_not_blockcs.t|jdr|jIdHS|jIdHS)zShuts down the send side of the stream. If ``self.send_stream.send_eof`` exists, then calls it. Otherwise, calls ``self.send_stream.aclose()``. send_eofN)hasattrrrrrr r r rVs zStapledStream.send_eofNcr)z+Calls ``self.receive_stream.receive_some``.N)receive_stream receive_some)rZ max_bytesr r r rbrzStapledStream.receive_somecs<z|jIdHW|jIdHdS|jIdHw)z,Calls ``aclose`` on both underlying streams.N)rrrrr r r rfs&zStapledStream.aclose)N) __name__ __module__ __qualname____doc__attribrrrrrrrr r r r r's" r) metaclass) r rabcrZ trio._utilrr srr r r r s