openadr3-client-gac-compliance 1.4.0__tar.gz → 3.0.0__tar.gz

{openadr3_client_gac_compliance-1.4.0 → openadr3_client_gac_compliance-3.0.0}/PKG-INFO

@@ -1,14 +1,16 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: openadr3-client-gac-compliance
-Version: 1.4.0
+Version: 3.0.0
 Summary: 
+License-File: LICENSE.md
 Author: Nick van der Burgt
 Author-email: nick.van.der.burgt@elaad.nl
 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.7,<1.0.0)
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: openadr3-client (>=1.0.0a1,<2.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
@@ -17,8 +19,13 @@ Description-Content-Type: text/markdown
 
 This repository contains a plugin for the [OpenADR3-client](https://github.com/ElaadNL/openadr3-client) library that adds additional pydantic validators to the OpenADR3 domain models to ensure GAC compliance. Since GAC compliance is a superset of OpenADR3, adding validation rules on top of the OpenADR3 models is sufficient to ensure compliance.
 
-To use this plugin, the package must be imported once globally. We recommend doing this in your root directories `__init__.py` file.
+Registering the plugin is done using the global ValidatorPluginRegistry class:
 
 ```python
-import openadr3_client_gac_compliance  # noqa: F401 (in case you use ruff)
+    from openadr3_client.plugin import ValidatorPluginRegistry, ValidatorPlugin
+    from openadr3_client_gac_compliance.gac20.plugin import Gac20ValidatorPlugin
+
+    ValidatorPluginRegistry.register_plugin(
+        Gac20ValidatorPlugin().setup()
+    )
 ```

{openadr3_client_gac_compliance-1.4.0 → openadr3_client_gac_compliance-3.0.0}/README.md

@@ -2,8 +2,13 @@
 
 This repository contains a plugin for the [OpenADR3-client](https://github.com/ElaadNL/openadr3-client) library that adds additional pydantic validators to the OpenADR3 domain models to ensure GAC compliance. Since GAC compliance is a superset of OpenADR3, adding validation rules on top of the OpenADR3 models is sufficient to ensure compliance.
 
-To use this plugin, the package must be imported once globally. We recommend doing this in your root directories `__init__.py` file.
+Registering the plugin is done using the global ValidatorPluginRegistry class:
 
 ```python
-import openadr3_client_gac_compliance  # noqa: F401 (in case you use ruff)
+    from openadr3_client.plugin import ValidatorPluginRegistry, ValidatorPlugin
+    from openadr3_client_gac_compliance.gac20.plugin import Gac20ValidatorPlugin
+
+    ValidatorPluginRegistry.register_plugin(
+        Gac20ValidatorPlugin().setup()
+    )
 ```

openadr3_client_gac_compliance-3.0.0/openadr3_client_gac_compliance/__init__.py

@@ -0,0 +1,22 @@
+"""
+OpenADR3 GAC Compliance Plugin.
+
+This package provides validation plugins for OpenADR3 models to ensure compliance
+with the Grid Aware Charging (GAC) specification.
+
+The main entry point is the Gac20ValidatorPlugin which can be registered
+with the OpenADR3 client's validator plugin registry.
+
+Example:
+    ```python
+    from openadr3_client.plugin import ValidatorPluginRegistry
+    from openadr3_client_gac_compliance.plugin import Gac20ValidatorPlugin
+    from openadr3_client_gac_compliance.gac20.gac_plugin import GacVersion
+
+    # Register the GAC validation plugin
+    ValidatorPluginRegistry.register_plugin(
+        Gac20ValidatorPlugin.setup(gac_version=GacVersion.VERSION_2_0)
+    )
+    ```
+
+"""

{openadr3_client_gac_compliance-1.4.0 → openadr3_client_gac_compliance-3.0.0}/openadr3_client_gac_compliance/gac20/__init__.py

@@ -1,4 +1,4 @@
 # This module imports all the GAC 3.0 compliance validators.
 
+import openadr3_client_gac_compliance.gac20.event_gac_compliant
 import openadr3_client_gac_compliance.gac20.program_gac_compliant  # noqa: F401
-import openadr3_client_gac_compliance.gac20.event_gac_compliant  # noqa: F401

{openadr3_client_gac_compliance-1.4.0 → openadr3_client_gac_compliance-3.0.0}/openadr3_client_gac_compliance/gac20/event_gac_compliant.py

@@ -1,4 +1,5 @@
-"""Module which implements GAC compliance validators for the event OpenADR3 types.
+"""
+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.
@@ -8,37 +9,37 @@ pydantic validators. Namely, the requirement that a safe mode event MUST be pres
 
 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.
+as the program object does not contain the events, these are stored separately in the VTN.
 """
 
-from itertools import pairwise
 import re
-from typing import Tuple
-from openadr3_client.models.model import ValidatorRegistry, Model as ValidatorModel
+from itertools import pairwise
+
 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
 
+INTERVAL_PERIOD_ERROR_MESSAGE = "'interval_period' must either be set on the event-level, or for each interval."
+
 
-def _continuous_or_seperated(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
-    """Enforces that events either have consistent interval definitions compliant with GAC.
+def _continuous_or_separated(self: Event) -> list[InitErrorDetails]:
+    """
+    Validates that events have consistent interval definitions GAC compliant.
 
-    the Grid aware charging (GAC) specification allows for two types of (mutually exclusive)
+    The Grid aware charging (GAC) specification allows for two types of (mutually exclusive)
     interval definitions:
 
     1. Continuous
-    2. Seperated
+    2. Separated
 
-    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
+    The continuous implementation can be used when all intervals have the same duration.
+    In this case, only the top-level intervalPeriod of the event may 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
+    In the separated implementation, the intervalPeriods must be set on each individual intervals,
+    and the top-level intervalPeriod of the event must be None. This separated implementation allows events to have differing
     durations.
-    """
+    """  # noqa: E501
     validation_errors: list[InitErrorDetails] = []
 
     intervals = self.intervals or ()
@@ -52,7 +53,7 @@ def _continuous_or_seperated(self: Event) -> Tuple[Event, list[InitErrorDetails]
                 InitErrorDetails(
                     type=PydanticCustomError(
                         "value_error",
-                        "Either 'interval_period' must be set on the event once, or every interval must have its own 'interval_period'.",
+                        INTERVAL_PERIOD_ERROR_MESSAGE,
                     ),
                     loc=("intervals",),
                     input=self.intervals,
@@ -62,15 +63,13 @@ def _continuous_or_seperated(self: Event) -> Tuple[Event, list[InitErrorDetails]
     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
-        ]
+        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'.",
+                        INTERVAL_PERIOD_ERROR_MESSAGE,
                     ),
                     loc=("intervals",),
                     input=self.intervals,
@@ -78,18 +77,19 @@ def _continuous_or_seperated(self: Event) -> Tuple[Event, list[InitErrorDetails]
                 )
             )
 
-    return self, validation_errors
+    return validation_errors
 
 
-def _targets_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
-    """Enforces that the targets of the event are compliant with GAC.
+def _targets_compliant(self: Event) -> list[InitErrorDetails]:
+    """
+    Validates that the targets of the event are GAC compliant.
 
-    GAC enforces the following constraints for targets:
+    The following constraints are enforced for targets:
 
     - The event must contain a POWER_SERVICE_LOCATION target.
     - The POWER_SERVICE_LOCATION 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).
+    - The VEN_NAME target value must be a list of 'VEN name' values (between 1 and 128 characters).
     """
     validation_errors: list[InitErrorDetails] = []
     targets = self.targets or ()
@@ -141,7 +141,7 @@ def _targets_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
             InitErrorDetails(
                 type=PydanticCustomError(
                     "value_error",
-                    "The event must contain only one VEN_NAME target.",
+                    "The event must contain exactly one VEN_NAME target.",
                 ),
                 loc=("targets",),
                 input=self.targets,
@@ -149,12 +149,7 @@ def _targets_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
             )
         )
 
-    if (
-        power_service_locations
-        and ven_names
-        and len(power_service_locations) == 1
-        and len(ven_names) == 1
-    ):
+    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]
 
@@ -163,7 +158,7 @@ def _targets_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
                 InitErrorDetails(
                     type=PydanticCustomError(
                         "value_error",
-                        "The POWER_SERVICE_LOCATION target value cannot be empty.",
+                        "The POWER_SERVICE_LOCATION target value may not be empty.",
                     ),
                     loc=("targets",),
                     input=self.targets,
@@ -171,9 +166,7 @@ def _targets_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
                 )
             )
 
-        if not all(
-            re.fullmatch(r"^EAN\d{15}$", v) for v in power_service_location.values
-        ):
+        if not all(re.fullmatch(r"^\d{18}$", v) for v in power_service_location.values):
             validation_errors.append(
                 InitErrorDetails(
                     type=PydanticCustomError(
@@ -191,7 +184,7 @@ def _targets_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
                 InitErrorDetails(
                     type=PydanticCustomError(
                         "value_error",
-                        "The VEN_NAME target value cannot be empty.",
+                        "The VEN_NAME target value may not be empty.",
                     ),
                     loc=("targets",),
                     input=self.targets,
@@ -199,12 +192,12 @@ def _targets_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
                 )
             )
 
-        if not all(1 <= len(v) <= 128 for v in ven_name.values):
+        if not all(1 <= len(v) <= 128 for v in ven_name.values):  # noqa: PLR2004
             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).",
+                        "The VEN_NAME target value must be a list of 'VEN name' values (between 1 and 128 characters).",
                     ),
                     loc=("targets",),
                     input=self.targets,
@@ -212,17 +205,18 @@ def _targets_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
                 )
             )
 
-    return self, validation_errors
+    return validation_errors
 
 
-def _payload_descriptor_gac_compliant(
+def _payload_descriptors_gac_compliant(
     self: Event,
-) -> Tuple[Event, list[InitErrorDetails]]:
-    """Enforces that the payload descriptor is GAC compliant.
+) -> list[InitErrorDetails]:
+    """
+    Validates that the payload descriptor is GAC compliant.
 
-    GAC enforces the following constraints for payload descriptors:
+    The following constraints are enforced for payload descriptors:
 
-    - The event interval must exactly one payload descriptor.
+    - The event interval must contain 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).
     """
@@ -255,9 +249,9 @@ def _payload_descriptor_gac_compliant(
                 )
             )
 
-        payload_descriptor = self.payload_descriptors[0]
+        payload_descriptors = self.payload_descriptors[0]
 
-        if payload_descriptor.payload_type != EventPayloadType.IMPORT_CAPACITY_LIMIT:
+        if payload_descriptors.payload_type != EventPayloadType.IMPORT_CAPACITY_LIMIT:
             validation_errors.append(
                 InitErrorDetails(
                     type=PydanticCustomError(
@@ -270,7 +264,7 @@ def _payload_descriptor_gac_compliant(
                 )
             )
 
-        if payload_descriptor.units != "KW":
+        if payload_descriptors.units != "KW":
             validation_errors.append(
                 InitErrorDetails(
                     type=PydanticCustomError(
@@ -283,13 +277,14 @@ def _payload_descriptor_gac_compliant(
                 )
             )
 
-    return self, validation_errors
+    return validation_errors
 
 
-def _event_interval_gac_compliant(self: Event) -> Tuple[Event, list[InitErrorDetails]]:
-    """Enforces that the event interval is GAC compliant.
+def _event_interval_gac_compliant(self: Event) -> list[InitErrorDetails]:
+    """
+    Validates that the event interval is GAC compliant.
 
-    GAC enforces the following constraints for event intervals:
+    The following constraints are enforced for event intervals:
 
     - The event interval must have an id value that is strictly increasing.
     - The event interval must have exactly one payload.
@@ -364,22 +359,34 @@ def _event_interval_gac_compliant(self: Event) -> Tuple[Event, list[InitErrorDet
                         ctx={},
                     )
                 )
+            if len(payload.values) > 1:
+                validation_errors.append(
+                    InitErrorDetails(
+                        type=PydanticCustomError(
+                            "value_error",
+                            "The event interval payload must have exactly one value per payload.",
+                        ),
+                        loc=("intervals",),
+                        input=self.intervals,
+                        ctx={},
+                    )
+                )
 
-    return self, validation_errors
+    return validation_errors
 
 
-@ValidatorRegistry.register(Event, ValidatorModel())
-def event_gac_compliant(self: Event) -> Event:
-    """Enforces that events are GAC compliant.
+def validate_event_gac_compliant(event: Event) -> list[InitErrorDetails] | None:
+    """
+    Validates that events are GAC compliant.
 
-    GAC enforces the following constraints for events:
+    The following constraints are enforced for events:
 
     - The event must not have a priority set.
-    - The event must have either a continuous or seperated interval definition.
+    - The event must have either a continuous or separated interval definition.
     """
     validation_errors: list[InitErrorDetails] = []
 
-    if self.priority is not None:
+    if event.priority is not None:
         validation_errors.append(
             InitErrorDetails(
                 type=PydanticCustomError(
@@ -387,30 +394,21 @@ def event_gac_compliant(self: Event) -> Event:
                     "The event must not have a priority set for GAC 2.0 compliance",
                 ),
                 loc=("priority",),
-                input=self.priority,
+                input=event.priority,
                 ctx={},
             )
         )
 
-    interval_periods_validated, errors = _continuous_or_seperated(self)
+    errors = _continuous_or_separated(event)
     validation_errors.extend(errors)
 
-    targets_validated, errors = _targets_compliant(interval_periods_validated)
+    errors = _targets_compliant(event)
     validation_errors.extend(errors)
 
-    payload_descriptor_validated, errors = _payload_descriptor_gac_compliant(
-        targets_validated
-    )
+    errors = _payload_descriptors_gac_compliant(event)
     validation_errors.extend(errors)
 
-    event_interval_validated, errors = _event_interval_gac_compliant(
-        payload_descriptor_validated
-    )
+    errors = _event_interval_gac_compliant(event)
     validation_errors.extend(errors)
 
-    if validation_errors:
-        raise ValidationError.from_exception_data(
-            title=self.__class__.__name__, line_errors=validation_errors
-        )
-
-    return event_interval_validated
+    return validation_errors if validation_errors else None

openadr3_client_gac_compliance-3.0.0/openadr3_client_gac_compliance/gac20/plugin.py

@@ -0,0 +1,43 @@
+"""GAC compliance plugin for OpenADR3 client."""
+
+from typing import Any
+
+from openadr3_client.models.event.event import Event
+from openadr3_client.models.program.program import Program
+from openadr3_client.models.ven.ven import Ven
+from openadr3_client.plugin import ValidatorPlugin
+
+from openadr3_client_gac_compliance.gac20.event_gac_compliant import validate_event_gac_compliant
+from openadr3_client_gac_compliance.gac20.program_gac_compliant import validate_program_gac_compliant
+from openadr3_client_gac_compliance.gac20.ven_gac_compliant import validate_ven_gac_compliant
+
+
+class Gac20ValidatorPlugin(ValidatorPlugin):
+    """Plugin that validates OpenADR3 models for GAC compliance."""
+
+    def __init__(self) -> None:
+        """Initialize the GAC validator plugin."""
+        super().__init__()
+
+    @staticmethod
+    def setup(*_args: Any, **_kwargs: Any) -> "Gac20ValidatorPlugin":  # noqa: ANN401
+        """
+        Set up the GAC validator plugin.
+
+        Args:
+            *args: Positional arguments (unused).
+            **kwargs: Keyword arguments containing configuration.
+                     Expected keys:
+                     - gac_version: The GAC version to validate against.
+
+        Returns:
+            GacValidatorPlugin: Configured plugin instance.
+
+        """
+        plugin = Gac20ValidatorPlugin()
+
+        plugin.register_model_validator(Event, validate_event_gac_compliant)
+        plugin.register_model_validator(Program, validate_program_gac_compliant)
+        plugin.register_model_validator(Ven, validate_ven_gac_compliant)
+
+        return plugin

{openadr3_client_gac_compliance-1.4.0 → openadr3_client_gac_compliance-3.0.0}/openadr3_client_gac_compliance/gac20/program_gac_compliant.py

