easyscience 0.6.1__tar.gz → 1.0.0__tar.gz

{easyscience-0.6.1 → easyscience-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: easyscience
-Version: 0.6.1
+Version: 1.0.0
 Summary: Generic logic for easyScience libraries
 Project-URL: homepage, https://docs.easyscience.org
 Project-URL: documentation, https://docs.easyscience.org
@@ -51,8 +51,9 @@ Requires-Dist: asteval
 Requires-Dist: bumps
 Requires-Dist: dfo-ls
 Requires-Dist: lmfit
-Requires-Dist: numpy
-Requires-Dist: pint
+Requires-Dist: numpy==1.26
+Requires-Dist: pint==0.23
+Requires-Dist: scipp
 Requires-Dist: uncertainties
 Requires-Dist: xarray
 Provides-Extra: dev
@@ -111,6 +112,6 @@ Documentation can be found at:
 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.
 
 ## License
-While **EasyScience** is under the BSD-3 license, DFO_LS is subject to the GPL license.
+While **EasyScience** is under the BSD-3 license, DFO-LS is subject to the GPL license.
 
 

{easyscience-0.6.1 → easyscience-1.0.0}/README.md

@@ -35,6 +35,6 @@ Documentation can be found at:
 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.
 
 ## License
-While **EasyScience** is under the BSD-3 license, DFO_LS is subject to the GPL license.
+While **EasyScience** is under the BSD-3 license, DFO-LS is subject to the GPL license.
 
 

{easyscience-0.6.1 → easyscience-1.0.0}/pyproject.toml

@@ -34,10 +34,11 @@ dependencies = [
     "bumps",
     "DFO-LS",
     "lmfit",
-    "numpy",
-    "pint",
+    "numpy==1.26",  # Should be updated to numpy 2.0
     "uncertainties",
-    "xarray"
+    "xarray",
+    "pint==0.23",  # Only to ensure that unit is reported as dimensionless rather than empty string
+    "scipp"
 ]
 
 [project.optional-dependencies]

{easyscience-0.6.1 → easyscience-1.0.0}/src/easyscience/Datasets/xarray.py

@@ -20,7 +20,7 @@ import numpy as np
 import xarray as xr
 
 from easyscience import ureg
-from easyscience.Fitting.fitting_template import FitResults
+from easyscience.fitting import FitResults
 
 T_ = TypeVar('T_')
 
@@ -281,14 +281,13 @@ class EasyScienceDatasetAccessor:
 
         :param variable_label: Name of the DataArray to perform the calculation on
         :type variable_label: str
-        :param sigma_func: Function to generate the sigmas. Must be of the form f(x) and return an array of the same
-        shape as the input. DEFAULT: sqrt(|data|)
+        :param sigma_func: Function to generate the sigmas. Must be of the form f(x) and return an array of the same shape as the input. Default sqrt(\|x\|)
         :type sigma_func: Callable
         :param label_prefix: What prefix should be used to designate a sigma DataArray from a data DataArray
         :type label_prefix: str
         :return: None
         :rtype: None
-        """
+        """  # noqa: E501
         sigma_values = sigma_func(self._obj[variable_label])
         self.sigma_attach(variable_label, sigma_values, label_prefix)
 
@@ -371,13 +370,13 @@ class EasyScienceDatasetAccessor:
         **kwargs,
     ) -> List[FitResults]:
         """
-        Perform a fit on one or more DataArrays. This fit utilises a given fitter from `EasyScience.Fitting.Fitter`, though
+        Perform a fit on one or more DataArrays. This fit utilises a given fitter from `EasyScience.fitting.Fitter`, though
         there are a few differences to a standard EasyScience fit. In particular, key-word arguments to control the
         optimisation algorithm go in the `fit_kwargs` dictionary, fit function key-word arguments go in the `fn_kwargs`
         and given key-word arguments control the `xarray.apply_ufunc` function.
 
         :param fitter: Fitting object which controls the fitting
-        :type fitter: EasyScience.Fitting.Fitter
+        :type fitter: EasyScience.fitting.Fitter
         :param args: Arguments to go to the fit function
         :type args: Any
         :param dask: Dask control string. See `xarray.apply_ufunc` documentation
@@ -612,13 +611,13 @@ class EasyScienceDataarrayAccessor:
 
     def fit_prep(self, func_in: Callable, bdims=None, dask_chunks=None) -> Tuple[xr.DataArray, Callable]:
         """
