memorymanagement 1.2.0__tar.gz → 1.2.2__tar.gz

{memorymanagement-1.2.0 → memorymanagement-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymanagement
-Version: 1.2.0
+Version: 1.2.2
 Summary: Adds support for memory management
 Home-page: https://github.com/Ricardo-Werner-Rivas/memorymanagement/tree/PyPI
 Author: Ricardo Werner Rivas

{memorymanagement-1.2.0 → memorymanagement-1.2.2}/memorymanagement/cleaning/core.py

@@ -6,48 +6,58 @@ class Cleaner:
     """
     Class for references management. It keeps track of the names of the global variables to be deleted and deletes them when ordered.
     
-    The cleaning process only deletes the flagged references to objects, but doesn't directly force the garbage collector to destroy the objects they are pointing to.\n
-    ---
+    The cleaning process only deletes the flagged references to objects, but doesn't directly force the garbage collector to destroy the objects they are pointing to.
+    
     ## WARNING
     THERE CAN ONLY BE **ONE** CLEANER OBJECT.\n
-    Initializing a new one will delete all global references to the previous one.\n
-    ---
-    Attributes:
-        _not_delete (`list[str]`, Hidden): List of variables to never delete from memory. These cannot be included in the process even if ordered so.\n
-            These mainly are variables needed for the system to work and imports.
-        _excluded (`list[str]`, Hidden): List of variables excluded from the memory cleaning that can be included again if desired.
-        _flagged (`list[str]`, Hidden): List of variables to erase from memory. Variables can be put in and/or taken out through methods.
-        _name (`str`, Hidden): Name of the variable referencing the `Cleaner` object. Only for internal purposes.
-    ---
-    \n## Methods
-        :update: *`MethodType`*
-        Updates the list of variables to erase from memory including all the new variables global variables not manually excluded.\n
-            It also allows to incorporate previously excluded variables.
-        :exclude: *`MethodType`*
-        Allows you to exclude variables from the cleaning process without need to use the `instance.update()` method.
-        :include: *`MethodType`*
-        Allows you to include variables in the cleaning process without need to use the `instance.update()` method.
-        :clean: *`MethodType`*
-        Erases all the flagged references from memory.
-    ---
-    \n## Properties
-        :not_delete: *`MethodType`*, *Getter*
-        Returns the list of variables that shouldn't be deleted and can't be included in the cleaning process.
-        :excluded: *`MethodType`*, *Getter*
-        Returns the list of variables excluded from the cleaning process but can be included again if ordered.
-        :flagged: *`MethodType`*, *Getter*
-        Returns the list of variables to be erased from memory.
-    None of this properties has setter or deleter. Those lists can only be manipulated through the class methods.
+    Initializing a new one will delete all global references to the previous one.
+    
+    Attributes
+    ----------
+    _not_delete : `list[str]`, Hidden
+        List of variables to never delete from memory. These cannot be included in the process even if ordered so.
+        These mainly are imports and variables needed for the system to work.
+    _excluded : `list[str]`, Hidden
+        List of variables excluded from the memory cleaning that can be included again if desired.
+    _flagged : `list[str]`, Hidden
+        List of variables to erase from memory. Variables can be put in and/or taken out through methods.
+    _name : `str`, Hidden
+        Name of the variable referencing the `Cleaner` object. Only for internal purposes.
+    
+    Methods
+    -------
+        **update**
+            Updates the list of variables to erase from memory including all the new variables global variables not manually excluded. It also allows to incorporate previously excluded variables.
+        **exclude**
+            Allows you to exclude variables from the cleaning process without need to use the `instance.update()` method.
+        **include**
+            Allows you to include variables in the cleaning process without need to use the `instance.update()` method.
+        **clean**
+            Erases all the flagged references from memory.
+    
+    Properties
+    ----------
+        **not_delete**
+            Returns the list of variables that shouldn't be deleted and can't be included in the cleaning process.
+        **excluded**
+            Returns the list of variables excluded from the cleaning process but can be included again if ordered.
+        **flagged**
+            Returns the list of variables to be erased from memory.
+        None of this properties has setter or deleter. Those lists can only be manipulated through the class methods.
     """
     def __init__(self,not_delete:list[str]|None=None,excluded:list[str]=[],flagged:list[str]=[]):
         """
         Initializes the class instance.\n
-        It is recommended to initialize the instance right after all global imports at the beggining of the program so no argument is needed.\n
-        ---
-        Arguments:
-            not_delete (`list[str]`, Optional): List of variables to never be deleted. It takes the list of global variables of the main module by default.
-            excluded (`list[str]`, Optional): List of variables to be excluded from the memory cleaning process. Empty list by default.
-            flagged (`list[str]`, Optional): List of variables to be erased from memory. Empty list by default.
+        It is recommended to initialize the instance right after all global imports at the beggining of the program so no argument is needed.
+        
+        Arguments
+        ---------
+        not_delete : `list[str]`, Optional
+            List of variables to never be deleted. It takes the list of global variables of the main module by default.
+        excluded : `list[str]`, Optional
+            List of variables to be excluded from the memory cleaning process. Empty list by default.
+        flagged : `list[str]`, Optional
+            List of variables to be erased from memory. Empty list by default.
         """
         if not not_delete:
             not_delete=list(vars(modules["__main__"]))
@@ -60,14 +70,16 @@ class Cleaner:
         self._name=None
     def update(self,exclude:str|list[str]|tuple[str]|None=None,include:str|list[str]|tuple[str]|None=None):
         """
-        Flags all the new global variables' references that were not manually excluded here or before. You can also include previously excluded references.
+        Flags all the new global variables' references that were not manually excluded here or before.
+        You can also include previously excluded references.
         
-        ---
-        Arguments:
-            exclude (`str`|`list[str]`|`tuple[str]`|`None`, Optional): Allows you to exclude a single (`str`) or multiple (`list` or `tuple`) variables.
-                `None` by default.
-            include (`str`|`list[str]`|`tuple[str]`|`None`, Optional): Allows you to include a single (`str`) or multiple (`list` or `tuple`) variables.
-                `None` by default.
+        Arguments
+        ---------
+        exclude : `str`|`list[str]`|`tuple[str]`|`None`, Optional
+            Allows you to exclude a single (`str`) or multiple (`list` or `tuple`) variables.
+            `None` by default.
+        include : `str`|`list[str]`|`tuple[str]`|`None`, Optional
+            Allows you to include a single (`str`) or multiple (`list` or `tuple`) variables. `None` by default.
         """
         if exclude:
             if isinstance(exclude,str):
@@ -88,6 +100,8 @@ class Cleaner:
                     self._name=key
                     self._not_delete.append(self._name)
                     break
+                else:
+                    self._name=None
             if not self._name:
                 raise ReferenceError("'Cleaner' object is not referenced")
         elif self._name not in self._not_delete:
@@ -103,9 +117,10 @@ class Cleaner:
         """
         Allows to exclude the desired references from the cleaning process.
         
-        ---
-        Arguments:
-            *exclude (`str`): Stream of references to be excluded.
+        Arguments
+        ---------
+        exclude : `tuple[str]`
+            Stream of references to be excluded.
         """
         for var in exclude:
             while var in self._flagged:
@@ -116,9 +131,10 @@ class Cleaner:
         """
         Allows to include the desired references (previously excluded) in the cleaning process.
         
-        ---
-        Arguments:
-            *include (`str`): Stream of references to be included.
+        Arguments
+        ---------
+        include : `tuple[str]`
+            Stream of references to be included.
         """
         for var in include:
             if var not in self._flagged:
@@ -127,7 +143,8 @@ class Cleaner:
                 self._excluded.remove(var)
     def clean(self):
         """
-        Culminates the cleaning process. Erases all the flagged references.
+        Culminates the cleaning process.
+        Erases all the flagged references.
         """
         for var in self._flagged:
             if var in list(vars(modules["__main__"])):

{memorymanagement-1.2.0 → memorymanagement-1.2.2}/memorymanagement/pointers/core.py

@@ -40,26 +40,44 @@ class Pointer(Generic[PT]):
     * **Setter**: it updates the value of the variable to its own (if variable was given instead of literal).
     * **Deleter**: it also deletes the original variable (if variable was given instead of literal).
     ---
-    Attributes:
-        value (`Any`, Hidden): Object to point to.
-        attr (`str`|`None`, Hidden): Attribute of class instance. Only if `value` is a class instance.
-        name (`str`, Hidden): Name of the global variable to which the pointer is pointing.
-            Could require an input from the user to introduce the name of the variable if more than one is found.
-        vars_dict (`dict[str,Any]`, Hidden): Dictionary of variables.
-            `vars(modules["__main__"])` if pointing to a global variable and `inspect.currentframe().f_back.f_locals` if pointing to a local variable.\n
-    ---
-    ## Methods
-    * `point_to`: Changes the variable or attribute the pointer is pointed to.
-    * `switch_ref`: Allows to switch between the references pointing to the same value.
-    * `print_refs`: Prints all the references pointing to the value.
-    ---
-    ## Properties\n
-    :value: *`MethodType`*\n
-        Points to `value` (or `value.attr`). Called through `<instance@Pointer>.value`. All three possible objects (getter, setter and deleter) have been declared.
-    :reference: *`MethodType`*\n
-        Pointed reference. Called through `<instance@Pointer>.reference`. **Only getter** defined.
-    :attr: *`MethodType`*\n
-        Name of the attribute of the pointed class instance. Called through `<instance@Pointer>.attr`. **Only getter** defined.\n
+    
+    Attributes
+    ----------
+    value : `Any`, Hidden
+        Object to point to.
+    attr : `str`|`None`, Hidden
+        Attribute of class instance. Only if `value` is a class instance.
+    name : `str`, Hidden
+        Name of the global variable to which the pointer is pointing.
+        Could require an input from the user to introduce the name of the variable if more than one is found.
+    vars_dict : `dict[str,Any]`, Hidden
+        Dictionary of variables.
+        `vars(modules["__main__"])` if pointing to a global variable and
+        `inspect.currentframe().f_back.f_locals` if pointing to a local variable.
+    
+    Methods
+    -------
+        **point_to**
+            Changes the variable or attribute the pointer is pointed to.
+        **switch_ref**
+            Allows to switch between the references pointing to the same value.
+        **print_refs**
+            Prints all the references pointing to the value.
+    
+    Properties
+    ----------
+        **value**
+            Points to `value` (or `value.attr`).
+            Called through `<instance@Pointer>.value`.
+            All three possible objects (getter, setter and deleter) have been declared.
+        **reference**
+            Pointed reference.
+            Called through `<instance@Pointer>.reference`.
+            **Only getter** defined.
+        **attr**
+            Name of the attribute of the pointed class instance.
+            Called through `<instance@Pointer>.attr`.
+            **Only getter** defined.
     ---
     ## Currently supported
     Both global and local variables can be pointed at.
@@ -73,11 +91,16 @@ class Pointer(Generic[PT]):
     # Constructor (__init__)
     def __init__(self,value=None,reference:str|None=None,*,attr:str|None=None,local:bool=False):
         """
-        Arguments:
-            value (`Any`, Optional): Object to point to. If want to point to a class instance atribute, pass to this argument the class instance without the atribute.
-            reference (`str`|`None`, Optional): Name linked to the value to point to. Useful in case there are multiple references pointing to the same value.
-            attr (`str`|`None`, Optional): Atribute of the class instance to which you want to point. Leave empty if `value` is not a class instance.
-            local (`bool`, Optional): Indicates if the value to point to is a local variable (`True` for yes and `False` for no). `False` by default.
+        Arguments
+        ---------
+        value : `Any`, Optional
+            Object to point to. If want to point to a class instance atribute, pass to this argument the class instance without the atribute.
+        reference : `str`|`None`, Optional
+            Name linked to the value to point to. Useful in case there are multiple references pointing to the same value.
+        attr : `str`|`None`, Optional
+            Attribute of the class instance to which you want to point. Leave empty if `value` is not a class instance.
+        local : `bool`, Optional
+            Indicates if the value to point to is a local variable (`True` for yes and `False` for no). `False` by default.
         """
         if local:
             vars_dict=currentframe().f_back.f_locals
@@ -105,12 +128,16 @@ class Pointer(Generic[PT]):
     # Point to
     def point_to(self,reference:str|None=None,value=None,*,attr:str|None=None):
         """
-        Changes the address which the pointer points to.\n
-        ---
-        Arguments:
-            reference (`str`|`None`, Optional): Reference pointing to the desired value. If wanted class attribute, introduce the reference for the class object.
-            value (`Any`|`None`, Optional): Value to point to. If wanted class attribute, introduce just the class object.
-            attr (`str`|`None`, Optional): Attribute of the class if class object was passed through `reference` or `value`.
+        Changes the address which the pointer points to.
+        
+        Arguments
+        ---------
+        reference : `str`|`None`, Optional
+            Reference pointing to the desired value. If wanted class attribute, introduce the reference for the class object.
+        value : `Any`|`None`, Optional
+            Value to point to. If wanted class attribute, introduce just the class object.
+        attr : `str`|`None`, Optional
+            Attribute of the class if class object was passed through `reference` or `value`.
         """
         if not reference and not value:
             pass
@@ -150,10 +177,12 @@ class Pointer(Generic[PT]):
     # Switch reference
     def switch_ref(self,reference:str):
         """
-        Allows to switch between references pointing to the same current value of the pointer.\n
-        ---
-        Arguments:
-            reference (`str`): Reference to switch the pointer to.
+        Allows to switch between references pointing to the same current value of the pointer.
+        
+        Arguments
+        ---------
+        reference : `str`
+            Reference to switch the pointer to.
         """
         if reference in self._vars_dict and self._vars_dict[reference] is not self.value:
             raise ValueError(f"Name \"{reference}\" doesn't point to pointer's value \"{self.value}\"")
@@ -168,6 +197,7 @@ class Pointer(Generic[PT]):
         """
         refs=[key for key,v in self._vars_dict.items() if v is self._value]
         refs=refs if len(refs)!=0 else [None]
+        print(refs)
     
     #* PROPERTIES
     # Value

{memorymanagement-1.2.0 → memorymanagement-1.2.2}/memorymanagement/pointers/decorators.py

@@ -30,9 +30,10 @@ def pointerize(func):
     
     The decorated function is still able to receive its normally expected parameters.
     
-    ---
-    Arguments:
-        func (`FunctionType`): Decorated function.
+    Arguments
+    ---------
+    func : `FunctionType`
+        Decorated function.
     """
     # Makes the decorating function to keep its identity
     @wraps(func)

{memorymanagement-1.2.0 → memorymanagement-1.2.2}/memorymanagement.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymanagement
-Version: 1.2.0
+Version: 1.2.2
 Summary: Adds support for memory management
 Home-page: https://github.com/Ricardo-Werner-Rivas/memorymanagement/tree/PyPI
 Author: Ricardo Werner Rivas

{memorymanagement-1.2.0 → memorymanagement-1.2.2}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = memorymanagement
-version = 1.2.0
+version = 1.2.2
 author = Ricardo Werner Rivas
 author_email = ricardowernerrivas@gmail.com
 description = Adds support for memory management