akkudoktoreos.config.config.ConfigEOS

class akkudoktoreos.config.config.ConfigEOS(*args: Any, general: GeneralSettings = GeneralSettings(version='0.2.0', data_folder_path=None, data_output_subpath='output', latitude=52.52, longitude=13.405, timezone='Europe/Berlin', data_output_path=None, config_folder_path=Path('/home/docs/.config/net.akkudoktor.eos'), config_file_path=Path('/home/docs/.config/net.akkudoktor.eos/EOS.config.json')), cache: CacheCommonSettings = CacheCommonSettings(subpath='cache', cleanup_interval=300), ems: EnergyManagementCommonSettings = EnergyManagementCommonSettings(startup_delay=5, interval=None, mode=None), logging: LoggingCommonSettings = LoggingCommonSettings(console_level=None, file_level=None, file_path=Path('/home/docs/.local/share/net.akkudoktor.eos/output/eos.log')), devices: DevicesCommonSettings = DevicesCommonSettings(batteries=None, max_batteries=None, electric_vehicles=None, max_electric_vehicles=None, inverters=None, max_inverters=None, home_appliances=None, max_home_appliances=None, measurement_keys=[]), measurement: MeasurementCommonSettings = MeasurementCommonSettings(load_emr_keys=None, grid_export_emr_keys=None, grid_import_emr_keys=None, pv_production_emr_keys=None, keys=[]), optimization: OptimizationCommonSettings = OptimizationCommonSettings(horizon_hours=24, interval=3600, algorithm='GENETIC', genetic=GeneticCommonSettings(individuals=300, generations=400, seed=None, penalties=None)), prediction: PredictionCommonSettings = PredictionCommonSettings(hours=48, historic_hours=48), elecprice: ElecPriceCommonSettings = ElecPriceCommonSettings(provider=None, charges_kwh=None, vat_rate=1.19, provider_settings=ElecPriceCommonProviderSettings(ElecPriceImport=None)), feedintariff: FeedInTariffCommonSettings = FeedInTariffCommonSettings(provider=None, provider_settings=FeedInTariffCommonProviderSettings(FeedInTariffFixed=None, FeedInTariffImport=None)), load: LoadCommonSettings = LoadCommonSettings(provider=None, provider_settings=LoadCommonProviderSettings(LoadAkkudoktor=None, LoadVrm=None, LoadImport=None)), pvforecast: PVForecastCommonSettings = PVForecastCommonSettings(provider=None, provider_settings=PVForecastCommonProviderSettings(PVForecastImport=None, PVForecastVrm=None), planes=None, max_planes=0, planes_peakpower=[], planes_azimuth=[], planes_tilt=[], planes_userhorizon=[], planes_inverter_paco=[]), weather: WeatherCommonSettings = WeatherCommonSettings(provider=None, provider_settings=WeatherCommonProviderSettings(WeatherImport=None)), server: ServerCommonSettings = ServerCommonSettings(host='127.0.0.1', port=8503, verbose=False, startup_eosdash=True, eosdash_host=None, eosdash_port=None), utils: UtilsCommonSettings = UtilsCommonSettings())

Bases: SingletonMixin, SettingsEOSDefaults

Singleton configuration handler for the EOS application.

ConfigEOS extends SettingsEOS with support for default configuration paths and automatic initialization.

ConfigEOS ensures that only one instance of the class is created throughout the application, allowing consistent access to EOS configuration settings. This singleton instance loads configuration data from a predefined set of directories or creates a default configuration if none is found.

Initialization Process:

Upon instantiation, the singleton instance attempts to load a configuration file in this order: 1. The directory specified by the EOS_CONFIG_DIR environment variable 2. The directory specified by the EOS_DIR environment variable. 3. A platform specific default directory for EOS. 4. The current working directory.
The first available configuration file found in these directories is loaded.
If no configuration file is found, a default configuration file is created in the platform specific default directory, and default settings are loaded into it.

Attributes from the loaded configuration are accessible directly as instance attributes of ConfigEOS, providing a centralized, shared configuration object for EOS.

Singleton Behavior:

This class uses the SingletonMixin to ensure that all requests for ConfigEOS return the same instance, which contains the most up-to-date configuration. Modifying the configuration in one part of the application reflects across all references to this class.

config_folder_path

Path to the configuration directory.

Type:: Optional[Path]

config_file_path

Path to the configuration file.

Type:: Optional[Path]

