openadr3-client-gac-compliance 2.0.0__tar.gz → 3.0.0a2__tar.gz

{openadr3_client_gac_compliance-2.0.0 → openadr3_client_gac_compliance-3.0.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openadr3-client-gac-compliance
-Version: 2.0.0
+Version: 3.0.0a2
 Summary: 
 License-File: LICENSE.md
 Author: Nick van der Burgt
@@ -10,18 +10,22 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: openadr3-client (>=0.0.11,<1.0.0)
+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)
-Requires-Dist: python-decouple (>=3.8,<4.0)
 Description-Content-Type: text/markdown
 
 # OpenADR3 client
 
 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-2.0.0 → openadr3_client_gac_compliance-3.0.0a2}/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.0a2/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-2.0.0 → openadr3_client_gac_compliance-3.0.0a2}/openadr3_client_gac_compliance/gac20/event_gac_compliant.py

@@ -9,7 +9,7 @@ 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.
 """
 
 import re
@@ -17,28 +17,27 @@ from itertools import pairwise
 
 from openadr3_client.models.event.event import Event
 from openadr3_client.models.event.event_payload import EventPayloadType
-from openadr3_client.models.model import Model as ValidatorModel
-from openadr3_client.models.model import ValidatorRegistry
-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]]:
+
+def _continuous_or_separated(self: Event) -> list[InitErrorDetails]:
     """
-    Enforces that events either have consistent interval definitions compliant with GAC.
+    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. Separated
 
     The continuous 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
+    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 separated intervalDefinition approach, the intervalPeriods must be set on each individual intervals,
-    and the top-level intervalPeriod of the event must be None. This separated 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] = []
@@ -54,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'.",  # noqa: E501
+                        INTERVAL_PERIOD_ERROR_MESSAGE,
                     ),
                     loc=("intervals",),
                     input=self.intervals,
@@ -70,7 +69,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'.",  # noqa: E501
+                        INTERVAL_PERIOD_ERROR_MESSAGE,
                     ),
                     loc=("intervals",),
                     input=self.intervals,
@@ -78,19 +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]]:
+def _targets_compliant(self: Event) -> list[InitErrorDetails]:
     """
-    Enforces that the targets of the event are compliant with GAC.
+    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 ()
@@ -142,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,
@@ -159,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,
@@ -185,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,
@@ -198,7 +197,7 @@ def _targets_compliant(self: Event) -> tuple[Event, list[InitErrorDetails]]:
                 InitErrorDetails(
                     type=PydanticCustomError(
                         "value_error",
-                        "The VEN_NAME target value must be a list of 'ven object name' values (between 1 and 128 characters).",  # noqa: E501
+                        "The VEN_NAME target value must be a list of 'VEN name' values (between 1 and 128 characters).",
                     ),
                     loc=("targets",),
                     input=self.targets,
@@ -206,18 +205,18 @@ def _targets_compliant(self: Event) -> tuple[Event, list[InitErrorDetails]]:
                 )
             )
 
-    return self, validation_errors
+    return validation_errors
 
 
 def _payload_descriptors_gac_compliant(
     self: Event,
-) -> tuple[Event, list[InitErrorDetails]]:
+) -> list[InitErrorDetails]:
     """
-    Enforces that the payload descriptor is GAC compliant.
+    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).
     """
@@ -278,14 +277,14 @@ def _payload_descriptors_gac_compliant(
                 )
             )
 
-    return self, validation_errors
+    return validation_errors
 
 
-def _event_interval_gac_compliant(self: Event) -> tuple[Event, list[InitErrorDetails]]:
+def _event_interval_gac_compliant(self: Event) -> list[InitErrorDetails]:
     """
-    Enforces that the event interval is GAC compliant.
+    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.
@@ -361,22 +360,21 @@ def _event_interval_gac_compliant(self: Event) -> tuple[Event, list[InitErrorDet
                     )
                 )
 
-    return self, validation_errors
+    return validation_errors
 
 
-@ValidatorRegistry.register(Event, ValidatorModel())
-def event_gac_compliant(self: Event) -> Event:
+def validate_event_gac_compliant(event: Event) -> list[InitErrorDetails] | None:
     """
-    Enforces that events are GAC compliant.
+    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(
@@ -384,24 +382,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_descriptors_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.0a2/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-2.0.0 → openadr3_client_gac_compliance-3.0.0a2}/openadr3_client_gac_compliance/gac20/program_gac_compliant.py

@@ -2,25 +2,21 @@
 
 import re
 
-from openadr3_client.models.model import Model as ValidatorModel
-from openadr3_client.models.model import ValidatorRegistry
 from openadr3_client.models.program.program import Program
-from pydantic import ValidationError
 from pydantic_core import InitErrorDetails, PydanticCustomError
 
 
-@ValidatorRegistry.register(Program, ValidatorModel())
-def program_gac_compliant(self: Program) -> Program:
+def validate_program_gac_compliant(program: Program) -> list[InitErrorDetails] | None:
     """
-    Enforces that the program is GAC compliant.
+    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] = []
 
@@ -35,7 +31,7 @@ def program_gac_compliant(self: Program) -> Program:
         r"$"
     )
 
-    if self.retailer_name is None:
+    if program.retailer_name is None:
         validation_errors.append(
             InitErrorDetails(
                 type=PydanticCustomError(
@@ -43,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  # noqa: PLR2004
+    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(
@@ -58,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(
@@ -71,11 +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(
@@ -83,25 +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.0a2/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-2.0.0 → openadr3_client_gac_compliance-3.0.0a2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openadr3-client-gac-compliance"
-version = "2.0.0"
+version = "3.0.0a2"
 description = ""
 authors = [
     {name = "Nick van der Burgt", email = "nick.van.der.burgt@elaad.nl"}
@@ -9,9 +9,8 @@ readme = "README.md"
 requires-python = ">=3.12, <4"
 dependencies = [
     "pydantic (>=2.11.2,<3.0.0)",
-    "openadr3-client (>=0.0.11,<1.0.0)",
+    "openadr3-client (>=1.0.0a1,<2.0.0)",
     "pycountry (>=24.6.1,<25.0.0)",
-    "python-decouple (>=3.8,<4.0)",
 ]
 
 [build-system]
@@ -26,7 +25,7 @@ pytest-cov = "^6.1.1"
 taskipy = "^1.14.1"
 
 [[tool.mypy.overrides]]
-module = ["openadr3_client", "decouple"]
+module = ["openadr3_client"]
 ignore_missing_imports = true
 
 [tool.taskipy.tasks]

openadr3_client_gac_compliance-2.0.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.event_gac_compliant
-    import openadr3_client_gac_compliance.gac20.program_gac_compliant
-    import openadr3_client_gac_compliance.gac20.ven_gac_compliant  # noqa: F401

openadr3_client_gac_compliance-2.0.0/openadr3_client_gac_compliance/config.py

@@ -1,29 +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:
-        msg = f"Invalid GAC version: {value}"
-        raise ValueError(msg)
-    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-2.0.0/openadr3_client_gac_compliance/gac20/ven_gac_compliant.py

@@ -1,55 +0,0 @@
-import re
-
-import pycountry
-from openadr3_client.models.model import Model as ValidatorModel
-from openadr3_client.models.model import ValidatorRegistry
-from openadr3_client.models.ven.ven import Ven
-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