2BfzddlZddlZddlZddlZddlZddlZddlmZddlmZddlm Z ejdZ gZ dZ daGdd eZy) N) exceptions namespace)packetzsocketio.clientctddD]}|jjttr t ||St j ||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_abortsetcallableoriginal_signal_handlersignaldefault_int_handler)sigframeclients O/var/www/highfloat_scraper/venv/lib/python3.12/site-packages/socketio/client.pysignal_handlerrsU 'q)&##%&'(&sE22))#u55ceZdZdZ d#dZdZd$dZdZd Zidddd ddfd Z d Z d%d Z d$dZ d&dZ dZd'dZdZdZd(dZdZdZdZdZdZdZdZdZdZdZdZd Zd!Zd"Z y))Clienta 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 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 serializer: The serialization method to use when transmitting packets. Valid values are ``'default'``, ``'pickle'``, ``'msgpack'`` and ``'cbor'``. Alternatively, a subclass of the :class:`Packet` class with custom implementations of the ``encode()`` and ``decode()`` methods can be provided. Client and server must use compatible serializers. :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 http_session: an initialized ``requests.Session`` 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, 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 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``. TrNc  ntQtjtjk(r(t jtj t a||_||_||_ ||_ ||_ | } | jdd} | | | d<|dk(rtj|_n$|dk(rddlm} | j$|_n||_|||j_|| d<|j)d i| |_|j*j-d|j.|j*j-d |j0|j*j-d |j2t5|t6s||_nt:|_|j8j<t>j@k(r|r*|j8jCt>jDn)|j8jCt>jF|j8jIt?jJd|_&d|_'d|_(d|_)g|_*d|_+d|_,d |_-i|_.i|_/i|_0i|_1d|_2d|_3d|_4d|_5y) Nengineio_loggerloggerdefaultmsgpackr)msgpack_packetjsonconnectmessage disconnectF)6r threadingcurrent_thread main_threadrSIGINTr reconnectionreconnection_attemptsreconnection_delayreconnection_delay_maxrandomization_factorpoprPacket packet_classr MsgPackPacketr_engineio_client_classeioon_handle_eio_connect_handle_eio_message_handle_eio_disconnect isinstanceboolrdefault_loggerlevelloggingNOTSETsetLevelINFOERROR addHandler StreamHandlerconnection_urlconnection_headersconnection_authconnection_transportsconnection_namespaces socketio_pathsid connected namespaceshandlersnamespace_handlers callbacks_binary_packet_connect_event_reconnect_taskr ) selfr'r(r)r*r+r serializerrkwargsengineio_optionsrrs r__init__zClient.__init__Zs9 # *((*i.C.C.EE&,mmFMM4B'D #(%:""4&<#$8!!*../@$G  &)8 X &  " & D  9 $ ( . < .set_handlers5 -+- i(.5DMM) $U +NrNr")rQr^r]rr_s`` ` rr3z Client.ons*B$   ? Grctdk(rCtdk(r5tdr'jdjdSfd}|S)aDecorator to register an event handler. This is a simplified version of the ``on()`` method that takes the event name from the decorated function. Example usage:: @sio.event def my_event(data): print('Received data: ', data) The above example is equivalent to:: @sio.on('my_event') def my_event(data): print('Received data: ', data) A custom namespace can be given as an argument to the decorator:: @sio.event(namespace='/test') def my_event(data): print('Received data: ', data) rrcPj|jgi|Sr\)r3__name__)r]argsrSrQs rr_z!Client.event..set_handlers+Awtwww//A$A&A'JJr)lenr r3rb)rQrcrSr_s``` rr^z Client.eventsZ0 t9>c&kQ.8DG3D-47747++,T!W5 5 K rct|tjs td|j |j k7r td|j |||j |j<y)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)r7rClientNamespace ValueErrorrX _set_clientrL)rQnamespace_handlers rregister_namespacezClient.register_namespacesp+Y-F-FG78 8  "&7&H&H&J JJK K%%d+   1 ; ;>,,-@A A!")#%/"%/"*  c$--"4"4"67==D++002356J:!#!U  C ($J%/"    &"&(("7"7"9D     % % '''(;(;<++D,C,CD  D HH  X|(2+8  : %%**<*@##))+t'3t/I/I+JJ%%**<*@4??#s4+E+E'FF! 00>@@!""22 D   "388}q0 chhqk C,,SXXa[9t C  DsIK/A*KKc |jj|jd|jsy|jj |jj dk7rym)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. rrIN)r2r|sleeprPjoinstaterWs rr|z Client.waitWsU  HHMMO JJqM''  % % 'xx~~,rcx|xsd}||jvrtj|dz|jj d||||j ||}nd}t |tr t|}n||g}ng}|j|jtj||g|z|y)aFEmit 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 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 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 thread safe. If multiple threads are emitting at the same time on the same client connection, 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. rZz is not a connected namespace.zEmitting event "%s" [%s]N)rdataid) rJrBadNamespaceErrorrinfo_generate_ack_idr7tuplers _send_packetr.rEVENT)rQr^rrcallbackrs remitz Client.emitfs0$ DOO +..<<> > 3UIF  &&y(;BB dE ":D  6DD $++FLLI274B,H Irc.|jd|||y)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 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 the server has received the message. The arguments that will be passed to the function are those provided by the server. r rrrN)r)rQrrrs rsendz Client.sends$ )$)#  %rc"|jjgfd}|j||||j|st j t ddkDrdSt ddk(rddSdS)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 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 client acknowledges the event, then a ``TimeoutError`` exception is raised. Note: this method is not thread safe. If multiple threads are emitting at the same time on the same client connection, 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. cHj|jyr\)appendr )rc callback_argscallback_events revent_callbackz#Client.call..event_callbacks   &    rrrprrN)r2rwrr|r TimeoutErrorrd)rQr^rrrqrrrs @@rcallz Client.calls...0  ! %di)  +""7"3))+ +#&}Q'7#81#<}Q (+M!,<(=(Bq!!$  rc|jD]2}|j|jtj|4|j j dy)zDisconnect from the server.rTabortN)rJrr.r DISCONNECTr2r!rQns rr!zClient.disconnectsY 1A   d//!!Q00 1 1 $'rc@|jj|xsdS)aReturn the ``sid`` associated with a connection. :param namespace: The Socket.IO namespace. If this argument is omitted the handler is associated with the default namespace. Note that unlike previous versions, the current version of the Socket.IO protocol uses different ``sid`` values per namespace. This method returns the ``sid`` for the requested namespace as a string. rZ)rJgetrQrs rget_sidzClient.get_sids""9#344rc6|jjS)zReturn the name of the transport used by the client. The two possible values returned by this function are ``'polling'`` and ``'websocket'``. )r2 transportrWs rrzClient.transports xx!!##rcB|jj|g|i|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. )r2start_background_task)rQtargetrcrSs rrzClient.start_background_tasks%.txx--fFtFvFFrc8|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. )r2r)rQsecondss rrz Client.sleepsxx~~g&&rc*t|s|S|S)zTReturn the actual value, for parameters that can also be given as callables.)r )rQvalues rryzClient._get_real_valuesLwrc|j}t|tr#|D]}|jj |y|jj |y)z&Send a Socket.IO packet to the server.N)encoder7rsr2r)rQpktencoded_packeteps rrzClient._send_packetsH nd +$ " b! " HHMM. )rc|xsd}||jvr$dtjdi|j|<t|j|d}||j||<|S)z/Generate a unique identifier for an ACK packet.rZrr)rM itertoolscountnext)rQrrrs rrzClient._generate_ack_idsd$ DNN *)*IOOA,>(?DNN9 % $..+A. /(0y!"% rc6|xsd}||jvr|jjdj||xsij d|j |j|<|j d||jjyy)NrZzNamespace {} is connectedrHrr) rJrrformatrrHr{rOr rQrrs r_handle_connectzClient._handle_connect s$ DOO + KK  8?? J K*.*")9)9%)JDOOI &    Y  ?    # # % ,rc|jsy|xsd}|jd|||jvr |j|=|js$d|_|jj dyy)NrZr!rFTr)rIr{rJr2r!rs r_handle_disconnectzClient._handle_disconnect(si~~ $  LI>  ' *"DN HH  d  +rc6|xsd}|jjd|d||j|d|g|dd}|W|g}nt|tr t |}n|g}|j |jtj|||yy)NrZzReceived event "%s" [%s]rr)rrr) rrr{r7rrsrr.rACK)rQrrrrs r _handle_eventzClient._handle_event3s$  3T!WiH D  Q >T!"X > >yAu%Aws   d// iBT0C D rc|xsd}|jjd|d} |j||}|j||=|||yy#t$r|jj dY/wxYw)NrZzReceived ack [%s]z$Unknown callback received, ignoring.)rrrMKeyErrorwarning)rQrrrrs r _handle_ackzClient._handle_ackCs$  ,i8 .~~i04H y)"-   dO  H KK   F G HsA$A87A8cj|xsd}|jjdj|| t}nt |tt fs|f}|j d|g||jj||jvr |j|=|dk(ri|_ d|_ yy)NrZz'Connection to namespace {} was rejectedroF) rrrrr7rsr{rOr rJrIrs r _handle_errorzClient._handle_errorQs$  BII   <7DD5$-07DOY>> !  ' *   DO"DN rc||jvr&||j|vr|j|||S||jvr |j|j|g|Sy)z$Invoke an application event handler.N)rKrL trigger_event)rQr^rrcs rr{zClient._trigger_eventas{  %%4==3K*K24==+E2D9 9$11 1C4**95CC 2rc|j|jj|_|jjtj |d}|j } |}|dz}||jkDr |j}||jdtjzdz zz }|jjdj||jj|r|jjdn||dz } |j|j|j |j"|j$|j&|j(|jjdd|_ tj5|y#t,j.t0f$rYnwxYw|j2r+||j2k\r|jjdl) Nrrz1Connection failed, new attempt in {:.02f} secondszReconnect task aborted)rlr~rmrJrGzReconnection successfulz0Maximum reconnection attempts reached, giving up)r r2rwrxr rr)r*r+randomrrrr|rrBrCrDrErFrGrPrrrrgr(remove)rQ attempt_count current_delaydelays r_handle_reconnectzClient._handle_reconnectls  ($(HH$9$9$;D ! ##%##D) // !E Q Mt22233 T..!fmmo2E2IJ JE KK  CJJ $$))%0   !9: Q M  T00%)%<%<"&"6"6(,(B(B(,(B(B+/+=+= ?   !:;'+$ ##D).. ;   ))!T%?%??   FH=sAF))GGc*|jjd|jj|_|j |j }|j D]3}|j|jtj||5y)z&Handle the Engine.IO connection event.z Engine.IO connection established)rrN) rrr2rHryrDrFrr.rCONNECT)rQ real_authrs rr4zClient._handle_eio_connectsz ;<88<<(()=)=> ++ >A   d//Y!0= > >rc|jr|j}|j|rd|_|jtjk(r2|j |j |j|jy|j|j |j|jyy|j|}|jtjk(r'|j|j |jy|jtjk(r|j|j y|jtjk(r2|j |j |j|jy|jtj k(r2|j|j |j|jy|jtjk(s|jtj"k(r||_y|jtj$k(r'|j'|j |jyt)d)zDispatch Engine.IO messages.N)rzUnknown packet type.)rNadd_attachment packet_typer BINARY_EVENTrrrrrr.rrrrrr BINARY_ACK CONNECT_ERRORrrg)rQrrs rr5zClient._handle_eio_messages   %%C!!$'&*#??f&9&99&&s}}cffchhG$$S]]CFFCHHE (##4#8C&..0$$S]]CHH=F$5$55'' 6FLL0""3==#&&#((CFJJ.  AF$7$77OOv'8'88&)#F$8$88""3==#((; !788rcn|jjd|jr2|jD]}|j d|i|_d|_i|_d|_d|_|jjdk(r.|jr!|j|j|_ yyy)z)Handle the Engine.IO disconnection event.zEngine.IO connection droppedr!rFNrI)rrrIrJr{rMrNrHr2rr'rrrPrs rr6zClient._handle_eio_disconnects 78 >>__ ?##LA#> ? DO"DN" 88>>[ (T->->#'#=#=&&$(D .? (rc"tjSr\)rzrrWs rr1zClient._engineio_client_classs r)Trrg?FrN)NN)NNN)NN<r\)r)!rb __module__ __qualname____doc__rUrXr3r^rjrr|rrrr!rrrrryrrrrrrrr{rr4r5r6r1r"rrrr#s5lAB>?DM>%@+Z!F $&DT{Yv *IX%*$L( 5$G"'*& ,D # &*P>98 (rr)rr;rrr#rzr/rrr getLoggerr9r rr objectrr"rrrsT """#45 6f Vf r