Module stac_fastapi.pgstac.config¶
Postgres API configuration.
Variables¶
DEFAULT_INVALID_ID_CHARS
Classes¶
ServerSettings¶
class ServerSettings(
/,
**data: 'Any'
)
Server runtime parameters.
Ancestors (in MRO)¶
- pydantic.main.BaseModel
Class variables¶
model_computed_fields
model_config
model_fields
Static methods¶
construct¶
def construct(
_fields_set: 'set[str] | None' = None,
**values: 'Any'
) -> 'Self'
from_orm¶
def from_orm(
obj: 'Any'
) -> 'Self'
model_construct¶
def model_construct(
_fields_set: 'set[str] | None' = None,
**values: 'Any'
) -> 'Self'
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.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
_fields_set | None | 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. |
None |
values | None | Trusted or pre-validated data dictionary. | None |
Returns:
Type | Description |
---|---|
None | A new instance of the Model class with validated data. |
model_json_schema¶
def model_json_schema(
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}',
schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>,
mode: 'JsonSchemaMode' = 'validation'
) -> 'dict[str, Any]'
Generates a JSON schema for a model class.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
by_alias | None | Whether to use attribute aliases or not. | None |
ref_template | None | The reference template. | None |
schema_generator | None | To override the logic used to generate the JSON schema, as a subclass ofGenerateJsonSchema with your desired modifications |
None |
mode | None | The mode in which to generate the schema. | None |
Returns:
Type | Description |
---|---|
None | The JSON schema for the given model class. |
model_parametrized_name¶
def model_parametrized_name(
params: 'tuple[type[Any], ...]'
) -> 'str'
Compute the class name for parametrizations of generic classes.
This method can be overridden to achieve a custom naming scheme for generic BaseModels.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
params | None | Tuple of types of the class. Given a generic classModel with 2 type variables and a concrete model Model[str, int] ,the value (str, int) would be passed to params . |
None |
Returns:
Type | Description |
---|---|
None | String representing the new class where params are passed to cls as type variables. |
Raises:
Type | Description |
---|---|
TypeError | Raised when trying to generate concrete names for non-generic models. |
model_rebuild¶
def model_rebuild(
*,
force: 'bool' = False,
raise_errors: 'bool' = True,
_parent_namespace_depth: 'int' = 2,
_types_namespace: 'dict[str, Any] | None' = None
) -> 'bool | None'
Try to rebuild the pydantic-core schema for the model.
This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
force | None | Whether to force the rebuilding of the model schema, defaults to False . |
None |
raise_errors | None | Whether to raise errors, defaults to True . |
None |
_parent_namespace_depth | None | The depth level of the parent namespace, defaults to 2. | None |
_types_namespace | None | The types namespace, defaults to None . |
None |
Returns:
Type | Description |
---|---|
None | 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 . |
model_validate¶
def model_validate(
obj: 'Any',
*,
strict: 'bool | None' = None,
from_attributes: 'bool | None' = None,
context: 'Any | None' = None
) -> 'Self'
Validate a pydantic model instance.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
obj | None | The object to validate. | None |
strict | None | Whether to enforce types strictly. | None |
from_attributes | None | Whether to extract data from object attributes. | None |
context | None | Additional context to pass to the validator. | None |
Returns:
Type | Description |
---|---|
None | The validated model instance. |
Raises:
Type | Description |
---|---|
ValidationError | If the object could not be validated. |
model_validate_json¶
def model_validate_json(
json_data: 'str | bytes | bytearray',
*,
strict: 'bool | None' = None,
context: 'Any | None' = None
) -> 'Self'
Usage docs: docs.pydantic.dev/2.9/concepts/json/#json-parsing
Validate the given JSON data against the Pydantic model.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
json_data | None | The JSON data to validate. | None |
strict | None | Whether to enforce types strictly. | None |
context | None | Extra variables to pass to the validator. | None |
Returns:
Type | Description |
---|---|
None | The validated Pydantic model. |
Raises:
Type | Description |
---|---|
ValidationError | If json_data is not a JSON string or the object could not be validated. |
model_validate_strings¶
def model_validate_strings(
obj: 'Any',
*,
strict: 'bool | None' = None,
context: 'Any | None' = None
) -> 'Self'
Validate the given object with string data against the Pydantic model.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
obj | None | The object containing string data to validate. | None |
strict | None | Whether to enforce types strictly. | None |
context | None | Extra variables to pass to the validator. | None |
Returns:
Type | Description |
---|---|
None | The validated Pydantic model. |
parse_file¶
def parse_file(
path: 'str | Path',
*,
content_type: 'str | None' = None,
encoding: 'str' = 'utf8',
proto: 'DeprecatedParseProtocol | None' = None,
allow_pickle: 'bool' = False
) -> 'Self'
parse_obj¶
def parse_obj(
obj: 'Any'
) -> 'Self'
parse_raw¶
def parse_raw(
b: 'str | bytes',
*,
content_type: 'str | None' = None,
encoding: 'str' = 'utf8',
proto: 'DeprecatedParseProtocol | None' = None,
allow_pickle: 'bool' = False
) -> 'Self'
schema¶
def schema(
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}'
) -> 'Dict[str, Any]'
schema_json¶
def schema_json(
*,
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}',
**dumps_kwargs: 'Any'
) -> 'str'
update_forward_refs¶
def update_forward_refs(
**localns: 'Any'
) -> 'None'
validate¶
def validate(
value: 'Any'
) -> 'Self'
Instance variables¶
model_extra
Get extra fields set during validation.
model_fields_set
Returns the set of fields that have been explicitly set on this model instance.
Methods¶
copy¶
def copy(
self,
*,
include: 'AbstractSetIntStr | MappingIntStrAny | None' = None,
exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None,
update: 'Dict[str, Any] | None' = None,
deep: 'bool' = False
) -> 'Self'
Returns a copy of the model.
Deprecated
This method is now deprecated; use model_copy
instead.
If you need include
or exclude
, use:
data = self.model_dump(include=include, exclude=exclude, round_trip=True)
data = {**data, **(update or {})}
copied = self.model_validate(data)
Parameters:
Name | Type | Description | Default |
---|---|---|---|
include | None | Optional set or mapping specifying which fields to include in the copied model. | None |
exclude | None | Optional set or mapping specifying which fields to exclude in the copied model. | None |
update | None | Optional dictionary of field-value pairs to override field values in the copied model. | None |
deep | None | If True, the values of fields that are Pydantic models will be deep-copied. | None |
Returns:
Type | Description |
---|---|
None | A copy of the model with included, excluded and updated fields as specified. |
dict¶
def dict(
self,
*,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False
) -> 'Dict[str, Any]'
json¶
def json(
self,
*,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
encoder: 'Callable[[Any], Any] | None' = PydanticUndefined,
models_as_dict: 'bool' = PydanticUndefined,
**dumps_kwargs: 'Any'
) -> 'str'
model_copy¶
def model_copy(
self,
*,
update: 'dict[str, Any] | None' = None,
deep: 'bool' = False
) -> 'Self'
Usage docs: docs.pydantic.dev/2.9/concepts/serialization/#model_copy
Returns a copy of the model.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
update | None | Values to change/add in the new model. Note: the data is not validated before creating the new model. You should trust this data. |
None |
deep | None | Set to True to make a deep copy of the model. |
None |
Returns:
Type | Description |
---|---|
None | New model instance. |
model_dump¶
def model_dump(
self,
*,
mode: "Literal['json', 'python'] | str" = 'python',
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
context: 'Any | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
serialize_as_any: 'bool' = False
) -> 'dict[str, Any]'
Usage docs: docs.pydantic.dev/2.9/concepts/serialization/#modelmodel_dump
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
mode | None | 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. |
None |
include | None | A set of fields to include in the output. | None |
exclude | None | A set of fields to exclude from the output. | None |
context | None | Additional context to pass to the serializer. | None |
by_alias | None | Whether to use the field's alias in the dictionary key if defined. | None |
exclude_unset | None | Whether to exclude fields that have not been explicitly set. | None |
exclude_defaults | None | Whether to exclude fields that are set to their default value. | None |
exclude_none | None | Whether to exclude fields that have a value of None . |
None |
round_trip | None | If True, dumped values should be valid as input for non-idempotent types such as Json[T]. | None |
warnings | None | How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, "error" raises a [ PydanticSerializationError ][pydantic_core.PydanticSerializationError]. |
None |
serialize_as_any | None | Whether to serialize fields with duck-typing serialization behavior. | None |
Returns:
Type | Description |
---|---|
None | A dictionary representation of the model. |
model_dump_json¶
def model_dump_json(
self,
*,
indent: 'int | None' = None,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
context: 'Any | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
serialize_as_any: 'bool' = False
) -> 'str'
Usage docs: docs.pydantic.dev/2.9/concepts/serialization/#modelmodel_dump_json
Generates a JSON representation of the model using Pydantic's to_json
method.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
indent | None | Indentation to use in the JSON output. If None is passed, the output will be compact. | None |
include | None | Field(s) to include in the JSON output. | None |
exclude | None | Field(s) to exclude from the JSON output. | None |
context | None | Additional context to pass to the serializer. | None |
by_alias | None | Whether to serialize using field aliases. | None |
exclude_unset | None | Whether to exclude fields that have not been explicitly set. | None |
exclude_defaults | None | Whether to exclude fields that are set to their default value. | None |
exclude_none | None | Whether to exclude fields that have a value of None . |
None |
round_trip | None | If True, dumped values should be valid as input for non-idempotent types such as Json[T]. | None |
warnings | None | How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, "error" raises a [ PydanticSerializationError ][pydantic_core.PydanticSerializationError]. |
None |
serialize_as_any | None | Whether to serialize fields with duck-typing serialization behavior. | None |
Returns:
Type | Description |
---|---|
None | A JSON string representation of the model. |
model_post_init¶
def model_post_init(
self,
_BaseModel__context: 'Any'
) -> 'None'
Override this method to perform additional initialization after __init__
and model_construct
.
This is useful if you want to do some validation that requires the entire model to be initialized.
Settings¶
class Settings(
__pydantic_self__,
_case_sensitive: 'bool | None' = None,
_nested_model_default_partial_update: 'bool | None' = None,
_env_prefix: 'str | None' = None,
_env_file: 'DotenvType | None' = PosixPath('.'),
_env_file_encoding: 'str | None' = None,
_env_ignore_empty: 'bool | None' = None,
_env_nested_delimiter: 'str | None' = None,
_env_parse_none_str: 'str | None' = None,
_env_parse_enums: 'bool | None' = None,
_cli_prog_name: 'str | None' = None,
_cli_parse_args: 'bool | list[str] | tuple[str, ...] | None' = None,
_cli_settings_source: 'CliSettingsSource[Any] | None' = None,
_cli_parse_none_str: 'str | None' = None,
_cli_hide_none_type: 'bool | None' = None,
_cli_avoid_json: 'bool | None' = None,
_cli_enforce_required: 'bool | None' = None,
_cli_use_class_docs_for_groups: 'bool | None' = None,
_cli_exit_on_error: 'bool | None' = None,
_cli_prefix: 'str | None' = None,
_cli_flag_prefix_char: 'str | None' = None,
_cli_implicit_flags: 'bool | None' = None,
_cli_ignore_unknown_args: 'bool | None' = None,
_secrets_dir: 'PathType | None' = None,
**values: 'Any'
)
Postgres-specific API settings.
Attributes¶
Name | Type | Description | Default |
---|---|---|---|
postgres_user | None | postgres username. | None |
postgres_pass | None | postgres password. | None |
postgres_host_reader | None | hostname for the reader connection. | None |
postgres_host_writer | None | hostname for the writer connection. | None |
postgres_port | None | database port. | None |
postgres_dbname | None | database name. | None |
use_api_hydrate | None | perform hydration of stac items within stac-fastapi. | None |
invalid_id_chars | None | list of characters that are not allowed in item or collection ids. | None |
Ancestors (in MRO)¶
- stac_fastapi.types.config.ApiSettings
- pydantic_settings.main.BaseSettings
- pydantic.main.BaseModel
Class variables¶
model_computed_fields
model_config
model_fields
Static methods¶
construct¶
def construct(
_fields_set: 'set[str] | None' = None,
**values: 'Any'
) -> 'Self'
from_orm¶
def from_orm(
obj: 'Any'
) -> 'Self'
model_construct¶
def model_construct(
_fields_set: 'set[str] | None' = None,
**values: 'Any'
) -> 'Self'
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.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
_fields_set | None | 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. |
None |
values | None | Trusted or pre-validated data dictionary. | None |
Returns:
Type | Description |
---|---|
None | A new instance of the Model class with validated data. |
model_json_schema¶
def model_json_schema(
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}',
schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>,
mode: 'JsonSchemaMode' = 'validation'
) -> 'dict[str, Any]'
Generates a JSON schema for a model class.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
by_alias | None | Whether to use attribute aliases or not. | None |
ref_template | None | The reference template. | None |
schema_generator | None | To override the logic used to generate the JSON schema, as a subclass ofGenerateJsonSchema with your desired modifications |
None |
mode | None | The mode in which to generate the schema. | None |
Returns:
Type | Description |
---|---|
None | The JSON schema for the given model class. |
model_parametrized_name¶
def model_parametrized_name(
params: 'tuple[type[Any], ...]'
) -> 'str'
Compute the class name for parametrizations of generic classes.
This method can be overridden to achieve a custom naming scheme for generic BaseModels.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
params | None | Tuple of types of the class. Given a generic classModel with 2 type variables and a concrete model Model[str, int] ,the value (str, int) would be passed to params . |
None |
Returns:
Type | Description |
---|---|
None | String representing the new class where params are passed to cls as type variables. |
Raises:
Type | Description |
---|---|
TypeError | Raised when trying to generate concrete names for non-generic models. |
model_rebuild¶
def model_rebuild(
*,
force: 'bool' = False,
raise_errors: 'bool' = True,
_parent_namespace_depth: 'int' = 2,
_types_namespace: 'dict[str, Any] | None' = None
) -> 'bool | None'
Try to rebuild the pydantic-core schema for the model.
This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
force | None | Whether to force the rebuilding of the model schema, defaults to False . |
None |
raise_errors | None | Whether to raise errors, defaults to True . |
None |
_parent_namespace_depth | None | The depth level of the parent namespace, defaults to 2. | None |
_types_namespace | None | The types namespace, defaults to None . |
None |
Returns:
Type | Description |
---|---|
None | 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 . |
model_validate¶
def model_validate(
obj: 'Any',
*,
strict: 'bool | None' = None,
from_attributes: 'bool | None' = None,
context: 'Any | None' = None
) -> 'Self'
Validate a pydantic model instance.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
obj | None | The object to validate. | None |
strict | None | Whether to enforce types strictly. | None |
from_attributes | None | Whether to extract data from object attributes. | None |
context | None | Additional context to pass to the validator. | None |
Returns:
Type | Description |
---|---|
None | The validated model instance. |
Raises:
Type | Description |
---|---|
ValidationError | If the object could not be validated. |
model_validate_json¶
def model_validate_json(
json_data: 'str | bytes | bytearray',
*,
strict: 'bool | None' = None,
context: 'Any | None' = None
) -> 'Self'
Usage docs: docs.pydantic.dev/2.9/concepts/json/#json-parsing
Validate the given JSON data against the Pydantic model.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
json_data | None | The JSON data to validate. | None |
strict | None | Whether to enforce types strictly. | None |
context | None | Extra variables to pass to the validator. | None |
Returns:
Type | Description |
---|---|
None | The validated Pydantic model. |
Raises:
Type | Description |
---|---|
ValidationError | If json_data is not a JSON string or the object could not be validated. |
model_validate_strings¶
def model_validate_strings(
obj: 'Any',
*,
strict: 'bool | None' = None,
context: 'Any | None' = None
) -> 'Self'
Validate the given object with string data against the Pydantic model.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
obj | None | The object containing string data to validate. | None |
strict | None | Whether to enforce types strictly. | None |
context | None | Extra variables to pass to the validator. | None |
Returns:
Type | Description |
---|---|
None | The validated Pydantic model. |
parse_cors_methods¶
def parse_cors_methods(
v
)
Parse CORS methods.
parse_cors_origin¶
def parse_cors_origin(
v
)
Parse CORS origins.
parse_file¶
def parse_file(
path: 'str | Path',
*,
content_type: 'str | None' = None,
encoding: 'str' = 'utf8',
proto: 'DeprecatedParseProtocol | None' = None,
allow_pickle: 'bool' = False
) -> 'Self'
parse_obj¶
def parse_obj(
obj: 'Any'
) -> 'Self'
parse_raw¶
def parse_raw(
b: 'str | bytes',
*,
content_type: 'str | None' = None,
encoding: 'str' = 'utf8',
proto: 'DeprecatedParseProtocol | None' = None,
allow_pickle: 'bool' = False
) -> 'Self'
schema¶
def schema(
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}'
) -> 'Dict[str, Any]'
schema_json¶
def schema_json(
*,
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}',
**dumps_kwargs: 'Any'
) -> 'str'
settings_customise_sources¶
def settings_customise_sources(
settings_cls: 'type[BaseSettings]',
init_settings: 'PydanticBaseSettingsSource',
env_settings: 'PydanticBaseSettingsSource',
dotenv_settings: 'PydanticBaseSettingsSource',
file_secret_settings: 'PydanticBaseSettingsSource'
) -> 'tuple[PydanticBaseSettingsSource, ...]'
Define the sources and their order for loading the settings values.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
settings_cls | None | The Settings class. | None |
init_settings | None | The InitSettingsSource instance. |
None |
env_settings | None | The EnvSettingsSource instance. |
None |
dotenv_settings | None | The DotEnvSettingsSource instance. |
None |
file_secret_settings | None | The SecretsSettingsSource instance. |
None |
Returns:
Type | Description |
---|---|
None | A tuple containing the sources and their order for loading the settings values. |
update_forward_refs¶
def update_forward_refs(
**localns: 'Any'
) -> 'None'
validate¶
def validate(
value: 'Any'
) -> 'Self'
Instance variables¶
model_extra
Get extra fields set during validation.
model_fields_set
Returns the set of fields that have been explicitly set on this model instance.
reader_connection_string
Create reader psql connection string.
testing_connection_string
Create testing psql connection string.
writer_connection_string
Create writer psql connection string.
Methods¶
copy¶
def copy(
self,
*,
include: 'AbstractSetIntStr | MappingIntStrAny | None' = None,
exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None,
update: 'Dict[str, Any] | None' = None,
deep: 'bool' = False
) -> 'Self'
Returns a copy of the model.
Deprecated
This method is now deprecated; use model_copy
instead.
If you need include
or exclude
, use:
data = self.model_dump(include=include, exclude=exclude, round_trip=True)
data = {**data, **(update or {})}
copied = self.model_validate(data)
Parameters:
Name | Type | Description | Default |
---|---|---|---|
include | None | Optional set or mapping specifying which fields to include in the copied model. | None |
exclude | None | Optional set or mapping specifying which fields to exclude in the copied model. | None |
update | None | Optional dictionary of field-value pairs to override field values in the copied model. | None |
deep | None | If True, the values of fields that are Pydantic models will be deep-copied. | None |
Returns:
Type | Description |
---|---|
None | A copy of the model with included, excluded and updated fields as specified. |
dict¶
def dict(
self,
*,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False
) -> 'Dict[str, Any]'
json¶
def json(
self,
*,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
encoder: 'Callable[[Any], Any] | None' = PydanticUndefined,
models_as_dict: 'bool' = PydanticUndefined,
**dumps_kwargs: 'Any'
) -> 'str'
model_copy¶
def model_copy(
self,
*,
update: 'dict[str, Any] | None' = None,
deep: 'bool' = False
) -> 'Self'
Usage docs: docs.pydantic.dev/2.9/concepts/serialization/#model_copy
Returns a copy of the model.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
update | None | Values to change/add in the new model. Note: the data is not validated before creating the new model. You should trust this data. |
None |
deep | None | Set to True to make a deep copy of the model. |
None |
Returns:
Type | Description |
---|---|
None | New model instance. |
model_dump¶
def model_dump(
self,
*,
mode: "Literal['json', 'python'] | str" = 'python',
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
context: 'Any | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
serialize_as_any: 'bool' = False
) -> 'dict[str, Any]'
Usage docs: docs.pydantic.dev/2.9/concepts/serialization/#modelmodel_dump
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
mode | None | 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. |
None |
include | None | A set of fields to include in the output. | None |
exclude | None | A set of fields to exclude from the output. | None |
context | None | Additional context to pass to the serializer. | None |
by_alias | None | Whether to use the field's alias in the dictionary key if defined. | None |
exclude_unset | None | Whether to exclude fields that have not been explicitly set. | None |
exclude_defaults | None | Whether to exclude fields that are set to their default value. | None |
exclude_none | None | Whether to exclude fields that have a value of None . |
None |
round_trip | None | If True, dumped values should be valid as input for non-idempotent types such as Json[T]. | None |
warnings | None | How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, "error" raises a [ PydanticSerializationError ][pydantic_core.PydanticSerializationError]. |
None |
serialize_as_any | None | Whether to serialize fields with duck-typing serialization behavior. | None |
Returns:
Type | Description |
---|---|
None | A dictionary representation of the model. |
model_dump_json¶
def model_dump_json(
self,
*,
indent: 'int | None' = None,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
context: 'Any | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
serialize_as_any: 'bool' = False
) -> 'str'
Usage docs: docs.pydantic.dev/2.9/concepts/serialization/#modelmodel_dump_json
Generates a JSON representation of the model using Pydantic's to_json
method.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
indent | None | Indentation to use in the JSON output. If None is passed, the output will be compact. | None |
include | None | Field(s) to include in the JSON output. | None |
exclude | None | Field(s) to exclude from the JSON output. | None |
context | None | Additional context to pass to the serializer. | None |
by_alias | None | Whether to serialize using field aliases. | None |
exclude_unset | None | Whether to exclude fields that have not been explicitly set. | None |
exclude_defaults | None | Whether to exclude fields that are set to their default value. | None |
exclude_none | None | Whether to exclude fields that have a value of None . |
None |
round_trip | None | If True, dumped values should be valid as input for non-idempotent types such as Json[T]. | None |
warnings | None | How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, "error" raises a [ PydanticSerializationError ][pydantic_core.PydanticSerializationError]. |
None |
serialize_as_any | None | Whether to serialize fields with duck-typing serialization behavior. | None |
Returns:
Type | Description |
---|---|
None | A JSON string representation of the model. |
model_post_init¶
def model_post_init(
self,
_BaseModel__context: 'Any'
) -> 'None'
Override this method to perform additional initialization after __init__
and model_construct
.
This is useful if you want to do some validation that requires the entire model to be initialized.