pydantic

Logic for creating models.

BaseModel

BaseModel(__pydantic_self__, **data)

A base model class for creating Pydantic models.

Attributes:

Name	Type	Description
model_config	ConfigDict	Configuration settings for the model.
model_fields	dict[str, FieldInfo]	Metadata about the fields defined on the model. This replaces Model.__fields__ from Pydantic V1.
__class_vars__	set[str]	The names of classvars defined on the model.
__private_attributes__	dict[str, ModelPrivateAttr]	Metadata about the private attributes of the model.
__signature__	Signature	The signature for instantiating the model.
__pydantic_complete__	bool	Whether model building is completed, or if there are still undefined fields.
__pydantic_core_schema__	CoreSchema	The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
__pydantic_custom_init__	bool	Whether the model has a custom __init__ function.
__pydantic_decorators__	_decorators.DecoratorInfos	Metadata containing the decorators defined on the model. This replaces Model.__validators__ and Model.__root_validators__ from Pydantic V1.
__pydantic_generic_metadata__	_generics.PydanticGenericMetadata	Metadata for generic models; contains data used for a similar purpose to args, origin, parameters in typing-module generics. May eventually be replaced by these.
__pydantic_parent_namespace__	dict[str, Any] | None	Parent namespace of the model, used for automatic rebuilding of models.
__pydantic_post_init__	None | Literal['model_post_init']	The name of the post-init method for the model, if defined.
__pydantic_root_model__	bool	Whether the model is a RootModel.
__pydantic_serializer__	SchemaSerializer	The pydantic-core SchemaSerializer used to dump instances of the model.
__pydantic_validator__	SchemaValidator	The pydantic-core SchemaValidator used to validate instances of the model.
__pydantic_extra__	dict[str, Any] | None	An instance attribute with the values of extra fields from validation when model_config['extra'] == 'allow'.
__pydantic_fields_set__	set[str]	An instance attribute with the names of fields explicitly specified during validation.
__pydantic_private__	dict[str, Any] | None	Instance attribute with the values of private attributes set on the model instance.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Source code in pydantic/main.py

def __init__(__pydantic_self__, **data: Any) -> None:  # type: ignore
    """Create a new model by parsing and validating input data from keyword arguments.

    Raises ValidationError if the input data cannot be parsed to form a valid model.

    Uses `__pydantic_self__` instead of the more common `self` for the first arg to
    allow `self` as a field name.
    """
    # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks
    __tracebackhide__ = True
    __pydantic_self__.__pydantic_validator__.validate_python(data, self_instance=__pydantic_self__)

model_computed_fields property

model_computed_fields: dict[str, ComputedFieldInfo]

Get the computed fields of this model instance.

Returns:

Type	Description
dict[str, ComputedFieldInfo]	A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_extra property

model_extra: dict[str, Any] | None

Get extra fields set during validation.

Returns:

Type	Description
dict[str, Any] | None	A dictionary of extra fields, or None if config.extra is not set to "allow".

model_fields_set property

model_fields_set: set[str]

Returns the set of fields that have been set on this model instance.

Returns:

Type	Description
set[str]	A set of strings representing the fields that have been set, i.e. that were not filled from defaults.

copy

copy(
    *, include=None, exclude=None, update=None, deep=False
)

Returns a copy of the model.

This method is now deprecated; use model_copy instead. If you need include or exclude, use:

data = self.model_dump(include=include, exclude=exclude, round_trip=True)
data = {**data, **(update or {})}
copied = self.model_validate(data)

Parameters:

Name	Type	Description	Default
include	AbstractSetIntStr | MappingIntStrAny | None	Optional set or mapping specifying which fields to include in the copied model.	None
exclude	AbstractSetIntStr | MappingIntStrAny | None	Optional set or mapping specifying which fields to exclude in the copied model.	None
update	typing.Dict[str, Any] | None	Optional dictionary of field-value pairs to override field values in the copied model.	None
deep	bool	If True, the values of fields that are Pydantic models will be deep copied.	False

Returns:

Type	Description
Model	A copy of the model with included, excluded and updated fields as specified.

Source code in pydantic/main.py

@typing_extensions.deprecated(
    'The copy method is deprecated; use `model_copy` instead.', category=PydanticDeprecatedSince20
)
def copy(
    self: Model,
    *,
    include: AbstractSetIntStr | MappingIntStrAny | None = None,
    exclude: AbstractSetIntStr | MappingIntStrAny | None = None,
    update: typing.Dict[str, Any] | None = None,  # noqa UP006
    deep: bool = False,
) -> Model:  # pragma: no cover
    """Returns a copy of the model.

    This method is now deprecated; use `model_copy` instead. If you need `include` or `exclude`, use:

    ```py
    data = self.model_dump(include=include, exclude=exclude, round_trip=True)
    data = {**data, **(update or {})}
    copied = self.model_validate(data)
    ```

    Args:
        include: Optional set or mapping
            specifying which fields to include in the copied model.
        exclude: Optional set or mapping
            specifying which fields to exclude in the copied model.
        update: Optional dictionary of field-value pairs to override field values
            in the copied model.
        deep: If True, the values of fields that are Pydantic models will be deep copied.

    Returns:
        A copy of the model with included, excluded and updated fields as specified.
    """
    warnings.warn(
        'The `copy` method is deprecated; use `model_copy` instead. '
        'See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.',
        DeprecationWarning,
    )

    values = dict(
        _deprecated_copy_internals._iter(  # type: ignore
            self, to_dict=False, by_alias=False, include=include, exclude=exclude, exclude_unset=False
        ),
        **(update or {}),
    )
    if self.__pydantic_private__ is None:
        private = None
    else:
        private = {k: v for k, v in self.__pydantic_private__.items() if v is not PydanticUndefined}

    if self.__pydantic_extra__ is None:
        extra: dict[str, Any] | None = None
    else:
        extra = self.__pydantic_extra__.copy()
        for k in list(self.__pydantic_extra__):
            if k not in values:  # k was in the exclude
                extra.pop(k)
        for k in list(values):
            if k in self.__pydantic_extra__:  # k must have come from extra
                extra[k] = values.pop(k)

    # new `__pydantic_fields_set__` can have unset optional fields with a set value in `update` kwarg
    if update:
        fields_set = self.__pydantic_fields_set__ | update.keys()
    else:
        fields_set = set(self.__pydantic_fields_set__)

    # removing excluded fields from `__pydantic_fields_set__`
    if exclude:
        fields_set -= set(exclude)

    return _deprecated_copy_internals._copy_and_set_values(self, values, fields_set, extra, private, deep=deep)

model_construct classmethod

model_construct(_fields_set=None, **values)

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed. Behaves as if Config.extra = 'allow' was set since it adds all passed values

Parameters:

Name	Type	Description	Default
_fields_set	set[str] | None	The set of field names accepted for the Model instance.	None
values	Any	Trusted or pre-validated data dictionary.	{}

Returns:

Type	Description
Model	A new instance of the Model class with validated data.

Source code in pydantic/main.py

@classmethod
def model_construct(cls: type[Model], _fields_set: set[str] | None = None, **values: Any) -> Model:
    """Creates a new instance of the `Model` class with validated data.

    Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
    Default values are respected, but no other validation is performed.
    Behaves as if `Config.extra = 'allow'` was set since it adds all passed values

    Args:
        _fields_set: The set of field names accepted for the Model instance.
        values: Trusted or pre-validated data dictionary.

    Returns:
        A new instance of the `Model` class with validated data.
    """
    m = cls.__new__(cls)
    fields_values: dict[str, Any] = {}
    defaults: dict[str, Any] = {}  # keeping this separate from `fields_values` helps us compute `_fields_set`
    for name, field in cls.model_fields.items():
        if field.alias and field.alias in values:
            fields_values[name] = values.pop(field.alias)
        elif name in values:
            fields_values[name] = values.pop(name)
        elif not field.is_required():
            defaults[name] = field.get_default(call_default_factory=True)
    if _fields_set is None:
        _fields_set = set(fields_values.keys())
    fields_values.update(defaults)

    _extra: dict[str, Any] | None = None
    if cls.model_config.get('extra') == 'allow':
        _extra = {}
        for k, v in values.items():
            _extra[k] = v
    else:
        fields_values.update(values)
    _object_setattr(m, '__dict__', fields_values)
    _object_setattr(m, '__pydantic_fields_set__', _fields_set)
    if not cls.__pydantic_root_model__:
        _object_setattr(m, '__pydantic_extra__', _extra)

    if cls.__pydantic_post_init__:
        m.model_post_init(None)
    elif not cls.__pydantic_root_model__:
        # Note: if there are any private attributes, cls.__pydantic_post_init__ would exist
        # Since it doesn't, that means that `__pydantic_private__` should be set to None
        _object_setattr(m, '__pydantic_private__', None)

    return m

