3 \]g@sddlZddlZddlZddlZddlZddlZddlmZddlmZddlm Z ej dZ gZ ddZ ejeje ZGd d d eZdS) N) exceptions) namespace)packetzsocketio.clientcCs*xtddD]}|jjqWt||S)zSIGINT handler. Notify any clients that are in a reconnect loop to abort. Other disconnection tasks are handled at the engine.io level. N)reconnecting_clients_reconnect_abortsetoriginal_signal_handler)sigframeclientr :/tmp/pip-build-mqc4i71p/python-socketio/socketio/client.pysignal_handlersrc@seZdZdZdAd d Zd d ZdBd dZddZddZidddfddZ ddZ dCddZ dDddZ dEddZ dd Zd!d"Zd#d$ZdFd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Zd=d>Zd?d@ZdS)GClienta A Socket.IO client. 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 infinity 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``. :param binary: ``True`` to support binary payloads, ``False`` to treat all payloads as text. On Python 2, if this is set to ``True``, ``unicode`` values are treated as text, and ``str`` and ``bytes`` values are treated as binary. This option has no effect on Python 3, where text and binary payloads are always automatically discovered. :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. The Engine.IO configuration supports the following settings: :param request_timeout: A timeout in seconds for requests. The default is 5 seconds. :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 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``. Trr?FNc Ks^||_||_||_||_||_||_| } | jdd} | dk rD| | d<|dk r\|tj_ || d<|j f| |_ |j j d|j |j j d|j|j j d|jt|ts||_nRt|_tjj o|jjtjkr|r|jjtjn|jjtj|jjtjd|_d|_d|_ d|_!d|_"d|_#d|_$g|_%i|_i|_&i|_'d|_(d|_)|j j*|_+dS)Nengineio_loggerloggerjsonconnectmessage disconnectF), reconnectionreconnection_attemptsreconnection_delayreconnection_delay_maxrandomization_factorbinarypoprPacketr_engineio_client_classeioon_handle_eio_connect_handle_eio_message_handle_eio_disconnect isinstanceboolrdefault_loggerloggingroothandlerslevelNOTSETsetLevelINFOERROR addHandler StreamHandlerconnection_urlconnection_headersconnection_transportsconnection_namespaces socketio_pathsid connected namespacesnamespace_handlers callbacks_binary_packet_reconnect_task create_eventr) selfrrrrrrrrkwargsZengineio_optionsrr r r__init__NsP   zClient.__init__cCsdS)NFr )rAr r ris_asyncio_basedszClient.is_asyncio_basedcs0pdfdd}|dkr$|S||dS)aRegister an event handler. :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 handler: The function that should be invoked to handle the event. When this parameter is not given, the method acts as a decorator for the handler function. :param namespace: The Socket.IO namespace for the event. If this argument is omitted the handler is associated with the default namespace. Example usage:: # as a decorator: @sio.on('connect') def connect_handler(): print('Connected!') # as a method: def message_handler(msg): print('Received message: ', msg) sio.send( 'response') sio.on('message', message_handler) The ``'connect'`` event handler receives no arguments. The ``'message'`` handler and handlers for custom event names receive the message payload as only argument. Any values returned from a message handler will be passed to the client's acknowledgement callback function if it exists. The ``'disconnect'`` handler does not take arguments. /cs&jkrij<|j<|S)N)r,)handler)eventrrAr r set_handlers  zClient.on..set_handlerNr )rArGrFrrHr )rGrrArr#s !z Client.oncsTtdkr.set_handlerN)lencallabler#rI)rArJrBrHr )rJrBrArrGs$z Client.eventcCsFt|tjstd|j|jkr,td|j|||j|j<dS)zRegister a namespace handler object. :param namespace_handler: An instance of a :class:`Namespace` subclass that handles all the event traffic for a namespace. zNot a namespace instancez+Not a valid namespace class for this clientN)r'rZClientNamespace ValueErrorrDZ _set_clientr<)rAnamespace_handlerr r rregister_namespaces   zClient.register_namespacez socket.iocCs||_||_||_||_||_|dkrFt|jjjt|j j}nt |t j r^|g}||_dd|D|_ y|jj||||dWn>tjjk r}zt jtj|jddWYdd}~XnXd|_dS)aConnect 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. :param headers: A dictionary with custom headers to send with the connection request. :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 list of custom namespaces to connect, in addition to the default namespace. If not given, the namespace list is obtained from the registered event handlers. :param socketio_path: The endpoint where the Socket.IO server is installed. The default value is appropriate for most cases. Example usage:: sio = socketio.Client() sio.connect('http://localhost:5000') NcSsg|]}|dkr|qS)rEr ).0nr r r sz"Client.connect..)headers transportsZ engineio_pathrT)r4r5r6r7r8rr,keysunionr<r'six string_typesr;r"rengineiorConnectionError raise_fromrJr:)rAurlrSrTr;r8excr r rrs$   *zClient.connectcCs>x8|jj|jd|jsP|jj|jjdkrPqWdS)zWait until the connection with the server ends. Client applications can use this function to block the main thread during the life of the connection. rr:N)r"waitsleepr?joinstate)rAr r rr^s    z Client.waitcCs|pd}|dkr(||jkr(tj|d|jjd|||dk rN|j||}nd}tjrf|j rfd}nd}t |t r~t |}n|dk r|g}ng}|j t jt j||g|||ddS)a0Emit a custom event to one or more connected clients. :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 client or clients. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. If a ``list`` or ``dict``, the data will be serialized as JSON. :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 the client has received the message. The arguments that will be passed to the function are those provided by the client. Callback functions can only be used when addressing an individual client. rEz is not a connected namespace.zEmitting event "%s" [%s]NF)rdataidr)r;rZBadNamespaceErrorrinfo_generate_ack_idrWPY2rr'tuplelist _send_packetrr EVENT)rArGrbrcallbackrcrr r remit s&    z Client.emitcCs|jd|||ddS)aSend a message to one or more connected clients. 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 client or clients. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. If a ``list`` or ``dict``, the data will be serialized as JSON. :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 the client has received the message. The arguments that will be passed to the function are those provided by the client. Callback functions can only be used when addressing an individual client. r)rbrrkN)rl)rArbrrkr r rsendKs z Client.send<csz|jjgfdd}|j||||dj|dsBtjtddkrZdStddkrvddSdS)aEmit a custom event to a client and wait for the response. :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 client or clients. Data can be of type ``str``, ``bytes``, ``list`` or ``dict``. If a ``list`` or ``dict``, the data will be serialized as JSON. :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 client acknowledges the event, then a ``TimeoutError`` exception is raised. csj|jdS)N)appendr)rJ) callback_argscallback_eventr revent_callbackss z#Client.call..event_callback)rbrrk)timeoutrrN)r"r@rlr^r TimeoutErrorrK)rArGrbrrsrrr )rprqrcall`s   z Client.callcCsTx$|jD]}|jtjtj|dqW|jtjtjddd|_|jjdddS)zDisconnect from the server.)rrEFT)abortN)r;rirr DISCONNECTr:r"r)rArQr r rrs  zClient.disconnectcCs |jjS)zReturn the name of the transport used by the client. The two possible values returned by this function are ``'polling'`` and ``'websocket'``. )r" transport)rAr r rrxszClient.transportcOs|jj|f||S)adStart 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. This function returns an object compatible with the `Thread` class in the Python standard library. The `start()` method on this object is already called by this function. )r"start_background_task)rAtargetrJrBr r rryszClient.start_background_taskcCs |jj|S)aSleep 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. )r"r_)rAsecondsr r rr_sz Client.sleepcCsN|j}t|tr:d}x2|D]}|jj||dd}qWn|jj|dddS)z&Send a Socket.IO packet to the server.F)rTN)encoder'rhr"rm)rApktencoded_packetrepr r rris   zClient._send_packetcCsL|pd}||jkr&dtjdi|j|<tj|j|d}||j||<|S)z/Generate a unique identifier for an ACK packet.rErr)r= itertoolscountrWnext)rArrkrcr r rres  zClient._generate_ack_idcCsr|pd}|jjdj||jd|d|dkrXx<|jD]}|jtjtj|dq8Wn||jkrn|jj |dS)NrEzNamespace {} is connectedr)r) rrdformat_trigger_eventr;rirr CONNECTro)rArrQr r r_handle_connects  zClient._handle_connectcCst|js dS|pd}|dkr>x|jD]}|jd|dq"Wg|_|jd|d||jkrb|jj||dkrpd|_dS)NrEr)rF)r:r;rremove)rArrQr r r_handle_disconnects   zClient._handle_disconnectcCs|pd}|jjd|d||j|d|f|dd}|dk r|dkrPg}nt|trdt|}n|g}tjr~|j r~d}nd}|j t j t j ||||ddS)NrEzReceived event "%s" [%s]rrF)rrcrbr) rrdrr'rgrhrWrfrrirr ACK)rArrcrbrrr r r _handle_events  zClient._handle_eventc Csn|pd}|jjd|d}y|j||}Wn tk rL|jjdYnX|j||=|dk rj||dS)NrEzReceived ack [%s]z$Unknown callback received, ignoring.)rrdr=KeyErrorwarning)rArrcrbrkr r r _handle_acks zClient._handle_ackcCs~|pd}|jjdj||dkr*t}nt|ttfs>|f}|jd|f|||jkrf|jj||dkrzg|_d|_ dS)NrEz'Connection to namespace {} was rejectedZ connect_errorF) rrdrrgr'rhrr;rr:)rArrbr r r _handle_errors   zClient._handle_errorcGsN||jkr*||j|kr*|j|||S||jkrJ|j|j|f|SdS)z$Invoke an application event handler.N)r,r<Z trigger_event)rArGrrJr r rr s   zClient._trigger_eventc Cs |jjtj|d}|j}x|}|d9}||jkr<|j}||jdtjd7}|jj dj ||jj |r|jj dP|d7}y"|j |j |j|j|j|jdWntjtfk rYnX|jj dd|_P|jr ||jkr |jj dPq Wtj|dS) Nrrz1Connection failed, new attempt in {:.02f} secondszReconnect task aborted)rSrTr;r8zReconnection successfulz0Maximum reconnection attempts reached, giving up)rclearrrorrrrandomrrdrr^rr4r5r6r7r8rrZrMr?rr)rAZ attempt_countZ current_delaydelayr r r_handle_reconnectsD       zClient._handle_reconnectcCs|jjd|jj|_dS)z&Handle the Engine.IO connection event.z Engine.IO connection establishedN)rrdr"r9)rAr r rr$:s zClient._handle_eio_connectcCs$|jrT|j}|j|rRd|_|jtjkr>|j|j|j|jn|j |j|j|jntj |d}|jtj krz|j |jn|jtj kr|j|jn|jtjkr|j|j|j|jnj|jtjkr|j |j|j|jnH|jtjks|jtjkr||_n(|jtjkr|j|j|jntddS)zDispatch Engine.IO messages.N)r~zUnknown packet type.)r>add_attachmentZ packet_typerZ BINARY_EVENTrrrcrbrr rrrwrrjrZ BINARY_ACKr1rrM)rArbr}r r rr%?s,         zClient._handle_eio_messagecCs|jjd|jrJx|jD]}|jd|dqW|jdddg|_d|_i|_d|_d|_|jj dkr||j r||j |j |_ dS)z)Handle the Engine.IO disconnection event.zEngine.IO connection droppedr)rrEFNr:)rrdr:r;rr=r>r9r"rarryrr?)rArQr r rr&[s  zClient._handle_eio_disconnectcCstjS)N)rYr)rAr r rr!kszClient._engineio_client_class)TrrrrFFN)NN)NNN)NN)NNrn)r)rI __module__ __qualname____doc__rCrDr#rGrOrr^rlrmrurrxryr_rirerrrrrrrr$r%r&r!r r r rrs@. 1 -#, +        %r)rr*rsignalrYrWrrr getLoggerr)rrSIGINTr objectrr r r rs