akkudoktoreos.prediction.loadimport.LoadImport

class akkudoktoreos.prediction.loadimport.LoadImport(*args: ~typing.Any, records: ~typing.List[~akkudoktoreos.prediction.loadabc.LoadDataRecord] = <factory>, update_datetime: ~pydantic.types.AwareDatetime | None = None)

Bases: LoadProvider, PredictionImportProvider

Fetch Load data from import file or JSON string.

LoadImport is a singleton-based class that retrieves load forecast data from a file or JSON string and maps it to LoadDataRecord fields. It manages the forecast over a range of hours into the future and retains historical data.

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

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Methods

__init__(*args, **kwargs)

Create a new model by parsing and validating input data from keyword arguments.

append(value)

S.append(value) -- append value to the end of the sequence

clear()

construct([_fields_set])

copy(*[, include, exclude, update, deep])

Returns a copy of the model.

count(value)

delete_by_datetime([start_datetime, ...])

Delete DataRecords from the sequence within a specified datetime range.

dict(*[, include, exclude, by_alias, ...])

enabled()

Return True if the provider is enabled according to configuration.

extend(values)

S.extend(iterable) -- extend sequence by appending elements from the iterable

filter_by_datetime([start_datetime, ...])

Returns a new DataSequence object containing only records within the specified datetime range.

from_dict(data)

Create a PydanticBaseModel instance from a dictionary.

from_json(json_str)

Create an instance of the PydanticBaseModel class or its subclass from a JSON string.

from_orm(obj)

get_nested_value(path)

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

historic_hours_min()

Return the minimum historic prediction hours for specific data.

import_datetimes(start_datetime, value_count)

Generates a list of tuples containing timestamps and their corresponding value indices.

import_from_dataframe(df[, key_prefix, ...])

Updates generic data by importing it from a pandas DataFrame.

import_from_dict(import_data[, key_prefix, ...])

Updates generic data by importing it from a dictionary.

import_from_file(import_file_path[, ...])

Updates generic data by importing it from a file.

import_from_json(json_str[, key_prefix, ...])

Updates generic data by importing it from a JSON string.

index(value, [start, [stop]])

Raises ValueError if the value is not present.

insert(index, value)

Insert a DataRecord at a specified index in the sequence.

insert_by_datetime(value)

Insert or merge a DataRecord into the sequence based on its date.

json(*[, include, exclude, by_alias, ...])

key_delete_by_datetime(key[, ...])

Delete an attribute specified by key from records in the sequence within a given datetime range.

key_from_lists(key, dates, values)

Update the DataSequence from lists of datetime and value elements.

key_from_series(key, series)

Update the DataSequence from a Pandas Series.

key_to_array(key[, start_datetime, ...])

Extract an array indexed by fixed time intervals from data records within an optional date range.

key_to_dict(key[, start_datetime, ...])

Extract a dictionary indexed by the date_time field of the DataRecords.

key_to_lists(key[, start_datetime, ...])

Extracts two lists from data records within an optional date range.

key_to_series(key[, start_datetime, ...])

Extract a series indexed by the date_time field from data records within an optional date range.

key_to_value(key, target_datetime)

Returns the value corresponding to the specified key that is nearest to the given datetime.

model_construct([_fields_set])

Creates a new instance of the Model class with validated data.

model_copy(*[, update, deep])

!!! abstract "Usage Documentation"

model_dump(*args[, include_computed_fields])

Custom dump method to serialize computed fields by default.

model_dump_json(*args[, indent])

!!! 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, /)

This function is meant to behave like a BaseModel method to initialise private attributes.

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, ...])

pop([index])

Raise IndexError if list is empty or index is out of range.

provider_id()

Return the unique identifier for the LoadImport provider.

record_class()

Get the class of the data record handled by this data sequence.

remove(value)

S.remove(value) -- remove first occurrence of value.

reset_instance()

Resets the singleton instance, forcing it to be recreated on next access.

reset_to_defaults()

Resets the fields to their default values.

reverse()

S.reverse() -- reverse IN PLACE

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.

sort_by_datetime([reverse])

Sort the DataRecords in the sequence by their date_time attribute.

to_dataframe([start_datetime, end_datetime])

Converts the sequence of DataRecord instances into a Pandas DataFrame.

to_datetimeindex()

Generate a Pandas DatetimeIndex from the date_time fields of all records in the sequence.

to_dict()