model_copy

model_copy(*, update=None, deep=False)

Returns a copy of the model.

Parameters:

Name	Type	Description	Default
update	dict[str, Any] | None	Values to change/add in the new model. Note: the data is not validated before creating the new model. You should trust this data.	None
deep	bool	Set to True to make a deep copy of the model.	False

Returns:

Type	Description
Model	New model instance.

Source code in pydantic/main.py

def model_copy(self: Model, *, update: dict[str, Any] | None = None, deep: bool = False) -> Model:
    """Returns a copy of the model.

    Args:
        update: Values to change/add in the new model. Note: the data is not validated
            before creating the new model. You should trust this data.
        deep: Set to `True` to make a deep copy of the model.

    Returns:
        New model instance.
    """
    copied = self.__deepcopy__() if deep else self.__copy__()
    if update:
        if self.model_config.get('extra') == 'allow':
            for k, v in update.items():
                if k in self.model_fields:
                    copied.__dict__[k] = v
                else:
                    if copied.__pydantic_extra__ is None:
                        copied.__pydantic_extra__ = {}
                    copied.__pydantic_extra__[k] = v
        else:
            copied.__dict__.update(update)
        copied.__pydantic_fields_set__.update(update.keys())
    return copied

model_dump

model_dump(
    *,
    mode="python",
    include=None,
    exclude=None,
    by_alias=False,
    exclude_unset=False,
    exclude_defaults=False,
    exclude_none=False,
    round_trip=False,
    warnings=True
)

Usage Documentation

model.model_dump(...)

Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.

Parameters:

Name	Type	Description	Default
mode	Literal['json', 'python'] | str	The mode in which to_python should run. If mode is 'json', the dictionary will only contain JSON serializable types. If mode is 'python', the dictionary may contain any Python objects.	'python'
include	IncEx	A list of fields to include in the output.	None
exclude	IncEx	A list of fields to exclude from the output.	None
by_alias	bool	Whether to use the field's alias in the dictionary key if defined.	False
exclude_unset	bool	Whether to exclude fields that are unset or None from the output.	False
exclude_defaults	bool	Whether to exclude fields that are set to their default value from the output.	False
exclude_none	bool	Whether to exclude fields that have a value of None from the output.	False
round_trip	bool	Whether to enable serialization and deserialization round-trip support.	False
warnings	bool	Whether to log warnings when invalid fields are encountered.	True

Returns:

Type	Description
dict[str, Any]	A dictionary representation of the model.

Source code in pydantic/main.py

def model_dump(
    self,
    *,
    mode: Literal['json', 'python'] | str = 'python',
    include: IncEx = None,
    exclude: IncEx = None,
    by_alias: bool = False,
    exclude_unset: bool = False,
    exclude_defaults: bool = False,
    exclude_none: bool = False,
    round_trip: bool = False,
    warnings: bool = True,
) -> dict[str, Any]:
    """Usage docs: https://docs.pydantic.dev/dev-v2/usage/serialization/#modelmodel_dump

    Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.

    Args:
        mode: The mode in which `to_python` should run.
            If mode is 'json', the dictionary will only contain JSON serializable types.
            If mode is 'python', the dictionary may contain any Python objects.
        include: A list of fields to include in the output.
        exclude: A list of fields to exclude from the output.
        by_alias: Whether to use the field's alias in the dictionary key if defined.
        exclude_unset: Whether to exclude fields that are unset or None from the output.
        exclude_defaults: Whether to exclude fields that are set to their default value from the output.
        exclude_none: Whether to exclude fields that have a value of `None` from the output.
        round_trip: Whether to enable serialization and deserialization round-trip support.
        warnings: Whether to log warnings when invalid fields are encountered.

    Returns:
        A dictionary representation of the model.
    """
    return self.__pydantic_serializer__.to_python(
        self,
        mode=mode,
        by_alias=by_alias,
        include=include,
        exclude=exclude,
        exclude_unset=exclude_unset,
        exclude_defaults=exclude_defaults,
        exclude_none=exclude_none,
        round_trip=round_trip,
        warnings=warnings,
    )

