MINI MINI MANI MO

Path : /lib64/python3.6/asyncio/__pycache__/
Current File : //lib64/python3.6/asyncio/__pycache__/transports.cpython-36.opt-1.pyc
3


 \R'ã@s”dZddlmZddddddgZGd	d„dƒZGd
d„deƒZGdd„deƒZGdd„deeƒZGd
d„deƒZGdd„deƒZ	Gdd„deƒZ
dS)zAbstract Transport class.é)ÚcompatÚ
BaseTransportÚ
ReadTransportÚWriteTransportÚ	TransportÚDatagramTransportÚSubprocessTransportc@sDeZdZdZddd„Zddd„Zdd„Zd	d
„Zdd„Zd
d„Z	dS)rzBase class for transports.NcCs|dkri}||_dS)N)Ú_extra)ÚselfÚextra©rú*/usr/lib64/python3.6/asyncio/transports.pyÚ__init__
szBaseTransport.__init__cCs|jj||ƒS)z#Get optional transport information.)r	Úget)r
ÚnameÚdefaultrrr
Úget_extra_infoszBaseTransport.get_extra_infocCst‚dS)z2Return True if the transport is closing or closed.N)ÚNotImplementedError)r
rrr
Ú
is_closingszBaseTransport.is_closingcCst‚dS)a
Close the transport.

        Buffered data will be flushed asynchronously.  No more data
        will be received.  After all buffered data is flushed, the
        protocol's connection_lost() method will (eventually) called
        with None as its argument.
        N)r)r
rrr
ÚcloseszBaseTransport.closecCst‚dS)zSet a new protocol.N)r)r
Úprotocolrrr
Úset_protocol$szBaseTransport.set_protocolcCst‚dS)zReturn the current protocol.N)r)r
rrr
Úget_protocol(szBaseTransport.get_protocol)N)N)
Ú__name__Ú
__module__Ú__qualname__Ú__doc__rrrrrrrrrr
r
s


c@s eZdZdZdd„Zdd„ZdS)rz#Interface for read-only transports.cCst‚dS)z”Pause the receiving end.

        No data will be passed to the protocol's data_received()
        method until resume_reading() is called.
        N)r)r
rrr
Ú
pause_reading0szReadTransport.pause_readingcCst‚dS)z…Resume the receiving end.

        Data received will once again be passed to the protocol's
        data_received() method.
        N)r)r
rrr
Úresume_reading8szReadTransport.resume_readingN)rrrrrrrrrr
r-sc@sJeZdZdZddd„Zdd„Zdd„Zd	d
„Zdd„Zd
d„Z	dd„Z
dS)rz$Interface for write-only transports.NcCst‚dS)a¦Set the high- and low-water limits for write flow control.

        These two values control when to call the protocol's
        pause_writing() and resume_writing() methods.  If specified,
        the low-water limit must be less than or equal to the
        high-water limit.  Neither value can be negative.

        The defaults are implementation-specific.  If only the
        high-water limit is given, the low-water limit defaults to an
        implementation-specific value less than or equal to the
        high-water limit.  Setting high to zero forces low to zero as
        well, and causes pause_writing() to be called whenever the
        buffer becomes non-empty.  Setting low to zero causes
        resume_writing() to be called only once the buffer is empty.
        Use of zero for either limit is generally sub-optimal as it
        reduces opportunities for doing I/O and computation
        concurrently.
        N)r)r
ÚhighÚlowrrr
Úset_write_buffer_limitsDsz&WriteTransport.set_write_buffer_limitscCst‚dS)z,Return the current size of the write buffer.N)r)r
rrr
Úget_write_buffer_sizeYsz$WriteTransport.get_write_buffer_sizecCst‚dS)zWrite some data bytes to the transport.

        This does not block; it buffers the data and arranges for it
        to be sent out asynchronously.
        N)r)r
Údatarrr
Úwrite]szWriteTransport.writecCstj|ƒ}|j|ƒdS)z¯Write a list (or any iterable) of data bytes to the transport.

        The default implementation concatenates the arguments and
        calls write() on the result.
        N)rZflatten_list_bytesr$)r
Zlist_of_datar#rrr
Ú
writelineses
zWriteTransport.writelinescCst‚dS)z©Close the write end after flushing buffered data.

        (This is like typing ^D into a UNIX program reading from stdin.)

        Data may still be received.
        N)r)r
rrr
Ú	write_eofnszWriteTransport.write_eofcCst‚dS)zAReturn True if this transport supports write_eof(), False if not.N)r)r
rrr
Ú
can_write_eofwszWriteTransport.can_write_eofcCst‚dS)zÝClose the transport immediately.

        Buffered data will be lost.  No more data will be received.
        The protocol's connection_lost() method will (eventually) be
        called with None as its argument.
        N)r)r
rrr
Úabort{szWriteTransport.abort)NN)rrrrr!r"r$r%r&r'r(rrrr
rAs
		c@seZdZdZdS)raSInterface representing a bidirectional transport.

    There may be several implementations, but typically, the user does
    not implement new transports; rather, the platform provides some
    useful transports that are implemented using the platform's best
    practices.

    The user never instantiates a transport directly; they call a
    utility function, passing it a protocol factory and other
    information necessary to create the transport and protocol.  (E.g.
    EventLoop.create_connection() or EventLoop.create_server().)

    The utility function will asynchronously create a transport and a
    protocol and hook them up by calling the protocol's
    connection_made() method, passing it the transport.

    The implementation here raises NotImplemented for every method
    except writelines(), which calls write() in a loop.
    N)rrrrrrrr
r…sc@s"eZdZdZddd„Zdd„ZdS)rz(Interface for datagram (UDP) transports.NcCst‚dS)aSend data to the transport.

        This does not block; it buffers the data and arranges for it
        to be sent out asynchronously.
        addr is target socket address.
        If addr is None use target address pointed on transport creation.
        N)r)r
r#Zaddrrrr
ÚsendtožszDatagramTransport.sendtocCst‚dS)zÝClose the transport immediately.

        Buffered data will be lost.  No more data will be received.
        The protocol's connection_lost() method will (eventually) be
        called with None as its argument.
        N)r)r
rrr
r(¨szDatagramTransport.abort)N)rrrrr)r(rrrr
r›s

c@s<eZdZdd„Zdd„Zdd„Zdd„Zd	d
„Zdd„Zd
S)rcCst‚dS)zGet subprocess id.N)r)r
rrr
Úget_pid´szSubprocessTransport.get_pidcCst‚dS)z…Get subprocess returncode.

        See also
        http://docs.python.org/3/library/subprocess#subprocess.Popen.returncode
        N)r)r
rrr
Úget_returncode¸sz"SubprocessTransport.get_returncodecCst‚dS)z&Get transport for pipe with number fd.N)r)r
Úfdrrr
Úget_pipe_transportÀsz&SubprocessTransport.get_pipe_transportcCst‚dS)z€Send signal to subprocess.

        See also:
        docs.python.org/3/library/subprocess#subprocess.Popen.send_signal
        N)r)r
Úsignalrrr
Úsend_signalÄszSubprocessTransport.send_signalcCst‚dS)aLStop the subprocess.

        Alias for close() method.

        On Posix OSs the method sends SIGTERM to the subprocess.
        On Windows the Win32 API function TerminateProcess()
         is called to stop the subprocess.

        See also:
        http://docs.python.org/3/library/subprocess#subprocess.Popen.terminate
        N)r)r
rrr
Ú	terminateÌszSubprocessTransport.terminatecCst‚dS)zõKill the subprocess.

        On Posix OSs the function sends SIGKILL to the subprocess.
        On Windows kill() is an alias for terminate().

        See also:
        http://docs.python.org/3/library/subprocess#subprocess.Popen.kill
        N)r)r
rrr
ÚkillÚs	zSubprocessTransport.killN)	rrrr*r+r-r/r0r1rrrr
r²scsVeZdZdZd‡fdd„	Zdd„Zdd„Zd	d
„Zddd„Zdd
d„Z	dd„Z
‡ZS)Ú_FlowControlMixinavAll the logic for (write) flow control in a mix-in base class.

    The subclass must implement get_write_buffer_size().  It must call
    _maybe_pause_protocol() whenever the write buffer size increases,
    and _maybe_resume_protocol() whenever it decreases.  It may also
    override set_write_buffer_limits() (e.g. to specify different
    defaults).

    The subclass constructor must call super().__init__(extra).  This
    will call set_write_buffer_limits().

    The user may call set_write_buffer_limits() and
    get_write_buffer_size(), and their protocol's pause_writing() and
    resume_writing() may be called.
    Ncs$tƒj|ƒ||_d|_|jƒdS)NF)ÚsuperrÚ_loopÚ_protocol_pausedÚ_set_write_buffer_limits)r
rZloop)Ú	__class__rr
r÷sz_FlowControlMixin.__init__cCsp|jƒ}||jkrdS|jsld|_y|jjƒWn:tk
rj}z|jjd|||jdœƒWYdd}~XnXdS)NTzprotocol.pause_writing() failed)ÚmessageÚ	exceptionÚ	transportr)r"Ú_high_waterr5Ú	_protocolZ
pause_writingÚ	Exceptionr4Úcall_exception_handler)r
ÚsizeÚexcrrr
Ú_maybe_pause_protocolþs
z'_FlowControlMixin._maybe_pause_protocolcCsh|jrd|jƒ|jkrdd|_y|jjƒWn:tk
rb}z|jjd|||jdœƒWYdd}~XnXdS)NFz protocol.resume_writing() failed)r8r9r:r)r5r"Ú
_low_waterr<Zresume_writingr=r4r>)r
r@rrr
Ú_maybe_resume_protocolsz(_FlowControlMixin._maybe_resume_protocolcCs|j|jfS)N)rBr;)r
rrr
Úget_write_buffer_limitssz)_FlowControlMixin.get_write_buffer_limitscCsf|dkr|dkrd}nd|}|dkr.|d}||ko@dknsVtd||fƒ‚||_||_dS)Né@iérz*high (%r) must be >= low (%r) must be >= 0i)Ú
ValueErrorr;rB)r
rr rrr
r6sz*_FlowControlMixin._set_write_buffer_limitscCs|j||d|jƒdS)N)rr )r6rA)r
rr rrr
r!-sz)_FlowControlMixin.set_write_buffer_limitscCst‚dS)N)r)r
rrr
r"1sz'_FlowControlMixin.get_write_buffer_size)NN)NN)NN)rrrrrrArCrDr6r!r"Ú
__classcell__rr)r7r
r2æs

r2N)rZasynciorÚ__all__rrrrrrr2rrrr
Ú<module>s
#D4
OHA YOOOO