� ���g�l���ddlZddlZddlZddlZddlmZddlmZddlmZejd��Z Gd�dej ��Z dS) �N�)� base_client)� exceptions)�packetzsocketio.clientc��eZdZdZd�Zidddddddfd�Zd �Zd d �Zd!d �Zd"d �Z d�Z d�Z d�Z d#d�Z d�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZdS)$� AsyncClientar A Socket.IO client for asyncio. This class implements a fully compliant Socket.IO web client with support for websocket and long-polling transports. :param reconnection: ``True`` if the client should automatically attempt to reconnect to the server after an interruption, or ``False`` to not reconnect. The default is ``True``. :param reconnection_attempts: How many reconnection attempts to issue before giving up, or 0 for infinite attempts. The default is 0. :param reconnection_delay: How long to wait in seconds before the first reconnection attempt. Each successive attempt doubles this delay. :param reconnection_delay_max: The maximum delay between reconnection attempts. :param randomization_factor: Randomization amount for each delay between reconnection attempts. The default is 0.5, which means that each delay is randomly adjusted by +/- 50%. :param logger: To enable logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. The default is ``False``. Note that fatal errors are logged even when ``logger`` is ``False``. :param json: An alternative json module to use for encoding and decoding packets. Custom json modules must have ``dumps`` and ``loads`` functions that are compatible with the standard library versions. :param handle_sigint: Set to ``True`` to automatically handle disconnection when the process is interrupted, or to ``False`` to leave interrupt handling to the calling application. Interrupt handling can only be enabled when the client instance is created in the main thread. The Engine.IO configuration supports the following settings: :param request_timeout: A timeout in seconds for requests. The default is 5 seconds. :param http_session: an initialized ``aiohttp.ClientSession`` object to be used when sending requests to the server. Use it if you need to add special client options such as proxy servers, SSL certificates, custom CA bundle, etc. :param ssl_verify: ``True`` to verify SSL certificates, or ``False`` to skip SSL certificate verification, allowing connections to servers with self signed certificates. The default is ``True``. :param websocket_extra_options: Dictionary containing additional keyword arguments passed to ``websocket.create_connection()``. :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. The default is ``False``. Note that fatal errors are logged even when ``engineio_logger`` is ``False``. c��dS)NT���selfs �e/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/socketio/async_client.py�is_asyncio_basedzAsyncClient.is_asyncio_basedFs���t�Nz socket.ioTrFc ���K�|jrtjd���||_||_||_||_||_||_|��tt|j � ����� t|j� ��������}d|vr|�d��t!|��dkrdg}nt#|t$��r|g}||_i|_|j�|j���|_n|j���|�|j���d{V��} |�|j���d{V��} |j�| | ||����d{V��n�#t4jj$r�} |jD]O} |�d| t!| j��dkr | jdn | jd���d{V���P| r0|����d{V��|jjd krYd} ~ dStj| jd��| �d} ~ wwxYw|r� t?j |j�!��|���d{V��|j���t|j��t|j��krn�wn#t>j"$rYnwxYwt|j��t|j��kr.|�#���d{V��tjd ���d |_dS) af Connect to a Socket.IO server. :param url: The URL of the Socket.IO server. It can include custom query string parameters if required by the server. If a function is provided, the client will invoke it to obtain the URL each time a connection or reconnection is attempted. :param headers: A dictionary with custom headers to send with the connection request. If a function is provided, the client will invoke it to obtain the headers dictionary each time a connection or reconnection is attempted. :param auth: Authentication data passed to the server with the connection request, normally a dictionary with one or more string key/value pairs. If a function is provided, the client will invoke it to obtain the authentication data each time a connection or reconnection is attempted. :param transports: The list of allowed transports. Valid transports are ``'polling'`` and ``'websocket'``. If not given, the polling transport is connected first, then an upgrade to websocket is attempted. :param namespaces: The namespaces to connect as a string or list of strings. If not given, the namespaces that have registered event handlers are connected. :param socketio_path: The endpoint where the Socket.IO server is installed. The default value is appropriate for most cases. :param wait: if set to ``True`` (the default) the call only returns when all the namespaces are connected. If set to ``False``, the call returns as soon as the Engine.IO transport is connected, and the namespaces will connect in the background. :param wait_timeout: How long the client should wait for the connection. The default is 1 second. This argument is only considered when ``wait`` is set to ``True``. :param retry: Apply the reconnection logic if the initial connection attempt fails. The default is ``False``. Note: this method is a coroutine. Example usage:: sio = socketio.AsyncClient() await sio.connect('http://localhost:5000') zAlready connectedN�*r�/)�headers� transports� engineio_path� connect_errorr� connectedTz(One or more namespaces failed to connect)$rr�ConnectionError�connection_url�connection_headers�connection_auth�connection_transports�connection_namespaces� socketio_path�list�set�handlers�keys�union�namespace_handlers�remove�len� isinstance�str� namespaces�_connect_event�eio� create_event�clear�_get_real_value�connect�engineio�_trigger_event�args�_handle_reconnect�state�asyncio�wait_for�wait� TimeoutError� disconnect)r �urlr�authrr)rr7� wait_timeout�retry�real_url� real_headers�exc�ns r r/zAsyncClient.connectIs,����` �>� B��,�-@�A�A� A�!���")���#���%/��"�%/��"�*��� � ��c�$�-�"4�"4�"6�"6�7�7�=�=��D�+�0�0�2�2�3�3�5�5�6�6�J��j� � ��!�!�#�&�&�&��:���!�#�#�!�U� �� � �C� (� (� &�$��J�%/��"���� � � &�"&�(�"7�"7�"9�"9�D� � � � � %� %� '� '� '��-�-�d�.A�B�B�B�B�B�B�B�B��!�1�1�$�2I�J�J�J�J�J�J�J�J� � C��(�"�"�8�\�.8�1>�#�@�@� @� @� @� @� @� @� @� @���"�2� C� C� C��/� G� G���)�)�#�Q�#&�s�x�=�=�1�#4�#4�C�H�Q�K�K�#�(�1�+�G�G�G�G�G�G�G�G�G�G�� ��,�,�.�.�.�.�.�.�.�.�.��8�>�[�0�0��F�F�F�F�F��,�S�X�a�[�9�9�s� B����� C���� � @� ��!�*�4�+>�+C�+C�+E�+E�+7�9�9�9�9�9�9�9�9�9��'�-�-�/�/�/��4�?�+�+�s�4�3M�/N�/N�N�N�� � ���'� � � ��� �����4�?�#�#�s�4�+E�'F�'F�F�F��o�o�'�'�'�'�'�'�'�'�'� �0�>�@�@�@�����s2� $F/�/I1�BI,� I,�,I1�7A8K0�0L�Lc��K� |j����d{V��|�d���d{V��|js"|jjdkrt d���bdS|j�d{V��|jjdkrdS��)z�Wait until the connection with the server ends. Client applications can use this function to block the main thread during the life of the connection. Note: this method is a coroutine. TNrr�oops)r+r7�sleep�_reconnect_taskr4�printr s r r7zAsyncClient.wait�s����� ��(�-�-�/�/� !� !� !� !� !� !� !��*�*�Q�-�-� � � � � � � ��'� ��8�>�[�0�0��&�M�M�M�����&� &� &� &� &� &� &� &��x�~��,�,��� rc��K�|pd}||jvrtj|dz���|j�d||��|�|�||��}nd}t |t��rt|��}n|�|g}ng}|� |� tj ||g|z|������d{V��dS)atEmit a custom event to the server. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param data: The data to send to the server. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param callback: If given, this function will be called to acknowledge the server has received the message. The arguments that will be passed to the function are those provided by the server. Note: this method is not designed to be used concurrently. If multiple tasks are emitting at the same time on the same client connection, then messages composed of multiple packets may end up being sent in an incorrect sequence. Use standard concurrency solutions (such as a Lock object) to prevent this situation. Note 2: this method is a coroutine. rz is not a connected namespace.zEmitting event "%s" [%s]N)� namespace�data�id) r)r�BadNamespaceError�logger�info�_generate_ack_idr'�tupler� _send_packet� packet_classr�EVENT)r �eventrIrH�callbackrJs r �emitzAsyncClient.emit�s$����4�$�� � �D�O� +� +��.��<�<�>�>� >� � ���3�U�I�F�F�F� � ��&�&�y�(�;�;�B�B��B� �d�E� "� "� ���:�:�D�D� � ��6�D�D��D����� 1� 1� �L�I�U�G�d�N�r�!2�!K�!K�L�L� L� L� L� L� L� L� L� L� Lrc��HK�|�d|||����d{V��dS)a�Send a message to the server. This function emits an event with the name ``'message'``. Use :func:`emit` to issue custom event names. :param data: The data to send to the server. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param callback: If given, this function will be called to acknowledge the server has received the message. The arguments that will be passed to the function are those provided by the server. Note: this method is a coroutine. �message�rIrHrTN)rU)r rIrHrTs r �sendzAsyncClient.send�sT����(�i�i� �� �!)��+�+� +� +� +� +� +� +� +� +� +r�<c�����K�|j����g���fd�}|�||||����d{V�� tj����|���d{V��n'#tj$rtj��d�wxYwt�d��dkr�dn(t�d��dkr�ddndS)a�Emit a custom event to the server and wait for the response. This method issues an emit with a callback and waits for the callback to be invoked before returning. If the callback isn't invoked before the timeout, then a ``TimeoutError`` exception is raised. If the Socket.IO connection drops during the wait, this method still waits until the specified timeout. :param event: The event name. It can be any string. The event names ``'connect'``, ``'message'`` and ``'disconnect'`` are reserved and should not be used. :param data: The data to send to the server. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. To send multiple arguments, use a tuple where each element is of one of the types indicated above. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the event is emitted to the default namespace. :param timeout: The waiting timeout. If the timeout is reached before the server acknowledges the event, then a ``TimeoutError`` exception is raised. Note: this method is not designed to be used concurrently. If multiple tasks are emitting at the same time on the same client connection, then messages composed of multiple packets may end up being sent in an incorrect sequence. Use standard concurrency solutions (such as a Lock object) to prevent this situation. Note 2: this method is a coroutine. c�Z����|������dS�N)�appendr )r2� callback_args�callback_events ��r �event_callbackz(AsyncClient.call.<locals>.event_callback0s/��� � � �� &� &� &� � � � � � � � rrXNrr) r+r,rUr5r6r7r8rr&)r rSrIrH�timeoutrar_r`s @@r �callzAsyncClient.calls=������>��.�.�0�0��� � !� !� !� !� !� !��i�i��D�I�!/��1�1� 1� 1� 1� 1� 1� 1� 1� 6��"�>�#6�#6�#8�#8�'�B�B� B� B� B� B� B� B� B� B���#� 6� 6� 6��)�+�+�� 5� 6����#&�}�Q�'7�#8�#8�1�#<�#<�}�Q���(+�M�!�,<�(=�(=��(B�(B��q�!�!�$�$�� s �-A4�4$Bc���K�|jD]<}|�|�tj|������d{V���=|j����d{V��dS)zODisconnect from the server. Note: this method is a coroutine. �rHN)r)rPrQr� DISCONNECTr+r9)r rAs r r9zAsyncClient.disconnect>s������� 2� 2�A��#�#�D�$5�$5�f�6G�./�%6�%1�%1�2�2� 2� 2� 2� 2� 2� 2� 2� 2��h�!�!�#�#�#�#�#�#�#�#�#�#�#rc��K�|jr|����d{V��dS|jr(|j���|j�d{V��dSdS)aAStop the client. If the client is connected to a server, it is disconnected. If the client is attempting to reconnect to server, the reconnection attempts are stopped. If the client is not connected to a server and is not attempting to reconnect, then this function does nothing. N)rr9rE�_reconnect_abortr r s r �shutdownzAsyncClient.shutdownJs����� �>� '��/�/�#�#� #� #� #� #� #� #� #� #� #� � !� '� � !� %� %� '� '� '��&� &� &� &� &� &� &� &� &� &� '� 'rc�.�|jj|g|�Ri|��S)a�Start a background task using the appropriate async model. This is a utility function that applications can use to start a background task using the method that is compatible with the selected async mode. :param target: the target function to execute. :param args: arguments to pass to the function. :param kwargs: keyword arguments to pass to the function. The return value is a ``asyncio.Task`` object. )r+�start_background_task)r �targetr2�kwargss r rkz!AsyncClient.start_background_taskXs)��.�t�x�-�f�F�t�F�F�F�v�F�F�Frrc��FK�|j�|���d{V��S)a<Sleep for the requested amount of time using the appropriate async model. This is a utility function that applications can use to put a task to sleep without having to worry about using the correct call for the selected async mode. Note: this method is a coroutine. N)r+rD)r �secondss r rDzAsyncClient.sleepgs.�����X�^�^�G�,�,�,�,�,�,�,�,�,rc��K�t|��s|Stj|��r|���d{V��S|��S)zTReturn the actual value, for parameters that can also be given as callables.N)�callabler5�iscoroutinefunction)r �values r r.zAsyncClient._get_real_valuessQ�������� ��L� � &�u� -� -� !�����=�=�=�=�=�=� ��u�w�w�rc���K�|���}t|t��r'|D]"}|j�|���d{V���#dS|j�|���d{V��dS)z&Send a Socket.IO packet to the server.N)�encoder'rr+rY)r �pkt�encoded_packet�eps r rPzAsyncClient._send_packet|s����������� �n�d� +� +� 0�$� (� (���h�m�m�B�'�'�'�'�'�'�'�'�'�'� (� (��(�-�-��/�/� /� /� /� /� /� /� /� /� /rc��K�|pd}||jvr{|j�d|�d���|pi�d|j��|j|<|�d|����d{V��|j���dSdS)Nrz Namespace z is connected�sidr/re)r)rLrM�getrzr1r*r �r rHrIs r �_handle_connectzAsyncClient._handle_connect�s������$�� � �D�O� +� +� �K� � �B�)�B�B�B� C� C� C�*.�*�"�)9�)9�%���)J�)J�D�O�I� &��%�%�i�9�%�E�E� E� E� E� E� E� E� E� � � #� #� %� %� %� %� %� ,� +rc��.K�|jsdS|pd}|�d||jj���d{V��|�d|���d{V��||jvr|j|=|js*d|_|j�d����d{V��dSdS)Nrr9�__disconnect_finalFT)�abort)rr1�reason�SERVER_DISCONNECTr)r+r9)r rHs r �_handle_disconnectzAsyncClient._handle_disconnect�s������~� � �F��$�� ��!�!�,� �"&�+�"?�A�A� A� A� A� A� A� A� A��!�!�"6� �B�B�B�B�B�B�B�B�B� ��� '� '��� �*��� 2�"�D�N��(�%�%�D�%�1�1� 1� 1� 1� 1� 1� 1� 1� 1� 1� 2� 2rc��vK�|pd}|j�d|d|��|j|d|g|dd��R��d{V��}|�k|�g}n(t|t��rt |��}n|g}|�|�tj |||������d{V��dSdS)NrzReceived event "%s" [%s]rr)rHrJrI) rLrMr1r'rOrrPrQr�ACK)r rHrJrI�rs r � _handle_eventzAsyncClient._handle_event�s�����$�� � � ���3�T�!�W�i�H�H�H�%�$�%�d�1�g�y�D�4����8�D�D�D� D� D� D� D� D� D�� �>��y�����A�u�%�%� ��A�w�w����s���#�#�D�$5�$5�� �i�B�T�%6�%C�%C�D�D� D� D� D� D� D� D� D� D� D� �>rc��:K�|pd}|j�d|��d} |j||}|j||=n*#t$r|j�d��YnwxYw|�(t j|��r ||��d{V��dS||�dSdS)NrzReceived ack [%s]z$Unknown callback received, ignoring.)rLrM� callbacks�KeyError�warningr5rr)r rHrJrIrTs r � _handle_ackzAsyncClient._handle_ack�s������$�� � � ���,�i�8�8�8��� .��~�i�0��4�H� ��y�)�"�-�-�� � H� H� H� �K� � � F� G� G� G� G� G� H���� � ��*�8�4�4� ��h��o�%�%�%�%�%�%�%�%�%���$����� � s�A�$A.�-A.c��vK�|pd}|j�d�|����|�t��}nt |tt f��s|f}|jd|g|�R��d{V��|j���||j vr|j |=|dkri|_ d|_ dSdS)Nrz'Connection to namespace {} was rejectedrF) rLrM�formatrOr'rr1r*r r)rr|s r � _handle_errorzAsyncClient._handle_error�s������$�� � � ���B�I�I� ��� � � � �<��7�7�D�D��D�5�$�-�0�0� ��7�D�!�d�!�/�9�D�t�D�D�D�D�D�D�D�D�D�D� ����!�!�!� ��� '� '��� �*� �� � � �D�O�"�D�N�N�N� � rc���K�|�|||��\}}|r�tj|��rQ ||��d{V��}n+#t$r|dkr||dd���d{V��}n�YnwxYwnC#tj$rd}Yn0wxYw ||�}n%#t$r|dkr||dd��}n�YnwxYw|S|�||��\}}|r|j|g|�R��d{V��SdS)z$Invoke an application event handler.Nr9�����)�_get_event_handlerr5rr� TypeError�CancelledError�_get_namespace_handler� trigger_event)r rSrHr2�handler�rets r r1zAsyncClient._trigger_event�s������/�/��y�$�G�G� ��� � ��*�7�3�3� � �"�$+�G�T�N�2�2�2�2�2�2����$�"�"�"�!�L�0�0�(/���c�r�c��(;�";�";�";�";�";�";�C�C�!� �C� "�������-�����C�C�C������!�'�4�.�C�C�� ����� �,�,�%�g�t�C�R�C�y�1������ �����J��3�3�I�t�D�D� ��� � =�.��.�u�<�t�<�<�<�<�<�<�<�<�<� <� =� =sA� A�A-�%A)�&A-�(A)�)A-�-B�B�B � B-�,B-c ���K�|j�|j���|_|j���tj�|��d}|j} |}|dz}||jkr|j}||j dtj ��zdz zz }|j � d� |����d} tj|j���|���d{V��d}n'#tj$rYntj$rd}YnwxYw|rB|j � d��|jD]}|�d|� ���d{V��� n�|dz } |�|j|j|j|j|j|jd� ���d{V��|j � d ��d|_nr#t8jt<f$rYnwxYw|jrM||jkrB|j � d ��|jD]}|�d|� ���d{V��� n���tj� |��dS) NrT�rz1Connection failed, new attempt in {:.02f} secondsFzReconnect task abortedrre)rr;rr)rr=zReconnection successfulz0Maximum reconnection attempts reached, giving up)!rhr+r,r-r�reconnecting_clientsr^�reconnection_delay�reconnection_delay_max�randomization_factor�randomrLrMr�r5r6r7r8r�rr1r/rrrrrrErr� ValueError�reconnection_attemptsr%)r � attempt_count� current_delay�delayr�rAs r r3zAsyncClient._handle_reconnect�sT���� � � (�$(�H�$9�$9�$;�$;�D� !� ��#�#�%�%�%��(�/�/��5�5�5�� ��/� �- �!�E� �Q� �M��t�2�2�2��3�� �T�.�!�f�m�o�o�2E��2I�J� J�E� �K� � �C�J�J���� � � ��E� ��&�t�'<�'A�'A�'C�'C�U�K�K�K�K�K�K�K�K�K������'� � � ����)� � � ����� ����� �� � � �!9�:�:�:��3�;�;�A��-�-�.B�89�.�;�;�;�;�;�;�;�;�;�;�� �Q� �M� ��l�l�4�#6�+/�+B�(,�(<�.2�.H�.2�.H�15�1C�).� #�0�0�0�0�0�0�0�0�0�� � � �!:�;�;�;�'+��$��� �.� �;� � � ��� ���� �)� �!�T�%?�?�?�� � � �F�H�H�H��3�;�;�A��-�-�.B�89�.�;�;�;�;�;�;�;�;�;�;��[- �\ �(�/�/��5�5�5�5�5s+�4D � D0�D0�/D0�=AG�G8�7G8c��.K�|j�d��|jj|_|�|j���d{V��pi}|jD]=}|�|�tj ||������d{V���>dS)z&Handle the Engine.IO connection event.z Engine.IO connection establishedN)rIrH) rLrMr+rzr.rrrPrQr�CONNECT)r � real_authrAs r �_handle_eio_connectzAsyncClient._handle_eio_connect%s����� � ���;�<�<�<��8�<����.�.�t�/C�D�D�D�D�D�D�D�D�J�� ��+� >� >�A��#�#�D�$5�$5���Y�!�%6�%=�%=�>�>� >� >� >� >� >� >� >� >� >� >rc��^K�|jr�|j}|�|��rxd|_|jtjkr.|�|j|j|j���d{V��dS|� |j|j|j���d{V��dSdS|� |���}|jtj kr(|� |j|j���d{V��dS|jtj kr"|�|j���d{V��dS|jtjkr.|�|j|j|j���d{V��dS|jtjkr.|� |j|j|j���d{V��dS|jtjks|jtjkr ||_dS|jtjkr(|�|j|j���d{V��dSt)d���)zDispatch Engine.IO messages.N)rwzUnknown packet type.)�_binary_packet�add_attachment� packet_typer� BINARY_EVENTr�rHrJrIr�rQr�r}rfr�rRr�� BINARY_ACK� CONNECT_ERRORr�r�)r rIrvs r �_handle_eio_messagezAsyncClient._handle_eio_message.s`���� � � 9��%�C��!�!�$�'�'� L�&*��#��?�f�&9�9�9��,�,�S�]�C�F�C�H�M�M�M�M�M�M�M�M�M�M�M��*�*�3�=�#�&�#�(�K�K�K�K�K�K�K�K�K�K�K�  L� L��#�#�4�#�8�8�C���&�.�0�0��*�*�3�=�#�(�C�C�C�C�C�C�C�C�C�C�C���F�$5�5�5��-�-�c�m�<�<�<�<�<�<�<�<�<�<�<���F�L�0�0��(�(�������I�I�I�I�I�I�I�I�I�I�I���F�J�.�.��&�&�s�}�c�f�c�h�G�G�G�G�G�G�G�G�G�G�G���F�$7�7�7��O�v�'8�8�8�&)��#�#�#���F�$8�8�8��(�(�����A�A�A�A�A�A�A�A�A�A�A� �!7�8�8�8rc��K�|j�d��|jo|jjdk}|jrS|jD]=}|�d||���d{V��|s|�d|���d{V���>i|_d|_i|_d|_ d|_ |r(|j s#|� |j ��|_ dSdSdS)z)Handle the Engine.IO disconnection event.zEngine.IO connection droppedrr9NrF)rLrM� reconnectionr+r4rr)r1r�r�rzrErkr3)r r��will_reconnectrAs r �_handle_eio_disconnectz"AsyncClient._handle_eio_disconnectJs���� � ���7�8�8�8��*�L�t�x�~��/L�� �>� #��_� G� G���)�)�,��6�B�B�B�B�B�B�B�B�B�%�G��-�-�.B�A�F�F�F�F�F�F�F�F�F�� �D�O�"�D�N����"������ � (�$�"6� (�#'�#=�#=��&�$(�$(�D� � � � (� (� (� (rc��tjSr])r0rr s r �_engineio_client_classz"AsyncClient._engineio_client_class\s ���#�#r)NNN)NN)NNrZ)r)�__name__� __module__� __qualname__�__doc__rr/r7rUrYrcr9rirkrDr.rPr}r�r�r�r�r1r3r�r�r�r�r rr rrs�������6�6�n���*,�$�4�!%�[�t�#$�E�i�i�i�i�V���*,L�,L�,L�,L�\+�+�+�+�..�.�.�.�` $� $� $� '� '� '� G� G� G� -� -� -� -����0�0�0�&�&�&� 2� 2� 2�D�D�D�  � � �"#�#�#� !=�!=�!=�F56�56�56�n>�>�>�9�9�9�8(�(�(�$$�$�$�$�$rr) r5�loggingr�r0�rrr� getLogger�default_logger� BaseClientrr rr �<module>r�s����������� � � � �����������������������"��"�#4�5�5��O $�O $�O $�O $�O $�+�(�O $�O $�O $�O $�O $r
Memory