memorymanagement 1.1.5__py3-none-any.whl → 1.2.1__py3-none-any.whl

memorymanagement/cleaning/__init__.py

@@ -29,7 +29,7 @@ cleaner.update(
 )
 print(cleaner)
 ```
-The cell above prints (via `__str__` method):
+The cell above prints the following (via `__str__` method):
 ```
 Flagged: ["x","y","z"]
 

memorymanagement/cleaning/core.py

@@ -6,13 +6,11 @@ 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.
-    
+    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
     ---
     ## WARNING
     THERE CAN ONLY BE **ONE** CLEANER OBJECT.\n
-    Initializing a new one will delete all global references to the previous one.
-    
+    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
@@ -21,8 +19,7 @@ class Cleaner:
         _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
+    \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.
@@ -33,8 +30,7 @@ class Cleaner:
         :clean: *`MethodType`*
         Erases all the flagged references from memory.
     ---
-    
-    ## Properties
+    \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*
@@ -46,8 +42,7 @@ class Cleaner:
     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.
-        
+        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.
@@ -87,11 +82,18 @@ class Cleaner:
         self._flagged=[var for var in list(vars(modules["__main__"]))if var not in self.not_delete and var not in self.excluded]
     @property
     def not_delete(self):
-        if not self._name:
+        if not self._name or vars(modules["__main__"])[self._name] is not self:
             for key,value in vars(modules["__main__"]).items():
                 if value is self:
                     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:
+            self._not_delete.append(self._name)
         return self._not_delete
     @property
     def excluded(self):

memorymanagement/pointers/__init__.py

@@ -5,11 +5,12 @@ A safe implementation of pointers written in pure Python.
 It is safe beacause it doesn't imitate the internal behaviour of C pointers because it could break the memory.
 It only replicates the visible effects and behaviour of C pointers.
 ## Class `Pointer`
-This is the core of the module. The class `Pointer` points to a specific reference,
+This is the core of the module. The class `Pointer` points to a specific reference (not object in memory),
 which will be syncrhonized with the pointer's value since the moment of the pointer's creation.
 ## Decorator `pointerize`
 This decorator makes any function able to receive `Pointer` objects instead of the originally expected.
 """
 # Import from modules
 from .core import Pointer # Class "Pointer"
-from .decorators import pointerize # Decorator "pointerize"
+from .decorators import pointerize # Decorator "pointerize"
+__all__=["Pointer","pointerize"]

memorymanagement/pointers/core.py

@@ -2,6 +2,7 @@
 #* LEGEND
 #*-------------------------------------------------------------------------------------------------------------------------------
 #! Missing
+#& Missing unimportant
 #? Question
 #* Section
 #^ Important
@@ -18,10 +19,13 @@ from typing import TypeVar,Generic
 from sys import modules
 # Import "currentframe" from "inspect" package
 from inspect import currentframe
+# Define type with TypeVar
+PT=TypeVar("PT")
 
 #* MAIN CLASS
 # Define the class "Pointer" with generic type
-class Pointer(Generic[TypeVar("Any")]):
+class Pointer(Generic[PT]):
+    #& Missing code comments
     """
     Implements pointers in Python for both mutable (though unneded) and non-mutable objects.
     These pointers are completely safe and do not work internally as C's pointers, they are just an imitation of their behaviour.
@@ -31,10 +35,10 @@ class Pointer(Generic[TypeVar("Any")]):
     
     Non-mutable objects still change their memory adresses when re-referenced but the reference and the value stored in the pointer are forced to share memory adress.
     
-    Value and memory adress updates are not made in real-time, but the methods update the non-coincident values:
-        * **Getter**: it updates its own value to the variable's one (if variable was given instead of literal).
-        * **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).
+    Value and memory adress updates are not made in real-time, but the properties update the non-coincident values:
+    * **Getter**: it updates its own value to the variable's one (if variable was given instead of literal).
+    * **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.
@@ -42,33 +46,36 @@ class Pointer(Generic[TypeVar("Any")]):
         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.
+            `vars(modules["__main__"])` if pointing to a global variable and `inspect.currentframe().f_back.f_locals` if pointing to a local variable.\n
     ---
-    
     ## Methods
