python-socketio
***************

This projects implements Socket.IO clients and servers that can run
standalone or integrated with a variety of Python web frameworks.

* Getting Started

  * What is Socket.IO?

  * Version compatibility

  * Client Examples

  * Client Features

  * Server Examples

  * Server Features

* The Socket.IO Clients

  * Installation

  * Using the Simple Client

    * Creating a Client Instance

    * Connecting to a Server

    * Emitting Events

    * Receiving Events

    * Disconnecting from the Server

    * Debugging and Troubleshooting

  * Using the Event-Driven Client

    * Creating a Client Instance

    * Defining Event Handlers

    * Catch-All Event and Namespace Handlers

    * Connect, Connect Error and Disconnect Event Handlers

    * Connecting to a Server

    * Emitting Events

    * Event Callbacks

    * Namespaces

    * Class-Based Namespaces

    * Disconnecting from the Server

    * Managing Background Tasks

    * Debugging and Troubleshooting

* The Socket.IO Server

  * Installation

  * Creating a Server Instance

  * Running the Server

    * Running as a WSGI Application

    * Running as an ASGI Application

    * Serving Static Files

  * Events

    * Listening to Events

    * Connect and Disconnect Events

    * Catch-All Event Handlers

    * Emitting Events to Clients

    * Acknowledging Events

    * Requesting Client Acknowledgements

  * Rooms

  * Namespaces

    * Decorator-Based Namespaces

    * Class-Based Namespaces

    * Catch-All Namespaces

  * User Sessions

  * Cross-Origin Controls

  * Monitoring and Administration

  * Debugging and Troubleshooting

  * Concurrency and Web Server Integration

    * Standard Modes

    * Asyncio Modes

  * Deployment Strategies

    * Gunicorn

    * Uvicorn (and other ASGI web servers)

    * Aiohttp

    * Gevent

    * Tornado

    * Eventlet

    * Sanic

  * Using a Message Queue

    * Redis

    * Kombu

    * Kafka

    * AioPika

    * Deploying the Message Queue for Production

    * Horizontal Scaling

    * Emitting from external processes

* API Reference

  * "SimpleClient"

    * "SimpleClient.call()"

    * "SimpleClient.client_class"

    * "SimpleClient.connect()"

    * "SimpleClient.disconnect()"

    * "SimpleClient.emit()"

    * "SimpleClient.receive()"

    * "SimpleClient.sid"

    * "SimpleClient.transport"

  * "AsyncSimpleClient"

    * "AsyncSimpleClient.call()"

    * "AsyncSimpleClient.client_class"

    * "AsyncSimpleClient.connect()"

    * "AsyncSimpleClient.disconnect()"

    * "AsyncSimpleClient.emit()"

    * "AsyncSimpleClient.receive()"

    * "AsyncSimpleClient.sid"

    * "AsyncSimpleClient.transport"

  * "Client"

    * "Client.call()"

    * "Client.connect()"

    * "Client.connected"

    * "Client.disconnect()"

    * "Client.emit()"

    * "Client.event()"

    * "Client.get_sid()"

    * "Client.namespaces"

    * "Client.on()"

    * "Client.reason"

    * "Client.register_namespace()"

    * "Client.send()"

    * "Client.shutdown()"

    * "Client.sleep()"

    * "Client.start_background_task()"

    * "Client.transport()"

    * "Client.wait()"

  * "AsyncClient"

    * "AsyncClient.call()"

    * "AsyncClient.connect()"

    * "AsyncClient.connected"

    * "AsyncClient.disconnect()"

    * "AsyncClient.emit()"

    * "AsyncClient.event()"

    * "AsyncClient.get_sid()"

    * "AsyncClient.namespaces"

    * "AsyncClient.on()"

    * "AsyncClient.reason"

    * "AsyncClient.register_namespace()"

    * "AsyncClient.send()"

    * "AsyncClient.shutdown()"

    * "AsyncClient.sleep()"

    * "AsyncClient.start_background_task()"

    * "AsyncClient.transport()"

    * "AsyncClient.wait()"

  * "Server"

    * "Server.call()"

    * "Server.close_room()"

    * "Server.disconnect()"

    * "Server.emit()"

    * "Server.enter_room()"

    * "Server.event()"

    * "Server.get_environ()"

    * "Server.get_session()"

    * "Server.handle_request()"

    * "Server.instrument()"

    * "Server.leave_room()"

    * "Server.on()"

    * "Server.reason"

    * "Server.register_namespace()"

    * "Server.rooms()"

    * "Server.save_session()"

    * "Server.send()"

    * "Server.session()"

    * "Server.shutdown()"

    * "Server.sleep()"

    * "Server.start_background_task()"

    * "Server.transport()"

  * "AsyncServer"

    * "AsyncServer.attach()"

    * "AsyncServer.call()"

    * "AsyncServer.close_room()"

    * "AsyncServer.disconnect()"

    * "AsyncServer.emit()"

    * "AsyncServer.enter_room()"

    * "AsyncServer.event()"

    * "AsyncServer.get_environ()"

    * "AsyncServer.get_session()"

    * "AsyncServer.handle_request()"

    * "AsyncServer.instrument()"

    * "AsyncServer.leave_room()"

    * "AsyncServer.on()"

    * "AsyncServer.reason"

    * "AsyncServer.register_namespace()"

    * "AsyncServer.rooms()"

    * "AsyncServer.save_session()"

    * "AsyncServer.send()"

    * "AsyncServer.session()"

    * "AsyncServer.shutdown()"

    * "AsyncServer.sleep()"

    * "AsyncServer.start_background_task()"

    * "AsyncServer.transport()"

  * "ConnectionRefusedError"

  * "WSGIApp"

  * "ASGIApp"

  * "Middleware"

  * "ClientNamespace"

    * "ClientNamespace.call()"

    * "ClientNamespace.disconnect()"

    * "ClientNamespace.emit()"

    * "ClientNamespace.send()"

    * "ClientNamespace.trigger_event()"

  * "Namespace"

    * "Namespace.call()"

    * "Namespace.close_room()"

    * "Namespace.disconnect()"

    * "Namespace.emit()"

    * "Namespace.enter_room()"

    * "Namespace.get_session()"

    * "Namespace.leave_room()"

    * "Namespace.rooms()"

    * "Namespace.save_session()"

    * "Namespace.send()"

    * "Namespace.session()"

    * "Namespace.trigger_event()"

  * "AsyncClientNamespace"

    * "AsyncClientNamespace.call()"

    * "AsyncClientNamespace.disconnect()"

    * "AsyncClientNamespace.emit()"

    * "AsyncClientNamespace.send()"

    * "AsyncClientNamespace.trigger_event()"

  * "AsyncNamespace"

    * "AsyncNamespace.call()"

    * "AsyncNamespace.close_room()"

    * "AsyncNamespace.disconnect()"

    * "AsyncNamespace.emit()"

    * "AsyncNamespace.enter_room()"

    * "AsyncNamespace.get_session()"

    * "AsyncNamespace.leave_room()"

    * "AsyncNamespace.rooms()"

    * "AsyncNamespace.save_session()"

    * "AsyncNamespace.send()"

    * "AsyncNamespace.session()"

    * "AsyncNamespace.trigger_event()"

  * "Manager"

    * "Manager.close_room()"

    * "Manager.connect()"

    * "Manager.disconnect()"

    * "Manager.emit()"

    * "Manager.enter_room()"

    * "Manager.get_namespaces()"

    * "Manager.get_participants()"

    * "Manager.get_rooms()"

    * "Manager.initialize()"

    * "Manager.leave_room()"

    * "Manager.pre_disconnect()"

    * "Manager.trigger_callback()"

  * "PubSubManager"

    * "PubSubManager.close_room()"

    * "PubSubManager.connect()"

    * "PubSubManager.disconnect()"

    * "PubSubManager.emit()"

    * "PubSubManager.enter_room()"

    * "PubSubManager.get_namespaces()"

    * "PubSubManager.get_participants()"

    * "PubSubManager.get_rooms()"

    * "PubSubManager.initialize()"

    * "PubSubManager.leave_room()"

    * "PubSubManager.pre_disconnect()"

    * "PubSubManager.trigger_callback()"

  * "KombuManager"

    * "KombuManager.close_room()"

    * "KombuManager.connect()"

    * "KombuManager.disconnect()"

    * "KombuManager.emit()"

    * "KombuManager.enter_room()"

    * "KombuManager.get_namespaces()"

    * "KombuManager.get_participants()"

    * "KombuManager.get_rooms()"

    * "KombuManager.initialize()"

    * "KombuManager.leave_room()"

    * "KombuManager.pre_disconnect()"

    * "KombuManager.trigger_callback()"

  * "RedisManager"

    * "RedisManager.close_room()"

    * "RedisManager.connect()"

    * "RedisManager.disconnect()"

    * "RedisManager.emit()"

    * "RedisManager.enter_room()"

    * "RedisManager.get_namespaces()"

    * "RedisManager.get_participants()"

    * "RedisManager.get_rooms()"

    * "RedisManager.initialize()"

    * "RedisManager.leave_room()"

    * "RedisManager.pre_disconnect()"

    * "RedisManager.trigger_callback()"

  * "KafkaManager"

    * "KafkaManager.close_room()"

    * "KafkaManager.connect()"

    * "KafkaManager.disconnect()"

    * "KafkaManager.emit()"

    * "KafkaManager.enter_room()"

    * "KafkaManager.get_namespaces()"

    * "KafkaManager.get_participants()"

    * "KafkaManager.get_rooms()"

    * "KafkaManager.initialize()"

    * "KafkaManager.leave_room()"

    * "KafkaManager.pre_disconnect()"

    * "KafkaManager.trigger_callback()"

  * "AsyncManager"

    * "AsyncManager.close_room()"

    * "AsyncManager.connect()"

    * "AsyncManager.disconnect()"

    * "AsyncManager.emit()"

    * "AsyncManager.enter_room()"

    * "AsyncManager.get_namespaces()"

    * "AsyncManager.get_participants()"

    * "AsyncManager.get_rooms()"

    * "AsyncManager.initialize()"

    * "AsyncManager.leave_room()"

    * "AsyncManager.pre_disconnect()"

    * "AsyncManager.trigger_callback()"

  * "AsyncRedisManager"

    * "AsyncRedisManager.close_room()"

    * "AsyncRedisManager.connect()"

    * "AsyncRedisManager.disconnect()"

    * "AsyncRedisManager.emit()"

    * "AsyncRedisManager.enter_room()"

    * "AsyncRedisManager.get_namespaces()"

    * "AsyncRedisManager.get_participants()"

    * "AsyncRedisManager.get_rooms()"

    * "AsyncRedisManager.initialize()"

    * "AsyncRedisManager.leave_room()"

    * "AsyncRedisManager.pre_disconnect()"

    * "AsyncRedisManager.trigger_callback()"

  * "AsyncAioPikaManager"

    * "AsyncAioPikaManager.close_room()"

    * "AsyncAioPikaManager.connect()"

    * "AsyncAioPikaManager.disconnect()"

    * "AsyncAioPikaManager.emit()"

    * "AsyncAioPikaManager.enter_room()"

    * "AsyncAioPikaManager.get_namespaces()"

    * "AsyncAioPikaManager.get_participants()"

    * "AsyncAioPikaManager.get_rooms()"

    * "AsyncAioPikaManager.initialize()"

    * "AsyncAioPikaManager.leave_room()"

    * "AsyncAioPikaManager.pre_disconnect()"

    * "AsyncAioPikaManager.trigger_callback()"

* Index

* Module Index

* Search Page
