Module stac_fastapi.core.redis_utils¶
Utilities for connecting to and managing Redis connections.
Variables¶
python3
logger
python3
sentinel_settings
python3
settings
Functions¶
build_url_with_token¶
python3
def build_url_with_token(
base_url: str,
token: str
) -> str
Build URL with token parameter.
connect_redis¶
```python3 def connect_redis(
) -> redis.asyncio.client.Redis | None ```
Handle Redis connection.
get_prev_link¶
python3
def get_prev_link(
*args,
**kwargs
)
Get the previous page link for the current token.
get_redis_key¶
python3
def get_redis_key(
url: str,
token: str
) -> str
Create Redis key using URL path and token.
redis_pagination_links¶
python3
def redis_pagination_links(
current_url: str,
token: str,
next_token: str,
links: list
) -> None
Handle Redis pagination.
redis_retry¶
python3
def redis_retry(
func: Callable
) -> Callable
Retry with back-off decorator for Redis connections.
save_prev_link¶
python3
def save_prev_link(
*args,
**kwargs
)
Save the current page as the previous link for the next URL.
Classes¶
AsyncRedisQueueManager¶
python3
class AsyncRedisQueueManager(
redis: redis.asyncio.client.Redis
)
Asynchronous Redis queue manager.
Items are segregated by the primary datetime field (determined by USE_DATETIME env variable: properties.datetime when True, properties.start_datetime when False) using a Redis sorted set (ZSET) for ordering and a hash (HASH) for item data storage.
Redis key layout per collection: {prefix}:{collection_id}:zset — ZSET where score = primary datetime timestamp {prefix}:{collection_id}:data — HASH item_id → JSON payload {prefix}:collections — SET collection IDs with pending items
Static methods¶
create¶
```python3 def create(
) -> 'AsyncRedisQueueManager' ```
Create and connect an AsyncRedisQueueManager.
Methods¶
close¶
python3
def close(
self
)
Close Redis connection.
get_pending_collections¶
python3
def get_pending_collections(
self
) -> list[str]
Get list of collections with pending items.
get_pending_item_ids¶
python3
def get_pending_item_ids(
self,
collection_id: str,
limit: int | None = None
) -> list[str]
Get IDs of pending items ordered by primary datetime (ascending).
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
| collection_id | None | The collection identifier. | None |
| limit | None | Maximum number of IDs to return. | None |
Returns:
| Type | Description |
|---|---|
| None | List of item IDs ordered by primary datetime. |
get_pending_items¶
python3
def get_pending_items(
self,
collection_id: str,
limit: int | None = None
) -> list[dict]
Get pending items from the queue ordered by primary datetime (ascending).
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
| collection_id | None | The collection identifier. | None |
| limit | None | Maximum number of items to return. If None, returns all. | None |
Returns:
| Type | Description |
|---|---|
| None | List of item dicts ordered by primary datetime. |
get_queue_length¶
python3
def get_queue_length(
self,
collection_id: str
) -> int
Get number of items in the queue.
mark_items_processed¶
python3
def mark_items_processed(
self,
collection_id: str,
item_ids: list[str]
) -> int
Remove processed items from the queue by their IDs.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
| collection_id | None | The collection identifier. | None |
| item_ids | None | List of item IDs to remove. | None |
Returns:
| Type | Description |
|---|---|
| int | Number of remaining items in the queue. |
queue_items¶
python3
def queue_items(
self,
collection_id: str,
items: dict | list[dict]
) -> int
Queue one or more items for a collection. Deduplicates by item ID.
Items are scored by the primary datetime field so that pending items are always returned in chronological order.
If an item with the same ID already exists in the queue, it will be replaced.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
| collection_id | None | The collection identifier. | None |
| items | None | Single item dict or list of item dicts to queue. | None |
Returns:
| Type | Description |
|---|---|
| int | The total number of items in the queue after operation. |
remove_item¶
python3
def remove_item(
self,
collection_id: str,
item_id: str
) -> bool
Remove a specific item from the queue.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
| collection_id | None | The collection identifier. | None |
| item_id | None | The item ID to remove. | None |
Returns:
| Type | Description |
|---|---|
| bool | True if item was removed, False if it didn't exist. |
save_failed_items¶
python3
def save_failed_items(
self,
collection_id: str,
item_ids: list[str]
) -> None
Save failed item IDs to the dead-letter queue.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
| collection_id | None | The collection identifier. | None |
| item_ids | None | Item IDs that failed during bulk indexing. | None |
ItemQueueSettings¶
python3
class ItemQueueSettings(
__pydantic_self__,
_case_sensitive: 'bool | None' = None,
_nested_model_default_partial_update: 'bool | None' = None,
_env_prefix: 'str | None' = None,
_env_prefix_target: 'EnvPrefixTarget | 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_nested_max_split: 'int | 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 | Literal['dual', 'toggle'] | None" = None,
_cli_ignore_unknown_args: 'bool | None' = None,
_cli_kebab_case: "bool | Literal['all', 'no_enums'] | None" = None,
_cli_shortcuts: 'Mapping[str, str | list[str]] | None' = None,
_secrets_dir: 'PathType | None' = None,
_build_sources: 'tuple[tuple[PydanticBaseSettingsSource, ...], dict[str, Any]] | None' = None,
**values: 'Any'
)
Configuration for item queue behavior.
Ancestors (in MRO)¶
- pydantic_settings.main.BaseSettings
- pydantic.main.BaseModel
Class variables¶
python3
model_computed_fields
python3
model_config
python3
model_fields
Static methods¶
construct¶
python3
def construct(
_fields_set: 'set[str] | None' = None,
**values: 'Any'
) -> 'Self'
from_orm¶
python3
def from_orm(
obj: 'Any'
) -> 'Self'
model_construct¶
python3
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¶
python3
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',
*,
union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of'
) -> '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 |
| union_format | None | The format to use when combining schemas from unions together. Can be one of: - 'any_of': Use the anyOfkeyword to combine schemas (the default). - 'primitive_type_array': Use the typekeyword 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 toany_of. |
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¶
python3
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¶
python3
def model_rebuild(
*,
force: 'bool' = False,
raise_errors: 'bool' = True,
_parent_namespace_depth: 'int' = 2,
_types_namespace: 'MappingNamespace | 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¶
python3
def model_validate(
obj: 'Any',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
from_attributes: 'bool | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | 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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| from_attributes | None | Whether to extract data from object attributes. | None |
| context | None | Additional context to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | None |
Returns:
| Type | Description |
|---|---|
| None | The validated model instance. |
Raises:
| Type | Description |
|---|---|
| ValidationError | If the object could not be validated. |
model_validate_json¶
python3
def model_validate_json(
json_data: 'str | bytes | bytearray',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | None' = None
) -> 'Self'
Usage Documentation
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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| context | None | Extra variables to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | 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¶
python3
def model_validate_strings(
obj: 'Any',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | 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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| context | None | Extra variables to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | None |
Returns:
| Type | Description |
|---|---|
| None | The validated Pydantic model. |
parse_file¶
python3
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¶
python3
def parse_obj(
obj: 'Any'
) -> 'Self'
parse_raw¶
python3
def parse_raw(
b: 'str | bytes',
*,
content_type: 'str | None' = None,
encoding: 'str' = 'utf8',
proto: 'DeprecatedParseProtocol | None' = None,
allow_pickle: 'bool' = False
) -> 'Self'
schema¶
python3
def schema(
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}'
) -> 'Dict[str, Any]'
schema_json¶
python3
def schema_json(
*,
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}',
**dumps_kwargs: 'Any'
) -> 'str'
settings_customise_sources¶
python3
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¶
python3
def update_forward_refs(
**localns: 'Any'
) -> 'None'
validate¶
python3
def validate(
value: 'Any'
) -> 'Self'
Instance variables¶
python3
model_extra
Get extra fields set during validation.
python3
model_fields_set
Returns the set of fields that have been explicitly set on this model instance.
Methods¶
copy¶
python3
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:
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)
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¶
python3
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¶
python3
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¶
python3
def model_copy(
self,
*,
update: 'Mapping[str, Any] | None' = None,
deep: 'bool' = False
) -> 'Self'
Usage Documentation
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]).
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¶
python3
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 | None' = None,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
exclude_computed_fields: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
fallback: 'Callable[[Any], Any] | None' = None,
serialize_as_any: 'bool' = False
) -> 'dict[str, Any]'
Usage Documentation
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 |
| exclude_computed_fields | None | 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. |
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 |
| fallback | None | A function to call when an unknown value is encountered. If not provided, a [ PydanticSerializationError][pydantic_core.PydanticSerializationError] error is raised. |
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¶
python3
def model_dump_json(
self,
*,
indent: 'int | None' = None,
ensure_ascii: 'bool' = False,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
exclude_computed_fields: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
fallback: 'Callable[[Any], Any] | None' = None,
serialize_as_any: 'bool' = False
) -> 'str'
Usage Documentation
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 |
| ensure_ascii | None | 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. |
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 |
| exclude_computed_fields | None | 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. |
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 |
| fallback | None | A function to call when an unknown value is encountered. If not provided, a [ PydanticSerializationError][pydantic_core.PydanticSerializationError] error is raised. |
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¶
python3
def model_post_init(
self,
context: 'Any',
/
) -> 'None'
Override this method to perform additional initialization after __init__ and model_construct.
This is useful if you want to do some validation that requires the entire model to be initialized.
RedisCommonSettings¶
python3
class RedisCommonSettings(
__pydantic_self__,
_case_sensitive: 'bool | None' = None,
_nested_model_default_partial_update: 'bool | None' = None,
_env_prefix: 'str | None' = None,
_env_prefix_target: 'EnvPrefixTarget | 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_nested_max_split: 'int | 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 | Literal['dual', 'toggle'] | None" = None,
_cli_ignore_unknown_args: 'bool | None' = None,
_cli_kebab_case: "bool | Literal['all', 'no_enums'] | None" = None,
_cli_shortcuts: 'Mapping[str, str | list[str]] | None' = None,
_secrets_dir: 'PathType | None' = None,
_build_sources: 'tuple[tuple[PydanticBaseSettingsSource, ...], dict[str, Any]] | None' = None,
**values: 'Any'
)
Common configuration for Redis Sentinel and Redis Standalone.
Ancestors (in MRO)¶
- pydantic_settings.main.BaseSettings
- pydantic.main.BaseModel
Descendants¶
- stac_fastapi.core.redis_utils.RedisSentinelSettings
- stac_fastapi.core.redis_utils.RedisSettings
Class variables¶
python3
model_computed_fields
python3
model_config
python3
model_fields
Static methods¶
construct¶
python3
def construct(
_fields_set: 'set[str] | None' = None,
**values: 'Any'
) -> 'Self'
from_orm¶
python3
def from_orm(
obj: 'Any'
) -> 'Self'
model_construct¶
python3
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¶
python3
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',
*,
union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of'
) -> '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 |
| union_format | None | The format to use when combining schemas from unions together. Can be one of: - 'any_of': Use the anyOfkeyword to combine schemas (the default). - 'primitive_type_array': Use the typekeyword 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 toany_of. |
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¶
python3
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¶
python3
def model_rebuild(
*,
force: 'bool' = False,
raise_errors: 'bool' = True,
_parent_namespace_depth: 'int' = 2,
_types_namespace: 'MappingNamespace | 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¶
python3
def model_validate(
obj: 'Any',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
from_attributes: 'bool | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | 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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| from_attributes | None | Whether to extract data from object attributes. | None |
| context | None | Additional context to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | None |
Returns:
| Type | Description |
|---|---|
| None | The validated model instance. |
Raises:
| Type | Description |
|---|---|
| ValidationError | If the object could not be validated. |
model_validate_json¶
python3
def model_validate_json(
json_data: 'str | bytes | bytearray',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | None' = None
) -> 'Self'
Usage Documentation
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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| context | None | Extra variables to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | 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¶
python3
def model_validate_strings(
obj: 'Any',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | 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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| context | None | Extra variables to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | None |
Returns:
| Type | Description |
|---|---|
| None | The validated Pydantic model. |
parse_file¶
python3
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¶
python3
def parse_obj(
obj: 'Any'
) -> 'Self'
parse_raw¶
python3
def parse_raw(
b: 'str | bytes',
*,
content_type: 'str | None' = None,
encoding: 'str' = 'utf8',
proto: 'DeprecatedParseProtocol | None' = None,
allow_pickle: 'bool' = False
) -> 'Self'
schema¶
python3
def schema(
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}'
) -> 'Dict[str, Any]'
schema_json¶
python3
def schema_json(
*,
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}',
**dumps_kwargs: 'Any'
) -> 'str'
settings_customise_sources¶
python3
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¶
python3
def update_forward_refs(
**localns: 'Any'
) -> 'None'
validate¶
python3
def validate(
value: 'Any'
) -> 'Self'
validate_db¶
python3
def validate_db(
v: int
) -> int
Validate REDIS_DB is not negative integer.
validate_max_connections¶
python3
def validate_max_connections(
v
)
Handle empty/None values for REDIS_MAX_CONNECTIONS.
validate_self_link_ttl¶
python3
def validate_self_link_ttl(
v: int
) -> int
Validate REDIS_SELF_LINK_TTL is negative.
Instance variables¶
python3
model_extra
Get extra fields set during validation.
python3
model_fields_set
Returns the set of fields that have been explicitly set on this model instance.
Methods¶
copy¶
python3
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:
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)
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¶
python3
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¶
python3
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¶
python3
def model_copy(
self,
*,
update: 'Mapping[str, Any] | None' = None,
deep: 'bool' = False
) -> 'Self'
Usage Documentation
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]).
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¶
python3
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 | None' = None,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
exclude_computed_fields: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
fallback: 'Callable[[Any], Any] | None' = None,
serialize_as_any: 'bool' = False
) -> 'dict[str, Any]'
Usage Documentation
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 |
| exclude_computed_fields | None | 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. |
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 |
| fallback | None | A function to call when an unknown value is encountered. If not provided, a [ PydanticSerializationError][pydantic_core.PydanticSerializationError] error is raised. |
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¶
python3
def model_dump_json(
self,
*,
indent: 'int | None' = None,
ensure_ascii: 'bool' = False,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
exclude_computed_fields: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
fallback: 'Callable[[Any], Any] | None' = None,
serialize_as_any: 'bool' = False
) -> 'str'
Usage Documentation
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 |
| ensure_ascii | None | 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. |
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 |
| exclude_computed_fields | None | 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. |
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 |
| fallback | None | A function to call when an unknown value is encountered. If not provided, a [ PydanticSerializationError][pydantic_core.PydanticSerializationError] error is raised. |
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¶
python3
def model_post_init(
self,
context: 'Any',
/
) -> 'None'
Override this method to perform additional initialization after __init__ and model_construct.
This is useful if you want to do some validation that requires the entire model to be initialized.
RedisSentinelSettings¶
python3
class RedisSentinelSettings(
__pydantic_self__,
_case_sensitive: 'bool | None' = None,
_nested_model_default_partial_update: 'bool | None' = None,
_env_prefix: 'str | None' = None,
_env_prefix_target: 'EnvPrefixTarget | 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_nested_max_split: 'int | 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 | Literal['dual', 'toggle'] | None" = None,
_cli_ignore_unknown_args: 'bool | None' = None,
_cli_kebab_case: "bool | Literal['all', 'no_enums'] | None" = None,
_cli_shortcuts: 'Mapping[str, str | list[str]] | None' = None,
_secrets_dir: 'PathType | None' = None,
_build_sources: 'tuple[tuple[PydanticBaseSettingsSource, ...], dict[str, Any]] | None' = None,
**values: 'Any'
)
Configuration for connecting to Redis Sentinel.
Ancestors (in MRO)¶
- stac_fastapi.core.redis_utils.RedisCommonSettings
- pydantic_settings.main.BaseSettings
- pydantic.main.BaseModel
Class variables¶
python3
model_computed_fields
python3
model_config
python3
model_fields
Static methods¶
construct¶
python3
def construct(
_fields_set: 'set[str] | None' = None,
**values: 'Any'
) -> 'Self'
from_orm¶
python3
def from_orm(
obj: 'Any'
) -> 'Self'
model_construct¶
python3
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¶
python3
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',
*,
union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of'
) -> '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 |
| union_format | None | The format to use when combining schemas from unions together. Can be one of: - 'any_of': Use the anyOfkeyword to combine schemas (the default). - 'primitive_type_array': Use the typekeyword 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 toany_of. |
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¶
python3
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¶
python3
def model_rebuild(
*,
force: 'bool' = False,
raise_errors: 'bool' = True,
_parent_namespace_depth: 'int' = 2,
_types_namespace: 'MappingNamespace | 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¶
python3
def model_validate(
obj: 'Any',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
from_attributes: 'bool | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | 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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| from_attributes | None | Whether to extract data from object attributes. | None |
| context | None | Additional context to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | None |
Returns:
| Type | Description |
|---|---|
| None | The validated model instance. |
Raises:
| Type | Description |
|---|---|
| ValidationError | If the object could not be validated. |
model_validate_json¶
python3
def model_validate_json(
json_data: 'str | bytes | bytearray',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | None' = None
) -> 'Self'
Usage Documentation
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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| context | None | Extra variables to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | 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¶
python3
def model_validate_strings(
obj: 'Any',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | 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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| context | None | Extra variables to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | None |
Returns:
| Type | Description |
|---|---|
| None | The validated Pydantic model. |
parse_file¶
python3
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¶
python3
def parse_obj(
obj: 'Any'
) -> 'Self'
parse_raw¶
python3
def parse_raw(
b: 'str | bytes',
*,
content_type: 'str | None' = None,
encoding: 'str' = 'utf8',
proto: 'DeprecatedParseProtocol | None' = None,
allow_pickle: 'bool' = False
) -> 'Self'
schema¶
python3
def schema(
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}'
) -> 'Dict[str, Any]'
schema_json¶
python3
def schema_json(
*,
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}',
**dumps_kwargs: 'Any'
) -> 'str'
settings_customise_sources¶
python3
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¶
python3
def update_forward_refs(
**localns: 'Any'
) -> 'None'
validate¶
python3
def validate(
value: 'Any'
) -> 'Self'
validate_db¶
python3
def validate_db(
v: int
) -> int
Validate REDIS_DB is not negative integer.
validate_max_connections¶
python3
def validate_max_connections(
v
)
Handle empty/None values for REDIS_MAX_CONNECTIONS.
validate_self_link_ttl¶
python3
def validate_self_link_ttl(
v: int
) -> int
Validate REDIS_SELF_LINK_TTL is negative.
Instance variables¶
python3
model_extra
Get extra fields set during validation.
python3
model_fields_set
Returns the set of fields that have been explicitly set on this model instance.
Methods¶
copy¶
python3
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:
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)
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¶
python3
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]'
get_sentinel_hosts¶
python3
def get_sentinel_hosts(
self
) -> list[str]
Parse Redis Sentinel hosts from string to list.
get_sentinel_nodes¶
python3
def get_sentinel_nodes(
self
) -> list[tuple[str, int]]
Get list of (host, port) tuples for Sentinel connection.
get_sentinel_ports¶
python3
def get_sentinel_ports(
self
) -> list[int]
Parse Redis Sentinel ports from string to list of integers.
json¶
python3
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¶
python3
def model_copy(
self,
*,
update: 'Mapping[str, Any] | None' = None,
deep: 'bool' = False
) -> 'Self'
Usage Documentation
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]).
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¶
python3
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 | None' = None,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
exclude_computed_fields: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
fallback: 'Callable[[Any], Any] | None' = None,
serialize_as_any: 'bool' = False
) -> 'dict[str, Any]'
Usage Documentation
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 |
| exclude_computed_fields | None | 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. |
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 |
| fallback | None | A function to call when an unknown value is encountered. If not provided, a [ PydanticSerializationError][pydantic_core.PydanticSerializationError] error is raised. |
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¶
python3
def model_dump_json(
self,
*,
indent: 'int | None' = None,
ensure_ascii: 'bool' = False,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
exclude_computed_fields: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
fallback: 'Callable[[Any], Any] | None' = None,
serialize_as_any: 'bool' = False
) -> 'str'
Usage Documentation
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 |
| ensure_ascii | None | 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. |
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 |
| exclude_computed_fields | None | 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. |
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 |
| fallback | None | A function to call when an unknown value is encountered. If not provided, a [ PydanticSerializationError][pydantic_core.PydanticSerializationError] error is raised. |
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¶
python3
def model_post_init(
self,
context: 'Any',
/
) -> 'None'
Override this method to perform additional initialization after __init__ and model_construct.
This is useful if you want to do some validation that requires the entire model to be initialized.
RedisSettings¶
python3
class RedisSettings(
__pydantic_self__,
_case_sensitive: 'bool | None' = None,
_nested_model_default_partial_update: 'bool | None' = None,
_env_prefix: 'str | None' = None,
_env_prefix_target: 'EnvPrefixTarget | 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_nested_max_split: 'int | 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 | Literal['dual', 'toggle'] | None" = None,
_cli_ignore_unknown_args: 'bool | None' = None,
_cli_kebab_case: "bool | Literal['all', 'no_enums'] | None" = None,
_cli_shortcuts: 'Mapping[str, str | list[str]] | None' = None,
_secrets_dir: 'PathType | None' = None,
_build_sources: 'tuple[tuple[PydanticBaseSettingsSource, ...], dict[str, Any]] | None' = None,
**values: 'Any'
)
Configuration for connecting Redis.
Ancestors (in MRO)¶
- stac_fastapi.core.redis_utils.RedisCommonSettings
- pydantic_settings.main.BaseSettings
- pydantic.main.BaseModel
Class variables¶
python3
model_computed_fields
python3
model_config
python3
model_fields
Static methods¶
construct¶
python3
def construct(
_fields_set: 'set[str] | None' = None,
**values: 'Any'
) -> 'Self'
from_orm¶
python3
def from_orm(
obj: 'Any'
) -> 'Self'
model_construct¶
python3
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¶
python3
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',
*,
union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of'
) -> '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 |
| union_format | None | The format to use when combining schemas from unions together. Can be one of: - 'any_of': Use the anyOfkeyword to combine schemas (the default). - 'primitive_type_array': Use the typekeyword 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 toany_of. |
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¶
python3
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¶
python3
def model_rebuild(
*,
force: 'bool' = False,
raise_errors: 'bool' = True,
_parent_namespace_depth: 'int' = 2,
_types_namespace: 'MappingNamespace | 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¶
python3
def model_validate(
obj: 'Any',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
from_attributes: 'bool | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | 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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| from_attributes | None | Whether to extract data from object attributes. | None |
| context | None | Additional context to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | None |
Returns:
| Type | Description |
|---|---|
| None | The validated model instance. |
Raises:
| Type | Description |
|---|---|
| ValidationError | If the object could not be validated. |
model_validate_json¶
python3
def model_validate_json(
json_data: 'str | bytes | bytearray',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | None' = None
) -> 'Self'
Usage Documentation
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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| context | None | Extra variables to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | 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¶
python3
def model_validate_strings(
obj: 'Any',
*,
strict: 'bool | None' = None,
extra: 'ExtraValues | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | 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 |
| extra | None | Whether to ignore, allow, or forbid extra data during model validation. See the [ extra configuration value][pydantic.ConfigDict.extra] for details. |
None |
| context | None | Extra variables to pass to the validator. | None |
| by_alias | None | Whether to use the field's alias when validating against the provided input data. | None |
| by_name | None | Whether to use the field's name when validating against the provided input data. | None |
Returns:
| Type | Description |
|---|---|
| None | The validated Pydantic model. |
parse_file¶
python3
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¶
python3
def parse_obj(
obj: 'Any'
) -> 'Self'
parse_raw¶
python3
def parse_raw(
b: 'str | bytes',
*,
content_type: 'str | None' = None,
encoding: 'str' = 'utf8',
proto: 'DeprecatedParseProtocol | None' = None,
allow_pickle: 'bool' = False
) -> 'Self'
schema¶
python3
def schema(
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}'
) -> 'Dict[str, Any]'
schema_json¶
python3
def schema_json(
*,
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}',
**dumps_kwargs: 'Any'
) -> 'str'
settings_customise_sources¶
python3
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¶
python3
def update_forward_refs(
**localns: 'Any'
) -> 'None'
validate¶
python3
def validate(
value: 'Any'
) -> 'Self'
validate_db¶
python3
def validate_db(
v: int
) -> int
Validate REDIS_DB is not negative integer.
validate_max_connections¶
python3
def validate_max_connections(
v
)
Handle empty/None values for REDIS_MAX_CONNECTIONS.
validate_port_standalone¶
python3
def validate_port_standalone(
v: int
) -> int
Validate REDIS_PORT is not a negative integer.
validate_self_link_ttl¶
python3
def validate_self_link_ttl(
v: int
) -> int
Validate REDIS_SELF_LINK_TTL is negative.
Instance variables¶
python3
model_extra
Get extra fields set during validation.
python3
model_fields_set
Returns the set of fields that have been explicitly set on this model instance.
Methods¶
copy¶
python3
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:
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)
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¶
python3
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¶
python3
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¶
python3
def model_copy(
self,
*,
update: 'Mapping[str, Any] | None' = None,
deep: 'bool' = False
) -> 'Self'
Usage Documentation
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]).
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¶
python3
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 | None' = None,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
exclude_computed_fields: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
fallback: 'Callable[[Any], Any] | None' = None,
serialize_as_any: 'bool' = False
) -> 'dict[str, Any]'
Usage Documentation
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 |
| exclude_computed_fields | None | 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. |
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 |
| fallback | None | A function to call when an unknown value is encountered. If not provided, a [ PydanticSerializationError][pydantic_core.PydanticSerializationError] error is raised. |
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¶
python3
def model_dump_json(
self,
*,
indent: 'int | None' = None,
ensure_ascii: 'bool' = False,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
context: 'Any | None' = None,
by_alias: 'bool | None' = None,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
exclude_computed_fields: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
fallback: 'Callable[[Any], Any] | None' = None,
serialize_as_any: 'bool' = False
) -> 'str'
Usage Documentation
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 |
| ensure_ascii | None | 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. |
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 |
| exclude_computed_fields | None | 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. |
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 |
| fallback | None | A function to call when an unknown value is encountered. If not provided, a [ PydanticSerializationError][pydantic_core.PydanticSerializationError] error is raised. |
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¶
python3
def model_post_init(
self,
context: 'Any',
/
) -> 'None'
Override this method to perform additional initialization after __init__ and model_construct.
This is useful if you want to do some validation that requires the entire model to be initialized.