[Transition to dataclass] meta.py file

Author: DEKHTIARJonathan

tests/test_combinations.py

@@ -1,14 +1,16 @@
 import json
-from pathlib import Path
 import random
 import string
+from collections.abc import Generator
+from pathlib import Path
 
+import jsondiff
+import pytest
 from hypothesis import assume
 from hypothesis import example
 from hypothesis import given
 from hypothesis import strategies as st
-import jsondiff
-import pytest
+
 from variantlib.combination import filtered_sorted_variants
 from variantlib.combination import get_combinations
 from variantlib.config import KeyConfig
@@ -51,7 +53,7 @@ def test_get_combinations(configs):
     assert not differences, f"Serialization altered JSON: {differences}"
 
 
-def desc_to_json(desc_list: list[VariantDescription]) -> dict:
+def desc_to_json(desc_list: list[VariantDescription]) -> Generator:
     shuffled_desc_list = list(desc_list)
     random.shuffle(shuffled_desc_list)
     for desc in shuffled_desc_list:
@@ -63,9 +65,10 @@ def desc_to_json(desc_list: list[VariantDescription]) -> dict:
 
 
 def test_filtered_sorted_variants_roundtrip(configs):
-    """Test that we can round-trip all combinations via variants.json and get the same result."""
+    """Test that we can round-trip all combinations via variants.json and get the same
+    result."""
     combinations = list(get_combinations(configs))
-    variants_from_json = {k: v for k, v in desc_to_json(combinations)}
+    variants_from_json = dict(desc_to_json(combinations))
     assert filtered_sorted_variants(variants_from_json, configs) == combinations
 
 
@@ -125,5 +128,5 @@ def filter_long_combinations():
             yield x
 
     combinations = list(filter_long_combinations())
-    variants_from_json = {k: v for k, v in desc_to_json(combinations)}
+    variants_from_json = dict(desc_to_json(combinations))
     assert filtered_sorted_variants(variants_from_json, configs) == combinations

tests/test_config.py

@@ -1,4 +1,5 @@
 import pytest
+
 from variantlib.config import KeyConfig
 from variantlib.config import ProviderConfig
 
@@ -7,7 +8,7 @@ def test_key_config_creation_valid():
     """Test valid creation of KeyConfig."""
     key_config = KeyConfig(key="attr_nameA", values=["7", "4", "8", "12"])
     assert key_config.key == "attr_nameA"
-    assert key_config.values == ["7", "4", "8", "12"]  # noqa: PD011
+    assert key_config.values == ["7", "4", "8", "12"]
 
 
 def test_provider_config_creation_valid():

tests/test_meta.py

@@ -3,6 +3,7 @@
 import string
 
 import pytest
+
 from variantlib import VARIANT_HASH_LEN
 from variantlib.meta import VariantDescription
 from variantlib.meta import VariantMeta
@@ -193,7 +194,7 @@ def test_variantdescription_invalid_data():
         "key": "access_key",
         "value": "secret_value",
     }
-    with pytest.raises(AssertionError):
+    with pytest.raises(TypeError):
         VariantDescription([invalid_meta])
 
 

variantlib/combination.py

@@ -20,7 +20,7 @@ def get_combinations(data: list[ProviderConfig]) -> Generator[VariantDescription
     data = [
         [
             VariantMeta(provider=provider_cnf.provider, key=key_config.key, value=val)
-            for val in key_config.values  # noqa: PD011
+            for val in key_config.values
         ]
         for provider_cnf in data
         for key_config in provider_cnf.configs
@@ -30,27 +30,26 @@ def get_combinations(data: list[ProviderConfig]) -> Generator[VariantDescription
     for r in range(len(data), 0, -1):
         for combo in itertools.combinations(data, r):
             for vmetas in itertools.product(*combo):
-                yield VariantDescription(data=vmetas)
+                yield VariantDescription(data=list(vmetas))
 
 
-def unpack_variants_from_json(variants_from_json: dict
-                              ) -> Generator[VariantDescription]:
+def unpack_variants_from_json(
+    variants_from_json: dict,
+) -> Generator[VariantDescription]:
     def variant_to_metas(providers: dict) -> VariantMeta:
         for provider, keys in providers.items():
             for key, value in keys.items():
-                yield VariantMeta(provider=provider,
-                                  key=key,
-                                  value=value)
+                yield VariantMeta(provider=provider, key=key, value=value)
 
     for variant_hash, providers in variants_from_json.items():
-        desc = VariantDescription(variant_to_metas(providers))
+        desc = VariantDescription(list(variant_to_metas(providers)))
         assert variant_hash == desc.hexdigest
         yield desc
 
 
-def filtered_sorted_variants(variants_from_json: dict,
-                             data: list[ProviderConfig]
-                             ) -> Generator[VariantDescription]:
+def filtered_sorted_variants(  # noqa: C901
+    variants_from_json: dict, data: list[ProviderConfig]
+) -> Generator[VariantDescription]:
     providers = {}
     for provider_idx, provider_cnf in enumerate(data):
         keys = {}
@@ -94,15 +93,26 @@ def variant_sort_key_gen(desc: VariantDescription) -> Generator[tuple]:
         yield from (x[0:2] for x in meta_keys)
         yield from (x[2] for x in meta_keys)
 
-    res = sorted(filter(variant_filter,
-                        unpack_variants_from_json(variants_from_json)),
-                 key=lambda x: tuple(variant_sort_key_gen(x)))
+    res = sorted(
+        filter(variant_filter, unpack_variants_from_json(variants_from_json)),
+        key=lambda x: tuple(variant_sort_key_gen(x)),
+    )
+
     if missing_providers:
-        logger.warn("No plugins provide the following variant providers: "
-                    f"{' '.join(missing_providers)}; some variants will be ignored")
+        logger.warning(
+            "No plugins provide the following variant providers: "
+            "%(provider)s; some variants will be ignored",
+            provider=" ".join(missing_providers),
+        )
+
     for provider, provider_missing_keys in missing_keys.items():
-        logger.warn(f"The {provider} provider does not provide the following expected keys: "
-                    f"{' '.join(provider_missing_keys)}; some variants will be ignored")
+        logger.warning(
+            "The %(provider)s provider does not provide the following expected keys: "
+            "%(missing_keys)s; some variants will be ignored",
+            provider=provider,
+            missing_keys=" ".join(provider_missing_keys),
+        )
+
     return res
 
 

variantlib/meta.py

@@ -2,40 +2,53 @@
 import hashlib
 import re
 from collections.abc import Iterator
+from dataclasses import asdict
+from dataclasses import dataclass
+from dataclasses import field
 from typing import Self
 
-from attrs import Converter
-from attrs import asdict
-from attrs import field
-from attrs import frozen
-from attrs import validators
-
 from variantlib.constants import VALIDATION_REGEX
 from variantlib.constants import VALIDATION_VALUE_REGEX
 from variantlib.constants import VARIANT_HASH_LEN
+from variantlib.validators import validate_instance_of
+from variantlib.validators import validate_list_of
+from variantlib.validators import validate_matches_re
 
 
-@frozen
+@dataclass(frozen=True)
 class VariantMeta:
     provider: str = field(
-        validator=[
-            validators.instance_of(str),
-            validators.matches_re(VALIDATION_REGEX),
-        ]
+        metadata={
+            "validators": [
+                lambda v: validate_instance_of(v, str),
+                lambda v: validate_matches_re(v, VALIDATION_REGEX),
+            ]
+        }
     )
     key: str = field(
-        validator=[
-            validators.instance_of(str),
-            validators.matches_re(VALIDATION_REGEX),
-        ]
+        metadata={
+            "validators": [
+                lambda v: validate_instance_of(v, str),
+                lambda v: validate_matches_re(v, VALIDATION_REGEX),
+            ]
+        }
     )
     value: str = field(
-        validator=[
-            validators.instance_of(str),
-            validators.matches_re(VALIDATION_VALUE_REGEX),
-        ]
+        metadata={
+            "validators": [
+                lambda v: validate_instance_of(v, str),
+                lambda v: validate_matches_re(v, VALIDATION_VALUE_REGEX),
+            ]
+        }
     )
 
+    def __post_init__(self):
+        # Execute the validators
+        for field_name, field_def in self.__dataclass_fields__.items():
+            value = getattr(self, field_name)
+            for validator in field_def.metadata.get("validators", []):
+                validator(value)
+
     def __hash__(self) -> int:
         # Variant Metas are unique in provider & key and ignore the value.
         return hash((self.__class__, self.provider, self.key))
@@ -75,16 +88,8 @@ def deserialize(cls, data: dict[str, str]) -> Self:
         return cls(**data)
 
 
-def _sort_variantmetas(value: list[VariantMeta]) -> list[VariantMeta]:
-    # We sort the data so that they always get displayed/hashed
-    # in a consistent manner.
-    with contextlib.suppress(AttributeError):
-        return sorted(value, key=lambda x: (x.provider, x.key))
-    # Error will be rejected during validation
-    return value
-
-
-@frozen
+@dataclass(frozen=True)
+# @dataclass
 class VariantDescription:
     """
     A `Variant` is being described by a N >= 1 `VariantMeta` metadata.
@@ -96,17 +101,31 @@ class VariantDescription:
     """
 
     data: list[VariantMeta] = field(
-        validator=validators.instance_of(list), converter=Converter(_sort_variantmetas)
+        metadata={
+            "validators": [
+                lambda v: validate_instance_of(v, list),
+                lambda v: validate_list_of(v, VariantMeta),
+            ]
+        }
     )
 
-    @data.validator
-    def validate_data(self, _, data: list[VariantMeta]) -> None:
-        """The field `data` must comply with the following
-        - Being a non-empty list of `VariantMeta`
-        - Each value inside the list must be unique
-        """
-        assert len(data) > 0
-        assert all(isinstance(inst, VariantMeta) for inst in data)
+    def __post_init__(self):
+        # Execute the validators
+        for field_name, field_def in self.__dataclass_fields__.items():
+            value = getattr(self, field_name)
+            for validator in field_def.metadata.get("validators", []):
+                validator(value)
+
+        # We verify `data` is not empty
+        assert len(self.data) > 0
+
+        # We sort the data so that they always get displayed/hashed
+        # in a consistent manner.
+        with contextlib.suppress(AttributeError):
+            # Only "legal way" to modify a frozen dataclass attribute post init.
+            object.__setattr__(
+                self, "data", sorted(self.data, key=lambda x: (x.provider, x.key))
+            )
 
         # Detect multiple `VariantMeta` with identical provider/key
         # Ignores the attribute `value` of `VariantMeta`.
@@ -116,7 +135,7 @@ def validate_data(self, _, data: list[VariantMeta]) -> None:
         #       an exception when there is a collision instead of
         #       a silent behavior.
         seen = set()
-        for vmeta in data:
+        for vmeta in self.data:
             vmeta_hash = hash(vmeta)
             if vmeta_hash in seen:
                 raise ValueError(

variantlib/validators.py

@@ -0,0 +1,18 @@
+import re
+from typing import Any
+
+
+def validate_instance_of(value: Any, expected_type: type) -> None:
+    if not isinstance(value, expected_type):
+        raise TypeError(f"Expected {expected_type}, got {type(value)}")
+
+
+def validate_list_of(data: list[Any], expected_type: type) -> None:
+    for value in data:
+        if not isinstance(value, expected_type):
+            raise TypeError(f"Expected {expected_type}, got {type(value)}")
+
+
+def validate_matches_re(value: str, pattern: str) -> None:
+    if not re.match(pattern, value):
+        raise ValueError(f"Value must match regex {pattern}")