patch() — fastapi Function Reference

Architecture documentation for the patch() function in applications.py from the fastapi codebase.

Function python FastAPI Applications calls 2

Entity Profile

FastAPI→ Applications→ patch() — fastapi Function Reference

Dependency Diagram

graph TD
  7025f2e0_d2f7_4809_ee15_829bb1290211["patch()"]
  587454b3_6db6_011f_9fa4_3e4e2e09b72d["FastAPI"]
  7025f2e0_d2f7_4809_ee15_829bb1290211 -->|defined in| 587454b3_6db6_011f_9fa4_3e4e2e09b72d
  c5bafab2_5f69_c237_195d_2a065cbb446e["patch()"]
  7025f2e0_d2f7_4809_ee15_829bb1290211 -->|calls| c5bafab2_5f69_c237_195d_2a065cbb446e
  28261a63_2ba9_f1ff_1d1b_475348a45a65["Default()"]
  7025f2e0_d2f7_4809_ee15_829bb1290211 -->|calls| 28261a63_2ba9_f1ff_1d1b_475348a45a65
  style 7025f2e0_d2f7_4809_ee15_829bb1290211 fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

fastapi/applications.py lines 3792–4168

    def patch(
        self,
        path: Annotated[
            str,
            Doc(
                """
                The URL path to be used for this *path operation*.

                For example, in `http://example.com/items`, the path is `/items`.
                """
            ),
        ],
        *,
        response_model: Annotated[
            Any,
            Doc(
                """
                The type to use for the response.

                It could be any valid Pydantic *field* type. So, it doesn't have to
                be a Pydantic model, it could be other things, like a `list`, `dict`,
                etc.

                It will be used for:

                * Documentation: the generated OpenAPI (and the UI at `/docs`) will
                    show it as the response (JSON Schema).
                * Serialization: you could return an arbitrary object and the
                    `response_model` would be used to serialize that object into the
                    corresponding JSON.
                * Filtering: the JSON sent to the client will only contain the data
                    (fields) defined in the `response_model`. If you returned an object
                    that contains an attribute `password` but the `response_model` does
                    not include that field, the JSON sent to the client would not have
                    that `password`.
                * Validation: whatever you return will be serialized with the
                    `response_model`, converting any data as necessary to generate the
                    corresponding JSON. But if the data in the object returned is not
                    valid, that would mean a violation of the contract with the client,
                    so it's an error from the API developer. So, FastAPI will raise an
                    error and return a 500 error code (Internal Server Error).

                Read more about it in the
                [FastAPI docs for Response Model](https://fastapi.tiangolo.com/tutorial/response-model/).
                """
            ),
        ] = Default(None),
        status_code: Annotated[
            Optional[int],
            Doc(
                """
                The default status code to be used for the response.

                You could override the status code by returning a response directly.

                Read more about it in the
                [FastAPI docs for Response Status Code](https://fastapi.tiangolo.com/tutorial/response-status-code/).
                """
            ),
        ] = None,
        tags: Annotated[
            Optional[list[Union[str, Enum]]],
            Doc(
                """
                A list of tags to be applied to the *path operation*.

                It will be added to the generated OpenAPI (e.g. visible at `/docs`).

                Read more about it in the
                [FastAPI docs for Path Operation Configuration](https://fastapi.tiangolo.com/tutorial/path-operation-configuration/#tags).
                """
            ),
        ] = None,
        dependencies: Annotated[
            Optional[Sequence[Depends]],
            Doc(
                """
                A list of dependencies (using `Depends()`) to be applied to the
                *path operation*.

                Read more about it in the