403Webshell
Server IP : 172.67.201.108  /  Your IP : 216.73.217.83
Web Server : Apache/2.4.68 (Amazon Linux) OpenSSL/3.5.5
System : Linux ip-172-31-69-123.ec2.internal 6.1.176-223.369.amzn2023.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Jul 24 13:34:27 UTC 2026 x86_64
User : ec2-user ( 1000)
PHP Version : 8.4.23
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib64/python3.9/site-packages/awscrt/eventstream/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib64/python3.9/site-packages/awscrt/eventstream/__pycache__/rpc.cpython-39.opt-1.pyc
a

ů�iI_�@sdZddlZddlmZmZddlmZddlZddlm	Z	ddl
mZmZm
Z
ddlmZddlmZdd	lmZdd
lmZddlmZmZmZgd�ZGd
d�de�ZGdd�d�ZGdd�de�Zdd�Zdd�Zdd�Z Gdd�de�Z!Gdd�de�Z"Gdd�de�Z#dS)zI
event-stream RPC (remote procedure call) protocol library for `awscrt`.
�N)�ABC�abstractmethod)�NativeResource)�Header)�ClientBootstrap�
SocketOptions�TlsConnectionOptions)�Callable)�Future)�IntEnum)�partial)�Optional�Sequence�Union)�MessageType�MessageFlag�ClientConnectionHandler�ClientConnection�ClientContinuation�ClientContinuationHandlerc@s8eZdZdZdZdZdZdZdZdZ	dZ
d	Zd
d�ZdS)
ra�Types of messages in the event-stream RPC protocol.

    The :attr:`~MessageType.APPLICATION_MESSAGE` and :attr:`~MessageType.APPLICATION_ERROR` types may only be sent
    on streams, and will never arrive as a protocol message (stream-id 0).

    For all other message types, they may only be sent as protocol messages
    (stream-id 0), and will never arrive as a stream message.

    Different message types expect specific headers and flags, consult documentation.r�������cCst|�S�N��str��self�format_spec�r#�</usr/lib64/python3.9/site-packages/awscrt/eventstream/rpc.py�
__format__CszMessageType.__format__N)
�__name__�
__module__�__qualname__�__doc__ZAPPLICATION_MESSAGEZAPPLICATION_ERRORZPINGZ
PING_RESPONSEZCONNECTZCONNECT_ACKZPROTOCOL_ERRORZINTERNAL_ERRORr%r#r#r#r$rs
rc@s$eZdZdZdZdZdZdd�ZdS)rz�Flags for messages in the event-stream RPC protocol.

    Flags may be XORed together.
    Not all flags can be used with all message types, consult documentation.
    rrrcCst|�Srrr r#r#r$r%aszMessageFlag.__format__N)r&r'r(r)�NONEZCONNECTION_ACCEPTEDZTERMINATE_STREAMr%r#r#r#r$rHs
	rc@sXeZdZdZedd�dd��Zeeedd�dd��Zee	e
eee
dd	�d
d��ZdS)raBase class for handling connection events.

    Inherit from this class and override methods to handle connection events.
    All callbacks for this connection will be invoked on the same thread,
    and :meth:`on_connection_setup()` will always be the first callback invoked.
    N��returncKsdS)a^Invoked upon completion of the setup attempt.

        If setup was successful, the connection is provided to the user.

        Note that the network connection stays alive until it is closed,
        even if no local references to the connection object remain.
        The user should store a reference to this connection, and call
        `connection.close()` when they are done with it to avoid leaking
        resources.

        Setup will always be the first callback invoked on the handler.
        If setup failed, no further callbacks will be invoked on this handler.

        Args:
            connection: The connection, if setup was successful,
                or None if setup failed.

            error: None, if setup was successful, or an Exception
                if setup failed.

            `**kwargs`: Forward compatibility kwargs.
        Nr#)r!�
connection�error�kwargsr#r#r$�on_connection_setupnsz+ClientConnectionHandler.on_connection_setup)�reasonr,cKsdS)aKInvoked when the connection finishes shutting down.

        This event will not be invoked if connection setup failed.

        Args:
            reason: Reason will be None if the user initiated the shutdown,
                otherwise the reason will be an Exception.

            **kwargs: Forward compatibility kwargs.
        Nr#)r!r1r/r#r#r$�on_connection_shutdown�sz.ClientConnectionHandler.on_connection_shutdown��headers�payload�message_type�flagsr,cKsdS)a�Invoked when a message for the connection (stream-id 0) is received.

        Args:
            headers: Message headers.

            payload: Binary message payload.

            message_type: Message type.

            flags: Message flags. Values from :class:`MessageFlag` may be
                XORed together. Not all flags can be used with all message
                types, consult documentation.

            **kwargs: Forward compatibility kwargs.
        Nr#�r!r4r5r6r7r/r#r#r$�on_protocol_message�sz+ClientConnectionHandler.on_protocol_message)r&r'r(r)rr0r
