Skip to content

AuthenticationMiddleware classΒΆ

This is the reference for the main object AuthenticationMiddleware that contains all the parameters, attributes and functions.

Use this class for authentication middleware in Ravyn.

ravyn.middleware.authentication.AuthenticationMiddleware ΒΆ

AuthenticationMiddleware(app, backend=None, on_error=None)

Bases: AuthenticationMiddleware

PARAMETER DESCRIPTION
app

The ASGI application callable wrapped by this middleware.

TYPE: ASGIApp

backend

One or more authentication backends used to authenticate the connection. If multiple backends are provided, they are tried in order.

TYPE: AuthenticationBackend | Sequence[AuthenticationBackend] | None DEFAULT: None

on_error

An optional error handler function called when authentication fails. It receives the Connection and AuthenticationError and must return an ASGI-compatible Response object.

TYPE: Callable[[Connection, AuthenticationError], Response] | None DEFAULT: None

Source code in ravyn/middleware/authentication.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
def __init__(
    self,
    app: Annotated[
        ASGIApp,
        Doc(
            """
            The ASGI application callable wrapped by this middleware.
            """
        ),
    ],
    backend: Annotated[
        AuthenticationBackend | Sequence[AuthenticationBackend] | None,
        Doc(
            """
            One or more authentication backends used to authenticate the connection.
            If multiple backends are provided, they are tried in order.
            """
        ),
    ] = None,
    on_error: Annotated[
        Callable[[Connection, AuthenticationError], Response] | None,
        Doc(
            """
            An optional error handler function called when authentication fails.
            It receives the Connection and AuthenticationError and must return an
            ASGI-compatible Response object.
            """
        ),
    ] = None,
) -> None:
    super().__init__(app=app, backend=backend, on_error=on_error)  # type: ignore[arg-type]

app instance-attribute ΒΆ

app = app

on_error instance-attribute ΒΆ

on_error = (
    on_error if on_error is not None else default_on_error
)

scopes instance-attribute ΒΆ

scopes = {HTTP, WEBSOCKET}

backend instance-attribute ΒΆ

backend

authenticate async ΒΆ

authenticate(conn, **kwargs)

Authorize users here.

Source code in lilya/middleware/authentication.py 
124
125
126
127
128
129
130
131
132
async def authenticate(self, conn: Connection, **kwargs: Any) -> None | AuthResult:
    """Authorize users here."""

    for backend in self.backend:
        # exceptions are passed through to __call__ and there handled
        auth_result = await backend.authenticate(conn)
        if auth_result is not None:
            return auth_result
    return None

default_on_error staticmethod ΒΆ

default_on_error(connection, exc)
Source code in lilya/middleware/authentication.py 
 99
100
101
@staticmethod
def default_on_error(connection: Connection, exc: Exception) -> Response:
    return PlainText(str(exc), status_code=status.HTTP_400_BAD_REQUEST)

ravyn.middleware.authentication.AuthResult ΒΆ

Bases: ArbitraryBaseModel

user instance-attribute ΒΆ

user

Arbitrary user coming from authentication and assignable to request.user.

model_config class-attribute instance-attribute ΒΆ

model_config = ConfigDict(arbitrary_types_allowed=True)

    - "!^model_config"