10321375181

Committed 09 Aug 2024 03:00PM UTC coverage: 67.374% (+0.03%) from 67.347%

Build # 10321375181

Build Type

Pull #1127

github

Committed by

Flix6x

Commit Message

style: be more explicit about requiring the soc-unit field to be set

Signed-off-by: F.N. Claessen <felix@seita.nl>

Pull Request Pull Request #1127: Feature/merge time series schemas

Run Details

6055 of 9834 branches covered (61.57%)

Branch coverage included in aggregate %.

106 of 115 new or added lines in 9 files covered. (92.17%)

16 existing lines in 2 files now uncovered.

7669 of 10536 relevant lines covered (72.79%)

5.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.43

/flexmeasures/data/schemas/scheduling/storage.py

from __future__ import annotations

from datetime import datetime

from flask import current_app
from marshmallow import (
    Schema,
    post_load,
    validate,
    validates_schema,
    fields,
    validates,
)
from marshmallow.validate import OneOf, ValidationError

from flexmeasures.data.models.time_series import Sensor
from flexmeasures.data.schemas.units import QuantityField
from flexmeasures.data.schemas.sensors import VariableQuantityField

from flexmeasures.utils.unit_utils import ur


class EfficiencyField(QuantityField):
    """Field that deserializes to a Quantity with % units. Must be greater than 0% and less than or equal to 100%.

    Examples:

        >>> ef = EfficiencyField()
        >>> ef.deserialize(0.9)
        <Quantity(90.0, 'percent')>
        >>> ef.deserialize("90%")
        <Quantity(90.0, 'percent')>
        >>> ef.deserialize("0%")
        Traceback (most recent call last):
        ...
        marshmallow.exceptions.ValidationError: ['Must be greater than 0 and less than or equal to 1.']
    """

    def __init__(self, *args, **kwargs):
        super().__init__(
            "%",
            validate=validate.Range(
                min=0, max=1, min_inclusive=False, max_inclusive=True
            ),
            *args,
            **kwargs,
        )


