Merge pull request #7 from mr-fatalyst/0.5.0-dev

0.5.0 dev

Author: mr-fatalyst

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to FastOpenAPI are documented in this file.
 
 FastOpenAPI follows the [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) format.
 
+## [0.5.0] - Unreleased
+
+### Added
+- `AioHttpRouter` for integration with the `AioHttp` framework
+- Class-level cache for model schemas
+- `response_errors` for routers
+- `error_handler` for standard error responses
+
 ## [0.4.0] - 2025-03-20
 
 ### Added

README.md

@@ -30,12 +30,18 @@ pip install fastopenapi
 
 #### Install FastOpenAPI with a specific framework:
 ```bash
+pip install fastopenapi[aiohttp]
+```
+```bash
 pip install fastopenapi[falcon]
 ```
 ```bash
 pip install fastopenapi[flask]
 ```
 ```bash
+pip install fastopenapi[quart]
+```
+```bash
 pip install fastopenapi[sanic]
 ```
 ```bash
@@ -57,6 +63,35 @@ pip install fastopenapi[tornado]
 
 #### Examples:
 
+- ![AIOHTTP](https://img.shields.io/badge/AioHttp-0078D7?style=flat&logo=python&logoColor=white)
+  <details>
+    <summary>Click to expand the Falcon Example</summary>
+    
+    ```python
+    from aiohttp import web
+    from pydantic import BaseModel
+    
+    from fastopenapi.routers import AioHttpRouter
+    
+    app = web.Application()
+    router = AioHttpRouter(app=app)
+    
+    
+    class HelloResponse(BaseModel):
+        message: str
+    
+    
+    @router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+    async def hello(name: str):
+        """Say hello from aiohttp"""
+        return HelloResponse(message=f"Hello, {name}! It's aiohttp!")
+    
+    
+    if __name__ == "__main__":
+        web.run_app(app, host="127.0.0.1", port=8000)
+    ```
+  </details>
+
 - ![Falcon](https://img.shields.io/badge/Falcon-45b8d8?style=flat&logo=falcon&logoColor=white)
   <details>
     <summary>Click to expand the Falcon Example</summary>
@@ -264,7 +299,7 @@ http://127.0.0.1:8000/redoc
 ## ⚙️ Features
 - **Generate OpenAPI schemas** with Pydantic v2.
 - **Data validation** using Pydantic models.
-- **Supports multiple frameworks:** Falcon, Flask, Quart, Sanic, Starlette, Tornado.
+- **Supports multiple frameworks:** AIOHTTP, Falcon, Flask, Quart, Sanic, Starlette, Tornado.
 - **Proxy routing provides FastAPI-style routing**
 
 ---

benchmarks/README.md

@@ -8,6 +8,7 @@ Each implementation runs in a separate instance, and the benchmark measures resp
 
 ### 📈 Rough results
 - You can check rough results here:
+  - [AioHttp](aiohttp/AIOHTTP.md)
   - [Falcon](falcon/FALCON.md)
   - [Flask](flask/FLASK.md)
   - [Quart](quart/QUART.md)

benchmarks/aiohttp/AIOHTTP.md

@@ -0,0 +1,50 @@
+# AioHttp Benchmark
+
+---
+
+## Testing Original Implementation
+```
+Original - Running 10000 iterations per endpoint
+--------------------------------------------------
+GET all records: 8.5742 sec total, 0.86 ms per request
+GET one record: 8.7001 sec total, 0.87 ms per request
+POST new record: 9.0483 sec total, 0.90 ms per request
+PUT record: 9.1385 sec total, 0.91 ms per request
+PATCH record: 9.1465 sec total, 0.91 ms per request
+DELETE record: 17.7022 sec total, 1.77 ms per request
+```
+---
+
+## Testing FastOpenAPI Implementation
+
+```
+FastOpenAPI - Running 10000 iterations per endpoint
+--------------------------------------------------
+GET all records: 8.7114 sec total, 0.87 ms per request
+GET one record: 9.2981 sec total, 0.93 ms per request
+POST new record: 9.4486 sec total, 0.94 ms per request
+PUT record: 9.4418 sec total, 0.94 ms per request
+PATCH record: 9.4253 sec total, 0.94 ms per request
+DELETE record: 18.2327 sec total, 1.82 ms per request
+```
+
+---
+
+## Performance Comparison (10000 iterations)
+
+| Endpoint         | Original | FastOpenAPI | Difference      |
+|------------------|----------|-------------|-----------------|
+| GET all records  | 0.86 ms  | 0.87 ms     | +0.01 ms (+1.6%) |
+| GET one record   | 0.87 ms  | 0.93 ms     | +0.06 ms (+6.9%) |
+| POST new record  | 0.90 ms  | 0.94 ms     | +0.04 ms (+4.4%) |
+| PUT record       | 0.91 ms  | 0.94 ms     | +0.03 ms (+3.3%) |
+| PATCH record     | 0.91 ms  | 0.94 ms     | +0.03 ms (+3.0%) |
+| DELETE record    | 1.77 ms  | 1.82 ms     | +0.05 ms (+3.0%) |
+
+
+
+---
+
+[<< Back](../README.md)
+
+---

benchmarks/aiohttp/with_fastopenapi/run.py

@@ -0,0 +1,95 @@
+from aiohttp import web
+
+from benchmarks.aiohttp.with_fastopenapi.schemas import (
+    RecordCreate,
+    RecordResponse,
+    RecordUpdate,
+)
+from benchmarks.aiohttp.with_fastopenapi.storage import RecordStore
+from fastopenapi.routers import AioHttpRouter
+
+# Initialize AioHttp app and router
+app = web.Application()
+router = AioHttpRouter(
+    app=app,
+    title="Record API",
+    description="A simple Record API built with FastOpenAPI and AioHttp",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json",
+)
+
+# Initialize the storage
+store = RecordStore()
+
+
+# Define routes using the AioHttpRouter decorators
+@router.get("/records", tags=["records"], response_model=list[RecordResponse])
+async def get_records():
+    """
+    Get all records
+    """
+    return store.get_all()
+
+
+@router.get("/records/{record_id}", tags=["records"], response_model=RecordResponse)
+async def get_record(record_id: str):
+    """
+    Get a specific record by ID
+    """
+    record = store.get_by_id(record_id)
+    if not record:
+        raise web.HTTPNotFound(reason="Not Found")
+    return record
+
+
+@router.post(
+    "/records", tags=["records"], status_code=201, response_model=RecordResponse
+)
+async def create_record(record: RecordCreate):
+    """
+    Create a new record
+    """
+    return store.create(record)
+
+
+@router.put("/records/{record_id}", tags=["records"], response_model=RecordResponse)
+async def update_record_full(record_id: str, record: RecordCreate):
+    """
+    Update a record completely (all fields required)
+    """
+    existing_record = store.get_by_id(record_id)
+    if not existing_record:
+        raise web.HTTPNotFound(reason="Not Found")
+
+    # Delete and recreate with the same ID
+    store.delete(record_id)
+    new_record = {"id": record_id, **record.model_dump()}
+    store.records[record_id] = new_record
+    return RecordResponse(**new_record)
+
+
+@router.patch("/records/{record_id}", tags=["records"], response_model=RecordResponse)
+async def update_record_partial(record_id: str, record: RecordUpdate):
+    """
+    Update a record partially (only specified fields)
+    """
+    updated_record = store.update(record_id, record)
+    if not updated_record:
+        raise web.HTTPNotFound(reason="Not Found")
+    return updated_record
+
+
+@router.delete("/records/{record_id}", tags=["records"], status_code=204)
+async def delete_record(record_id: str):
+    """
+    Delete a record
+    """
+    if not store.delete(record_id):
+        raise web.HTTPNotFound(reason="Not Found")
+    return None
+
+
+if __name__ == "__main__":
+    web.run_app(app, host="127.0.0.1", port=8001)

benchmarks/aiohttp/with_fastopenapi/schemas.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel, Field
+
+
+class RecordCreate(BaseModel):
+    title: str = Field(..., min_length=1, max_length=100)
+    description: str | None = Field(None, max_length=500)
+    is_completed: bool = Field(False)
+
+
+class RecordUpdate(BaseModel):
+    title: str | None = Field(None, min_length=1, max_length=100)
+    description: str | None = Field(None, max_length=500)
+    is_completed: bool | None = None
+
+
+class RecordResponse(BaseModel):
+    id: str
+    title: str
+    description: str | None = None
+    is_completed: bool

benchmarks/aiohttp/with_fastopenapi/storage.py

@@ -0,0 +1,45 @@
+import uuid
+
+from .schemas import RecordCreate, RecordResponse, RecordUpdate
+
+
+class RecordStore:
+    def __init__(self):
+        self.records: dict[str, dict] = {}
+
+    def create(self, record_data: RecordCreate) -> RecordResponse:
+        record_id = str(uuid.uuid4())
+        record = {"id": record_id, **record_data.model_dump()}
+        self.records[record_id] = record
+        return RecordResponse(**record)
+
+    def get_all(self) -> list[RecordResponse]:
+        return [RecordResponse(**record) for record in self.records.values()]
+
+    def get_by_id(self, record_id: str) -> RecordResponse | None:
+        record = self.records.get(record_id)
+        if record:
+            return RecordResponse(**record)
+        return None
+
+    def update(
+        self, record_id: str, record_data: RecordUpdate
+    ) -> RecordResponse | None:
+        if record_id not in self.records:
+            return None
+
+        update_data = record_data.model_dump(exclude_unset=True)
+        if not update_data:
+            return RecordResponse(**self.records[record_id])
+
+        for key, value in update_data.items():
+            if value is not None:
+                self.records[record_id][key] = value
+
+        return RecordResponse(**self.records[record_id])
+
+    def delete(self, record_id: str) -> bool:
+        if record_id in self.records:
+            del self.records[record_id]
+            return True
+        return False

benchmarks/aiohttp/without_fastopenapi/run.py

@@ -0,0 +1,83 @@
+from aiohttp import web
+
+from benchmarks.aiohttp.without_fastopenapi.schemas import (
+    RecordCreate,
+    RecordResponse,
+    RecordUpdate,
+)
+from benchmarks.aiohttp.without_fastopenapi.storage import RecordStore
+
+store = RecordStore()
+
+
+async def get_all_records(request: web.Request):
+    records = store.get_all()
+    return web.json_response([record.model_dump() for record in records], status=200)
+
+
+async def get_one_record(request: web.Request):
+    record_id = request.match_info.get("record_id")
+    record = store.get_by_id(record_id)
+    if record:
+        return web.json_response(record.model_dump(), status=200)
+    else:
+        return web.json_response({"error": "Record not found"}, status=404)
+
+
+async def create_record(request: web.Request):
+    try:
+        data = await request.json()
+        record_data = RecordCreate(**data)
+        new_record = store.create(record_data)
+        return web.json_response(new_record.model_dump(), status=201)
+    except ValueError as e:
+        return web.json_response({"error": str(e)}, status=400)
+
+
+async def replace_record(request: web.Request):
+    record_id = request.match_info.get("record_id")
+    if not store.get_by_id(record_id):
+        return web.json_response({"error": "Record not found"}, status=404)
+    try:
+        data = await request.json()
+        record_data = RecordCreate(**data)
+        store.delete(record_id)
+        record = {"id": record_id, **record_data.model_dump()}
+        store.records[record_id] = record
+        return web.json_response(RecordResponse(**record).model_dump(), status=200)
+    except ValueError as e:
+        return web.json_response({"error": str(e)}, status=400)
+
+
+async def update_record(request: web.Request):
+    record_id = request.match_info.get("record_id")
+    try:
+        data = await request.json()
+        record_data = RecordUpdate(**data)
+        updated_record = store.update(record_id, record_data)
+        if updated_record:
+            return web.json_response(updated_record.model_dump(), status=200)
+        else:
+            return web.json_response({"error": "Record not found"}, status=404)
+    except ValueError as e:
+        return web.json_response({"error": str(e)}, status=400)
+
+
+async def delete_record(request: web.Request):
+    record_id = request.match_info.get("record_id")
+    if store.delete(record_id):
+        return web.Response(status=204)
+    else:
+        return web.json_response({"error": "Record not found"}, status=404)
+
+
+app = web.Application()
+app.router.add_get("/records", get_all_records)
+app.router.add_get("/records/{record_id}", get_one_record)
+app.router.add_post("/records", create_record)
+app.router.add_put("/records/{record_id}", replace_record)
+app.router.add_patch("/records/{record_id}", update_record)
+app.router.add_delete("/records/{record_id}", delete_record)
+
+if __name__ == "__main__":
+    web.run_app(app, host="127.0.0.1", port=8000)