<h2>Edit File - protocols.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/lib64/python3.6/asyncio/protocols.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;Abstract Protocol class.&quot;&quot;&quot;

__all__ = [&#039;BaseProtocol&#039;, &#039;Protocol&#039;, &#039;DatagramProtocol&#039;,
           &#039;SubprocessProtocol&#039;]


class BaseProtocol:
    &quot;&quot;&quot;Common base class for protocol interfaces.

    Usually user implements protocols that derived from BaseProtocol
    like Protocol or ProcessProtocol.

    The only case when BaseProtocol should be implemented directly is
    write-only transport like write pipe
    &quot;&quot;&quot;

    def connection_made(self, transport):
        &quot;&quot;&quot;Called when a connection is made.

        The argument is the transport representing the pipe connection.
        To receive data, wait for data_received() calls.
        When the connection is closed, connection_lost() is called.
        &quot;&quot;&quot;

    def connection_lost(self, exc):
        &quot;&quot;&quot;Called when the connection is lost or closed.

        The argument is an exception object or None (the latter
        meaning a regular EOF is received or the connection was
        aborted or closed).
        &quot;&quot;&quot;

    def pause_writing(self):
        &quot;&quot;&quot;Called when the transport&#039;s buffer goes over the high-water mark.

        Pause and resume calls are paired -- pause_writing() is called
        once when the buffer goes strictly over the high-water mark
        (even if subsequent writes increases the buffer size even
        more), and eventually resume_writing() is called once when the
        buffer size reaches the low-water mark.

        Note that if the buffer size equals the high-water mark,
        pause_writing() is not called -- it must go strictly over.
        Conversely, resume_writing() is called when the buffer size is
        equal or lower than the low-water mark.  These end conditions
        are important to ensure that things go as expected when either
        mark is zero.

        NOTE: This is the only Protocol callback that is not called
        through EventLoop.call_soon() -- if it were, it would have no
        effect when it&#039;s most needed (when the app keeps writing
        without yielding until pause_writing() is called).
        &quot;&quot;&quot;

    def resume_writing(self):
        &quot;&quot;&quot;Called when the transport&#039;s buffer drains below the low-water mark.

        See pause_writing() for details.
        &quot;&quot;&quot;


class Protocol(BaseProtocol):
    &quot;&quot;&quot;Interface for stream protocol.

    The user should implement this interface.  They can inherit from
    this class but don&#039;t need to.  The implementations here do
    nothing (they don&#039;t raise exceptions).

    When the user wants to requests a transport, they pass a protocol
    factory to a utility function (e.g., EventLoop.create_connection()).

    When the connection is made successfully, connection_made() is
    called with a suitable transport object.  Then data_received()
    will be called 0 or more times with data (bytes) received from the
    transport; finally, connection_lost() will be called exactly once
    with either an exception object or None as an argument.

    State machine of calls:

      start -&gt; CM [-&gt; DR*] [-&gt; ER?] -&gt; CL -&gt; end

    * CM: connection_made()
    * DR: data_received()
    * ER: eof_received()
    * CL: connection_lost()
    &quot;&quot;&quot;

    def data_received(self, data):
        &quot;&quot;&quot;Called when some data is received.

        The argument is a bytes object.
        &quot;&quot;&quot;

    def eof_received(self):
        &quot;&quot;&quot;Called when the other end calls write_eof() or equivalent.

        If this returns a false value (including None), the transport
        will close itself.  If it returns a true value, closing the
        transport is up to the protocol.
        &quot;&quot;&quot;


class DatagramProtocol(BaseProtocol):
    &quot;&quot;&quot;Interface for datagram protocol.&quot;&quot;&quot;

    def datagram_received(self, data, addr):
        &quot;&quot;&quot;Called when some datagram is received.&quot;&quot;&quot;

    def error_received(self, exc):
        &quot;&quot;&quot;Called when a send or receive operation raises an OSError.

        (Other than BlockingIOError or InterruptedError.)
        &quot;&quot;&quot;


class SubprocessProtocol(BaseProtocol):
    &quot;&quot;&quot;Interface for protocol for subprocess calls.&quot;&quot;&quot;

    def pipe_data_received(self, fd, data):
        &quot;&quot;&quot;Called when the subprocess writes data into stdout/stderr pipe.

        fd is int file descriptor.
        data is bytes object.
        &quot;&quot;&quot;

    def pipe_connection_lost(self, fd, exc):
        &quot;&quot;&quot;Called when a file descriptor associated with the child process is
        closed.

        fd is the int file descriptor that was closed.
        &quot;&quot;&quot;

    def process_exited(self):
        &quot;&quot;&quot;Called when subprocess has exited.&quot;&quot;&quot;
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>