livioribeiro / selva

Python ASGI web framework

Project Selva

Documentation: https://livioribeiro.github.io/selva/

Selva is a Python ASGI web framework built on top of asgikit and inspired by Spring Boot, AspNet, FastAPI and Go's net/http.

It features a Dependency Injection system to help build robust and reliable applications.

Quick start

Install selva and uvicorn to run application:

pip install selva uvicorn[standard]

Create a module called application.py:

touch application.py

Create a controller:

from asgikit.requests import Request
from asgikit.responses import respond_text
from selva.web import controller, get


@controller
class Controller:
    @get
    async def hello(self, request: Request):
        await respond_text(request.response, "Hello, World!")

Run application with uvicorn (Selva will automatically load application.py):

uvicorn selva.run:app --reload

selva's Issues

Configure loggers with environment variable

Refactor service and controller markers

Add exception handling support

refactor di to behave like dataclasses

Change Router to use list of tuples instead of dict

Add di interceptor registration

DI Interceptors can intercept the creation of services. This can be used, for example, to add a caching behavior to some functions in a service that meet a specific predicate

Make "Settings" object immutable

Create a namedtuple when parsing settings

Add background services

Add support for creating services that are instantiated on application startup and run until application is shutdown.

These services may loop waiting for events, for example, listening for rabbitmq events, and should handle StopIteration or InterruptedError

Change configuration to use strictyaml

Remove the need to create an "Application" instance

Use an Application instance from selva itself and scan user application module/package for services and controllers

Use standard logging

Evaluate alternate logging libraries structlog and loguru

Configure individual parts of the logging dict configuration

Users should be able to configure parts of the logging configuration without overriding the whole configuration dict, unless it is explicitly overriden, like the following:

LOGGING_FORMATTERS = {
    "default": {
        "format": "{asctime} | {levelname:<8} | {name} - {message}",
        "style": "{",
        "datefmt": "%Y-%m-%d %H:%M:%S",
    },
}

LOGGING_HANDLERS = {
    "console": {
        "class": "logging.StreamHandler",
        "formatter": "default",
    },
}

LOGGING_LOGGERS = {
    "selva": {
        "handlers": ["console"],
        "level": "WARNING",
    },
    "application": {
        "handlers": ["console"],
        "level": "INFO",
    },
}

Better handle optional and missing handler function parameters

Parametrize FromRequest converters

For example:

from selva.seb impor controller, get
from selva.web.converters import Json

@controller
class Controller:
    @get
    def handler(self, model: Model = Json()):
        ...

Add `python-dotenv` integration

Rework service registry to be cleaner and expose list of services

Change websocket interface

receive websocket "client" by calling await websocket.accept()

Change service discovery to use DI Contaner's "scan"

Create a test application class

Change Middleware interface to improve pure asgi middleware compatibility

Switch to starlette

Create utilities to deal with environment variables in settings

Add optional response body to Http exception

Validate that a service can only have a parameterless constructor

Use `asgiref` to integrate sync and async

Evaluate using Hatch instead of Poetry

Provide a way to extend application with external modules

External modules are python packages that provide hook to configure themselves with the framwork, registering services, routes, etc

Improve websockets to provide a higher level interface