openadr3-client-gac-compliance 1.1.0__tar.gz → 1.2.0__tar.gz

{openadr3_client_gac_compliance-1.1.0 → openadr3_client_gac_compliance-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openadr3-client-gac-compliance
-Version: 1.1.0
+Version: 1.2.0
 Summary: 
 Author: Nick van der Burgt
 Author-email: nick.van.der.burgt@elaad.nl

openadr3_client_gac_compliance-1.2.0/openadr3_client_gac_compliance/gac20/event_gac_compliant.py

@@ -0,0 +1,416 @@
+"""Module which implements GAC compliance validators for the event OpenADR3 types.
+
+This module validates all the object constraints and requirements on the OpenADR3 events resource
+as specified in the Grid aware charging (GAC) specification.
+
+There is one requirement that is not validated here, as it cannot be validated through the scope of the
+pydantic validators. Namely, the requirement that a safe mode event MUST be present in a program.
+
+As the pydantic validator works on the scope of a single Event Object, it is not possible to validate
+that a safe mode event is present in a program. And it cannot be validated on the Program object,
+as the program object does not contain the events, these are stored seperately in the VTN.
+"""
+
+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) -> 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)
+    interval definitions:
+
+    1. Continuous
+    2. Seperated
+
+    The continious implementation can be used when all intervals have the same duration.
+    In this case, only the top-level intervalPeriod of the event can be used, and the intervalPeriods
+    of the individual intervals must be None.
+
+    In the seperated intervalDefinition approach, the intervalPeriods must be set on each individual intervals,
+    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:
+        # interval period not set at top level of the 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:
+            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.
+        # Ensure that all intervals do not have the interval_period defined, to comply with the GAC specification.
+        duplicate_interval_period = [
+            i for i in intervals if i.interval_period is not None
+        ]
+        if duplicate_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, validation_errors
+
+
+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:
+
+    - The event must contain a POWER_SERVICE_LOCATIONS target.
+    - The POWER_SERVICE_LOCATIONS target value must be a list of 'EAN18' values.
+    - 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 = [
+        t for t in targets if t.type == "POWER_SERVICE_LOCATIONS"
+    ]
+    ven_names = [t for t in targets if t.type == "VEN_NAME"]
+
+    if not power_service_locations:
+        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:
+        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:
+        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:
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The event must contain only one VEN_NAME target.",
+                ),
+                loc=("targets",),
+                input=self.targets,
+                ctx={},
+            )
+        )
+
+    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):
+            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:
+            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):
+            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, validation_errors
+
+
+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:
+
+    - The event interval must exactly one payload descriptor.
+    - The payload descriptor must have a payload type of 'IMPORT_CAPACITY_LIMIT'
+    - The payload descriptor must have a units of 'KW' (case sensitive).
+    """
+    validation_errors: list[InitErrorDetails] = []
+
+    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={},
+            )
+        )
+
+    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={},
+                )
+            )
+
+        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":
+            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, validation_errors
+
+
+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:
+
+    - The event interval must have an id value that is strictly increasing.
+    - 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:
+        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)):
+        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:
+            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:
+            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, validation_errors
+
+
+@ValidatorRegistry.register(Event, ValidatorModel())
+def event_gac_compliant(self: Event) -> Event:
+    """Enforces that events are GAC compliant.
+
+    GAC enforces the following constraints for events:
+
+    - 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:
+        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, 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-1.2.0/openadr3_client_gac_compliance/gac20/program_gac_compliant.py