-        1. **Getter**: Gets the value.
-        2. **Setter**: Sets a new value.
-        3. **Deleter**: Deletes the value.
-    All three methods are part of the same property.
+    * `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: *`MethodType`*
-        Points to `value` (or `value.attr`). Called through `<instance>.value`. All three possible objects (getter, setter and deleter) have been declared.
-    
+    ## 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
     ---
-    
     ## Currently supported
     Both global and local variables can be pointed at.
     
-    Literals are **not** supported because of it being useless. If you create a `Pointer` instance for a literal and works,
-    keep in mind that it is merely by accident and it is **not** the intended use it was designed for.
-    Currently, the only use for inserting a literal instead of a referenced value could be for the class code to display all the references pointing to that literal
-    and bind the instance to the desired reference.
+    Literals are **not** supported because of it being useless. Literals do **not** work anymore.
+    The only use for introducing a literal instead of a referenced value is for the class code to bind the instance
+    to an unknown reference pointing to the given value or to display all the references pointing to the given literal
+    if there is more than one.
     """
-    def __init__(self,value=None,attr:str|None=None,*,local:bool=False):
+    #* METHODS
+    # 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, introduce the class instance without the atribute.
+            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.
         """
@@ -79,70 +86,134 @@ class Pointer(Generic[TypeVar("Any")]):
         self._value=value
         self._vars_dict=vars_dict
         self._attr=attr
-        name=[]
-        for key,v in vars_dict.items():
-            try:
-                if v is value:
-                    name.append(key)
-            except ValueError:
-                pass
-        if len(name)>1:
-            print(f"{name}\nMultiple variable names found for the 'value' parameter, introduce the correct one:")
-            while True:
-                name_aux=input()
-                if name_aux in name:
-                    break
-                else:
-                    print("Error, introduce the correct variable name for the 'value' parameter:")
-            name=name_aux
-            del name_aux
-        elif len(name)==1:
-            name=name[0]
-        elif len(name)==0:
-            name=None
+        if self._attr and self._attr not in dir(self._value):
+            raise AttributeError(f"\"{attr}\" is not an attribute of \"{self._value}\"")
+        if reference:
+            if reference in vars_dict and vars_dict[reference] is value:
+                name=reference
+            elif reference not in vars_dict:
+                raise NameError(f"Name \"{reference}\" is not defined")
+            elif vars_dict[reference] is not value:
+                raise ValueError(f"Name \"{reference}\" doesn't point to given value ({value})")
+        else:
+            name=[key for key,v in vars_dict.items() if v is value]
+            name=name if len(name)!=0 else [None]
         self._name=name
-        return
+        if self._name==None:
+            raise NameError(f"No reference is pointing to given value \"{self._value}\"")
+    
+    # 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`.
+        """
+        if not reference and not value:
+            pass
+        elif reference and value:
+            if reference in self._vars_dict and self._vars_dict[reference] is value:
+                self._name,self._value=reference,value
+                if attr:
+                    if attr in dir(self._value):
+                        self._attr=attr
+                    else:
+                        raise AttributeError(f"\"{attr}\" is not an attribute of \"{self._value}\"")
+            elif reference not in self._vars_dict:
+                raise NameError(f"Name \"{reference}\" is not defined")
+            elif self._vars_dict[reference] is not value:
+                raise ValueError(f"Name \"{reference}\" doesn't point to given value \"{value}\"")
+        elif reference:
+            if reference in self._vars_dict:
+                self._name,self._value=reference,self._vars_dict[reference]
+                if attr:
+                    if attr in dir(self._value):
+                        self._attr=attr
+                    else:
+                        raise AttributeError(f"\"{attr}\" is not an attribute of \"{self._value}\"")
+            else:
+                raise NameError(f"Name \"{reference}\" is not defined")
+        elif value:
+            self._name,self._value=[key for key,v in self._vars_dict.items() if v is value],value
+            self._name=self._name if len(self._name)!=0 else [None]
+            if self._name==None:
+                raise NameError(f"No reference is pointing to given value \"{self._value}\"")
+            if attr:
+                if attr in dir(self._value):
+                    self._attr=attr
+                else:
+                    raise AttributeError(f"\"{attr}\" is not an attribute of \"{self._value}\"")
+    
+    # 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.
+        """
+        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}\"")
+        elif reference not in self._vars_dict:
+            raise NameError(f"Name \"{reference}\" is not defined")
+        self._name=reference
+    
+    # Print references
+    def print_refs(self):
+        """
+        Prints all the references pointing to the same current value of the pointer.
+        """
+        refs=[key for key,v in self._vars_dict.items() if v is self._value]
+        refs=refs if len(refs)!=0 else [None]
     
     #* PROPERTIES
     # Value
     @property
     # Getter
     def value(self):
-        if self._attr:
-            if self._name and self._name not in list(self._vars_dict):
-                del self._value,self._attr
-                raise KeyError("The class instance has already been deleted, so the pointer no longer has access to it.")
-            elif self._attr not in dir(self._value):
-                raise AttributeError(f"The atribute '{self._attr}' has already been deleted, so the pointer no longer has access to it.")
-            return getattr(self._value,self._attr)
+        if self.attr:
+            if self.reference not in self._vars_dict:
+                del self._value,self.attr
+                raise NameError("The class instance has already been deleted, so the pointer no longer has access to it.")
+            elif self.attr not in dir(self._value):
+                raise AttributeError(f"The atribute \"{self._attr}\" has already been deleted, so the pointer no longer has access to it.")
+            return getattr(self._value,self.attr)
         else:
-            if self._name:
-                if self._name not in list(self._vars_dict):
-                    del self._value
-                    raise KeyError("The variable has already been deleted, so the pointer no longer has access to it.")
-                if self._value is not self._vars_dict[self._name]:
-                    self._value=self._vars_dict[self._name]
+            if self.reference not in self._vars_dict:
+                del self._value
+                raise NameError("The variable has already been deleted, so the pointer no longer has access to it.")
+            if self._value is not self._vars_dict[self.reference]:
+                self._value=self._vars_dict[self.reference]
             return self._value
     # Setter
     @value.setter
     def value(self,value):
-        if self._attr:
-            setattr(self._value,self._attr,value)
+        if self.attr:
+            setattr(self._value,self.attr,value)
         else:
             self._value=value
-            if self._name and value is not self._vars_dict[self._name]:
-                self._vars_dict[self._name]=value
-        return
+            if value is not self._vars_dict[self.reference]:
+                self._vars_dict[self.reference]=value
     # Deleter
     @value.deleter
     def value(self):
-        if self._attr:
-            delattr(self._value,self._attr)
+        if self.attr:
+            delattr(self._value,self.attr)
         else:
             del self._value
-            if self._name:
-                del self._vars_dict[self._name]
-        return
+            del self._vars_dict[self.reference]
+    # Reference
+    @property
+    # Getter
+    def reference(self):
+        return self._name
+    # Attribute
+    @property
+    def attr(self):
+        return self._attr
     
     #* INDEXATION
     # Getter
@@ -311,8 +382,10 @@ class Pointer(Generic[TypeVar("Any")]):
     # __int__
     def __int__(self):
         return int(self.value)
+    # __float__
     def __float__(self):
         return float(self.value)
+    # __index__
     def __index__(self):
         return self.value
     
@@ -322,7 +395,18 @@ class Pointer(Generic[TypeVar("Any")]):
         return f"{self.__class__.__name__}({self.value})"
     # HTML representation
     def _repr_html_(self):
-        return f"<p>{self.value}</p>"
+        return f"""
+        <table>
+            <thead>
+                <tr>
+                    <th style=\"text-align: center;\">{self.reference}</th>
+                </tr>
+            </thead>
+            <tr>
+                <td style=\"text-align: center;\">{self.value}</td>
+            </tr>
+        </table>
+        """
     # Printing
     def __str__(self):
         return str(self.value)

memorymanagement/pointers/decorators.py

@@ -1,10 +1,29 @@
-# Imports
+#*===============================================================================================================================
+#* LEGEND
+#*-------------------------------------------------------------------------------------------------------------------------------
+#! Missing
+#& Missing unimportant
+#? Question
+#* Section
+#^ Important
+# Normal comment
+#// Alternative or deprecated code
+#*===============================================================================================================================
+
+#^ The different types of comments require the "Colorful Comments Refreshed" extension for VSCode to be properly distinguished
+
+#* IMPORTS
+# settrace (sys)
 from sys import settrace
+# signature (inspect)
 from inspect import signature
+# wraps (functools)
 from functools import wraps
+# Pointer (from the core of the package)
 from .core import Pointer
 
