fastopenapi 0.1.0__tar.gz

fastopenapi-0.1.0/LICENSE

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

fastopenapi-0.1.0/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.3
+Name: fastopenapi
+Version: 0.1.0
+Summary: A library for generating and integrating OpenAPI schemas using Pydantic v2.
+License: MIT
+Keywords: FastOpenAPI,OpenAPI,Pydantic,API,Python,Flask,Falcon,Sanic,Starlette
+Author: Nikita Ryzhenkov
+Author-email: nikita.ryzhenkoff@gmail.com
+Requires-Python: >=3.10
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Code Generators
+Provides-Extra: falcon
+Provides-Extra: flask
+Provides-Extra: sanic
+Provides-Extra: starlette
+Requires-Dist: falcon (>=4.0.2,<5.0.0) ; extra == "falcon"
+Requires-Dist: flask (>=3.1.0,<4.0.0) ; extra == "flask"
+Requires-Dist: pydantic (>=2.10.6,<3.0.0)
+Requires-Dist: sanic (>=24.12.0,<25.0.0) ; extra == "sanic"
+Requires-Dist: starlette (>=0.46.0,<0.47.0) ; extra == "starlette"
+Description-Content-Type: text/markdown
+
+
+# 🚀 FastOpenAPI
+![Test](https://github.com/mr-fatalyst/fastopenapi/actions/workflows/test.yml/badge.svg)
+![codecov](https://codecov.io/gh/mr-fatalyst/fastopenapi/branch/main/graph/badge.svg?token=USHR1I0CJB)
+
+**FastOpenAPI** is a library for generating and integrating OpenAPI schemas using Pydantic v2 and various frameworks (Falcon, Flask, Sanic, Starlette).
+
+---
+
+## 📦 Installation
+```bash
+pip install fastopenapi
+```
+
+---
+
+## ⚙️ Features
+- 📄 **Generate OpenAPI schemas** with Pydantic v2.
+- 🛡️ **Data validation** using Pydantic models.
+- 🛠️ **Supports multiple frameworks:** Falcon, Flask, Sanic, Starlette.
+- ✅ **Compatible with Pydantic v2.**
+
+---
+
+## 🛠️ Quick Start
+
+### ![Falcon](https://img.shields.io/badge/Falcon-45b8d8?style=flat&logo=falcon&logoColor=white)
+```python
+import falcon.asgi
+import uvicorn
+from pydantic import BaseModel
+
+from fastopenapi.routers.falcon import FalconRouter
+
+app = falcon.asgi.App()
+router = FalconRouter(app=app, docs_url="/docs/", openapi_version="3.0.0")
+
+
+class HelloResponse(BaseModel):
+    message: str
+
+
+@router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+async def hello(name: str):
+    """Say hello from Falcon"""
+    return HelloResponse(message=f"Hello, {name}! It's Falcon!")
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)
+
+```
+
+---
+
+### ![Flask](https://img.shields.io/badge/-Flask-000000?style=flat-square&logo=flask&logoColor=white)
+```python
+from flask import Flask
+from pydantic import BaseModel
+
+from fastopenapi.routers.flask import FlaskRouter
+
+app = Flask(__name__)
+router = FlaskRouter(app=app, docs_url="/docs/", openapi_version="3.0.0")
+
+
+class HelloResponse(BaseModel):
+    message: str
+
+
+@router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+def hello(name: str):
+    """Say hello from Flask"""
+    return HelloResponse(message=f"Hello, {name}! It's Flask!")
+
+
+if __name__ == "__main__":
+    app.run(debug=True, port=8000)
+
+```
+
+---
+
+### ![Sanic](https://img.shields.io/badge/-Sanic-00bfff?style=flat-square&logo=sanic&logoColor=white)
+```python
+from pydantic import BaseModel
+from sanic import Sanic
+
+from fastopenapi.routers.sanic import SanicRouter
+
+app = Sanic("MySanicApp")
+router = SanicRouter(app=app, docs_url="/docs/", openapi_version="3.0.0")
+
+
+class HelloResponse(BaseModel):
+    message: str
+
+
+@router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+async def hello(name: str):
+    """Say hello from Sanic"""
+    return HelloResponse(message=f"Hello, {name}! It's Sanic!")
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=8000, debug=True)
+
+```
+
+---
+
+### ![Starlette](https://img.shields.io/badge/-Starlette-ff4785?style=flat-square&logo=starlette&logoColor=white)
+```python
+import uvicorn
+from pydantic import BaseModel
+from starlette.applications import Starlette
+
+from fastopenapi.routers.starlette import StarletteRouter
+
+app = Starlette()
+router = StarletteRouter(app=app, docs_url="/docs/", openapi_version="3.0.0")
+
+
+class HelloResponse(BaseModel):
+    message: str
+
+
+@router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+async def hello(name: str):
+    """Say hello from Starlette"""
+    return HelloResponse(message=f"Hello, {name}! It's Starlette!")
+
+
+router.register_routes()
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)
+
+```
+
+---
+
+## 🛡️ **Type Safety with Pydantic v2**
+```python
+from pydantic import BaseModel
+
+class User(BaseModel):
+    id: int
+    name: str
+
+@router.post("/api/v1/users/")
+def create_user(user: User) -> User:
+    return user
+```
+
+---
+
+## 🧪 **Running Tests**
+```bash
+poetry run pytest
+```
+
+---
+
+## 📄 **License**
+This project is licensed under the terms of the MIT license.
+

fastopenapi-0.1.0/README.md

@@ -0,0 +1,166 @@
+
+# 🚀 FastOpenAPI
+![Test](https://github.com/mr-fatalyst/fastopenapi/actions/workflows/test.yml/badge.svg)
+![codecov](https://codecov.io/gh/mr-fatalyst/fastopenapi/branch/main/graph/badge.svg?token=USHR1I0CJB)
+
+**FastOpenAPI** is a library for generating and integrating OpenAPI schemas using Pydantic v2 and various frameworks (Falcon, Flask, Sanic, Starlette).
+
+---
+
+## 📦 Installation
+```bash
+pip install fastopenapi
+```
+
+---
+
+## ⚙️ Features
+- 📄 **Generate OpenAPI schemas** with Pydantic v2.
+- 🛡️ **Data validation** using Pydantic models.
+- 🛠️ **Supports multiple frameworks:** Falcon, Flask, Sanic, Starlette.
+- ✅ **Compatible with Pydantic v2.**
+
+---
+
+## 🛠️ Quick Start
+
+### ![Falcon](https://img.shields.io/badge/Falcon-45b8d8?style=flat&logo=falcon&logoColor=white)
+```python
+import falcon.asgi
+import uvicorn
+from pydantic import BaseModel
+
+from fastopenapi.routers.falcon import FalconRouter
+
+app = falcon.asgi.App()
+router = FalconRouter(app=app, docs_url="/docs/", openapi_version="3.0.0")
+
+
+class HelloResponse(BaseModel):
+    message: str
+
+
+@router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+async def hello(name: str):
+    """Say hello from Falcon"""
+    return HelloResponse(message=f"Hello, {name}! It's Falcon!")
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)
+
+```
+
+---
+
+### ![Flask](https://img.shields.io/badge/-Flask-000000?style=flat-square&logo=flask&logoColor=white)
+```python
+from flask import Flask
+from pydantic import BaseModel
+
+from fastopenapi.routers.flask import FlaskRouter
+
+app = Flask(__name__)
+router = FlaskRouter(app=app, docs_url="/docs/", openapi_version="3.0.0")
+
+
+class HelloResponse(BaseModel):
+    message: str
+
+
+@router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+def hello(name: str):
+    """Say hello from Flask"""
+    return HelloResponse(message=f"Hello, {name}! It's Flask!")
+
+
+if __name__ == "__main__":
+    app.run(debug=True, port=8000)
+
+```
+
+---
+
+### ![Sanic](https://img.shields.io/badge/-Sanic-00bfff?style=flat-square&logo=sanic&logoColor=white)
+```python
+from pydantic import BaseModel
+from sanic import Sanic
+
+from fastopenapi.routers.sanic import SanicRouter
+
+app = Sanic("MySanicApp")
+router = SanicRouter(app=app, docs_url="/docs/", openapi_version="3.0.0")
+
+
+class HelloResponse(BaseModel):
+    message: str
+
+
+@router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+async def hello(name: str):
+    """Say hello from Sanic"""
+    return HelloResponse(message=f"Hello, {name}! It's Sanic!")
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=8000, debug=True)
+
+```
+
+---
+
+### ![Starlette](https://img.shields.io/badge/-Starlette-ff4785?style=flat-square&logo=starlette&logoColor=white)
+```python
+import uvicorn
+from pydantic import BaseModel
+from starlette.applications import Starlette
+
+from fastopenapi.routers.starlette import StarletteRouter
+
+app = Starlette()
+router = StarletteRouter(app=app, docs_url="/docs/", openapi_version="3.0.0")
+
+
+class HelloResponse(BaseModel):
+    message: str
+
+
+@router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+async def hello(name: str):
+    """Say hello from Starlette"""
+    return HelloResponse(message=f"Hello, {name}! It's Starlette!")
+
+
+router.register_routes()
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)
+
+```
+
+---
+
+## 🛡️ **Type Safety with Pydantic v2**
+```python
+from pydantic import BaseModel
+
+class User(BaseModel):
+    id: int
+    name: str
+
+@router.post("/api/v1/users/")
+def create_user(user: User) -> User:
+    return user
+```
+
+---
+
+## 🧪 **Running Tests**
+```bash
+poetry run pytest
+```
+
+---
+
+## 📄 **License**
+This project is licensed under the terms of the MIT license.

fastopenapi-0.1.0/fastopenapi/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

fastopenapi-0.1.0/fastopenapi/base_router.py

@@ -0,0 +1,177 @@
+import inspect
+from collections.abc import Callable
+from typing import Any
+
+from pydantic import BaseModel
+
+SWAGGER_URL = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.20.0/"
+
+
+class BaseRouter:
+    def __init__(
+        self,
+        app: Any = None,
+        docs_url: str = "/docs/",
+        openapi_version: str = "3.0.0",
+        title: str = "My App",
+        version: str = "0.1.0",
+    ):
+        self.app = app
+        self.docs_url = docs_url
+        self.openapi_version = openapi_version
+        self.title = title
+        self.version = version
+        self._routes: list[tuple[str, str, Callable]] = []
+
+    def add_route(self, path: str, method: str, endpoint: Callable):
+        self._routes.append((path, method.upper(), endpoint))
+
+    def get_routes(self):
+        return self._routes
+
+    def include_router(self, other: "BaseRouter"):
+        self._routes.extend(other.get_routes())
+
+    def get(self, path: str, **meta):
+        def decorator(func: Callable):
+            func.__route_meta__ = meta
+            self.add_route(path, "GET", func)
+            return func
+
+        return decorator
+
+    def post(self, path: str, **meta):
+        def decorator(func: Callable):
+            func.__route_meta__ = meta
+            self.add_route(path, "POST", func)
+            return func
+
+        return decorator
+
+    def put(self, path: str, **meta):
+        def decorator(func: Callable):
+            func.__route_meta__ = meta
+            self.add_route(path, "PUT", func)
+            return func
+
+        return decorator
+
+    def patch(self, path: str, **meta):
+        def decorator(func: Callable):
+            func.__route_meta__ = meta
+            self.add_route(path, "PATCH", func)
+            return func
+
+        return decorator
+
+    def delete(self, path: str, **meta):
+        def decorator(func: Callable):
+            func.__route_meta__ = meta
+            self.add_route(path, "DELETE", func)
+            return func
+
+        return decorator
+
+    def generate_openapi(self) -> dict:
+        schema = {
+            "openapi": self.openapi_version,
+            "info": {"title": self.title, "version": self.version},
+            "paths": {},
+            "components": {"schemas": {}},
+        }
+        definitions = {}
+
+        for path, method, endpoint in self._routes:
+            operation = self._build_operation(endpoint, definitions)
+            schema["paths"].setdefault(path, {})[method.lower()] = operation
+
+        schema["components"]["schemas"].update(definitions)
+        return schema
+
+    def _build_operation(self, endpoint, definitions: dict) -> dict:
+        sig = inspect.signature(endpoint)
+        parameters = []
+        request_body = None
+
+        for param_name, param in sig.parameters.items():
+            if param.annotation is inspect.Parameter.empty:
+                continue
+
+            if isinstance(param.annotation, type) and issubclass(
+                param.annotation, BaseModel
+            ):
+                model_schema = self._get_model_schema(param.annotation, definitions)
+                request_body = {
+                    "content": {"application/json": {"schema": model_schema}},
+                    "required": True,
+                }
+            else:
+                parameters.append(
+                    {
+                        "name": param_name,
+                        "in": "query",
+                        "required": param.default is inspect.Parameter.empty,
+                        "schema": {"type": "string"},
+                    }
+                )
+
+        op = {
+            "summary": endpoint.__doc__ or "",
+            "responses": {"200": {"description": "OK"}},
+        }
+        if parameters:
+            op["parameters"] = parameters
+        if request_body:
+            op["requestBody"] = request_body
+
+        meta = getattr(endpoint, "__route_meta__", {})
+        if meta.get("tags"):
+            op["tags"] = meta["tags"]
+        if meta.get("status_code"):
+            code = str(meta["status_code"])
+            op["responses"] = {code: {"description": "OK"}}
+            response_model = meta.get("response_model")
+            if (
+                response_model
+                and isinstance(response_model, type)
+                and issubclass(response_model, BaseModel)
+            ):
+                resp_model_schema = self._get_model_schema(response_model, definitions)
+                op["responses"][code]["content"] = {
+                    "application/json": {"schema": resp_model_schema}
+                }
+        return op
+
+    @staticmethod
+    def _get_model_schema(model: type[BaseModel], definitions: dict) -> dict:
+        model_schema = model.model_json_schema(
+            ref_template="#/components/schemas/{model}"
+        )
+        for key in ("definitions", "$defs"):
+            if key in model_schema:
+                definitions.update(model_schema[key])
+                del model_schema[key]
+        return model_schema
+
+    @staticmethod
+    def render_swagger_ui(openapi_json_url: str) -> str:
+        return f"""
+        <!DOCTYPE html>
+        <html lang="en">
+          <head>
+            <meta charset="UTF-8">
+            <title>Swagger UI</title>
+            <link rel="stylesheet" href="{SWAGGER_URL}swagger-ui.css" />
+          </head>
+          <body>
+            <div id="swagger-ui"></div>
+            <script src="{SWAGGER_URL}swagger-ui-bundle.js"></script>
+            <script>
+              SwaggerUIBundle({{
+                url: '{openapi_json_url}',
+                dom_id: '#swagger-ui'
+              }});
+            </script>
+          </body>
+        </html>
+        """

fastopenapi-0.1.0/fastopenapi/routers/falcon.py

@@ -0,0 +1,84 @@
+import inspect
+import json
+
+import falcon.asgi
+from pydantic import BaseModel
+
+from fastopenapi.base_router import BaseRouter
+
+METHODS_MAPPER = {
+    "GET": "on_get",
+    "POST": "on_post",
+    "PUT": "on_put",
+    "PATCH": "on_patch",
+    "DELETE": "on_delete",
+}
+
+
+class FalconRouter(BaseRouter):
+    def __init__(
+        self,
+        app: falcon.asgi.App = None,
+        docs_url: str = "/docs/",
+        openapi_version: str = "3.0.0",
+        title: str = "My Falcon App",
+        version: str = "0.1.0",
+    ):
+        super().__init__(app, docs_url, openapi_version, title, version)
+        if self.app is not None:
+            self._register_docs_endpoints()
+
+    def add_route(self, path: str, method: str, endpoint):
+        super().add_route(path, method, endpoint)
+        if self.app is not None:
+            resource = self._create_resource(endpoint, method.upper())
+            self.app.add_route(path, resource)
+
+    def include_router(self, other: BaseRouter):
+        for path, method, endpoint in other.get_routes():
+            self.add_route(path, method, endpoint)
+
+    def _create_resource(self, endpoint, method: str):
+        class Resource:
+            async def handle(inner_self, req, resp):
+                params = dict(req.params)
+                try:
+                    body_bytes = await req.bounded_stream.read()
+                    if body_bytes:
+                        body = json.loads(body_bytes.decode("utf-8"))
+                        params.update(body)
+                except Exception:
+                    pass
+                try:
+                    if inspect.iscoroutinefunction(endpoint):
+                        result = await endpoint(**params)
+                    else:
+                        result = endpoint(**params)
+                except TypeError as exc:
+                    resp.status = falcon.HTTP_422
+                    resp.media = {"detail": str(exc)}
+                    return
+                if isinstance(result, BaseModel):
+                    result = result.model_dump()
+                resp.media = result
+
+        res = Resource()
+        setattr(res, METHODS_MAPPER[method], res.handle)
+        return res
+
+    def _register_docs_endpoints(self):
+        outer = self
+
+        class OpenAPISchemaResource:
+            async def on_get(inner_self, req, resp):
+                resp.media = outer.generate_openapi()
+
+        self.app.add_route("/openapi.json", OpenAPISchemaResource())
+
+        class SwaggerUIResource:
+            async def on_get(inner_self, req, resp):
+                html = outer.render_swagger_ui("/openapi.json")
+                resp.content_type = "text/html"
+                resp.text = html
+
+        self.app.add_route(self.docs_url, SwaggerUIResource())

fastopenapi-0.1.0/fastopenapi/routers/flask.py

@@ -0,0 +1,51 @@
+from flask import Flask, Response, jsonify, request
+from pydantic import BaseModel
+
+from fastopenapi.base_router import BaseRouter
+
+
+class FlaskRouter(BaseRouter):
+    def __init__(
+        self,
+        app: Flask = None,
+        docs_url: str = "/docs/",
+        openapi_version: str = "3.0.0",
+        title: str = "My Flask App",
+        version: str = "0.1.0",
+    ):
+        super().__init__(app, docs_url, openapi_version, title, version)
+        if self.app is not None:
+            self._register_docs_endpoints()
+
+    def add_route(self, path: str, method: str, endpoint):
+        super().add_route(path, method, endpoint)
+        if self.app is not None:
+
+            def view_func(**kwargs):
+                json_data = request.get_json(silent=True) or {}
+                params = {**request.args.to_dict(), **json_data}
+                try:
+                    result = endpoint(**params)
+                except TypeError as exc:
+                    return jsonify({"detail": str(exc)}), 422
+                if isinstance(result, BaseModel):
+                    result = result.model_dump()
+                return jsonify(result)
+
+            self.app.add_url_rule(
+                path, endpoint.__name__, view_func, methods=[method.upper()]
+            )
+
+    def include_router(self, other: BaseRouter):
+        for path, method, endpoint in other.get_routes():
+            self.add_route(path, method, endpoint)
+
+    def _register_docs_endpoints(self):
+        @self.app.route("/openapi.json", methods=["GET"])
+        def openapi_view():
+            return jsonify(self.generate_openapi())
+
+        @self.app.route(self.docs_url, methods=["GET"])
+        def docs_view():
+            html = self.render_swagger_ui("/openapi.json")
+            return Response(html, mimetype="text/html")

fastopenapi-0.1.0/fastopenapi/routers/sanic.py

@@ -0,0 +1,57 @@
+import inspect
+
+from pydantic import BaseModel
+from sanic import Sanic, response
+
+from fastopenapi.base_router import BaseRouter
+
+
+class SanicRouter(BaseRouter):
+    def __init__(
+        self,
+        app: Sanic = None,
+        docs_url: str = "/docs/",
+        openapi_version: str = "3.0.0",
+        title: str = "My Sanic App",
+        version: str = "0.1.0",
+    ):
+        super().__init__(app, docs_url, openapi_version, title, version)
+        if self.app is not None:
+            self._register_docs_endpoints()
+
+    def add_route(self, path: str, method: str, endpoint):
+        super().add_route(path, method, endpoint)
+
+        async def view_func(request, *args, **kwargs):
+            params = {
+                k: (v[0] if isinstance(v, list) else v) for k, v in request.args.items()
+            }
+            if request.json:
+                params.update(request.json)
+            try:
+                if inspect.iscoroutinefunction(endpoint):
+                    result = await endpoint(**params)
+                else:
+                    result = endpoint(**params)
+            except TypeError as exc:
+                return response.json({"detail": str(exc)}, status=422)
+            if isinstance(result, BaseModel):
+                result = result.model_dump()
+            return response.json(result)
+
+        route_name = f"{endpoint.__name__}_{method.lower()}_{path.replace('/', '_')}"
+        self.app.add_route(view_func, path, methods=[method.upper()], name=route_name)
+
+    def include_router(self, other: BaseRouter):
+        for path, method, endpoint in other.get_routes():
+            self.add_route(path, method, endpoint)
+
+    def _register_docs_endpoints(self):
+        @self.app.route("/openapi.json", methods=["GET"])
+        async def openapi_view(request):
+            return response.json(self.generate_openapi())
+
+        @self.app.route(self.docs_url, methods=["GET"])
+        async def docs_view(request):
+            html = self.render_swagger_ui("/openapi.json")
+            return response.html(html)

fastopenapi-0.1.0/fastopenapi/routers/starlette.py

@@ -0,0 +1,71 @@
+import inspect
+import json
+
+from pydantic import BaseModel
+from starlette.applications import Starlette
+from starlette.responses import HTMLResponse, JSONResponse
+from starlette.routing import Route
+
+from fastopenapi.base_router import BaseRouter
+
+
+class StarletteRouter(BaseRouter):
+    def __init__(
+        self,
+        app: Starlette = None,
+        docs_url: str = "/docs/",
+        openapi_version: str = "3.0.0",
+        title: str = "My Starlette App",
+        version: str = "0.1.0",
+    ):
+        super().__init__(app, docs_url, openapi_version, title, version)
+        self._routes_starlette = []
+        if self.app is not None:
+            self._register_docs_endpoints()
+
+    def add_route(self, path: str, method: str, endpoint):
+        super().add_route(path, method, endpoint)
+        if self.app is not None:
+
+            async def view(request):
+                params = dict(request.query_params)
+                try:
+                    body = await request.body()
+                    if body:
+                        json_body = json.loads(body.decode("utf-8"))
+                        params.update(json_body)
+                except Exception:
+                    pass
+                try:
+                    if inspect.iscoroutinefunction(endpoint):
+                        result = await endpoint(**params)
+                    else:
+                        result = endpoint(**params)
+                except TypeError as exc:
+                    return JSONResponse({"detail": str(exc)}, status_code=422)
+                if isinstance(result, BaseModel):
+                    result = result.model_dump()
+                return JSONResponse(result)
+
+            self._routes_starlette.append(Route(path, view, methods=[method.upper()]))
+
+    def include_router(self, other: BaseRouter):
+        for path, method, endpoint in other.get_routes():
+            self.add_route(path, method, endpoint)
+
+    def register_routes(self):
+        if self.app is not None:
+            self.app.router.routes.extend(self._routes_starlette)
+
+    def _register_docs_endpoints(self):
+        async def openapi_view(request):
+            return JSONResponse(self.generate_openapi())
+
+        async def docs_view(request):
+            html = self.render_swagger_ui("/openapi.json")
+            return HTMLResponse(html)
+
+        self.app.router.routes.append(
+            Route("/openapi.json", openapi_view, methods=["GET"])
+        )
+        self.app.router.routes.append(Route(self.docs_url, docs_view, methods=["GET"]))

fastopenapi-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "fastopenapi"
+version = "0.1.0"
+description = "A library for generating and integrating OpenAPI schemas using Pydantic v2."
+authors = [
+    {name = "Nikita Ryzhenkov", email = "nikita.ryzhenkoff@gmail.com"}
+]
+license = {text = "MIT License"}
+readme = "README.md"
+requires-python = ">=3.10"
+keywords = ["FastOpenAPI", "OpenAPI", "Pydantic", "API", "Python", "Flask", "Falcon", "Sanic", "Starlette"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Code Generators",
+]
+
+dependencies = [
+    "pydantic (>=2.10.6,<3.0.0)"
+]
+
+[project.optional-dependencies]
+falcon = ["falcon (>=4.0.2,<5.0.0)"]
+flask = ["flask (>=3.1.0,<4.0.0)"]
+sanic = ["sanic (>=24.12.0,<25.0.0)"]
+starlette = ["starlette (>=0.46.0,<0.47.0)"]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.group.dev.dependencies]
+mypy = "^1.15.0"
+flake8 = "^7.1.2"
+autoflake = "^2.3.1"
+isort = "^6.0.1"
+black = "^25.1.0"
+pre-commit = "^4.1.0"
+pyupgrade = "^3.19.1"
+pytest = "^8.3.4"
+anyio = "^4.8.0"
+sanic-testing = "^24.6.0"
+trio = "^0.29.0"
+pytest-anyio = "^0.0.0"
+pytest-asyncio = "^0.25.3"
+coverage = "^7.6.12"