@@ -1,31 +1,37 @@
 """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 openadr3_client.models.program.program import Program
 from pydantic_core import InitErrorDetails, PydanticCustomError
 
 
-@ValidatorRegistry.register(Program, ValidatorModel())
-def program_gac_compliant(self: Program) -> Program:
-    """Enforces that the program is GAC compliant.
+def validate_program_gac_compliant(program: Program) -> list[InitErrorDetails] | None:
+    """
+    Validates that the program is GAC compliant.
 
-    GAC enforces the following constraints for programs:
+    The following constraints are enforced 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.
-    """
+    - The program MUST have bindingEvents set to true.
+
+    """  # noqa: E501
     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-]+)*))?$"
+    program_type_regex = (
+        r"^DSO_CPO_INTERFACE-"
+        r"(0|[1-9]\d*)\."
+        r"(0|[1-9]\d*)\."
+        r"(0|[1-9]\d*)"
+        r"(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)"
+        r"(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))"
+        r"?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?"
+        r"$"
+    )
 
-    if self.retailer_name is None:
+    if program.retailer_name is None:
         validation_errors.append(
             InitErrorDetails(
                 type=PydanticCustomError(
@@ -33,13 +39,13 @@ def program_gac_compliant(self: Program) -> Program:
                     "The program must have a retailer name.",
                 ),
                 loc=("retailer_name",),
-                input=self.retailer_name,
+                input=program.retailer_name,
                 ctx={},
             )
         )
 
-    if self.retailer_name is not None and (
-        len(self.retailer_name) < 2 or len(self.retailer_name) > 128
+    if program.retailer_name is not None and (
+        len(program.retailer_name) < 2 or len(program.retailer_name) > 128  # noqa: PLR2004
     ):
         validation_errors.append(
             InitErrorDetails(
@@ -48,12 +54,12 @@ def program_gac_compliant(self: Program) -> Program:
                     "The retailer name must be between 2 and 128 characters long.",
                 ),
                 loc=("retailer_name",),
-                input=self.retailer_name,
+                input=program.retailer_name,
                 ctx={},
             )
         )
 
-    if self.program_type is None:
+    if program.program_type is None:
         validation_errors.append(
             InitErrorDetails(
                 type=PydanticCustomError(
@@ -61,13 +67,11 @@ def program_gac_compliant(self: Program) -> Program:
                     "The program must have a program type.",
                 ),
                 loc=("program_type",),
-                input=self.program_type,
+                input=program.program_type,
                 ctx={},
             )
         )
-    if self.program_type is not None and not re.fullmatch(
-        program_type_regex, self.program_type
-    ):
+    if program.program_type is not None and not re.fullmatch(program_type_regex, program.program_type):
         validation_errors.append(
             InitErrorDetails(
                 type=PydanticCustomError(
@@ -75,27 +79,22 @@ def program_gac_compliant(self: Program) -> Program:
                     "The program type must follow the format DSO_CPO_INTERFACE-x.x.x.",
                 ),
                 loc=("program_type",),
-                input=self.program_type,
+                input=program.program_type,
                 ctx={},
             )
         )
 
-    if self.binding_events is False:
+    if program.binding_events is False:
         validation_errors.append(
             InitErrorDetails(
                 type=PydanticCustomError(
                     "value_error",
-                    "The program must have bindingEvents set to True.",
+                    "The program must have bindingEvents set to true.",
                 ),
                 loc=("binding_events",),
-                input=self.binding_events,
+                input=program.binding_events,
                 ctx={},
             )
         )
 
-    if validation_errors:
-        raise ValidationError.from_exception_data(
-            title=self.__class__.__name__, line_errors=validation_errors
-        )
-
-    return self
+    return validation_errors if validation_errors else None

openadr3_client_gac_compliance-3.0.0/openadr3_client_gac_compliance/gac20/ven_gac_compliant.py

@@ -0,0 +1,49 @@
+import re
+
+import pycountry
+from openadr3_client.models.ven.ven import Ven
+from pydantic_core import InitErrorDetails, PydanticCustomError
+
+
+def validate_ven_gac_compliant(ven: Ven) -> list[InitErrorDetails] | None:
+    """
+    Validates that the VEN is GAC compliant.
+
+    The following constraints are enforced 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, ven.ven_name):
+        validation_errors.append(
+            InitErrorDetails(
+                type=PydanticCustomError(
+                    "value_error",
+                    "The VEN name must be formatted as an eMI3 identifier.",
+                ),
+                loc=("ven_name",),
+                input=ven.ven_name,
+                ctx={},
+            )
+        )
+
+    alpha_2_country = pycountry.countries.get(alpha_2=ven.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=ven.ven_name,
+                ctx={},
+            )
+        )
+
+    return validation_errors if validation_errors else None

openadr3_client_gac_compliance-3.0.0/pyproject.toml

@@ -0,0 +1,79 @@
+[project]
+name = "openadr3-client-gac-compliance"
+version = "3.0.0"
+description = ""
+authors = [
+    {name = "Nick van der Burgt", email = "nick.van.der.burgt@elaad.nl"}
+]
+readme = "README.md"
+requires-python = ">=3.12, <4"
+dependencies = [
+    "pydantic (>=2.11.2,<3.0.0)",
+    "openadr3-client (>=1.0.0a1,<2.0.0)",
+    "pycountry (>=24.6.1,<25.0.0)",
+]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.group.dev.dependencies]
+mypy = "^1.15.0"
+ruff = "^0.11.4"
+pytest = "^8.3.5"
+pytest-cov = "^6.1.1"
+taskipy = "^1.14.1"
+
+[[tool.mypy.overrides]]
+module = ["openadr3_client"]
+ignore_missing_imports = true
+
+[tool.taskipy.tasks]
+local-ci = "task check && task format && task mypy && task test"
+fix = "task check-fix && task format-fix && task mypy"
+check = "ruff check ."
+check-fix = "ruff check --fix ."
+check-ci = "ruff check --output-format=github --no-cache ."
+mypy = "mypy . --check-untyped-defs"
+format = "ruff format . --diff"
+format-fix = "ruff format ."
+format-ci = "ruff format --diff --no-cache ."
+test = "pytest --cov"
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["ALL"]
+
+# Do not require docstrings for functions, methods and classes
+ignore = [
+    # From:https://github.com/wemake-services/wemake-django-template/blob/master/pyproject.toml
+    "A005",   # allow to shadow stdlib and builtin module names
+    "COM812", # trailing comma, conflicts with `ruff format`
+    # Different doc rules that we don't really care about:
+    "D100",
+    "D104",
+    "D106",
+    "D203",
+    "D212",
+    "D401",
+    "D404",
+    "D405",
+    "ISC001",  # implicit string concat conflicts with `ruff format`
+    "ISC003",  # prefer explicit string concat over implicit concat
+    "PLR09",   # we have our own complexity rules
+    # "PLR2004", # do not report magic numbers -> I do want to report magic numbers
+    "PLR6301", # do not require classmethod / staticmethod when self not used
+    "TRY003",  # long exception messages from `tryceratops`
+    # Start of own error codes
+    "ANN002", # Ignore unused *args
+    "ANN003", # Ignore unused **kwargs
+    "D107", # Allow undocumented __init__
+    "TC001", # Move to type checking block (does not play nice with pydantic models)
+    "TC002", # Move to type checking block (does not play nice with pydantic models)
+]
+
+# Ignores S101 ("Use of 'assert' detected") for the tests.
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101", "ANN201", "SLF001", "S106", "S105", "S311", "PLR2004", "PT018"]

openadr3_client_gac_compliance-1.4.0/openadr3_client_gac_compliance/__init__.py

@@ -1,6 +0,0 @@
-from openadr3_client_gac_compliance.config import GAC_VERSION
-
-if GAC_VERSION == "2.0":
-    import openadr3_client_gac_compliance.gac20.program_gac_compliant  # noqa: F401
-    import openadr3_client_gac_compliance.gac20.event_gac_compliant  # noqa: F401
-    import openadr3_client_gac_compliance.gac20.ven_gac_compliant  # noqa: F401

openadr3_client_gac_compliance-1.4.0/openadr3_client_gac_compliance/config.py

@@ -1,26 +0,0 @@
-"""Contains configuration variables used by the OpenADR3 GAC compliance plugin."""
-
-from decouple import config
-
-VALID_GAC_VERSIONS: list[str] = ["2.0"]
-
-
-def _gac_version_cast(value: str) -> str:
-    """Cast the GAC version to a string.
-
-    Args:
-        value (str): The GAC version to cast.
-
-    Raises:
-        ValueError: If the GAC version is not a valid GAC version.
-
-    Returns:
-        str: The GAC version.
-    """
-    if value not in VALID_GAC_VERSIONS:
-        raise ValueError(f"Invalid GAC version: {value}")
-    return value
-
-
-# The GAC version to use for the compliance validators.
-GAC_VERSION = config("GAC_VERSION", default="2.0", cast=_gac_version_cast)

openadr3_client_gac_compliance-1.4.0/openadr3_client_gac_compliance/gac20/ven_gac_compliant.py

@@ -1,55 +0,0 @@
-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.4.0/pyproject.toml

@@ -1,28 +0,0 @@
-[project]
-name = "openadr3-client-gac-compliance"
-version = "1.4.0"
-description = ""
-authors = [
-    {name = "Nick van der Burgt", email = "nick.van.der.burgt@elaad.nl"}
-]
-readme = "README.md"
-requires-python = ">=3.12, <4"
-dependencies = [
-    "pydantic (>=2.11.2,<3.0.0)",
-    "openadr3-client (>=0.0.7,<1.0.0)",
-    "pycountry (>=24.6.1,<25.0.0)",
-]
-
-[build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.poetry.group.dev.dependencies]
-mypy = "^1.15.0"
-ruff = "^0.11.4"
-pytest = "^8.3.5"
-pytest-cov = "^6.1.1"
-
-[[tool.mypy.overrides]]
-module = ["openadr3_client", "decouple"]
-ignore_missing_imports = true