Generate Class & Decorators for your FastAPI project
Project description
Fastapi-Class 🦜
Source Code: https://github.com/yezz123/fastapi-class
Install the project: pip install fastapi-class
Classes and Decorators to use FastAPI with class based routing
. In particular this allows you to
construct an instance of a class and have methods of that instance be route handlers for FastAPI & Python 3.8.
- Older Versions of Python:
- Unfortunately this does not work with
async
routes with Python versions less than 3.8 due to bugs ininspect.iscoroutinefunction
. Specifically with older versions of Pythoniscoroutinefunction
incorrectly returns false soasync
routes aren'tawait
'd. We therefore only support Python versions >= 3.8.
- Unfortunately this does not work with
Example 🐢
from ping import pong
# Some fictional ping pong class
from fastapi_class import Routable, get, delete
def parse_arg() -> argparse.Namespace:
"""parse command line arguments."""
...
class UserRoutes(Routable):
"""Inherits from Routable."""
# Note injection here by simply passing values to the constructor. Other injection frameworks also
# supported as there's nothing special about this __init__ method.
def __init__(self, pong: pong) -> None:
"""Constructor. The pong is injected here."""
self.__pong = pong
@get('/user/{name}')
def get_user_by_name(name: str) -> User:
# Use our injected pong instance.
return self.__pong.get_user_by_name(name)
@delete('/user/{name}')
def delete_user(name: str) -> None:
self.__pong.delete(name)
def main():
args = parse_args()
# Configure the pomg per command line arguments
pong = pong(args.url, args.user, args.password)
# Simple intuitive injection
user_routes = UserRoutes(pong)
app = FastAPI()
# router member inherited from Routable and configured per the annotations.
app.include_router(user_routes.router)
Why 🐣
FastAPI generally has one define routes like:
app = FastAPI()
@app.get('/echo/{x}')
def echo(x: int) -> int:
return x
Note: that app
is a global. Furthermore, FastAPI's suggested way of doing dependency injection is handy for things like pulling values out of header in the HTTP request. However, they don't work well for more standard dependency injection scenarios where we'd like to do something like inject a Data Access Object or database connection. For that, FastAPI suggests their parameterized dependencies which might look something like:
app = FastAPI()
class ValueToInject:
def __init__(self, y: int) -> None:
self.y = y
def __call__(self) -> int:
return self.y
to_add = ValueToInject(2)
@app.get('/add/{x}')
def add(x: int, y: Depends(to_add)) -> int:
return x + y
Development 🚧
You should create a virtual environment and activate it:
python -m venv venv/
source venv/bin/activate
And then install the development dependencies:
pip install -r requirements.dev.txt
Format the code 💅
Execute the following command to apply pre-commit
formatting:
make lint
License 🍻
This project is licensed under the terms of the MIT license.
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for fastapi_class-1.0.0-py3-none-any.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 7a8be575199efb27e45f39ec858e72e2dc207892948b465efe3a688bdc669654 |
|
MD5 | 44dbf0435e37fcca89351e07e9e48af3 |
|
BLAKE2b-256 | 60be7f296995e06c45f5136bf43eac83c5c06f751794907e0fe619b0d7a2997c |