"functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "model-core",
    "path": "platforms/core-configuration/model-core",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "model-groovy",
    "path": "platforms/core-configuration/model-groovy",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": false

    *   `Model.fit_generator`, `Model.evaluate_generator`,
        `Model.predict_generator`, `Model.train_on_batch`,
        `Model.test_on_batch`, and `Model.predict_on_batch` methods now respect
        the `run_eagerly` property, and will correctly run using `tf.function`
        by default. Note that `Model.fit_generator`, `Model.evaluate_generator`,

---> 100%
```

</div>

## Создание приложения с единственной моделью { #create-the-app-with-a-single-model }

Сначала мы создадим самую простую первую версию приложения с одной моделью **SQLModel**.

Позже мы улучшим его, повысив безопасность и универсальность, добавив **несколько моделей**. 🤓

### Создание моделей { #create-models }

Импортируйте `SQLModel` и создайте модель базы данных:

## Other models { #other-models }

You can now get the current user directly in the *path operation functions* and deal with the security mechanisms at the **Dependency Injection** level, using `Depends`.

And you can use any model or data for the security requirements (in this case, a Pydantic model `User`).

But you are not restricted to using some specific data model, class or type.

///

## Embed a single body parameter { #embed-a-single-body-parameter }

Let's say you only have a single `item` body parameter from a Pydantic model `Item`.

By default, **FastAPI** will then expect its body directly.

But if you want it to expect a JSON with a key `item` and inside of it the model contents, as it does when you declare extra body parameters, you can use the special `Body` parameter `embed`:

```Python

        model = builder.build();
        String modelVersion = new MavenModelVersion().getModelVersion(model);
        if (!ModelBuilder.MODEL_VERSION_4_0_0.equals(modelVersion) && !preserveModelVersion) {
            warnNotDowngraded(project);
        }
        model = model.withModelVersion(modelVersion);
        return model;
    }

    version: Literal["1", "auto"] = "auto",
) -> ModelField:
    if annotation_is_pydantic_v1(type_):
        raise PydanticV1NotSupportedError(
            "pydantic.v1 models are no longer supported by FastAPI."
            f" Please update the response model {type_!r}."
        )
    class_validators = class_validators or {}

    field_info = field_info or FieldInfo(annotation=type_, default=default, alias=alias)

    disabled = user_dict["disabled"],
    hashed_password = user_dict["hashed_password"],
)
```

/// info

For a more complete explanation of `**user_dict` check back in [the documentation for **Extra Models**](../extra-models.md#about-user-in-dict){.internal-link target=_blank}.

///

## Return the token { #return-the-token }

The response of the `token` endpoint must be a JSON object.

from typing import Annotated, Optional

from annotated_doc import Doc
from fastapi.openapi.models import OpenIdConnect as OpenIdConnectModel
from fastapi.security.base import SecurityBase
from starlette.exceptions import HTTPException
from starlette.requests import Request
from starlette.status import HTTP_401_UNAUTHORIZED


class OpenIdConnect(SecurityBase):
    """
    OpenID Connect authentication class. An instance of it would be used as a

///

### `examples` no Pydantic e no FastAPI { #pydantic-and-fastapi-examples }

Quando você adiciona `examples` dentro de um modelo Pydantic, usando `schema_extra` ou `Field(examples=["something"])`, esse exemplo é adicionado ao **JSON Schema** para esse modelo Pydantic.

E esse **JSON Schema** do modelo Pydantic é incluído no **OpenAPI** da sua API e, então, é usado na UI da documentação.