Opinionated set of utilities on top of FastAPI

Overview

FastAPI Contrib

Documentation Status Updates

Opinionated set of utilities on top of FastAPI

Features

  • Auth Backend & Middleware (User or None in every request object)
  • Permissions: reusable class permissions, specify multiple as FastAPI Dependency
  • ModelSerializers: serialize (pydantic) incoming request, connect data with DB model and save
  • UJSONResponse: correctly show slashes in fields with URLs
  • Limit-Offset Pagination: use it as FastAPI Dependency (works only with ModelSerializers for now)
  • MongoDB integration: Use models as if it was Django (based on pydantic models)
  • MongoDB indices verification on startup of the app
  • Custom Exceptions and Custom Exception Handlers
  • Opentracing middleware & setup utility with Jaeger tracer + root span available in every Request's state
  • StateRequestIDMiddleware: receives configurable header and saves it in request state

Roadmap

See GitHub Project Roadmap.

Installation

To install just Contrib (without mongodb, pytz, ujson):

$ pip install fastapi_contrib

To install contrib with mongodb support:

$ pip install fastapi_contrib[mongo]

To install contrib with ujson support:

$ pip install fastapi_contrib[ujson]

To install contrib with pytz support:

$ pip install fastapi_contrib[pytz]

To install contrib with opentracing & Jaeger tracer:

$ pip install fastapi_contrib[jaegertracing]

To install everything:

$ pip install fastapi_contrib[all]

Usage

To use Limit-Offset pagination:

from fastapi import FastAPI
from fastapi_contrib.pagination import Pagination
from fastapi_contrib.serializers.common import ModelSerializer
from yourapp.models import SomeModel

app = FastAPI()

class SomeSerializer(ModelSerializer):
    class Meta:
        model = SomeModel

@app.get("/")
async def list(pagination: Pagination = Depends()):
    filter_kwargs = {}
    return await pagination.paginate(
        serializer_class=SomeSerializer, **filter_kwargs
    )

Subclass this pagination to define custom default & maximum values for offset & limit:

class CustomPagination(Pagination):
    default_offset = 90
    default_limit = 1
    max_offset = 100
    max_limit = 2000

To use State Request ID Middleware:

from fastapi import FastAPI
from fastapi_contrib.common.middlewares import StateRequestIDMiddleware

app = FastAPI()

@app.on_event('startup')
async def startup():
    app.add_middleware(StateRequestIDMiddleware)

To use Authentication Middleware:

from fastapi import FastAPI
from fastapi_contrib.auth.backends import AuthBackend
from fastapi_contrib.auth.middlewares import AuthenticationMiddleware

app = FastAPI()

@app.on_event('startup')
async def startup():
    app.add_middleware(AuthenticationMiddleware, backend=AuthBackend())

Define & use custom permissions based on FastAPI Dependency framework:

from fastapi import FastAPI
from fastapi_contrib.permissions import BasePermission, PermissionsDependency

class TeapotUserAgentPermission(BasePermission):

    def has_required_permissions(self, request: Request) -> bool:
        return request.headers.get('User-Agent') == "Teapot v1.0"

app = FastAPI()

@app.get(
    "/teapot/",
    dependencies=[Depends(
        PermissionsDependency([TeapotUserAgentPermission]))]
)
async def teapot() -> dict:
    return {"teapot": True}

Setup uniform exception-handling:

from fastapi import FastAPI
from fastapi_contrib.exception_handlers import setup_exception_handlers

app = FastAPI()

@app.on_event('startup')
async def startup():
    setup_exception_handlers(app)

If you want to correctly handle scenario when request is an empty body (IMPORTANT: non-multipart):

from fastapi import FastAPI
from fastapi_contrib.routes import ValidationErrorLoggingRoute

app = FastAPI()
app.router.route_class = ValidationErrorLoggingRoute

Or if you use multiple routes for handling different namespaces (IMPORTANT: non-multipart):