-        Generate boradcasted coordinates for fitting and reform the fitting function into one which can handle xarrays
+        Generate broadcasted coordinates for fitting and reform the fitting function into one which can handle xarrays.
 
-        :param func_in: Function to be wrapped and made xarray fitting compatable.
+        :param func_in: Function to be wrapped and made xarray fitting compatible.
         :type func_in: Callable
         :param bdims: Optional precomputed broadcasted dimensions.
         :type bdims: xarray.DataArray
-        :param dask_chunks: How to split to broadcasted dimensions for dask.
+        :param dask_chunks: How to split the broadcasted dimensions for dask.
         :type dask_chunks: Tuple[int..]
         :return: Tuple of broadcasted fit arrays and wrapped fit function.
         :rtype: xarray.DataArray, Callable
@@ -681,13 +680,13 @@ class EasyScienceDataarrayAccessor:
         **kwargs,
     ) -> FitResults:
         """
-        Perform a fit on the given DataArray. This fit utilises a given fitter from `EasyScience.Fitting.Fitter`, though
+        Perform a fit on the given DataArray. This fit utilises a given fitter from `EasyScience.fitting.Fitter`, though
         there are a few differences to a standard EasyScience fit. In particular, key-word arguments to control the
         optimisation algorithm go in the `fit_kwargs` dictionary, fit function key-word arguments go in the `fn_kwargs`
         and given key-word arguments control the `xarray.apply_ufunc` function.
 
         :param fitter: Fitting object which controls the fitting
-        :type fitter: EasyScience.Fitting.Fitter
+        :type fitter: EasyScience.fitting.Fitter
         :param args: Arguments to go to the fit function
         :type args: Any
         :param dask: Dask control string. See `xarray.apply_ufunc` documentation
@@ -732,7 +731,7 @@ class EasyScienceDataarrayAccessor:
 
         # Set the new callable to the fitter and initialize
         fitter.initialize(fitter.fit_object, local_fit_func)
-        # Make EasyScience.Fitting.Fitter compatible `x`
+        # Make EasyScience.fitting.Fitter compatible `x`
         x_for_fit = xr.concat(bdims, dim='fit_dim')
         x_for_fit = x_for_fit.stack(all_x=[d.name for d in bdims])
         try:
@@ -803,7 +802,7 @@ def check_sanity_multiple(fit_results: FitResults, originals: List[xr.DataArray]
         current_results = fit_results.__class__()
         # Fill out the basic stuff....
         current_results.engine_result = fit_results.engine_result
-        current_results.fitting_engine = fit_results.fitting_engine
+        current_results.minimizer_engine = fit_results.minimizer_engine
         current_results.success = fit_results.success
         current_results.p = fit_results.p
         current_results.p0 = fit_results.p0

{easyscience-0.6.1 → easyscience-1.0.0}/src/easyscience/Objects/Groups.py

@@ -17,15 +17,14 @@ from typing import Optional
 from typing import Tuple
 from typing import Union
 
-from easyscience import borg
+from easyscience.global_object.undo_redo import NotarizedDict
 from easyscience.Objects.ObjectClasses import BasedBase
 from easyscience.Objects.ObjectClasses import Descriptor
-from easyscience.Utils.UndoRedo import NotarizedDict
 
 if TYPE_CHECKING:
-    from easyscience.Utils.typing import B
-    from easyscience.Utils.typing import V
-    from easyscience.Utils.typing import iF
+    from easyscience.Objects.Inferface import iF
+    from easyscience.Objects.ObjectClasses import B
+    from easyscience.Objects.Variable import V
 
 
 class BaseCollection(BasedBase, MutableSequence):
@@ -75,8 +74,8 @@ class BaseCollection(BasedBase, MutableSequence):
         for key, item in kwargs.items():
             _kwargs[key] = item
         for arg in args:
-            kwargs[str(borg.map.convert_id_to_key(arg))] = arg
-            _kwargs[str(borg.map.convert_id_to_key(arg))] = arg
+            kwargs[arg.unique_name] = arg
+            _kwargs[arg.unique_name] = arg
 
         # Set kwargs, also useful for serialization
         self._kwargs = NotarizedDict(**_kwargs)
@@ -84,8 +83,8 @@ class BaseCollection(BasedBase, MutableSequence):
         for key in kwargs.keys():
             if key in self.__dict__.keys() or key in self.__slots__:
                 raise AttributeError(f'Given kwarg: `{key}`, is an internal attribute. Please rename.')
-            self._borg.map.add_edge(self, kwargs[key])
-            self._borg.map.reset_type(kwargs[key], 'created_internal')
+            self._global_object.map.add_edge(self, kwargs[key])
+            self._global_object.map.reset_type(kwargs[key], 'created_internal')
             if interface is not None:
                 kwargs[key].interface = interface
             # TODO wrap getter and setter in Logger
@@ -109,13 +108,13 @@ class BaseCollection(BasedBase, MutableSequence):
             update_key = list(self._kwargs.keys())
             values = list(self._kwargs.values())
             # Update the internal dict
-            new_key = str(borg.map.convert_id_to_key(value))
+            new_key = value.unique_name
             update_key.insert(index, new_key)
             values.insert(index, value)
             self._kwargs.reorder(**{k: v for k, v in zip(update_key, values)})
             # ADD EDGE
-            self._borg.map.add_edge(self, value)
-            self._borg.map.reset_type(value, 'created_internal')
+            self._global_object.map.add_edge(self, value)
+            self._global_object.map.reset_type(value, 'created_internal')
             value.interface = self.interface
         else:
             raise AttributeError('Only EasyScience objects can be put into an EasyScience group')
@@ -174,11 +173,11 @@ class BaseCollection(BasedBase, MutableSequence):
             update_dict = {update_key[key]: value}
             self._kwargs.update(update_dict)
             # ADD EDGE
-            self._borg.map.add_edge(self, value)
-            self._borg.map.reset_type(value, 'created_internal')
+            self._global_object.map.add_edge(self, value)
+            self._global_object.map.reset_type(value, 'created_internal')
             value.interface = self.interface
             # REMOVE EDGE
-            self._borg.map.prune_vertex_from_edge(self, old_item)
+            self._global_object.map.prune_vertex_from_edge(self, old_item)
         else:
             raise NotImplementedError('At the moment only numerical values or EasyScience objects can be set.')
 
@@ -193,7 +192,7 @@ class BaseCollection(BasedBase, MutableSequence):
         """
         keys = list(self._kwargs.keys())
         item = self._kwargs[keys[key]]
