sda.dashboard.api.models
========================

.. py:module:: sda.dashboard.api.models

.. autoapi-nested-parse::

   Pydantic models for SDA FastAPI endpoints.



Classes
-------

.. autoapisummary::

   sda.dashboard.api.models.TestInfoResponse
   sda.dashboard.api.models.ColumnsRequest
   sda.dashboard.api.models.ColumnsResponse
   sda.dashboard.api.models.FiltersRequest
   sda.dashboard.api.models.ColumnMeta
   sda.dashboard.api.models.ColumnOptionsRequest
   sda.dashboard.api.models.ColumnOptionsResponse
   sda.dashboard.api.models.FilterAllocationResponse
   sda.dashboard.api.models.FilterCountResponse
   sda.dashboard.api.models.QueryRequest
   sda.dashboard.api.models.QueryResponse
   sda.dashboard.api.models.ScatterPlotRequest
   sda.dashboard.api.models.DownloadScriptRequest
   sda.dashboard.api.models.DownloadScriptResponse
   sda.dashboard.api.models.ThemeResponse
   sda.dashboard.api.models.HealthResponse


Module Contents
---------------

.. py:class:: TestInfoResponse(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: columns
      :type:  List[str]


   .. py:attribute:: default_columns
      :type:  List[str]


   .. py:attribute:: row_count
      :type:  int


   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: ColumnsRequest(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: test_names
      :type:  List[str]


   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: ColumnsResponse(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: columns
      :type:  List[str]


   .. py:attribute:: default_columns
      :type:  List[str]


   .. py:attribute:: failed_tests
      :type:  List[str]


   .. py:attribute:: empty_columns
      :type:  List[str]
      :value: []



   .. py:attribute:: column_test_map
      :type:  Dict[str, List[str]]
      :value: None



   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: FiltersRequest(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: test_names
      :type:  List[str]


   .. py:attribute:: columns
      :type:  Optional[List[str]]
      :value: None



   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: ColumnMeta(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   Lightweight per-column metadata returned by POST /api/filters.

   Options are NOT included here — they are loaded lazily via
   POST /api/column-options when the user expands a filter slot.


   .. py:attribute:: name
      :type:  str


   .. py:attribute:: dtype
      :type:  str


   .. py:attribute:: unique_count
      :type:  int


   .. py:attribute:: min
      :type:  Optional[float]
      :value: None



   .. py:attribute:: max
      :type:  Optional[float]
      :value: None



   .. py:attribute:: histogram
      :type:  Optional[List[int]]
      :value: None



   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: ColumnOptionsRequest(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: test_names
      :type:  List[str]


   .. py:attribute:: column
      :type:  str


   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: ColumnOptionsResponse(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: column
      :type:  str


   .. py:attribute:: options
      :type:  List[Any]


   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: FilterAllocationResponse(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: columns_meta
      :type:  List[ColumnMeta]
      :value: []



   .. py:attribute:: filter_allocation
      :type:  List[str]


   .. py:attribute:: filter_options
      :type:  Dict[str, List[Any]]


   .. py:attribute:: total_row_count
      :type:  int
      :value: 0



   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: FilterCountResponse(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: row_count
      :type:  int


   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: QueryRequest(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: test_names
      :type:  List[str]


   .. py:attribute:: columns
      :type:  Optional[List[str]]
      :value: None



   .. py:attribute:: filters
      :type:  Optional[Dict[str, List[Any]]]
      :value: None



   .. py:attribute:: range_filters
      :type:  Optional[Dict[str, List[float]]]
      :value: None



   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: QueryResponse(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: data
      :type:  List[Dict[str, Any]]


   .. py:attribute:: row_count
      :type:  int


   .. py:attribute:: columns
      :type:  List[str]


   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: ScatterPlotRequest(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: test_names
      :type:  List[str]


   .. py:attribute:: columns
      :type:  Optional[List[str]]
      :value: None



   .. py:attribute:: filters
      :type:  Optional[Dict[str, List[Any]]]
      :value: None



   .. py:attribute:: range_filters
      :type:  Optional[Dict[str, List[float]]]
      :value: None



   .. py:attribute:: x
      :type:  str


   .. py:attribute:: y
      :type:  str


   .. py:attribute:: color
      :type:  Optional[str]
      :value: None



   .. py:attribute:: connect_points
      :type:  bool
      :value: None



   .. py:attribute:: connect_sort_by
      :type:  Optional[str]
      :value: None



   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: DownloadScriptRequest(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: test_names
      :type:  List[str]


   .. py:attribute:: columns
      :type:  Optional[List[str]]
      :value: None



   .. py:attribute:: filters
      :type:  Optional[Dict[str, List[Any]]]
      :value: None



   .. py:attribute:: range_filters
      :type:  Optional[Dict[str, List[float]]]
      :value: None



   .. py:attribute:: plot_format
      :type:  str
      :value: 'plotly'



   .. py:attribute:: plot_type
      :type:  str
      :value: 'scatter'



   .. py:attribute:: x
      :type:  Optional[str]
      :value: None



   .. py:attribute:: y
      :type:  Optional[str]
      :value: None



   .. py:attribute:: color
      :type:  Optional[str]
      :value: None



   .. py:attribute:: connect_points
      :type:  bool
      :value: False



   .. py:attribute:: connect_sort_by
      :type:  Optional[str]
      :value: None



   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: DownloadScriptResponse(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: script
      :type:  str


   .. py:attribute:: filename
      :type:  str


   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: ThemeResponse(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: theme
      :type:  str


   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod:



.. py:class:: HealthResponse(/, **data)

   Bases: :py:obj:`pydantic.BaseModel`


   !!! abstract "Usage Documentation"
       [Models](../concepts/models.md)

   A base class for creating Pydantic models.

   Attributes:
       __class_vars__: The names of the class variables defined on the model.
       __private_attributes__: Metadata about the private attributes of the model.
       __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.

       __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
       __pydantic_core_schema__: The core schema of the model.
       __pydantic_custom_init__: Whether the model has a custom `__init__` function.
       __pydantic_decorators__: Metadata containing the decorators defined on the model.
           This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
       __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
           The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
           and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
           and the `parameter` item maps to the `__parameter__` attribute of generic classes.
       __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
       __pydantic_post_init__: The name of the post-init method for the model, if defined.
       __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
       __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
       __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.

       __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
       __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.

       __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
           is set to `'allow'`.
       __pydantic_fields_set__: The names of fields explicitly set during instantiation.
       __pydantic_private__: Values of private attributes set on the model instance.


   .. py:attribute:: status
      :type:  str


   .. py:attribute:: model_config
      :type:  ClassVar[pydantic.config.ConfigDict]

      Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].


   .. py:method:: model_fields()
      :classmethod:


      A mapping of field names to their respective [`FieldInfo`][pydantic.fields.FieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:method:: model_computed_fields()
      :classmethod:


      A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

      !!! warning
          Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
          Instead, you should access this attribute from the model class.



   .. py:property:: model_extra
      :type: dict[str, Any] | None


      Get extra fields set during validation.

      Returns:
          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.


   .. py:property:: model_fields_set
      :type: set[str]


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

      Returns:
          A set of strings representing the fields that have been set,
              i.e. that were not filled from defaults.


   .. py:method:: model_construct(_fields_set = None, **values)
      :classmethod:


      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.

      !!! note
          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
          an error if extra values are passed, but they will be ignored.

      Args:
          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
              Otherwise, the field names from the `values` argument will be used.
          values: Trusted or pre-validated data dictionary.

      Returns:
          A new instance of the `Model` class with validated data.



   .. py:method:: model_copy(*, update = None, deep = False)

      !!! abstract "Usage Documentation"
          [`model_copy`](../concepts/models.md#model-copy)

      Returns a copy of the model.

      !!! note
          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
          might have unexpected side effects if you store anything in it, on top of the model
          fields (e.g. the value of [cached properties][functools.cached_property]).

      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.



   .. py:method:: model_dump(*, mode = 'python', include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump`](../concepts/serialization.md#python-mode)

      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 output will only contain JSON serializable types.
              If mode is 'python', the output may contain non-JSON-serializable Python objects.
          include: A set of fields to include in the output.
          exclude: A set of fields to exclude from the output.
          context: Additional context to pass to the serializer.
          by_alias: Whether to use the field's alias in the dictionary key if defined.
          exclude_unset: Whether to exclude fields that have not been explicitly set.
          exclude_defaults: Whether to exclude fields that are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A dictionary representation of the model.



   .. py:method:: model_dump_json(*, indent = None, ensure_ascii = False, include = None, exclude = None, context = None, by_alias = None, exclude_unset = False, exclude_defaults = False, exclude_none = False, exclude_computed_fields = False, round_trip = False, warnings = True, fallback = None, serialize_as_any = False, polymorphic_serialization = None)

      !!! abstract "Usage Documentation"
          [`model_dump_json`](../concepts/serialization.md#json-mode)

      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.
          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
              If `False` (the default), these characters will be output as-is.
          include: Field(s) to include in the JSON output.
          exclude: Field(s) to exclude from the JSON output.
          context: Additional context to pass to the serializer.
          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 are set to their default value.
          exclude_none: Whether to exclude fields that have a value of `None`.
          exclude_computed_fields: Whether to exclude computed fields.
              While this can be useful for round-tripping, it is usually recommended to use the dedicated
              `round_trip` parameter instead.
          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
          fallback: A function to call when an unknown value is encountered. If not provided,
              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.

      Returns:
          A JSON string representation of the model.



   .. py:method:: model_json_schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, schema_generator = GenerateJsonSchema, mode = 'validation', *, union_format = 'any_of')
      :classmethod:


      Generates a JSON schema for a model class.

      Args:
          by_alias: Whether to use attribute aliases or not.
          ref_template: The reference template.
          union_format: The format to use when combining schemas from unions together. Can be one of:

              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
              keyword to combine schemas (the default).
              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
              `any_of`.
          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
              `GenerateJsonSchema` with your desired modifications
          mode: The mode in which to generate the schema.

      Returns:
          The JSON schema for the given model class.



   .. py:method:: model_parametrized_name(params)
      :classmethod:


      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.



   .. py:method:: 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.



   .. py:method:: model_rebuild(*, force = False, raise_errors = True, _parent_namespace_depth = 2, _types_namespace = None)
      :classmethod:


      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`.



   .. py:method:: model_validate(obj, *, strict = None, extra = None, from_attributes = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate a pydantic model instance.

      Args:
          obj: The object to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          from_attributes: Whether to extract data from object attributes.
          context: Additional context to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

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

      Returns:
          The validated model instance.



   .. py:method:: model_validate_json(json_data, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      !!! abstract "Usage Documentation"
          [JSON Parsing](../concepts/json.md#json-parsing)

      Validate the given JSON data against the Pydantic model.

      Args:
          json_data: The JSON data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.

      Raises:
          ValidationError: If `json_data` is not a JSON string or the object could not be validated.



   .. py:method:: model_validate_strings(obj, *, strict = None, extra = None, context = None, by_alias = None, by_name = None)
      :classmethod:


      Validate the given object with string data against the Pydantic model.

      Args:
          obj: The object containing string data to validate.
          strict: Whether to enforce types strictly.
          extra: Whether to ignore, allow, or forbid extra data during model validation.
              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
          context: Extra variables to pass to the validator.
          by_alias: Whether to use the field's alias when validating against the provided input data.
          by_name: Whether to use the field's name when validating against the provided input data.

      Returns:
          The validated Pydantic model.



   .. py:method:: dict(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False)


   .. py:method:: json(*, include = None, exclude = None, by_alias = False, exclude_unset = False, exclude_defaults = False, exclude_none = False, encoder = PydanticUndefined, models_as_dict = PydanticUndefined, **dumps_kwargs)


   .. py:method:: parse_obj(obj)
      :classmethod:



   .. py:method:: parse_raw(b, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: parse_file(path, *, content_type = None, encoding = 'utf8', proto = None, allow_pickle = False)
      :classmethod:



   .. py:method:: from_orm(obj)
      :classmethod:



   .. py:method:: construct(_fields_set = None, **values)
      :classmethod:



   .. py:method:: copy(*, include = None, exclude = None, update = None, deep = False)

      Returns a copy of the model.

      !!! warning "Deprecated"
          This method is now deprecated; use `model_copy` instead.

      If you need `include` or `exclude`, use:

      ```python {test="skip" lint="skip"}
      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.



   .. py:method:: schema(by_alias = True, ref_template = DEFAULT_REF_TEMPLATE)
      :classmethod:



   .. py:method:: schema_json(*, by_alias = True, ref_template = DEFAULT_REF_TEMPLATE, **dumps_kwargs)
      :classmethod:



   .. py:method:: validate(value)
      :classmethod:



   .. py:method:: update_forward_refs(**localns)
      :classmethod: