openadr3-client-gac-compliance 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

openadr3_client_gac_compliance/gac20/event_gac_compliant.py

@@ -13,12 +13,16 @@ as the program object does not contain the events, these are stored seperately i
 
 from itertools import pairwise
 import re
+from typing import Tuple
 from openadr3_client.models.model import ValidatorRegistry, Model as ValidatorModel
 from openadr3_client.models.event.event import Event
 from openadr3_client.models.event.event_payload import EventPayloadType
 
+from pydantic import ValidationError
+from pydantic_core import InitErrorDetails, PydanticCustomError
 
-def _continuous_or_seperated(self: Event) -> Event:
+
+def _continuous_or_seperated(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
     """Enforces that events either have consistent interval definitions compliant with GAC.
 
     the Grid aware charging (GAC) specification allows for two types of (mutually exclusive)
@@ -35,6 +39,8 @@ def _continuous_or_seperated(self: Event) -> Event:
     and the top-level intervalPeriod of the event must be None. This seperated approach is used when events have differing
     durations.
     """
+    validation_errors: list[InitErrorDetails] = []
+
     intervals = self.intervals or ()
 
     if self.interval_period is None:
@@ -42,8 +48,16 @@ def _continuous_or_seperated(self: Event) -> Event:
         # Ensure that all intervals have the interval_period defined, to comply with the GAC specification.
         undefined_intervals_period = [i for i in intervals if i.interval_period is None]
         if undefined_intervals_period:
-            raise ValueError(
-                "Either 'interval_period' must be set on the event once, or every interval must have its own 'interval_period'."
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "Either 'interval_period' must be set on the event once, or every interval must have its own 'interval_period'.",
+                    ),
+                    loc=("intervals",),
+                    input=self.intervals,
+                    ctx={},
+                )
             )
     else:
         # interval period set at top level of the event.
@@ -52,14 +66,22 @@ def _continuous_or_seperated(self: Event) -> Event:
             i for i in intervals if i.interval_period is not None
         ]
         if duplicate_interval_period:
-            raise ValueError(
-                "Either 'interval_period' must be set on the event once, or every interval must have its own 'interval_period'."
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "Either 'interval_period' must be set on the event once, or every interval must have its own 'interval_period'.",
+                    ),
+                    loc=("intervals",),
+                    input=self.intervals,
+                    ctx={},
+                )
             )
 
-    return self
+    return self, validation_errors
 
 
-def _targets_compliant(self: Event) -> Event:
+def _targets_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
     """Enforces that the targets of the event are compliant with GAC.
 
     GAC enforces the following constraints for targets:
@@ -69,6 +91,7 @@ def _targets_compliant(self: Event) -> Event:
     - The event must contain a VEN_NAME target.
     - The VEN_NAME target value must be a list of 'ven object name' values (between 1 and 128 characters).
     """
+    validation_errors: list[InitErrorDetails] = []
     targets = self.targets or ()
 
     power_service_locations = [
@@ -77,42 +100,124 @@ def _targets_compliant(self: Event) -> Event:
     ven_names = [t for t in targets if t.type == "VEN_NAME"]
 
     if not power_service_locations:
-        raise ValueError("The event must contain a POWER_SERVICE_LOCATIONS target.")
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The event must contain a POWER_SERVICE_LOCATIONS target.",
+                ),
+                loc=("targets",),
+                input=self.targets,
+                ctx={},
+            )
+        )
 
     if not ven_names:
-        raise ValueError("The event must contain a VEN_NAME target.")
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The event must contain a VEN_NAME target.",
+                ),
+                loc=("targets",),
+                input=self.targets,
+                ctx={},
+            )
+        )
 
     if len(power_service_locations) > 1:
-        raise ValueError(
-            "The event must contain exactly one POWER_SERVICE_LOCATIONS target."
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The event must contain exactly one POWER_SERVICE_LOCATIONS target.",
+                ),
+                loc=("targets",),
+                input=self.targets,
+                ctx={},
+            )
         )
 
     if len(ven_names) > 1:
-        raise ValueError("The event must contain only one VEN_NAME target.")
-
-    power_service_location = power_service_locations[0]
-    ven_name = ven_names[0]
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The event must contain only one VEN_NAME target.",
+                ),
+                loc=("targets",),
+                input=self.targets,
+                ctx={},
+            )
+        )
 
