fastsio (Fast Socket.IO for Python)

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?
  • Why fastsio vs python-socketio and FastAPI?
  • Quick comparison to FastAPI-style handlers
  • 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 (fastsio)
  • 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
    • Horizontal Scaling
    • Emitting from external processes
• Routers
  • Basic usage
  • Decorators
  • Multiple routers
  • Interplay with class-based namespaces
• Dependency Injection
  • What can be injected
    • Built-in Dependencies
    • Custom Dependencies with Depends()
  • Basic Examples
  • Advanced Examples with Custom Dependencies
    • Database Dependency
    • Configuration Dependency
    • Caching Dependencies
    • Global Dependency Registration
  • How It Works
    • ContextVar-based System
    • Dependency Resolution
  • Notes
  • Synchronous Server Support
  • Architecture and Performance
• Middlewares
  • Basic Concepts
  • Middleware Types
  • Creating Middlewares
    • Method-based Middleware
    • Call-based Middleware
    • Synchronous Middleware
  • Middleware Configuration
    • Event Filtering
    • Namespace Filtering
    • Global Middlewares
  • Registering Middlewares
    • Adding to Server
    • Managing Middlewares
  • Built-in Middlewares
    • Authentication Middleware
    • Logging Middleware
    • Rate Limiting Middleware
  • Advanced Usage
    • Custom Exception Handling
    • Data Transformation
    • Middleware Chaining
  • Performance Considerations
  • Best Practices
  • Example: Complete Chat Application
• Pydantic Validation
  • Rules
  • Example
  • Error cases
• 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.add_middleware()
    • Server.add_router()
    • Server.call()
    • Server.close_room()
    • Server.disconnect()
    • Server.emit()
    • Server.enter_room()
    • Server.event()
    • Server.get_environ()
    • Server.get_middlewares()
    • Server.get_session()
    • Server.handle_request()
    • Server.instrument()
    • Server.leave_room()
    • Server.on()
    • Server.reason
    • Server.register_namespace()
    • Server.remove_middleware()
    • Server.rooms()
    • Server.save_session()
    • Server.send()
    • Server.session()
    • Server.shutdown()
    • Server.sleep()
    • Server.start_background_task()
    • Server.transport()
  • AsyncServer
    • AsyncServer.add_middleware()
    • AsyncServer.add_router()
    • AsyncServer.attach()
    • AsyncServer.call()
    • AsyncServer.close_room()
    • AsyncServer.disconnect()
    • AsyncServer.emit()
    • AsyncServer.enter_room()
    • AsyncServer.event()
    • AsyncServer.get_environ()
    • AsyncServer.get_middlewares()
    • AsyncServer.get_session()
    • AsyncServer.handle_request()
    • AsyncServer.instrument()
    • AsyncServer.leave_room()
    • AsyncServer.on()
    • AsyncServer.reason
    • AsyncServer.register_namespace()
    • AsyncServer.remove_middleware()
    • 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

• Index

• Module Index

• Search Page