from fastapi import APIRouter, FastAPI
from fastapi_contrib.routes import ValidationErrorLoggingRoute

app = FastAPI()

my_router = APIRouter(route_class=ValidationErrorLoggingRoute)

To correctly show slashes in fields with URLs + ascii locking:

from fastapi import FastAPI
from fastapi_contrib.common.responses import UJSONResponse

app = FastAPI()

@app.get("/", response_class=UJSONResponse)
async def root():
    return {"a": "b"}

Or specify it as default response class for the whole app (FastAPI >= 0.39.0):

from fastapi import FastAPI
from fastapi_contrib.common.responses import UJSONResponse

app = FastAPI(default_response_class=UJSONResponse)

To setup Jaeger tracer and enable Middleware that captures every request in opentracing span:

from fastapi import FastAPI
from fastapi_contrib.tracing.middlewares import OpentracingMiddleware
from fastapi_contrib.tracing.utils import setup_opentracing

app = FastAPI()

@app.on_event('startup')
async def startup():
    setup_opentracing(app)
    app.add_middleware(OpentracingMiddleware)

To setup mongodb connection at startup and never worry about it again:

from fastapi import FastAPI
from fastapi_contrib.db.utils import setup_mongodb

app = FastAPI()

@app.on_event('startup')
async def startup():
    setup_mongodb(app)

Use models to map data to MongoDB:

from fastapi_contrib.db.models import MongoDBModel

class MyModel(MongoDBModel):
    additional_field1: str
    optional_field2: int = 42

    class Meta:
        collection = "mymodel_collection"


mymodel = MyModel(additional_field1="value")
mymodel.save()

assert mymodel.additional_field1 == "value"
assert mymodel.optional_field2 == 42
assert isinstance(mymodel.id, int)

Or use TimeStamped model with creation datetime:

from fastapi_contrib.db.models import MongoDBTimeStampedModel

class MyTimeStampedModel(MongoDBTimeStampedModel):

    class Meta:
        collection = "timestamped_collection"


mymodel = MyTimeStampedModel()
mymodel.save()

assert isinstance(mymodel.id, int)
assert isinstance(mymodel.created, datetime)

Use serializers and their response models to correctly show Schemas and convert from JSON/dict to models and back:

from fastapi import FastAPI
from fastapi_contrib.db.models import MongoDBModel
from fastapi_contrib.serializers import openapi
from fastapi_contrib.serializers.common import Serializer

from yourapp.models import SomeModel

app = FastAPI()


class SomeModel(MongoDBModel):
    field1: str


@openapi.patch
class SomeSerializer(Serializer):
    read_only1: str = "const"
    write_only2: int
    not_visible: str = "42"

    class Meta:
        model = SomeModel
        exclude = {"not_visible"}
        write_only_fields = {"write_only2"}
        read_only_fields = {"read_only1"}


@app.get("/", response_model=SomeSerializer.response_model)
async def root(serializer: SomeSerializer):
    model_instance = await serializer.save()
    return model_instance.dict()

POST-ing to this route following JSON:

{"read_only1": "a", "write_only2": 123, "field1": "b"}

Should return following response:

{"id": 1, "field1": "b", "read_only1": "const"}

Auto-creation of MongoDB indexes

Suppose we have this directory structure:

-- project_root/
     -- apps/
          -- app1/
               -- models.py (with MongoDBModel inside with indices declared)
          -- app2/
               -- models.py (with MongoDBModel inside with indices declared)

Based on this, your name of the folder with all the apps would be "apps". This is the default name for fastapi_contrib package to pick up your structure automatically. You can change that by setting ENV variable CONTRIB_APPS_FOLDER_NAME (by the way, all the setting of this package are overridable via ENV vars with CONTRIB_ prefix before them).

You also need to tell fastapi_contrib which apps to look into for your models. This is controlled by CONTRIB_APPS ENV variable, which is list of str names of the apps with models. In the example above, this would be CONTRIB_APPS=["app1","app2"].

Just use create_indexes function after setting up mongodb:

from fastapi import FastAPI
from fastapi_contrib.db.utils import setup_mongodb, create_indexes

app = FastAPI()

@app.on_event("startup")
async def startup():
    setup_mongodb(app)
    await create_indexes()

This will scan all the specified CONTRIB_APPS in the CONTRIB_APPS_FOLDER_NAME for models, that are subclassed from either MongoDBModel or MongoDBTimeStampedModel and create indices for any of them that has Meta class with indexes attribute:

models.py:

import pymongo
from fastapi_contrib.db.models import MongoDBTimeStampedModel


class MyModel(MongoDBTimeStampedModel):

    class Meta:
        collection = "mymodel"
        indexes = [
            pymongo.IndexModel(...),
            pymongo.IndexModel(...),
        ]

This would not create duplicate indices because it relies on pymongo and motor to do all the job.

Credits

This package was created with Cookiecutter and the audreyr/cookiecutter-pypackage project template.

Comments
  • Passing extra arguments to MongoDBModel.list()

    Passing extra arguments to MongoDBModel.list()

    • FastAPI Contrib version: 0.1.14
    • FastAPI version: 0.42
    • Python version: 3.7.4
    • Operating System: Debian 10

    Description

    Hi, I am trying to get a list of entries from a collection sorted in descending order according to a recorded date (not a creation timestamp, I am not using the timestamped model). Pymongo sort should work passing a sort=[(key, value)] argument, but when I do that, I get back an empty list. Am I doing anything wrong?

    What I Did

    This is my function. The field transmit_time is a MongoDB date field.

    @router.get("/")
    async def get_packets(limit: int = 100, offset: int = 0):
        sort_desc = [('transmit_time', -1)]
        packets = await Packet.list(_limit=limit, _offset=offset, sort=sort_desc)
        return packets
    
    question 
    opened by dasv 5
  • consider using configurator for settings store

    consider using configurator for settings store

    Reading https://github.com/identixone/fastapi_contrib/blob/master/fastapi_contrib/conf.py#L73 - you may find https://configurator.readthedocs.io/en/latest/ to be of interest.

    In particular https://configurator.readthedocs.io/en/latest/patterns.html#global-configuration-object.

    If you have any questions, please ping me on here :-)

    enhancement 
    opened by cjw296 4
  • has_required_permisions typo or bypass of naming conflict?

    has_required_permisions typo or bypass of naming conflict?

    • FastAPI Contrib version: 0.2.8
    • FastAPI version: 0.61.1
    • Python version: 3.8
    • Operating System: Ubuntu 20.04

    has_required_permisions method from BasePermission class should be has_required_permissions, is it a typo or is it a trick to bypass a naming conflict?

    bug 
    opened by rsommerard 3
  • How to save data in Mongo?

    How to save data in Mongo?

    • FastAPI Contrib version: 0.2.7
    • FastAPI version: 0.59.0
    • Python version: 3.7.7
    • Operating System: MacOS

    Description

    Hello. I was looking for tools with what will be possible to play FastAPI with MongoDB in nice, simple way, because I never before using NoSQL. I found FastAPI_Contrib, my attention takes especially two of features:

    1. ModelSerializers: serialize (pydantic) incoming request, connect data with DB model and save

    2. MongoDB integration: Use models as if it was Django (based on pydantic models)

    I was trying all day to understand the documentation how to use FastAPI_Contrib, unfortunately documentation is so hard for entry-level users. What I want to achieve at this time is nothing more than just:

    1. Create Model
    2. Create Serializer
    3. Send the request with data from for example Postman
    4. Save that data in MongoDB

    Just a first step of CRUD...

    What I Did

    I was trying take it in very different ways, but for this issue I will present the most simply way based on documentation...

    Project Structure:
    project/
    - project/
    -- sample/
    --- __init__.py
    --- serializers.py
    - __init__.py
    - main.py
    

    project/main.py:

    import os
    
    from fastapi_contrib.db.utils import setup_mongodb, create_indexes
    import motor.motor_asyncio
    from fastapi import FastAPI
    from dotenv import load_dotenv
    
    from project.serializers import sample_router
    
    load_dotenv(verbose=True)
    DATABASE_URL =os.getenv("DB_URL")
    
    SECRET = os.getenv("SECRET")
    
    CONTRIB_APPS = os.getenv("CONTRIB_APPS")
    CONTRIB_APPS_FOLDER_NAME = os.getenv("CONTRIB_APPS_FOLDER_NAME")
    
    client = motor.motor_asyncio.AsyncIOMotorClient(
        DATABASE_URL, uuidRepresentation="standard"
    )
    db = client["sample"]
    
    app = FastAPI()
    
    @app.on_event("startup")
    async def startup():
        setup_mongodb(db)
        await create_indexes()
        print('Is it connected to DB?')
    
    app.include_router(sample_router)
    

    project/sample/serializers.py

    from fastapi import APIRouter
    from fastapi_contrib.db.models import MongoDBModel
    from fastapi_contrib.serializers import openapi
    from fastapi_contrib.serializers.common import Serializer
    
    # from yourapp.models import SomeModel
    
    sample_router = APIRouter()
    
    
    class SomeModel(MongoDBModel):
        field1: str
    
        class Meta:
            collection = "test"
    
    
    @openapi.patch
    class SomeSerializer(Serializer):
        read_only1: str = "const"
        write_only2: int
        not_visible: str = "42"
    
        class Meta:
            model = SomeModel
            exclude = {"not_visible"}
            write_only_fields = {"write_only2"}
            read_only_fields = {"read_only1"}
    
    
    @sample_router.post("/test/", response_model=SomeSerializer.response_model)
    async def root(serializer: SomeSerializer):
        model_instance = await serializer.save()
        return model_instance.dict()
    

    When I send data as POST to /test/ from postman

    {
      "write_only2": 2,
      "field1": "string"
    }
    

    or by curl

    curl -X POST "http://127.0.0.1:8000/test/" -H  "accept: application/json" -H  "Content-Type: application/json" -d "{\"id\":0,\"field1\":\"string\",\"write_only2\":0}"
    

    Then I got errors: Screenshot 1

    if I will remove:

        class Meta:
            collection = "test"
    

    as it in an example in documentation then I got other error: Screenshot 2

    I will be grateful if someone will explain to me using simple examples how to properly combine models, serializers, and perform CRUD operations on them reflected in MongoDB.

    By the way. I think is it good idea to rewrite documentation to be more affordable to not so advenced users. And add to them a tutorial, awesome will be to see there real world examples. I think, good documentation can make this package a very popular.

    Regards, Oskar

    opened by oskar-gmerek 3
  • Issue with  updating a document

    Issue with updating a document

    Hi, I am having trouble to update a document.
    My model:

    class MyModel(MongoDBTimeStampedModel):
        id: UUID
        other: str
    

    Usage:

    MyModel.update_one(
         {'id': UUID(id)},
         update={
                '$set': { 'other' : 'something'}
            }
    )
    

    Is it a bug in passing kwargs to await collection.update_one( filter_kwargs, kwargs, session=session ) should not it be await collection.update_one( filter_kwargs, **kwargs, session=session ) or am I getting something wrong? Ref: Source code

    question 
    opened by mariamgarchagudashvili 3
  • Firestore DB Support

    Firestore DB Support

    Hi,

    This library looks fantastic and I'm going to try and use it for the easy mongodb integration with FastAPI. What I would be interested in (and may look to contribute myself) is a FirestoreClient (GCP's serverless document db) that could work as a drop in replacement for the mongodb client as I'm seeking to support both in a project i'm working on. I can see the intention of your design is to provide a nice abstraction to the DB technology, this use case would put that to the test with a second implementation.

    enhancement help wanted 
    opened by SamuelBradley 3
  • Allow overriding settings from fastAPI app

    Allow overriding settings from fastAPI app

    • FastAPI Contrib version: 0.2.9
    • FastAPI version: 0.52.0
    • Python version: 3.8.2
    • Operating System: Linux

    Description

    Currently we can only override settings with settings from the fastAPI app by using environment variables (See the Todo). Can we implement this functionaility, so we do not have to go through the environment variables?

    opened by pheanex 2
  • Why is the version of FastAPI fixed in the install_requires?

    Why is the version of FastAPI fixed in the install_requires?

    Currently fastapi/pydantic versions are fixed in setup.py:

    requirements = [
        'fastapi==0.52.0',
        'pydantic==1.4',
        'contextvars;python_version<"3.7"'
    ]
    

    Is there a reason not to use >= instead?

    If compatibility is a concern, it's possible to test against different versions of FastAPI on TravisCI.

    enhancement help wanted good first issue 
    opened by gukoff 2
  • Minor error in README code sample of  limit-offset pagination

    Minor error in README code sample of limit-offset pagination

    Description

    Sample taken from: https://github.com/identixone/fastapi_contrib#usage

    class CustomPagination(Pagination):
        default_offset = 90
        default_limit = 1
        max_offset = 100`
        max_limit = 2000
    

    In the above code, notice there's one extra character after max_offset = 100

    What I Did

    Paste the command(s) you ran and the output.
    If there was a crash, please include the traceback here.
    
        max_offset = 100`
                        ^
    SyntaxError: invalid syntax
    
    opened by Haider8 2
  • Add Support for FastAPI latest version

    Add Support for FastAPI latest version

    • FastAPI Contrib version:
    • FastAPI version: 0.45.0
    • Python version: 3.7
    • Operating System: Linux

    Description

    pipenv.exceptions.ResolutionFailure: ERROR: ERROR: Could not find a version that matches fastapi==0.42.0,==0.45.0

    What I Did

    Trying to use lib with FastAPI 0.45.0 and up
    
    enhancement help wanted 
    opened by vveliev-tc 2
  • Bug with List of response_models taken from Serializer

    Bug with List of response_models taken from Serializer

    Description

    When trying to use List of generated response_model model as response_model in route, you get in response

    {
      "code": 400,
      "detail": "Validation error",
      "fields": [
        {
          "name": "response",
          "message": "Value is not a valid list"
        }
      ]
    }
    

    What I Did

    from typing import List
    from fastapi import APIRouter, Depends
    
    from fastapi_contrib.pagination import Pagination
    from fastapi_contrib.serializers import openapi
    from fastapi_contrib.serializers.common import Serializer
    
    
    @openapi.patch
    class MySerializer(Serializer):
        ...
    
    
    router = APIRouter()
    
    
    @router.get("/", response_model=List[MySerializer.response_model])
    async def lst(pagination: Pagination = Depends()):
        return await pagination.paginate(MySerializer)
    
    bug help wanted good first issue 
    opened by levchik 2
  • How to mock or override PermissionsDependency

    How to mock or override PermissionsDependency

    • FastAPI Contrib version: Latest
    • FastAPI version: Latest
    • Python version: 3.9.7
    • Operating System: Mac Os

    Description

    Hello guys I need help with testing PermissionsDependency.

    What I Did

    My current code is :

    api_router.include_router(
        article_deviation.router,
        prefix="{Confidential information}",
        tags=["{confidential information}"],
        dependencies=[
            Depends(azure_scheme),
            Depends(PermissionsDependency([QCPermission])),
        ],
    )
    

    In the test I override azure_scheme as :

    
    api_client = TestClient(app)
    app.dependency_overrides[azure_scheme] = {"Authorized": "Yes"}
    
    

    but with

    
    api_client = TestClient(app)
    app.dependency_overrides[PermissionsDependency([QCPermission])] = True
    
    

    It does not work.

    Thank you in advance! Wish you all best!

    opened by kristiqntashev 0
  • Pin ujson to latest version 5.4.0

    Pin ujson to latest version 5.4.0

    This PR pins ujson to the latest release 5.4.0.

    The bot wasn't able to find a changelog for this release. Got an idea?

    Links
    • PyPI: https://pypi.org/project/ujson
    • Repo: https://github.com/ultrajson/ultrajson
    opened by pyup-bot 0
  • ModuleNotFoundError: No module named 'fastapi_contrib'

    ModuleNotFoundError: No module named 'fastapi_contrib'

    • FastAPI Contrib version: 0.2.11
    • FastAPI version: 0.78.0
    • Python version: 3.8.13
    • Operating System: mac

    Description

    I cloned fastapi project which uses fastapi-contrib library.

    and then i installed fastapi-contrib with $ pip install fastapi_contrib.

    but ModuleNotFoundError: No module named 'fastapi_contrib' was logged repeatly. 😅

    Thank you for your busy schedule. 🙏🏼

    What I Did

    • Pycharm turned off and on.
    • $ pip install fastapi_contrib[all] (but it says zsh: no matches found: fastapi_contrib[all])
    opened by seongkyu-lim 0
  • Pin ujson to latest version 5.2.0

    Pin ujson to latest version 5.2.0

    This PR pins ujson to the latest release 5.2.0.

    The bot wasn't able to find a changelog for this release. Got an idea?

    Links
    • PyPI: https://pypi.org/project/ujson
    • Repo: https://github.com/ultrajson/ultrajson
    opened by pyup-bot 0
  • Update pytz to 2022.1

    Update pytz to 2022.1

    This PR updates pytz from 2019.3 to 2022.1.

    The bot wasn't able to find a changelog for this release. Got an idea?

    Links
    • PyPI: https://pypi.org/project/pytz
    • Homepage: http://pythonhosted.org/pytz
    • Docs: https://pythonhosted.org/pytz/
    opened by pyup-bot 0