Convert this PredictionRecord instance to a dictionary representation.

to_json()

Convert the PydanticBaseModel instance to a JSON string.

track_nested_value(path, callback)

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

update_data([force_enable, force_update])

Update prediction parameters and call the custom update function.

update_forward_refs(**localns)

update_value(date, *args, **kwargs)

Updates specific values in the data record for a given date.

validate(value)

Attributes

config

ems

ems_start_datetime

end_datetime

Compute the end datetime based on the start_datetime and hours.

keep_datetime

Compute the keep datetime for historical data retention.

keep_hours

Compute the hours from keep_datetime to start_datetime.

max_datetime

Maximum (latest) datetime in the sorted sequence of data records.

measurement

min_datetime

Minimum (earliest) datetime in the sorted sequence of data records.

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.

record_keys

Returns the keys of all fields in the data records.

record_keys_writable

Get the keys of all writable fields in the data records.

total_hours

Compute the hours from start_datetime to end_datetime.

records

update_datetime

classmethod provider_id() → str

Return the unique identifier for the LoadImport provider.

__copy__() → Self

Returns a shallow copy of the model.

__deepcopy__(memo: dict[int, Any] | None = None) → Self

Returns a deep copy of the model.

__delitem__(index: Any) → None

Remove a single data record or a slice of records.

Supports deleting a single record by integer index or multiple records using a slice.

Parameters:

index (int or slice) – The index or slice to delete.

Raises:

IndexError – If the index is out of range.

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.

__getitem__(index: int | slice) → DataRecord | list[DataRecord]

Retrieve a DataRecord or list of DataRecords by index or slice.

Supports both single item and slice-based access to the sequence.

Parameters:

index (int or slice) – The index or slice to access.

Returns:

A single DataRecord or a list of DataRecords.

Return type:

DataRecord or list[DataRecord]

Raises:

IndexError – If the index is invalid or out of range.

__hash__() → int

Returns a stable hash based on the instance’s UUID.

Returns:

Hash value derived from the model’s UUID.

Return type:

int

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

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

__iter__() → Iterator[DataRecord]

Create an iterator for accessing DataRecords sequentially.

Returns:

An iterator for the records.

Return type:

Iterator[DataRecord]

__len__() → int

Get the number of DataRecords in the sequence.

Returns:

The count of records in the sequence.

Return type:

int

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__() → str

Provide a string representation of the DataSequence.

Returns:

A string representation of the DataSequence.

Return type:

str

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

__setitem__(index: Any, value: Any) → None

Replace a data record or slice of records with new value(s).

Supports setting a single record at an integer index or multiple records using a slice.

Parameters:

  • index (int or slice) – The index or slice to modify.

  • value (DataRecord or list[DataRecord]) – Single record or list of records to set.

Raises:

  • ValueError – If the number of records does not match the slice length.

  • IndexError – If the index is out of range.

append(value)

S.append(value) – append value to the end of the sequence