-        self._borg.map.prune_vertex_from_edge(self, item)
+        self._global_object.map.prune_vertex_from_edge(self, item)
         del self._kwargs[keys[key]]
 
     def __len__(self) -> int:

{easyscience-0.6.1 → easyscience-1.0.0}/src/easyscience/Objects/Inferface.py

@@ -4,8 +4,8 @@ from __future__ import annotations
 #  SPDX-License-Identifier: BSD-3-Clause
 #  © 2021-2023 Contributors to the EasyScience project <https://github.com/easyScience/EasyScience
 
-__author__ = "github.com/wardsimon"
-__version__ = "0.1.0"
+__author__ = 'github.com/wardsimon'
+__version__ = '0.1.0'
 
 from abc import ABCMeta
 from typing import TYPE_CHECKING
@@ -16,10 +16,10 @@ from typing import Optional
 from typing import Type
 from typing import TypeVar
 
-_C = TypeVar("_C", bound=ABCMeta)
-_M = TypeVar("_M")
+_C = TypeVar('_C', bound=ABCMeta)
+_M = TypeVar('_M')
 if TYPE_CHECKING:
-    from easyscience.Fitting.Fitting import Fitter
+    from easyscience.fitting import Fitter
 
 
 class InterfaceFactoryTemplate:
@@ -44,14 +44,14 @@ class InterfaceFactoryTemplate:
         :return: None
         :rtype: noneType
         """
-        if kwargs.get("interface_name", None) is None:
+        if kwargs.get('interface_name', None) is None:
             if len(self._interfaces) > 0:
                 # Fallback name
                 interface_name = self.return_name(self._interfaces[0])
             else:
                 raise NotImplementedError
         else:
-            interface_name = kwargs.pop("interface_name")
+            interface_name = kwargs.pop('interface_name')
         interfaces = self.available_interfaces
         if interface_name in interfaces:
             self._current_interface = self._interfaces[interfaces.index(interface_name)]
@@ -65,7 +65,7 @@ class InterfaceFactoryTemplate:
         :param new_interface: name of new interface to be created
         :type new_interface: str
         :param fitter: Fitting interface which contains the fitting object which may have bindings which will be updated.
-        :type fitter: EasyScience.Fitting.Fitting.Fitter
+        :type fitter: EasyScience.fitting.Fitter
         :return: None
         :rtype: noneType
         """
@@ -74,20 +74,20 @@ class InterfaceFactoryTemplate:
             self._current_interface = self._interfaces[interfaces.index(new_interface)]
             self.__interface_obj = self._current_interface()
         else:
-            raise AttributeError("The user supplied interface is not valid.")
+            raise AttributeError('The user supplied interface is not valid.')
         if fitter is not None:
-            if hasattr(fitter, "_fit_object"):
-                obj = getattr(fitter, "_fit_object")
+            if hasattr(fitter, '_fit_object'):
+                obj = getattr(fitter, '_fit_object')
                 try:
-                    if hasattr(obj, "update_bindings"):
+                    if hasattr(obj, 'update_bindings'):
                         obj.update_bindings()
                 except Exception as e:
-                    print(f"Unable to auto generate bindings.\n{e}")
-            elif hasattr(fitter, "generate_bindings"):
+                    print(f'Unable to auto generate bindings.\n{e}')
+            elif hasattr(fitter, 'generate_bindings'):
                 try:
                     fitter.generate_bindings()
                 except Exception as e:
-                    print(f"Unable to auto generate bindings.\n{e}")
+                    print(f'Unable to auto generate bindings.\n{e}')
 
     @property
     def available_interfaces(self) -> List[str]:
@@ -152,6 +152,8 @@ 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()
         props_names = [prop.name for prop in props]
@@ -161,8 +163,16 @@ class InterfaceFactoryTemplate:
                     continue
                 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
+                    prop_value = prop.value_no_call_back
+                else:
+                    prop_value = prop.raw_value
+
                 prop._callback = item.make_prop(item_key)
-                prop._callback.fset(prop.raw_value)
+                prop._callback.fset(prop_value)
 
     def __call__(self, *args, **kwargs) -> _M:
         return self.__interface_obj
@@ -189,8 +199,8 @@ class InterfaceFactoryTemplate:
         Return an interfaces name
         """
         interface_name = this_interface.__name__
-        if hasattr(this_interface, "name"):
-            interface_name = getattr(this_interface, "name")
+        if hasattr(this_interface, 'name'):
+            interface_name = getattr(this_interface, 'name')
         return interface_name
 
 
@@ -225,4 +235,4 @@ class ItemContainer(NamedTuple):
         return set_value
 
 
-iF = TypeVar("iF", bound=InterfaceFactoryTemplate)
+iF = TypeVar('iF', bound=InterfaceFactoryTemplate)

{easyscience-0.6.1 → easyscience-1.0.0}/src/easyscience/Objects/ObjectClasses.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-__author__ = "github.com/wardsimon"
-__version__ = "0.1.0"
+__author__ = 'github.com/wardsimon'
+__version__ = '0.1.0'
 
 #  SPDX-FileCopyrightText: 2023 EasyScience contributors  <core@easyscience.software>
 #  SPDX-License-Identifier: BSD-3-Clause
@@ -16,35 +16,41 @@ from typing import List
 from typing import Optional
 from typing import Set
 from typing import TypeVar
+from typing import Union
 
-from easyscience import borg
+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
 
 if TYPE_CHECKING:
-    from easyscience.Utils.typing import C
-    from easyscience.Utils.typing import V
-    from easyscience.Utils.typing import iF
+    from easyscience.fitting.Constraints import C
+    from easyscience.Objects.Inferface import iF
+    from easyscience.Objects.Variable import V
 
 
 class BasedBase(ComponentSerializer):
-    __slots__ = ["_name", "_borg", "user_data", "_kwargs"]
+    __slots__ = ['_name', '_global_object', 'user_data', '_kwargs']
 
     _REDIRECT = {}
 
-    def __init__(self, name: str, interface: Optional[iF] = None):
-        self._borg = borg
-        self._borg.map.add_vertex(self, obj_type="created")
+    def __init__(self, name: str, interface: Optional[iF] = 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 = {}
-        self._name: str = name
 
     @property
     def _arg_spec(self) -> Set[str]:
-        base_cls = getattr(self, "__old_class__", self.__class__)
+        base_cls = getattr(self, '__old_class__', self.__class__)
         spec = getfullargspec(base_cls.__init__)
         names = set(spec.args[1:])
         return names
@@ -58,9 +64,24 @@ class BasedBase(ComponentSerializer):
         :rtype: tuple
         """
         state = self.encode()