-    if len(power_service_location.values) == 0:
-        raise ValueError("The POWER_SERVICE_LOCATIONS target value cannot be empty.")
+    if (
+        power_service_locations
+        and ven_names
+        and len(power_service_locations) == 1
+        and len(ven_names) == 1
+    ):
+        power_service_location = power_service_locations[0]
+        ven_name = ven_names[0]
+
+        if len(power_service_location.values) == 0:
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "The POWER_SERVICE_LOCATIONS target value cannot be empty.",
+                    ),
+                    loc=("targets",),
+                    input=self.targets,
+                    ctx={},
+                )
+            )
 
-    if not all(re.fullmatch(r"\d{18}", v) for v in power_service_location.values):
-        raise ValueError(
-            "The POWER_SERVICE_LOCATIONS target value must be a list of 'EAN18' values."
-        )
+        if not all(re.fullmatch(r"\d{18}", v) for v in power_service_location.values):
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "The POWER_SERVICE_LOCATIONS target value must be a list of 'EAN18' values.",
+                    ),
+                    loc=("targets",),
+                    input=self.targets,
+                    ctx={},
+                )
+            )
 
-    if len(ven_name.values) == 0:
-        raise ValueError("The VEN_NAME target value cannot be empty.")
+        if len(ven_name.values) == 0:
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "The VEN_NAME target value cannot be empty.",
+                    ),
+                    loc=("targets",),
+                    input=self.targets,
+                    ctx={},
+                )
+            )
 
-    if not all(1 <= len(v) <= 128 for v in ven_name.values):
-        raise ValueError(
-            "The VEN_NAME target value must be a list of 'ven object name' values (between 1 and 128 characters)."
-        )
+        if not all(1 <= len(v) <= 128 for v in ven_name.values):
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "The VEN_NAME target value must be a list of 'ven object name' values (between 1 and 128 characters).",
+                    ),
+                    loc=("targets",),
+                    input=self.targets,
+                    ctx={},
+                )
+            )
 
-    return self
+    return self, validation_errors
 
 
-def _payload_descriptor_gac_compliant(self: Event) -> Event:
+def _payload_descriptor_gac_compliant(
+    self: Event,
+) -> Tuple[Event, list[InitErrorDetails]]:
     """Enforces that the payload descriptor is GAC compliant.
 
     GAC enforces the following constraints for payload descriptors:
@@ -121,28 +226,67 @@ def _payload_descriptor_gac_compliant(self: Event) -> Event:
     - The payload descriptor must have a payload type of 'IMPORT_CAPACITY_LIMIT'
     - The payload descriptor must have a units of 'KW' (case sensitive).
     """
-    if self.payload_descriptor is None:
-        raise ValueError("The event must have a payload descriptor.")
+    validation_errors: list[InitErrorDetails] = []
 
-    if len(self.payload_descriptor) != 1:
-        raise ValueError("The event must have exactly one payload descriptor.")
+    if self.payload_descriptor is None:
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The event must have a payload descriptor.",
+                ),
+                loc=("payload_descriptor",),
+                input=self.payload_descriptor,
+                ctx={},
+            )
+        )
 
-    payload_descriptor = self.payload_descriptor[0]
+    if self.payload_descriptor is not None:
+        if len(self.payload_descriptor) != 1:
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "The event must have exactly one payload descriptor.",
+                    ),
+                    loc=("payload_descriptor",),
+                    input=self.payload_descriptor,
+                    ctx={},
+                )
+            )
 
-    if payload_descriptor.payload_type != EventPayloadType.IMPORT_CAPACITY_LIMIT:
-        raise ValueError(
-            "The payload descriptor must have a payload type of 'IMPORT_CAPACITY_LIMIT'."
-        )
+        payload_descriptor = self.payload_descriptor[0]
+
+        if payload_descriptor.payload_type != EventPayloadType.IMPORT_CAPACITY_LIMIT:
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "The payload descriptor must have a payload type of 'IMPORT_CAPACITY_LIMIT'.",
+                    ),
+                    loc=("payload_descriptor",),
+                    input=self.payload_descriptor,
+                    ctx={},
+                )
+            )
 
