Name-mangle dependency_id.

Author: damskii9992

src/easyscience/variable/descriptor_number.py

@@ -68,8 +68,8 @@ def __init__(
         self._observers: List[DescriptorNumber] = []
 
         # Extract dependency_id if provided during deserialization
-        if '_dependency_id' in kwargs:
-            self._dependency_id = kwargs.pop('_dependency_id')
+        if '__dependency_id' in kwargs:
+            self.__dependency_id = kwargs.pop('__dependency_id')
 
         if not isinstance(value, numbers.Number) or isinstance(value, bool):
             raise TypeError(f'{value=} must be a number')
@@ -118,14 +118,14 @@ def from_scipp(cls, name: str, full_value: Variable, **kwargs) -> DescriptorNumb
     def _attach_observer(self, observer: DescriptorNumber) -> None:
         """Attach an observer to the descriptor."""
         self._observers.append(observer)
-        if not hasattr(self, '_dependency_id'):
-            self._dependency_id = str(uuid.uuid4())
+        if not hasattr(self, '_DescriptorNumber__dependency_id'):
+            self.__dependency_id = str(uuid.uuid4())
 
     def _detach_observer(self, observer: DescriptorNumber) -> None:
         """Detach an observer from the descriptor."""
         self._observers.remove(observer)
         if not self._observers:
-            del self._dependency_id
+            del self.__dependency_id
 
     def _notify_observers(self) -> None:
         """Notify all observers of a change."""
@@ -333,8 +333,8 @@ def as_dict(self, skip: Optional[List[str]] = None) -> Dict[str, Any]:
         raw_dict['value'] = self._scalar.value
         raw_dict['unit'] = str(self._scalar.unit)
         raw_dict['variance'] = self._scalar.variance
-        if hasattr(self, '_dependency_id'):
-            raw_dict['_dependency_id'] = self._dependency_id
+        if hasattr(self, '_DescriptorNumber__dependency_id'):
+            raw_dict['__dependency_id'] = self.__dependency_id
         return raw_dict
 
     def __add__(self, other: Union[DescriptorNumber, numbers.Number]) -> DescriptorNumber:

src/easyscience/variable/parameter.py

@@ -544,7 +544,7 @@ def as_dict(self, skip: Optional[List[str]] = None) -> Dict[str, Any]:
             # Convert dependency_map to use dependency_ids
             raw_dict['_dependency_map_dependency_ids'] = {}
             for key, obj in self._dependency_map.items():
-                raw_dict['_dependency_map_dependency_ids'][key] = obj._dependency_id
+                raw_dict['_dependency_map_dependency_ids'][key] = obj._DescriptorNumber__dependency_id
 
         return raw_dict
 
@@ -983,7 +983,7 @@ def resolve_pending_dependencies(self) -> None:
     def _find_parameter_by_dependency_id(self, dependency_id: str) -> Optional['DescriptorNumber']:
         """Find a parameter by its dependency_id from all parameters in the global map."""
         for obj in self._global_object.map._store.values():
-            if isinstance(obj, DescriptorNumber) and hasattr(obj, '_dependency_id') and obj._dependency_id == dependency_id:
+            if isinstance(obj, DescriptorNumber) and hasattr(obj, '_DescriptorNumber__dependency_id') and obj._DescriptorNumber__dependency_id == dependency_id:
                 return obj
         return None
 

src/easyscience/variable/parameter_dependency_resolver.py

@@ -67,7 +67,7 @@ def _collect_parameters(item: Any, parameters: List[Parameter]) -> None:
                 resolved_count += 1
             except Exception as e:
                 error_count += 1
-                dependency_id = getattr(param, '_dependency_id', 'unknown')
+                dependency_id = getattr(param, '_DescriptorNumber__dependency_id', 'unknown')
                 errors.append(f"Failed to resolve dependencies for parameter '{param.name}'" \
                                f" (unique_name: '{param.unique_name}', dependency_id: '{dependency_id}'): {e}")
 

tests/unit_tests/variable/test_parameter_dependency_serialization.py

@@ -71,7 +71,7 @@ def test_dependent_parameter_serialization(self, clear_global_map):
 
         # Should contain dependency information
         assert serialized['_dependency_string'] == "2 * a"
-        assert serialized['_dependency_map_dependency_ids'] == {"a": a._dependency_id}
+        assert serialized['_dependency_map_dependency_ids'] == {"a": a._DescriptorNumber__dependency_id}
         assert serialized['_independent'] is False
 
         # Deserialize
@@ -81,7 +81,7 @@ def test_dependent_parameter_serialization(self, clear_global_map):
         # Should have pending dependency info
         assert hasattr(new_b, '_pending_dependency_string')
         assert new_b._pending_dependency_string == "2 * a"
-        assert new_b._pending_dependency_map_dependency_ids == {"a": a._dependency_id}
+        assert new_b._pending_dependency_map_dependency_ids == {"a": a._DescriptorNumber__dependency_id}
         assert new_b.independent is True  # Initially independent until dependencies resolved
 
     def test_dependency_resolution_after_deserialization(self, clear_global_map):
@@ -150,7 +150,7 @@ def test_unique_name_dependency_serialization(self, clear_global_map):
         # Should contain unique name mapping
         assert b_serialized['_dependency_string'] == '2 * "Parameter_0"'
         assert "__Parameter_0__" in b_serialized['_dependency_map_dependency_ids']
-        assert b_serialized['_dependency_map_dependency_ids']["__Parameter_0__"] == a._dependency_id
+        assert b_serialized['_dependency_map_dependency_ids']["__Parameter_0__"] == a._DescriptorNumber__dependency_id
 
         # Deserialize both and resolve
         global_object.map._clear()
@@ -350,8 +350,8 @@ def test_dependency_id_system_order_independence(self, clear_global_map, order):
         assert z.value == 50.0  # 5 * 10
 
         # Get dependency IDs
-        x_dep_id = x._dependency_id
-        y_dep_id = y._dependency_id
+        x_dep_id = x._DescriptorNumber__dependency_id
+        y_dep_id = y._DescriptorNumber__dependency_id
 
         # Serialize all parameters
         params_data = {
@@ -361,9 +361,9 @@ def test_dependency_id_system_order_independence(self, clear_global_map, order):
         }
 
         # Verify dependency IDs are in serialized data
-        assert params_data["x"]["_dependency_id"] == x_dep_id
-        assert params_data["y"]["_dependency_id"] == y_dep_id
-        assert "_dependency_id" not in params_data["z"]
+        assert params_data["x"]["__dependency_id"] == x_dep_id
+        assert params_data["y"]["__dependency_id"] == y_dep_id
+        assert "__dependency_id" not in params_data["z"]
         assert "_dependency_map_dependency_ids" in params_data["z"]
 
         # THEN
@@ -376,8 +376,8 @@ def test_dependency_id_system_order_independence(self, clear_global_map, order):
 
         # EXPECT
         # Verify dependency IDs are preserved
-        assert new_params["x"]._dependency_id == x_dep_id
-        assert new_params["y"]._dependency_id == y_dep_id
+        assert new_params["x"]._DescriptorNumber__dependency_id == x_dep_id
+        assert new_params["y"]._DescriptorNumber__dependency_id == y_dep_id
 
         # Resolve dependencies
         resolve_all_parameter_dependencies(new_params)