-        cls = getattr(self, "__old_class__", self.__class__)
+        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:
         """
@@ -109,16 +130,14 @@ class BasedBase(ComponentSerializer):
         :raises: AttributeError
         """
         if self.interface is None:
-            raise AttributeError(
-                "Interface error for generating bindings. `interface` has to be set."
-            )
+            raise AttributeError('Interface error for generating bindings. `interface` has to be set.')
         interfaceable_children = [
             key
-            for key in self._borg.map.get_edges(self)
-            if issubclass(type(self._borg.map.get_item_by_key(key)), BasedBase)
+            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._borg.map.get_item_by_key(child_key)
+            child = self._global_object.map.get_item_by_key(child_key)
             child.interface = self.interface
         self.interface.generate_bindings(self)
 
@@ -127,9 +146,7 @@ class BasedBase(ComponentSerializer):
         Switch or create a new interface.
         """
         if self.interface is None:
-            raise AttributeError(
-                "Interface error for generating bindings. `interface` has to be set."
-            )
+            raise AttributeError('Interface error for generating bindings. `interface` has to be set.')
         self.interface.switch(new_interface_name)
         self.generate_bindings()
 
@@ -143,7 +160,8 @@ class BasedBase(ComponentSerializer):
                 constraints.append(con[key])
         return constraints
 
-    def get_parameters(self) -> List[Parameter]:
+    ## TODO clean when full move to new_variable
+    def get_parameters(self) -> Union[List[Parameter], List[NewParameter]]:
         """
         Get all parameter objects as a list.
 
@@ -151,12 +169,13 @@ class BasedBase(ComponentSerializer):
         """
         par_list = []
         for key, item in self._kwargs.items():
-            if hasattr(item, "get_parameters"):
+            if hasattr(item, 'get_parameters'):
                 par_list = [*par_list, *item.get_parameters()]
-            elif isinstance(item, Parameter):
+            elif isinstance(item, Parameter) or isinstance(item, NewParameter):
                 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.
@@ -165,13 +184,14 @@ class BasedBase(ComponentSerializer):
         """
         item_list = []
         for key, item in self._kwargs.items():
-            if hasattr(item, "_get_linkable_attributes"):
+            if hasattr(item, '_get_linkable_attributes'):
                 item_list = [*item_list, *item._get_linkable_attributes()]
-            elif issubclass(type(item), Descriptor):
+            elif issubclass(type(item), Descriptor) or issubclass(type(item), DescriptorBase):
                 item_list.append(item)
         return item_list
 
-    def get_fit_parameters(self) -> List[Parameter]:
+    ## TODO clean when full move to new_variable
+    def get_fit_parameters(self) -> Union[List[Parameter], List[NewParameter]]:
         """
         Get all objects which can be fitted (and are not fixed) as a list.
 
@@ -179,10 +199,11 @@ class BasedBase(ComponentSerializer):
         """
         fit_list = []
         for key, item in self._kwargs.items():
-            if hasattr(item, "get_fit_parameters"):
+            if hasattr(item, 'get_fit_parameters'):
                 fit_list = [*fit_list, *item.get_fit_parameters()]
-            elif isinstance(item, Parameter) and item.enabled and not item.fixed:
-                fit_list.append(item)
+            elif isinstance(item, Parameter) or isinstance(item, NewParameter):
+                if item.enabled and not item.fixed:
+                    fit_list.append(item)
         return fit_list
 
     def __dir__(self) -> Iterable[str]:
@@ -191,13 +212,13 @@ class BasedBase(ComponentSerializer):
 
         :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("_"))
