iva(s)",badCreditCard:"O número de cartão de crédito digitado não é válido",badCVV:"O código de segurança do cartão de crédito não é válido",wrongFileDim:"As dimensões da imagem não são válidas",imageTooTall:"a imagem não pode ser mais alta que ",imageTooWide:"a imagem não pode ser mais larga que ",imageTooSmall:"a imagem é muito pequena",min:"min",max:"max",imageRatioNotAccepted:"A proporção da imagem (largura x altura) não é válida",badBrazilTelephoneAnswer:"O número de telefone digitado é inv...

# Codificador Compatível com JSON

Existem alguns casos em que você pode precisar converter um tipo de dados (como um modelo Pydantic) para algo compatível com JSON (como um `dict`, `list`, etc).

Por exemplo, se você precisar armazená-lo em um banco de dados.

Para isso, **FastAPI** fornece uma função `jsonable_encoder()`.

## Usando a função `jsonable_encoder`

Você pode definir parâmetros de Cookie da mesma maneira que define paramêtros com `Query` e `Path`.

## Importe `Cookie`

Primeiro importe `Cookie`:

```Python hl_lines="3"
{!../../../docs_src/cookie_params/tutorial001.py!}
```

## Declare parâmetros de `Cookie`

Então declare os paramêtros de cookie usando a mesma estrutura que em `Path` e `Query`.

# Corpo - Modelos aninhados

Com o **FastAPI**, você pode definir, validar, documentar e usar modelos profundamente aninhados de forma arbitrária (graças ao Pydantic).

## Campos do tipo Lista

Você pode definir um atributo como um subtipo. Por exemplo, uma `list` do Python:

```Python hl_lines="14"
{!../../../docs_src/body_nested_models/tutorial001.py!}
```

	}

	// Run the same check as k8s.io/kubectl/pkg/cmd/portforward/portforward.go
	// so that we will fail early if there is a problem contacting API server.
	podGet := restClient.Get().Resource("pods").Namespace(f.ns).Name(f.podName)
	obj, err := podGet.Do(context.TODO()).Get()
	if err != nil {
		return nil, fmt.Errorf("failed retrieving: %v in the %q namespace", err, f.ns)
	}
	pod, ok := obj.(*v1.Pod)
	if !ok {

Em muitos casos você pode ter (e deveria ter) um "proxy de saída" tratando HTTPS no topo, isso dependerá de como você fará o deploy da sua aplicação, seu provedor pode fazer isso pra você ou talvez seja necessário fazer você mesmo.

!!! tip

    ```

## Resposta com `dict` arbitrário

Você também pode declarar uma resposta usando um simples `dict` arbitrário, declarando apenas o tipo das chaves e valores, sem usar um modelo Pydantic.

Isso é útil se você não souber os nomes de campo / atributo válidos (que seriam necessários para um modelo Pydantic) antecipadamente.

Neste caso, você pode usar `typing.Dict` (ou simplesmente dict no Python 3.9 e superior):

před
pta
jejich
byl
ještě
až
bez
také
pouze
první
vaše
která
nás
nový
tipy
pokud
může
strana
jeho
své
jiné
zprávy
nové
není
vás
jen
podle
zde
už
být
více
bude
již
než
který
by
které
co
nebo
ten
tak
má
při
od
po
jsou
jak
další
ale
si
se
ve
to
jako

// RUN: tf-mlir-translate -mlir-to-graphdef %s -o - | FileCheck %s

func.func @main() {
  // The operation does not have any attributes, but TensorFlow OpDef expects
  // a `dtype` to be added on the NodeDef. We verify that we correctly use the
  // DerivedAttr to populate the NodeDef.
  // CHECK:      key: "dtype"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   type: DT_FLOAT
  // CHECK:   float_val: 2
  // CHECK:      key: "dtype"
  // CHECK-NEXT: value {

  The argument to the decorator must be the name of a TF raw operator the
  function composites for. Decorated function must take positional arguments
  which corresponds to the input and attributes in OpDef of the TF operation.
  # TODO(fengliuai): more documents here.

  Example:
    @composite.Composite('AddN')
    def _compose_add_n(inputs, N):
      if N == 1:
        ....
  """