Initial release: moderyo v2.0.7

- Sync client (Moderyo) and async client (AsyncModeryo)
- Full Pydantic v2 models with 27-category support
- Policy decision, detected phrases, long-text analysis
- Automatic retry with exponential backoff
- httpx-based HTTP client, Python 3.8+
- CI/CD workflows for GitHub Actions

Author: Moderyo

.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install poetry
+          poetry install
+
+      - name: Lint with ruff
+        run: poetry run ruff check .
+
+      - name: Type check with mypy
+        run: poetry run mypy moderyo/
+
+      - name: Run tests
+        run: poetry run pytest -v
+        env:
+          MODERYO_API_KEY: ${{ secrets.MODERYO_API_KEY }}

.github/workflows/pypi-publish.yml

@@ -0,0 +1,31 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build twine
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        run: twine upload dist/*
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}

.gitignore

@@ -0,0 +1,37 @@
+# Byte-compiled / optimized
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.*
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.mypy_cache/
+.ruff_cache/

CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to the Moderyo Python SDK will be documented in this file.
+
+## [2.0.7] - 2026-02-17
+
+### Added
+- Initial public release on PyPI
+- Synchronous client (`Moderyo`) and async client (`AsyncModeryo`)
+- Full Pydantic v2 models with 27-category support
+- Policy decision support (ALLOW / FLAG / BLOCK)
+- Score breakdown: toxicity, hate, harassment, scam, violence, fraud
+- Category detection (30+ categories including child safety, extremism)
+- Detected phrases with labels
+- Batch processing support (`moderate_batch`)
+- Long-text analysis with sentence-level scoring
+- Automatic retry with exponential backoff
+- Rate limiting handling
+- Configurable options: mode, risk level, player_id
+- Content options: skip_profanity, skip_threat, skip_masked_word, long_text_mode
+- Comprehensive exception hierarchy (AuthenticationError, RateLimitError, etc.)
+
+### Technical
+- Python 3.8+ support
+- httpx for HTTP client
+- Pydantic v2 for data models
+- Typed (PEP 561 compatible)
+- Zero extra dependencies beyond httpx and pydantic

LICENSE

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

README.md

@@ -0,0 +1,221 @@
+# Moderyo Python SDK
+
+Official Python client library for the Moderyo Content Moderation API.
+
+[![PyPI version](https://badge.fury.io/py/moderyo.svg)](https://badge.fury.io/py/moderyo)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install moderyo
+```
+
+Or with Poetry:
+
+```bash
+poetry add moderyo
+```
+
+## Quick Start
+
+```python
+from moderyo import Moderyo
+
+# Initialize client
+client = Moderyo(api_key="sk_live_xxxxx")
+
+# Moderate content
+result = client.moderate("Hello, this is a test message")
+
+print(result.flagged)        # True/False
+print(result.action)         # 'allow', 'flag', 'block'
+print(result.categories)     # Category breakdown
+print(result.explanation)    # Human-readable explanation
+```
+
+## Async Support
+
+```python
+import asyncio
+from moderyo import AsyncModeryo
+
+async def main():
+    client = AsyncModeryo(api_key="sk_live_xxxxx")
+    
+    result = await client.moderate("Check this content")
+    print(result.action)
+
+asyncio.run(main())
+```
+
+## Batch Processing
+
+```python
+# Moderate multiple items efficiently
+results = client.moderate_batch([
+    "First message",
+    "Second message",
+    "Third message"
+])
+
+for result in results:
+    print(f"{result.id}: {result.action}")
+```
+
+## Configuration Options
+
+```python
+client = Moderyo(
+    api_key="sk_live_xxxxx",
+    
+    # Optional settings
+    base_url="https://api.moderyo.com",  # Custom API endpoint
+    timeout=30,                           # Request timeout in seconds
+    max_retries=3,                        # Retry count on failure
+    
+    # Callbacks
+    on_error=lambda e: print(f"Error: {e}"),
+    on_rate_limit=lambda info: print(f"Rate limited: {info}")
+)
+```
+
+## Error Handling
+
+```python
+from moderyo import Moderyo
+from moderyo.exceptions import (
+    ModeryoError,
+    AuthenticationError,
+    RateLimitError,
+    ValidationError,
+    APIError
+)
+
+client = Moderyo(api_key="sk_live_xxxxx")
+
+try:
+    result = client.moderate("Some content")
+except AuthenticationError:
+    print("Invalid API key")
+except RateLimitError as e:
+    print(f"Rate limited. Retry after {e.retry_after} seconds")
+except ValidationError as e:
+    print(f"Invalid request: {e.message}")
+except APIError as e:
+    print(f"API error: {e.status_code} - {e.message}")
+except ModeryoError as e:
+    print(f"General error: {e}")
+```
+
+## Context & Metadata
+
+```python
+result = client.moderate(
+    content="User message here",
+    context={
+        "user_id": "user_123",
+        "content_type": "chat",
+        "platform": "mobile",
+        "language": "en"
+    }
+)
+```
+
+## Response Structure
+
+```python
+result = client.moderate("Some content")
+
+# Core fields
+result.id           # Unique request ID
+result.flagged      # bool - Any category triggered?
+result.action       # 'allow' | 'flag' | 'block'
+
+# Detailed scores
+result.categories   # Dict of category -> bool
+result.scores       # Dict of category -> float (0-1)
+
+# Explanation (Explainability 2.0)
+result.explanation  # Human-readable explanation
+
+# Policy info
+result.policy_decision  # Policy engine result
+result.safety_score     # 0-100 safety score
+```
+
+## Framework Integrations
+
+### FastAPI
+
+```python
+from fastapi import FastAPI, HTTPException, Depends
+from moderyo.integrations.fastapi import ModeryoDep
+
+app = FastAPI()
+
+@app.post("/messages")
+async def create_message(
+    content: str,
+    moderation = Depends(ModeryoDep(api_key="sk_live_xxx"))
+):
+    result = await moderation.check(content)
+    
+    if result.action == "block":
+        raise HTTPException(400, detail=result.explanation)
+    
+    return {"status": "ok", "flagged": result.flagged}
+```
+
+### Django
+
+```python
+from moderyo.integrations.django import moderate_content
+
+@moderate_content(field='message', on_block='reject')
+def create_message(request):
+    # Only reached if content is allowed or flagged
+    Message.objects.create(content=request.POST['message'])
+    return JsonResponse({'status': 'ok'})
+```
+
+### Flask
+
+```python
+from flask import Flask, request, jsonify
+from moderyo.integrations.flask import require_moderation
+
+app = Flask(__name__)
+
+@app.route('/messages', methods=['POST'])
+@require_moderation(api_key="sk_live_xxx", field='content')
+def create_message():
+    return jsonify({'status': 'ok'})
+```
+
+## Development
+
+```bash
+# Clone repository
+git clone https://github.com/moderyo/moderyo-python.git
+cd moderyo-python
+
+# Install dependencies
+poetry install
+
+# Run tests
+poetry run pytest
+
+# Run linting
+poetry run ruff check .
+poetry run mypy moderyo
+```
+
+## Examples
+
+See the [playground-examples](https://github.com/moderyo/playground-examples/tree/main/python) repository for a complete working FastAPI server example.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.