model_dump_json

model_dump_json(
    *,
    indent=None,
    include=None,
    exclude=None,
    by_alias=False,
    exclude_unset=False,
    exclude_defaults=False,
    exclude_none=False,
    round_trip=False,
    warnings=True
)

Usage Documentation

model.model_dump_json(...)

Generates a JSON representation of the model using Pydantic's to_json method.

Parameters:

Name	Type	Description	Default
indent	int | None	Indentation to use in the JSON output. If None is passed, the output will be compact.	None
include	IncEx	Field(s) to include in the JSON output. Can take either a string or set of strings.	None
exclude	IncEx	Field(s) to exclude from the JSON output. Can take either a string or set of strings.	None
by_alias	bool	Whether to serialize using field aliases.	False
exclude_unset	bool	Whether to exclude fields that have not been explicitly set.	False
exclude_defaults	bool	Whether to exclude fields that have the default value.	False
exclude_none	bool	Whether to exclude fields that have a value of None.	False
round_trip	bool	Whether to use serialization/deserialization between JSON and class instance.	False
warnings	bool	Whether to show any warnings that occurred during serialization.	True

Returns:

Type	Description
str	A JSON string representation of the model.

Source code in pydantic/main.py

def model_dump_json(
    self,
    *,
    indent: int | None = None,
    include: IncEx = None,
    exclude: IncEx = None,
    by_alias: bool = False,
    exclude_unset: bool = False,
    exclude_defaults: bool = False,
    exclude_none: bool = False,
    round_trip: bool = False,
    warnings: bool = True,
) -> str:
    """Usage docs: https://docs.pydantic.dev/dev-v2/usage/serialization/#modelmodel_dump_json

    Generates a JSON representation of the model using Pydantic's `to_json` method.

    Args:
        indent: Indentation to use in the JSON output. If None is passed, the output will be compact.
        include: Field(s) to include in the JSON output. Can take either a string or set of strings.
        exclude: Field(s) to exclude from the JSON output. Can take either a string or set of strings.
        by_alias: Whether to serialize using field aliases.
        exclude_unset: Whether to exclude fields that have not been explicitly set.
        exclude_defaults: Whether to exclude fields that have the default value.
        exclude_none: Whether to exclude fields that have a value of `None`.
        round_trip: Whether to use serialization/deserialization between JSON and class instance.
        warnings: Whether to show any warnings that occurred during serialization.

    Returns:
        A JSON string representation of the model.
    """
    return self.__pydantic_serializer__.to_json(
        self,
        indent=indent,
        include=include,
        exclude=exclude,
        by_alias=by_alias,
        exclude_unset=exclude_unset,
        exclude_defaults=exclude_defaults,
        exclude_none=exclude_none,
        round_trip=round_trip,
        warnings=warnings,
    ).decode()

model_json_schema classmethod

model_json_schema(
    by_alias=True,
    ref_template=DEFAULT_REF_TEMPLATE,
    schema_generator=GenerateJsonSchema,
    mode="validation",
)

Generates a JSON schema for a model class.

To override the logic used to generate the JSON schema, you can create a subclass of GenerateJsonSchema with your desired modifications, then override this method on a custom base class and set the default value of schema_generator to be your subclass.

Parameters:

Name	Type	Description	Default
by_alias	bool	Whether to use attribute aliases or not.	True
ref_template	str	The reference template.	DEFAULT_REF_TEMPLATE
schema_generator	type[GenerateJsonSchema]	The JSON schema generator.	GenerateJsonSchema
mode	JsonSchemaMode	The mode in which to generate the schema.	'validation'

Returns:

Type	Description
dict[str, Any]	The JSON schema for the given model class.