+        new_class_objs = list(k for k in dir(self.__class__) if not k.startswith('_'))
         return sorted(new_class_objs)
 
 
 if TYPE_CHECKING:
-    B = TypeVar("B", bound=BasedBase)
-    BV = TypeVar("BV", bound=ComponentSerializer)
+    B = TypeVar('B', bound=BasedBase)
+    BV = TypeVar('BV', bound=ComponentSerializer)
 
 
 class BaseObj(BasedBase):
@@ -208,9 +229,11 @@ class BaseObj(BasedBase):
     cheat with `BaseObj(*[Descriptor(...), Parameter(...), ...])`.
     """
 
+    ## TODO clean when full move to new_variable
     def __init__(
         self,
         name: str,
+        unique_name: Optional[str] = None,
         *args: Optional[BV],
         **kwargs: Optional[BV],
     ):
@@ -221,22 +244,22 @@ class BaseObj(BasedBase):
         :param args: Any arguments?
         :param kwargs: Fields which this class should contain
         """
-        super(BaseObj, self).__init__(name)
+        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)):
-                kwargs[getattr(arg, "name")] = arg
+            if issubclass(type(arg), (BaseObj, Descriptor, 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
-            if issubclass(
-                type(kwargs[key]), (BasedBase, Descriptor)
-            ) or "BaseCollection" in [c.__name__ for c in type(kwargs[key]).__bases__]:
-                self._borg.map.add_edge(self, kwargs[key])
-                self._borg.map.reset_type(kwargs[key], "created_internal")
+                raise AttributeError('Kwargs cannot overwrite class attributes in BaseObj.')
+            if issubclass(type(kwargs[key]), (BasedBase, Descriptor, DescriptorBase)) or 'BaseCollection' 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,
@@ -269,8 +292,8 @@ class BaseObj(BasedBase):
         :return: None
         """
         self._kwargs[key] = component
-        self._borg.map.add_edge(self, component)
-        self._borg.map.reset_type(component, "created_internal")
+        self._global_object.map.add_edge(self, component)
+        self._global_object.map.reset_type(component, 'created_internal')
         addLoggedProp(
             self,
             key,
@@ -281,31 +304,32 @@ 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
         if (
-            hasattr(self.__class__, "__annotations__")
+            hasattr(self.__class__, '__annotations__')
             and key in self.__class__.__annotations__
-            and hasattr(self.__class__.__annotations__[key], "__args__")
+            and hasattr(self.__class__.__annotations__[key], '__args__')
             and issubclass(
-                getattr(value, "__old_class__", value.__class__),
+                getattr(value, '__old_class__', value.__class__),
                 self.__class__.__annotations__[key].__args__,
             )
         ):
-            if issubclass(type(getattr(self, key, None)), (BasedBase, Descriptor)):
+            if issubclass(type(getattr(self, key, None)), (BasedBase, Descriptor, DescriptorBase)):
                 old_obj = self.__getattribute__(key)
-                self._borg.map.prune_vertex_from_edge(self, old_obj)
+                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)):
+            if hasattr(self, key) and issubclass(type(value), (BasedBase, Descriptor, DescriptorBase)):
                 old_obj = self.__getattribute__(key)
-                self._borg.map.prune_vertex_from_edge(self, old_obj)
-                self._borg.map.add_edge(self, value)
+                self._global_object.map.prune_vertex_from_edge(self, old_obj)
+                self._global_object.map.add_edge(self, value)
         super(BaseObj, 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)
+            old_interface = getattr(self, 'interface', None)
             if old_interface is not None:
                 self.generate_bindings()
 
@@ -322,9 +346,7 @@ 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) and not issubclass(
-                value.__class__, Descriptor
-            ):
+            if issubclass(obj._kwargs[key].__class__, Descriptor) and not issubclass(value.__class__, Descriptor):
                 obj._kwargs[key].value = value
             else:
                 obj._kwargs[key] = value