pydantic-socketio 0.1.0__tar.gz

pydantic_socketio-0.1.0/.gitattributes

@@ -0,0 +1,4 @@
+# exclude .gitignore and similar from the generated tarball
+.git*           export-ignore
+# exclude CI configurations
+.github         export-ignore

pydantic_socketio-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,76 @@
+name: Publish Python 🐍 distributions 📦
+
+on:
+  workflow_dispatch:
+    inputs:
+      publish_testpypi:
+        type: boolean
+        default: false
+        description: Publish to TestPyPI
+      publish_pypi:
+        type: boolean
+        default: false
+        description: Publish to PyPI
+      publish_gh_release:
+        type: boolean
+        default: true
+        description: Publish to GitHub Release
+      use_changelog:
+        type: boolean
+        default: true
+        description: Extract release notes from CHANGELOG.md
+      changelog_file:
+        type: string
+        default: CHANGELOG.md
+        description: Path to changelog file
+        required: false
+      release_tag:
+        type: string
+        description: Tag to package (empty for latest tag)
+        required: false
+
+jobs:
+  get-tag:
+    runs-on: ubuntu-latest
+    outputs:
+      release_tag: ${{ steps.set_release_tag.outputs.tag }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    - name: Fetch all tags
+      run: |
+        git fetch --prune --unshallow --tags
+    - name: Verify and set release tag
+      id: set_release_tag
+      run: |
+        release_tag=${{ inputs.release_tag }}
+        if [ -z "$release_tag" ]; then
+          echo "Input tag is empty. Fetching latest tag."
+          release_tag=$(git describe --tags $(git rev-list --tags --max-count=1))
+          if [ -z "$release_tag" ]; then
+            echo "No latest tag available. Exiting workflow."
+            exit 1
+          fi
+        else
+          if ! git rev-parse -q --verify "refs/tags/$release_tag" >/dev/null; then
+            echo "Invalid tag '$release_tag'. Exiting workflow."
+            exit 1
+          fi
+        fi
+        echo "tag=$release_tag" >> $GITHUB_OUTPUT
+  build-n-publish:
+    needs: get-tag
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing and sigstore
+      contents: write  # IMPORTANT: mandatory for making GitHub Releases
+    uses: atomiechen/reusable-workflows/.github/workflows/publish-python-distributions.yml@main
+    with:
+      publish_testpypi: ${{ inputs.publish_testpypi }}
+      publish_pypi: ${{ inputs.publish_pypi }}
+      publish_gh_release: ${{ inputs.publish_gh_release }}
+      use_changelog: ${{ inputs.use_changelog }}
+      changelog_file: ${{ inputs.changelog_file }}
+      release_tag: ${{ needs.get-tag.outputs.release_tag }}
+    secrets:
+      TEST_PYPI_API_TOKEN: ${{ secrets.TEST_PYPI_API_TOKEN }}
+      PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}

pydantic_socketio-0.1.0/.gitignore

@@ -0,0 +1,168 @@
+# ruff
+.ruff_cache
+
+
+# == Below are commonly ignored files for Python projects == #
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

pydantic_socketio-0.1.0/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Change Log
+
+All notable changes to Pydantic-SocketIO will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+
+## [0.1.0] - 2025-03-16
+
+### Added
+
+Initial features:
+
+- Pydantic enhanced socketio server and client (both sync and async). They should be drop-in replacements for the original socketio server and client.
+- Alternatively, monkey patching method `monkey_patch()` for the original socketio server and client.
+- Integration with fastapi `FastAPISocketIO`.

pydantic_socketio-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Atomie CHEN
+
+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.

