easyscience 1.2.1__tar.gz → 2.0.0__tar.gz

{easyscience-1.2.1 → easyscience-2.0.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.2.1 → easyscience-2.0.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: easyscience
-Version: 1.2.1
+Version: 2.0.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,21 +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.11
 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: scipp
 Requires-Dist: uncertainties
-Requires-Dist: xarray
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: codecov; extra == 'dev'

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

@@ -21,22 +21,19 @@ 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.11"
 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
     "scipp"
 ]
 
@@ -75,6 +72,7 @@ packages = ["src"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/easyscience"]
+exclude = ["src/easyscience/legacy"]
 
 [tool.coverage.run]
 source = ["src/easyscience"]
@@ -128,13 +126,12 @@ force-single-line = true
 legacy_tox_ini = """
 [tox]
 isolated_build = True
-envlist = py{3.9,3.10,3.11,3.12}
+envlist = py{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-2.0.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.0.0/src/easyscience/__version__.py

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

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

@@ -0,0 +1,9 @@
+from .based_base import BasedBase
+from .collection_base import CollectionBase
+from .obj_base import ObjBase
+
+__all__ = [
+    BasedBase,
+    CollectionBase,
+    ObjBase,
+]

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

@@ -0,0 +1,198 @@
+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 getfullargspec
+from typing import TYPE_CHECKING
+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__)
+        spec = getfullargspec(base_cls.__init__)
+        names = set(spec.args[1:])
+        return names
+
+    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
+
+

easyscience-1.2.1/src/easyscience/Objects/Groups.py → easyscience-2.0.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
@@ -18,29 +15,28 @@ from typing import Tuple
 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 ..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
-    from easyscience.Objects.Variable import V
+    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,
     ):
@@ -69,7 +65,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 = {}
@@ -95,19 +91,19 @@ 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.
 
         :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
@@ -122,14 +118,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 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]
         :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 +152,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.
 
@@ -168,7 +164,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]
@@ -238,11 +234,11 @@ class BaseCollection(BasedBase, MutableSequence):
     def __repr__(self) -> str:
         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.
 
-        :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-2.0.0/src/easyscience/base_classes/obj_base.py

@@ -0,0 +1,162 @@
+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 typing import Callable
+from typing import Optional
+
+from ..utils.classTools import addLoggedProp
+from ..variable.descriptor_base import DescriptorBase
+from .based_base import BasedBase
+
+if TYPE_CHECKING:
+    from ..io import SerializerComponent
+
+
+
+class ObjBase(BasedBase):
+    """
+    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:
+    `ObjBase(a=value, b=value)`. For `Parameter` or `Descriptor` objects we can
+    cheat with `ObjBase(*[Descriptor(...), Parameter(...), ...])`.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        unique_name: Optional[str] = None,
+        *args: Optional[SerializerComponent],
+        **kwargs: Optional[SerializerComponent],
+    ):
+        """
+        Set up the base class.
+
+        :param name: Name of this object
+        :param args: Any arguments?
+        :param kwargs: Fields which this class should contain
+        """
+        super(ObjBase, self).__init__(name=name, unique_name=unique_name)
+        # If Parameter or Descriptor is given as arguments...
+        for arg in args:
+            if issubclass(type(arg), (ObjBase, DescriptorBase)):
+                kwargs[getattr(arg, 'name')] = arg
+        # Set kwargs, also useful for serialization
+        known_keys = self.__dict__.keys()
+        self._kwargs = kwargs
+        for key in kwargs.keys():
+            if key in known_keys:
+                raise AttributeError('Kwargs cannot overwrite class attributes in ObjBase.')
+            if issubclass(type(kwargs[key]), (BasedBase, DescriptorBase)) or 'CollectionBase' in [
+                c.__name__ for c in type(kwargs[key]).__bases__
+            ]:
+                self._global_object.map.add_edge(self, kwargs[key])
+                self._global_object.map.reset_type(kwargs[key], 'created_internal')
+            addLoggedProp(
+                self,
+                key,
+                self.__getter(key),
+                self.__setter(key),
+                get_id=key,
+                my_self=self,
+                test_class=ObjBase,
+            )
+
+    def _add_component(self, key: str, component: SerializerComponent) -> None:
+        """
+        Dynamically add a component to the class. This is an internal method, though can be called remotely.
+        The recommended alternative is to use typing, i.e.
+
+        class Foo(Bar):
+            def __init__(self, foo: Parameter, bar: Parameter):
+                super(Foo, self).__init__(bar=bar)
+                self._add_component("foo", foo)
+
+        Goes to:
+         class Foo(Bar):
+            foo: ClassVar[Parameter]
+            def __init__(self, foo: Parameter, bar: Parameter):
+                super(Foo, self).__init__(bar=bar)
+                self.foo = foo
+
+        :param key: Name of component to be added
+        :param component: Component to be added
+        :return: None
+        """
+        self._kwargs[key] = component
+        self._global_object.map.add_edge(self, component)
+        self._global_object.map.reset_type(component, 'created_internal')
+        addLoggedProp(
+            self,
+            key,
+            self.__getter(key),
+            self.__setter(key),
+            get_id=key,
+            my_self=self,
+            test_class=ObjBase,
+        )
+
+    def __setattr__(self, key: str, value: SerializerComponent) -> None:
+        # Assume that the annotation is a ClassVar
+        old_obj = None
+        if (
+            hasattr(self.__class__, '__annotations__')
+            and key in self.__class__.__annotations__
+            and hasattr(self.__class__.__annotations__[key], '__args__')
+            and issubclass(
+                getattr(value, '__old_class__', value.__class__),
+                self.__class__.__annotations__[key].__args__,
+            )
+        ):
+            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, 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)
+        super(ObjBase, self).__setattr__(key, value)
+        # Update the interface bindings if something changed (BasedBase and Descriptor)
+        if old_obj is not None:
+            old_interface = getattr(self, 'interface', None)
+            if old_interface is not None:
+                self.generate_bindings()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__} `{getattr(self, 'name')}`"
+
+    @staticmethod
+    def __getter(key: str) -> Callable[[SerializerComponent], SerializerComponent]:
+        def getter(obj: SerializerComponent) -> SerializerComponent:
+            return obj._kwargs[key]
+
+        return getter
+
+    @staticmethod
+    def __setter(key: str) -> Callable[[SerializerComponent], None]:
+        def setter(obj: SerializerComponent, value: float) -> None:
+            if issubclass(obj._kwargs[key].__class__, (DescriptorBase)) and not issubclass(
+                value.__class__, (DescriptorBase)
+            ):
+                obj._kwargs[key].value = value
+            else:
+                obj._kwargs[key] = value
+
+        return setter
+
+    # @staticmethod
+    # def __setter(key: str) -> Callable[[Union[B, V]], None]:
+    #     def setter(obj: Union[V, B], value: float) -> None:
+    #         if issubclass(obj._kwargs[key].__class__, Descriptor):
+    #             if issubclass(obj._kwargs[key].__class__, Descriptor):
+    #                 obj._kwargs[key] = value
+    #             else:
+    #                 obj._kwargs[key].value = value
+    #         else:
+    #             obj._kwargs[key] = value
+    #
+    #     return setter

easyscience-2.0.0/src/easyscience/fitting/calculators/__init__.py

@@ -0,0 +1,7 @@
+#  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 .interface_factory import InterfaceFactoryTemplate
+
+__all__ = [InterfaceFactoryTemplate]