class StorageFlexModelSchema(Schema):
    """
    This schema lists fields we require when scheduling storage assets.
    Some fields are not required, as they might live on the Sensor.attributes.
    You can use StorageScheduler.deserialize_flex_config to get that filled in.
    """

    soc_at_start = QuantityField(
        required=True,
        to_unit="MWh",
        default_src_unit="dimensionless",  # placeholder, overridden in __init__
        return_magnitude=True,
        data_key="soc-at-start",
    )

    soc_min = QuantityField(
        validate=validate.Range(
            min=0
        ),  # change to min=ur.Quantity("0 MWh") in case return_magnitude=False
        to_unit="MWh",
        default_src_unit="dimensionless",  # placeholder, overridden in __init__
        return_magnitude=True,
        data_key="soc-min",
    )
    soc_max = QuantityField(
        to_unit="MWh",
        default_src_unit="dimensionless",  # placeholder, overridden in __init__
        return_magnitude=True,
        data_key="soc-max",
    )

    power_capacity_in_mw = VariableQuantityField(
        "MW", required=False, data_key="power-capacity"
    )

    consumption_capacity = VariableQuantityField(
        "MW", data_key="consumption-capacity", required=False
    )
    production_capacity = VariableQuantityField(
        "MW", data_key="production-capacity", required=False
    )

    # Timezone placeholders for the soc_maxima, soc_minima and soc_targets fields are overridden in __init__
    soc_maxima = VariableQuantityField(
        to_unit="MWh",
        default_src_unit="dimensionless",  # placeholder, overridden in __init__
        timezone="placeholder",
        data_key="soc-maxima",
    )

    soc_minima = VariableQuantityField(
        to_unit="MWh",
        default_src_unit="dimensionless",  # placeholder, overridden in __init__
        timezone="placeholder",
        data_key="soc-minima",
        value_validator=validate.Range(min=0),
    )

    soc_targets = VariableQuantityField(
        to_unit="MWh",
        default_src_unit="dimensionless",  # placeholder, overridden in __init__
        timezone="placeholder",
        data_key="soc-targets",
    )

    soc_unit = fields.Str(
        validate=OneOf(
            [
                "kWh",
                "MWh",
            ]
        ),
        data_key="soc-unit",
        required=False,
    )

    charging_efficiency = VariableQuantityField(
        "%", data_key="charging-efficiency", required=False
    )
    discharging_efficiency = VariableQuantityField(
        "%", data_key="discharging-efficiency", required=False
    )

    roundtrip_efficiency = EfficiencyField(
        data_key="roundtrip-efficiency", required=False
    )

    storage_efficiency = VariableQuantityField(
        "%", default_src_unit="dimensionless", data_key="storage-efficiency"
    )
    prefer_charging_sooner = fields.Bool(data_key="prefer-charging-sooner")

    soc_gain = fields.List(
        VariableQuantityField("MW"),
        data_key="soc-gain",
        required=False,
        validate=validate.Length(min=1),
    )
    soc_usage = fields.List(
        VariableQuantityField("MW"),
        data_key="soc-usage",
        required=False,
        validate=validate.Length(min=1),
    )

    def __init__(
        self,
        start: datetime,
        sensor: Sensor,
        *args,
        default_soc_unit: str | None = None,
        **kwargs,
    ):
        """Pass the schedule's start, so we can use it to validate soc-target datetimes."""
        self.start = start
        self.sensor = sensor
        self.soc_maxima = VariableQuantityField(
            to_unit="MWh",
            default_src_unit=default_soc_unit,
            timezone=sensor.timezone,
            data_key="soc-maxima",
        )

        self.soc_minima = VariableQuantityField(
            to_unit="MWh",
            default_src_unit=default_soc_unit,
            timezone=sensor.timezone,
            data_key="soc-minima",
            value_validator=validate.Range(min=0),
        )
        self.soc_targets = VariableQuantityField(
            to_unit="MWh",
            default_src_unit=default_soc_unit,
            timezone=sensor.timezone,
            data_key="soc-targets",
        )

        super().__init__(*args, **kwargs)
        if default_soc_unit is not None:
            for field in self.fields.keys():
                if field.startswith("soc_"):
                    setattr(self.fields[field], "default_src_unit", default_soc_unit)

    @validates_schema
    def check_whether_targets_exceed_max_planning_horizon(self, data: dict, **kwargs):
        soc_targets: list[dict[str, datetime | float] | Sensor] | None = data.get(
            "soc_targets"
        )
        # skip check if the SOC targets are not provided or if they are defined as sensors
        if not soc_targets or isinstance(soc_targets, Sensor):
            return
        max_server_horizon = current_app.config.get("FLEXMEASURES_MAX_PLANNING_HORIZON")
        if isinstance(max_server_horizon, int):
            max_server_horizon *= self.sensor.event_resolution
        max_target_datetime = max([target["end"] for target in soc_targets])
        max_server_datetime = self.start + max_server_horizon
        if max_target_datetime > max_server_datetime:
            current_app.logger.warning(
                f"Target datetime exceeds {max_server_datetime}. Maximum scheduling horizon is {max_server_horizon}."
            )

    @validates("storage_efficiency")
    def validate_storage_efficiency_resolution(self, unit: Sensor | ur.Quantity):
        if (
            isinstance(unit, Sensor)
            and unit.event_resolution != self.sensor.event_resolution
        ):
            raise ValidationError(
                "Event resolution of the storage efficiency and the power sensor don't match. Resampling the storage efficiency is not supported."
            )

    @validates_schema
    def check_redundant_efficiencies(self, data: dict, **kwargs):
        """
        Check that none of the following cases occurs:
            (1) flex-model contains both a round-trip efficiency and a charging efficiency
            (2) flex-model contains both a round-trip efficiency and a discharging efficiency
            (3) flex-model contains a round-trip efficiency, a charging efficiency and a discharging efficiency


        :raise: ValidationError
        """

        for field in ["charging_efficiency", "discharging_efficiency"]:
            if field in data and "roundtrip_efficiency" in data:
                raise ValidationError(
                    f"Fields `{field}` and `roundtrip_efficiency` are mutually exclusive."
                )

    @post_load
    def post_load_sequence(self, data: dict, **kwargs) -> dict:
        """Perform some checks and corrections after we loaded."""
        # currently we only handle MWh internally, and the conversion to MWh happened during deserialization
        data["soc_unit"] = "MWh"

        # Convert efficiency to dimensionless (to the (0,1] range)
        if data.get("roundtrip_efficiency") is not None:
            data["roundtrip_efficiency"] = (
                data["roundtrip_efficiency"].to(ur.Quantity("dimensionless")).magnitude
            )

        return data

