}
	for _, line := range bytes.Split(data, []byte("\n")) {
		m := valRe.FindSubmatch(line)
		if m == nil {
			continue
		}
		fmt.Println(strconv.Unquote(string(m[1])))
		if s, err := strconv.Unquote(string(m[1])); err != nil {
			return false, err
		} else if s == expected {
			return true, nil
		}
	}
	return false, nil
}

var valRe = regexp.MustCompile(`^\[\]byte\(([^)]+)\)$`)

func main() {

* `bytes`

```Python hl_lines="1"
{!../../../docs_src/python_types/tutorial005.py!}
```

### Tipos con sub-tipos

Existen algunas estructuras de datos que pueden contener otros valores, como `dict`, `list`, `set` y `tuple`. Los valores internos pueden tener su propio tipo también.

Para declarar esos tipos y sub-tipos puedes usar el módulo estándar de Python `typing`.

Al heredar desde `str` la documentación de la API podrá saber que los valores deben ser de tipo `string` y podrá mostrarlos correctamente.

Luego crea atributos de clase con valores fijos, que serán los valores disponibles válidos:

```Python hl_lines="1  6-9"
{!../../../docs_src/path_params/tutorial005.py!}
```

!!! info "Información"

namespace tf {
namespace libtf {
namespace impl {

TEST(ValueTest, TestBasic) {
  TaggedValue valuef(3.f);
  TaggedValue valuei(int64_t(3));
  TaggedValue list = TaggedValue::List();
  TaggedValue tuple = TaggedValue::Tuple();
  tuple.tuple().push_back(TaggedValue(int64_t(310)));
  list.list().push_back(valuei);
  list.list().push_back(valuef);
  list.list().push_back(tuple);
  std::stringstream stream;
  stream << list;

## Cabeçalhos duplicados

É possível receber cabeçalhos duplicados. Isso significa, o mesmo cabeçalho com vários valores.

Você pode definir esses casos usando uma lista na declaração de tipo.

Você receberá todos os valores do cabeçalho duplicado como uma `list` Python.

Por exemplo, para declarar um cabeçalho de `X-Token` que pode aparecer mais de uma vez, você pode escrever:

* Validación de datos
* Documentación automática

## Configuraciones por defecto

Como los parámetros de query no están fijos en una parte del path pueden ser opcionales y pueden tener valores por defecto.

El ejemplo arriba tiene `skip=0` y `limit=10` como los valores por defecto.

Entonces, si vas a la URL:

```
http://127.0.0.1:8000/items/
```

Sería lo mismo que ir a:

```
http://127.0.0.1:8000/items/?skip=0&limit=10

```Python hl_lines="1"
{!../../../docs_src/python_types/tutorial005.py!}
```

### Tipos genéricos com parâmetros de tipo

Existem algumas estruturas de dados que podem conter outros valores, como `dict`, `list`, `set` e `tuple`. E os valores internos também podem ter seu próprio tipo.

Para declarar esses tipos e os tipos internos, você pode usar o módulo Python padrão `typing`.

Ele existe especificamente para suportar esses type hints.

## Corpos de `dict`s arbitrários

Você também pode declarar um corpo como um `dict` com chaves de algum tipo e valores de outro tipo.

Sem ter que saber de antemão quais são os nomes de campos/atributos válidos (como seria o caso dos modelos Pydantic).

Isso seria útil se você deseja receber chaves que ainda não conhece.

---

                }
            }

            task ok(type: SomeTask) {
                value = "42"
                def valueRef = value
                doFirst {
                    valueRef.set("123")
                }
            }

            task other {
                mustRunAfter(tasks.ok)
                def value = tasks.ok.value

    Cuando devuelves directamente una `Response`, como en los ejemplos anteriores, será devuelta directamente.

    No será serializado con el modelo, etc.

    Asegúrate de que la respuesta tenga los datos que quieras, y que los valores sean JSON válidos (si estás usando `JSONResponse`).

!!! note "Detalles Técnicos"
    También podrías utilizar `from starlette.responses import JSONResponse`.