fastopenapi

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

(★ 511)

FastOpenAPI is a library for generating and integrating OpenAPI schemas using Pydantic v2 and various frameworks (AioHttp, Django, Falcon, Flask, Quart, Sanic, Starlette, Tornado).

fastopenapi 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

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

This project was inspired by <a href="https://fastapi.tiangolo.com/">FastAPI</a> and aims to provide a similar developer-friendly experience.

---

## 📦 Installation
#### Install only FastOpenAPI:
```bash
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
pip install fastopenapi[starlette]
```
```bash
pip install fastopenapi[tornado]
```
```bash
pip install fastopenapi[django]
```

---

## 🛠️ Quick Start

### Step 1. Create an application

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

#### Examples:

- ![AIOHTTP](https://img.shields.io/badge/AioHttp-0078D7?style=flat&logo=python&logoColor=white)
 <details>
 <summary>Click to expand the AioHTTP 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>
 
 ```python
 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()
 ```
 </details>
 <details>
 <summary>Click to expand the Falcon Async Example</summary>
 
 ```python
 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)
 ```
 </details>

- ![Flask](https://img.shields.io/badge/-Flask-EEEEEE?style=flat&logo=flask&logoColor=black)
 <details>
 <summary>Click to expand the Flask Example</summary>
 
 ```python
 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)
 ```
 </details>

- ![Quart](https://img.shields.io/badge/-Quart-4997D0?style=flat&logo=python&logoColor=white)
 <details>
 <summary>Click to expand the Quart Example</summary>
 
 ```python
 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)
 ```
 </details>

- ![Sanic](https://img.shields.io/badge/-Sanic-00bfff?style=flat&logo=sanic&logoColor=white)
 <details>
 <summary>Click to expand the Sanic Example</summary>
 
 ```python
 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)
 ```
 </details>

- ![Starlette](https://img.shields.io/badge/-Starlette-4B0082?style=flat&logo=python&logoColor=white)
 <details>
 <summary>Click to expand the Starlette Example</summary>
 
 ```python
 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)
 ```
 </details>

- ![Tornado](https://img.shields.io/badge/-Tornado-2980B9?style=flat&logo=python&logoColor=white)
 <details>
 <summary>Click to expand the Tornado Example</summary>
 
 ```python
 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())
 ```
 </details>

- ![Django](https://img.shields.io/badge/-Django-092E20?style=flat&logo=django&logoColor=white)
 <details>
 <summary>Click to expand the Django Example</summary>

```python
    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")

```
 </details>

### Step 2. Run the server

Launch the application:

```bash
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
```

---

## ⚙️ Features
- **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**

---

## 📖 Documentation

Explore the [Docs](https://fastopenapi.fatalyst.dev/) for an overview of FastOpenAPI, its core components, and usage guidelines. The documentation is continuously updated and improved.

---

## 📂 Advanced Examples

Examples of integration and detailed usage for each framework are available in the [`examples`](https://github.com/mr-fatalyst/fastopenapi/tree/master/examples) directory.

---

## 📊 Quick & Dirty Benchmarks

Fast but not perfect benchmarks. Check the [`benchmarks`](https://github.com/mr-fatalyst/fastopenapi/tree/master/benchmarks) directory for details.

---

## ✅ Development Recommendations

- 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.

---

## 🛠️ Contributing

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

---

## 🤝 Acknowledgements

<a href="https://www.jetbrains.com/">
 <img src="https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.png" alt="JetBrains logo" width="120" style="background:white; padding:10px;"/>
 </a>


 
 Supported by <a href="https://www.jetbrains.com/">JetBrains</a> under the
 <a href="https://www.jetbrains.com/community/opensource/#support">Open Source Support Program</a>.

---

## 📄 **License**
This project is licensed under the terms of the MIT license.

fastopenapi

fastopenapi 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

fastopenapi

fastopenapi 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README