Flask-SocketIO-2.8.6/0000755_j0000000000013064236701014571 5ustar migu778100000000000000Flask-SocketIO-2.8.6/flask_socketio/0000755_j0000000000013064236701017571 5ustar migu778100000000000000Flask-SocketIO-2.8.6/flask_socketio/__init__.py0000644_j0000010537113064236564021720 0ustar migu778100000000000000import sys # make sure gevent-socketio is not installed, as it conflicts with # python-socketio gevent_socketio_found = True try: from socketio import socketio_manage except ImportError: gevent_socketio_found = False if gevent_socketio_found: print('The 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.') sys.exit(1) import socketio import flask from flask import json as flask_json from werkzeug.debug import DebuggedApplication from werkzeug.serving import run_with_reloader from .namespace import Namespace from .test_client import SocketIOTestClient __version__ = '2.8.6' class _SocketIOMiddleware(socketio.Middleware): """This WSGI middleware simply exposes the Flask application in the WSGI environment before executing the request. """ def __init__(self, socketio_app, flask_app, socketio_path='socket.io'): self.flask_app = flask_app super(_SocketIOMiddleware, self).__init__(socketio_app, flask_app.wsgi_app, socketio_path) def __call__(self, environ, start_response): environ = environ.copy() environ['flask.app'] = self.flask_app return super(_SocketIOMiddleware, self).__call__(environ, start_response) class SocketIO(object): """Create 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 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``. :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. To use the same json encoder and decoder as a Flask application, use ``flask.json``. 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_timeout: The time in seconds that the client waits for the server to respond before disconnecting. :param ping_interval: The interval in seconds at which the client pings the server. :param max_http_buffer_size: The maximum size of a message when using the polling transport. :param allow_upgrades: Whether to allow transport upgrades or not. :param http_compression: Whether to compress packages when using the polling transport. :param compression_threshold: Only compress messages when their byte size is greater than this value. :param cookie: Name of the HTTP cookie that contains the client session id. If set to ``None``, a cookie is not sent to the client. :param cors_allowed_origins: List of origins that are allowed to connect to this server. All origins are allowed by default. :param cors_credentials: Whether credentials (cookies, authentication) are allowed in requests to this server. :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass a logger object to use. To disable logging set to ``False``. """ def __init__(self, app=None, **kwargs): self.server = None self.server_options = {} self.wsgi_server = None self.handlers = [] self.namespace_handlers = [] self.exception_handlers = {} self.default_exception_handler = None # We can call init_app when: # - we were given the Flask app instance (standard initialization) # - we were not given the app, but we were given a message_queue # (standard initialization for auxiliary process) # In all other cases we collect the arguments and assume the client # will call init_app from an app factory function. if app is not None or 'message_queue' in kwargs: self.init_app(app, **kwargs) else: self.server_options.update(kwargs) def init_app(self, app, **kwargs): if app is not None: if not hasattr(app, 'extensions'): app.extensions = {} # pragma: no cover app.extensions['socketio'] = self self.server_options.update(kwargs) if 'client_manager' not in self.server_options: url = kwargs.pop('message_queue', None) channel = kwargs.pop('channel', 'flask-socketio') write_only = app is None if url: if url.startswith('redis://'): queue_class = socketio.RedisManager elif url.startswith('zmq'): queue_class = socketio.ZmqManager else: queue_class = socketio.KombuManager queue = queue_class(url, channel=channel, write_only=write_only) self.server_options['client_manager'] = queue if 'json' in self.server_options and \ self.server_options['json'] == flask_json: # flask's json module is tricky to use because its output # changes when it is invoked inside or outside the app context # so here to prevent any ambiguities we replace it with wrappers # that ensure that the app context is always present class FlaskSafeJSON(object): @staticmethod def dumps(*args, **kwargs): with app.app_context(): return flask_json.dumps(*args, **kwargs) @staticmethod def loads(*args, **kwargs): with app.app_context(): return flask_json.loads(*args, **kwargs) self.server_options['json'] = FlaskSafeJSON resource = kwargs.pop('path', kwargs.pop('resource', 'socket.io')) if resource.startswith('/'): resource = resource[1:] self.server = socketio.Server(**self.server_options) self.async_mode = self.server.async_mode for handler in self.handlers: self.server.on(handler[0], handler[1], namespace=handler[2]) for namespace_handler in self.namespace_handlers: self.server.register_namespace(namespace_handler) if app is not None: # here we attach the SocketIO middlware to the SocketIO object so it # can be referenced later if debug middleware needs to be inserted self.sockio_mw = _SocketIOMiddleware(self.server, app, socketio_path=resource) app.wsgi_app = self.sockio_mw def on(self, message, namespace=None): """Decorator 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. """ namespace = namespace or '/' def decorator(handler): def _handler(sid, *args): return self._handle_event(handler, message, namespace, sid, *args) if self.server: self.server.on(message, _handler, namespace=namespace) else: self.handlers.append((message, _handler, namespace)) return handler return decorator def on_error(self, namespace=None): """Decorator 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. """ namespace = namespace or '/' def decorator(exception_handler): if not callable(exception_handler): raise ValueError('exception_handler must be callable') self.exception_handlers[namespace] = exception_handler return exception_handler return decorator def on_error_default(self, exception_handler): """Decorator 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)) """ if not callable(exception_handler): raise ValueError('exception_handler must be callable') self.default_exception_handler = exception_handler return exception_handler def on_event(self, message, handler, namespace=None): """Register 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. """ self.on(message, namespace=namespace)(handler) def on_namespace(self, namespace_handler): if not isinstance(namespace_handler, Namespace): raise ValueError('Not a namespace instance.') namespace_handler._set_socketio(self) if self.server: self.server.register_namespace(namespace_handler) else: self.namespace_handlers.append(namespace_handler) def emit(self, event, *args, **kwargs): """Emit 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 room: Send the message to all the users in the given room. If this parameter is not included, the event is sent to all connected users. :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. :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. """ namespace = kwargs.pop('namespace', '/') room = kwargs.pop('room', None) include_self = kwargs.pop('include_self', True) skip_sid = kwargs.pop('skip_sid', None) if not include_self and not skip_sid: skip_sid = flask.request.sid callback = kwargs.pop('callback', None) self.server.emit(event, *args, namespace=namespace, room=room, skip_sid=skip_sid, callback=callback, **kwargs) def send(self, data, json=False, namespace=None, room=None, callback=None, include_self=True, skip_sid=None, **kwargs): """Send a server-generated 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 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. :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 global namespace. :param room: Send the message only to the users in the given room. If this parameter is not included, the message is sent to all connected users. :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. :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. """ skip_sid = flask.request.sid if not include_self else skip_sid if json: self.emit('json', data, namespace=namespace, room=room, skip_sid=skip_sid, callback=callback, **kwargs) else: self.emit('message', data, namespace=namespace, room=room, skip_sid=skip_sid, callback=callback, **kwargs) def close_room(self, room, namespace=None): """Close 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. """ self.server.close_room(room, namespace) def run(self, app, host=None, port=None, **kwargs): """Run 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 extra_files: A list of additional files that the Flask reloader should watch. Defaults to ``None`` :param log_output: If ``True``, the server logs all incomming 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 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. """ if host is None: host = '127.0.0.1' if port is None: server_name = app.config['SERVER_NAME'] if server_name and ':' in server_name: port = int(server_name.rsplit(':', 1)[1]) else: port = 5000 debug = kwargs.pop('debug', app.debug) log_output = kwargs.pop('log_output', debug) use_reloader = kwargs.pop('use_reloader', debug) extra_files = kwargs.pop('extra_files', None) app.debug = debug if app.debug and self.server.eio.async_mode != 'threading': # put the debug middleware between the SocketIO middleware # and the Flask application instance # # mw1 mw2 mw3 Flask app # o ---- o ---- o ---- o # / # o Flask-SocketIO # \ middleware # o # Flask-SocketIO WebSocket handler # # BECOMES # # dbg-mw mw1 mw2 mw3 Flask app # o ---- o ---- o ---- o ---- o # / # o Flask-SocketIO # \ middleware # o # Flask-SocketIO WebSocket handler # self.sockio_mw.wsgi_app = DebuggedApplication(self.sockio_mw.wsgi_app, evalex=True) if self.server.eio.async_mode == 'threading': from werkzeug._internal import _log _log('warning', 'WebSocket transport not available. Install ' 'eventlet or gevent and gevent-websocket for ' 'improved performance.') app.run(host=host, port=port, threaded=True, use_reloader=use_reloader, **kwargs) elif self.server.eio.async_mode == 'eventlet': def run_server(): import eventlet import eventlet.wsgi eventlet_socket = eventlet.listen((host, port)) # If provided an SSL argument, use an SSL socket ssl_args = ['keyfile', 'certfile', 'server_side', 'cert_reqs', 'ssl_version', 'ca_certs', 'do_handshake_on_connect', 'suppress_ragged_eofs', 'ciphers'] ssl_params = {k: kwargs[k] for k in kwargs if k in ssl_args} if len(ssl_params) > 0: for k in ssl_params: kwargs.pop(k) ssl_params['server_side'] = True # Listening requires true eventlet_socket = eventlet.wrap_ssl(eventlet_socket, **ssl_params) eventlet.wsgi.server(eventlet_socket, app, log_output=log_output, **kwargs) if use_reloader: run_with_reloader(run_server, extra_files=extra_files) else: run_server() elif self.server.eio.async_mode == 'gevent': from gevent import pywsgi try: from geventwebsocket.handler import WebSocketHandler websocket = True except ImportError: websocket = False log = 'default' if not log_output: log = None if websocket: self.wsgi_server = pywsgi.WSGIServer( (host, port), app, handler_class=WebSocketHandler, log=log, **kwargs) else: self.wsgi_server = pywsgi.WSGIServer((host, port), app, log=log) if use_reloader: # monkey patching is required by the reloader from gevent import monkey monkey.patch_all() def run_server(): self.wsgi_server.serve_forever() run_with_reloader(run_server, extra_files=extra_files) else: self.wsgi_server.serve_forever() def stop(self): """Stop a running SocketIO web server. This method must be called from a HTTP or SocketIO handler function. """ if self.server.eio.async_mode == 'threading': func = flask.request.environ.get('werkzeug.server.shutdown') if func: func() else: raise RuntimeError('Cannot stop unknown web server') elif self.server.eio.async_mode == 'eventlet': raise SystemExit elif self.server.eio.async_mode == 'gevent': self.wsgi_server.stop() def start_background_task(self, target, *args, **kwargs): """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. 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. """ return self.server.start_background_task(target, *args, **kwargs) def sleep(self, seconds=0): """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. """ return self.server.sleep(seconds) def test_client(self, app, namespace=None): """Return a simple SocketIO client that can be used for unit tests.""" return SocketIOTestClient(app, self, namespace) def _handle_event(self, handler, message, namespace, sid, *args): if sid not in self.server.environ: # we don't have record of this client, ignore this event return '', 400 app = self.server.environ[sid]['flask.app'] with app.request_context(self.server.environ[sid]): if 'saved_session' in self.server.environ[sid]: self._copy_session( self.server.environ[sid]['saved_session'], flask.session) flask.request.sid = sid flask.request.namespace = namespace flask.request.event = {'message': message, 'args': args} try: if message == 'connect': ret = handler() else: ret = handler(*args) except: err_handler = self.exception_handlers.get( namespace, self.default_exception_handler) if err_handler is None: raise type, value, traceback = sys.exc_info() return err_handler(value) if flask.session.modified and sid in self.server.environ: self.server.environ[sid]['saved_session'] = {} self._copy_session( flask.session, self.server.environ[sid]['saved_session']) return ret def _copy_session(self, src, dest): for k in src: dest[k] = src[k] def emit(event, *args, **kwargs): """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 room: Send the message to all the users in the given room. If this argument is set, then broadcast is implied to be ``True``. :param include_self: ``True`` to include the sender when broadcasting or addressing a room, or ``False`` to send to everyone but the sender. """ if 'namespace' in kwargs: namespace = kwargs['namespace'] else: namespace = flask.request.namespace callback = kwargs.get('callback') broadcast = kwargs.get('broadcast') room = kwargs.get('room') if room is None and not broadcast: room = flask.request.sid include_self = kwargs.get('include_self', True) socketio = flask.current_app.extensions['socketio'] return socketio.emit(event, *args, namespace=namespace, room=room, include_self=include_self, callback=callback) def send(message, **kwargs): """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 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 room: Send the message to all the users in the given room. :param include_self: ``True`` to include the sender when broadcasting or addressing a room, or ``False`` to send to everyone but the sender. """ if 'namespace' in kwargs: namespace = kwargs['namespace'] else: namespace = flask.request.namespace callback = kwargs.get('callback') broadcast = kwargs.get('broadcast') room = kwargs.get('room') if room is None and not broadcast: room = flask.request.sid include_self = kwargs.get('include_self', True) socketio = flask.current_app.extensions['socketio'] return socketio.send(message, namespace=namespace, room=room, include_self=include_self, callback=callback) def join_room(room, sid=None, namespace=None): """Join 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.', room=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. """ socketio = flask.current_app.extensions['socketio'] sid = sid or flask.request.sid namespace = namespace or flask.request.namespace socketio.server.enter_room(sid, room, namespace=namespace) def leave_room(room, sid=None, namespace=None): """Leave 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.', room=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. """ socketio = flask.current_app.extensions['socketio'] sid = sid or flask.request.sid namespace = namespace or flask.request.namespace socketio.server.leave_room(sid, room, namespace=namespace) def close_room(room, namespace=None): """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. """ socketio = flask.current_app.extensions['socketio'] namespace = namespace or flask.request.namespace socketio.server.close_room(room, namespace=namespace) def rooms(sid=None, namespace=None): """Return 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. """ socketio = flask.current_app.extensions['socketio'] sid = sid or flask.request.sid namespace = namespace or flask.request.namespace return socketio.server.rooms(sid, namespace=namespace) def disconnect(silent=False): """Disconnect 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() # ... :param silent: this option is deprecated. """ socketio = flask.current_app.extensions['socketio'] return socketio.server.disconnect(flask.request.sid, namespace=flask.request.namespace) Flask-SocketIO-2.8.6/flask_socketio/cli.py0000644_j0000000517213007024123020705 0ustar migu778100000000000000import os import sys from flask.cli import pass_script_info, get_debug_flag, run_command import click @click.command() @click.option('--host', '-h', default='127.0.0.1', help='The interface to bind to.') @click.option('--port', '-p', default=5000, help='The port to bind to.') @click.option('--reload/--no-reload', default=None, help='Enable or disable the reloader. By default the reloader ' 'is active if debug is enabled.') @click.option('--debugger/--no-debugger', default=None, help='Enable or disable the debugger. By default the debugger ' 'is active if debug is enabled.') @click.option('--eager-loading/--lazy-loader', default=None, help='Enable or disable eager loading. By default eager ' 'loading is enabled if the reloader is disabled.') @pass_script_info def run(info, host, port, reload, debugger, eager_loading): """Runs a local development server for the Flask-SocketIO application. The reloader and debugger are by default enabled if the debug flag of Flask is enabled and disabled otherwise. """ debug = get_debug_flag() if reload is None: reload = bool(debug) if debugger is None: debugger = bool(debug) if eager_loading is None: eager_loading = not reload # Extra startup messages. This depends a bit on Werkzeug internals to # not double execute when the reloader kicks in. if os.environ.get('WERKZEUG_RUN_MAIN') != 'true': # If we have an import path we can print it out now which can help # people understand what's being served. If we do not have an # import path because the app was loaded through a callback then # we won't print anything. if info.app_import_path is not None: print(' * Serving Flask-SocketIO app "%s"' % info.app_import_path) if debug is not None: print(' * Forcing debug mode %s' % (debug and 'on' or 'off')) def run_server(): app = info.load_app() if 'socketio' not in app.extensions: # flask-socketio is installed, but it isn't in this application # so we invoke Flask's original run command run_index = sys.argv.index('run') sys.argv = sys.argv[run_index:] return run_command() socketio = app.extensions['socketio'] socketio.run(app, host=host, port=port, debug=debugger, use_reloader=False, log_output=debugger) if reload: from werkzeug.serving import run_with_reloader run_with_reloader(run_server) else: run_server() Flask-SocketIO-2.8.6/flask_socketio/namespace.py0000644_j0000000374413007022524022100 0ustar migu778100000000000000from socketio import Namespace as _Namespace class Namespace(_Namespace): def __init__(self, namespace=None): super(Namespace, self).__init__(namespace) self.socketio = None def _set_socketio(self, socketio): self.socketio = socketio def trigger_event(self, event, *args): """Dispatch an event to the proper handler method. In the most common usage, this method is not overloaded by subclasses, as it performs the routing of events to methods. However, this method can be overriden if special dispatching rules are needed, or if having a single method that catches all events is desired. """ handler_name = 'on_' + event if not hasattr(self, handler_name): # there is no handler for this event, so we ignore it return handler = getattr(self, handler_name) return self.socketio._handle_event(handler, event, self.namespace, *args) def emit(self, event, data=None, room=None, include_self=True, namespace=None, callback=None): """Emit a custom event to one or more connected clients.""" return self.socketio.emit(event, data, room=room, include_self=include_self, namespace=namespace or self.namespace, callback=callback) def send(self, data, room=None, include_self=True, namespace=None, callback=None): """Send a message to one or more connected clients.""" return self.socketio.send(data, room=room, include_self=include_self, namespace=namespace or self.namespace, callback=callback) def close_room(self, room, namespace=None): """Close a room.""" return self.socketio.close_room(room=room, namespace=namespace or self.namespace) Flask-SocketIO-2.8.6/flask_socketio/test_client.py0000644_j0000001571613050251766022475 0ustar migu778100000000000000import uuid from socketio import packet from socketio.pubsub_manager import PubSubManager from werkzeug.test import EnvironBuilder class SocketIOTestClient(object): """ This class 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 socketio: The application's ``SocketIO`` instance. :param namespace: The namespace for the client. If not provided, the client connects to the server on the global namespace. """ queue = {} ack = None def __init__(self, app, socketio, namespace=None): def _mock_send_packet(sid, pkt): if pkt.packet_type == packet.EVENT or \ pkt.packet_type == packet.BINARY_EVENT: if sid not in self.queue: self.queue[sid] = [] if pkt.data[0] == 'message' or pkt.data[0] == 'json': self.queue[sid].append({'name': pkt.data[0], 'args': pkt.data[1], 'namespace': pkt.namespace or '/'}) else: self.queue[sid].append({'name': pkt.data[0], 'args': pkt.data[1:], 'namespace': pkt.namespace or '/'}) elif pkt.packet_type == packet.ACK or \ pkt.packet_type == packet.BINARY_ACK: self.ack = {'args': pkt.data, 'namespace': pkt.namespace or '/'} self.app = app self.sid = uuid.uuid4().hex self.queue[self.sid] = [] self.callback_counter = 0 self.socketio = socketio socketio.server._send_packet = _mock_send_packet socketio.server.environ[self.sid] = {} if isinstance(socketio.server.manager, PubSubManager): raise RuntimeError('Test client cannot be used with a message ' 'queue. Disable the queue on your test ' 'configuration.') socketio.server.manager.initialize() self.connect(namespace) def connect(self, namespace=None): """Connect the client. :param namespace: The namespace for the client. If not provided, the client connects to the server on the global namespace. Note that it is usually not necessary to explicitly call this method, since a connection is automatically established when an instance of this class is created. An example where it this method would be useful is when the application accepts multiple namespace connections. """ environ = EnvironBuilder('/socket.io').get_environ() environ['flask.app'] = self.app self.socketio.server._handle_eio_connect(self.sid, environ) if namespace is not None and namespace != '/': pkt = packet.Packet(packet.CONNECT, namespace=namespace) with self.app.app_context(): self.socketio.server._handle_eio_message(self.sid, pkt.encode()) def disconnect(self, namespace=None): """Disconnect the client. :param namespace: The namespace to disconnect. The global namespace is assumed if this argument is not provided. """ pkt = packet.Packet(packet.DISCONNECT, namespace=namespace) with self.app.app_context(): self.socketio.server._handle_eio_message(self.sid, pkt.encode()) def emit(self, event, *args, **kwargs): """Emit an event to the server. :param event: The event name. :param *args: The event arguments. :param callback: ``True`` if the client requests a callback, ``False`` if not. Note that client-side callbacks are not implemented, a callback request will just tell the server to provide the arguments to invoke the callback, but no callback is invoked. Instead, the arguments that the server provided for the callback are returned by this function. :param namespace: The namespace of the event. The global namespace is assumed if this argument is not provided. """ namespace = kwargs.pop('namespace', None) callback = kwargs.pop('callback', False) id = None if callback: self.callback_counter += 1 id = self.callback_counter pkt = packet.Packet(packet.EVENT, data=[event] + list(args), namespace=namespace, id=id, binary=False) self.ack = None with self.app.app_context(): self.socketio.server._handle_eio_message(self.sid, pkt.encode()) if self.ack is not None: return self.ack['args'][0] if len(self.ack['args']) == 1 \ else self.ack['args'] def send(self, data, json=False, callback=False, namespace=None): """Send a text or JSON message to the server. :param data: A string, dictionary or list to send to the server. :param json: ``True`` to send a JSON message, ``False`` to send a text message. :param callback: ``True`` if the client requests a callback, ``False`` if not. Note that client-side callbacks are not implemented, a callback request will just tell the server to provide the arguments to invoke the callback, but no callback is invoked. Instead, the arguments that the server provided for the callback are returned by this function. :param namespace: The namespace of the event. The global namespace is assumed if this argument is not provided. """ if json: msg = 'json' else: msg = 'message' return self.emit(msg, data, callback=callback, namespace=namespace) def get_received(self, namespace=None): """Return the list of messages received from the server. Since this is not a real client, any time the server emits an event, the event is simply stored. The test code can invoke this method to obtain the list of events that were received since the last call. :param namespace: The namespace to get events from. The global namespace is assumed if this argument is not provided. """ namespace = namespace or '/' r = [pkt for pkt in self.queue[self.sid] if pkt['namespace'] == namespace] self.queue[self.sid] = [pkt for pkt in self.queue[self.sid] if pkt not in r] return r Flask-SocketIO-2.8.6/Flask_SocketIO.egg-info/0000755_j0000000000013064236701021063 5ustar migu778100000000000000Flask-SocketIO-2.8.6/Flask_SocketIO.egg-info/dependency_links.txt0000644_j0000000000113064236701025131 0ustar migu778100000000000000 Flask-SocketIO-2.8.6/Flask_SocketIO.egg-info/entry_points.txt0000644_j0000000005713064236701024363 0ustar migu778100000000000000[flask.commands] run = flask_socketio.cli:run Flask-SocketIO-2.8.6/Flask_SocketIO.egg-info/not-zip-safe0000644_j0000000000113007022547023307 0ustar migu778100000000000000 Flask-SocketIO-2.8.6/Flask_SocketIO.egg-info/PKG-INFO0000644_j0000000152613064236701022164 0ustar migu778100000000000000Metadata-Version: 1.1 Name: Flask-SocketIO Version: 2.8.6 Summary: Socket.IO integration for Flask applications Home-page: http://github.com/miguelgrinberg/Flask-SocketIO/ Author: Miguel Grinberg Author-email: miguelgrinberg50@gmail.com License: MIT Description: Flask-SocketIO -------------- Socket.IO integration for Flask applications. Platform: any Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content Classifier: Topic :: Software Development :: Libraries :: Python Modules Flask-SocketIO-2.8.6/Flask_SocketIO.egg-info/requires.txt0000644_j0000000007113064236701023461 0ustar migu778100000000000000Flask>=0.9 python-socketio>=1.5.0 python-engineio>=1.0.0 Flask-SocketIO-2.8.6/Flask_SocketIO.egg-info/SOURCES.txt0000644_j0000000063413064236701022752 0ustar migu778100000000000000LICENSE MANIFEST.in README.md setup.py Flask_SocketIO.egg-info/PKG-INFO Flask_SocketIO.egg-info/SOURCES.txt Flask_SocketIO.egg-info/dependency_links.txt Flask_SocketIO.egg-info/entry_points.txt Flask_SocketIO.egg-info/not-zip-safe Flask_SocketIO.egg-info/requires.txt Flask_SocketIO.egg-info/top_level.txt flask_socketio/__init__.py flask_socketio/cli.py flask_socketio/namespace.py flask_socketio/test_client.pyFlask-SocketIO-2.8.6/Flask_SocketIO.egg-info/top_level.txt0000644_j0000000001713064236701023613 0ustar migu778100000000000000flask_socketio Flask-SocketIO-2.8.6/LICENSE0000644_j0000000207213007022524015570 0ustar migu778100000000000000The MIT License (MIT) Copyright (c) 2014 Miguel Grinberg Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Flask-SocketIO-2.8.6/MANIFEST.in0000644_j0000000003213007022524016313 0ustar migu778100000000000000include README.md LICENSE Flask-SocketIO-2.8.6/PKG-INFO0000644_j0000000152613064236701015672 0ustar migu778100000000000000Metadata-Version: 1.1 Name: Flask-SocketIO Version: 2.8.6 Summary: Socket.IO integration for Flask applications Home-page: http://github.com/miguelgrinberg/Flask-SocketIO/ Author: Miguel Grinberg Author-email: miguelgrinberg50@gmail.com License: MIT Description: Flask-SocketIO -------------- Socket.IO integration for Flask applications. Platform: any Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content Classifier: Topic :: Software Development :: Libraries :: Python Modules Flask-SocketIO-2.8.6/README.md0000644_j0000000200013007022524016031 0ustar migu778100000000000000Flask-SocketIO ============== [![Build Status](https://travis-ci.org/miguelgrinberg/Flask-SocketIO.png?branch=master)](https://travis-ci.org/miguelgrinberg/Flask-SocketIO) Socket.IO integration for Flask applications. Installation ------------ You can install this package as usual with pip: pip install flask-socketio Example ------- from flask import Flask, render_template from flask_socketio import SocketIO, emit app = Flask(__name__) app.config['SECRET_KEY'] = 'secret!' socketio = SocketIO(app) @app.route('/') def index(): return render_template('index.html') @socketio.on('my event') def test_message(message): emit('my response', {'data': 'got it!'}) if __name__ == '__main__': socketio.run(app) Resources --------- - [Tutorial](http://blog.miguelgrinberg.com/post/easy-websockets-with-flask-and-gevent) - [Documentation](http://pythonhosted.org/Flask-SocketIO) - [PyPI](https://pypi.python.org/pypi/Flask-SocketIO) Flask-SocketIO-2.8.6/setup.cfg0000644_j0000000007313064236701016412 0ustar migu778100000000000000[egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 Flask-SocketIO-2.8.6/setup.py0000755_j0000000272013007022524016300 0ustar migu778100000000000000""" Flask-SocketIO -------------- Socket.IO integration for Flask applications. """ import re from setuptools import setup with open('flask_socketio/__init__.py', 'r') as f: version = re.search(r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', f.read(), re.MULTILINE).group(1) setup( name='Flask-SocketIO', version=version, url='http://github.com/miguelgrinberg/Flask-SocketIO/', license='MIT', author='Miguel Grinberg', author_email='miguelgrinberg50@gmail.com', description='Socket.IO integration for Flask applications', long_description=__doc__, packages=['flask_socketio'], zip_safe=False, include_package_data=True, platforms='any', entry_points={ 'flask.commands': [ 'run=flask_socketio.cli:run' ], }, install_requires=[ 'Flask>=0.9', 'python-socketio>=1.5.0', 'python-engineio>=1.0.0' ], tests_require=[ 'coverage' ], test_suite='test_socketio', classifiers=[ 'Environment :: Web Environment', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 3', 'Topic :: Internet :: WWW/HTTP :: Dynamic Content', 'Topic :: Software Development :: Libraries :: Python Modules' ] )