* @param value4
     *            The fourth value
     * @return A tuple of four values
     */
    public static <T1, T2, T3, T4> Tuple4<T1, T2, T3, T4> tuple4(final T1 value1, final T2 value2, final T3 value3, final T4 value4) {
        return new Tuple4<>(value1, value2, value3, value4);
    }

    /**
     * Constructs an instance.
     */
    public Tuple4() {
    }

    /**
     * Constructs an instance.
     *

     *            The fifth value
     * @return A tuple of five values
     */
    public static <T1, T2, T3, T4, T5> Tuple5<T1, T2, T3, T4, T5> tuple5(final T1 value1, final T2 value2, final T3 value3, final T4 value4,
            final T5 value5) {
        return new Tuple5<>(value1, value2, value3, value4, value5);
    }

    /**
     * Constructs an instance.
     */
    public Tuple5() {
    }

    /**

     * @param value3
     *            The third value
     * @return A tuple of three values
     */
    public static <T1, T2, T3> Tuple3<T1, T2, T3> tuple3(final T1 value1, final T2 value2, final T3 value3) {
        return new Tuple3<>(value1, value2, value3);
    }

    /**
     * Constructs an instance.
     */
    public Tuple3() {
    }

    /**
     * Constructs an instance.
     *

import types
from collections.abc import Callable
from enum import Enum
from typing import Any, TypeVar, Union

from pydantic import BaseModel
from pydantic.main import IncEx as IncEx

DecoratedCallable = TypeVar("DecoratedCallable", bound=Callable[..., Any])
UnionType = getattr(types, "UnionType", Union)
ModelNameMap = dict[type[BaseModel] | type[Enum], str]

    /**
     * Creates a thumbnail generation task.
     * @param path The path to the source document.
     * @param docMap The document map containing metadata.
     * @return A tuple containing task information.
     */
    Tuple3<String, String, String> createTask(String path, Map<String, Object> docMap);

package loggertypes

// TargetType indicates type of the target e.g. console, http, kafka
type TargetType uint8

//go:generate stringer -type=TargetType -trimprefix=Target $GOFILE

// Constants for target types
const (
	_ TargetType = iota
	TargetConsole
	TargetHTTP
	TargetKafka
)

// TargetStats contains statistics for a target.
type TargetStats struct {

	return pattern
}

// Rules - event rules
type Rules map[string]TargetIDSet

// Add - adds pattern and target ID.
func (rules Rules) Add(pattern string, targetID TargetID) {
	rules[pattern] = NewTargetIDSet(targetID).Union(rules[pattern])
}

// MatchSimple - returns true one of the matching object name in rules.
func (rules Rules) MatchSimple(objectName string) bool {
	for pattern := range rules {

def post_form_param_list(items: list = Form()):
    return items


@app.post("/form/python-set")
def post_form_param_set(items: set = Form()):
    return items


@app.post("/form/python-tuple")
def post_form_param_tuple(items: tuple = Form()):
    return items


client = TestClient(app)


def test_python_list_param_as_form():
    response = client.post(

* Documentación automática

## Tipos especiales y validación { #special-types-and-validation }

Además de tipos singulares normales como `str`, `int`, `float`, etc., puedes usar tipos singulares más complejos que heredan de `str`.

Para ver todas las opciones que tienes, Revisa [Resumen de tipos de Pydantic](https://docs.pydantic.dev/latest/concepts/types/). Verás algunos ejemplos en el siguiente capítulo.

WithArgsTypes: tuple[Any, ...] = (
    typing._GenericAlias,  # type: ignore[attr-defined]
    types.GenericAlias,
    types.UnionType,
)  # pyright: ignore[reportAttributeAccessIssue]

PYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(".")[:2])


sequence_annotation_to_type = {
    Sequence: list,
    list: list,
    tuple: tuple,
    set: set,
    frozenset: frozenset,