pydantic_socketio-0.1.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: pydantic-socketio
+Version: 0.1.0
+Summary: Pydantic-enhanced SocketIO with FastAPI integration support.
+Project-URL: homepage, https://github.com/atomiechen/Pydantic-SocketIO
+Project-URL: issues, https://github.com/atomiechen/Pydantic-SocketIO/issues
+Project-URL: changelog, https://github.com/atomiechen/Pydantic-SocketIO/blob/main/CHANGELOG.md
+Author-email: Atomie CHEN <atomic_cwh@163.com>
+License-File: LICENSE
+Keywords: fastapi,pydantic,socketio
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: python-socketio>=5.12.1
+Provides-Extra: asyncio-client
+Requires-Dist: python-socketio[asyncio-client]>=5.12.1; extra == 'asyncio-client'
+Provides-Extra: client
+Requires-Dist: python-socketio[client]>=5.12.1; extra == 'client'
+Provides-Extra: docs
+Requires-Dist: python-socketio[docs]>=5.12.1; extra == 'docs'
+Provides-Extra: fastapi
+Requires-Dist: fastapi[standard]>=0.115.11; extra == 'fastapi'
+Description-Content-Type: text/markdown
+
+# Pydantic-SocketIO
+
+A Pydantic-enhanced SocketIO library for Python, with FastAPI integration.
+
+
+## Features
+
+⭐️ **Pydantic-Enhanced SocketIO**: Drop-in replacements for the original [python-socketio](https://github.com/miguelgrinberg/python-socketio) server and client (sync and async), with built-in Pydantic validation for event data. You can also easily monkey patch this validation to the original `socketio` server and client.
+
+🪐 **Easy Integration with FastAPI**: Seamlessly integrates `Socket.IO` with FastAPI, allowing you to manage event-driven communication effortlessly.
+
+
+## Installation
+
+```sh
+pip install pydantic-socketio
+```
+
+
+## Usage
+
+### Recommended: Pydantic-Enhanced SocketIO Server and Client
+
+Drop-in replacements for the original [python-socketio](https://github.com/miguelgrinberg/python-socketio) server and client are provided. 
+
+The enhanced SocketIO server with Pydantic validation:
+
+```python
+from pydantic import BaseModel
+import pydantic_socketio
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+# Create an enhanced SocketIO server; use AsyncServer for async server
+sio = pydantic_socketio.Server()
+
+# Define an event with Pydantic validation
+@sio.event
+def message(data: ChatMessage):
+    print(f"Received chat message from {data.role}: {data.content}")
+    data.content = data.content.upper()
+    print(f"Sending uppercase message: {data.content}")
+    # Emit an event with Pydantic model without any additional conversion
+    sio.emit("message", data)
+
+# `on` decorator is also supported
+@sio.on("custom_event")
+def handle_custom_event(data: int):
+    ...
+```
+
+The enhanced SocketIO client with Pydantic validation:
+
+```python
+import pydantic_socketio
+
+# Create an enhanced SocketIO client; use AsyncClient for async client
+sio = pydantic_socketio.Client()
+
+@sio.event
+def ping(data: int):
+    ...
+
+@sio.on("pong")
+def handle_pong(data: int):
+    ...
+```
+
+
+### Alternative: Monkey Patching for Original SocketIO
+
+Alternatively, if you want to apply Pydantic validation to the original [python-socketio](https://github.com/miguelgrinberg/python-socketio) server and client without replacing them, you can use the `monkey_patch()` method:
+
+```python
+from pydantic_socketio import monkey_patch
+import socketio
+
+# Apply monkey patch to the original socketio server and client
+monkey_patch()
+
+# Now, you can use the original socketio server and client with Pydantic validation
+sio = socketio.Server()
+
+@sio.event
+def ping(data: int):
+    print(f"Received ping: {data}")
+    data += 1
+    print(f"Sending pong: {data}")
+    sio.emit("poing", data)
+```
+
+
+### FastAPI Integration
+
+You can easily integrate the enhanced socketio server with FastAPI by using FastAPISocketIO:
+
+```python
+from fastapi import FastAPI
+from pydantic_socketio import FastAPISocketIO
+
+app = FastAPI()
+
+@app.get("/")
+async def root():
+    return {"message": "Hello World"}
+...
+
+# Create a FastAPI socketio server
+sio = FastAPISocketIO(app)
+
+@sio.event
+async def ping(data: int):
+    print(f"Received ping: {data}")
+    data += 1
+    print(f"Sending pong: {data}")
+    await sio.emit("pong", data)
+...
+```
+
+You can also integrate the SocketIO server manually after FastAPI initialization:
+
+```python
+from fastapi import FastAPI
+from pydantic_socketio import FastAPISocketIO
+
+sio = FastAPISocketIO()
+...
+app = FastAPI()
+...
+
+# Integrate the SocketIO server to FastAPI
+sio.integrate(app)
+```
+
+## License
+
+[Pydantic-SocketIO](https://github.com/atomiechen/Pydantic-SocketIO) © 2025 by [Atomie CHEN](https://github.com/atomiechen) is licensed under the [MIT License](https://github.com/atomiechen/Pydantic-SocketIO/blob/main/LICENSE).

pydantic_socketio-0.1.0/README.md

@@ -0,0 +1,139 @@
+# Pydantic-SocketIO
+
+A Pydantic-enhanced SocketIO library for Python, with FastAPI integration.
+
+
+## Features
+
+⭐️ **Pydantic-Enhanced SocketIO**: Drop-in replacements for the original [python-socketio](https://github.com/miguelgrinberg/python-socketio) server and client (sync and async), with built-in Pydantic validation for event data. You can also easily monkey patch this validation to the original `socketio` server and client.
+
+🪐 **Easy Integration with FastAPI**: Seamlessly integrates `Socket.IO` with FastAPI, allowing you to manage event-driven communication effortlessly.
+
+
+## Installation
+
+```sh
+pip install pydantic-socketio
+```
+
+
+## Usage
+
+### Recommended: Pydantic-Enhanced SocketIO Server and Client
+
+Drop-in replacements for the original [python-socketio](https://github.com/miguelgrinberg/python-socketio) server and client are provided. 
+
+The enhanced SocketIO server with Pydantic validation:
+
+```python
+from pydantic import BaseModel
+import pydantic_socketio
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+# Create an enhanced SocketIO server; use AsyncServer for async server
+sio = pydantic_socketio.Server()
+
+# Define an event with Pydantic validation
+@sio.event
+def message(data: ChatMessage):
+    print(f"Received chat message from {data.role}: {data.content}")
+    data.content = data.content.upper()
+    print(f"Sending uppercase message: {data.content}")
+    # Emit an event with Pydantic model without any additional conversion
+    sio.emit("message", data)
+
+# `on` decorator is also supported
+@sio.on("custom_event")
+def handle_custom_event(data: int):
+    ...
+```
+
+The enhanced SocketIO client with Pydantic validation:
+
+```python
+import pydantic_socketio
+
+# Create an enhanced SocketIO client; use AsyncClient for async client
+sio = pydantic_socketio.Client()
+
+@sio.event
+def ping(data: int):
+    ...
+
+@sio.on("pong")
+def handle_pong(data: int):
+    ...
+```
+
+
+### Alternative: Monkey Patching for Original SocketIO
+
+Alternatively, if you want to apply Pydantic validation to the original [python-socketio](https://github.com/miguelgrinberg/python-socketio) server and client without replacing them, you can use the `monkey_patch()` method:
+
+```python
+from pydantic_socketio import monkey_patch
+import socketio
+
+# Apply monkey patch to the original socketio server and client
+monkey_patch()
+
+# Now, you can use the original socketio server and client with Pydantic validation
+sio = socketio.Server()
+
+@sio.event
+def ping(data: int):
+    print(f"Received ping: {data}")
+    data += 1
+    print(f"Sending pong: {data}")
+    sio.emit("poing", data)
+```
+
+
+### FastAPI Integration
+
+You can easily integrate the enhanced socketio server with FastAPI by using FastAPISocketIO:
+
+```python
+from fastapi import FastAPI
+from pydantic_socketio import FastAPISocketIO
+
+app = FastAPI()
+
+@app.get("/")
+async def root():
+    return {"message": "Hello World"}
+...
+
+# Create a FastAPI socketio server
+sio = FastAPISocketIO(app)
+
+@sio.event
+async def ping(data: int):
+    print(f"Received ping: {data}")
+    data += 1
+    print(f"Sending pong: {data}")
+    await sio.emit("pong", data)
+...
+```
+
+You can also integrate the SocketIO server manually after FastAPI initialization:
+
+```python
+from fastapi import FastAPI
+from pydantic_socketio import FastAPISocketIO
+
+sio = FastAPISocketIO()
+...
+app = FastAPI()
+...
+
+# Integrate the SocketIO server to FastAPI
+sio.integrate(app)
+```
+
+## License
+
+[Pydantic-SocketIO](https://github.com/atomiechen/Pydantic-SocketIO) © 2025 by [Atomie CHEN](https://github.com/atomiechen) is licensed under the [MIT License](https://github.com/atomiechen/Pydantic-SocketIO/blob/main/LICENSE).

pydantic_socketio-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "pydantic-socketio"
+version = "0.1.0"
+description = "Pydantic-enhanced SocketIO with FastAPI integration support."
+readme = "README.md"
+authors = [
+    { name = "Atomie CHEN", email = "atomic_cwh@163.com" }
+]
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+keywords = ["pydantic", "socketio", "fastapi"]
+dependencies = [
+    "pydantic>=2.10.6",
+    "python-socketio>=5.12.1",
+]
+
+[project.urls]
+homepage = "https://github.com/atomiechen/Pydantic-SocketIO"
+issues = "https://github.com/atomiechen/Pydantic-SocketIO/issues"
+changelog = "https://github.com/atomiechen/Pydantic-SocketIO/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+fastapi = [
+    "fastapi[standard]>=0.115.11",
+]
+client = [
+    "python-socketio[client]>=5.12.1",
+]
+asyncio-client = [
+    "python-socketio[asyncio-client]>=5.12.1",
+]
+docs = [
+    "python-socketio[docs]>=5.12.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "eventlet>=0.39.1",
+    "fastapi[standard]>=0.115.11",
+    "python-socketio[client]>=5.12.1",
+    "ruff>=0.11.0",
+]

pydantic_socketio-0.1.0/scripts/format.sh

@@ -0,0 +1,5 @@
+set -x
+set -e
+
+ruff check src tests --fix
+ruff format src tests

pydantic_socketio-0.1.0/scripts/lint.sh

@@ -0,0 +1,5 @@
+set -e
+set -x
+
+ruff check src tests
+ruff format src tests --check

pydantic_socketio-0.1.0/src/pydantic_socketio/__init__.py

@@ -0,0 +1,16 @@
+# first import everything from socketio
+from socketio import *  # type: ignore # noqa: F403
+
+from .pydantic_socketio import (
+    BaseClient as BaseClient,
+    Client as Client,
+    AsyncClient as AsyncClient,
+    BaseServer as BaseServer,
+    Server as Server,
+    AsyncServer as AsyncServer,
+    monkey_patch as monkey_patch,
+)
+
+from .fastapi_socketio import (
+    FastAPISocketIO as FastAPISocketIO,
+)