easyscience 1.2.1__tar.gz → 1.3.0__tar.gz

{easyscience-1.2.1 → easyscience-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: easyscience
-Version: 1.2.1
+Version: 1.3.0
 Summary: Generic logic for easyScience libraries
 Project-URL: homepage, https://github.com/EasyScience/EasyScience
 Project-URL: documentation, https://easyscience.github.io/EasyScience/
@@ -40,18 +40,18 @@ Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: <3.13,>=3.9
+Requires-Python: >=3.10
 Requires-Dist: asteval
 Requires-Dist: bumps
 Requires-Dist: dfo-ls
 Requires-Dist: lmfit
-Requires-Dist: numpy==1.26
-Requires-Dist: pint==0.23
+Requires-Dist: numpy
+Requires-Dist: pint
 Requires-Dist: scipp
 Requires-Dist: uncertainties
 Requires-Dist: xarray

{easyscience-1.2.1 → easyscience-1.3.0}/pyproject.toml

@@ -21,22 +21,22 @@ classifiers = [
     "Topic :: Scientific/Engineering",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Development Status :: 3 - Alpha"
 ]
-requires-python = ">=3.9,<3.13"
+requires-python = ">=3.10"
 dependencies = [
     "asteval",
     "bumps",
     "DFO-LS",
     "lmfit",
-    "numpy==1.26",  # Should be updated to numpy 2.0
+    "numpy",  
     "uncertainties",
     "xarray",
-    "pint==0.23",  # Only to ensure that unit is reported as dimensionless rather than empty string
+    "pint",  # Only to ensure that unit is reported as dimensionless rather than empty string
     "scipp"
 ]
 
@@ -128,13 +128,13 @@ force-single-line = true
 legacy_tox_ini = """
 [tox]
 isolated_build = True
-envlist = py{3.9,3.10,3.11,3.12}
+envlist = py{3.10,3.11,3.12,3.13}
 [gh-actions]
 python =
-        3.9: py39
         3.10: py310
         3.11: py311
         3.12: py312
+        3.13: py313
 [gh-actions:env]
 PLATFORM =
     ubuntu-latest: linux

{easyscience-1.2.1 → easyscience-1.3.0}/src/easyscience/Constraints.py

@@ -194,13 +194,9 @@ class NumericConstraint(ConstraintBase):
         super(NumericConstraint, self).__init__(dependent_obj, operator=operator, value=value)
 
     def _parse_operator(self, obj: V, *args, **kwargs) -> Number:
-        ## TODO clean when full move to new_variable
-        import easyscience.Objects.new_variable.parameter
+        ## TODO Probably needs to be updated when DescriptorArray is implemented
 
-        if isinstance(obj, easyscience.Objects.new_variable.parameter.Parameter):
-            value = obj.value_no_call_back
-        else:
-            value = obj.raw_value
+        value = obj.value_no_call_back
 
         if isinstance(value, list):
             value = np.array(value)
@@ -258,13 +254,7 @@ class SelfConstraint(ConstraintBase):
         super(SelfConstraint, self).__init__(dependent_obj, operator=operator, value=value)
 
     def _parse_operator(self, obj: V, *args, **kwargs) -> Number:
-        ## TODO clean when full move to new_variable
-        import easyscience.Objects.new_variable.parameter
-
-        if isinstance(obj, easyscience.Objects.new_variable.parameter.Parameter):
-            value = obj.value_no_call_back
-        else:
-            value = obj.raw_value
+        value = obj.value_no_call_back
 
         self.aeval.symtable['value1'] = value
         self.aeval.symtable['value2'] = getattr(obj, self.value)
@@ -322,13 +312,7 @@ class ObjConstraint(ConstraintBase):
         self.external = True
 
     def _parse_operator(self, obj: V, *args, **kwargs) -> Number:
-        ## TODO clean when full move to new_variable
-        import easyscience.Objects.new_variable.parameter
-
-        if isinstance(obj, easyscience.Objects.new_variable.parameter.Parameter):
-            value = obj.value_no_call_back
-        else:
-            value = obj.raw_value
+        value = obj.value_no_call_back
 
         self.aeval.symtable['value1'] = value
         try:
@@ -417,16 +401,11 @@ class MultiObjConstraint(ConstraintBase):
         self.external = True
 
     def _parse_operator(self, independent_objs: List[V], *args, **kwargs) -> Number:
-        import easyscience.Objects.new_variable.parameter
 
         in_str = ''
         value = None
         for idx, obj in enumerate(independent_objs):
-            ## TODO clean when full move to new_variable
-            if isinstance(obj, easyscience.Objects.new_variable.parameter.Parameter):
-                self.aeval.symtable['p' + str(self.independent_obj_ids[idx])] = obj.value_no_call_back
-            else:
-                self.aeval.symtable['p' + str(self.independent_obj_ids[idx])] = obj.raw_value
+            self.aeval.symtable['p' + str(self.independent_obj_ids[idx])] = obj.value_no_call_back
 
             in_str += ' p' + str(self.independent_obj_ids[idx])
             if idx < len(self.operator):
@@ -485,25 +464,16 @@ class FunctionalConstraint(ConstraintBase):
             self.external = True
 
     def _parse_operator(self, obj: V, *args, **kwargs) -> Number:
-        import easyscience.Objects.new_variable.parameter
 
         self.aeval.symtable[f'f{id(self.function)}'] = self.function
         value_str = f'r_value = f{id(self.function)}('
         if isinstance(obj, list):
             for o in obj:
-                ## TODO clean when full move to new_variable
-                if isinstance(o, easyscience.Objects.new_variable.parameter.Parameter):
-                    value_str += f'{o.value_no_call_back},'
-                else:
-                    value_str += f'{o.raw_value},'
+                value_str += f'{o.value_no_call_back},'
 
             value_str = value_str[:-1]
         else:
-            ## TODO clean when full move to new_variable
-            if isinstance(obj, easyscience.Objects.new_variable.parameter.Parameter):
-                value_str += f'{obj.value_no_call_back}'
-            else:
-                value_str += f'{obj.raw_value}'
+            value_str += f'{obj.value_no_call_back}'
 
         value_str += ')'
         try:

{easyscience-1.2.1 → easyscience-1.3.0}/src/easyscience/Objects/Groups.py

@@ -15,17 +15,17 @@ from typing import Callable
 from typing import List
 from typing import Optional
 from typing import Tuple
+from typing import TypeVar
 from typing import Union
 
 from easyscience.global_object.undo_redo import NotarizedDict
-from easyscience.Objects.new_variable.descriptor_base import DescriptorBase
 from easyscience.Objects.ObjectClasses import BasedBase
-from easyscience.Objects.ObjectClasses import Descriptor
+from easyscience.Objects.variable.descriptor_base import DescriptorBase
 
 if TYPE_CHECKING:
     from easyscience.Objects.Inferface import iF
     from easyscience.Objects.ObjectClasses import B
-    from easyscience.Objects.Variable import V
+    V = TypeVar('V', bound=DescriptorBase)
 
 
 class BaseCollection(BasedBase, MutableSequence):
@@ -69,7 +69,7 @@ class BaseCollection(BasedBase, MutableSequence):
                 _kwargs[key] = item
         kwargs = _kwargs
         for item in list(kwargs.values()) + _args:
-            if not issubclass(type(item), (Descriptor, DescriptorBase, BasedBase)):
+            if not issubclass(type(item), (DescriptorBase, BasedBase)):
                 raise AttributeError('A collection can only be formed from easyscience objects.')
         args = _args
         _kwargs = {}
@@ -102,12 +102,12 @@ class BaseCollection(BasedBase, MutableSequence):
         :param index: Index for EasyScience object to be inserted.
         :type index: int
         :param value: Object to be inserted.
-        :type value: Union[BasedBase, Descriptor]
+        :type value: Union[BasedBase, DescriptorBase]
         :return: None
         :rtype: None
         """
         t_ = type(value)
-        if issubclass(t_, (BasedBase, Descriptor, DescriptorBase)):
+        if issubclass(t_, (BasedBase, DescriptorBase)):
             update_key = list(self._kwargs.keys())
             values = list(self._kwargs.values())
             # Update the internal dict
@@ -124,7 +124,7 @@ class BaseCollection(BasedBase, MutableSequence):
 
     def __getitem__(self, idx: Union[int, slice]) -> Union[V, B]:
         """
-        Get an item in the collection based on it's index.
+        Get an item in the collection based on its index.
 
         :param idx: index or slice of the collection.
         :type idx: Union[int, slice]
@@ -168,7 +168,7 @@ class BaseCollection(BasedBase, MutableSequence):
         if isinstance(value, Number):  # noqa: S3827
             item = self.__getitem__(key)
             item.value = value
-        elif issubclass(type(value), (BasedBase, Descriptor, DescriptorBase)):
+        elif issubclass(type(value), (BasedBase, DescriptorBase)):
             update_key = list(self._kwargs.keys())
             values = list(self._kwargs.values())
             old_item = values[key]
@@ -242,7 +242,7 @@ class BaseCollection(BasedBase, MutableSequence):
         """
         Sort the collection according to the given mapping.
 
-        :param mapping: mapping function to sort the collection. i.e. lambda parameter: parameter.raw_value
+        :param mapping: mapping function to sort the collection. i.e. lambda parameter: parameter.value
         :type mapping: Callable
         :param reverse: Reverse the sorting.
         :type reverse: bool

{easyscience-1.2.1 → easyscience-1.3.0}/src/easyscience/Objects/Inferface.py

@@ -152,7 +152,6 @@ class InterfaceFactoryTemplate:
         :return: binding property
         :rtype: property
         """
-        import easyscience.Objects.new_variable.parameter
 
         class_links = self.__interface_obj.create(model)
         props = model._get_linkable_attributes()
@@ -164,12 +163,13 @@ class InterfaceFactoryTemplate:
                 idx = props_names.index(item_key)
                 prop = props[idx]
 
-                ## TODO clean when full move to new_variable
-                if isinstance(prop, easyscience.Objects.new_variable.parameter.Parameter):
-                    # Should be fetched this way to ensure we don't get value from callback
+                # Should be fetched this way to ensure we don't get value from callback
+                if hasattr(prop, 'value_no_call_back'):
+                    # Property object
                     prop_value = prop.value_no_call_back
                 else:
-                    prop_value = prop.raw_value
+                    # Descriptor object
+                    prop_value = prop.value
 
                 prop._callback = item.make_prop(item_key)
                 prop._callback.fset(prop_value)

{easyscience-1.2.1 → easyscience-1.3.0}/src/easyscience/Objects/ObjectClasses.py

@@ -16,21 +16,18 @@ from typing import List
 from typing import Optional
 from typing import Set
 from typing import TypeVar
-from typing import Union
 
 from easyscience import global_object
 from easyscience.Utils.classTools import addLoggedProp
 
 from .core import ComponentSerializer
-from .new_variable import Parameter as NewParameter
-from .new_variable.descriptor_base import DescriptorBase
-from .Variable import Descriptor
-from .Variable import Parameter
+from .variable import Parameter
+from .variable.descriptor_base import DescriptorBase
 
 if TYPE_CHECKING:
     from easyscience.Constraints import C
     from easyscience.Objects.Inferface import iF
-    from easyscience.Objects.Variable import V
+    V = TypeVar('V', bound=DescriptorBase)
 
 
 class BasedBase(ComponentSerializer):
@@ -160,8 +157,7 @@ class BasedBase(ComponentSerializer):
                 constraints.append(con[key])
         return constraints
 
-    ## TODO clean when full move to new_variable
-    def get_parameters(self) -> Union[List[Parameter], List[NewParameter]]:
+    def get_parameters(self) -> List[Parameter]:
         """
         Get all parameter objects as a list.
 
@@ -171,11 +167,10 @@ class BasedBase(ComponentSerializer):
         for key, item in self._kwargs.items():
             if hasattr(item, 'get_parameters'):
                 par_list = [*par_list, *item.get_parameters()]
-            elif isinstance(item, Parameter) or isinstance(item, NewParameter):
+            elif isinstance(item, Parameter):
                 par_list.append(item)
         return par_list
 
-    ## TODO clean when full move to new_variable
     def _get_linkable_attributes(self) -> List[V]:
         """
         Get all objects which can be linked against as a list.
@@ -186,12 +181,11 @@ class BasedBase(ComponentSerializer):
         for key, item in self._kwargs.items():
             if hasattr(item, '_get_linkable_attributes'):
                 item_list = [*item_list, *item._get_linkable_attributes()]
-            elif issubclass(type(item), (Descriptor, DescriptorBase)):
+            elif issubclass(type(item), (DescriptorBase)):
                 item_list.append(item)
         return item_list
 
-    ## TODO clean when full move to new_variable
-    def get_fit_parameters(self) -> Union[List[Parameter], List[NewParameter]]:
+    def get_fit_parameters(self) -> List[Parameter]:
         """
         Get all objects which can be fitted (and are not fixed) as a list.
 
@@ -201,7 +195,7 @@ class BasedBase(ComponentSerializer):
         for key, item in self._kwargs.items():
             if hasattr(item, 'get_fit_parameters'):
                 fit_list = [*fit_list, *item.get_fit_parameters()]
-            elif isinstance(item, Parameter) or isinstance(item, NewParameter):
+            elif isinstance(item, Parameter):
                 if item.enabled and not item.fixed:
                     fit_list.append(item)
         return fit_list
@@ -235,7 +229,6 @@ class BaseObj(BasedBase):
     cheat with `BaseObj(*[Descriptor(...), Parameter(...), ...])`.
     """
 
-    ## TODO clean when full move to new_variable
     def __init__(
         self,
         name: str,
@@ -253,7 +246,7 @@ class BaseObj(BasedBase):
         super(BaseObj, self).__init__(name=name, unique_name=unique_name)
         # If Parameter or Descriptor is given as arguments...
         for arg in args:
-            if issubclass(type(arg), (BaseObj, Descriptor, DescriptorBase)):
+            if issubclass(type(arg), (BaseObj, DescriptorBase)):
                 kwargs[getattr(arg, 'name')] = arg
         # Set kwargs, also useful for serialization
         known_keys = self.__dict__.keys()
@@ -261,7 +254,7 @@ class BaseObj(BasedBase):
         for key in kwargs.keys():
             if key in known_keys:
                 raise AttributeError('Kwargs cannot overwrite class attributes in BaseObj.')
-            if issubclass(type(kwargs[key]), (BasedBase, Descriptor, DescriptorBase)) or 'BaseCollection' in [
+            if issubclass(type(kwargs[key]), (BasedBase, DescriptorBase)) or 'BaseCollection' in [
                 c.__name__ for c in type(kwargs[key]).__bases__
             ]:
                 self._global_object.map.add_edge(self, kwargs[key])
@@ -310,7 +303,6 @@ class BaseObj(BasedBase):
             test_class=BaseObj,
         )
 
-    ## TODO clean when full move to new_variable
     def __setattr__(self, key: str, value: BV) -> None:
         # Assume that the annotation is a ClassVar
         old_obj = None
@@ -323,12 +315,12 @@ class BaseObj(BasedBase):
                 self.__class__.__annotations__[key].__args__,
             )
         ):
-            if issubclass(type(getattr(self, key, None)), (BasedBase, Descriptor, DescriptorBase)):
+            if issubclass(type(getattr(self, key, None)), (BasedBase, DescriptorBase)):
                 old_obj = self.__getattribute__(key)
                 self._global_object.map.prune_vertex_from_edge(self, old_obj)
             self._add_component(key, value)
         else:
-            if hasattr(self, key) and issubclass(type(value), (BasedBase, Descriptor, DescriptorBase)):
+            if hasattr(self, key) and issubclass(type(value), (BasedBase, DescriptorBase)):
                 old_obj = self.__getattribute__(key)
                 self._global_object.map.prune_vertex_from_edge(self, old_obj)
                 self._global_object.map.add_edge(self, value)
@@ -352,8 +344,8 @@ class BaseObj(BasedBase):
     @staticmethod
     def __setter(key: str) -> Callable[[BV], None]:
         def setter(obj: BV, value: float) -> None:
-            if issubclass(obj._kwargs[key].__class__, (Descriptor, DescriptorBase)) and not issubclass(
-                value.__class__, (Descriptor, DescriptorBase)
+            if issubclass(obj._kwargs[key].__class__, (DescriptorBase)) and not issubclass(
+                value.__class__, (DescriptorBase)
             ):
                 obj._kwargs[key].value = value
             else:

{easyscience-1.2.1/src/easyscience/Objects/new_variable → easyscience-1.3.0/src/easyscience/Objects/variable}/__init__.py

@@ -1,9 +1,13 @@
+from .descriptor_any_type import DescriptorAnyType
+from .descriptor_array import DescriptorArray
 from .descriptor_bool import DescriptorBool
 from .descriptor_number import DescriptorNumber
 from .descriptor_str import DescriptorStr
 from .parameter import Parameter
 
 __all__ = [
+    DescriptorAnyType,
+    DescriptorArray,
     DescriptorBool,
     DescriptorNumber,
     DescriptorStr,

easyscience-1.3.0/src/easyscience/Objects/variable/descriptor_any_type.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import numbers
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Union
+
+import numpy as np
+
+from easyscience.global_object.undo_redo import property_stack_deco
+
+from .descriptor_base import DescriptorBase
+
+
+class DescriptorAnyType(DescriptorBase):
+    """
+    A `Descriptor` for any type that does not fit the other Descriptors. Should be avoided when possible. 
+    It was created to hold the symmetry operations used in the SpaceGroup class of EasyCrystallography.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        value: Any,
+        unique_name: Optional[str] = None,
+        description: Optional[str] = None,
+        url: Optional[str] = None,
+        display_name: Optional[str] = None,
+        parent: Optional[Any] = None,
+    ):
+        """Constructor for the DescriptorAnyType class
+
+        param name: Name of the descriptor
+        param value: Value of the descriptor
+        param description: Description of the descriptor
+        param url: URL of the descriptor
+        param display_name: Display name of the descriptor
+        param parent: Parent of the descriptor
+        .. note:: Undo/Redo functionality is implemented for the attributes `variance`, `error`, `unit` and `value`.
+        """
+
+        self._value=value
+        
+        super().__init__(
+            name=name,
+            unique_name=unique_name,
+            description=description,
+            url=url,
+            display_name=display_name,
+            parent=parent,
+        )
+
+    @property
+    def value(self) -> numbers.Number:
+        """
+        Get the value. 
+
+        :return: Value of self.
+        """
+        return self._value
+
+    @value.setter
+    @property_stack_deco
+    def value(self, value: Union[list, np.ndarray]) -> None:
+        """
+        Set the value of self. 
+
+        :param value: New value for the DescriptorAnyType.
+        """
+        self._value = value
+
+    def __copy__(self) -> DescriptorAnyType:
+        return super().__copy__()
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the DescriptorAnyType, showing its name and value.
+        """
+
+        if hasattr(self._value, '__repr__'):
+            value_repr = repr(self._value)
+        else:
+            value_repr = type(self._value)
+
+        return f"<{self.__class__.__name__} '{self._name}': {value_repr}>"
+
+    def as_dict(self, skip: Optional[List[str]] = None) -> Dict[str, Any]:
+        raw_dict = super().as_dict(skip=skip)
+        raw_dict['value'] = self._value
+        return raw_dict
+