Source code in pydantic/main.py

@classmethod
def model_json_schema(
    cls,
    by_alias: bool = True,
    ref_template: str = DEFAULT_REF_TEMPLATE,
    schema_generator: type[GenerateJsonSchema] = GenerateJsonSchema,
    mode: JsonSchemaMode = 'validation',
) -> dict[str, Any]:
    """Generates a JSON schema for a model class.

    To override the logic used to generate the JSON schema, you can create a subclass of `GenerateJsonSchema`
    with your desired modifications, then override this method on a custom base class and set the default
    value of `schema_generator` to be your subclass.

    Args:
        by_alias: Whether to use attribute aliases or not.
        ref_template: The reference template.
        schema_generator: The JSON schema generator.
        mode: The mode in which to generate the schema.

    Returns:
        The JSON schema for the given model class.
    """
    return model_json_schema(
        cls, by_alias=by_alias, ref_template=ref_template, schema_generator=schema_generator, mode=mode
    )

model_parametrized_name classmethod

model_parametrized_name(params)

Compute the class name for parametrizations of generic classes.

This method can be overridden to achieve a custom naming scheme for generic BaseModels.

Parameters:

Name	Type	Description	Default
params	tuple[type[Any], ...]	Tuple of types of the class. Given a generic class Model with 2 type variables and a concrete model Model[str, int], the value (str, int) would be passed to params.	required

Returns:

Type	Description
str	String representing the new class where params are passed to cls as type variables.

Raises:

Type	Description
TypeError	Raised when trying to generate concrete names for non-generic models.

Source code in pydantic/main.py

@classmethod
def model_parametrized_name(cls, params: tuple[type[Any], ...]) -> str:
    """Compute the class name for parametrizations of generic classes.

    This method can be overridden to achieve a custom naming scheme for generic BaseModels.

    Args:
        params: Tuple of types of the class. Given a generic class
            `Model` with 2 type variables and a concrete model `Model[str, int]`,
            the value `(str, int)` would be passed to `params`.

    Returns:
        String representing the new class where `params` are passed to `cls` as type variables.

    Raises:
        TypeError: Raised when trying to generate concrete names for non-generic models.
    """
    if not issubclass(cls, typing.Generic):  # type: ignore[arg-type]
        raise TypeError('Concrete names should only be generated for generic models.')

    # Any strings received should represent forward references, so we handle them specially below.
    # If we eventually move toward wrapping them in a ForwardRef in __class_getitem__ in the future,
    # we may be able to remove this special case.
    param_names = [param if isinstance(param, str) else _repr.display_as_type(param) for param in params]
    params_component = ', '.join(param_names)
    return f'{cls.__name__}[{params_component}]'

model_post_init

model_post_init(__context)

Override this method to perform additional initialization after __init__ and model_construct. This is useful if you want to do some validation that requires the entire model to be initialized.

Source code in pydantic/main.py

def model_post_init(self, __context: Any) -> None:
    """Override this method to perform additional initialization after `__init__` and `model_construct`.
    This is useful if you want to do some validation that requires the entire model to be initialized.
    """
    pass

model_rebuild classmethod

model_rebuild(
    *,
    force=False,
    raise_errors=True,
    _parent_namespace_depth=2,
    _types_namespace=None
)

Try to rebuild the pydantic-core schema for the model.

This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.

Parameters:

Name	Type	Description	Default
force	bool	Whether to force the rebuilding of the model schema, defaults to False.	False
raise_errors	bool	Whether to raise errors, defaults to True.	True
_parent_namespace_depth	int	The depth level of the parent namespace, defaults to 2.	2
_types_namespace	dict[str, Any] | None	The types namespace, defaults to None.	None

Returns:

Type	Description
bool | None	Returns None if the schema is already "complete" and rebuilding was not required.
bool | None	If rebuilding was required, returns True if rebuilding was successful, otherwise False.

Source code in pydantic/main.py