-    if payload_descriptor.units != "KW":
-        raise ValueError(
-            "The payload descriptor must have a units of 'KW' (case sensitive)."
-        )
+        if payload_descriptor.units != "KW":
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "The payload descriptor must have a units of 'KW' (case sensitive).",
+                    ),
+                    loc=("payload_descriptor",),
+                    input=self.payload_descriptor,
+                    ctx={},
+                )
+            )
 
-    return self
+    return self, validation_errors
 
 
-def _event_interval_gac_compliant(self: Event) -> Event:
+def _event_interval_gac_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
     """Enforces that the event interval is GAC compliant.
 
     GAC enforces the following constraints for event intervals:
@@ -151,29 +295,77 @@ def _event_interval_gac_compliant(self: Event) -> Event:
     - The event interval must have exactly one payload.
     - The payload of the event interval must have a type of 'IMPORT_CAPACITY_LIMIT'
     """
+    validation_errors: list[InitErrorDetails] = []
+
     if not self.intervals:
-        raise ValueError("The event must have at least one interval.")
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The event must have at least one interval.",
+                ),
+                loc=("intervals",),
+                input=self.intervals,
+                ctx={},
+            )
+        )
 
     if not all(curr.id > prev.id for prev, curr in pairwise(self.intervals)):
-        raise ValueError(
-            "The event interval must have an id value that is strictly increasing."
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The event interval must have an id value that is strictly increasing.",
+                ),
+                loc=("intervals",),
+                input=self.intervals,
+                ctx={},
+            )
         )
 
     for interval in self.intervals:
         if interval.payloads is None:
-            raise ValueError("The event interval must have a payload.")
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "The event interval must have a payload.",
+                    ),
+                    loc=("intervals",),
+                    input=self.intervals,
+                    ctx={},
+                )
+            )
 
         if len(interval.payloads) != 1:
-            raise ValueError("The event interval must have exactly one payload.")
-
-        payload = interval.payloads[0]
-
-        if payload.type != EventPayloadType.IMPORT_CAPACITY_LIMIT:
-            raise ValueError(
-                "The event interval payload must have a payload type of 'IMPORT_CAPACITY_LIMIT'."
+            validation_errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError(
+                        "value_error",
+                        "The event interval must have exactly one payload.",
+                    ),
+                    loc=("intervals",),
+                    input=self.intervals,
+                    ctx={},
+                )
             )
+        else:
+            payload = interval.payloads[0]
+
+            if payload.type != EventPayloadType.IMPORT_CAPACITY_LIMIT:
+                validation_errors.append(
+                    InitErrorDetails(
+                        type=PydanticCustomError(
+                            "value_error",
+                            "The event interval payload must have a payload type of 'IMPORT_CAPACITY_LIMIT'.",
+                        ),
+                        loc=("intervals",),
+                        input=self.intervals,
+                        ctx={},
+                    )
+                )
 
-    return self
+    return self, validation_errors
 
 
 @ValidatorRegistry.register(Event, ValidatorModel())
@@ -185,16 +377,40 @@ def event_gac_compliant(self: Event) -> Event:
     - The event must not have a priority set.
     - The event must have either a continuous or seperated interval definition.
     """
+    validation_errors: list[InitErrorDetails] = []
+
     if self.priority is not None:
-        raise ValueError(
-            "The event must not have a priority set for GAC 2.0 compliance"
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The event must not have a priority set for GAC 2.0 compliance",
+                ),
+                loc=("priority",),
+                input=self.priority,
+                ctx={},
+            )
         )
 
-    interval_periods_validated = _continuous_or_seperated(self)
-    targets_validated = _targets_compliant(interval_periods_validated)
-    payload_descriptor_validated = _payload_descriptor_gac_compliant(targets_validated)
-    event_interval_validated = _event_interval_gac_compliant(
+    interval_periods_validated, errors = _continuous_or_seperated(self)
+    validation_errors.extend(errors)
+
+    targets_validated, errors = _targets_compliant(interval_periods_validated)
+    validation_errors.extend(errors)
+
+    payload_descriptor_validated, errors = _payload_descriptor_gac_compliant(
+        targets_validated
+    )
+    validation_errors.extend(errors)
+
+    event_interval_validated, errors = _event_interval_gac_compliant(
         payload_descriptor_validated
     )
+    validation_errors.extend(errors)
+
+    if validation_errors:
+        raise ValidationError.from_exception_data(
+            title=self.__class__.__name__, line_errors=validation_errors
+        )
 
     return event_interval_validated

openadr3_client_gac_compliance/gac20/program_gac_compliant.py

@@ -5,6 +5,9 @@ from openadr3_client.models.model import ValidatorRegistry, Model as ValidatorMo
 
 import re
 
+from pydantic import ValidationError
+from pydantic_core import InitErrorDetails, PydanticCustomError
+
 
 @ValidatorRegistry.register(Program, ValidatorModel())
 def program_gac_compliant(self: Program) -> Program:
@@ -18,22 +21,81 @@ def program_gac_compliant(self: Program) -> Program:
     - The program MUST have bindingEvents set to True.
     are allowed there.
     """
