Merge pull request #112 from Exabyte-io/feature/SOF-7570-fix

fix: clean cleans config + tests

Author: VsevolodX

src/py/mat3ra/code/entity.py

@@ -38,7 +38,8 @@ class InMemoryEntityPydantic(BaseModel):
 
     @classmethod
     def create(cls: Type[T], config: Dict[str, Any]) -> T:
-        return cls.validate(config)
+        cleaned_data = cls.clean(config)
+        return cls.validate(cleaned_data)
 
     @classmethod
     def validate(cls, value: Any) -> Self:
@@ -59,8 +60,9 @@ def from_json(cls: Type[T], json_str: str) -> T:
 
     @classmethod
     def clean(cls: Type[T], config: Dict[str, Any]) -> Dict[str, Any]:
-        validated_model = cls.model_validate(config)
-        return validated_model.model_dump()
+        # Validate the config; extra keys are dropped and defaults are substituted.
+        validated = cls.model_validate(config, strict=False)
+        return validated.model_dump(exclude_unset=False)
 
     def get_schema(self) -> Dict[str, Any]:
         return self.model_json_schema()

src/py/mat3ra/code/vector.py

@@ -33,6 +33,10 @@ def __eq__(self, other):
             other = Vector3D(other)
         return np.allclose(self.root, other.root, atol=self.__atol__, rtol=0)
 
+    @property
+    def norm(self):
+        return np.linalg.norm(self.value)
+
 
 class RoundedVector3D(RoundNumericValuesMixin, Vector3D):
     def __init__(self, root: List[float]):
@@ -64,3 +68,7 @@ def __eq__(self, other):
             other = RoundedVector3D(other)
         atol = self.__atol__ or 10 ** (-self.__round_precision__)
         return np.allclose(self.value_rounded, other.value_rounded, atol=atol, rtol=0)
+
+    @property
+    def norm_rounded(self):
+        return self.round_array_or_number(self.norm)

tests/py/unit/__init__.py

@@ -4,6 +4,8 @@
 from pydantic import BaseModel
 
 REFERENCE_OBJECT_VALID = {"key1": "value1", "key2": 1}
+REFERENCE_OBJECT_VALID_WITH_EXTRA_KEY = {"key1": "value1", "key2": 1, "key-to-clean": "will-be-removed"}
+REFERENCE_OBJECT_VALID_WITH_MISSING_KEY = {"key2": 1}
 REFERENCE_OBJECT_VALID_UPDATED = {"key1": "value1-updated", "key2": 2}
 REFERENCE_OBJECT_INVALID = {"key1": "value1", "key2": "value2"}
 REFERENCE_OBJECT_VALID_JSON = json.dumps(REFERENCE_OBJECT_VALID)
@@ -18,6 +20,11 @@ class ExampleSchema(BaseModel):
     key2: int
 
 
+class ExampleDefaultableSchema(BaseModel):
+    key1: str = "value1"
+    key2: int
+
+
 class ExampleNestedSchema(BaseModel):
     nested_key1: ExampleSchema
 
@@ -30,6 +37,10 @@ class ExampleClass(ExampleSchema, InMemoryEntityPydantic):
     pass
 
 
+class ExampleDefaultableClass(ExampleDefaultableSchema, InMemoryEntityPydantic):
+    pass
+
+
 class ExampleNestedClass(ExampleNestedSchema, InMemoryEntityPydantic):
     @property
     def nested_key1_instance(self) -> ExampleClass:

tests/py/unit/test_entity.py

@@ -8,7 +8,10 @@
     REFERENCE_OBJECT_VALID,
     REFERENCE_OBJECT_VALID_JSON,
     REFERENCE_OBJECT_VALID_UPDATED,
+    REFERENCE_OBJECT_VALID_WITH_EXTRA_KEY,
+    REFERENCE_OBJECT_VALID_WITH_MISSING_KEY,
     ExampleClass,
+    ExampleDefaultableClass,
     ExampleDoubleNestedKeyAsClassInstancesClass,
     ExampleDoubleNestedSchema,
     ExampleNestedClass,
@@ -65,6 +68,15 @@ def test_update_nested_as_class_instance():
     assert isinstance(entity.nested_key1, ExampleClass)
 
 
+def test_create_with_default():
+    entity = ExampleDefaultableClass.create(REFERENCE_OBJECT_VALID_WITH_MISSING_KEY)
+    assert isinstance(entity, ExampleDefaultableClass)
+    # Default value for key1 -- "value1" is used
+    assert entity.key1 == "value1"
+    assert entity.key2 == 1
+    assert isinstance(entity, ExampleDefaultableClass)
+
+
 def test_validate():
     # Test valid case
     entity = ExampleClass.create(REFERENCE_OBJECT_VALID)
@@ -111,6 +123,28 @@ def test_clean():
         assert True  # Expecting an exception for invalid input
 
 
+def test_clean_extra_keys():
+    # Test clean method with valid input with extra keys
+    cleaned_data_with_extra = ExampleClass.clean(REFERENCE_OBJECT_VALID_WITH_EXTRA_KEY)
+    assert isinstance(cleaned_data_with_extra, dict)
+    assert cleaned_data_with_extra == REFERENCE_OBJECT_VALID
+    assert "key-to-clean" not in cleaned_data_with_extra
+
+
+def test_clean_default_substitution():
+    # Test case with default substitution (should add pass and add default values)
+    cleaned_data_with_default = ExampleDefaultableClass.clean(REFERENCE_OBJECT_VALID_WITH_MISSING_KEY)
+    assert isinstance(cleaned_data_with_default, dict)
+    assert cleaned_data_with_default == REFERENCE_OBJECT_VALID
+
+    # Test case with invalid input with missing keys (should raise an error)
+    try:
+        _ = ExampleDefaultableClass.clean(REFERENCE_OBJECT_INVALID)
+        assert False, "Invalid input did not raise an exception"
+    except Exception:
+        assert True
+
+
 def test_get_cls_name():
     # Test get_cls_name method
     entity = ExampleClass.create(REFERENCE_OBJECT_VALID)

tests/py/unit/test_vector.py

@@ -1,6 +1,10 @@
+import numpy as np
 from mat3ra.code.vector import RoundedVector3D, Vector3D
 
 VECTOR_FLOAT = [1.234567890, 2.345678901, 3.456789012]
+VECTOR_FLOAT_NORM = 4.3561172682906
+FLOAT_PRECISION = 1e-8
+
 VECTOR_FLOAT_DIFFERENT_WITHIN_TOL = [1.23456789999, 2.345678901, 3.456789012]
 VECTOR_FLOAT_DIFFERENT_OUTSIDE_TOL = [1.2345699999, 2.345678901, 3.456789012]
 VECTOR_FLOAT_ROUNDED_4 = [1.2346, 2.3457, 3.4568]
@@ -38,6 +42,28 @@ def test_vector_equality():
     assert vector != Vector3D(VECTOR_FLOAT_DIFFERENT_OUTSIDE_TOL)
 
 
+def test_vector_equality_with_list():
+    vector = Vector3D(VECTOR_FLOAT)
+    assert vector == VECTOR_FLOAT
+    assert vector == VECTOR_FLOAT_DIFFERENT_WITHIN_TOL
+    assert vector != VECTOR_FLOAT_DIFFERENT_OUTSIDE_TOL
+
+
+def test_vector_norm():
+    vector = Vector3D(VECTOR_FLOAT)
+    # Check if the norm is close to the expected value to avoid architecture-specific issues
+    np.isclose(vector.norm, VECTOR_FLOAT_NORM, atol=FLOAT_PRECISION, rtol=0)
+    assert vector.value == VECTOR_FLOAT
+    assert vector.x == 1.234567890
+    assert vector.y == 2.345678901
+    assert vector.z == 3.456789012
+
+
+#####################################################################
+##      RoundedVector3D tests
+#####################################################################
+
+
 def test_rounded_vector_init():
     vector = RoundedVector3D(VECTOR_FLOAT)
     assert vector.model_dump() == VECTOR_FLOAT
@@ -70,3 +96,19 @@ def test_rounded_vector_serialization():
     assert vector.x_rounded == VECTOR_FLOAT_ROUNDED_3[0]
     assert vector.y_rounded == VECTOR_FLOAT_ROUNDED_3[1]
     assert vector.z_rounded == VECTOR_FLOAT_ROUNDED_3[2]
+
+
+def test_rounded_vector_equality():
+    class_reference = RoundedVector3D
+    # Higher precision yields inequality
+    class_reference.__round_precision__ = 4
+    vector = class_reference(VECTOR_FLOAT)
+    assert vector == VECTOR_FLOAT
+    assert vector == VECTOR_FLOAT_ROUNDED_4
+    assert vector != VECTOR_FLOAT_ROUNDED_3
+    # Lower precision yields equality
+    class_reference.__round_precision__ = 3
+    vector = class_reference(VECTOR_FLOAT)
+    assert vector == VECTOR_FLOAT
+    assert vector == VECTOR_FLOAT_ROUNDED_4
+    assert vector == VECTOR_FLOAT_ROUNDED_3