Releases(v0.2.11)
  • v0.2.11(Jun 3, 2021)

  • v0.2.10(Mar 1, 2021)

    • Dropped Python 3.6 support
    • Added Python 3.9 support
    • FastAPI is updated to the latest version in requirements
    • Fixed serializer base class bug because of latest pydantic update (1.8)
    Source code(tar.gz)
    Source code(zip)
Owner
identix.one
The first worldwide ready-to-use facial recognition cloud platform
identix.one
Fastapi-ml-template - Fastapi ml template with python

FastAPI ML Template Run Web API Local $ sh run.sh # poetry run uvicorn app.mai

Yuki Okuda 29 Nov 20, 2022
FastAPI + Postgres + Docker Compose + Heroku Deploy Template

FastAPI + Postgres + Docker Compose + Heroku Deploy ⚠️ For educational purpose only. Not ready for production use YET Features FastAPI with Postgres s

DP 12 Dec 27, 2022
REST API with FastAPI and PostgreSQL

REST API with FastAPI and PostgreSQL To have the same data in db: create table CLIENT_DATA (id SERIAL PRIMARY KEY, fullname VARCHAR(50) NOT NULL,email

Luis Quiñones Requelme 1 Nov 11, 2021
Farlimit - FastAPI rate limit with python

FastAPIRateLimit Contributing is F&E (free&easy) Y Usage pip install farlimit N

omid 27 Oct 06, 2022
A FastAPI Plug-In to support authentication authorization using the Microsoft Authentication Library (MSAL)

FastAPI/MSAL - MSAL (Microsoft Authentication Library) plugin for FastAPI FastAPI - https://github.com/tiangolo/fastapi FastAPI is a modern, fast (hig

Dudi Levy 15 Jul 20, 2022
A fast and durable Pub/Sub channel over Websockets. FastAPI + WebSockets + PubSub == ⚡ 💪 ❤️

⚡ 🗞️ FastAPI Websocket Pub/Sub A fast and durable Pub/Sub channel over Websockets. The easiest way to create a live publish / subscribe multi-cast ov

8 Dec 06, 2022
Opinionated authorization package for FastAPI

FastAPI Authorization Installation pip install fastapi-authorization Usage Currently, there are two models available: RBAC: Role-based Access Control

Marcelo Trylesinski 18 Jul 04, 2022
Simple FastAPI Example : Blog API using FastAPI : Beginner Friendly

fastapi_blog FastAPI : Simple Blog API with CRUD operation Steps to run the project: git clone https://github.com/mrAvi07/fastapi_blog.git cd fastapi-

Avinash Alanjkar 1 Oct 08, 2022
FastAPI-PostgreSQL-Celery-RabbitMQ-Redis bakcend with Docker containerization

FastAPI - PostgreSQL - Celery - Rabbitmq backend This source code implements the following architecture: All the required database endpoints are imple

Juan Esteban Aristizabal 54 Nov 26, 2022
Dead-simple mailer micro-service for static websites

Mailer Dead-simple mailer micro-service for static websites A free and open-source software alternative to contact form services such as FormSpree, to

Romain Clement 42 Dec 21, 2022
Dead simple CSRF security middleware for Starlette ⭐ and Fast API ⚡

csrf-starlette-fastapi Dead simple CSRF security middleware for Starlette ⭐ and Fast API ⚡ Will work with either a input type="hidden" field or ajax

Nathaniel Sabanski 9 Nov 20, 2022
Slack webhooks API served by FastAPI

Slackers Slack webhooks API served by FastAPI What is Slackers Slackers is a FastAPI implementation to handle Slack interactions and events. It serves

Niels van Huijstee 68 Jan 05, 2023
Keycloack plugin for FastApi.

FastAPI Keycloack Keycloack plugin for FastApi. Your aplication receives the claims decoded from the access token. Usage Run keycloak on port 8080 and

Elber 4 Jun 24, 2022
Fast, simple API for Apple firmwares.

Loyal Fast, Simple API for fetching Apple Firmwares. The API server is closed due to some reasons. Wait for v2 releases. Features Fetching Signed IPSW

11 Oct 28, 2022
An extension library for FastAPI framework

FastLab An extension library for FastAPI framework Features Logging Models Utils Routers Installation use pip to install the package: pip install fast

Tezign Lab 10 Jul 11, 2022
FastAPI Server Session is a dependency-based extension for FastAPI that adds support for server-sided session management

FastAPI Server-sided Session FastAPI Server Session is a dependency-based extension for FastAPI that adds support for server-sided session management.

DevGuyAhnaf 5 Dec 23, 2022
Keycloak integration for Python FastAPI

FastAPI Keycloak Integration Documentation Introduction Welcome to fastapi-keycloak. This projects goal is to ease the integration of Keycloak (OpenID

Code Specialist 113 Dec 31, 2022
Github timeline htmx based web app rewritten from Common Lisp to Python FastAPI

python-fastapi-github-timeline Rewrite of Common Lisp htmx app _cl-github-timeline into Python using FastAPI. This project tries to prove, that with h

Jan Vlčinský 4 Mar 25, 2022
Simple example of FastAPI + Celery + Triton for benchmarking

You can see the previous work from: https://github.com/Curt-Park/producer-consumer-fastapi-celery https://github.com/Curt-Park/triton-inference-server

Jinwoo Park (Curt) 37 Dec 29, 2022
API written using Fast API to manage events and implement a leaderboard / badge system.

Open Food Facts Events API written using Fast API to manage events and implement a leaderboard / badge system. Installation To run the API locally, ru

Open Food Facts 5 Jan 07, 2023