+    validation_errors: list[InitErrorDetails] = []
+
     program_type_regex = r"^DSO_CPO_INTERFACE-(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$"
 
     if self.retailer_name is None:
-        raise ValueError("The program must have a retailer name.")
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The program must have a retailer name.",
+                ),
+                loc=("retailer_name",),
+                input=self.retailer_name,
+                ctx={},
+            )
+        )
 
-    if len(self.retailer_name) < 2 or len(self.retailer_name) > 128:
-        raise ValueError("The retailer name must be between 2 and 128 characters long.")
+    if self.retailer_name is not None and (
+        len(self.retailer_name) < 2 or len(self.retailer_name) > 128
+    ):
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The retailer name must be between 2 and 128 characters long.",
+                ),
+                loc=("retailer_name",),
+                input=self.retailer_name,
+                ctx={},
+            )
+        )
 
     if self.program_type is None:
-        raise ValueError("The program must have a program type.")
-    if not re.fullmatch(program_type_regex, self.program_type):
-        raise ValueError(
-            "The program type must follow the format DSO_CPO_INTERFACE-x.x.x."
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The program must have a program type.",
+                ),
+                loc=("program_type",),
+                input=self.program_type,
+                ctx={},
+            )
+        )
+    if self.program_type is not None and not re.fullmatch(
+        program_type_regex, self.program_type
+    ):
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The program type must follow the format DSO_CPO_INTERFACE-x.x.x.",
+                ),
+                loc=("program_type",),
+                input=self.program_type,
+                ctx={},
+            )
         )
 
     if self.binding_events is False:
-        raise ValueError("The program must have bindingEvents set to True.")
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The program must have bindingEvents set to True.",
+                ),
+                loc=("binding_events",),
+                input=self.binding_events,
+                ctx={},
+            )
+        )
+
+    if validation_errors:
+        raise ValidationError.from_exception_data(
+            title=self.__class__.__name__, line_errors=validation_errors
+        )
 
     return self

openadr3_client_gac_compliance/gac20/ven_gac_compliant.py

@@ -3,6 +3,9 @@ from openadr3_client.models.model import ValidatorRegistry, Model as ValidatorMo
 from openadr3_client.models.ven.ven import Ven
 import pycountry
 
+from pydantic import ValidationError
+from pydantic_core import InitErrorDetails, PydanticCustomError
+
 
 @ValidatorRegistry.register(Ven, ValidatorModel())
 def ven_gac_compliant(self: Ven) -> Ven:
@@ -12,16 +15,41 @@ def ven_gac_compliant(self: Ven) -> Ven:
     - The ven must have a ven name
     - The ven name must be an eMI3 identifier.
     """
+    validation_errors: list[InitErrorDetails] = []
+
     emi3_identifier_regex = r"^[A-Z]{2}-?[A-Z0-9]{3}$"
 
     if not re.fullmatch(emi3_identifier_regex, self.ven_name):
-        raise ValueError("The ven name must be formatted as an eMI3 identifier.")
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The ven name must be formatted as an eMI3 identifier.",
+                ),
+                loc=("ven_name",),
+                input=self.ven_name,
+                ctx={},
+            )
+        )
 
     alpha_2_country = pycountry.countries.get(alpha_2=self.ven_name[:2])
 
     if alpha_2_country is None:
-        raise ValueError(
-            "The first two characters of the ven name must be a valid ISO 3166-1 alpha-2 country code."
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The first two characters of the ven name must be a valid ISO 3166-1 alpha-2 country code.",
+                ),
+                loc=("ven_name",),
+                input=self.ven_name,
+                ctx={},
+            )
+        )
+
+    if validation_errors:
+        raise ValidationError.from_exception_data(
+            title=self.__class__.__name__, line_errors=validation_errors
         )
 
     return self

{openadr3_client_gac_compliance-1.1.0.dist-info → openadr3_client_gac_compliance-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openadr3-client-gac-compliance
-Version: 1.1.0
+Version: 1.2.1
 Summary: 
 Author: Nick van der Burgt
 Author-email: nick.van.der.burgt@elaad.nl
@@ -8,7 +8,7 @@ Requires-Python: >=3.12, <4
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: openadr3-client (>=0.0.1,<0.0.2)
+Requires-Dist: openadr3-client (>=0.0.1,<1.0.0)
 Requires-Dist: pycountry (>=24.6.1,<25.0.0)
 Requires-Dist: pydantic (>=2.11.2,<3.0.0)
 Description-Content-Type: text/markdown

{openadr3_client_gac_compliance-1.1.0.dist-info → openadr3_client_gac_compliance-1.2.1.dist-info}/RECORD

@@ -1,11 +1,11 @@
 openadr3_client_gac_compliance/__init__.py,sha256=dzf9YdOlssEb9GSIoThaMzEJ956G-hpLi7HIXRC3TR8,334
 openadr3_client_gac_compliance/config.py,sha256=X_KEl99bUm05rH0IOKLyeR4Zn2utdC8U3vLkdG8MYXU,675
 openadr3_client_gac_compliance/gac20/__init__.py,sha256=YPjRHMl-uR6ZwrDGjY_EboScHe_VhTrovso_zDOSd6o,220
-openadr3_client_gac_compliance/gac20/event_gac_compliant.py,sha256=KPcUyazlroFv0c3IovvtMW4a4LD2lBOyct4ptjngixk,7970
-openadr3_client_gac_compliance/gac20/program_gac_compliant.py,sha256=qJeyvAdu0f6F0I3iXXl64dOVRZwPfRHQyGqc3ECuzjw,1725
-openadr3_client_gac_compliance/gac20/ven_gac_compliant.py,sha256=YAzM2Q9ggh_O-p1xD5GlN7-lTGg2MjqUG26KBSy3-d8,908
+openadr3_client_gac_compliance/gac20/event_gac_compliant.py,sha256=dZIVRRgpRajkceu8IDLNaz9b0lNmlFfWjdlAvlxymTo,15060
+openadr3_client_gac_compliance/gac20/program_gac_compliant.py,sha256=i7l9oboA31_HMHZ-b8GbVTXGfeNCL3kF-o5e7--riCg,3540
+openadr3_client_gac_compliance/gac20/ven_gac_compliant.py,sha256=57MH73JorFSNyeB6Tep4XX_WMhtKls2DXoSoBaMhob8,1751
 openadr3_client_gac_compliance/gac21/__init__.py,sha256=GTu1EyBj2T72zT3MKPettcvP-DNCJ0p6oAMj3Z-08N0,61
-openadr3_client_gac_compliance-1.1.0.dist-info/LICENSE.md,sha256=NNNxKzhSK6afX-UaN8WZIVtMi5Tu8dVr6q3ciTSnH-g,10250
-openadr3_client_gac_compliance-1.1.0.dist-info/METADATA,sha256=tuuieVH5mgB1rE9ijxwSyt3zSFzvB4zqEwsw98WLA-s,1096
-openadr3_client_gac_compliance-1.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-openadr3_client_gac_compliance-1.1.0.dist-info/RECORD,,
+openadr3_client_gac_compliance-1.2.1.dist-info/LICENSE.md,sha256=NNNxKzhSK6afX-UaN8WZIVtMi5Tu8dVr6q3ciTSnH-g,10250
+openadr3_client_gac_compliance-1.2.1.dist-info/METADATA,sha256=n5GMDEvlXrEreakDfUWYiVOTZF7mgT1W8JzzhhsGK6g,1096
+openadr3_client_gac_compliance-1.2.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+openadr3_client_gac_compliance-1.2.1.dist-info/RECORD,,