Raises:: FileNotFoundError – If no configuration file is found, and creating a default configuration fails.

Example

To initialize and access configuration attributes (only one instance is created): `python config_eos = ConfigEOS() # Always returns the same instance print(config_eos.prediction.hours) # Access a setting from the loaded configuration `

__init__(*args: Any, **kwargs: Any) → None

Initializes the singleton ConfigEOS instance.

Configuration data is loaded from a configuration file or a default one is created if none exists.

Methods

`__init__`(args, *kwargs)	Initializes the singleton ConfigEOS instance.
`construct`([_fields_set])
`copy`(*[, include, exclude, update, deep])	Returns a copy of the model.
`dict`(*[, include, exclude, by_alias, ...])
`from_orm`(obj)
`get_nested_value`(path)	Retrieve a nested value from the model using a '/'-separated path.
`json`(*[, include, exclude, by_alias, ...])
`list_backups`()	List available configuration backup files and extract metadata.
`merge_settings`(settings)	Merges the provided settings into the global settings for EOS, with optional overwrite.
`merge_settings_from_dict`(data)	Merges the provided dictionary data into the current instance.
`model_construct`([_fields_set])	Creates a new instance of the Model class with validated data.
`model_copy`(*[, update, deep])	!!! abstract "Usage Documentation"
`model_dump`(*[, mode, include, exclude, ...])	!!! abstract "Usage Documentation"
`model_dump_json`(*[, indent, ensure_ascii, ...])	!!! abstract "Usage Documentation"
`model_json_schema`([by_alias, ref_template, ...])	Generates a JSON schema for a model class.
`model_parametrized_name`(params)	Compute the class name for parametrizations of generic classes.
`model_post_init`(context, /)	Override this method to perform additional initialization after __init__ and model_construct.
`model_rebuild`(*[, force, raise_errors, ...])	Try to rebuild the pydantic-core schema for the model.
`model_validate`(obj, *[, strict, extra, ...])	Validate a pydantic model instance.
`model_validate_json`(json_data, *[, strict, ...])	!!! abstract "Usage Documentation"
`model_validate_strings`(obj, *[, strict, ...])	Validate the given object with string data against the Pydantic model.
`parse_file`(path, *[, content_type, ...])
`parse_obj`(obj)
`parse_raw`(b, *[, content_type, encoding, ...])
`reset_instance`()	Resets the singleton instance, forcing it to be recreated on next access.
`reset_settings`()	Reset all changed settings to environment/config file defaults.
`revert_settings`(backup_id)	Revert application settings to a stored backup.
`schema`([by_alias, ref_template])
`schema_json`(*[, by_alias, ref_template])
`set_nested_value`(path, value)	Set a nested value in the model using a '/'-separated path.
`settings_customise_sources`(settings_cls, ...)	Customizes the order and handling of settings sources for a pydantic_settings.BaseSettings subclass.
`to_config_file`()	Saves the current configuration to the configuration file.
`track_nested_value`(path, callback)	Register a callback for a specific path (or subtree).
`update`()	Updates all configuration fields.
`update_forward_refs`(**localns)
`validate`(value)

Attributes

`APP_AUTHOR`
`APP_NAME`
`CONFIG_FILE_NAME`
`ENCODING`
`EOS_CONFIG_DIR`
`EOS_DIR`
`config_default_file_path`
`model_computed_fields`
`model_config`	Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
`model_extra`	Get extra fields set during validation.
`model_fields`
`model_fields_set`	Returns the set of fields that have been explicitly set on this model instance.
`package_root_path`
`general`
`cache`
`ems`
`logging`
`devices`
`measurement`
`optimization`
`prediction`
`elecprice`
`feedintariff`
`load`
`pvforecast`
`weather`
`server`
`utils`

APP_NAME: ClassVar[str] = 'net.akkudoktor.eos'

APP_AUTHOR: ClassVar[str] = 'akkudoktor'

EOS_DIR: ClassVar[str] = 'EOS_DIR'

EOS_CONFIG_DIR: ClassVar[str] = 'EOS_CONFIG_DIR'

ENCODING: ClassVar[str] = 'UTF-8'

CONFIG_FILE_NAME: ClassVar[str] = 'EOS.config.json'

classmethod settings_customise_sources(settings_cls: Type[BaseSettings], init_settings: PydanticBaseSettingsSource, env_settings: PydanticBaseSettingsSource, dotenv_settings: PydanticBaseSettingsSource, file_secret_settings: PydanticBaseSettingsSource) → tuple[PydanticBaseSettingsSource, ...]

Customizes the order and handling of settings sources for a pydantic_settings.BaseSettings subclass.

This method determines the sources for application configuration settings, including environment variables, dotenv files and JSON configuration files. It ensures that a default configuration file exists and creates one if necessary.

Parameters:

settings_cls (Type[pydantic_settings.BaseSettings]) – The Pydantic BaseSettings class for which sources are customized.
init_settings (pydantic_settings.PydanticBaseSettingsSource) – The initial settings source, typically passed at runtime.
env_settings (pydantic_settings.PydanticBaseSettingsSource) – Settings sourced from environment variables.
dotenv_settings (pydantic_settings.PydanticBaseSettingsSource) – Settings sourced from a dotenv file.
file_secret_settings (pydantic_settings.PydanticBaseSettingsSource) – Unused (needed for parent class interface).

Returns:

A tuple of settings sources in the order they should be applied.

Return type:

tuple[pydantic_settings.PydanticBaseSettingsSource, …]

Behavior:

Checks for the existence of a JSON configuration file in the expected location.
If the configuration file does not exist, creates the directory (if needed) and attempts to copy a default configuration file to the location. If the copy fails, uses the default configuration file directly.
Creates a pydantic_settings.JsonConfigSettingsSource for both the configuration file and the default configuration file.
Updates class attributes GeneralSettings._config_folder_path and GeneralSettings._config_file_path to reflect the determined paths.
Returns a tuple containing all provided and newly created settings sources in the desired order.

Notes

This method logs a warning if the default configuration file cannot be copied.
It ensures that a fallback to the default configuration file is always possible.

config_default_file_path = Path('/home/docs/checkouts/readthedocs.org/user_builds/akkudoktor-eos/checkouts/stable/src/akkudoktoreos/data/default.config.json')

package_root_path = Path('/home/docs/checkouts/readthedocs.org/user_builds/akkudoktor-eos/checkouts/stable/src/akkudoktoreos')

__init__(*args: Any, **kwargs: Any) → None

Initializes the singleton ConfigEOS instance.

Configuration data is loaded from a configuration file or a default one is created if none exists.

merge_settings(settings: SettingsEOS) → None

Merges the provided settings into the global settings for EOS, with optional overwrite.

Parameters:: settings (SettingsEOS) – The settings to apply globally.
Raises:: ValueError – If the settings is not a SettingsEOS instance.

merge_settings_from_dict(data: dict) → None

Merges the provided dictionary data into the current instance.

Creates a new settings instance, then applies the dictionary data through validation, and finally merges the validated settings into the current instance. None values are not merged.

Parameters:: data (dict) – Dictionary containing field values to merge into the current settings instance.
Raises:: ValidationError – If the data contains invalid values for the defined fields.

Example

>>> config = get_config()
>>> new_data = {"prediction": {"hours": 24}, "server": {"port": 8000}}
>>> config.merge_settings_from_dict(new_data)

reset_settings() → None

Reset all changed settings to environment/config file defaults.

This functions basically deletes the settings provided before.

revert_settings(backup_id: str) → None

Revert application settings to a stored backup.

This method restores configuration values from a backup file identified by backup_id. The backup is expected to exist alongside the main configuration file, using the main config file’s path but with the given suffix. Any settings previously applied will be overwritten.

Parameters:

backup_id (str) – The suffix used to locate the backup configuration file. Example: ".bak" or ".backup".

Returns:

The method does not return a value.

Return type:

None

Raises:

ValueError – If the backup file cannot be found at the constructed path.
json.JSONDecodeError – If the backup file exists but contains invalid JSON.
TypeError – If the unpacked backup data fails to match the signature required by self._setup().
OSError – If reading the backup file fails due to I/O issues.

list_backups() → dict[str, dict[str, Any]]

List available configuration backup files and extract metadata.

Backup files are identified by sharing the same stem as the main config file but having a different suffix. Each backup file is assumed to contain a JSON object.

The returned dictionary uses backup_id (suffix) as keys. The value for each key is a dictionary including: - storage_time: The file modification timestamp in ISO-8601 format. - version: Version information found in the backup file

(defaults to "unknown").

Returns:

Mapping of backup identifiers to metadata.

Return type:

dict[str, dict[str, Any]]

Raises:

OSError – If directory scanning or file reading fails.
json.JSONDecodeError – If a backup file cannot be parsed as JSON.

to_config_file() → None

Saves the current configuration to the configuration file.

Also updates the configuration file settings.

Raises:: ValueError – If the configuration file path is not specified or can not be written to.

update() → None

Updates all configuration fields.

This method updates all configuration fields using the following order for value retrieval:

Current settings.
Environment variables.
EOS configuration file.
Field default constants.

The first non None value in priority order is taken.

__copy__() → Self: Returns a shallow copy of the model.

__deepcopy__(memo: dict[int, Any] | None = None) → Self: Returns a deep copy of the model.

classmethod __get_pydantic_json_schema__(core_schema: CoreSchema, handler: GetJsonSchemaHandler, /) → JsonSchemaValue

Hook into generating the model’s JSON schema.

Parameters:

core_schema – A pydantic-core CoreSchema. You can ignore this argument and call the handler with a new CoreSchema, wrap this CoreSchema ({‘type’: ‘nullable’, ‘schema’: current_schema}), or just call the handler with the original schema.
handler – Call into Pydantic’s internal JSON schema generation. This will raise a pydantic.errors.PydanticInvalidForJsonSchema if JSON schema generation fails. Since this gets called by BaseModel.model_json_schema you can override the schema_generator argument to that function to change JSON schema generation globally for a type.

Returns:

A JSON schema, as a Python object.

__iter__() → Generator[tuple[str, Any], None, None]: So dict(model) works.

static __new__(cls: Type[SingletonMixin], *args: Any, **kwargs: Any) → SingletonMixin

Creates or returns the singleton instance of the class.

Ensures thread-safe instance creation by locking during the first instantiation.

Parameters:

*args – Positional arguments for instance creation (ignored if instance exists).
**kwargs – Keyword arguments for instance creation (ignored if instance exists).

Returns:

The singleton instance of the derived class.

Return type:

SingletonMixin

__pretty__(fmt: Callable[[Any], Any], **kwargs: Any) → Generator[Any]: Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.

classmethod __pydantic_init_subclass__(**kwargs: Any) → None

This is intended to behave just like __init_subclass__, but is called by ModelMetaclass only after basic class initialization is complete. In particular, attributes like model_fields will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.

This is necessary because __init_subclass__ will always be called by type.__new__, and it would require a prohibitively large refactor to the ModelMetaclass to ensure that type.__new__ was called in such a manner that the class would already be sufficiently initialized.

This will receive the same kwargs that would be passed to the standard __init_subclass__, namely, any kwargs passed to the class definition that aren’t used internally by Pydantic.

Parameters:: **kwargs – Any keyword arguments passed to the class definition that aren’t used internally by Pydantic.

Note

You may want to override [__pydantic_on_complete__()][pydantic.main.BaseModel.__pydantic_on_complete__] instead, which is called once the class and its fields are fully initialized and ready for validation.

classmethod __pydantic_on_complete__() → None

This is called once the class and its fields are fully initialized and ready to be used.