clear() → None -- remove all items from S
config = ConfigEOS(general=GeneralSettings(version='0.2.0', data_folder_path=Path('/home/docs/.local/share/net.akkudoktor.eos'), data_output_subpath=Path('output'), latitude=52.52, longitude=13.405, timezone='Europe/Berlin', data_output_path=Path('/home/docs/.local/share/net.akkudoktor.eos/output'), 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(subpath=Path('cache'), cleanup_interval=300.0), ems=EnergyManagementCommonSettings(startup_delay=5.0, interval=None, mode=None), logging=LoggingCommonSettings(console_level='INFO', file_level=None, file_path=Path('/home/docs/.local/share/net.akkudoktor.eos/output/eos.log')), devices=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(load_emr_keys=None, grid_export_emr_keys=None, grid_import_emr_keys=None, pv_production_emr_keys=None, keys=[]), optimization=OptimizationCommonSettings(horizon_hours=24, interval=3600, algorithm='GENETIC', genetic=GeneticCommonSettings(individuals=300, generations=400, seed=None, penalties=None)), prediction=PredictionCommonSettings(hours=48, historic_hours=48), elecprice=ElecPriceCommonSettings(provider=None, charges_kwh=None, vat_rate=1.19, provider_settings=ElecPriceCommonProviderSettings(ElecPriceImport=None)), feedintariff=FeedInTariffCommonSettings(provider=None, provider_settings=FeedInTariffCommonProviderSettings(FeedInTariffFixed=None, FeedInTariffImport=None)), load=LoadCommonSettings(provider=None, provider_settings=LoadCommonProviderSettings(LoadAkkudoktor=None, LoadVrm=None, LoadImport=None)), pvforecast=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(provider=None, provider_settings=WeatherCommonProviderSettings(WeatherImport=None)), server=ServerCommonSettings(host='127.0.0.1', port=8503, verbose=False, startup_eosdash=True, eosdash_host=None, eosdash_port=None), utils=UtilsCommonSettings())
classmethod construct(_fields_set: set[str] | None = None, **values: Any) → Self
copy(*, 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.

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

count(value) → integer -- return number of occurrences of value
delete_by_datetime(start_datetime: DateTime | None = None, end_datetime: DateTime | None = None) → None

Delete DataRecords from the sequence within a specified datetime range.

Removes records with date_time attributes that fall between start_datetime (inclusive) and end_datetime (exclusive). If only start_datetime is provided, records from that date onward will be removed. If only end_datetime is provided, records up to that date will be removed. If none is given, no record will be deleted.

Parameters:

  • start_datetime (datetime, optional) – The start date to begin deleting records (inclusive).

  • end_datetime (datetime, optional) – The end date to stop deleting records (exclusive).

Raises:

ValueError – If both start_datetime and end_datetime are None.

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]
ems = EnergyManagement(start_datetime=DateTime(2025, 11, 9, 8, 0, 0, tzinfo=Timezone('Etc/UTC')), last_run_datetime=None)
ems_start_datetime = DateTime(2025, 11, 9, 8, 0, 0, tzinfo=Timezone('Etc/UTC'))
enabled() → bool

Return True if the provider is enabled according to configuration.

To be implemented by derived classes.

property end_datetime: DateTime | None

Compute the end datetime based on the start_datetime and hours.

Ajusts the calculated end time if DST transitions occur within the prediction window.

Returns:

The calculated end datetime, or None if inputs are missing.

Return type:

Optional[DateTime]

extend(values)

S.extend(iterable) – extend sequence by appending elements from the iterable

filter_by_datetime(start_datetime: DateTime | None = None, end_datetime: DateTime | None = None) → DataSequence

Returns a new DataSequence object containing only records within the specified datetime range.

Parameters:

  • start_datetime (Optional[datetime]) – The start of the datetime range (inclusive). If None, no lower limit.

  • end_datetime (Optional[datetime]) – The end of the datetime range (exclusive). If None, no upper limit.

Returns:

A new DataSequence object with filtered records.

Return type:

DataSequence

classmethod from_dict(data: dict) → PydanticBaseModel

Create a PydanticBaseModel instance from a dictionary.

Parameters:

data (dict) – A dictionary containing data to initialize the PydanticBaseModel. Keys should match the field names defined in the model.

Returns:

An instance of the PydanticBaseModel populated with the data.

Return type:

PydanticBaseModel

Notes

Works with derived classes by ensuring the cls argument is used to instantiate the object.

classmethod from_json(json_str: str) → PydanticBaseModel

Create an instance of the PydanticBaseModel class or its subclass from a JSON string.

Parameters:

json_str (str) – JSON string to parse and convert into a PydanticBaseModel instance.

Returns:

A new instance of the class, populated with data from the JSON string.

Return type:

PydanticBaseModel

Notes

Works with derived classes by ensuring the cls argument is used to instantiate the object.

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

historic_hours_min() → int

Return the minimum historic prediction hours for specific data.

To be implemented by derived classes if default 0 is not appropriate.

import_datetimes(start_datetime: DateTime, value_count: int, interval: Duration | None = None) → List[Tuple[DateTime, int]]

Generates a list of tuples containing timestamps and their corresponding value indices.

The function accounts for daylight saving time (DST) transitions: - During a spring forward transition (e.g., DST begins), skipped hours are omitted. - During a fall back transition (e.g., DST ends), repeated hours are included, but they share the same value index.

Parameters:

  • start_datetime (DateTime) – Start datetime of values

  • value_count (int) – The number of timestamps to generate.

  • interval (duration, optional) – The fixed time interval. Defaults to 1 hour.

Returns:

A list of tuples, where each tuple contains: - A DateTime object representing an hourly step from start_datetime. - An integer value index corresponding to the logical hour.

Return type:

List[Tuple[DateTime, int]]

Behavior:

  • Skips invalid timestamps during DST spring forward transitions.

  • Includes both instances of repeated timestamps during DST fall back transitions.

  • Ensures the list contains exactly value_count entries.

Example

>>> start_datetime = pendulum.datetime(2024, 11, 3, 0, 0, tz="America/New_York")
>>> import_datetimes(start_datetime, 5)
[(DateTime(2024, 11, 3, 0, 0, tzinfo=Timezone('America/New_York')), 0),
(DateTime(2024, 11, 3, 1, 0, tzinfo=Timezone('America/New_York')), 1),
(DateTime(2024, 11, 3, 1, 0, tzinfo=Timezone('America/New_York')), 1),  # Repeated hour
(DateTime(2024, 11, 3, 2, 0, tzinfo=Timezone('America/New_York')), 2),
(DateTime(2024, 11, 3, 3, 0, tzinfo=Timezone('America/New_York')), 3)]
import_from_dataframe(df: DataFrame, key_prefix: str = '', start_datetime: DateTime | None = None, interval: Duration | None = None) → None

Updates generic data by importing it from a pandas DataFrame.

This method reads generic data from a DataFrame, matches columns based on the record keys and the provided key_prefix, and updates the data values using the DataFrame’s index as timestamps.

Parameters:

  • df (pd.DataFrame) – DataFrame containing the generic data with datetime index or sequential values.

  • key_prefix (str, optional) – A prefix to filter relevant columns from the DataFrame. Only columns starting with this prefix will be considered. Defaults to an empty string.

  • start_datetime (DateTime, optional) – Start datetime if DataFrame doesn’t have datetime index.

  • interval (Duration, optional) – The fixed time interval if DataFrame doesn’t have datetime index.

Raises:

ValueError – If DataFrame structure is invalid or datetime conversion fails.

import_from_dict(import_data: dict, key_prefix: str = '', start_datetime: DateTime | None = None, interval: Duration | None = None) → None

Updates generic data by importing it from a dictionary.

This method reads generic data from a dictionary, matches keys based on the record keys and the provided key_prefix, and updates the data values sequentially. All value lists must have the same length.

Parameters:

  • import_data (dict) – Dictionary containing the generic data with optional ‘start_datetime’ and ‘interval’ keys.

  • key_prefix (str, optional) – A prefix to filter relevant keys from the generic data. Only keys starting with this prefix will be considered. Defaults to an empty string.

  • start_datetime (DateTime, optional) – Start datetime of values if not in dict.

  • interval (Duration, optional) – The fixed time interval if not in dict.

Raises:

ValueError – If value lists have different lengths or if datetime conversion fails.

import_from_file(import_file_path: Path, key_prefix: str = '', start_datetime: DateTime | None = None, interval: Duration | None = None) → None

Updates generic data by importing it from a file.

This method reads generic data from a JSON file, matches keys based on the record keys and the provided key_prefix, and updates the data values sequentially, starting from the start_datetime. Each data value is associated with an hourly interval.

If start_datetime and or interval is given in the JSON dict it will be used. Otherwise the given parameters are used. If None is given start_datetime defaults to ‘self.ems_start_datetime’ and interval defaults to 1 hour.

Parameters:

  • import_file_path (Path) – The path to the JSON file containing the generic data.

  • key_prefix (str, optional) – A prefix to filter relevant keys from the generic data. Only keys starting with this prefix will be considered. Defaults to an empty string.

  • start_datetime (DateTime, optional) – Start datetime of values.

  • interval (duration, optional) – The fixed time interval. Defaults to 1 hour.

Raises:

  • FileNotFoundError – If the specified file does not exist.

  • JSONDecodeError – If the file content is not valid JSON.

Example

Given a JSON file with the following content: ```json {

“loadforecast_power_w”: [20.5, 21.0, 22.1], “other_xyz: [10.5, 11.0, 12.1],

}

and key_prefix = “load”, only the “loadforecast_power_w” key will be processed even though both keys are in the record.

import_from_json(json_str: str, key_prefix: str = '', start_datetime: DateTime | None = None, interval: Duration | None = None) → None

Updates generic data by importing it from a JSON string.

This method reads generic data from a JSON string, matches keys based on the record keys and the provided key_prefix, and updates the data values sequentially, starting from the start_datetime.

If start_datetime and or interval is given in the JSON dict it will be used. Otherwise the given parameters are used. If None is given start_datetime defaults to ‘self.ems_start_datetime’ and interval defaults to 1 hour.

Parameters:

  • json_str (str) – The JSON string containing the generic data.

  • key_prefix (str, optional) – A prefix to filter relevant keys from the generic data. Only keys starting with this prefix will be considered. Defaults to an empty string.

  • start_datetime (DateTime, optional) – Start datetime of values.

  • interval (duration, optional) – The fixed time interval. Defaults to 1 hour.

Raises:

JSONDecodeError – If the file content is not valid JSON.

Example

Given a JSON string with the following content: ```json {

“start_datetime”: “2024-11-10 00:00:00” “interval”: “30 minutes” “loadforecast_power_w”: [20.5, 21.0, 22.1], “other_xyz: [10.5, 11.0, 12.1],

}

and key_prefix = “load”, only the “loadforecast_power_w” key will be processed even though both keys are in the record.

index(value[, start[, stop]]) → integer -- return first index of value.

Raises ValueError if the value is not present.

Supporting start and stop arguments is optional, but recommended.

insert(index: int, value: DataRecord) → None

Insert a DataRecord at a specified index in the sequence.

This method inserts a DataRecord at the specified index within the sequence of records, shifting subsequent records to the right. If index is 0, the record is added at the beginning of the sequence, and if index is equal to the length of the sequence, the record is appended at the end.

Parameters:

  • index (int) – The position before which to insert the new record. An index of 0 inserts the record at the start, while an index equal to the length of the sequence appends it to the end.

  • value (DataRecord) – The DataRecord instance to insert into the sequence.

Raises:

ValueError – If value is not an instance of DataRecord.

insert_by_datetime(value: DataRecord) → None

Insert or merge a DataRecord into the sequence based on its date.

If a record with the same date exists, merges new data fields with the existing record. Otherwise, appends the record and maintains chronological order.

Parameters:

value (DataRecord) – The record to add or merge.

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
property keep_datetime: DateTime | None

Compute the keep datetime for historical data retention.

Returns:

The calculated retention cutoff datetime, or None if inputs are missing.

Return type:

Optional[DateTime]

property keep_hours: int | None

Compute the hours from keep_datetime to start_datetime.

Returns:

The duration hours, or None if either datetime is unavailable.

Return type:

Optional[pendulum.period]

key_delete_by_datetime(key: str, start_datetime: DateTime | None = None, end_datetime: DateTime | None = None) → None

Delete an attribute specified by key from records in the sequence within a given datetime range.

This method removes the attribute identified by key from records that have a date_time value falling within the specified start_datetime (inclusive) and end_datetime (exclusive) range.

  • If only start_datetime is specified, attributes will be removed from records from that date onward.

  • If only end_datetime is specified, attributes will be removed from records up to that date.

  • If neither start_datetime nor end_datetime is given, the attribute will be removed from all records.

Parameters:

  • key (str) – The attribute name to delete from each record.

  • start_datetime (datetime, optional) – The start datetime to begin attribute deletion (inclusive).

  • end_datetime (datetime, optional) – The end datetime to stop attribute deletion (exclusive).

Raises:

KeyError – If key is not a valid attribute of the records.

key_from_lists(key: str, dates: List[DateTime], values: List[float]) → None

Update the DataSequence from lists of datetime and value elements.

The dates list should represent the date_time of each DataRecord, and the values list should represent the corresponding data values for the specified key.

Parameters:

  • key (str) – The field name in the DataRecord that corresponds to the values in the Series.

  • dates – List of datetime elements.

  • values – List of values corresponding to the specified key in the data records.

key_from_series(key: str, series: Series) → None

Update the DataSequence from a Pandas Series.

The series index should represent the date_time of each DataRecord, and the series values should represent the corresponding data values for the specified key.

Parameters:

  • series (pd.Series) – A Pandas Series containing data to update the DataSequence.

  • key (str) – The field name in the DataRecord that corresponds to the values in the Series.

key_to_array(key: str, start_datetime: DateTime | None = None, end_datetime: DateTime | None = None, interval: Duration | None = None, fill_method: str | None = None, dropna: bool | None = None) → Any]

Extract an array indexed by fixed time intervals from data records within an optional date range.

Parameters:

  • key (str) – The field name in the DataRecord from which to extract values.

  • start_datetime (datetime, optional) – The start date for filtering the records (inclusive).

  • end_datetime (datetime, optional) – The end date for filtering the records (exclusive).

  • interval (duration, optional) – The fixed time interval. Defaults to 1 hour.

  • fill_method (str) – Method to handle missing values during resampling. - ‘linear’: Linearly interpolate missing values (for numeric data only). - ‘ffill’: Forward fill missing values. - ‘bfill’: Backward fill missing values. - ‘none’: Defaults to ‘linear’ for numeric values, otherwise ‘ffill’.

  • dropna – (bool, optional): Whether to drop NAN/ None values before processing. Defaults to True.

Returns:

A NumPy Array of the values extracted from the specified key.

Return type:

np.ndarray

Raises:

KeyError – If the specified key is not found in any of the DataRecords.

key_to_dict(key: str, start_datetime: DateTime | None = None, end_datetime: DateTime | None = None, dropna: bool | None = None) → Dict[DateTime, Any]

Extract a dictionary indexed by the date_time field of the DataRecords.

The dictionary will contain values extracted from the specified key attribute of each DataRecord, using the date_time field as the key.

Parameters:

  • key (str) – The field name in the DataRecord from which to extract values.

  • start_datetime (datetime, optional) – The start date to filter records (inclusive).

  • end_datetime (datetime, optional) – The end date to filter records (exclusive).

  • dropna – (bool, optional): Whether to drop NAN/ None values before processing. Defaults to True.

Returns:

A dictionary with the date_time of each record as the key

and the values extracted from the specified key.

Return type:

Dict[datetime, Any]

Raises:

KeyError – If the specified key is not found in any of the DataRecords.

key_to_lists(key: str, start_datetime: DateTime | None = None, end_datetime: DateTime | None = None, dropna: bool | None = None) → Tuple[List[DateTime], List[float | None]]

Extracts two lists from data records within an optional date range.

The lists are:

Dates: List of datetime elements. Values: List of values corresponding to the specified key in the data records.

Parameters:

  • key (str) – The key of the attribute in DataRecord to extract.

  • start_datetime (datetime, optional) – The start date for filtering the records (inclusive).

  • end_datetime (datetime, optional) – The end date for filtering the records (exclusive).

  • dropna – (bool, optional): Whether to drop NAN/ None values before processing. Defaults to True.

Returns:

A tuple containing a list of datetime values and a list of extracted values.

Return type:

tuple

Raises:

KeyError – If the specified key is not found in any of the DataRecords.

key_to_series(key: str, start_datetime: DateTime | None = None, end_datetime: DateTime | None = None, dropna: bool | None = None) → Series

Extract a series indexed by the date_time field from data records within an optional date range.

Parameters:

  • key (str) – The field name in the DataRecord from which to extract values.

  • start_datetime (datetime, optional) – The start date for filtering the records (inclusive).

  • end_datetime (datetime, optional) – The end date for filtering the records (exclusive).

  • dropna – (bool, optional): Whether to drop NAN/ None values before processing. Defaults to True.

Returns:

A Pandas Series with the index as the date_time of each record

and the values extracted from the specified key.

Return type:

pd.Series

Raises:

KeyError – If the specified key is not found in any of the DataRecords.

key_to_value(key: str, target_datetime: DateTime) → float | None

Returns the value corresponding to the specified key that is nearest to the given datetime.

Parameters:

  • key (str) – The key of the attribute in DataRecord to extract.

  • target_datetime (datetime) – The datetime to search nearest to.

Returns:

The value nearest to the given datetime, or None if no valid records are found.

Return type:

Optional[float]

Raises:

KeyError – If the specified key is not found in any of the DataRecords.

property max_datetime: DateTime

Maximum (latest) datetime in the sorted sequence of data records.

This property computes the latest datetime from the sequence of data records. If no records are present, it returns None.

Returns:

The latest datetime in the sequence, or None if no

data records exist.

Return type:

Optional[DateTime]

measurement = Measurement([])
property min_datetime: DateTime | None

Minimum (earliest) datetime in the sorted sequence of data records.

This property computes the earliest datetime from the sequence of data records. If no records are present, it returns None.

Returns:

The earliest datetime in the sequence, or None if no

data records exist.

Return type:

Optional[DateTime]

