o Rh @sddlmZddlmZmZmZddlZddlZddlm Z ddl m Z m Z m Z mZer2ddlmZeded Zed e d ZdddZdddZe ejdddGddde eeefZdS)) annotations) TYPE_CHECKINGGenericTypeVarN)final) AsyncResourceHalfCloseableStream ReceiveStream SendStream) TypeGuard SendStreamT)boundReceiveStreamTresourcerreturnNonecsFt}||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)trio CancelScopecancelaclose)rcsrY/home/air/sanwanet/backup_V2/venv/lib/python3.10/site-packages/trio/_highlevel_generic.pyaclose_forcefullys  "rstreamr TypeGuard[HalfCloseableStream]cCs t|dS)z,Check if the stream has a send_eof() method.send_eof)hasattr)rrrr_is_halfclosable2s rF)eqslotsc@sVeZdZUdZded<ded<dd d Zdd d ZdddZddddZdddZ 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_streamdatabytes | bytearray | memoryviewrrc|j|IdHS)z$Calls ``self.send_stream.send_all``.N)r#send_all)selfr%rrrr(bzStapledStream.send_allcs|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|IdHS)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)rrrrrjs zStapledStream.send_eofN max_bytes int | Nonebytescr')z+Calls ``self.receive_stream.receive_some``.N)r$ receive_some)r)r-rrrr0xr*zStapledStream.receive_somecs<z|jIdHW|jIdHdS|jIdHw)z,Calls ``aclose`` on both underlying streams.N)r#rr$r,rrrr|s&zStapledStream.aclose)r%r&rr)rr)N)r-r.rr/) __name__ __module__ __qualname____doc____annotations__r(r+rr0rrrrrr"7s "    r")rrrr)rr rr) __future__rtypingrrrattrsr trio._utilrabcrr r r typing_extensionsr r rrrdefiner"rrrrs$