Route class

Here's the reference information for the Route class, with all its parameters, attributes and methods.

You can import the Route class directly from nexify:

from Route import Nexify

nexify.routing.Route

Route(
    path,
    handler,
    *,
    methods,
    status_code=None,
    tags=None,
    dependencies=None,
    summary=None,
    description=None,
    response_description="Successful Response",
    deprecated=None,
    operation_id=None,
    response_class=JSONResponse,
    name=None,
    openapi_extra=None,
    middlewares=None,
)

Bases: Operation

PARAMETER	DESCRIPTION
methods	The HTTP methods to be used for this path operation. For example, ["GET", "POST"]. TYPE: Sequence[Literal['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD']]
status_code	The status code to be used for this path operation. For example, in http://example.com/items, the status code is 200. TYPE: int | None DEFAULT: None
tags	A list of tags to be applied to the path operation. It will be added to the generated OpenAPI. TYPE: list[str] | None DEFAULT: None
dependencies	A list of dependencies (using Depends()) to be applied TYPE: Sequence[Depends] | None DEFAULT: None
summary	A summary for the path operation. It will be added to the generated OpenAPI. TYPE: str | None DEFAULT: None
description	A description for the path operation. If not provided, it will be extracted automatically from the docstring of the path operation function. It can contain Markdown. It will be added to the generated OpenAPI. TYPE: str | None DEFAULT: None
response_description	The description for the default response. It will be added to the generated OpenAPI. TYPE: str DEFAULT: 'Successful Response'
deprecated	Mark this path operation as deprecated. It will be added to the generated OpenAPI. TYPE: bool | None DEFAULT: None
operation_id	Custom operation ID to be used by this path operation. By default, it is generated automatically. If you provide a custom operation ID, you need to make sure it is unique for the whole API. You can customize the operation ID generation with the parameter generate_unique_id_function in the Nexify class. TYPE: str | None DEFAULT: None
response_class	Response class to be used for this path operation. This will not be used if you return a response directly. TYPE: type[HttpResponse] DEFAULT: JSONResponse
name	Name for this path operation. Only used internally. TYPE: str | None DEFAULT: None
openapi_extra	Extra metadata to be included in the OpenAPI schema for this path operation. TYPE: dict[str, Any] | None DEFAULT: None
middlewares	A list of middlewares to be applied to this path operation. TYPE: list[Middleware] | None DEFAULT: None

Source code in nexify/routing.py

def __init__(
    self,
    path: str,
    handler: Callable,
    *,
    methods: Annotated[
        Sequence[Literal["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]],
        Doc(
            """
            The HTTP methods to be used for this *path operation*.

            For example, `["GET", "POST"]`.
            """
        ),
    ],
    status_code: Annotated[
        int | None,
        Doc(
            """
            The status code to be used for this *path operation*.

            For example, in `http://example.com/items`, the status code is `200`.
            """
        ),
    ] = None,
    tags: Annotated[
        list[str] | None,
        Doc(
            """
            A list of tags to be applied to the *path operation*.

            It will be added to the generated OpenAPI.
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied
            """
        ),
    ] = None,
    summary: Annotated[
        str | None,
        Doc(
            """
            A summary for the *path operation*.

            It will be added to the generated OpenAPI.
            """
        ),
    ] = None,
    description: Annotated[
        str | None,
        Doc(
            """
            A description for the *path operation*.

            If not provided, it will be extracted automatically from the docstring
            of the *path operation function*.

            It can contain Markdown.

            It will be added to the generated OpenAPI.
            """
        ),
    ] = None,
    response_description: Annotated[
        str,
        Doc(
            """
            The description for the default response.

            It will be added to the generated OpenAPI.
            """
        ),
    ] = "Successful Response",
    deprecated: Annotated[
        bool | None,
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI.
            """
        ),
    ] = None,
    operation_id: Annotated[
        str | None,
        Doc(
            """
            Custom operation ID to be used by this *path operation*.

            By default, it is generated automatically.

            If you provide a custom operation ID, you need to make sure it is
            unique for the whole API.

            You can customize the
            operation ID generation with the parameter
            `generate_unique_id_function` in the `Nexify` class.
            """
        ),
    ] = None,
    response_class: Annotated[
        type[HttpResponse],
        Doc(
            """
            Response class to be used for this *path operation*.

            This will not be used if you return a response directly.
            """
        ),
    ] = JSONResponse,
    name: Annotated[
        str | None,
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        dict[str, Any] | None,
        Doc(
            """
            Extra metadata to be included in the OpenAPI schema for this *path
            operation*.
            """
        ),
    ] = None,
    middlewares: Annotated[
        list[Middleware] | None,
        Doc(
            """
            A list of middlewares to be applied to this *path operation*.
            """
        ),
    ] = None,
) -> None:
    assert path.startswith("/"), "Path must start with '/'"
    super().__init__(handler=handler, middlewares=middlewares)

    self.path = path
    self.methods: set[Literal["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]] = set(methods)
    self.status_code = status_code
    self.dependencies = list(dependencies or [])
    self.tags = tags or []
    self.summary = summary
    self.description = description
    self.response_description = response_description
    self.deprecated = deprecated
    self.operation_id = operation_id
    self.name = get_name(handler) if name is None else name
    self.openapi_extra = openapi_extra
    self.path_regex, self.path_format, self.param_convertors = compile_path(path)
    self.unique_id = self.operation_id or generate_unique_id(self)

    self.dependant = get_dependant(
        path=self.path_format,
        call=self.handler,
    )
    for depends in reversed(self.dependencies):
        self.dependant.dependencies.insert(
            0,
            get_sub_dependant(
                depends=depends,
                dependency=depends.dependency,
                path=self.path_format,
            ),
        )

    return_annotation = get_typed_return_annotation(self.handler)
    if return_annotation is not None:
        _name = f"{self.handler.__name__}_response"
        self.response_field = create_model_field(
            FieldInfo(
                name=_name,
            ),
            annotation=return_annotation,
            name=_name,
        )
    else:
        self.response_field = None
    self.response_class = response_class

handler instance-attribute

handler = handler

middlewares instance-attribute

middlewares = middlewares or []

path instance-attribute

path = path

methods instance-attribute

methods = set(methods)

status_code instance-attribute

status_code = status_code

dependencies instance-attribute

dependencies = list(dependencies or [])

tags instance-attribute

tags = tags or []

summary instance-attribute

summary = summary

description instance-attribute

description = description

response_description instance-attribute

response_description = response_description

deprecated instance-attribute

deprecated = deprecated

operation_id instance-attribute

operation_id = operation_id

name instance-attribute

name = get_name(handler) if name is None else name

openapi_extra instance-attribute

openapi_extra = openapi_extra

unique_id instance-attribute

unique_id = operation_id or generate_unique_id(self)

dependant instance-attribute

dependant = get_dependant(path=path_format, call=handler)

response_field instance-attribute

response_field = create_model_field(
    FieldInfo(name=_name),
    annotation=return_annotation,
    name=_name,
)

response_class instance-attribute

response_class = response_class