model_computed_fields = {'end_datetime': ComputedFieldInfo(wrapped_property=<property object>, return_type=typing.Optional[pydantic_extra_types.pendulum_dt.DateTime], alias=None, alias_priority=None, title=None, field_title_generator=None, description='Compute the end datetime based on the `start_datetime` and `hours`.\n\nAjusts the calculated end time if DST transitions occur within the prediction window.\n\nReturns:\n    Optional[DateTime]: The calculated end datetime, or `None` if inputs are missing.', deprecated=None, examples=None, json_schema_extra=None, repr=True), 'keep_datetime': ComputedFieldInfo(wrapped_property=<property object>, return_type=typing.Optional[pydantic_extra_types.pendulum_dt.DateTime], alias=None, alias_priority=None, title=None, field_title_generator=None, description='Compute the keep datetime for historical data retention.\n\nReturns:\n    Optional[DateTime]: The calculated retention cutoff datetime, or `None` if inputs are missing.', deprecated=None, examples=None, json_schema_extra=None, repr=True), 'keep_hours': ComputedFieldInfo(wrapped_property=<property object>, return_type=typing.Optional[int], alias=None, alias_priority=None, title=None, field_title_generator=None, description='Compute the hours from `keep_datetime` to `start_datetime`.\n\nReturns:\n    Optional[pendulum.period]: The duration hours, or `None` if either datetime is unavailable.', deprecated=None, examples=None, json_schema_extra=None, repr=True), 'max_datetime': ComputedFieldInfo(wrapped_property=<property object>, return_type=<class 'pydantic_extra_types.pendulum_dt.DateTime'>, alias=None, alias_priority=None, title=None, field_title_generator=None, description='Maximum (latest) datetime in the sorted sequence of data records.\n\nThis property computes the latest datetime from the sequence of data records.\nIf no records are present, it returns `None`.\n\nReturns:\n    Optional[DateTime]: The latest datetime in the sequence, or `None` if no\n        data records exist.', deprecated=None, examples=None, json_schema_extra=None, repr=True), 'min_datetime': ComputedFieldInfo(wrapped_property=<property object>, return_type=typing.Optional[pydantic_extra_types.pendulum_dt.DateTime], alias=None, alias_priority=None, title=None, field_title_generator=None, description='Minimum (earliest) datetime in the sorted sequence of data records.\n\nThis property computes the earliest datetime from the sequence of data records.\nIf no records are present, it returns `None`.\n\nReturns:\n    Optional[DateTime]: The earliest datetime in the sequence, or `None` if no\n        data records exist.', deprecated=None, examples=None, json_schema_extra=None, repr=True), 'record_keys': ComputedFieldInfo(wrapped_property=<property object>, return_type=typing.List[str], alias=None, alias_priority=None, title=None, field_title_generator=None, description='Returns the keys of all fields in the data records.', deprecated=None, examples=None, json_schema_extra=None, repr=True), 'record_keys_writable': ComputedFieldInfo(wrapped_property=<property object>, return_type=typing.List[str], alias=None, alias_priority=None, title=None, field_title_generator=None, description="Get the keys of all writable fields in the data records.\n\nThis property retrieves the keys of all fields in the data records that\ncan be written to. It uses the `record_class` to determine the model's\nfield structure.\n\nReturns:\n    List[str]: A list of field keys that are writable in the data records.", deprecated=None, examples=None, json_schema_extra=None, repr=True), 'total_hours': ComputedFieldInfo(wrapped_property=<property object>, return_type=typing.Optional[int], alias=None, alias_priority=None, title=None, field_title_generator=None, description='Compute the hours from `start_datetime` to `end_datetime`.\n\nReturns:\n    Optional[pendulum.period]: The duration hours, or `None` if either datetime is unavailable.', deprecated=None, examples=None, json_schema_extra=None, repr=True)}
model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'use_enum_values': True, 'validate_assignment': True}

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.

model_dump(*args: Any, include_computed_fields: bool = True, **kwargs: Any) → dict[str, Any]

Custom dump method to serialize computed fields by default.

model_dump_json(*args: Any, indent: int | None = None, **kwargs: Any) → str
!!! 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 = {'records': FieldInfo(annotation=List[LoadDataRecord], required=False, default_factory=list, description='List of LoadDataRecord records'), 'update_datetime': FieldInfo(annotation=Union[AwareDatetime, NoneType], required=False, default=None, description='Latest update datetime for generic data')}
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:

    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

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

  • self – The BaseModel instance.

  • context – The context.

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.