This typically happens when the class is created (just before [__pydantic_init_subclass__()][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [model_rebuild()][pydantic.main.BaseModel.model_rebuild].

__repr_name__() → str: Name of the instance’s class, used in __repr__.

__repr_recursion__(object: Any) → str: Returns the string representation of a recursive object.

__rich_repr__() → RichReprResult: Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.

classmethod construct(_fields_set: set[str] | None = None, **values: Any) → Self

Returns a copy of the model.

!!! warning “Deprecated”: This method is now deprecated; use model_copy instead.

If you need include or exclude, use:

`python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) `

Parameters:

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

Returns:

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

dict(*, include: set[int] | set[str] | Mapping[int, set[int] | set[str] | Mapping[int, IncEx | bool] | Mapping[str, IncEx | bool] | bool] | Mapping[str, set[int] | set[str] | Mapping[int, IncEx | bool] | Mapping[str, IncEx | bool] | bool] | None = None, exclude: set[int] | set[str] | Mapping[int, set[int] | set[str] | Mapping[int, IncEx | bool] | Mapping[str, IncEx | bool] | bool] | Mapping[str, set[int] | set[str] | Mapping[int, IncEx | bool] | Mapping[str, IncEx | bool] | bool] | None = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False) → Dict[str, Any]

classmethod from_orm(obj: Any) → Self

get_nested_value(path: str) → Any

Retrieve a nested value from the model using a ‘/’-separated path.

Supports accessing nested attributes and list indices.

Parameters:

path (str) – A ‘/’-separated path to the nested attribute (e.g., “key1/key2/0”).

Returns:

The retrieved value.

Return type:

Any

Raises:

KeyError – If a key is not found in the model.
IndexError – If a list index is out of bounds or invalid.

Example

```python class Address(PydanticBaseModel):

city: str

class User(PydanticBaseModel):: name: str address: Address

user = User(name=”Alice”, address=Address(city=”New York”)) city = user.get_nested_value(“address/city”) print(city) # Output: “New York” ```

json(*, include: set[int] | set[str] | Mapping[int, set[int] | set[str] | Mapping[int, IncEx | bool] | Mapping[str, IncEx | bool] | bool] | Mapping[str, set[int] | set[str] | Mapping[int, IncEx | bool] | Mapping[str, IncEx | bool] | bool] | None = None, exclude: set[int] | set[str] | Mapping[int, set[int] | set[str] | Mapping[int, IncEx | bool] | Mapping[str, IncEx | bool] | bool] | Mapping[str, set[int] | set[str] | Mapping[int, IncEx | bool] | Mapping[str, IncEx | bool] | bool] | 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_computed_fields = {}

model_config: ClassVar[SettingsConfigDict] = {'arbitrary_types_allowed': True, 'case_sensitive': False, 'cli_avoid_json': False, 'cli_enforce_required': False, 'cli_exit_on_error': True, 'cli_flag_prefix_char': '-', 'cli_hide_none_type': False, 'cli_ignore_unknown_args': False, 'cli_implicit_flags': False, 'cli_kebab_case': False, 'cli_parse_args': None, 'cli_parse_none_str': None, 'cli_prefix': '', 'cli_prog_name': None, 'cli_shortcuts': None, 'cli_use_class_docs_for_groups': False, 'enable_decoding': True, 'env_file': None, 'env_file_encoding': None, 'env_ignore_empty': False, 'env_nested_delimiter': '__', 'env_nested_max_split': None, 'env_parse_enums': None, 'env_parse_none_str': None, 'env_prefix': 'EOS_', 'extra': 'forbid', 'ignored_types': (<class 'akkudoktoreos.core.decorators.classproperty'>,), 'json_file': None, 'json_file_encoding': None, 'nested_model_default_partial_update': True, 'protected_namespaces': ('model_validate', 'model_dump', 'settings_customise_sources'), 'secrets_dir': None, 'toml_file': None, 'validate_default': True, 'yaml_config_section': None, 'yaml_file': None, 'yaml_file_encoding': None}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

classmethod 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:

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

Returns:

A new instance of the Model class with validated data.

model_copy(*, update: Mapping[str, Any] | None = None, deep: bool = False) → Self

!!! abstract “Usage Documentation”: [model_copy](../concepts/models.md#model-copy)

Returns a copy of the model.

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

Parameters:

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

Returns:

New model instance.

!!! abstract “Usage Documentation”: [model_dump](../concepts/serialization.md#python-mode)

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

Parameters:

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

Returns:

A dictionary representation of the model.

!!! abstract “Usage Documentation”: [model_dump_json](../concepts/serialization.md#json-mode)

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

Parameters:

indent – Indentation to use in the JSON output. If None is passed, the output will be compact.
ensure_ascii – If True, the output is guaranteed to have all incoming non-ASCII characters escaped. If False (the default), these characters will be output as-is.
include – Field(s) to include in the JSON output.
exclude – Field(s) to exclude from the JSON output.
context – Additional context to pass to the serializer.
by_alias – Whether to serialize using field aliases.
exclude_unset – Whether to exclude fields that have not been explicitly set.
exclude_defaults – Whether to exclude fields that are set to their default value.
exclude_none – Whether to exclude fields that have a value of None.
exclude_computed_fields – Whether to exclude computed fields. While this can be useful for round-tripping, it is usually recommended to use the dedicated round_trip parameter instead.
round_trip – If True, dumped values should be valid as input for non-idempotent types such as Json[T].
warnings – How to handle serialization errors. False/”none” ignores them, True/”warn” logs errors, “error” raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
fallback – A function to call when an unknown value is encountered. If not provided, a [PydanticSerializationError][pydantic_core.PydanticSerializationError] error is raised.
serialize_as_any – Whether to serialize fields with duck-typing serialization behavior.

Returns:

A JSON string representation of the model.

property model_extra: dict[str, Any] | None

Get extra fields set during validation.

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

model_fields = {'cache': FieldInfo(annotation=CacheCommonSettings, required=False, default=CacheCommonSettings(subpath='cache', cleanup_interval=300)), 'devices': FieldInfo(annotation=DevicesCommonSettings, required=False, default=DevicesCommonSettings(batteries=None, max_batteries=None, electric_vehicles=None, max_electric_vehicles=None, inverters=None, max_inverters=None, home_appliances=None, max_home_appliances=None, measurement_keys=[])), 'elecprice': FieldInfo(annotation=ElecPriceCommonSettings, required=False, default=ElecPriceCommonSettings(provider=None, charges_kwh=None, vat_rate=1.19, provider_settings=ElecPriceCommonProviderSettings(ElecPriceImport=None))), 'ems': FieldInfo(annotation=EnergyManagementCommonSettings, required=False, default=EnergyManagementCommonSettings(startup_delay=5, interval=None, mode=None)), 'feedintariff': FieldInfo(annotation=FeedInTariffCommonSettings, required=False, default=FeedInTariffCommonSettings(provider=None, provider_settings=FeedInTariffCommonProviderSettings(FeedInTariffFixed=None, FeedInTariffImport=None))), 'general': FieldInfo(annotation=GeneralSettings, required=False, default=GeneralSettings(version='0.2.0', data_folder_path=None, data_output_subpath='output', latitude=52.52, longitude=13.405, timezone='Europe/Berlin', data_output_path=None, config_folder_path=Path('/home/docs/.config/net.akkudoktor.eos'), config_file_path=Path('/home/docs/.config/net.akkudoktor.eos/EOS.config.json'))), 'load': FieldInfo(annotation=LoadCommonSettings, required=False, default=LoadCommonSettings(provider=None, provider_settings=LoadCommonProviderSettings(LoadAkkudoktor=None, LoadVrm=None, LoadImport=None))), 'logging': FieldInfo(annotation=LoggingCommonSettings, required=False, default=LoggingCommonSettings(console_level=None, file_level=None, file_path=Path('/home/docs/.local/share/net.akkudoktor.eos/output/eos.log'))), 'measurement': FieldInfo(annotation=MeasurementCommonSettings, required=False, default=MeasurementCommonSettings(load_emr_keys=None, grid_export_emr_keys=None, grid_import_emr_keys=None, pv_production_emr_keys=None, keys=[])), 'optimization': FieldInfo(annotation=OptimizationCommonSettings, required=False, default=OptimizationCommonSettings(horizon_hours=24, interval=3600, algorithm='GENETIC', genetic=GeneticCommonSettings(individuals=300, generations=400, seed=None, penalties=None))), 'prediction': FieldInfo(annotation=PredictionCommonSettings, required=False, default=PredictionCommonSettings(hours=48, historic_hours=48)), 'pvforecast': FieldInfo(annotation=PVForecastCommonSettings, required=False, default=PVForecastCommonSettings(provider=None, provider_settings=PVForecastCommonProviderSettings(PVForecastImport=None, PVForecastVrm=None), planes=None, max_planes=0, planes_peakpower=[], planes_azimuth=[], planes_tilt=[], planes_userhorizon=[], planes_inverter_paco=[])), 'server': FieldInfo(annotation=ServerCommonSettings, required=False, default=ServerCommonSettings(host='127.0.0.1', port=8503, verbose=False, startup_eosdash=True, eosdash_host=None, eosdash_port=None)), 'utils': FieldInfo(annotation=UtilsCommonSettings, required=False, default=UtilsCommonSettings()), 'weather': FieldInfo(annotation=WeatherCommonSettings, required=False, default=WeatherCommonSettings(provider=None, provider_settings=WeatherCommonProviderSettings(WeatherImport=None)))}

property model_fields_set: set[str]

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

Returns:

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

classmethod model_json_schema(by_alias: bool = True, ref_template: str = '#/$defs/{model}', schema_generator: type[~pydantic.json_schema.GenerateJsonSchema] = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: ~typing.Literal['validation', 'serialization'] = 'validation', *, union_format: ~typing.Literal['any_of', 'primitive_type_array'] = 'any_of') → dict[str, Any]

Generates a JSON schema for a model class.

Parameters:

by_alias – Whether to use attribute aliases or not.
ref_template – The reference template.
union_format –
The format to use when combining schemas from unions together. Can be one of:
- ’any_of’: Use the [anyOf](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
keyword to combine schemas (the default). - ‘primitive_type_array’: Use the [type](https://json-schema.org/understanding-json-schema/reference/type) keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive type (string, boolean, null, integer or number) or contains constraints/metadata, falls back to any_of.
schema_generator – To override the logic used to generate the JSON schema, as a subclass of GenerateJsonSchema with your desired modifications
mode – The mode in which to generate the schema.

Returns:

The JSON schema for the given model class.

classmethod 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:: params – Tuple of types of the class. Given a generic class Model with 2 type variables and a concrete model Model[str, int], the value (str, int) would be passed to params.
Returns:: String representing the new class where params are passed to cls as type variables.
Raises:: TypeError – Raised when trying to generate concrete names for non-generic models.

model_post_init(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.

classmethod 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:

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

Returns:

Returns None if the schema is already “complete” and rebuilding was not required. If rebuilding _was_ required, returns True if rebuilding was successful, otherwise False.

Validate a pydantic model instance.

Parameters:

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

Raises:

ValidationError – If the object could not be validated.

Returns:

The validated model instance.

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

Validate the given JSON data against the Pydantic model.

Parameters:

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

Returns:

The validated Pydantic model.

Raises:

ValidationError – If json_data is not a JSON string or the object could not be validated.

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

Parameters:

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

Returns:

The validated Pydantic model.

classmethod parse_file(path: str | Path, *, content_type: str | None = None, encoding: str = 'utf8', proto: DeprecatedParseProtocol | None = None, allow_pickle: bool = False) → Self

classmethod parse_obj(obj: Any) → Self

classmethod parse_raw(b: str | bytes, *, content_type: str | None = None, encoding: str = 'utf8', proto: DeprecatedParseProtocol | None = None, allow_pickle: bool = False) → Self

classmethod reset_instance() → None: Resets the singleton instance, forcing it to be recreated on next access.

classmethod schema(by_alias: bool = True, ref_template: str = '#/$defs/{model}') → Dict[str, Any]

classmethod schema_json(*, by_alias: bool = True, ref_template: str = '#/$defs/{model}', **dumps_kwargs: Any) → str

set_nested_value(path: str, value: Any) → None

Set a nested value in the model using a ‘/’-separated path.

Supports modifying nested attributes and list indices while preserving Pydantic validation. Automatically initializes missing Optional, Union, dict, and list fields if necessary. If a missing field cannot be initialized, raises an exception.

Triggers the callbacks registered by track_nested_value().

Parameters:

path (str) – A ‘/’-separated path to the nested attribute (e.g., “key1/key2/0”).
value (Any) – The new value to set.

Raises:

KeyError – If a key is not found in the model.
IndexError – If a list index is out of bounds or invalid.
ValueError – If a validation error occurs.
TypeError – If a missing field cannot be initialized.

Example

```python class Address(PydanticBaseModel):

city: Optional[str]

class User(PydanticBaseModel):: name: str address: Optional[Address] settings: Optional[Dict[str, Any]]

user = User(name=”Alice”, address=None, settings=None) user.set_nested_value(“address/city”, “Los Angeles”) user.set_nested_value(“settings/theme”, “dark”)

print(user.address.city) # Output: “Los Angeles” print(user.settings) # Output: {‘theme’: ‘dark’} ```

track_nested_value(path: str, callback: Callable[[Any, str, Any, Any], None]) → None

Register a callback for a specific path (or subtree).

Callback triggers if set path is equal or deeper.

Parameters:

path (str) – ‘/’-separated path to track.
callback (callable) – Function called as callback(model_instance, set_path, old_value, new_value).

classmethod update_forward_refs(**localns: Any) → None

classmethod validate(value: Any) → Self

general: GeneralSettings

cache: CacheCommonSettings

ems: EnergyManagementCommonSettings

logging: LoggingCommonSettings

devices: DevicesCommonSettings

measurement: MeasurementCommonSettings

optimization: OptimizationCommonSettings

prediction: PredictionCommonSettings

elecprice: ElecPriceCommonSettings

feedintariff: FeedInTariffCommonSettings

load: LoadCommonSettings

pvforecast: PVForecastCommonSettings

weather: WeatherCommonSettings

server: ServerCommonSettings

utils: UtilsCommonSettings