easyscience 1.3.0__tar.gz → 2.1.0__tar.gz

{easyscience-1.3.0 → easyscience-2.1.0}/.gitignore

@@ -23,6 +23,9 @@ dist
 poetry.lock
 *.egg-info
 
+# Pixi
+.pixi/
+
 # PyInstaller
 build
 *.spec

{easyscience-1.3.0 → easyscience-2.1.0}/LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2024, Easyscience contributors (https://github.com/EasyScience)
+Copyright (c) 2025, Easyscience contributors (https://github.com/EasyScience)
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: easyscience
-Version: 1.3.0
+Version: 2.1.0
 Summary: Generic logic for easyScience libraries
 Project-URL: homepage, https://github.com/EasyScience/EasyScience
 Project-URL: documentation, https://easyscience.github.io/EasyScience/
 Author: EasyScience contributors
 License: BSD 3-Clause License
         
-        Copyright (c) 2024, Easyscience contributors (https://github.com/EasyScience)
+        Copyright (c) 2025, Easyscience contributors (https://github.com/EasyScience)
         All rights reserved.
         
         Redistribution and use in source and binary forms, with or without
@@ -40,25 +40,27 @@ 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.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.10
+Requires-Python: >=3.11
 Requires-Dist: asteval
 Requires-Dist: bumps
 Requires-Dist: dfo-ls
 Requires-Dist: lmfit
 Requires-Dist: numpy
-Requires-Dist: pint
 Requires-Dist: scipp
 Requires-Dist: uncertainties
-Requires-Dist: xarray
+Provides-Extra: build
+Requires-Dist: build; extra == 'build'
+Requires-Dist: hatchling<=1.21.0; extra == 'build'
+Requires-Dist: setuptools-git-versioning; extra == 'build'
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: codecov; extra == 'dev'
 Requires-Dist: flake8; extra == 'dev'
+Requires-Dist: jupyterlab; extra == 'dev'
 Requires-Dist: matplotlib; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
@@ -94,6 +96,10 @@ Or direct from the repository:
 
 ```pip install https://github.com/easyScience/EasyScience```
 
+### Development
+
+For development setup and workflow instructions, please see [CONTRIBUTING.md](CONTRIBUTING.md).
+
 ## Test
 
 After installation, launch the test suite:

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

@@ -19,6 +19,10 @@ Or direct from the repository:
 
 ```pip install https://github.com/easyScience/EasyScience```
 
+### Development
+
+For development setup and workflow instructions, please see [CONTRIBUTING.md](CONTRIBUTING.md).
+
 ## Test
 
 After installation, launch the test suite:

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

@@ -21,13 +21,12 @@ classifiers = [
     "Topic :: Scientific/Engineering",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "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.10"
+requires-python = ">=3.11"
 dependencies = [
     "asteval",
     "bumps",
@@ -35,12 +34,15 @@ dependencies = [
     "lmfit",
     "numpy",  
     "uncertainties",
-    "xarray",
-    "pint",  # Only to ensure that unit is reported as dimensionless rather than empty string
     "scipp"
 ]
 
 [project.optional-dependencies]
+build = [
+    "hatchling <= 1.21.0",
+    "setuptools-git-versioning",
+    "build"
+]
 dev = [
     "build",
     "codecov",
@@ -49,7 +51,8 @@ dev = [
     "pytest",
     "pytest-cov",
     "ruff",
-    "tox-gh-actions"
+    "tox-gh-actions",
+    "jupyterlab"
 ]
 docs = [
     "doc8",
@@ -75,6 +78,7 @@ packages = ["src"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/easyscience"]
+exclude = ["src/easyscience/legacy"]
 
 [tool.coverage.run]
 source = ["src/easyscience"]
@@ -128,10 +132,9 @@ force-single-line = true
 legacy_tox_ini = """
 [tox]
 isolated_build = True
-envlist = py{3.10,3.11,3.12,3.13}
+envlist = py{3.11,3.12,3.13}
 [gh-actions]
 python =
-        3.10: py310
         3.11: py311
         3.12: py312
         3.13: py313
@@ -139,6 +142,7 @@ python =
 PLATFORM =
     ubuntu-latest: linux
     macos-latest: macos
+    macos-15-intel: macos-intel
     windows-latest: windows
 [testenv]
 passenv =

easyscience-2.1.0/src/easyscience/__init__.py

@@ -0,0 +1,24 @@
+from .global_object import GlobalObject
+
+# Must be executed before any other imports
+global_object = GlobalObject()
+global_object.instantiate_stack()
+global_object.stack.enabled = False
+
+
+from .__version__ import __version__ as __version__  # noqa: E402
+from .base_classes import ObjBase  # noqa: E402
+from .fitting import AvailableMinimizers  # noqa: E402
+from .fitting import Fitter  # noqa: E402
+from .variable import DescriptorNumber  # noqa: E402
+from .variable import Parameter  # noqa: E402
+
+__all__ = [
+    __version__,
+    global_object,
+    ObjBase,
+    AvailableMinimizers,
+    Fitter,
+    DescriptorNumber,
+    Parameter,
+]

easyscience-2.1.0/src/easyscience/__version__.py

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

easyscience-2.1.0/src/easyscience/base_classes/__init__.py

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

easyscience-2.1.0/src/easyscience/base_classes/based_base.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+#  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 inspect import signature
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Dict
+from typing import Iterable
+from typing import List
+from typing import Optional
+from typing import Set
+
+from easyscience import global_object
+
+from ..io import SerializerComponent
+from ..variable import Parameter
+from ..variable.descriptor_base import DescriptorBase
+
+if TYPE_CHECKING:
+    from ..fitting.calculators import InterfaceFactoryTemplate
+
+
+class BasedBase(SerializerComponent):
+    __slots__ = ['_name', '_global_object', 'user_data', '_kwargs']
+
+    _REDIRECT = {}
+
+    def __init__(self, name: str, interface: Optional[InterfaceFactoryTemplate] = None, unique_name: Optional[str] = None):
+        self._global_object = global_object
+        if unique_name is None:
+            unique_name = self._global_object.generate_unique_name(self.__class__.__name__)
+        self._unique_name = unique_name
+        self._name = name
+        self._global_object.map.add_vertex(self, obj_type='created')
+        self.interface = interface
+        self.user_data: dict = {}
+
+    @property
+    def _arg_spec(self) -> Set[str]:
+        base_cls = getattr(self, '__old_class__', self.__class__)
+        sign = signature(base_cls.__init__)
+        names = [param.name for param in sign.parameters.values() if param.kind == param.POSITIONAL_OR_KEYWORD]
+        return set(names[1:])
+
+    def __reduce__(self):
+        """
+        Make the class picklable.
+        Due to the nature of the dynamic class definitions special measures need to be taken.
+
+        :return: Tuple consisting of how to make the object
+        :rtype: tuple
+        """
+        state = self.encode()
+        cls = getattr(self, '__old_class__', self.__class__)
+        return cls.from_dict, (state,)
+
+    @property
+    def unique_name(self) -> str:
+        """Get the unique name of the object."""
+        return self._unique_name
+
+    @unique_name.setter
+    def unique_name(self, new_unique_name: str):
+        """Set a new unique name for the object. The old name is still kept in the map.
+
+        :param new_unique_name: New unique name for the object"""
+        if not isinstance(new_unique_name, str):
+            raise TypeError('Unique name has to be a string.')
+        self._unique_name = new_unique_name
+        self._global_object.map.add_vertex(self)
+
+    @property
+    def name(self) -> str:
+        """
+        Get the common name of the object.
+
+        :return: Common name of the object
+        """
+        return self._name
+
+    @name.setter
+    def name(self, new_name: str):
+        """
+        Set a new common name for the object.
+
+        :param new_name: New name for the object
+        :return: None
+        """
+        self._name = new_name
+
+    @property
+    def interface(self) -> InterfaceFactoryTemplate:
+        """
+        Get the current interface of the object
+        """
+        return self._interface
+
+    @interface.setter
+    def interface(self, new_interface: InterfaceFactoryTemplate):
+        """
+        Set the current interface to the object and generate bindings if possible. iF.e.
+        ```
+        def __init__(self, bar, interface=None, **kwargs):
+            super().__init__(self, **kwargs)
+            self.foo = bar
+            self.interface = interface # As final step after initialization to set correct bindings.
+        ```
+        """
+        self._interface = new_interface
+        if new_interface is not None:
+            self.generate_bindings()
+
+    def generate_bindings(self):
+        """
+        Generate or re-generate bindings to an interface (if exists)
+
+        :raises: AttributeError
+        """
+        if self.interface is None:
+            raise AttributeError('Interface error for generating bindings. `interface` has to be set.')
+        interfaceable_children = [
+            key
+            for key in self._global_object.map.get_edges(self)
+            if issubclass(type(self._global_object.map.get_item_by_key(key)), BasedBase)
+        ]
+        for child_key in interfaceable_children:
+            child = self._global_object.map.get_item_by_key(child_key)
+            child.interface = self.interface
+        self.interface.generate_bindings(self)
+
+    def switch_interface(self, new_interface_name: str):
+        """
+        Switch or create a new interface.
+        """
+        if self.interface is None:
+            raise AttributeError('Interface error for generating bindings. `interface` has to be set.')
+        self.interface.switch(new_interface_name)
+        self.generate_bindings()
+
+    def get_parameters(self) -> List[Parameter]:
+        """
+        Get all parameter objects as a list.
+
+        :return: List of `Parameter` objects.
+        """
+        par_list = []
+        for key, item in self._kwargs.items():
+            if hasattr(item, 'get_parameters'):
+                par_list = [*par_list, *item.get_parameters()]
+            elif isinstance(item, Parameter):
+                par_list.append(item)
+        return par_list
+
+    def _get_linkable_attributes(self) -> List[DescriptorBase]:
+        """
+        Get all objects which can be linked against as a list.
+
+        :return: List of `Descriptor`/`Parameter` objects.
+        """
+        item_list = []
+        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), (DescriptorBase)):
+                item_list.append(item)
+        return item_list
+
+    def get_fit_parameters(self) -> List[Parameter]:
+        """
+        Get all objects which can be fitted (and are not fixed) as a list.
+
+        :return: List of `Parameter` objects which can be used in fitting.
+        """
+        fit_list = []
+        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):
+                if item.independent and not item.fixed:
+                    fit_list.append(item)
+        return fit_list
+
+    def __dir__(self) -> Iterable[str]:
+        """
+        This creates auto-completion and helps out in iPython notebooks.
+
+        :return: list of function and parameter names for auto-completion
+        """
+        new_class_objs = list(k for k in dir(self.__class__) if not k.startswith('_'))
+        return sorted(new_class_objs)
+
+    def __copy__(self) -> BasedBase:
+        """Return a copy of the object."""
+        temp = self.as_dict(skip=['unique_name'])
+        new_obj = self.__class__.from_dict(temp)
+        return new_obj
+
+    def as_dict(self, skip: Optional[List[str]] = None) -> Dict[str, Any]:
+        """
+        Convert an object into a full dictionary using `SerializerDict`.
+        This is a shortcut for ```obj.encode(encoder=SerializerDict)```
+
+        :param skip: List of field names as strings to skip when forming the dictionary
+        :return: encoded object containing all information to reform an EasyScience object.
+        """
+        # extend skip to include unique_name by default
+        if skip is None:
+            skip = []
+        if 'unique_name' not in skip:
+            skip.append('unique_name')
+        return super().as_dict(skip=skip)

easyscience-1.3.0/src/easyscience/Objects/Groups.py → easyscience-2.1.0/src/easyscience/base_classes/collection_base.py

@@ -1,12 +1,9 @@
-#  SPDX-FileCopyrightText: 2023 EasyScience contributors  <core@easyscience.software>
+#  SPDX-FileCopyrightText: 2025 EasyScience contributors  <core@easyscience.software>
 #  SPDX-License-Identifier: BSD-3-Clause
-#  © 2021-2023 Contributors to the EasyScience project <https://github.com/easyScience/EasyScience
+#  © 2021-2025 Contributors to the EasyScience project <https://github.com/easyScience/EasyScience
 
 from __future__ import annotations
 
-__author__ = 'github.com/wardsimon'
-__version__ = '0.1.0'
-
 from collections.abc import MutableSequence
 from numbers import Number
 from typing import TYPE_CHECKING
@@ -15,32 +12,30 @@ 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.ObjectClasses import BasedBase
-from easyscience.Objects.variable.descriptor_base import DescriptorBase
+
+from ..variable.descriptor_base import DescriptorBase
+from .based_base import BasedBase
 
 if TYPE_CHECKING:
-    from easyscience.Objects.Inferface import iF
-    from easyscience.Objects.ObjectClasses import B
-    V = TypeVar('V', bound=DescriptorBase)
+    from ..fitting.calculators import InterfaceFactoryTemplate
 
 
-class BaseCollection(BasedBase, MutableSequence):
+class CollectionBase(BasedBase, MutableSequence):
     """
     This is the base class for which all higher level classes are built off of.
     NOTE: This object is serializable only if parameters are supplied as:
-    `BaseObj(a=value, b=value)`. For `Parameter` or `Descriptor` objects we can
-    cheat with `BaseObj(*[Descriptor(...), Parameter(...), ...])`.
+    `ObjBase(a=value, b=value)`. For `Parameter` or `Descriptor` objects we can
+    cheat with `ObjBase(*[Descriptor(...), Parameter(...), ...])`.
     """
 
     def __init__(
         self,
         name: str,
-        *args: Union[B, V],
-        interface: Optional[iF] = None,
+        *args: Union[BasedBase, DescriptorBase],
+        interface: Optional[InterfaceFactoryTemplate] = None,
         unique_name: Optional[str] = None,
         **kwargs,
     ):
@@ -95,7 +90,7 @@ class BaseCollection(BasedBase, MutableSequence):
             self.interface = interface
         self._kwargs._stack_enabled = True
 
-    def insert(self, index: int, value: Union[V, B]) -> None:
+    def insert(self, index: int, value: Union[DescriptorBase, BasedBase]) -> None:
         """
         Insert an object into the collection at an index.
 
@@ -122,14 +117,14 @@ class BaseCollection(BasedBase, MutableSequence):
         else:
             raise AttributeError('Only EasyScience objects can be put into an EasyScience group')
 
-    def __getitem__(self, idx: Union[int, slice]) -> Union[V, B]:
+    def __getitem__(self, idx: Union[int, slice]) -> Union[DescriptorBase, BasedBase]:
         """
         Get an item in the collection based on its index.
 
         :param idx: index or slice of the collection.
         :type idx: Union[int, slice]
         :return: Object at index `idx`
-        :rtype: Union[Parameter, Descriptor, BaseObj, 'BaseCollection']
+        :rtype: Union[Parameter, Descriptor, ObjBase, 'CollectionBase']
         """
         if isinstance(idx, slice):
             start, stop, step = idx.indices(len(self))
@@ -156,7 +151,7 @@ class BaseCollection(BasedBase, MutableSequence):
         keys = list(self._kwargs.keys())
         return self._kwargs[keys[idx]]
 
-    def __setitem__(self, key: int, value: Union[B, V]) -> None:
+    def __setitem__(self, key: int, value: Union[BasedBase, DescriptorBase]) -> None:
         """
         Set an item via it's index.
 
@@ -236,9 +231,9 @@ class BaseCollection(BasedBase, MutableSequence):
         return tuple(self._kwargs.values())
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__} `{getattr(self, 'name')}` of length {len(self)}"
+        return f'{self.__class__.__name__} `{getattr(self, "name")}` of length {len(self)}'
 
-    def sort(self, mapping: Callable[[Union[B, V]], Any], reverse: bool = False) -> None:
+    def sort(self, mapping: Callable[[Union[BasedBase, DescriptorBase]], Any], reverse: bool = False) -> None:
         """
         Sort the collection according to the given mapping.
 

easyscience-2.1.0/src/easyscience/base_classes/model_base.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+#  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 typing import TYPE_CHECKING
+
+from easyscience.variable.descriptor_number import DescriptorNumber
+
+if TYPE_CHECKING:
+    from typing import Any
+    from typing import Dict
+    from typing import List
+    from typing import Optional
+
+from ..io import SerializerBase
+from ..variable import Parameter
+from ..variable.descriptor_base import DescriptorBase
+from .new_base import NewBase
+
+
+class ModelBase(NewBase):
+    """
+    This is the base class for all model classes in EasyScience.
+    It provides methods to get parameters for fitting and analysis as well as proper serialization/deserialization for
+    DescriptorNumber/Parameter attributes.
+
+    It assumes that Parameters/DescriptorNumbers are assigned as properties with the getters returning the parameter
+    but the setter only setting the value of the parameter.
+    e.g.
+    ```python
+    @property
+    def my_param(self) -> Parameter:
+        return self._my_param
+
+    @my_param.setter
+    def my_param(self, new_value: float) -> None:
+        self._my_param.value = new_value
+    ```
+    """
+
+    def __init__(self, unique_name: Optional[str] = None, display_name: Optional[str] = None):
+        super().__init__(unique_name=unique_name, display_name=display_name)
+
+    def get_all_variables(self) -> List[DescriptorBase]:
+        """
+        Get all `Descriptor` and `Parameter` objects as a list.
+
+        :return: List of `Descriptor` and `Parameter` objects.
+        """
+        vars = []
+        for attr_name in dir(self):
+            attr = getattr(self, attr_name)
+            if isinstance(attr, DescriptorBase):
+                vars.append(attr)
+            elif hasattr(attr, 'get_all_variables'):
+                vars += attr.get_all_variables()
+        return vars
+
+    def get_all_parameters(self) -> List[Parameter]:
+        """
+        Get all `Parameter` objects as a list.
+
+        :return: List of `Parameter` objects.
+        """
+        return [param for param in self.get_all_variables() if isinstance(param, Parameter)]
+
+    def get_fittable_parameters(self) -> List[Parameter]:
+        """
+        Get all parameters which can be fitted as a list.
+
+        :return: List of `Parameter` objects.
+        """
+        return [param for param in self.get_all_parameters() if param.independent]
+
+    def get_free_parameters(self) -> List[Parameter]:
+        """
+        Get all parameters which are currently free to be fitted as a list.
+
+        :return: List of `Parameter` objects.
+        """
+        return [param for param in self.get_fittable_parameters() if not param.fixed]
+
+    def get_fit_parameters(self) -> List[Parameter]:
+        """
+        This is an alias for `get_free_parameters`.
+        To be removed when fully moved to new base classes and minimizer can be changed.
+        """
+        return self.get_free_parameters()
+
+    @classmethod
+    def from_dict(cls, obj_dict: Dict[str, Any]) -> ModelBase:
+        """
+        Re-create an EasyScience object with DescriptorNumber attributes 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 object.')
+        if obj_dict['@class'] == cls.__name__:
+            kwargs = SerializerBase.deserialize_dict(obj_dict)
+            parameter_placeholder = {}
+            for key, value in kwargs.items():
+                if isinstance(value, DescriptorNumber):
+                    parameter_placeholder[key] = value
+                    kwargs[key] = value.value
+            cls_instance = cls(**kwargs)
+            for key, value in parameter_placeholder.items():
+                try:
+                    temp_param = getattr(cls_instance, key)
+                    setattr(cls_instance, '_' + key, value)
+                    cls_instance._global_object.map.prune(temp_param.unique_name)
+                except Exception as e:
+                    raise SyntaxError(f"""Could not set parameter {key} during `from_dict` with full deserialized variable. \n'
+                            This should be fixed in the class definition. Error: {e}""") from e
+            return cls_instance
+        else:
+            raise ValueError(f'Class name in dictionary does not match the expected class: {cls.__name__}.')