@classmethod
def model_rebuild(
    cls,
    *,
    force: bool = False,
    raise_errors: bool = True,
    _parent_namespace_depth: int = 2,
    _types_namespace: dict[str, Any] | None = None,
) -> bool | None:
    """Try to rebuild the pydantic-core schema for the model.

    This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
    the initial attempt to build the schema, and automatic rebuilding fails.

    Args:
        force: Whether to force the rebuilding of the model schema, defaults to `False`.
        raise_errors: Whether to raise errors, defaults to `True`.
        _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
        _types_namespace: The types namespace, defaults to `None`.

    Returns:
        Returns `None` if the schema is already "complete" and rebuilding was not required.
        If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
    """
    if not force and cls.__pydantic_complete__:
        return None
    else:
        if _types_namespace is not None:
            types_namespace: dict[str, Any] | None = _types_namespace.copy()
        else:
            if _parent_namespace_depth > 0:
                frame_parent_ns = _typing_extra.parent_frame_namespace(parent_depth=_parent_namespace_depth) or {}
                cls_parent_ns = cls.__pydantic_parent_namespace__ or {}
                cls.__pydantic_parent_namespace__ = {**cls_parent_ns, **frame_parent_ns}

            types_namespace = cls.__pydantic_parent_namespace__

            types_namespace = _typing_extra.get_cls_types_namespace(cls, types_namespace)
        return _model_construction.complete_model_class(
            cls,
            cls.__name__,
            _config.ConfigWrapper(cls.model_config, check=False),
            raise_errors=raise_errors,
            types_namespace=types_namespace,
        )

model_validate classmethod

model_validate(
    obj, *, strict=None, from_attributes=None, context=None
)

Validate a pydantic model instance.

Parameters:

Name	Type	Description	Default
obj	Any	The object to validate.	required
strict	bool | None	Whether to raise an exception on invalid fields.	None
from_attributes	bool | None	Whether to extract data from object attributes.	None
context	dict[str, Any] | None	Additional context to pass to the validator.	None

Raises:

Type	Description
ValidationError	If the object could not be validated.

Returns:

Type	Description
Model	The validated model instance.

Source code in pydantic/main.py

@classmethod
def model_validate(
    cls: type[Model],
    obj: Any,
    *,
    strict: bool | None = None,
    from_attributes: bool | None = None,
    context: dict[str, Any] | None = None,
) -> Model:
    """Validate a pydantic model instance.

    Args:
        obj: The object to validate.
        strict: Whether to raise an exception on invalid fields.
        from_attributes: Whether to extract data from object attributes.
        context: Additional context to pass to the validator.

    Raises:
        ValidationError: If the object could not be validated.

    Returns:
        The validated model instance.
    """
    # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks
    __tracebackhide__ = True
    return cls.__pydantic_validator__.validate_python(
        obj, strict=strict, from_attributes=from_attributes, context=context
    )

model_validate_json classmethod

model_validate_json(
    json_data, *, strict=None, context=None
)

Validate the given JSON data against the Pydantic model.

Parameters:

Name	Type	Description	Default
json_data	str | bytes | bytearray	The JSON data to validate.	required
strict	bool | None	Whether to enforce types strictly.	None
context	dict[str, Any] | None	Extra variables to pass to the validator.	None

Returns:

Type	Description
Model	The validated Pydantic model.

Raises:

Type	Description
ValueError	If json_data is not a JSON string.

Source code in pydantic/main.py

@classmethod
def model_validate_json(
    cls: type[Model],
    json_data: str | bytes | bytearray,
    *,
    strict: bool | None = None,
    context: dict[str, Any] | None = None,
) -> Model:
    """Validate the given JSON data against the Pydantic model.

    Args:
        json_data: The JSON data to validate.
        strict: Whether to enforce types strictly.
        context: Extra variables to pass to the validator.

    Returns:
        The validated Pydantic model.

    Raises:
        ValueError: If `json_data` is not a JSON string.
    """
    # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks
    __tracebackhide__ = True
    return cls.__pydantic_validator__.validate_json(json_data, strict=strict, context=context)

create_model

create_model(
    __model_name,
    *,
    __config__=None,
    __base__=None,
    __module__=__name__,
    __validators__=None,
    __cls_kwargs__=None,
    __slots__=None,
    **field_definitions
)

Dynamically creates and returns a new Pydantic model.

Parameters:

Name	Type	Description	Default
__model_name	str	The name of the newly created model.	required
__config__	ConfigDict | None	The configuration of the new model.	None
__base__	type[Model] | tuple[type[Model], ...] | None	The base class for the new model.	None
__module__	str	The name of the module that the model belongs to.	__name__
__validators__	dict[str, AnyClassMethod] | None	A dictionary of methods that validate fields.	None
__cls_kwargs__	dict[str, Any] | None	A dictionary of keyword arguments for class creation.	None
__slots__	tuple[str, ...] | None	Deprecated. Should not be passed to create_model.	None
**field_definitions	Any	Attributes of the new model. They should be passed in the format: <name>=(<type>, <default value>) or <name>=<default value>. For more complex cases, they can be passed in the format: <name>=<Field> or <name>=(<type>, <FieldInfo>).	{}

Returns:

Type	Description
type[Model]	The newly created model.

Raises:

Type	Description
PydanticUserError	If __base__ and __config__ are both passed.

Source code in pydantic/main.py

def create_model(
    __model_name: str,
    *,
    __config__: ConfigDict | None = None,
    __base__: type[Model] | tuple[type[Model], ...] | None = None,
    __module__: str = __name__,
    __validators__: dict[str, AnyClassMethod] | None = None,
    __cls_kwargs__: dict[str, Any] | None = None,
    __slots__: tuple[str, ...] | None = None,
    **field_definitions: Any,
) -> type[Model]:
    """Dynamically creates and returns a new Pydantic model.

    Args:
        __model_name: The name of the newly created model.
        __config__: The configuration of the new model.
        __base__: The base class for the new model.
        __module__: The name of the module that the model belongs to.
        __validators__: A dictionary of methods that validate
            fields.
        __cls_kwargs__: A dictionary of keyword arguments for class creation.
        __slots__: Deprecated. Should not be passed to `create_model`.
        **field_definitions: Attributes of the new model. They should be passed in the format:
            `<name>=(<type>, <default value>)` or `<name>=<default value>`. For more complex cases, they can be
            passed in the format: `<name>=<Field>` or `<name>=(<type>, <FieldInfo>)`.

    Returns:
        The newly created model.

    Raises:
        PydanticUserError: If `__base__` and `__config__` are both passed.
    """
    if __slots__ is not None:
        # __slots__ will be ignored from here on
        warnings.warn('__slots__ should not be passed to create_model', RuntimeWarning)

    if __base__ is not None:
        if __config__ is not None:
            raise PydanticUserError(
                'to avoid confusion `__config__` and `__base__` cannot be used together',
                code='create-model-config-base',
            )
        if not isinstance(__base__, tuple):
            __base__ = (__base__,)
    else:
        __base__ = (typing.cast(typing.Type['Model'], BaseModel),)

    __cls_kwargs__ = __cls_kwargs__ or {}

    fields = {}
    annotations = {}

    for f_name, f_def in field_definitions.items():
        if not _fields.is_valid_field_name(f_name):
            warnings.warn(f'fields may not start with an underscore, ignoring "{f_name}"', RuntimeWarning)
        if isinstance(f_def, tuple):
            f_def = typing.cast('tuple[str, Any]', f_def)
            try:
                f_annotation, f_value = f_def
            except ValueError as e:
                raise PydanticUserError(
                    'Field definitions should be a `(<type>, <default>)`.',
                    code='create-model-field-definitions',
                ) from e
        else:
            f_annotation, f_value = None, f_def

        if f_annotation:
            annotations[f_name] = f_annotation
        fields[f_name] = f_value

    namespace: dict[str, Any] = {'__annotations__': annotations, '__module__': __module__}
    if __validators__:
        namespace.update(__validators__)
    namespace.update(fields)
    if __config__:
        namespace['model_config'] = _config.ConfigWrapper(__config__).config_dict
    resolved_bases = types.resolve_bases(__base__)
    meta, ns, kwds = types.prepare_class(__model_name, resolved_bases, kwds=__cls_kwargs__)
    if resolved_bases is not __base__:
        ns['__orig_bases__'] = __base__
    namespace.update(ns)
    return meta(__model_name, resolved_bases, namespace, __pydantic_reset_parent_namespace__=False, **kwds)