Light, Flexible and Extensible ASGI API framework

Starlite logo

PyPI - License PyPI - Python Version

Coverage Vulnerabilities Quality Gate Status Maintainability Rating Reliability Rating Security Rating

Discord

Medium

Starlite

Starlite is a light and flexible ASGI API framework. Using Starlette and pydantic as foundations.

Check out the Starlite documentation 📚

Core Features

  • 👉 Class based controllers
  • 👉 Decorators based configuration
  • 👉 Extended testing support
  • 👉 Extensive typing support including inference, validation and parsing
  • 👉 Full async (ASGI) support
  • 👉 Layered dependency injection
  • 👉 OpenAPI 3.1 schema generation with Redoc UI
  • 👉 Route guards based authorization
  • 👉 Simple middleware and authentication
  • 👉 Support for pydantic models and pydantic dataclasses
  • 👉 Support for standard library dataclasses
  • 👉 Support for SQLAlchemy declarative classes
  • 👉 Plugin system to allow extending supported classes
  • 👉 Ultra-fast json serialization and deserialization using orjson

Installation

pip install starlite

Relation to Starlette and FastAPI

Although Starlite uses the Starlette ASGI toolkit, it does not simply extend Starlette, as FastAPI does. Starlite uses selective pieces of Starlette while implementing its own routing and parsing logic, the primary reason for this is to enforce a set of best practices and discourage misuse. This is done to promote simplicity and scalability - Starlite is simple to use, easy to learn, and unlike both Starlette and FastAPI - it keeps complexity low when scaling.

Additionally, Starlite is faster than both FastAPI and Starlette:

plain text requests processed

Legend:

  • a-: async, s-: sync
  • np: no params, pp: path param, qp: query param, mp: mixed params

Class Based Controllers

While supporting function based route handlers, Starlite also supports and promotes python OOP using class based controllers:

from typing import List, Optional

from pydantic import UUID4
from starlite import Controller, Partial, get, post, put, patch, delete
from datetime import datetime

from my_app.models import User


class UserController(Controller):
    path = "/users"

    @post()
    async def create_user(self, data: User) -> User:
        ...

    @get()
    async def list_users(self) -> List[User]:
        ...

    @get(path="/{date:int}")
    async def list_new_users(self, date: datetime) -> List[User]:
        ...

    @patch(path="/{user_id:uuid}")
    async def partially_update_user(self, user_id: UUID4, data: Partial[User]) -> User:
        ...

    @put(path="/{user_id:uuid}")
    async def update_user(self, user_id: UUID4, data: User) -> User:
        ...

    @get(path="/{user_name:str}")
    async def get_user_by_name(self, user_name: str) -> Optional[User]:
        ...

    @get(path="/{user_id:uuid}")
    async def get_user(self, user_id: UUID4) -> User:
        ...

    @delete(path="/{user_id:uuid}")
    async def delete_user(self, user_id: UUID4) -> User:
        ...

ReDoc Automatic API Documentation

While running Starlite, you can view the ReDoc API Documentation Page by accessing it at the default location of /schema or change the location using the OpenAPIController. If your app is running locally on port 8000 you can access the ReDoc page at http://0.0.0.0:8000/schema.

Data Parsing, Type Hints and Pydantic

One key difference between Starlite and Starlette/FastAPI is in parsing of form data and query parameters- Starlite supports mixed form data and has faster and better query parameter parsing.

Starlite is rigorously typed, and it enforces typing. For example, if you forget to type a return value for a route handler, an exception will be raised. The reason for this is that Starlite uses typing data to generate OpenAPI specs, as well as to validate and parse data. Thus typing is absolutely essential to the framework.

Furthermore, Starlite allows extending its support using plugins.

SQL Alchemy Support, Plugin System and DTOs

Starlite has a plugin system that allows the user to extend serialization/deserialization, OpenAPI generation and other features. It ships with a builtin plugin for SQL Alchemy, which allows the user to use SQL Alchemy declarative classes "natively", i.e. as type parameters that will be serialized/deserialized and to return them as values from route handlers.

