50 consolidate code for unique name generation (#51)

Author: andped10

src/easyscience/Objects/ObjectClasses.py

@@ -41,10 +41,10 @@ class BasedBase(ComponentSerializer):
     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._unique_name_generator()
+            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._global_object.map.add_vertex(self, obj_type='created')
         self.interface = interface
         self.user_data: dict = {}
 
@@ -69,16 +69,16 @@ def __reduce__(self):
 
     @property
     def unique_name(self) -> str:
-        """ Get the unique name of the object."""
+        """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. 
-        
+        """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.")
+            raise TypeError('Unique name has to be a string.')
         self._unique_name = new_unique_name
         self._global_object.map.add_vertex(self)
 
@@ -206,18 +206,6 @@ def get_fit_parameters(self) -> Union[List[Parameter], List[NewParameter]]:
                     fit_list.append(item)
         return fit_list
 
-    def _unique_name_generator(self) -> str:
-        """
-        Generate a generic unique name for the object using the class name and a global iterator.
-        """
-        class_name = self.__class__.__name__
-        iterator_string = str(self._global_object.map._get_name_iterator(class_name))
-        name = class_name + "_" + iterator_string
-        while name in self._global_object.map.vertices():
-            iterator_string = str(self._global_object.map._get_name_iterator(class_name))
-            name = class_name + "_" + iterator_string
-        return name
-
     def __dir__(self) -> Iterable[str]:
         """
         This creates auto-completion and helps out in iPython notebooks.
@@ -226,7 +214,6 @@ def __dir__(self) -> Iterable[str]:
         """
         new_class_objs = list(k for k in dir(self.__class__) if not k.startswith('_'))
         return sorted(new_class_objs)
-    
 
 
 if TYPE_CHECKING:
@@ -267,7 +254,7 @@ def __init__(
         self._kwargs = kwargs
         for key in kwargs.keys():
             if key in known_keys:
-                raise AttributeError("Kwargs cannot overwrite class attributes in BaseObj.")
+                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__
             ]:

src/easyscience/Objects/Variable.py

@@ -109,7 +109,7 @@ def __init__(
         if not hasattr(self, '_args'):
             self._args = {'value': None, 'units': ''}
         if unique_name is None:
-            unique_name = self._unique_name_generator()
+            unique_name = self._global_object.generate_unique_name(self.__class__.__name__)
         self._unique_name = unique_name
         self.name = name
         # Let the collective know we've been assimilated
@@ -190,14 +190,14 @@ def unique_name(self) -> str:
         :return: Unique name of this 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. 
-        
+        """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.")
+            raise TypeError('Unique name has to be a string.')
         self._unique_name = new_unique_name
         self._global_object.map.add_vertex(self)
 
@@ -363,19 +363,6 @@ def convert_unit(self, unit_str: str):
         self._args['value'] = self.raw_value
         self._args['units'] = str(self.unit)
 
-    def _unique_name_generator(self) -> str:
-        """
-        Generate a generic unique name for the object using the class name and a global iterator.
-        """
-        class_name = self.__class__.__name__
-        iterator_string = str(self._global_object.map._get_name_iterator(class_name))
-        name = class_name + "_" + iterator_string
-        while name in self._global_object.map.vertices():
-            iterator_string = str(self._global_object.map._get_name_iterator(class_name))
-            name = class_name + "_" + iterator_string
-        return name
-
-
     # @cached_property
     @property
     def compatible_units(self) -> List[str]:

src/easyscience/Objects/new_variable/descriptor_base.py

@@ -55,7 +55,7 @@ def __init__(
         """
 
         if unique_name is None:
-            unique_name = self._unique_name_generator()
+            unique_name = self._global_object.generate_unique_name(self.__class__.__name__)
         self._unique_name = unique_name
 
         if not isinstance(name, str):
@@ -178,29 +178,17 @@ def unique_name(self) -> str:
         :return: Unique name of this 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. 
-        
+        """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.")
+            raise TypeError('Unique name has to be a string.')
         self._unique_name = new_unique_name
         self._global_object.map.add_vertex(self)
 
-    def _unique_name_generator(self) -> str:
-        """
-        Generate a generic unique name for the object using the class name and a global iterator.
-        """
-        class_name = self.__class__.__name__
-        iterator_string = str(self._global_object.map._get_name_iterator(class_name))
-        name = class_name + "_" + iterator_string
-        while name in self._global_object.map.vertices():
-            iterator_string = str(self._global_object.map._get_name_iterator(class_name))
-            name = class_name + "_" + iterator_string
-        return name
-
     @property
     @abc.abstractmethod
     def value(self) -> Any:
@@ -218,6 +206,6 @@ def __repr__(self) -> str:
     def __copy__(self) -> DescriptorBase:
         """Return a copy of the object."""
         temp = self.as_dict()
-        temp["unique_name"] = None
+        temp['unique_name'] = None
         new_obj = self.__class__.from_dict(temp)
         return new_obj

src/easyscience/__init__.py

@@ -17,9 +17,12 @@
 global_object.instantiate_stack()
 global_object.stack.enabled = False
 
+
 # alias for global_object, remove later
 def __getattr__(name):
     if name == 'borg':
-        warnings.warn("The 'borg' has been renamed to 'global_object', this alias will be deprecated in the future", DeprecationWarning)  # noqa: E501
+        warnings.warn(
+            "The 'borg' has been renamed to 'global_object', this alias will be deprecated in the future", DeprecationWarning
+        )  # noqa: E501
         print("The 'borg' has been renamed to 'global_object', this alias will be deprecated in the future")
-        return global_object
+        return global_object

src/easyscience/global_object/global_object.py

@@ -2,8 +2,8 @@
 #  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 easyscience.Utils.classUtils import singleton
 
@@ -47,3 +47,23 @@ def instantiate_stack(self):
         from easyscience.global_object.undo_redo import UndoStack
 
         self.stack = UndoStack()
+
+    def generate_unique_name(self, name_prefix: str) -> str:
+        """
+        Generate a generic unique name for the object using the class name and a global iterator.
+        Names are in the format `name_prefix_0`, `name_prefix_1`, `name_prefix_2`, etc.
+
+        :param name_prefix: The prefix to be used for the name
+        """
+        names_with_prefix = [name for name in self.map.vertices() if name.startswith(name_prefix + '_')]
+        if names_with_prefix:
+            name_with_prefix_count = [0]
+            for name in names_with_prefix:
+                # Strip away the prefix and trailing _
+                name_without_prefix = name.replace(name_prefix + '_', '')
+                if name_without_prefix.isdecimal():
+                    name_with_prefix_count.append(int(name_without_prefix))
+            unique_name = f'{name_prefix}_{max(name_with_prefix_count) + 1}'
+        else:
+            unique_name = f'{name_prefix}_0'
+        return unique_name

src/easyscience/global_object/map.py

@@ -2,9 +2,10 @@
 #  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'
 
+import gc
 import sys
 import weakref
 from typing import List
@@ -13,22 +14,22 @@
 class _EntryList(list):
     def __init__(self, *args, my_type=None, **kwargs):
         super(_EntryList, self).__init__(*args, **kwargs)
-        self.__known_types = {"argument", "created", "created_internal", "returned"}
+        self.__known_types = {'argument', 'created', 'created_internal', 'returned'}
         self.finalizer = None
         self._type = []
         if my_type in self.__known_types:
             self._type.append(my_type)
 
     def __repr__(self) -> str:
-        s = "Map entry of type: "
+        s = 'Map entry of type: '
         if self._type:
-            s += ", ".join(self._type)
+            s += ', '.join(self._type)
         else:
-            s += "Undefined"
-        s += ". With"
+            s += 'Undefined'
+        s += '. With'
         if self.finalizer is None:
-            s += "out"
-        s += "a finalizer."
+            s += 'out'
+        s += 'a finalizer.'
         return s
 
     def __delitem__(self, key):
@@ -53,19 +54,19 @@ def type(self, value: str):
 
     @property
     def is_argument(self) -> bool:
-        return "argument" in self._type
+        return 'argument' in self._type
 
     @property
     def is_created(self) -> bool:
-        return "created" in self._type
+        return 'created' in self._type
 
     @property
     def is_created_internal(self) -> bool:
-        return "created_internal" in self._type
+        return 'created_internal' in self._type
 
     @property
     def is_returned(self) -> bool:
-        return "returned" in self._type
+        return 'returned' in self._type
 
 
 class Map:
@@ -74,8 +75,6 @@ def __init__(self):
         self._store = weakref.WeakValueDictionary()
         # A dict with object names as keys and a list of their object types as values, with weak references
         self.__type_dict = {}
-        # A dictionary of class names and their corresponding default name_generator iterators
-        self._name_iterator_dict = {}
 
     def vertices(self) -> List[str]:
         """returns the vertices of a map"""
@@ -87,36 +86,28 @@ def edges(self):
 
     @property
     def argument_objs(self) -> List[str]:
-        return self._nested_get("argument")
+        return self._nested_get('argument')
 
     @property
     def created_objs(self) -> List[str]:
-        return self._nested_get("created")
+        return self._nested_get('created')
 
     @property
     def created_internal(self) -> List[str]:
-        return self._nested_get("created_internal")
+        return self._nested_get('created_internal')
 
     @property
     def returned_objs(self) -> List[str]:
-        return self._nested_get("returned")
+        return self._nested_get('returned')
 
     def _nested_get(self, obj_type: str) -> List[str]:
         """Access a nested object in root by key sequence."""
         return [key for key, item in self.__type_dict.items() if obj_type in item.type]
 
-
-    def _get_name_iterator(self, class_name: str) -> int:
-        """Get the iterator for the name generator for a class"""
-        iterator = self._name_iterator_dict.setdefault(class_name, 0)
-        self._name_iterator_dict[class_name] += 1
-        return iterator
-
-
     def get_item_by_key(self, item_id: str) -> object:
         if item_id in self._store.keys():
             return self._store[item_id]
-        raise ValueError("Item not in map.")
+        raise ValueError('Item not in map.')
 
     def is_known(self, vertex: object) -> bool:
         # All objects should have a 'unique_name' attribute
@@ -137,19 +128,17 @@ def change_type(self, obj, new_type: str):
     def add_vertex(self, obj: object, obj_type: str = None):
         name = obj.unique_name
         if name in self._store.keys():
-            raise ValueError(f"Object name {name} already exists in the graph.")
+            raise ValueError(f'Object name {name} already exists in the graph.')
         self._store[name] = obj
         self.__type_dict[name] = _EntryList()  # Add objects type to the list of types
-        self.__type_dict[name].finalizer = weakref.finalize(
-            self._store[name], self.prune, name
-        )
+        self.__type_dict[name].finalizer = weakref.finalize(self._store[name], self.prune, name)
         self.__type_dict[name].type = obj_type
 
     def add_edge(self, start_obj: object, end_obj: object):
         if start_obj.unique_name in self.__type_dict.keys():
             self.__type_dict[start_obj.unique_name].append(end_obj.unique_name)
         else:
-            raise AttributeError("Start object not in map.")
+            raise AttributeError('Start object not in map.')
 
     def get_edges(self, start_obj) -> List[str]:
         if start_obj.unique_name in self.__type_dict.keys():
@@ -176,10 +165,7 @@ def prune_vertex_from_edge(self, parent_obj, child_obj):
             return
         vertex2 = child_obj.unique_name
 
-        if (
-            vertex1 in self.__type_dict.keys()
-            and vertex2 in self.__type_dict[vertex1]
-        ):
+        if vertex1 in self.__type_dict.keys() and vertex2 in self.__type_dict[vertex1]:
             del self.__type_dict[vertex1][self.__type_dict[vertex1].index(vertex2)]
 
     def prune(self, key: str):
@@ -282,20 +268,18 @@ def is_connected(self, vertices_encountered=None, start_vertex=None) -> bool:
         vertices_encountered.add(start_vertex)
         if len(vertices_encountered) != len(vertices):
             for vertex in graph[start_vertex]:
-                if vertex not in vertices_encountered and self.is_connected(
-                    vertices_encountered, vertex
-                ):
+                if vertex not in vertices_encountered and self.is_connected(vertices_encountered, vertex):
                     return True
         else:
             return True
         return False
 
     def _clear(self):
-        """ Reset the map to an empty state. """
-        self._store = weakref.WeakValueDictionary()
+        """Reset the map to an empty state."""
+        for vertex in self.vertices():
+            self.prune(vertex)
+        gc.collect()
         self.__type_dict = {}
-        self._name_iterator_dict = {}
 
     def __repr__(self) -> str:
-        return f"Map object of {len(self._store)} vertices."
-
+        return f'Map object of {len(self._store)} vertices.'