mr-fatalyst/fastopenapi: FastOpenAPI is a library for generating and integrating OpenAPI schemas using Pydantic v2 and various frameworks (AioHttp, Django, Falcon, Flask, Quart, Sanic, Starlette, Tornado). · GitHub

FastOpenAPI is a library for generating and integrating OpenAPI schemas using Pydantic and various frameworks.

This project was inspired by FastAPI and aims to provide a similar developer-friendly experience.

pip install fastopenapi

pip install fastopenapi[aiohttp]

pip install fastopenapi[falcon]

pip install fastopenapi[flask]

pip install fastopenapi[quart]

pip install fastopenapi[sanic]

pip install fastopenapi[starlette]

pip install fastopenapi[tornado]

pip install fastopenapi[django]

• Create the main.py file
• Copy the code from an example
• For some examples uvicorn is required (pip install uvicorn)

• 

  Click to expand the AioHTTP Example

  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)

• 

  Click to expand the Falcon Example

  from falcon import App
  from pydantic import BaseModel
  from wsgiref.simple_server import make_server
  
  from fastopenapi.routers import FalconRouter
  
  app = App()
  router = FalconRouter(app=app)
  
  
  class HelloResponse(BaseModel):
      message: str
  
  
  @router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
  def hello(name: str):
      """Say hello from Falcon"""
      return HelloResponse(message=f"Hello, {name}! It's Falcon!")
  
  
  if __name__ == "__main__":
      with make_server("", 8000, app) as httpd:
          print("Serving on port 8000...")
          httpd.serve_forever()

  Click to expand the Falcon Async Example

  import falcon.asgi
  import uvicorn
  from pydantic import BaseModel
  
  from fastopenapi.routers import FalconAsyncRouter
  
  app = falcon.asgi.App()
  router = FalconAsyncRouter(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 Falcon"""
      return HelloResponse(message=f"Hello, {name}! It's Falcon!")
  
  
  if __name__ == "__main__":
      uvicorn.run(app, host="127.0.0.1", port=8000)

• 

  Click to expand the Flask Example

  from flask import Flask
  from pydantic import BaseModel
  
  from fastopenapi.routers import FlaskRouter
  
  app = Flask(__name__)
  router = FlaskRouter(app=app)
  
  
  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(port=8000)

• 

  Click to expand the Quart Example

  from pydantic import BaseModel
  from quart import Quart
  
  from fastopenapi.routers import QuartRouter
  
  app = Quart(__name__)
  router = QuartRouter(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 Quart"""
      return HelloResponse(message=f"Hello, {name}! It's Quart!")
  
  
  if __name__ == "__main__":
      app.run(port=8000)

• 

  Click to expand the Sanic Example

  from pydantic import BaseModel
  from sanic import Sanic
  
  from fastopenapi.routers import SanicRouter
  
  app = Sanic("MySanicApp")
  router = SanicRouter(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 Sanic"""
      return HelloResponse(message=f"Hello, {name}! It's Sanic!")
  
  
  if __name__ == "__main__":
      app.run(host="0.0.0.0", port=8000)

• 

  Click to expand the Starlette Example

  import uvicorn
  from pydantic import BaseModel
  from starlette.applications import Starlette
  
  from fastopenapi.routers import StarletteRouter
  
  app = Starlette()
  router = StarletteRouter(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 Starlette"""
      return HelloResponse(message=f"Hello, {name}! It's Starlette!")
  
  if __name__ == "__main__":
      uvicorn.run(app, host="127.0.0.1", port=8000)

• 

  Click to expand the Tornado Example

  import asyncio
  
  from pydantic import BaseModel
  from tornado.web import Application
  
  from fastopenapi.routers import TornadoRouter
  
  app = Application()
  
  router = TornadoRouter(app=app)
  
  
  class HelloResponse(BaseModel):
      message: str
  
  
  @router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
  def hello(name: str):
      """Say hello from Tornado"""
      return HelloResponse(message=f"Hello, {name}! It's Tornado!")
  
  
  async def main():
      app.listen(8000)
      await asyncio.Event().wait()
  
  
  if __name__ == "__main__":
      asyncio.run(main())

• 

  Click to expand the Django Example

  from django.conf import settings
  from django.core.management import call_command
  from django.core.wsgi import get_wsgi_application
  from django.urls import path
  from pydantic import BaseModel
  
  from fastopenapi.routers import DjangoRouter
  
  settings.configure(DEBUG=True, SECRET_KEY="__CHANGEME__", ROOT_URLCONF=__name__)
  application = get_wsgi_application()
  
  router = DjangoRouter(app=True)
  
  
  class HelloResponse(BaseModel):
      message: str
  
  
  @router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
  def hello(name: str):
      """Say hello from django"""
      return HelloResponse(message=f"Hello, {name}! It's Django!")
  
  
  urlpatterns = [path("", router.urls)]
  
  if __name__ == "__main__":
      call_command("runserver")

Launch the application:

python main.py

Once launched, the documentation will be available at:

Swagger UI:

http://127.0.0.1:8000/docs

ReDoc UI:

http://127.0.0.1:8000/redoc

• Generate OpenAPI schemas with Pydantic v2.
• Data validation using Pydantic models.
• Supports multiple frameworks: AIOHTTP, Falcon, Flask, Quart, Sanic, Starlette, Tornado, Django.
• Proxy routing provides FastAPI-style routing

Explore the Docs for an overview of FastOpenAPI, its core components, and usage guidelines. The documentation is continuously updated and improved.

Examples of integration and detailed usage for each framework are available in the examples directory.

Fast but not perfect benchmarks. Check the benchmarks directory for details.

• Use Pydantic models for strict typing and data validation.
• Follow the project structure similar to provided examples for easy scalability.
• Regularly update dependencies and monitor library updates for new features.

If you have suggestions or find a bug, please open an issue or create a pull request on GitHub.

Supported by JetBrains under the Open Source Support Program.

This project is licensed under the terms of the MIT license.