-# Define the decorator
+#* DECORATORS
+# pointerize
 def pointerize(func):
     """
     Allows the decorated function to receive pointers instead of the normally expected values.

{memorymanagement-1.1.5.dist-info → memorymanagement-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymanagement
-Version: 1.1.5
+Version: 1.2.1
 Summary: Adds support for memory management
 Home-page: https://github.com/Ricardo-Werner-Rivas/memorymanagement/tree/PyPI
 Author: Ricardo Werner Rivas
@@ -167,14 +167,10 @@ There are two branches:
 
 Pull requests from TestPyPI to PyPI will only be done by the owner when a new release is ready.
 
+### Branch merging
 To merge branches properly with PyPI branch in your cloned repository, you will need to have the `.gitattributes` file in the PyPI branch and execute the following commands, while in repo directory, in your PowerShell:
 ```powershell
 git config merge.keepPyPIFiles.name "Keep README.md and setup.cfg from PyPI branch on merge"
 git config merge.keepPyPIFiles.driver "bash -c 'cp $(git rev-parse --show-toplevel)/$3 $2'"
 ```
-Or in your git bash terminal:
-```bash
-git config merge.keepPyPIFiles.name "Keep README.md and setup.cfg from PyPI branch on merge"
-git config merge.keepPyPIFiles.driver "bash -c 'cp $(git rev-parse --show-toplevel)/$3 $2'"
-```
-This way, READMEs and setup files will not be overwritten in the PyPI branch.
+This way, `README.md` and `setup.cfg` files will not be overwritten in the PyPI branch.

memorymanagement-1.2.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+memorymanagement/__init__.py,sha256=Clyt9uUH0DZW36BdmWCMYNg4R2uLYYsSdsn1UgeLSJs,816
+memorymanagement/cleaning/__init__.py,sha256=Z3KB1OxIg_3xCh4z-SP8mEyq5L9fIqVZtWsu1D88gaw,1373
+memorymanagement/cleaning/core.py,sha256=M9TNJ6X8V5S4FLpAdcpz6feKX9YDV-IHa_989eYhhVQ,7256
+memorymanagement/pointers/__init__.py,sha256=bUasGBW3STzvuLc8-oCDuANF1u6OW_cKeokIidgu7qM,791
+memorymanagement/pointers/core.py,sha256=kMuct-ZrDwbifLyQpqQUvDEnm2h1BozIk3BUxpXwMk0,16350
+memorymanagement/pointers/decorators.py,sha256=kx41gxNhQry2RAxwdYljjBoNEjS5C_b7P1vV8vmFQ_E,3644
+memorymanagement-1.2.1.dist-info/licenses/LICENSE,sha256=oomqnX6WpwczxhGg1lDAUrS13YL-0NFIpomyReHWgKo,1098
+memorymanagement-1.2.1.dist-info/METADATA,sha256=sz9j6PzEIjDLdT1yhnPtE_i4iYOKkr-AU5K5FvsKqnE,4739
+memorymanagement-1.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+memorymanagement-1.2.1.dist-info/top_level.txt,sha256=7SwrpC3BY9Cm6sqwu082DJE5SteRBira0LGqziTO7eQ,17
+memorymanagement-1.2.1.dist-info/RECORD,,

{memorymanagement-1.1.5.dist-info → memorymanagement-1.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

memorymanagement-1.1.5.dist-info/RECORD

@@ -1,11 +0,0 @@
-memorymanagement/__init__.py,sha256=Clyt9uUH0DZW36BdmWCMYNg4R2uLYYsSdsn1UgeLSJs,816
-memorymanagement/cleaning/__init__.py,sha256=zC6dWTCTP6b-E3_Q7L45i2ZK_5DrVBbjzKT2AFuXdJk,1359
-memorymanagement/cleaning/core.py,sha256=bmcGhuMYk73dyZ_06Gccli9FOOq7IQ-zH7L3hm62_yg,6903
-memorymanagement/pointers/__init__.py,sha256=MmQnt8KtC2GTHuc-JIypjeyc_iWHJsQTvQdwZPilF34,734
-memorymanagement/pointers/core.py,sha256=aMttcolo_IruqtwhIbKsD1Ygu4b7NJN-pRQURIBLC-o,11969
-memorymanagement/pointers/decorators.py,sha256=NDMlexU6s123jPU0Tqny8HkMdtPsfwrzVAgjCAYpy4A,2869
-memorymanagement-1.1.5.dist-info/licenses/LICENSE,sha256=oomqnX6WpwczxhGg1lDAUrS13YL-0NFIpomyReHWgKo,1098
-memorymanagement-1.1.5.dist-info/METADATA,sha256=__aPUWRYHvzKWWBX7_nsY2W6iMR5rOhGS5RtmOo_yr8,4941
-memorymanagement-1.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-memorymanagement-1.1.5.dist-info/top_level.txt,sha256=7SwrpC3BY9Cm6sqwu082DJE5SteRBira0LGqziTO7eQ,17
-memorymanagement-1.1.5.dist-info/RECORD,,