@@ -0,0 +1,101 @@
+"""Module which implements GAC compliance validators for the program OpenADR3 types."""
+
+from openadr3_client.models.program.program import Program
+from openadr3_client.models.model import ValidatorRegistry, Model as ValidatorModel
+
+import re
+
+from pydantic import ValidationError
+from pydantic_core import InitErrorDetails, PydanticCustomError
+
+
+@ValidatorRegistry.register(Program, ValidatorModel())
+def program_gac_compliant(self: Program) -> Program:
+    """Enforces that the program is GAC compliant.
+
+    GAC enforces the following constraints for programs:
+    - The program must have a retailer name
+    - The retailer name must be between 2 and 128 characters long.
+    - The program MUST have a programType.
+    - The programType MUST equal "DSO_CPO_INTERFACE-x.x.x, where x.x.x is the version as defined in the GAC specification.
+    - 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:
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The program must have a retailer name.",
+                ),
+                loc=("retailer_name",),
+                input=self.retailer_name,
+                ctx={},
+            )
+        )
+
+    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:
+        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:
+        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-1.2.0/openadr3_client_gac_compliance/gac20/ven_gac_compliant.py

@@ -0,0 +1,55 @@
+import re
+from openadr3_client.models.model import ValidatorRegistry, Model as ValidatorModel
+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:
+    """Enforces that the ven is GAC compliant.
+
+    GAC enforces the following constraints for vens:
+    - 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):
+        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:
+        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 → openadr3_client_gac_compliance-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openadr3-client-gac-compliance"
-version = "1.1.0"
+version = "1.2.0"
 description = ""
 authors = [
     {name = "Nick van der Burgt", email = "nick.van.der.burgt@elaad.nl"}

openadr3_client_gac_compliance-1.1.0/openadr3_client_gac_compliance/gac20/event_gac_compliant.py

@@ -1,200 +0,0 @@
-"""Module which implements GAC compliance validators for the event OpenADR3 types.
-
-This module validates all the object constraints and requirements on the OpenADR3 events resource
-as specified in the Grid aware charging (GAC) specification.
-
-There is one requirement that is not validated here, as it cannot be validated through the scope of the
-pydantic validators. Namely, the requirement that a safe mode event MUST be present in a program.
-
-As the pydantic validator works on the scope of a single Event Object, it is not possible to validate
-that a safe mode event is present in a program. And it cannot be validated on the Program object,
-as the program object does not contain the events, these are stored seperately in the VTN.
-"""
-
-from itertools import pairwise
-import re
-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
-
-
-def _continuous_or_seperated(self: Event) -> Event:
-    """Enforces that events either have consistent interval definitions compliant with GAC.
-
-    the Grid aware charging (GAC) specification allows for two types of (mutually exclusive)
-    interval definitions:
-
-    1. Continuous
-    2. Seperated
-
-    The continious implementation can be used when all intervals have the same duration.
-    In this case, only the top-level intervalPeriod of the event can be used, and the intervalPeriods
-    of the individual intervals must be None.
-
-    In the seperated intervalDefinition approach, the intervalPeriods must be set on each individual intervals,
-    and the top-level intervalPeriod of the event must be None. This seperated approach is used when events have differing
-    durations.
-    """
-    intervals = self.intervals or ()
-
-    if self.interval_period is None:
-        # interval period not set at top level of the 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'."
-            )
-    else:
-        # interval period set at top level of the event.
-        # Ensure that all intervals do not have the interval_period defined, to comply with the GAC specification.
-        duplicate_interval_period = [
-            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'."
-            )
-
-    return self
-
-
-def _targets_compliant(self: Event) -> Event:
-    """Enforces that the targets of the event are compliant with GAC.
-
-    GAC enforces the following constraints for targets:
-
-    - The event must contain a POWER_SERVICE_LOCATIONS target.
-    - The POWER_SERVICE_LOCATIONS target value must be a list of 'EAN18' values.
-    - 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).
-    """
-    targets = self.targets or ()
-
-    power_service_locations = [
-        t for t in targets if t.type == "POWER_SERVICE_LOCATIONS"
-    ]
-    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.")
-
-    if not ven_names:
-        raise ValueError("The event must contain a VEN_NAME target.")
-
-    if len(power_service_locations) > 1:
-        raise ValueError(
-            "The event must contain exactly one POWER_SERVICE_LOCATIONS target."
-        )
-
-    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]
-
-    if len(power_service_location.values) == 0:
-        raise ValueError("The POWER_SERVICE_LOCATIONS target value cannot be empty.")
-
-    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 len(ven_name.values) == 0:
-        raise ValueError("The VEN_NAME target value cannot be empty.")
-
-    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)."
-        )
-
-    return self
-
-
-def _payload_descriptor_gac_compliant(self: Event) -> Event:
-    """Enforces that the payload descriptor is GAC compliant.
-
-    GAC enforces the following constraints for payload descriptors:
-
-    - The event interval must exactly one payload descriptor.
-    - 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.")
-
-    if len(self.payload_descriptor) != 1:
-        raise ValueError("The event must have exactly one payload descriptor.")
-
-    payload_descriptor = self.payload_descriptor[0]
-
-    if payload_descriptor.payload_type != EventPayloadType.IMPORT_CAPACITY_LIMIT:
-        raise ValueError(
-            "The payload descriptor must have a payload type of 'IMPORT_CAPACITY_LIMIT'."
-        )
-
-    if payload_descriptor.units != "KW":
-        raise ValueError(
-            "The payload descriptor must have a units of 'KW' (case sensitive)."
-        )
-
-    return self
-
-
-def _event_interval_gac_compliant(self: Event) -> Event:
-    """Enforces that the event interval is GAC compliant.
-
-    GAC enforces the following constraints for event intervals:
-
-    - The event interval must have an id value that is strictly increasing.
-    - The event interval must have exactly one payload.
-    - The payload of the event interval must have a type of 'IMPORT_CAPACITY_LIMIT'
-    """
-    if not self.intervals:
-        raise ValueError("The event must have at least one interval.")
-
-    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."
-        )
-
-    for interval in self.intervals:
-        if interval.payloads is None:
-            raise ValueError("The event interval must have a payload.")
-
-        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'."
-            )
-
-    return self
-
-
-@ValidatorRegistry.register(Event, ValidatorModel())
-def event_gac_compliant(self: Event) -> Event:
-    """Enforces that events are GAC compliant.
-
-    GAC enforces the following constraints for events:
-
-    - The event must not have a priority set.
-    - The event must have either a continuous or seperated interval definition.
-    """
-    if self.priority is not None:
-        raise ValueError(
-            "The event must not have a priority set for GAC 2.0 compliance"
-        )
-
-    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(
-        payload_descriptor_validated
-    )
-
-    return event_interval_validated

openadr3_client_gac_compliance-1.1.0/openadr3_client_gac_compliance/gac20/program_gac_compliant.py

@@ -1,39 +0,0 @@
-"""Module which implements GAC compliance validators for the program OpenADR3 types."""
-
-from openadr3_client.models.program.program import Program
-from openadr3_client.models.model import ValidatorRegistry, Model as ValidatorModel
-
-import re
-
-
-@ValidatorRegistry.register(Program, ValidatorModel())
-def program_gac_compliant(self: Program) -> Program:
-    """Enforces that the program is GAC compliant.
-
-    GAC enforces the following constraints for programs:
-    - The program must have a retailer name
-    - The retailer name must be between 2 and 128 characters long.
-    - The program MUST have a programType.
-    - The programType MUST equal "DSO_CPO_INTERFACE-x.x.x, where x.x.x is the version as defined in the GAC specification.
-    - The program MUST have bindingEvents set to True.
-    are allowed there.
-    """
-    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.")
-
-    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.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."
-        )
-
-    if self.binding_events is False:
-        raise ValueError("The program must have bindingEvents set to True.")
-
-    return self

openadr3_client_gac_compliance-1.1.0/openadr3_client_gac_compliance/gac20/ven_gac_compliant.py

@@ -1,27 +0,0 @@
-import re
-from openadr3_client.models.model import ValidatorRegistry, Model as ValidatorModel
-from openadr3_client.models.ven.ven import Ven
-import pycountry
-
-
-@ValidatorRegistry.register(Ven, ValidatorModel())
-def ven_gac_compliant(self: Ven) -> Ven:
-    """Enforces that the ven is GAC compliant.
-
-    GAC enforces the following constraints for vens:
-    - The ven must have a ven name
-    - The ven name must be an eMI3 identifier.
-    """
-    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.")
-
-    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."
-        )
-
-    return self