easyscience 2.0.0__tar.gz → 2.2.0__tar.gz

{easyscience-2.0.0 → easyscience-2.2.0}/.gitignore

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: easyscience
-Version: 2.0.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/
@@ -52,10 +52,15 @@ Requires-Dist: lmfit
 Requires-Dist: numpy
 Requires-Dist: scipp
 Requires-Dist: uncertainties
+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'
@@ -73,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
 
@@ -91,6 +97,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:
@@ -101,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.0.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
 
@@ -19,6 +20,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:
@@ -29,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.0.0 → easyscience-2.2.0}/pyproject.toml

@@ -38,6 +38,11 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+build = [
+    "hatchling <= 1.21.0",
+    "setuptools-git-versioning",
+    "build"
+]
 dev = [
     "build",
     "codecov",
@@ -46,7 +51,8 @@ dev = [
     "pytest",
     "pytest-cov",
     "ruff",
-    "tox-gh-actions"
+    "tox-gh-actions",
+    "jupyterlab"
 ]
 docs = [
     "doc8",
@@ -136,6 +142,7 @@ python =
 PLATFORM =
     ubuntu-latest: linux
     macos-latest: macos
+    macos-15-intel: macos-intel
     windows-latest: windows
 [testenv]
 passenv =

easyscience-2.2.0/src/easyscience/__version__.py

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

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

@@ -0,0 +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, EasyList]

{easyscience-2.0.0 → easyscience-2.2.0}/src/easyscience/base_classes/based_base.py

@@ -3,8 +3,10 @@ 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 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
@@ -38,9 +40,9 @@ class BasedBase(SerializerComponent):
     @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
+        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):
         """
@@ -195,4 +197,17 @@ class BasedBase(SerializerComponent):
         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-2.0.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
@@ -23,7 +24,6 @@ if TYPE_CHECKING:
     from ..fitting.calculators import InterfaceFactoryTemplate
 
 
-
 class CollectionBase(BasedBase, MutableSequence):
     """
     This is the base class for which all higher level classes are built off of.
@@ -35,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,
@@ -65,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 = {}
@@ -91,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
@@ -118,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.
 
@@ -152,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.
 
@@ -164,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]
@@ -232,9 +232,13 @@ class CollectionBase(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[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.2.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__}.')