1	from __future__ import annotations	8✔
2
3	from datetime import datetime	8✔
4
5	from flask import current_app	8✔
6	from marshmallow import (	8✔
7	Schema,
8	post_load,
9	validate,
10	validates_schema,
11	fields,
12	validates,
13	)
14	from marshmallow.validate import OneOf, ValidationError	8✔
15
16	from flexmeasures.data.models.time_series import Sensor	8✔
17	from flexmeasures.data.schemas.units import QuantityField	8✔
18	from flexmeasures.data.schemas.sensors import VariableQuantityField	8✔
19
20	from flexmeasures.utils.unit_utils import ur	8✔
21
22
23	class EfficiencyField(QuantityField):	8✔
24	"""Field that deserializes to a Quantity with % units. Must be greater than 0% and less than or equal to 100%.	4✔
25
26	Examples:
27
28	>>> ef = EfficiencyField()
29	>>> ef.deserialize(0.9)
30	<Quantity(90.0, 'percent')>
31	>>> ef.deserialize("90%")
32	<Quantity(90.0, 'percent')>
33	>>> ef.deserialize("0%")
34	Traceback (most recent call last):
35	...
36	marshmallow.exceptions.ValidationError: ['Must be greater than 0 and less than or equal to 1.']
37	"""
38
39	def __init__(self, args, *kwargs):	8✔
40	super().__init__(	8✔
41	"%",
42	validate=validate.Range(
43	min=0, max=1, min_inclusive=False, max_inclusive=True
44	),
45	*args,
46	**kwargs,
47	)
48
49
50	class StorageFlexModelSchema(Schema):	8✔
51	"""	4✔
52	This schema lists fields we require when scheduling storage assets.
53	Some fields are not required, as they might live on the Sensor.attributes.
54	You can use StorageScheduler.deserialize_flex_config to get that filled in.
55	"""
56
57	soc_at_start = QuantityField(	8✔
58	required=True,
59	to_unit="MWh",
60	default_src_unit="dimensionless", # placeholder, overridden in __init__
61	return_magnitude=True,
62	data_key="soc-at-start",
63	)
64
65	soc_min = QuantityField(	8✔
66	validate=validate.Range(
67	min=0
68	), # change to min=ur.Quantity("0 MWh") in case return_magnitude=False
69	to_unit="MWh",
70	default_src_unit="dimensionless", # placeholder, overridden in __init__
71	return_magnitude=True,
72	data_key="soc-min",
73	)
74	soc_max = QuantityField(	8✔
75	to_unit="MWh",
76	default_src_unit="dimensionless", # placeholder, overridden in __init__
77	return_magnitude=True,
78	data_key="soc-max",
79	)
80
81	power_capacity_in_mw = VariableQuantityField(	8✔
82	"MW", required=False, data_key="power-capacity"
83	)
84
85	consumption_capacity = VariableQuantityField(	8✔
86	"MW", data_key="consumption-capacity", required=False
87	)
88	production_capacity = VariableQuantityField(	8✔
89	"MW", data_key="production-capacity", required=False
90	)
91
92	# Timezone placeholders for the soc_maxima, soc_minima and soc_targets fields are overridden in __init__
93	soc_maxima = VariableQuantityField(	8✔
94	to_unit="MWh",
95	default_src_unit="dimensionless", # placeholder, overridden in __init__
96	timezone="placeholder",
97	data_key="soc-maxima",
98	)
99
100	soc_minima = VariableQuantityField(	8✔
101	to_unit="MWh",
102	default_src_unit="dimensionless", # placeholder, overridden in __init__
103	timezone="placeholder",
104	data_key="soc-minima",
105	value_validator=validate.Range(min=0),
106	)
107
108	soc_targets = VariableQuantityField(	8✔
109	to_unit="MWh",
110	default_src_unit="dimensionless", # placeholder, overridden in __init__
111	timezone="placeholder",
112	data_key="soc-targets",
113	)
114
115	soc_unit = fields.Str(	8✔
116	validate=OneOf(
117	[
118	"kWh",
119	"MWh",
120	]
121	),
122	data_key="soc-unit",
123	required=False,
124	)
125
126	charging_efficiency = VariableQuantityField(	8✔
127	"%", data_key="charging-efficiency", required=False
128	)
129	discharging_efficiency = VariableQuantityField(	8✔
130	"%", data_key="discharging-efficiency", required=False
131	)
132
133	roundtrip_efficiency = EfficiencyField(	8✔
134	data_key="roundtrip-efficiency", required=False
135	)
136
137	storage_efficiency = VariableQuantityField(	8✔
138	"%", default_src_unit="dimensionless", data_key="storage-efficiency"
139	)
140	prefer_charging_sooner = fields.Bool(data_key="prefer-charging-sooner")	8✔
141
142	soc_gain = fields.List(	8✔
143	VariableQuantityField("MW"),
144	data_key="soc-gain",
145	required=False,
146	validate=validate.Length(min=1),
147	)
148	soc_usage = fields.List(	8✔
149	VariableQuantityField("MW"),
150	data_key="soc-usage",
151	required=False,
152	validate=validate.Length(min=1),
153	)
154
155	def __init__(	8✔
156	self,
157	start: datetime,
158	sensor: Sensor,
159	*args,
160	default_soc_unit: str \| None = None,
161	**kwargs,
162	):
163	"""Pass the schedule's start, so we can use it to validate soc-target datetimes."""
164	self.start = start	8✔
165	self.sensor = sensor	8✔
166	self.soc_maxima = VariableQuantityField(	8✔
167	to_unit="MWh",
168	default_src_unit=default_soc_unit,
169	timezone=sensor.timezone,
170	data_key="soc-maxima",
171	)
172
173	self.soc_minima = VariableQuantityField(	8✔
174	to_unit="MWh",
175	default_src_unit=default_soc_unit,
176	timezone=sensor.timezone,
177	data_key="soc-minima",
178	value_validator=validate.Range(min=0),
179	)
180	self.soc_targets = VariableQuantityField(	8✔
181	to_unit="MWh",
182	default_src_unit=default_soc_unit,
183	timezone=sensor.timezone,
184	data_key="soc-targets",
185	)
186
187	super().__init__(args, *kwargs)	8✔
188	if default_soc_unit is not None:	8✔
189	for field in self.fields.keys():	8✔
190	if field.startswith("soc_"):	8✔
191	setattr(self.fields[field], "default_src_unit", default_soc_unit)	8✔
192
193	@validates_schema	8✔
194	def check_whether_targets_exceed_max_planning_horizon(self, data: dict, **kwargs):	8✔
195	soc_targets: list[dict[str, datetime \| float] \| Sensor] \| None = data.get(	8✔
196	"soc_targets"
197	)
198	# skip check if the SOC targets are not provided or if they are defined as sensors
199	if not soc_targets or isinstance(soc_targets, Sensor):	8✔
200	return	8✔
201	max_server_horizon = current_app.config.get("FLEXMEASURES_MAX_PLANNING_HORIZON")	8✔
202	if isinstance(max_server_horizon, int):	8✔
203	max_server_horizon *= self.sensor.event_resolution	8✔
204	max_target_datetime = max([target["end"] for target in soc_targets])	8!
205	max_server_datetime = self.start + max_server_horizon	8✔
206	if max_target_datetime > max_server_datetime:	8✔
UNCOV 207	current_app.logger.warning(	×
208	f"Target datetime exceeds {max_server_datetime}. Maximum scheduling horizon is {max_server_horizon}."
209	)
210
211	@validates("storage_efficiency")	8✔
212	def validate_storage_efficiency_resolution(self, unit: Sensor \| ur.Quantity):	8✔
213	if (	8✔
214	isinstance(unit, Sensor)
215	and unit.event_resolution != self.sensor.event_resolution
216	):
217	raise ValidationError(	8✔
218	"Event resolution of the storage efficiency and the power sensor don't match. Resampling the storage efficiency is not supported."
219	)
220
221	@validates_schema	8✔
222	def check_redundant_efficiencies(self, data: dict, **kwargs):	8✔
223	"""
224	Check that none of the following cases occurs:
225	(1) flex-model contains both a round-trip efficiency and a charging efficiency
226	(2) flex-model contains both a round-trip efficiency and a discharging efficiency
227	(3) flex-model contains a round-trip efficiency, a charging efficiency and a discharging efficiency
228
229
230	:raise: ValidationError
231	"""
232
233	for field in ["charging_efficiency", "discharging_efficiency"]:	8✔
234	if field in data and "roundtrip_efficiency" in data:	8✔
235	raise ValidationError(	8✔
236	f"Fields `{field}` and `roundtrip_efficiency` are mutually exclusive."
237	)
238
239	@post_load	8✔
240	def post_load_sequence(self, data: dict, **kwargs) -> dict:	8✔
241	"""Perform some checks and corrections after we loaded."""
242	# currently we only handle MWh internally, and the conversion to MWh happened during deserialization
243	data["soc_unit"] = "MWh"	8✔
244
245	# Convert efficiency to dimensionless (to the (0,1] range)
246	if data.get("roundtrip_efficiency") is not None:	8✔
247	data["roundtrip_efficiency"] = (	8✔
248	data["roundtrip_efficiency"].to(ur.Quantity("dimensionless")).magnitude
249	)
250
251	return data	8✔

FlexMeasures / flexmeasures / 10321375181

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous