wgx|ddlmZddlZddlZdZ ddlmZeredejdddl Z ddl m Z m Z dd lmZddlZdd lmZdd lmZdd lmZdd lmZddlmZGddej4ZGddeeZGddZdZdZ dZ!ddZ"ddZ#ddZ$ddZ%ddZ&y#e$rdZYwxYw) )wrapsNT)socketio_manageFzThe gevent-socketio package is incompatible with this version of the Flask-SocketIO extension. Please uninstall it, and then install the latest version of python-socketio in its place.)has_request_contextjson) SessionMixin)ConnectionRefusedError)DebuggedApplication)run_with_reloader) NamespaceSocketIOTestClientc.eZdZdZdfd ZfdZxZS)_SocketIOMiddlewarezxThis WSGI middleware simply exposes the Flask application in the WSGI environment before executing the request. cL||_t| ||j|y)N socketio_path) flask_appsuper__init__wsgi_app)self socketio_apprr __class__s \/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/flask_socketio/__init__.pyrz_SocketIOMiddleware.__init__"s)" y'9'9'4  6cb|j}|j|d<t| ||S)N flask.app)copyrr__call__)renvironstart_responsers rr z_SocketIOMiddleware.__call__'s.,,.#~~ w88r) socket.io)__name__ __module__ __qualname____doc__rr __classcell__)rs@rrrs6 99rrceZdZdZy)_ManagedSessionzThis class is used for user sessions that are managed by Flask-SocketIO. It is simple dict, expanded with the Flask session attributes.N)r$r%r&r'rrr*r*-s  rr*ceZdZdZej j ZddZdZddZ ddZ dZ ddZ d Z d Zd Zd Z dd ZddZddZdZdZddZ ddZdZy)SocketIOaCreate a Flask-SocketIO server. :param app: The flask application instance. If the application instance isn't known at the time this class is instantiated, then call ``socketio.init_app(app)`` once the application instance is available. :param manage_session: If set to ``True``, this extension manages the user session for Socket.IO events. If set to ``False``, Flask's own session management is used. When using Flask's cookie based sessions it is recommended that you leave this set to the default of ``True``. When using server-side sessions, a ``False`` setting enables sharing the user session between HTTP routes and Socket.IO events. :param message_queue: A connection URL for a message queue service the server can use for multi-process communication. A message queue is not required when using a single server process. :param channel: The channel name, when using a message queue. If a channel isn't specified, a default channel will be used. If multiple clusters of SocketIO processes need to use the same message queue without interfering with each other, then each cluster should use a different channel. :param path: The path where the Socket.IO server is exposed. Defaults to ``'socket.io'``. Leave this as is unless you know what you are doing. :param resource: Alias to ``path``. :param kwargs: Socket.IO and Engine.IO server options. The Socket.IO server options are detailed below: :param client_manager: The client manager instance that will manage the client list. When this is omitted, the client list is stored in an in-memory structure, so the use of multiple connected servers is not possible. In most cases, this argument does not need to be set explicitly. :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 will be 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. To use the same json encoder and decoder as a Flask application, use ``flask.json``. :param async_handlers: If set to ``True``, event handlers for a client are executed in separate threads. To run handlers for a client synchronously, set to ``False``. The default is ``True``. :param always_connect: When set to ``False``, new connections are provisory until the connect handler returns something other than ``False``, at which point they are accepted. When set to ``True``, connections are immediately accepted, and then if the connect handler returns ``False`` a disconnect is issued. Set to ``True`` if you need to emit events from the connect handler and your client is confused when it receives events before the connection acceptance. In any other case use the default of ``False``. The Engine.IO server configuration supports the following settings: :param async_mode: The asynchronous model to use. See the Deployment section in the documentation for a description of the available options. Valid async modes are ``threading``, ``eventlet``, ``gevent`` and ``gevent_uwsgi``. If this argument is not given, ``eventlet`` is tried first, then ``gevent_uwsgi``, then ``gevent``, and finally ``threading``. The first async mode that has all its dependencies installed is then one that is chosen. :param ping_interval: The interval in seconds at which the server pings the client. The default is 25 seconds. For advanced control, a two element tuple can be given, where the first number is the ping interval and the second is a grace period added by the server. :param ping_timeout: The time in seconds that the client waits for the server to respond before disconnecting. The default is 5 seconds. :param max_http_buffer_size: The maximum size of a message when using the polling transport. The default is 1,000,000 bytes. :param allow_upgrades: Whether to allow transport upgrades or not. The default is ``True``. :param http_compression: Whether to compress packages when using the polling transport. The default is ``True``. :param compression_threshold: Only compress messages when their byte size is greater than this value. The default is 1024 bytes. :param cookie: If set to a string, it is the name of the HTTP cookie the server sends back to the client containing the client session id. If set to a dictionary, the ``'name'`` key contains the cookie name and other keys define cookie attributes, where the value of each attribute can be a string, a callable with no arguments, or a boolean. If set to ``None`` (the default), a cookie is not sent to the client. :param cors_allowed_origins: Origin or list of origins that are allowed to connect to this server. Only the same origin is allowed by default. Set this argument to ``'*'`` to allow all origins, or to ``[]`` to disable CORS handling. :param cors_credentials: Whether credentials (cookies, authentication) are allowed in requests to this server. The default is ``True``. :param monitor_clients: If set to ``True``, a background task will ensure inactive clients are closed. Set to ``False`` to disable the monitoring task (not recommended). 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``. Nc d|_i|_d|_g|_g|_i|_d|_d|_|d|vr|j|fi|y|jj|y)NT message_queue) serverserver_options wsgi_serverhandlersnamespace_handlersexception_handlersdefault_exception_handlermanage_sessioninit_appupdate)rappkwargss rrzSocketIO.__init__su   "$"$)-&" ?o7 DMM# ( (    & &v .rc "tdsi_|jd<|jj||jj d|j |_d|vr|jj dd}|jj dd}du}|r|jdrtj}nT|jd rtj}n2|jd rtj}ntj}|||| }||jd<d |jvr1|jd tk(rGfd d}||jd <|jj ddxs |jj ddxsd} | jdr| dd} tjj dr*|jj dd|jd<tj di|j|_|j"j$|_|j&D])} |j"j)| d| d| d+|j*D]} |j"j-| /t/|j"| |_|j0_yy)N extensionssocketior7client_managerr/channelzflask-socketio)zredis://z rediss://zkafka://zmq)r@ write_onlyrc6eZdZefdZefdZy)(SocketIO.init_app..FlaskSafeJSONczj5tj|i|cdddS#1swYyxYwN) app_context flask_jsondumpsargsr;r:s rrIz.SocketIO.init_app..FlaskSafeJSON.dumps9*A)//@@AAA1:czj5tj|i|cdddS#1swYyxYwrF)rGrHloadsrJs rrOz.SocketIO.init_app..FlaskSafeJSON.loadsrLrMN)r$r%r& staticmethodrIrO)r:sr FlaskSafeJSONrDs-AAAArrQpathresourcer#/rFLASK_RUN_FROM_CLI async_mode threadingr namespacerr+)hasattrr=r1r9popr7get startswithr> RedisManager KafkaManager ZmqManager KombuManagerrHosr!Serverr0rVr3onr4register_namespacer sockio_mwr) rr:r;urlr@rB queue_classqueuerQrShandlernamespace_handlers ` rr8zSocketIO.init_apps ?3 -!#)-CNN: & ""6*"11556F6:6I6IK 6 )%%))/4@C))--i9IJGJ>>";<"*"7"7K^^J/"*"7"7K^^E*"*"5"5K"*"7"7K#C/9;8=##$45 T(( (##F+z9 A A+8D   '&&**648E    # #J 5E9D    s #|H ::>>. /""&&|4<4?##L1oo<(;(;< ++00}} IG KKNN71:wqzWQZN H I!%!8!8 >  KK * *+< = > ?1c?GIDN>>CL rc&xsdfd}|S)aDecorator to register a SocketIO event handler. This decorator must be applied to SocketIO event handlers. Example:: @socketio.on('my event', namespace='/chat') def handle_my_custom_event(json): print('received json: ' + str(json)) :param message: The name of the event. This is normally a user defined string, but a few event names are already defined. Use ``'message'`` to define a handler that takes a string payload, ``'json'`` to define a handler that takes a JSON blob payload, ``'connect'`` or ``'disconnect'`` to create handlers for connection and disconnection events. :param namespace: The namespace on which the handler is to be registered. Defaults to the global namespace. rTctfd}jr jj|Sjj |fS)Nc}dk(r |}|d}|dd}}dk(r|}|d}|gt|ddz}j||g|S)N*rr)list _handle_event)sidrKreal_nsreal_msgrkmessagerZrs r_handlerz0SocketIO.on..decorator.._handlers$#!Gq'C8D"c>"Hq'C$:T!"X6D)t))'7GS1+/11rrY)rr0rer3append)rkrwrvrZrs` r decoratorzSocketIO.on..decorators_ 7^ 1 1{{ wIFN $$gx%CDNrr+)rrvrZrys``` rrez SocketIO.ons&$  ,rc"xsdfd}|S)aDecorator to define a custom error handler for SocketIO events. This decorator can be applied to a function that acts as an error handler for a namespace. This handler will be invoked when a SocketIO event handler raises an exception. The handler function must accept one argument, which is the exception raised. Example:: @socketio.on_error(namespace='/chat') def chat_error_handler(e): print('An error has occurred: ' + str(e)) :param namespace: The namespace for which to register the error handler. Defaults to the global namespace. rTcRt|s td|j<|S)N"exception_handler must be callable)callable ValueErrorr5)exception_handlerrZrs rryz$SocketIO.on_error..decorator?s.-. !EFF1BD # #I .$ $rr+)rrZrys`` ron_errorzSocketIO.on_error.s$  % rc@t|s td||_|S)ayDecorator to define a default error handler for SocketIO events. This decorator can be applied to a function that acts as a default error handler for any namespaces that do not have a specific handler. Example:: @socketio.on_error_default def error_handler(e): print('An error has occurred: ' + str(e)) r|)r}r~r6)rrs ron_error_defaultzSocketIO.on_error_defaultFs')*AB B):&  rc6|j|||y)aRegister a SocketIO event handler. ``on_event`` is the non-decorator version of ``'on'``. Example:: def on_foo_event(json): print('received json: ' + str(json)) socketio.on_event('my event', on_foo_event, namespace='/chat') :param message: The name of the event. This is normally a user defined string, but a few event names are already defined. Use ``'message'`` to define a handler that takes a string payload, ``'json'`` to define a handler that takes a JSON blob payload, ``'connect'`` or ``'disconnect'`` to create handlers for connection and disconnection events. :param handler: The function that handles the event. :param namespace: The namespace on which the handler is to be registered. Defaults to the global namespace. rYN)re)rrvrkrZs ron_eventzSocketIO.on_eventVs. .9-g6rctdk(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:: @socketio.event def my_event(data): print('Received data: ', data) The above example is equivalent to:: @socketio.on('my_event') def my_event(data): print('Received data: ', data) A custom namespace can be given as an argument to the decorator:: @socketio.event(namespace='/test') def my_event(data): print('Received data: ', data) rrcPj|jgi|SrF)rer$)rkrKr;rs r set_handlerz#SocketIO.event..set_handlers+Awtwww//A$A&A'JJr)lenr}rer$)rrKr;rs``` reventzSocketIO.eventosZ0 t9>c&kQ.8DG3D-47747++,T!W5 5 K rct|ts td|j||jr|jj |y|j j|y)NzNot a namespace instance.) isinstancer r~ _set_socketior0rfr4rx)rrls r on_namespacezSocketIO.on_namespacesV+Y789 9''- ;; KK * *+< =  # # * *+< =rc |jdd}|jddxs|jdd}|jdd}|jdd}|s|stjj}|jd d}|rRd | | t r6t tjd d t tjdd fd } r| }j j|g|||||d |y) aEmit a server generated SocketIO event. This function emits a SocketIO event to one or more connected clients. A JSON blob can be attached to the event as payload. This function can be used outside of a SocketIO event context, so it is appropriate to use when the server is the originator of an event, outside of any client context, such as in a regular HTTP request handler or a background task. Example:: @app.route('/ping') def ping(): socketio.emit('ping event', {'data': 42}, namespace='/chat') :param event: The name of the user event to emit. :param args: A dictionary with the JSON data to send as payload. :param namespace: The namespace under which the message is to be sent. Defaults to the global namespace. :param to: Send the message to all the users in the given room, or to the user with the given session ID. If this parameter is not included, the event is sent to all connected users. :param include_self: ``True`` to include the sender when broadcasting or addressing a room, or ``False`` to send to everyone but the sender. :param skip_sid: The session id of a client to ignore when broadcasting or addressing a room. This is typically set to the originator of the message, so that everyone except that client receive the message. To skip multiple sids pass a list. :param callback: If given, this function will be called to acknowledge that 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. rZrTtoNroom include_selfTskip_sidcallbackrsc0jdg|SrF)rr)rKoriginal_callbackoriginal_namespacerrss r_callback_wrapperz(SocketIO.emit.._callback_wrappers-)t))*;T*D F DIIi Fr'( F>D Frc<|jj||y)aClose a room. This function removes any users that are in the given room and then deletes the room from the server. This function can be used outside of a SocketIO event context. :param room: The name of the room to close. :param namespace: The namespace under which the room exists. Defaults to the global namespace. N)r0 close_room)rrrZs rrzSocketIO.close_room&s tY/rc d6jd}|r#d|vrt|jdddndjdj}jd|jd |}jd d}jd i} |r|| d <|_jrSj j jd k7r0tjjd j_ jdd} j j jd k(ri ddl } tj rtj j#s| s t%dddl m} | ddj&d"d |d| yj j jdk(r fd} |r t)| fi| y| yj j jdk(rddlm} ddlm}d }d}sd}|r|j2ff|d_n|j2ffd|i_|r8dd lm}|j9|j;fd!} t)| fi| yj4j=yy#t$rddl m} | ddYwxYw#t$rd}YwxYw)#aRun the SocketIO web server. :param app: The Flask application instance. :param host: The hostname or IP address for the server to listen on. Defaults to 127.0.0.1. :param port: The port number for the server to listen on. Defaults to 5000. :param debug: ``True`` to start the server in debug mode, ``False`` to start in normal mode. :param use_reloader: ``True`` to enable the Flask reloader, ``False`` to disable it. :param reloader_options: A dictionary with options that are passed to the Flask reloader, such as ``extra_files``, ``reloader_type``, etc. :param extra_files: A list of additional files that the Flask reloader should watch. Defaults to ``None``. Deprecated, use ``reloader_options`` instead. :param log_output: If ``True``, the server logs all incoming connections. If ``False`` logging is disabled. Defaults to ``True`` in debug mode, ``False`` in normal mode. Unused when the threading async mode is used. :param allow_unsafe_werkzeug: Set to ``True`` to allow the use of the Werkzeug web server in a production setting. Default is ``False``. Set to ``True`` at your own risk. :param kwargs: Additional web server options. The web server options are specific to the server used in each of the supported async modes. Note that options provided here will not be seen when using an external web server such as gunicorn, since this method is not called in that case. Nz 127.0.0.1 SERVER_NAME:ridebug log_output use_reloader extra_filesreloader_optionsrWT)evalexallow_unsafe_werkzeugFr)_logwarningzUWebSocket transport not available. Install simple-websocket for improved performance.zThe Werkzeug web server is not designed to run in production. Pass allow_unsafe_werkzeug=True to the run() method to disable this error.znWerkzeug appears to be used in a production deployment. Consider switching to a production web server instead.)hostportthreadedreventletcddl}ddl}ddl}|jjj  }|s t d|j|dd|dd}gd}Dcic]}||vr |||}}|D]}j|dt|dkDrd|d<|j|fi|}|jj|fd iycc}w)Nrz)Could not resolve host to a valid address) keyfilecertfile server_side cert_reqs ssl_versionca_certsdo_handshake_on_connectsuppress_ragged_eofsciphersTrr) r eventlet.wsgieventlet.greengreensocket getaddrinfo RuntimeErrorlistenr\rwrap_sslwsgir0) r addresseseventlet_socketssl_argsk ssl_paramsr:rr;rrs r run_serverz SocketIO.run..run_servers%$%$NN11==dDI  &CEE"*//)A,q/2;A,q/#C'5;Jq!"h6!93H lJ J!(AJJq$'(z?Q&04J}-&7h&7&7'F:D'FO% $$_cF0:F>DFJs'Cgevent)pywsgi)WebSocketHandlerdefault) handler_classlogr)monkeyc:jjyrF)r2 serve_forever)rsrrz SocketIO.run..run_servers$$224rr+)configintrsplitr\rr0eiorVr rgrsimple_websocket ImportErrorwerkzeug._internalrsysstdinisattyrrunr rrgeventwebsocket.handlerr WSGIServerr2r patch_thread patch_timer)rr:rrr; server_namerrrrrrrrrrgevent_websocketrrrs````` @rrz SocketIO.run3sD <D <**]3Ksk1;--c15a89 7CII.ZZ e4 zz.%8 jj5 !::&8"= .9 ] + 9933{B,':'''6DNN #!' +BE J ;;?? % % 4 N' 99CII$4$4$6,&(MNN 8&02 CGG MD4!- M1A MEK M [[__ ' ': 5 F F8!*A0@A [[__ ' '8 3 % )D#' C#46#4#44L#$'5E$'%$' $56#4#4dD\3$H9<$H@F$H )##%!!#5"*A0@A  ..0?4g N3Y!MN Np )#(  )s$ KK KK K.-K.c|jjjdk(r>tjj j d}|r|ytd|jjjdk(rt|jjjdk(r|jjyy)zzStop a running SocketIO web server. This method must be called from a HTTP or SocketIO handler function. rWzwerkzeug.server.shutdownzCannot stop unknown web serverrrN) r0rrVrrr!r]r SystemExitr2stop)rfuncs rrz SocketIO.stops ;;?? % % 4==((,,-GHD"#CDD [[__ ' ': 5  [[__ ' '8 3    ! ! #4rcB|jj|g|i|S)aNStart 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 that represents the background task, on which the ``join()`` method can be invoked to wait for the task to complete. )r0start_background_task)rtargetrKr;s rrzSocketIO.start_background_tasks%1t{{00I$I&IIrc8|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. )r0sleep)rsecondss rrzSocketIO.sleeps{{  ))rc &t|||||||S)a(The Socket.IO test client is useful for testing a Flask-SocketIO server. It works in a similar way to the Flask Test Client, but adapted to the Socket.IO server. :param app: The Flask application instance. :param namespace: The namespace for the client. If not provided, the client connects to the server on the global namespace. :param query_string: A string with custom query string arguments. :param headers: A dictionary with custom HTTP headers. :param auth: Optional authentication data, given as a dictionary. :param flask_test_client: The instance of the Flask test client currently in use. Passing the Flask test client is optional, but is necessary if you want the Flask user session and any other cookies set in HTTP routes accessible from Socket.IO events. )rZ query_stringheadersauthflask_test_clientr )rr:rZrrrrs r test_clientzSocketIO.test_clients$("#ty/;W'+4EG Grc|jj||}|sy|d}|j|5|jrd|vrt t j |d<|d}tt drCtt jdr)t jjj} nt jj} || _nt j j}|t j_|t j_||dt j_ |dk(rt#|d kDr|d nd} || } n||} |jsEt|d r |j2r-|j5}|j6j9|||| cdddS#t$$r |} YnwxYw#t&$r|j(j+||j,} | t/j0\} }}| |cYcdddSxYw#1swYyxYw) NrY)ir saved_sessionglobals request_ctx)rvrKconnectrmodified)r0 get_environrequest_contextr7r*rsessionr[rr_get_current_object_request_ctx_stacktoprrsrZrr TypeErrorr r5r]r6rexc_inforresponse_classsession_interface save_session)rrkrvrZrsrKr!r: session_objctxrret err_handlertypevalue tracebackresps rrrzSocketIO._handle_events ++))#)Ck"   )1 ""#'1/>u}}/MGO,%o6 5), }=--33GGIC 2266C) $mm??A #EMM &/EMM #.5t"DEMM  *i'&)$i!m47D(%dm"4.C&&{J7#,,--/D))66sKNc1 1 <%(%i(*  *"5599t==? &),&eY"5))U1 1 1 1 sPDH<?GG"G(AH<GGGGAH9.H<9H<<IrF)FNNNTNNN)r)NNNNN)r$r%r&r'r>rdreasonrr8rerrrrrrrrrrrrrrrrr+rrr-r-4srf__ # #F/(A*F+Z0! 72!F>>I@!*F9=8<&FP 0c1J$ J"*=A?CG27rr-c d|vr|d}ntjj}|jd}|jd}|j ddxs|j dd}||stjj }|jdd}|jd }|jd d } tj jd } | j|g||||||| d S)ab Emit a SocketIO event. This function emits a SocketIO event to one or more connected clients. A JSON blob can be attached to the event as payload. This is a function that can only be called from a SocketIO event handler, as in obtains some information from the current client context. Example:: @socketio.on('my event') def handle_my_custom_event(json): emit('my response', {'data': 42}) :param event: The name of the user event to emit. :param args: A dictionary with the JSON data to send as payload. :param namespace: The namespace under which the message is to be sent. Defaults to the namespace used by the originating event. A ``'/'`` can be used to explicitly specify the global namespace. :param callback: Callback function to invoke with the client's acknowledgement. :param broadcast: ``True`` to send the message to all clients, or ``False`` to only reply to the sender of the originating event. :param to: Send the message to all the users in the given room, or to the user with the given session ID. If this argument is not set and ``broadcast`` is ``False``, then the message is sent only to the originating user. :param include_self: ``True`` to include the sender when broadcasting or addressing a room, or ``False`` to send to everyone but the sender. :param skip_sid: The session id of a client to ignore when broadcasting or addressing a room. This is typically set to the originator of the message, so that everyone except that client receive the message. To skip multiple sids pass a list. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the event is emitted to the clients directly, without going through the queue. This is more efficient, but only works when a single server process is used, or when there is a single addressee. It is recommended to always leave this parameter with its default value of ``False``. rZr broadcastrNrrTr ignore_queueFr>)rZrrrrr) rrrZr]r\rs current_appr=r) rrKr;rZrrrrrrr>s rrrVsTf;' MM++ zz*%H ;'I D$  ;6::fd#;B z) ]]  ::nd3Lzz*%H::ne4L  ++J7H 8== G Gr&2X"* GGrcd|vr|d}ntjj}|jddxs|jdd}|tjj}|j dd}|j dd}tj jd }|j|g|||||d S) uEmit a SocketIO event and wait for the response. This function issues an emit with a callback and waits for the callback to be invoked by the client 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. Example:: def get_status(client, data): status = call('status', {'data': data}, to=client) :param event: The name of the user event to emit. :param args: A dictionary with the JSON data to send as payload. :param namespace: The namespace under which the message is to be sent. Defaults to the namespace used by the originating event. A ``'/'`` can be used to explicitly specify the global namespace. :param to: The session ID of the recipient client. If this argument is not given, the event is sent to the originating client. :param timeout: The waiting timeout. If the timeout is reached before the client acknowledges the event, then a ``TimeoutError`` exception is raised. The default is 60 seconds. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the event is emitted to the client directly, without going through the queue. This is more efficient, but only works when a single server process is used, or when there is a single addressee. It is recommended to always leave this parameter with its default value of ``False``. rZrNrtimeout<rFr>)rZrrr) rrrZr\rsr]rr=r)rrKr;rZrrrr>s rrrs>f;' MM++ D$  ;6::fd#;B z ]]  jjB'G::ne4L  ++J7H 8== E Er&2G EErc |jdd}d|vr|d}ntjj}|jd}|jd}|j ddxs|j dd}||stjj }|jd d }|jd }|jd d} tj jd } | j|||||||| S)a Send a SocketIO message. This function sends a simple SocketIO message to one or more connected clients. The message can be a string or a JSON blob. This is a simpler version of ``emit()``, which should be preferred. This is a function that can only be called from a SocketIO event handler. :param message: The message to send, either a string or a JSON blob. :param json: ``True`` if ``message`` is a JSON blob, ``False`` otherwise. :param namespace: The namespace under which the message is to be sent. Defaults to the namespace used by the originating event. An empty string can be used to use the global namespace. :param callback: Callback function to invoke with the client's acknowledgement. :param broadcast: ``True`` to send the message to all connected clients, or ``False`` to only reply to the sender of the originating event. :param to: Send the message to all the users in the given room, or to the user with the given session ID. If this argument is not set and ``broadcast`` is ``False``, then the message is sent only to the originating user. :param include_self: ``True`` to include the sender when broadcasting or addressing a room, or ``False`` to send to everyone but the sender. :param skip_sid: The session id of a client to ignore when broadcasting or addressing a room. This is typically set to the originator of the message, so that everyone except that client receive the message. To skip multiple sids pass a list. :param ignore_queue: Only used when a message queue is configured. If set to ``True``, the event is emitted to the clients directly, without going through the queue. This is more efficient, but only works when a single server process is used, or when there is a single addressee. It is recommended to always leave this parameter with its default value of ``False``. rFrZrrrNrrTrrr>)rrZrrrrr) r]rrrZr\rsrr=r) rvr;rrZrrrrrrr>s rrrsN ::fe $Df;' MM++ zz*%H ;'I D$  ;6::fd#;B z) ]]  ::nd3Lzz*%H::ne4L  ++J7H 8==tyR&2X"* GGrctjjd}|xstjj}|xstjj }|j j|||y)aJoin a room. This function puts the user in a room, under the current namespace. The user and the namespace are obtained from the event context. This is a function that can only be called from a SocketIO event handler. Example:: @socketio.on('join') def on_join(data): username = session['username'] room = data['room'] join_room(room) send(username + ' has entered the room.', to=room) :param room: The name of the room to join. :param sid: The session id of the client. If not provided, the client is obtained from the request context. :param namespace: The namespace for the room. If not provided, the namespace is obtained from the request context. r>rYN)rrr=rrsrZr0 enter_roomrrsrZr>s r join_roomrs[(  ++J7H """C4U]]44I OOsDI>rctjjd}|xstjj}|xstjj }|j j|||y)aLeave a room. This function removes the user from a room, under the current namespace. The user and the namespace are obtained from the event context. Example:: @socketio.on('leave') def on_leave(data): username = session['username'] room = data['room'] leave_room(room) send(username + ' has left the room.', to=room) :param room: The name of the room to leave. :param sid: The session id of the client. If not provided, the client is obtained from the request context. :param namespace: The namespace for the room. If not provided, the namespace is obtained from the request context. r>rYN)rrr=rrsrZr0 leave_roomrs rr!r!s[&  ++J7H """C4U]]44I OOsDI>rctjjd}|xstjj}|j j ||y)a?Close a room. This function removes any users that are in the given room and then deletes the room from the server. :param room: The name of the room to close. :param namespace: The namespace for the room. If not provided, the namespace is obtained from the request context. r>rYN)rrr=rrZr0r)rrZr>s rrr/sE  ++J7H4U]]44I OOty9rctjjd}|xstjj}|xstjj }|j j||S)aReturn a list of the rooms the client is in. This function returns all the rooms the client has entered, including its own room, assigned by the Socket.IO server. :param sid: The session id of the client. If not provided, the client is obtained from the request context. :param namespace: The namespace for the room. If not provided, the namespace is obtained from the request context. r>rY)rrr=rrsrZr0rooms)rsrZr>s rr$r$>s\  ++J7H """C4U]]44I ??  ::rctjjd}|xstjj}|xstjj }|j j||S)aDisconnect the client. This function terminates the connection with the client. As a result of this call the client will receive a disconnect event. Example:: @socketio.on('message') def receive_message(msg): if is_banned(session['username']): disconnect() else: # ... :param sid: The session id of the client. If not provided, the client is obtained from the request context. :param namespace: The namespace for the room. If not provided, the namespace is obtained from the request context. :param silent: this option is deprecated. r>rY)rrr=rrsrZr0 disconnect)rsrZsilentr>s rr&r&Os\&  ++J7H """C4U]]44I ?? % %cY % ??rrrF)NNF)' functoolsrrcrgevent_socketio_foundr>rrprintexitrrrrHflask.sessionsrsocketio.exceptionsr werkzeug.debugr werkzeug._reloaderr rZr rrWSGIApprdictr*r-rrrrr!rr$r&r+rrr2s "(  HI CHHQK 9'6.0 + 9(** 9 dL _ _ D:Gz+E\8Gv?4?2 :;"@K""!"sB11B;:B;