classmethod model_validate(obj: Any, *, strict: bool | None = None, extra: Literal['allow', 'ignore', 'forbid'] | 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:

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

classmethod model_validate_json(json_data: str | bytes | bytearray, *, strict: bool | None = None, extra: Literal['allow', 'ignore', 'forbid'] | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self
!!! 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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, extra: Literal['allow', 'ignore', 'forbid'] | 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:

  • 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
pop([index]) → item -- remove and return item at index (default last).

Raise IndexError if list is empty or index is out of range.

classmethod record_class() → Type

Get the class of the data record handled by this data sequence.

This method determines the class of the data record type associated with the records field of the model. The field is expected to be a list, and the element type of the list should be a subclass of DataRecord.

Raises:

ValueError – If the record type is not a subclass of DataRecord.

Returns:

The class of the data record handled by the data sequence.

Return type:

Type

property record_keys: List[str]

Returns the keys of all fields in the data records.

property record_keys_writable: List[str]

Get the keys of all writable fields in the data records.

This property retrieves the keys of all fields in the data records that can be written to. It uses the record_class to determine the model’s field structure.

Returns:

A list of field keys that are writable in the data records.

Return type:

List[str]

remove(value)

S.remove(value) – remove first occurrence of value. Raise ValueError if the value is not present.

classmethod reset_instance() → None

Resets the singleton instance, forcing it to be recreated on next access.

reset_to_defaults() → PydanticBaseModel

Resets the fields to their default values.

reverse()

S.reverse() – reverse IN PLACE

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’} ```

sort_by_datetime(reverse: bool = False) → None

Sort the DataRecords in the sequence by their date_time attribute.

This method modifies the existing list of records in place, arranging them in order based on the date_time attribute of each DataRecord.

Parameters:

reverse (bool, optional) – If True, sorts in descending order. If False (default), sorts in ascending order.

Raises:

TypeError – If any record’s date_time attribute is None or not comparable.

to_dataframe(start_datetime: DateTime | None = None, end_datetime: DateTime | None = None) → DataFrame

Converts the sequence of DataRecord instances into a Pandas DataFrame.

Parameters:

  • start_datetime (Optional[datetime]) – The lower bound for filtering (inclusive). Defaults to the earliest possible datetime if None.

  • end_datetime (Optional[datetime]) – The upper bound for filtering (exclusive). Defaults to the latest possible datetime if None.

Returns:

A DataFrame containing the filtered data from all records.

Return type:

pd.DataFrame

to_datetimeindex() → DatetimeIndex

Generate a Pandas DatetimeIndex from the date_time fields of all records in the sequence.

Returns:

An index of datetime values corresponding to each record’s date_time attribute.

Return type:

pd.DatetimeIndex

Raises:

ValueError – If any record does not have a valid date_time attribute.

to_dict() → dict

Convert this PredictionRecord instance to a dictionary representation.

Returns:

A dictionary where the keys are the field names of the PydanticBaseModel,

and the values are the corresponding field values.

Return type:

dict

to_json() → str

Convert the PydanticBaseModel instance to a JSON string.

Returns:

The JSON representation of the instance.

Return type:

str

property total_hours: int | None

Compute the hours from start_datetime to end_datetime.

Returns:

The duration hours, or None if either datetime is unavailable.

Return type:

Optional[pendulum.period]

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

update_data(force_enable: bool | None = False, force_update: bool | None = False) → None

Update prediction parameters and call the custom update function.

Updates the configuration, deletes outdated records, and performs the custom update logic.

Parameters:

  • force_enable (bool, optional) – If True, forces the update even if the provider is disabled.

  • force_update (bool, optional) – If True, forces the provider to update the data even if still cached.

classmethod update_forward_refs(**localns: Any) → None
update_value(date: DateTime, *args: Any, **kwargs: Any) → None

Updates specific values in the data record for a given date.

If a record for the date exists, updates the specified attributes with the new values. Otherwise, appends a new record with the given values and maintains chronological order.

Parameters:

  • date (datetime) – The date for which the values are to be added or updated.

  • key (str), value (Any) – Single key-value pair to update OR

  • values (Dict[str, Any]) – Dictionary of key-value pairs to update OR

  • **kwargs – Key-value pairs as keyword arguments

Examples

>>> update_value(date, 'temperature', 25.5)
>>> update_value(date, {'temperature': 25.5, 'humidity': 80})
>>> update_value(date, temperature=25.5, humidity=80)
classmethod validate(value: Any) → Self
records: List[LoadDataRecord]
update_datetime: AwareDatetime | None