easyscience 2.1.0__tar.gz → 2.2.0__tar.gz

{easyscience-2.1.0 → easyscience-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: easyscience
-Version: 2.1.0
+Version: 2.2.0
 Summary: Generic logic for easyScience libraries
 Project-URL: homepage, https://github.com/EasyScience/EasyScience
 Project-URL: documentation, https://easyscience.github.io/EasyScience/
@@ -78,6 +78,7 @@ Description-Content-Type: text/markdown
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
 [![PyPI badge](http://img.shields.io/pypi/v/EasyScience.svg)](https://pypi.python.org/pypi/EasyScience)
 [![License: BSD 3-Clause](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](LICENSE)
+[![codecov](https://codecov.io/github/EasyScience/corelib/graph/badge.svg?token=wc6Q0j0Q9t)](https://codecov.io/github/EasyScience/corelib)
 
 # Easyscience
 
@@ -110,7 +111,7 @@ After installation, launch the test suite:
 
 Documentation can be found at:
 
-[https://easyScience.github.io/EasyScience](https://easyScience.github.io/EasyScience)
+[https://easyScience.github.io/corelib](https://easyScience.github.io/corelib)
 
 ## Contributing
 We absolutely welcome contributions. **EasyScience** is maintained by the ESS and on a volunteer basis and thus we need to foster a community that can support user questions and develop new features to make this software a useful tool for all users while encouraging every member of the community to share their ideas.

{easyscience-2.1.0 → easyscience-2.2.0}/README.md

@@ -1,6 +1,7 @@
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
 [![PyPI badge](http://img.shields.io/pypi/v/EasyScience.svg)](https://pypi.python.org/pypi/EasyScience)
 [![License: BSD 3-Clause](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](LICENSE)
+[![codecov](https://codecov.io/github/EasyScience/corelib/graph/badge.svg?token=wc6Q0j0Q9t)](https://codecov.io/github/EasyScience/corelib)
 
 # Easyscience
 
@@ -33,7 +34,7 @@ After installation, launch the test suite:
 
 Documentation can be found at:
 
-[https://easyScience.github.io/EasyScience](https://easyScience.github.io/EasyScience)
+[https://easyScience.github.io/corelib](https://easyScience.github.io/corelib)
 
 ## Contributing
 We absolutely welcome contributions. **EasyScience** is maintained by the ESS and on a volunteer basis and thus we need to foster a community that can support user questions and develop new features to make this software a useful tool for all users while encouraging every member of the community to share their ideas.

easyscience-2.2.0/src/easyscience/__version__.py

@@ -0,0 +1 @@
+__version__ = '2.2.0'

{easyscience-2.1.0 → easyscience-2.2.0}/src/easyscience/base_classes/__init__.py

@@ -1,13 +1,8 @@
 from .based_base import BasedBase
 from .collection_base import CollectionBase
+from .easy_list import EasyList
 from .model_base import ModelBase
 from .new_base import NewBase
 from .obj_base import ObjBase
 
-__all__ = [
-    BasedBase,
-    CollectionBase,
-    ObjBase,
-    ModelBase,
-    NewBase,
-]
+__all__ = [BasedBase, CollectionBase, ObjBase, ModelBase, NewBase, EasyList]

{easyscience-2.1.0 → easyscience-2.2.0}/src/easyscience/base_classes/collection_base.py

@@ -14,6 +14,7 @@ from typing import Optional
 from typing import Tuple
 from typing import Union
 
+from easyscience.base_classes.new_base import NewBase
 from easyscience.global_object.undo_redo import NotarizedDict
 
 from ..variable.descriptor_base import DescriptorBase
@@ -34,7 +35,7 @@ class CollectionBase(BasedBase, MutableSequence):
     def __init__(
         self,
         name: str,
-        *args: Union[BasedBase, DescriptorBase],
+        *args: Union[BasedBase, DescriptorBase, NewBase],
         interface: Optional[InterfaceFactoryTemplate] = None,
         unique_name: Optional[str] = None,
         **kwargs,
@@ -64,7 +65,7 @@ class CollectionBase(BasedBase, MutableSequence):
                 _kwargs[key] = item
         kwargs = _kwargs
         for item in list(kwargs.values()) + _args:
-            if not issubclass(type(item), (DescriptorBase, BasedBase)):
+            if not issubclass(type(item), (DescriptorBase, BasedBase, NewBase)):
                 raise AttributeError('A collection can only be formed from easyscience objects.')
         args = _args
         _kwargs = {}
@@ -90,19 +91,19 @@ class CollectionBase(BasedBase, MutableSequence):
             self.interface = interface
         self._kwargs._stack_enabled = True
 
-    def insert(self, index: int, value: Union[DescriptorBase, BasedBase]) -> None:
+    def insert(self, index: int, value: Union[DescriptorBase, BasedBase, NewBase]) -> None:
         """
         Insert an object into the collection at an index.
 
         :param index: Index for EasyScience object to be inserted.
         :type index: int
         :param value: Object to be inserted.
-        :type value: Union[BasedBase, DescriptorBase]
+        :type value: Union[BasedBase, DescriptorBase, NewBase]
         :return: None
         :rtype: None
         """
         t_ = type(value)
-        if issubclass(t_, (BasedBase, DescriptorBase)):
+        if issubclass(t_, (BasedBase, DescriptorBase, NewBase)):
             update_key = list(self._kwargs.keys())
             values = list(self._kwargs.values())
             # Update the internal dict
@@ -117,7 +118,7 @@ class CollectionBase(BasedBase, MutableSequence):
         else:
             raise AttributeError('Only EasyScience objects can be put into an EasyScience group')
 
-    def __getitem__(self, idx: Union[int, slice]) -> Union[DescriptorBase, BasedBase]:
+    def __getitem__(self, idx: Union[int, slice]) -> Union[DescriptorBase, BasedBase, NewBase]:
         """
         Get an item in the collection based on its index.
 
@@ -151,7 +152,7 @@ class CollectionBase(BasedBase, MutableSequence):
         keys = list(self._kwargs.keys())
         return self._kwargs[keys[idx]]
 
-    def __setitem__(self, key: int, value: Union[BasedBase, DescriptorBase]) -> None:
+    def __setitem__(self, key: int, value: Union[BasedBase, DescriptorBase, NewBase]) -> None:
         """
         Set an item via it's index.
 
@@ -163,7 +164,7 @@ class CollectionBase(BasedBase, MutableSequence):
         if isinstance(value, Number):  # noqa: S3827
             item = self.__getitem__(key)
             item.value = value
-        elif issubclass(type(value), (BasedBase, DescriptorBase)):
+        elif issubclass(type(value), (BasedBase, DescriptorBase, NewBase)):
             update_key = list(self._kwargs.keys())
             values = list(self._kwargs.values())
             old_item = values[key]
@@ -233,7 +234,11 @@ class CollectionBase(BasedBase, MutableSequence):
     def __repr__(self) -> str:
         return f'{self.__class__.__name__} `{getattr(self, "name")}` of length {len(self)}'
 
-    def sort(self, mapping: Callable[[Union[BasedBase, DescriptorBase]], Any], reverse: bool = False) -> None:
+    def sort(
+        self,
+        mapping: Callable[[Union[BasedBase, DescriptorBase, NewBase]], Any],
+        reverse: bool = False,
+    ) -> None:
         """
         Sort the collection according to the given mapping.
 

easyscience-2.2.0/src/easyscience/base_classes/easy_list.py

@@ -0,0 +1,281 @@
+#  SPDX-FileCopyrightText: 2025 EasyScience contributors  <core@easyscience.software>
+#  SPDX-License-Identifier: BSD-3-Clause
+#  © 2021-2025 Contributors to the EasyScience project <https://github.com/easyScience/EasyScience
+
+from __future__ import annotations
+
+import copy
+import warnings
+from collections.abc import MutableSequence
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import Iterable
+from typing import List
+from typing import Optional
+from typing import Type
+from typing import TypeVar
+from typing import overload
+
+from easyscience.io.serializer_base import SerializerBase
+
+from .new_base import NewBase
+
+ProtectedType_ = TypeVar('ProtectedType', bound=NewBase)
+
+
+class EasyList(NewBase, MutableSequence[ProtectedType_]):
+    # If we were to inherit from List instead of MutableSequence,
+    # we would have to overwrite "extend", "remove", "__iadd__", "count", "append", "__iter__" and "clear"
+    def __init__(
+        self,
+        *args: ProtectedType_ | list[ProtectedType_],
+        protected_types: list[Type[NewBase]] | Type[NewBase] | None = None,
+        unique_name: Optional[str] = None,
+        display_name: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        """
+        Initialize the EasyList.
+        :param args: Initial items to add to the list
+        :param protected_types: Types that are allowed in the list. Can be a single NewBase subclass or a list of them.
+                                If None, defaults to [NewBase].
+        :param unique_name: Optional unique name for the list
+        :param display_name: Optional display name for the list
+        """
+        super().__init__(unique_name=unique_name, display_name=display_name)
+        if protected_types is None:
+            self._protected_types = [NewBase]
+        elif isinstance(protected_types, type) and issubclass(protected_types, NewBase):
+            self._protected_types = [protected_types]
+        elif isinstance(protected_types, Iterable) and all(issubclass(t, NewBase) for t in protected_types):
+            self._protected_types = list(protected_types)
+        else:
+            raise TypeError('protected_types must be a NewBase subclass or an iterable of NewBase subclasses')
+        self._data: List[ProtectedType_] = []
+
+        # Add initial items
+        for item in args:
+            if isinstance(item, list):
+                for sub_item in item:
+                    self.append(sub_item)
+            else:
+                self.append(item)
+
+        # For deserialization, the dict can't contain an *args, so we check for 'data' in kwargs
+        if 'data' in kwargs:
+            data = kwargs.pop('data')
+            for item in data:
+                self.append(item)
+
+    # MutableSequence abstract methods
+
+    # Use @overload to provide precise type hints for different __getitem__ argument types
+    @overload
+    def __getitem__(self, idx: int) -> ProtectedType_: ...
+    @overload
+    def __getitem__(self, idx: slice) -> 'EasyList[ProtectedType_]': ...
+    @overload
+    def __getitem__(self, idx: str) -> ProtectedType_: ...
+    def __getitem__(self, idx: int | slice | str) -> ProtectedType_ | 'EasyList[ProtectedType_]':
+        """
+        Get an item by index, slice, or unique_name.
+
+        :param idx: Index, slice, or unique_name of the item
+        :return: The item or a new EasyList for slices
+        """
+        if isinstance(idx, int):
+            return self._data[idx]
+        elif isinstance(idx, slice):
+            return self.__class__(self._data[idx], protected_types=self._protected_types)
+        elif isinstance(idx, str):
+            element = next((r for r in self._data if self._get_key(r) == idx), None)
+            if element is not None:
+                return element
+            raise KeyError(f'No item with unique name "{idx}" found')
+        else:
+            raise TypeError('Index must be an int, slice, or str')
+
+    @overload
+    def __setitem__(self, idx: int, value: ProtectedType_) -> None: ...
+    @overload
+    def __setitem__(self, idx: slice, value: Iterable[ProtectedType_]) -> None: ...
+
+    def __setitem__(self, idx: int | slice, value: ProtectedType_ | Iterable[ProtectedType_]) -> None:
+        """
+        Set an item at an index.
+
+        :param idx: Index to set
+        :param value: New value
+        """
+        if isinstance(idx, int):
+            if not isinstance(value, tuple(self._protected_types)):
+                raise TypeError(f'Items must be one of {self._protected_types}, got {type(value)}')
+            if value is not self._data[idx] and value in self:
+                warnings.warn(f'Item with unique name "{self._get_key(value)}" already in EasyList, it will be ignored')
+                return
+            self._data[idx] = value
+        elif isinstance(idx, slice):
+            if not isinstance(value, Iterable):
+                raise TypeError('Value must be an iterable for slice assignment')
+            replaced = self._data[idx]
+            new_values = list(value)
+            if len(new_values) != len(replaced):
+                raise ValueError('Length of new values must match the length of the slice being replaced')
+            for i, v in enumerate(new_values):
+                if not isinstance(v, tuple(self._protected_types)):
+                    raise TypeError(f'Items must be one of {self._protected_types}, got {type(v)}')
+                if v in self and replaced[i] is not v:
+                    warnings.warn(f'Item with unique name "{v.unique_name}" already in EasyList, it will be ignored')
+                    new_values[i] = replaced[i]  # Keep the original value if the new one is a duplicate
+            self._data[idx] = new_values
+        else:
+            raise TypeError('Index must be an int or slice')
+
+    def __delitem__(self, idx: int | slice | str) -> None:
+        """
+        Delete an item by index, slice, or name.
+
+        :param idx: Index, slice, or name of item to delete
+        """
+        if isinstance(idx, (int, slice)):
+            del self._data[idx]
+        elif isinstance(idx, str):
+            for i, item in enumerate(self._data):
+                if self._get_key(item) == idx:
+                    del self._data[i]
+                    return
+            raise KeyError(f'No item with unique name "{idx}" found')
+        else:
+            raise TypeError('Index must be an int, slice, or str')
+
+    def __len__(self) -> int:
+        """Return the number of items in the collection."""
+        return len(self._data)
+
+    def insert(self, index: int, value: ProtectedType_) -> None:
+        """
+        Insert an item at an index.
+
+        :param index: Index to insert at
+        :param value: Item to insert
+        """
+        if not isinstance(index, int):
+            raise TypeError('Index must be an integer')
+        elif not isinstance(value, tuple(self._protected_types)):
+            raise TypeError(f'Items must be one of {self._protected_types}, got {type(value)}')
+        if value in self:
+            warnings.warn(f'Item with unique name "{self._get_key(value)}" already in EasyList, it will be ignored')
+            return
+        self._data.insert(index, value)
+
+    def _get_key(self, obj) -> str:
+        """
+        Get the unique name of an object.
+        Can be overridden to use a different attribute as the key.
+        :param object: Object to get the key for
+        :return: The key of the object
+        :rtype: str
+        """
+        return obj.unique_name
+
+    # Overwriting methods
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__} of length {len(self)} of type(s) {self._protected_types}'
+
+    def __contains__(self, item: ProtectedType_ | str) -> bool:
+        if isinstance(item, str):
+            return any(self._get_key(r) == item for r in self._data)
+        return item in self._data
+
+    def __reversed__(self):
+        return self._data.__reversed__()
+
+    def sort(self, key: Callable[[ProtectedType_], Any] = None, reverse: bool = False) -> None:
+        """
+        Sort the collection according to the given key function.
+
+        :param key: Mapping function to sort by
+        :param reverse: Whether to reverse the sort
+        """
+        self._data.sort(reverse=reverse, key=key)
+
+    def index(self, value: ProtectedType_ | str, start: int = 0, stop: int = None) -> int:
+        if stop is None:
+            stop = len(self._data)
+        if isinstance(value, str):
+            for i in range(start, min(stop, len(self._data))):
+                if self._get_key(self._data[i]) == value:
+                    return i
+            raise ValueError(f'{value} is not in EasyList')
+        return self._data.index(value, start, stop)
+
+    def pop(self, index: int | str = -1) -> ProtectedType_:
+        """
+        Remove and return an item at the given index or unique_name.
+
+        :param index: Index or unique_name of the item to remove
+        :return: The removed item
+        """
+        if isinstance(index, int):
+            return self._data.pop(index)
+        elif isinstance(index, str):
+            for i, item in enumerate(self._data):
+                if self._get_key(item) == index:
+                    return self._data.pop(i)
+            raise KeyError(f'No item with unique name "{index}" found')
+        else:
+            raise TypeError('Index must be an int or str')
+
+    # Serialization support
+
+    def to_dict(self) -> dict:
+        """
+        Convert the EasyList to a dictionary for serialization.
+
+        :return: Dictionary representation of the EasyList
+        """
+        dict_repr = super().to_dict()
+        if self._protected_types != [NewBase]:
+            dict_repr['protected_types'] = [
+                {'@module': cls_.__module__, '@class': cls_.__name__} for cls_ in self._protected_types
+            ]  # noqa: E501
+        dict_repr['data'] = [item.to_dict() for item in self._data]
+        return dict_repr
+
+    @classmethod
+    def from_dict(cls, obj_dict: Dict[str, Any]) -> NewBase:
+        """
+        Re-create an EasyScience object from a full encoded dictionary.
+
+        :param obj_dict: dictionary containing the serialized contents (from `SerializerDict`) of an EasyScience object
+        :return: Reformed EasyScience object
+        """
+        if not SerializerBase._is_serialized_easyscience_object(obj_dict):
+            raise ValueError('Input must be a dictionary representing an EasyScience EasyList object.')
+        temp_dict = copy.deepcopy(obj_dict)  # Make a copy to avoid mutating the input
+        if temp_dict['@class'] == cls.__name__:
+            if 'protected_types' in temp_dict:
+                protected_types = temp_dict.pop('protected_types')
+                for i, type_dict in enumerate(protected_types):
+                    if '@module' in type_dict and '@class' in type_dict:
+                        modname = type_dict['@module']
+                        classname = type_dict['@class']
+                        mod = __import__(modname, globals(), locals(), [classname], 0)
+                        if hasattr(mod, classname):
+                            cls_ = getattr(mod, classname)
+                            protected_types[i] = cls_
+                        else:
+                            raise ImportError(f'Could not import class {classname} from module {modname}')
+                    else:
+                        raise ValueError(
+                            'Each protected type must be a serialized EasyScience class with @module and @class keys'
+                        )  # noqa: E501
+            else:
+                protected_types = None
+            kwargs = SerializerBase.deserialize_dict(temp_dict)
+            data = kwargs.pop('data', [])
+            return cls(data, protected_types=protected_types, **kwargs)
+        else:
+            raise ValueError(f'Class name in dictionary does not match the expected class: {cls.__name__}.')

{easyscience-2.1.0 → easyscience-2.2.0}/src/easyscience/fitting/minimizers/minimizer_bumps.py

@@ -98,6 +98,11 @@ class Bumps(MinimizerBase):
         :type method: str
         :return: Fit results
         :rtype: ModelResult
+
+        For standard least squares, the weights should be 1/sigma, where
+        sigma is the standard deviation of the measurement. For
+        unweighted least squares, these should be 1.
+
         """
         method_dict = self._get_method_kwargs(method)
 
@@ -191,6 +196,8 @@ class Bumps(MinimizerBase):
         Generate a bumps model from the supplied `fit_function` and parameters in the base object.
         Note that this makes a callable as it needs to be initialized with *x*, *y*, *weights*
 
+        Weights are converted to dy (standard deviation of y).
+
         :return: Callable to make a bumps Curve model
         :rtype: Callable
         """
@@ -205,7 +212,7 @@ class Bumps(MinimizerBase):
                 else:
                     for par in parameters:
                         bumps_pars[MINIMIZER_PARAMETER_PREFIX + par.unique_name] = obj.convert_to_par_object(par)
-                return Curve(fit_func, x, y, dy=weights, **bumps_pars)
+                return Curve(fit_func, x, y, dy=1 / weights, **bumps_pars)
 
             return _make_func
 

{easyscience-2.1.0 → easyscience-2.2.0}/src/easyscience/fitting/minimizers/minimizer_dfo.py

@@ -74,7 +74,7 @@ class DFO(MinimizerBase):
         :type x: np.ndarray
         :param y: measured points
         :type y: np.ndarray
-        :param weights: Weights for supplied measured points
+        :param weights: Weights for supplied measured points.
         :type weights: np.ndarray
         :param model: Optional Model which is being fitted to
         :type model: lmModel
@@ -85,6 +85,10 @@ class DFO(MinimizerBase):
         :type method: str
         :return: Fit results
         :rtype: ModelResult
+
+        For standard least squares, the weights should be 1/sigma, where
+        sigma is the standard deviation of the measurement. For
+        unweighted least squares, these should be 1.
         """
         x, y, weights = np.asarray(x), np.asarray(y), np.asarray(weights)
 
@@ -163,7 +167,7 @@ class DFO(MinimizerBase):
                 def _residuals(pars_values: List[float]) -> np.ndarray:
                     for idx, par_name in enumerate(dfo_pars.keys()):
                         dfo_pars[par_name] = pars_values[idx]
-                    return (y - fit_func(x, **dfo_pars)) / weights
+                    return (y - fit_func(x, **dfo_pars)) * weights
 
                 return _residuals
 
@@ -267,7 +271,11 @@ class DFO(MinimizerBase):
         return results
 
     @staticmethod
-    def _prepare_kwargs(tolerance: Optional[float] = None, max_evaluations: Optional[int] = None, **kwargs) -> dict[str:str]:
+    def _prepare_kwargs(
+        tolerance: Optional[float] = None,
+        max_evaluations: Optional[int] = None,
+        **kwargs,
+    ) -> dict[str:str]:
         if max_evaluations is not None:
             kwargs['maxfun'] = max_evaluations  # max number of function evaluations
         if tolerance is not None:

{easyscience-2.1.0 → easyscience-2.2.0}/src/easyscience/fitting/minimizers/minimizer_lmfit.py

@@ -111,6 +111,11 @@ class LMFit(MinimizerBase):  # noqa: S101
         :param kwargs: Additional arguments for the fitting function.
         :return: Fit results
         :rtype: ModelResult
+
+        For standard least squares, the weights should be 1/sigma, where
+        sigma is the standard deviation of the measurement. For
+        unweighted least squares, these should be 1.
+
         """
         x, y, weights = np.asarray(x), np.asarray(y), np.asarray(weights)
 
@@ -230,7 +235,12 @@ class LMFit(MinimizerBase):  # noqa: S101
             else:
                 value = item.value
 
-            model.set_param_hint(MINIMIZER_PARAMETER_PREFIX + str(name), value=value, min=item.min, max=item.max)
+            model.set_param_hint(
+                MINIMIZER_PARAMETER_PREFIX + str(name),
+                value=value,
+                min=item.min,
+                max=item.max,
+            )
 
         # Cache the model for later reference
         self._cached_model = model

{easyscience-2.1.0 → easyscience-2.2.0}/src/easyscience/global_object/map.py

@@ -74,9 +74,32 @@ class Map:
         # A dict with object names as keys and a list of their object types as values, with weak references
         self.__type_dict = {}
 
+    def _snapshot_items(self):
+        """Return a stable snapshot of __type_dict items.
+
+        Some callers iterate over __type_dict while other threads or
+        weakref finalizers may modify it. Creating a list snapshot (with
+        a retry loop) prevents RuntimeError: dictionary changed size during iteration.
+        """
+        while True:
+            try:
+                return list(self.__type_dict.items())
+            except RuntimeError:
+                # Dict changed during snapshot creation, retry
+                continue
+
     def vertices(self) -> List[str]:
-        """returns the vertices of a map"""
-        return list(self._store.keys())
+        """Returns the vertices of a map.
+
+        Uses a retry loop to handle RuntimeError that can occur when the
+        WeakValueDictionary is modified during iteration (e.g., by garbage collection).
+        """
+        while True:
+            try:
+                return list(self._store)
+            except RuntimeError:
+                # Dictionary changed size during iteration, retry
+                continue
 
     def edges(self):
         """returns the edges of a map"""
@@ -100,46 +123,64 @@ class Map:
 
     def _nested_get(self, obj_type: str) -> List[str]:
         """Access a nested object in root by key sequence."""
-        return [key for key, item in self.__type_dict.items() if obj_type in item.type]
+        # Create a stable snapshot of the dict items to avoid RuntimeError
+        # when the dict is modified during iteration (e.g., by finalizers).
+        while True:
+            try:
+                items = self._snapshot_items()
+                return [key for key, item in items if obj_type in item.type]
+            except RuntimeError:
+                # In case the snapshot itself raises (very rare), retry
+                continue
 
     def get_item_by_key(self, item_id: str) -> object:
-        if item_id in self._store.keys():
+        if item_id in self._store:
             return self._store[item_id]
         raise ValueError('Item not in map.')
 
     def is_known(self, vertex: object) -> bool:
-        # All objects should have a 'unique_name' attribute
-        return vertex.unique_name in self._store.keys()
+        """Check if a vertex is known in the map.
+
+        All objects should have a 'unique_name' attribute.
+        """
+        return vertex.unique_name in self._store
 
     def find_type(self, vertex: object) -> List[str]:
         if self.is_known(vertex):
             return self.__type_dict[vertex.unique_name].type
 
     def reset_type(self, obj, default_type: str):
-        if obj.unique_name in self.__type_dict.keys():
+        if obj.unique_name in self.__type_dict:
             self.__type_dict[obj.unique_name].reset_type(default_type)
 
     def change_type(self, obj, new_type: str):
-        if obj.unique_name in self.__type_dict.keys():
+        if obj.unique_name in self.__type_dict:
             self.__type_dict[obj.unique_name].type = new_type
 
     def add_vertex(self, obj: object, obj_type: str = None):
         name = obj.unique_name
-        if name in self._store.keys():
+        if name in self._store:
             raise ValueError(f'Object name {name} already exists in the graph.')
+        # Clean up stale entry in __type_dict if the weak reference was collected
+        # but the finalizer hasn't run yet
+        if name in self.__type_dict:
+            del self.__type_dict[name]
+
         self._store[name] = obj
-        self.__type_dict[name] = _EntryList()  # Add objects type to the list of types
-        self.__type_dict[name].finalizer = weakref.finalize(self._store[name], self.prune, name)
-        self.__type_dict[name].type = obj_type
+
+        entry_list = _EntryList()
+        entry_list.finalizer = weakref.finalize(obj, self.prune_type_dict, name)
+        entry_list.type = obj_type
+        self.__type_dict[name] = entry_list  # Add objects type to the list of types
 
     def add_edge(self, start_obj: object, end_obj: object):
-        if start_obj.unique_name in self.__type_dict.keys():
+        if start_obj.unique_name in self.__type_dict:
             self.__type_dict[start_obj.unique_name].append(end_obj.unique_name)
         else:
             raise AttributeError('Start object not in map.')
 
     def get_edges(self, start_obj) -> List[str]:
-        if start_obj.unique_name in self.__type_dict.keys():
+        if start_obj.unique_name in self.__type_dict:
             return list(self.__type_dict[start_obj.unique_name])
         else:
             raise AttributeError
@@ -151,8 +192,11 @@ class Map:
         vertices
         """
         edges = []
-        for vertex in self.__type_dict:
-            for neighbour in self.__type_dict[vertex]:
+        # Iterate over a snapshot of items and snapshot neighbour lists to
+        # avoid concurrent modification issues.
+        for vertex, neighbours in self._snapshot_items():
+            neighbours_snapshot = list(neighbours)
+            for neighbour in neighbours_snapshot:
                 if {neighbour, vertex} not in edges:
                     edges.append({vertex, neighbour})
         return edges
@@ -163,22 +207,25 @@ class Map:
             return
         vertex2 = child_obj.unique_name
 
-        if vertex1 in self.__type_dict.keys() and vertex2 in self.__type_dict[vertex1]:
+        if vertex1 in self.__type_dict and vertex2 in self.__type_dict[vertex1]:
             del self.__type_dict[vertex1][self.__type_dict[vertex1].index(vertex2)]
 
+    def prune_type_dict(self, key: str):
+        if key in self.__type_dict:
+            del self.__type_dict[key]
+
     def prune(self, key: str):
-        if key in self.__type_dict.keys():
+        if key in self.__type_dict:
             del self.__type_dict[key]
-            del self._store[key]
+            if key in self._store:
+                del self._store[key]
 
     def find_isolated_vertices(self) -> list:
         """returns a list of isolated vertices."""
-        graph = self.__type_dict
         isolated = []
-        for vertex in graph:
-            print(isolated, vertex)
-            if not graph[vertex]:
-                isolated += [vertex]
+        for vertex, neighbours in self._snapshot_items():
+            if not list(neighbours):
+                isolated.append(vertex)
         return isolated
 
     def find_path(self, start_vertex: str, end_vertex: str, path=[]) -> list:
@@ -230,9 +277,10 @@ class Map:
         path_length = sys.maxsize
         optimum_path = []
         if start_vertex is None:
-            # We now have to find where to begin.....
-            for possible_start, vertices in self.__type_dict.items():
-                if end_vertex in vertices:
+            # We now have to find where to begin..... Iterate over a snapshot
+            for possible_start, vertices in self._snapshot_items():
+                vertices_snapshot = list(vertices)
+                if end_vertex in vertices_snapshot:
                     temp_path = self.find_path(possible_start, end_vertex)
                     if len(temp_path) < path_length:
                         path_length = len(temp_path)
@@ -247,13 +295,13 @@ class Map:
         if vertices_encountered is None:
             vertices_encountered = set()
         graph = self.__type_dict
-        vertices = list(graph.keys())
+        vertices = list(graph)
         if not start_vertex:
             # chose a vertex from graph as a starting point
             start_vertex = vertices[0]
         vertices_encountered.add(start_vertex)
         if len(vertices_encountered) != len(vertices):
-            for vertex in graph[start_vertex]:
+            for vertex in list(graph[start_vertex]):
                 if vertex not in vertices_encountered and self.is_connected(vertices_encountered, vertex):
                     return True
         else:
@@ -262,10 +310,9 @@ class Map:
 
     def _clear(self):
         """Reset the map to an empty state. Only to be used for testing"""
-        for vertex in self.vertices():
-            self.prune(vertex)
+        self._store.clear()
+        self.__type_dict.clear()
         gc.collect()
-        self.__type_dict = {}
 
     def __repr__(self) -> str:
         return f'Map object of {len(self._store)} vertices.'

{easyscience-2.1.0 → easyscience-2.2.0}/src/easyscience/variable/descriptor_number.py

@@ -423,16 +423,13 @@ class DescriptorNumber(DescriptorBase):
 
     def __truediv__(self, other: Union[DescriptorNumber, numbers.Number]) -> DescriptorNumber:
         if isinstance(other, numbers.Number):
-            original_other = other
             if other == 0:
                 raise ZeroDivisionError('Cannot divide by zero')
             new_value = self.full_value / other
         elif type(other) is DescriptorNumber:
-            original_other = other.value
-            if original_other == 0:
+            if other.value == 0:
                 raise ZeroDivisionError('Cannot divide by zero')
             new_value = self.full_value / other.full_value
-            other.value = original_other
         else:
             return NotImplemented
         descriptor_number = DescriptorNumber.from_scipp(name=self.name, full_value=new_value)

{easyscience-2.1.0 → easyscience-2.2.0}/src/easyscience/variable/parameter.py

@@ -121,7 +121,12 @@ class Parameter(DescriptorNumber):
 
     @classmethod
     def from_dependency(
-        cls, name: str, dependency_expression: str, dependency_map: Optional[dict] = None, **kwargs
+        cls,
+        name: str,
+        dependency_expression: str,
+        dependency_map: Optional[dict] = None,
+        desired_unit: str | sc.Unit | None = None,
+        **kwargs,
     ) -> Parameter:  # noqa: E501
         """
         Create a dependent Parameter directly from a dependency expression.
@@ -129,15 +134,20 @@ class Parameter(DescriptorNumber):
         :param name: The name of the parameter
         :param dependency_expression: The dependency expression to evaluate. This should be a string which can be evaluated by the ASTEval interpreter.
         :param dependency_map: A dictionary of dependency expression symbol name and dependency object pairs. This is inserted into the asteval interpreter to resolve dependencies.
+        :param desired_unit: The desired unit of the dependent parameter.
         :param kwargs: Additional keyword arguments to pass to the Parameter constructor.
         :return: A new dependent Parameter object.
         """  # noqa: E501
         # Set default values for required parameters for the constructor, they get overwritten by the dependency anyways
-        default_kwargs = {'value': 0.0, 'unit': '', 'variance': 0.0, 'min': -np.inf, 'max': np.inf}
+        default_kwargs = {'value': 0.0, 'variance': 0.0, 'min': -np.inf, 'max': np.inf}
         # Update with user-provided kwargs, to avoid errors.
         default_kwargs.update(kwargs)
         parameter = cls(name=name, **default_kwargs)
-        parameter.make_dependent_on(dependency_expression=dependency_expression, dependency_map=dependency_map)
+        parameter.make_dependent_on(
+            dependency_expression=dependency_expression,
+            dependency_map=dependency_map,
+            desired_unit=desired_unit,
+        )
         return parameter
 
     def _update(self) -> None:
@@ -158,11 +168,20 @@ class Parameter(DescriptorNumber):
             )  # noqa: E501
             self._min.unit = temporary_parameter.unit
             self._max.unit = temporary_parameter.unit
+
+            if self._desired_unit is not None:
+                self._convert_unit(self._desired_unit)
+
             self._notify_observers()
         else:
             warnings.warn('This parameter is not dependent. It cannot be updated.')
 
-    def make_dependent_on(self, dependency_expression: str, dependency_map: Optional[dict] = None) -> None:
+    def make_dependent_on(
+        self,
+        dependency_expression: str,
+        dependency_map: Optional[dict] = None,
+        desired_unit: str | sc.Unit | None = None,
+    ) -> None:
         """
         Make this parameter dependent on another parameter. This will overwrite the current value, unit, variance, min and max.
 
@@ -183,6 +202,9 @@ class Parameter(DescriptorNumber):
             A dictionary of dependency expression symbol name and dependency object pairs.
             This is inserted into the asteval interpreter to resolve dependencies.
 
+        :param desired_unit:
+            The desired unit of the dependent parameter. If None, the default unit of the dependency expression result is used.
+
         """  # noqa: E501
         if not isinstance(dependency_expression, str):
             raise TypeError('`dependency_expression` must be a string representing a valid dependency expression.')
@@ -212,6 +234,7 @@ class Parameter(DescriptorNumber):
                 '_dependency_map': self._dependency_map,
                 '_dependency_interpreter': self._dependency_interpreter,
                 '_clean_dependency_string': self._clean_dependency_string,
+                '_desired_unit': self._desired_unit,
             }
             for dependency in self._dependency_map.values():
                 dependency._detach_observer(self)
@@ -219,6 +242,9 @@ class Parameter(DescriptorNumber):
         self._independent = False
         self._dependency_string = dependency_expression
         self._dependency_map = dependency_map if dependency_map is not None else {}
+        if desired_unit is not None and not (isinstance(desired_unit, str) or isinstance(desired_unit, sc.Unit)):
+            raise TypeError('`desired_unit` must be a string representing a valid unit.')
+        self._desired_unit = desired_unit
         # List of allowed python constructs for the asteval interpreter
         asteval_config = {
             'import': False,
@@ -289,6 +315,17 @@ class Parameter(DescriptorNumber):
             raise error
         # Update the parameter with the dependency result
         self._fixed = False
+
+        if self._desired_unit is not None:
+            try:
+                dependency_result._convert_unit(self._desired_unit)
+            except Exception as e:
+                desired_unit_for_error_message = self._desired_unit
+                self._revert_dependency()  # also deletes self._desired_unit
+                raise UnitError(
+                    f'Failed to convert unit from {dependency_result.unit} to {desired_unit_for_error_message}: {e}'
+                )
+
         self._update()
 
     def make_independent(self) -> None:
@@ -306,6 +343,7 @@ class Parameter(DescriptorNumber):
             del self._dependency_interpreter
             del self._dependency_string
             del self._clean_dependency_string
+            del self._desired_unit
         else:
             raise AttributeError('This parameter is already independent.')
 
@@ -470,6 +508,28 @@ class Parameter(DescriptorNumber):
         """
         self._convert_unit(unit_str)
 
+    def set_desired_unit(self, unit_str: str | sc.Unit | None) -> None:
+        """
+        Set the desired unit for a dependent Parameter. This will convert the parameter to the desired unit.
+
+        :param unit_str: The desired unit as a string.
+        """
+
+        if self._independent:
+            raise AttributeError('This is an independent parameter, desired unit can only be set for dependent parameters.')
+        if not (isinstance(unit_str, str) or isinstance(unit_str, sc.Unit) or unit_str is None):
+            raise TypeError('`unit_str` must be a string representing a valid unit.')
+
+        if unit_str is not None:
+            try:
+                old_unit_for_message = self.unit
+                self._convert_unit(unit_str)
+            except Exception as e:
+                raise UnitError(f'Failed to convert unit from {old_unit_for_message} to {unit_str}: {e}')
+
+        self._desired_unit = unit_str
+        self._update()
+
     @property
     def min(self) -> numbers.Number:
         """
@@ -580,6 +640,9 @@ class Parameter(DescriptorNumber):
             # Save the dependency expression
             raw_dict['_dependency_string'] = self._clean_dependency_string
 
+            if self._desired_unit is not None:
+                raw_dict['_desired_unit'] = self._desired_unit
+
             # Mark that this parameter is dependent
             raw_dict['_independent'] = self._independent
 
@@ -648,6 +711,7 @@ class Parameter(DescriptorNumber):
         dependency_string = raw_dict.pop('_dependency_string', None)
         dependency_map_serializer_ids = raw_dict.pop('_dependency_map_serializer_ids', None)
         is_independent = raw_dict.pop('_independent', True)
+        desired_unit = raw_dict.pop('_desired_unit', None)
         # Note: Keep _serializer_id in the dict so it gets passed to __init__
 
         # Create the parameter using the base class method (serializer_id is now handled in __init__)
@@ -659,6 +723,7 @@ class Parameter(DescriptorNumber):
             param._pending_dependency_map_serializer_ids = dependency_map_serializer_ids
             # Keep parameter as independent initially - will be made dependent after all objects are loaded
             param._independent = True
+            param._pending_desired_unit = desired_unit
 
         return param
 
@@ -874,10 +939,14 @@ class Parameter(DescriptorNumber):
                     elif self.max <= 0:
                         combinations = [self.max / other.min, np.inf]
                 else:
-                    combinations = [self.min / other.min, self.max / other.max, self.min / other.max, self.max / other.min]
+                    combinations = [
+                        self.min / other.min,
+                        self.max / other.max,
+                        self.min / other.max,
+                        self.max / other.min,
+                    ]
             else:
                 combinations = [self.min / other.value, self.max / other.value]
-            other.value = other_value
         else:
             return NotImplemented
         min_value = min(combinations)
@@ -926,7 +995,6 @@ class Parameter(DescriptorNumber):
         parameter = Parameter.from_scipp(name=self.name, full_value=new_full_value, min=min_value, max=max_value)
         parameter._convert_unit(parameter._base_unit())
         parameter.name = parameter.unique_name
-        self.value = original_self
         return parameter
 
     def __pow__(self, other: Union[DescriptorNumber, numbers.Number]) -> Parameter:
@@ -1019,13 +1087,18 @@ class Parameter(DescriptorNumber):
 
             # Establish the dependency relationship
             try:
-                self.make_dependent_on(dependency_expression=dependency_string, dependency_map=dependency_map)
+                self.make_dependent_on(
+                    dependency_expression=dependency_string,
+                    dependency_map=dependency_map,
+                    desired_unit=self._pending_desired_unit,
+                )
             except Exception as e:
                 raise ValueError(f"Error establishing dependency '{dependency_string}': {e}")
 
             # Clean up temporary attributes
             delattr(self, '_pending_dependency_string')
             delattr(self, '_pending_dependency_map_serializer_ids')
+            delattr(self, '_pending_desired_unit')
 
     def _find_parameter_by_serializer_id(self, serializer_id: str) -> Optional['DescriptorNumber']:
         """Find a parameter by its serializer_id from all parameters in the global map."""

easyscience-2.1.0/src/easyscience/__version__.py

@@ -1 +0,0 @@
-__version__ = '2.1.0'