Starlite also supports the programmatic creation of DTOs with a DTOFactory class, which also supports the use of plugins.

OpenAPI

Starlite has custom logic to generate OpenAPI 3.1.0 schema, the latest version. The schema generated by Starlite is significantly more complete and more correct than those generated by FastAPI, and they include optional generation of examples using the pydantic-factories library.

Dependency Injection

Starlite has a simple but powerful DI system inspired by pytest. You can define named dependencies - sync or async - at different levels of the application, and then selective use or overwrite them.

Middleware

Starlite supports the Starlette Middleware system while simplifying it and offering builtin configuration of CORS and some other middlewares.

Route Guards

Starlite has an authorization mechanism called guards, which allows the user to define guard functions at different level of the application (app, router, controller etc.) and validate the request before hitting the route handler function.

Request Life Cycle Hooks

Starlite supports request life cycle hooks, similarly to Flask - i.e. before_request and after_request

Contributing

Starlite is open to contributions big and small. You can always join our discord server to discuss contributions and project maintenance. For guidelines on how to contribute, please see the contribution guide.

Comments
  • [Question] Mount Piccolo Admin to Starlite app

    [Question] Mount Piccolo Admin to Starlite app

    Hello, First I want to thanks all for this great new framework. I would like to implement a Starlite asgi template for Piccolo ORM. Piccolo ORM is an easy-to-use async orm with an integrated web admin. Piccolo ORM currently support Starlette, FastAPI, BlackSheep and Xpresso (all this frameworks support mounting asgi apps) and it would be nice if we could add Starlite support. I have already implemented a basic CRUD for Piccolo tables, but the main problem is mounting Piccolo Admin (which is already an asgi application) on the Starlite app.

    Starlite routing has a different design and you can only run the another asgi application through middleware which work,

    # some other import
    from piccolo_admin.endpoints import create_admin
    from starlite import Starlite
    from home.piccolo_app import APP_CONFIG
    
    # Piccolo Admin asgi app
    admin_app = create_admin(tables=APP_CONFIG.table_classes)
    
    class AdminMiddleware(MiddlewareProtocol):
        def __init__(self, app: ASGIApp):
            self.app = admin_app
    
        async def __call__(
            self, scope: Scope, receive: Receive, send: Send
        ) -> None:
            if scope["type"] == "http":
                request = Request(scope)
            await self.app(scope, receive, send)
    
    app = Starlite(
        middleware=[AdminMiddleware],
       ...
    )
    

    but that didn't solve the main problem because admin app is mounted to root path and any other routes from route_handlers is not accesible (e.g /tasks). Router class also does not work because route_handlers accept standalone function or controller but not asgi app. Is it possible to mount Piccolo Admin on the /admin route (other frameworks have Mount or app.mount), and the rest of the Starlite app is on the root path? Sorry for long comment (I hope I have explained the problem well) but any help appriciated. Thanks.

  • Logging config

    Logging config

    This PR adds a default logging config and a way of setting logging easily:

    1. I created a pydantic model for the logging.config.dictConfig expected parameter.
    2. I set the defaults in this model.
    3. To modify or extend the base config, the user is expected to subclass this pydantic model and pass it to the app when instantiating.
    4. If None is passed by the user to Starlite(), logging will be disabled.
  • Incorrect middleware call order

    Incorrect middleware call order

    So I have an app with configured trusted host and CORS and some middlewares

    app = Starlite(
        debug=True,
        cors_config=cors_conf,
        allowed_hosts=['127.0.0.1', 'localhost'],
        dependencies={'edb': Provide(init_edgedb)},
        on_startup=[logging_config.configure],
        on_shutdown=[disconnect_edgedb],
        route_handlers=[health_check, admin_router],
        middleware=[SomeMiddleware, SomeMiddleware2],
    )
    
    class SomeMiddleware(MiddlewareProtocol):
        def __init__(self, app: ASGIApp):
            self.app = app
    
        async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
            print("///call some middleware")
            await self.app(scope, receive, send)
            print("///some middleware AWAITED")
    

    There are two problems here:

    1. SomeMiddleware2 called before SomeMiddleware. Normally we expect that middlewares will be called in order they were passed.
    2. cors_config and allowed_hosts settings can't be used with other middlewares, as the other middlewares will be called before host check which in most cases does not make sense. See log below, my middlewares called even for preflight OPTIONS request.
    INFO - 2022-04-19 00:22:24,513 - uvicorn.error - on - Application startup complete.
    ///call some middleware2
    ///call some middleware
    ///call cors middleware
    INFO:     127.0.0.1:38354 - "OPTIONS /api/a/brand HTTP/1.1" 200 OK
    ///cors middleware AWAITED OPTIONS
    ///some middleware AWAITED
    ///some middleware2 AWAITED
    # here OPTIONS req finishes and POST req starts
    ///call some middleware2
    ///call some middleware
    ///call cors middleware
    ///call trusted host middleware
    INFO:     127.0.0.1:38354 - "POST /api/a/brand HTTP/1.1" 201 Created
    ///trusted host middleware AWAITED
    ///cors middleware AWAITED
    ///some middleware AWAITED
    ///some middleware2 AWAITED
    
  • TestClient() ignores Starlite(on_startup=[...])

    TestClient() ignores Starlite(on_startup=[...])

    For my_app/main.py

    import sys
    
    from starlite import MediaType, Starlite, State, get
    
    
    def on_startup(state: State):
        state.value = 1
    
    
    @get(path="/health-check", media_type=MediaType.TEXT)
    def health_check(state: State) -> str:
        try:
            print(f'{state.value=}')
            return "healthy"
        except Exception as exc:
            print(exc, file=sys.stderr)
    
    
    app = Starlite(route_handlers=[health_check], on_startup=[on_startup])
    

    This test will fail. tests/test_health_check.py

    from starlette.status import HTTP_200_OK
    from starlite import TestClient
    
    from my_app.main import app
    
    client = TestClient(app=app)
    
    
    def test_health_check():
        response = client.get("/health-check")
        assert response.status_code == HTTP_200_OK
        assert response.text == "healthy"
    

    The error 'State' object has no attribute 'value' indicates, on_startup() were not executed prior to the test execution. It ran as expected when using uvicorn.

  • [documentation] Continous update

    [documentation] Continous update

    The documentation is an ongoing project - we would like to ask the community to contribute. PRs including any of the following will be welcome:

    1. edits and rewrites to improve the documentation in terms of grammar, syntax, structure
    2. improvements to examples - better code or cleaner code, fixes, additional examples
    3. additional documentation
    4. improvements to the documentation website (using mkdocs metarial theme)

    You are also welcome to discuss in this thread your opinion regarding required additions or improvements to the documentation.

  • header Parameter throws pydantic error in 0.7.1

    header Parameter throws pydantic error in 0.7.1

    These docs: https://starlite-api.github.io/starlite/usage/3-parameters/#header-and-cookie-parameters

    have the example for using a header parameter as:

    @get(path="/users/{user_id:uuid}/")
    async def get_user(
        user_id: UUID4,
        token: Parameter(header="X-API-KEY"),
    ) -> User:
        ...
    

    when I try the (slightly modified) resource (since I don't have User in my app):

    @get(path="/users/{user_id:uuid}/")
    async def get_user(
        user_id: UUID4,
        token: Parameter(header="X-API-KEY"),
    ) -> Request:
        ...
    

    I get the error

    RuntimeError: error checking inheritance of FieldInfo(default=PydanticUndefined, alias='', extra={'header': 'X-API-KEY', 'cookie': None, 'query': None, 'required': True, 'examples': None, 'external_docs': None, 'content_encoding': None}) (type: FieldInfo)
    

    This is on python v3.9.7 and pydantic 1.9.0 (which I'm not installing explicitly, and I think got installed as a dependency of starlite)

  • updated application lifecycle handling

    updated application lifecycle handling

    This PR updates how lifecycle is handled-

    1. functions set to on_startup and on_shutdown can now receive the application state object.
    2. the state object is now imported from starlite.datastructures.State instead of from Starlette, and it has a custom copy method which ensures correct shallow copy
    3. the state object can be injected to route handlers and dependencies by specifying the state kwarg.
    4. documentation has also been updated.
  • allow empty `

    allow empty `""` path in Controller ?

    https://github.com/starlite-api/starlite/blob/965d97620774991bd302a3a227bd3ebe6236ae96/starlite/controller.py#L27-L28

    Context

    In some of our project (built with FastAPI) we use Factory classes that helps us creating bunch of endpoints for given user inputs and dependencies (https://developmentseed.org/titiler/advanced/tiler_factories/ https://developmentseed.org/titiler/api/titiler/core/factory/#tilerfactory). This is why I was really interested in the Controller class to replace our Factories.

    One problem I'm facing right now is that Controller Path has to be non null.

    from starlite import get, Starlite
    from starlite.controller import Controller
    from starlette.requests import Request
    
    
    class Endpoints(Controller):
        """TileMatrixSets endpoints."""
    
        path = "/"
    
        @get(path="/yo")
        def hey(self, request: Request) -> str:
            return "yipi"
    
        @get(path="ye")
        def hey2(self, request: Request) -> str:
            return "what"
    
    
    app = Starlite(route_handlers=[Endpoints])
    

    schema

    {
      "openapi": "3.1.0",
      "info": {
        "title": "Starlite API",
        "version": "1.0.0"
      },
      "servers": [
        {
          "url": "/"
        }
      ],
      "paths": {
        "//yo": {
          "get": {
            "operationId": "hey",
            "responses": {
              "200": {
                "description": "Request fulfilled, document follows",
                "headers": {},
                "content": {
                  "application/json": {
                    "schema": {
                      "type": "string"
                    }
                  }
                }
              }
            },
            "deprecated": false
          }
        },
        "//ye": {
          "get": {
            "operationId": "hey2",
            "responses": {
              "200": {
                "description": "Request fulfilled, document follows",
                "headers": {},
                "content": {
                  "application/json": {
                    "schema": {
                      "type": "string"
                    }
                  }
                }
              }
            },
            "deprecated": false
          }
        }
      }
    }
    

    as we can see in the schema ☝️, both endpoints are // prefixed because Starlite is normalizing path (I think). I can agree that I want to use the Controller class for something it wasn't designed for, but it could be nice if the path could be set to "".

    Potential fix

    By allowing path to be all but not None it seem to fix my issue, but I'm not quite sure what it means for the rest of the application.

    class Endpoints(Controller):
        """TileMatrixSets endpoints."""
    
        path = ""
    
        def __init__(self, owner: "Router"):
            if not hasattr(self, "path") or self.path is None:
                raise ImproperlyConfiguredException("Controller subclasses must set a path attribute")
    
            for key in ["dependencies", "response_headers", "response_class", "guards"]:
                if not hasattr(self, key):
                    setattr(self, key, None)
    
            self.path = self.path
            self.owner = owner
            for route_handler in self.get_route_handlers():
                route_handler.owner = self
    
        @get(path="/yo")
        def hey(self, request: Request) -> str:
            print(request)
            return "yipi"
    
        @get(path="/ye")
        def hey2(self, request: Request) -> str:
            print(request)
            return "what"
    

    again, I will understand that I want to use the Controller class outside of its scope 🙏

  • Enhance multipart handling

    Enhance multipart handling

    Starlite currently uses the Starlette built-in multipart handling, which is somewhat limited. @adriangb has proposed to enhance this by supporting different encodings and data.

  • Static files with path=

    Static files with path="/"

    Hi Guys,

    I have a question about serving static files with path="/". I have found that the problem is here, in line 54. https://github.com/starlite-api/starlite/blob/e9372128d490667402db2893e47f5cfda0917bab/starlite/asgi.py#L52-L55

    Consider this static file configuration:

    [StaticFilesConfig(
        directories=[Path(pkg_resources.resource_filename(__name__, 'view_dist'))],
        path='/',
        html_mode=True
    )]
    

    and following view_dist subdirectories:

    +--- view_dist
        +--- index.html
        +--- diagnostic
            +--- index.html
    

    Requests and its reponses:

    URL=http://192.168.200.100:8000
    
    1. wget -O- $URL/                          --> 200 OK
    2. wget -O- $URL/index.html                --> 200 OK
    3. wget -O- $URL/diagnostic                --> 307 Temporary Redirect to new location (bad): http://192.168.200.100:8000diagnostic/
    4. wget -O- $URL/diagnostic/               --> 307 like above
    5. wget -O- $URL/diagnostic/index.html     --> 404 Not Found
    

    The problems in points 3 and 4 come from the fact that line 54 in asgi.py file removed every occurrences of / from scope['path'] and then the same scope is used in the starlette/staticfiles.py file to build the URL for redirecting purpose, but unfortunately scope['path'] is lack of forward slashes. https://github.com/encode/starlette/blob/d7cbe2a4887ad6b15fe7523ed62e28a426b7697d/starlette/staticfiles.py#L135-L139

    After guarding line 54 (removing every static_path='/' from scope['path']) with extra if it works as expected.

    if static_path != '/':
        scope["path"] = scope["path"].replace(static_path, "") 
    
    1. wget -O- $URL/                          --> 200 OK
    2. wget -O- $URL/index.html                --> 200 OK
    3. wget -O- $URL/diagnostic                --> 307 Temporary Redirect to new location (ok): http://192.168.200.100:8000/diagnostic/ --> 200 OK
    4. wget -O- $URL/diagnostic/               --> 200 OK
    5. wget -O- $URL/diagnostic/index.html     --> 200 OK
    

    I have just started my journey with starlite so I do not know if and where are the side effects of commented out this line in asgi.py. Do you have any suggestions on what I should do to make all the previously mentioned requests work?

  • implemented response caching

    implemented response caching

    This PR implements reponse caching:

    1. add a CacheBackendProtocol, which specifies a simple cache backend protocol. This should allow users to use whatever implementation they prefer, including stuff like Redis and Memcached.
    2. add a CacheConfig, which sets the cache backend for the app and the default expiration.
    3. update handlers to have the cache kwarg - this value can be either a boolean (default False), or an integer (expiration in seconds).
    4. update the HTTPRoute.handle method to handle the caching of responses. The Response instance is "pickled" - which is somewhat security sensitive but I think its OK in this context - the only vector for code injection is if an attacker controls the cache backend already, which basically means he or she has access to the environment.
    5. the caching keys are derived by default from the path + query params. The user can set a function to create the cache key both in the global config as well as per handler.

    P.S. This PR also includes splitting the Router from the Routes - i.e. move Router out of routes.py to router.py. In hindsight it pollutes the DIFF and makes review harder, so apologies.

    TODOs:

    1. update CHANGELOG
    2. update documentation
    3. optional - more tests against other backends. This needs some consideration because testing against redis requires some work.
  • List[User] in openapi is displayed as Any

    List[User] in openapi is displayed as Any

    code

    from typing import List
    
    from starlite import Starlite, Controller, Partial, get, post, delete, patch, put, OpenAPIConfig
    
    from pydantic import BaseModel, UUID4
    
    
    class User(BaseModel):
        first_name: str
        last_name: str
        id: UUID4
    
    
    class UserController(Controller):
        path = "/users"
    
        @post()
        async def create_user(self, data: User) -> User:
            ...
    
        @get()
        async def list_users(self) -> List[User]:
            ...
    
        @patch(path="/{user_id:uuid}")
        async def partially_update_user(self, user_id: UUID4, data: Partial[User]) -> User:
            ...
    
        @put(path="/{user_id:uuid}")
        async def update_user(self, user_id: UUID4, data: User) -> User:
            ...
    
        @get(path="/{user_id:uuid}")
        async def get_user(self, user_id: UUID4) -> User:
            ...
    
        @delete(path="/{user_id:uuid}")
        async def delete_user(self, user_id: UUID4) -> User:
            ...
    
    app = Starlite(route_handlers=[UserController])
    

    result

    image And how to access the interactive openapi documentation fastAPI is used in /docs Can you tell me what to do?

  • Data validation error response is not usable on front end side

    Data validation error response is not usable on front end side

    For data validation in request handler parameters Starlite returns JSON detail: "Validation failed for POST http://localhost:8000/api/a/brand/:\n\ndata -> age\n field required (type=value_error.missing)" extra: null It is hard to use such response for form validation on front end side.

    Besides validation errors breaks CORS middleware which makes response body unavailable for client app in browser. I think it would be more convenient instead raising Starlite ValidationException leave Pydantic ValidationError. It would make it possible to handle it on middleware level and fix CORS.

  • access-control-allow-methods is

    access-control-allow-methods is "DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT" while only post defined

    My controller:

    class BrandController(Controller):
        path = '/brand'
    
        @post()
        async def create(self, data: BrandNew, edb: AsyncIOClient) -> str:
            await edb.query("INSERT Brand { name := <str>$name }", name=data.name)
            return 'ok'
    

    On preflight request it returns access-control-allow-methods header equal to "DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT" but only "OPTIONS, POST" should be there.

  • Use asgiref for typing

    Use asgiref for typing

    Starlette's ASGI types use MutableMapping[str, Any] which is not too different from just typing them dict. This package is fully spec compliant and would help in implementing additional ASGI functionality, as it would allow us to see exactly which keys are available/required to support a feature. There is currently a PR for Starlette that addresses this but it doesn't seem like it would be merged soon.

  • [infra] github workflow for forks

    [infra] github workflow for forks

    The github action doesn't run correctly for forks - we need to fix it so tests run also for forks.

    A second level of this would be to add coverage reporting in github, so it becomes clear whats what with coverage.

FastAPI-Amis-Admin is a high-performance, efficient and easily extensible FastAPI admin framework. Inspired by django-admin, and has as many powerful functions as django-admin.
FastAPI-Amis-Admin is a high-performance, efficient and easily extensible FastAPI admin framework. Inspired by django-admin, and has as many powerful functions as django-admin.

简体中文 | English 项目介绍 FastAPI-Amis-Admin fastapi-amis-admin是一个拥有高性能,高效率,易拓展的fastapi管理后台框架. 启发自Django-Admin,并且拥有不逊色于Django-Admin的强大功能. 源码 · 在线演示 · 文档 · 文

May 19, 2022
API using python and Fastapi framework

Welcome ?? CFCApi is a API DEVELOPMENT PROJECT UNDER CODE FOR COMMUNITY ! Project Walkthrough ?? CFCApi run on Python using FASTapi Framework Docs The

Feb 21, 2022
This is an API developed in python with the FastApi framework and putting into practice the recommendations of the book Clean Architecture in Python by Leonardo Giordani,

This is an API developed in python with the FastApi framework and putting into practice the recommendations of the book Clean Architecture in Python by Leonardo Giordani,

Jan 26, 2022
Beyonic API Python official client library simplified examples using Flask, Django and Fast API.

Beyonic API Python Examples. The beyonic APIs Doc Reference: https://apidocs.beyonic.com/ To start using the Beyonic API Python API, you need to start

Nov 18, 2021
An alternative implement of Imjad API | Imjad API 的开源替代

HibiAPI An alternative implement of Imjad API. Imjad API 的开源替代. 前言 由于Imjad API这是什么?使用人数过多, 致使调用超出限制, 所以本人希望提供一个开源替代来供社区进行自由的部署和使用, 从而减轻一部分该API的使用压力 优势

May 13, 2022
Run your jupyter notebooks as a REST API endpoint. This isn't a jupyter server but rather just a way to run your notebooks as a REST API Endpoint.

Jupter Notebook REST API Run your jupyter notebooks as a REST API endpoint. This isn't a jupyter server but rather just a way to run your notebooks as

May 10, 2022
Practice-python is a simple Fast api project for dealing with modern rest api technologies.

Practice Python Practice-python is a simple Fast api project for dealing with modern rest api technologies. Deployment with docker Go to the project r

Nov 18, 2021
MS Graph API authentication example with Fast API

MS Graph API authentication example with Fast API What it is & does This is a simple python service/webapp, using FastAPI with server side rendering,

Feb 8, 2022
A RESTful API for creating and monitoring resource components of a hypothetical build system. Built with FastAPI and pydantic. Complete with testing and CI.
A RESTful API for creating and monitoring resource components of a hypothetical build system. Built with FastAPI and pydantic. Complete with testing and CI.

diskspace-monitor-CRUD Background The build system is part of a large environment with a multitude of different components. Many of the components hav

May 5, 2022
A FastAPI Framework for things like Database, Redis, Logging, JWT Authentication and Rate Limits

A FastAPI Framework for things like Database, Redis, Logging, JWT Authentication and Rate Limits Install You can install this Library with: pip instal

May 4, 2022
Restful Api developed with Flask using Prometheus and Grafana for monitoring and containerization with Docker :rocket:
Restful Api developed with Flask using Prometheus and Grafana for monitoring and containerization with Docker :rocket:

Hephaestus ?? In Greek mythology, Hephaestus was either the son of Zeus and Hera or he was Hera's parthenogenous child. ... As a smithing god, Hephaes

Nov 12, 2021
FastAPI framework plugins

Plugins for FastAPI framework, high performance, easy to learn, fast to code, ready for production fastapi-plugins FastAPI framework plugins Cache Mem

May 5, 2022
FastAPI framework plugins

Plugins for FastAPI framework, high performance, easy to learn, fast to code, ready for production fastapi-plugins FastAPI framework plugins Cache Mem

Feb 16, 2021
A Python framework to build Slack apps in a flash with the latest platform features.

Bolt for Python A Python framework to build Slack apps in a flash with the latest platform features. Read the getting started guide and look at our co

May 18, 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

Jan 25, 2022
Flask-vs-FastAPI - Understanding Flask vs FastAPI Web Framework. A comparison of two different RestAPI frameworks.
Flask-vs-FastAPI - Understanding Flask vs FastAPI Web Framework. A comparison of two different RestAPI frameworks.

Flask-vs-FastAPI Understanding Flask vs FastAPI Web Framework. A comparison of two different RestAPI frameworks. IntroductionIn Flask is a popular mic

Jan 1, 2022
Cookiecutter API for creating Custom Skills for Azure Search using Python and Docker

cookiecutter-spacy-fastapi Python cookiecutter API for quick deployments of spaCy models with FastAPI Azure Search The API interface is compatible wit

May 12, 2022
High-performance Async REST API, in Python. FastAPI + GINO + Arq + Uvicorn (w/ Redis and PostgreSQL).

fastapi-gino-arq-uvicorn High-performance Async REST API, in Python. FastAPI + GINO + Arq + Uvicorn (powered by Redis & PostgreSQL). Contents Get Star

May 8, 2022
Turns your Python functions into microservices with web API, interactive GUI, and more.
 Turns your Python functions into microservices with web API, interactive GUI, and more.

Instantly turn your Python functions into production-ready microservices. Deploy and access your services via HTTP API or interactive UI. Seamlessly export your services into portable, shareable, and executable files or Docker images.

May 15, 2022