�	Exceptionr2rr�bytesr�intr9r#r#r#r$rfs
�rcCsB|durg}ndd�|D�}|dur(d}|dur6tj}||||fS)z~
    Transform args that a python send-msg function would take,
    into args that a native send-msg function would take.
    NcSsg|]}|���qSr#)Z_as_binding_tuple��.0�ir#r#r$�
<listcomp>��z(_to_binding_msg_args.<locals>.<listcomp>rA)rr*�r4r5r6r7r#r#r$�_to_binding_msg_args�srCcCs.dd�|D�}|durd}t|�}||||fS)zr
    Transform msg-received args that came from native,
    into msg-received args presented to python users.
    cSsg|]}t�|��qSr#)rZ_from_binding_tupler=r#r#r$r@�rAz*_from_binding_msg_args.<locals>.<listcomp>NrA)rrBr#r#r$�_from_binding_msg_args�s
rDc	Csb|rtj�|�nd}z,|r$||d�W|r6|�|�q^|�d�n|rR|�|�n
|�d�0dS)N)r.)�awscrt�
exceptions�	from_code�
set_exception�
set_result)Zbound_futureZbound_callback�
error_code�er#r#r$�_on_message_flush�s�rLc
s�eZdZdZgd�Z�fdd�Zedddd�eee	e
eeee
dd�d	d
��Zdd�Zd
d�Zdd�Zdd�Zdd�Zddddd�eeeeeeefeee	edd�dd�Zddd�dd�Z�ZS)ra�A client connection for the event-stream RPC protocol.

    Use :meth:`ClientConnection.connect()` to establish a new
    connection.

    Note that the network connection stays alive until it is closed,
    even if no local references to the connection object remain.
    The user should store a reference to any connections, and call
    :meth:`close()` when they are done with them to avoid leaking resources.

    Attributes:
        host_name (str): Remote host name.

        port (int): Remote port.

        shutdown_future (concurrent.futures.Future[None]): Completes when this
            connection has finished shutting down. Future will contain a
            result of None, or an exception indicating why shutdown occurred.
    )�	host_name�port�shutdown_future�_connect_future�_handlercsDt���||_||_t�|_|j��t�|_|j��||_dSr)	�super�__init__rMrNr
rO�set_running_or_notify_cancelrPrQ)r!rMrN�handler��	__class__r#r$rS�s


zClientConnection.__init__N)�	bootstrap�socket_options�tls_connection_options�concurrent.futures.Future)rUrMrNrXrYrZr,cCs<|s
t�}||||�}|s"t��}t�||||||�|jS)a,Asynchronously establish a new ClientConnection.

        Args:
            handler: Handler for connection events.

            host_name: Connect to host.

            port: Connect to port.

            bootstrap: Client bootstrap to use when initiating socket connection.
                If None is provided, the default singleton is used.

            socket_options: Optional socket options.
                If None is provided, then default options are used.

            tls_connection_options: Optional TLS
                connection options. If None is provided, then the connection will
                be attempted over plain-text.

        Returns:
            concurrent.futures.Future: A Future which completes when the connection succeeds or fails.
            If successful, the Future will contain None.
            Otherwise it will contain an exception.
            If the connection is successful, it will be made available via
            the handler's on_connection_setup callback.
            Note that this network connection stays alive until it is closed,
            even if no local references to the connection object remain.
            The user should store a reference to any connections, and call
            :meth:`close()` when they are done with them to avoid leaking resources.
        )rrZget_or_create_static_default�_awscrtZ*event_stream_rpc_client_connection_connectrP)�clsrUrMrNrXrYrZr-r#r#r$�connect�s)�zClientConnection.connectc	Csv|rd}tj�|�}n|}d}z2|jj||d�W|rD|j�|�qr|j�d�n |rd|j�|�n|j�d�0dS)N)r-r.)rErFrGrQr0rPrHrI)r!rJr-r.r#r#r$�_on_connection_setup;s�z%ClientConnection._on_connection_setupc	Csj|rtj�|�nd}z0|jj|d�W|r8|j�|�qf|j�d�n |rX|j�|�n|j�d�0dS)N)r1)rErFrGrQr2rOrHrI)r!rJr1r#r#r$�_on_connection_shutdownLs�z(ClientConnection._on_connection_shutdowncCs.t||||�\}}}}|jj||||d�dS�NrB)rDrQr9�r!r4r5r6r7r#r#r$�_on_protocol_messageWs�z%ClientConnection._on_protocol_messagecCst�|j�|jS)a)Close the connection.

        Shutdown is asynchronous. This call has no effect if the connection is
        already closed or closing.

        Note that, if the network connection hasn't already ended,
        `close()` MUST be called to avoid leaking resources. The network
        connection will not terminate simply because there are no references
        to the connection object.

        Returns:
            concurrent.futures.Future: This connection's :attr:`shutdown_future`,
            which completes when shutdown has finished.
        )r\Z(event_stream_rpc_client_connection_close�_bindingrO�r!r#r#r$�close`szClientConnection.closecCst�|j�S)z�
        Returns:
            bool: True if this connection is open and usable, False otherwise.
            Check :attr:`shutdown_future` to know when the connection is completely
            finished shutting down.
        )r\Z*event_stream_rpc_client_connection_is_openrdrer#r#r$�is_opensszClientConnection.is_open�r4r5r7�on_flush�r4r5r6r7rir,cCsFt�}|��t||||�\}}}}t�|j||||tt||��|S)aXSend a protocol message.

        Protocol messages use stream-id 0.

        Use the returned future, or the `on_flush` callback, to be informed
        when the message is successfully written to the wire, or fails to send.

        Keyword Args:
            headers: Message headers.

            payload: Binary message payload.

            message_type: Message type.

            flags: Message flags. Values from :class:`MessageFlag` may be
                XORed together. Not all flags can be used with all message
                types, consult documentation.

            on_flush: Callback invoked when the message is successfully written
                to the wire, or fails to send. The function should take the
                following arguments and return nothing:

                    *   `error` (Optional[Exception]): None if the message was
                        successfully written to the wire, or an Exception
                        if it failed to send.

                    *   `**kwargs` (dict): Forward compatibility kwargs.

                This callback is always invoked on the connection's event-loop
                thread.

        Returns:
            A future which completes with a result of None if the
            message is successfully written to the wire,
            or an exception if the message fails to send.
        )r
rTrCr\Z8event_stream_rpc_client_connection_send_protocol_messagerdrrL�r!r4r5r6r7riZfuturer#r#r$�send_protocol_message|s,
�z&ClientConnection.send_protocol_messagerr)rUr,cCst||�}t�|�|_|S)aj
        Create a new stream.

        The stream will send no data until :meth:`ClientContinuation.activate()`
        is called. Call activate() when you're ready for callbacks and events to fire.

        Args:
            handler: Handler to process continuation messages and state changes.

        Returns:
            The new continuation object.
        )rr\Z-event_stream_rpc_client_connection_new_streamrd)r!rUZcontinuationr#r#r$�
new_stream�s
zClientConnection.new_stream)r&r'r(r)�	__slots__rS�classmethodrrr<rr
rrr^r_r`rcrfrgrrrr;�	bytearrayrr	rlrm�
__classcell__r#r#rVr$r�s@��<	�
�;rcs�eZdZdZ�fdd�Zddddd�eeeee	e
feee
d�dd�Zddddd�eeee	e
feee
d	d
�dd�Zd
d�Zdd�Zdd�Z�ZS)ra�
    A continuation of messages on a given stream-id.

    Create with :meth:`ClientConnection.new_stream()`.

    The stream will send no data until :meth:`ClientContinuation.activate()`
    is called. Call activate() when you're ready for callbacks and events to fire.

    Attributes:
        connection (ClientConnection): This stream's connection.

        closed_future (concurrent.futures.Future) : Future which completes with a result of None
            when the continuation has closed.
    cs,t���||_||_t�|_|j��dSr)rRrSrQr-r
�
closed_futurerT)r!rUr-rVr#r$rS�s

zClientContinuation.__init__Nrh)�	operationr4r5r6r7ric
CsJt�}|��t||||�\}}}}t�|j||||||tt||��|S)a�
        Activate the stream by sending its first message.

        Use the returned future, or the `on_flush` callback, to be informed
        when the message is successfully written to the wire, or fails to send.

        activate() may only be called once, use send_message() to write further
        messages on this stream-id.

        Keyword Args:
            operation: Operation name for this stream.

            headers: Message headers.

            payload: Binary message payload.

            message_type: Message type.

            flags: Message flags. Values from :class:`MessageFlag` may be
                XORed together. Not all flags can be used with all message
                types, consult documentation.

            on_flush: Callback invoked when the message is successfully written
                to the wire, or fails to send. The function should take the
                following arguments and return nothing:

                    *   `error` (Optional[Exception]): None if the message was
                        successfully written to the wire, or an Exception
                        if it failed to send.

                    *   `**kwargs` (dict): Forward compatibility kwargs.

                This callback is always invoked on the connection's event-loop
                thread.

        Returns:
            A future which completes with a result of None if the
            message is successfully written to the wire,
            or an exception if the message fails to send.
        )r
rTrCr\Z-event_stream_rpc_client_continuation_activaterdrrL)r!rsr4r5r6r7riZflush_futurer#r#r$�activate�s2
�
zClientContinuation.activater[rjcCsFt�}|��t||||�\}}}}t�|j||||tt||��|S)a�
        Send a continuation message.

        Use the returned future, or the `on_flush` callback, to be informed
        when the message is successfully written to the wire, or fails to send.

        Note that the the first message on a stream-id must be sent with activate(),
        send_message() is for all messages that follow.

        Keyword Args:
            operation: Operation name for this stream.

            headers: Message headers.

            payload: Binary message payload.

            message_type: Message type.

            flags: Message flags. Values from :class:`MessageFlag` may be
                XORed together. Not all flags can be used with all message
                types, consult documentation.

            on_flush: Callback invoked when the message is successfully written
                to the wire, or fails to send. The function should take the
                following arguments and return nothing:

                    *   `error` (Optional[Exception]): None if the message was
                        successfully written to the wire, or an Exception
                        if it failed to send.

                    *   `**kwargs` (dict): Forward compatibility kwargs.

                This callback is always invoked on the connection's event-loop
                thread.

        Returns:
            A future which completes with a result of None if the
            message is successfully written to the wire,
            or an exception if the message fails to send.
        )r
rTrCr\Z1event_stream_rpc_client_continuation_send_messagerdrrLrkr#r#r$�send_message(s0
�zClientContinuation.send_messagecCst�|j�Sr)r\Z.event_stream_rpc_client_continuation_is_closedrdrer#r#r$�	is_closedfszClientContinuation.is_closedc	Cs.z|j��W|j�d�n|j�d�0dSr)rQ�on_continuation_closedrrrIrer#r#r$�_on_continuation_closedisz*ClientContinuation._on_continuation_closedcCs.t||||�\}}}}|jj||||d�dSra)rDrQ�on_continuation_messagerbr#r#r$�_on_continuation_messageps�z+ClientContinuation._on_continuation_message)r&r'r(r)rSrrrrr;rprr<r	rtrurvrxrzrqr#r#rVr$r�s8�
�J�
�>rc@s@eZdZdZeeeeee	dd�dd��Z
edd�dd��ZdS)	ra�Base class for handling stream continuation events.

    Inherit from this class and override methods to handle events.
    All callbacks will be invoked on the same thread (the same thread used by
    the connection).

    A common pattern is to store the continuation within its handler.
    Example::

        continuation_handler.continuation = connection.new_stream(continuation_handler)
    Nr3cKsdS)a�Invoked when a message is received on this continuation.

        Args:
            headers: Message headers.

            payload: Binary message payload.

            message_type: Message type.

            flags: Message flags. Values from :class:`MessageFlag` may be
                XORed together. Not all flags can be used with all message
                types, consult documentation.

            **kwargs: Forward compatibility kwargs.
        Nr#r8r#r#r$ry�sz1ClientContinuationHandler.on_continuation_messager+cKsdS)aYInvoked when the continuation is closed.

        Once the continuation is closed, no more messages may be sent or received.
        The continuation is closed when a message is sent or received with
        the TERMINATE_STREAM flag, or when the connection shuts down.

        Args:
            **kwargs: Forward compatibility kwargs.
        Nr#)r!r/r#r#r$rw�sz0ClientContinuationHandler.on_continuation_closed)r&r'r(r)rrrr;rr<ryrwr#r#r#r$rzs�r)$r)r\�abcrrrErZawscrt.exceptionsZawscrt.eventstreamrZ	awscrt.iorrr�collections.abcr	�concurrent.futuresr
�enumr�	functoolsr�typingr
rr�__all__rrrrCrDrLrrrr#r#r#r$�<module>s.
*Kn2

Youez - 2016 - github.com/yon3zu
LinuXploit