Skip to content
Pydantic Docs

Dynamic models

Models can be created dynamically using the create_model() factory function.

In this example, we will show how to dynamically derive a model from an existing one, making every field optional. To achieve this, we will make use of the model_fields model class attribute, and derive new annotations from the field definitions to be passed to the create_model() factory. Of course, this example can apply to any use case where you need to derive a new model from another (remove default values, add aliases, etc).

from typing import Annotated, Union

from pydantic import BaseModel, Field, create_model


def make_fields_optional(model_cls: type[BaseModel]) -> type[BaseModel]:
  new_fields = {}

  for f_name, f_info in model_cls.model_fields.items():
      f_dct = f_info.asdict()
      new_fields[f_name] = (
          Annotated[(Union[f_dct['annotation'], None], *f_dct['metadata'], Field(**f_dct['attributes']))],
          None,
      )

  return create_model(
      f'{type.__name__}Optional',
      __base__=model_cls,  # (1)
      **new_fields,
  )

Using the original model as a base will inherit the validators, computed fields, etc.

The parent fields are overridden by the ones we define.

For each field, we generate a dictionary representation of the FieldInfo instance using the asdict() method, containing the annotation, metadata and attributes.

With the following model:

class Model(BaseModel):
    f: Annotated[int, Field(gt=1), WithJsonSchema({'extra': 'data'}), Field(title='F')] = 1

The FieldInfo instance of f will have three items in its dictionary representation:

  • annotation: int.
  • metadata: A list containing the type-specific constraints and other metadata: [Gt(1), WithJsonSchema(\{'extra': 'data'\})].
  • attributes: The remaining field-specific attributes: \{'title': 'F'\}.

With that in mind, we can recreate an annotation that “simulates” the one from the original model:

new_annotation = Annotated[(
  f_dct['annotation'] | None,  # (1)
  *f_dct['metadata'],  # (2)
  Field(**f_dct['attributes']),  # (3)
)]

We create a new annotation from the existing one, but adding None as an allowed value (in our previous example, this is equivalent to int | None).

We unpack the metadata to be reused (in our previous example, this is equivalent to specifying Field(gt=1) and WithJsonSchema({'extra': 'data'}) as Annotated metadata).

We specify the field-specific attributes by using the Field() function (in our previous example, this is equivalent to Field(title='F')).

and specify None as a default value (the second element of the tuple for the field definition accepted by create_model()).

Here is a demonstration of our factory function:

from pydantic import BaseModel, Field


class Model(BaseModel):
    a: Annotated[int, Field(gt=1)]


ModelOptional = make_fields_optional(Model)

m = ModelOptional()
print(m.a)
#> None

A couple notes on the implementation:

  • Our make_fields_optional() function is defined as returning an arbitrary Pydantic model class (-> type[BaseModel]). An alternative solution can be to use a type variable to preserve the input class:
ModelTypeT = TypeVar('ModelTypeT', bound=type[BaseModel])

def make_fields_optional(model_cls: ModelTypeT) -> ModelTypeT:
    ...

However, note that static type checkers won’t be able to understand that all fields are now optional.

  • The experimental MISSING sentinel can be used as an alternative to None for the default values. Simply replace None by MISSING in the new annotation and default value.

  • You might be tempted to make a copy of the original FieldInfo instances, add a default and/or perform other mutations, to then reuse it as Annotated metadata. While this may work in some cases, it is not a supported pattern, and could break or be deprecated at any point. We strongly encourage using the pattern from this example instead.