memorymanagement 1.0.0__tar.gz → 1.1.1__tar.gz

{memorymanagement-1.0.0 → memorymanagement-1.1.1}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Ricardo Werner Rivas
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 Ricardo Werner Rivas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{memorymanagement-1.0.0 → memorymanagement-1.1.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: memorymanagement
-Version: 1.0.0
+Version: 1.1.1
 Summary: Adds support for memory management
-Home-page: https://github.com/Ricardo-Werner-Rivas/python-memory-management/tree/main
+Home-page: https://github.com/Ricardo-Werner-Rivas/memorymanagement/tree/PyPI
 Author: Ricardo Werner Rivas
 Author-email: ricardowernerrivas@gmail.com
 License: MIT
-Project-URL: Issues Page, https://github.com/Ricardo-Werner-Rivas/python-memory-management/issues
-Project-URL: Repository, https://github.com/Ricardo-Werner-Rivas/python-memory-management
+Project-URL: Bug Tracker, https://github.com/Ricardo-Werner-Rivas/memorymanagement/issues
+Project-URL: Repository, https://github.com/Ricardo-Werner-Rivas/memorymanagement
 Classifier: Programming Language :: Python
 Classifier: Operating System :: Microsoft :: Windows
 Description-Content-Type: text/markdown
@@ -16,6 +16,9 @@ Dynamic: license-file
 
 # `memorymanagement`
 Provides memory management support.
+
+The only Python implementation currently supported is the one made by the **CPython** team.
+The rest remain untested.
 ## Modules
 ### `cleaning`
 Provides the class `Cleaner`, which allows you to flag references stored in memory to eventually erase them.
@@ -23,19 +26,14 @@ It is also possible to modify the list of flagged references through its methods
 ### `pointers`
 Provides a safe implementation of pointers for Python.
 #### Class `Pointer`
-The pointer itself. Imitates the behaviour of C pointers. This pointer points to a reference, not to an object stored in memory.
+The pointer itself. Imitates the behaviour of C pointers. `Pointer` points to a **reference**, not to an object stored in memory.
 #### Decorator `pointerize`
 Allows functions to receive pointers instead of values.
 ## Installation
-You can install the `memorymanager` package from PyPI as follows:
-```bash
+You can install the `memorymanagement` package from **PyPI** as follows:
+```powershell
 pip install memorymanagement
 ```
-You can also install the `memorymanager` package (Test PyPI versión of `memorymanager`) from TestPyPI as follows:
-```bash
-pip install --index-url https://test.pypi.org/simple/ memorymanager
-```
-For TestPyPI versión, `--no-deps` option is not needed because it has no dependencies.
 ## How to use
 ### Class `Cleaner`
 ```py
@@ -160,3 +158,23 @@ Value: 10
 Value: 20
 
 ```
+## Contribution
+To contribute to this project fork this repository and clone your fork. Pull requests will be revised by the owner before being accepted or rejected.
+
+There are two branches:
+* **PyPI**: the main branch, for releases.
+* **TestPyPI**: for pre-releases or development versions.
+
+Pull requests from TestPyPI to PyPI will only be done by the owner when a new release is ready.
+
+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.

{memorymanagement-1.0.0 → memorymanagement-1.1.1}/README.md

@@ -1,5 +1,8 @@
 # `memorymanagement`
 Provides memory management support.
+
+The only Python implementation currently supported is the one made by the **CPython** team.
+The rest remain untested.
 ## Modules
 ### `cleaning`
 Provides the class `Cleaner`, which allows you to flag references stored in memory to eventually erase them.
@@ -7,19 +10,14 @@ It is also possible to modify the list of flagged references through its methods
 ### `pointers`
 Provides a safe implementation of pointers for Python.
 #### Class `Pointer`
-The pointer itself. Imitates the behaviour of C pointers. This pointer points to a reference, not to an object stored in memory.
+The pointer itself. Imitates the behaviour of C pointers. `Pointer` points to a **reference**, not to an object stored in memory.
 #### Decorator `pointerize`
 Allows functions to receive pointers instead of values.
 ## Installation
-You can install the `memorymanager` package from PyPI as follows:
-```bash
+You can install the `memorymanagement` package from **PyPI** as follows:
+```powershell
 pip install memorymanagement
 ```
-You can also install the `memorymanager` package (Test PyPI versión of `memorymanager`) from TestPyPI as follows:
-```bash
-pip install --index-url https://test.pypi.org/simple/ memorymanager
-```
-For TestPyPI versión, `--no-deps` option is not needed because it has no dependencies.
 ## How to use
 ### Class `Cleaner`
 ```py
@@ -144,3 +142,23 @@ Value: 10
 Value: 20
 
 ```
+## Contribution
+To contribute to this project fork this repository and clone your fork. Pull requests will be revised by the owner before being accepted or rejected.
+
+There are two branches:
+* **PyPI**: the main branch, for releases.
+* **TestPyPI**: for pre-releases or development versions.
+
+Pull requests from TestPyPI to PyPI will only be done by the owner when a new release is ready.
+
+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.

memorymanagement-1.1.1/memorymanagement/cleaning/__init__.py

@@ -0,0 +1,41 @@
+"""
+# Module `cleaning`
+Implements the class `Cleaner` to keep track of the references and erase it easily.
+## Overview
+Initialize a `Cleaner` object:
+```
+# Default arguments' values
+cleaner=Cleaner(
+    not_delete:list[str]=list(vars(modules["main"])), # List of global variables at that moment (modules comes from sys library)
+    excluded:list[str]=[], # Empty list to be modified later if you need
+    flagged:list[str]=[] # List of references to undo
+)
+```
+Now `cleaner` has the following attributes:
+```
+cleaner._not_delete=list(vars(modules["main"])) # At initialization moment
+cleaner._excluded=[] # Wasn't asked to exclude any reference.
+cleaner._flagged=[] # Wasn't asked to include any reference.
+```
+To automatically include all the new references, use the `.update()` method:
+```
+x=10
+y="Hello world"
+z=f"Hello Python for time number {x}"
+# Default arguments' values
+cleaner.update(
+    exclude:str|list[str]|tuple[str]|None=None, # Excludes flagged or yet not created references from the process
+    include:str|list[str]|tuple[str]|None=None # Includes references into the process
+)
+print(cleaner)
+```
+The cell above prints (via `__str__` method):
+```
+Flagged: ["x","y","z"]
+
+Excluded: []
+
+Not delete: <list(vars(modules["main"]))> # Unchanged since initialization
+"""
+# Imports
+from .core import Cleaner

memorymanagement-1.0.0/memorymanagement/cleaning/cleaning.py → memorymanagement-1.1.1/memorymanagement/cleaning/core.py

@@ -128,4 +128,15 @@ class Cleaner:
             if var in list(vars(modules["__main__"])):
                 del vars(modules["__main__"])[var]
         self._flagged.clear()
-        return
+        return
+    def __str__(self):
+        string=f"""
+        Flagged: {self.flagged}
+        
+        Excluded: {self.excluded}
+        
+        Not delete: {self.not_delete}
+        """
+        return string
+    def __repr__(self):
+        return f"{self.__class__.__name__}(flagged={self.flagged})"

memorymanagement-1.1.1/memorymanagement/pointers/__init__.py

@@ -0,0 +1,15 @@
+"""
+# Module `pointers`
+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,
+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"

{memorymanagement-1.0.0 → memorymanagement-1.1.1}/memorymanagement/pointers/core.py

@@ -1,3 +1,16 @@
+#*===============================================================================================================================
+#* LEGEND
+#! Missing
+#? 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
 # Import "TypeVar" and "Generic"
 from typing import TypeVar,Generic
 # Import "modules" from "sys" package
@@ -5,10 +18,9 @@ from sys import modules
 # Import "currentframe" from "inspect" package
 from inspect import currentframe
 
-# Create new generic type
-object_type=TypeVar("object_type")
-# Define the class "Pointer"
-class Pointer(Generic[object_type]):
+#* MAIN CLASS
+# Define the class "Pointer" with generic type
+class Pointer(Generic[TypeVar("Any")]):
     """
     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.
@@ -66,7 +78,6 @@ class Pointer(Generic[object_type]):
         self._value=value
         self._vars_dict=vars_dict
         self._attr=attr
-        name=None
         name=[]
         for key,v in vars_dict.items():
             try:
@@ -90,7 +101,11 @@ class Pointer(Generic[object_type]):
             name=None
         self._name=name
         return
+    
+    #* PROPERTIES
+    # Value
     @property
+    # Getter
     def value(self):
         if self._attr:
             if self._name and self._name not in list(self._vars_dict):
@@ -107,6 +122,7 @@ class Pointer(Generic[object_type]):
                 if self._value is not self._vars_dict[self._name]:
                     self._value=self._vars_dict[self._name]
             return self._value
+    # Setter
     @value.setter
     def value(self,value):
         if self._attr:
@@ -116,6 +132,7 @@ class Pointer(Generic[object_type]):
             if self._name and value is not self._vars_dict[self._name]:
                 self._vars_dict[self._name]=value
         return
+    # Deleter
     @value.deleter
     def value(self):
         if self._attr:
@@ -124,4 +141,187 @@ class Pointer(Generic[object_type]):
             del self._value
             if self._name:
                 del self._vars_dict[self._name]
-        return
+        return
+    
+    #* INDEXATION
+    # Getter
+    def __getitem__(self,index):
+        return self.value[index]
+    # Setter
+    def __setitem__(self,index,value):
+        self.value[index]=value
+        return
+    # Deleter
+    def __delitem__(self,index):
+        del self.value[index]
+        return
+    
+    #* ARITHMETIC OPERATIONS
+    # Addition
+    def __add__(self,value):
+        if isinstance(value,Pointer):
+            return self.value+value.value
+        else:
+            return self.value+value
+    # Difference
+    def __sub__(self,value):
+        if isinstance(value,Pointer):
+            return self.value-value.value
+        else:
+            return self.value-value
+    # Multiplication
+    def __mul__(self,value):
+        if isinstance(value,Pointer):
+            return self.value*value.value
+        else:
+            return self.value*value
+    # Fraction
+    def __truediv__(self,value):
+        if isinstance(value,Pointer):
+            return self.value/value.value
+        else:
+            return self.value/value
+    # Integer division
+    def __floordiv__(self,value):
+        if isinstance(value,Pointer):
+            return self.value//value.value
+        else:
+            return self.value//value
+    # Module
+    def __mod__(self,value):
+        if isinstance(value,Pointer):
+            return self.value%value.value
+        else:
+            return self.value%value
+    # Power
+    def __pow__(self,value):
+        if isinstance(value,Pointer):
+            return self.value**value.value
+        else:
+            return self.value**value
+    
+    #* REFLEXED ARITHMETIC METHODS
+    # Addition
+    def __radd__(self,value):
+        return value+self.value
+    # Difference
+    def __rsub__(self,value):
+        return value-self.value
+    # Multiplication
+    def __rmul__(self,value):
+        return value*self.value
+    # Fraction
+    def __rtruediv__(self,value):
+        return value/self.value
+    # Integer division
+    def __rfloordiv__(self,value):
+        return value//self.value
+    # Module
+    def __rmod__(self,value):
+        return value%self.value
+    # Power
+    def __rpow__(self,value):
+        return value**self.value
+    
+    #* IN-PLACE ARITHMETIC METHODS
+    # Addition
+    def __iadd__(self,value):
+        self.value=self.value+value
+        return self
+    # Difference
+    def __isub__(self,value):
+        self.value=self.value-value
+        return self
+    # Multiplication
+    def __imul__(self,value):
+        self.value=self.value*value
+        return self
+    # Fraction
+    def __itruediv__(self,value):
+        self.value=self.value/value
+        return self
+    # Integer division
+    def __ifloordiv__(self,value):
+        self.value=self.value//value
+        return self
+    # Module
+    def __imod__(self,value):
+        self.value=self.value%value
+        return self
+    def __ipow__(self,value):
+        self.value=self.value**value
+        return self
+    
+    #* COMPARATIVE METHODS
+    # Equality
+    def __eq__(self,value):
+        if isinstance(value,Pointer):
+            return self.value==value.value
+        else:
+            return self.value==value
+    # Inequality
+    def __ne__(self,value):
+        if isinstance(value,Pointer):
+            return self.value!=value.value
+        else:
+            return self.value!=value
+    # Lower than
+    def __lt__(self,value):
+        if isinstance(value,Pointer):
+            return self.value<value.value
+        else:
+            return self.value<value
+    # Lower or equal
+    def __le__(self,value):
+        if isinstance(value,Pointer):
+            return self.value<=value.value
+        else:
+            return self.value<=value
+    # Greater than
+    def __gt__(self,value):
+        if isinstance(value,Pointer):
+            return self.value>value.value
+        else:
+            return self.value>value
+    # Greater or equal
+    def __ge__(self,value):
+        if isinstance(value,Pointer):
+            return self.value>=value.value
+        else:
+            return self.value>=value
+    
+    #* UNARY METHODS
+    # Negative
+    def __neg__(self):
+        return Pointer(-self.value)
+    # Positive
+    def __pos__(self):
+        return Pointer(+self.value)
+    # Absolute value
+    def __abs__(self):
+        return Pointer(abs(self.value))
+    
+    #* LENGTH
+    # Length
+    def __len__(self):
+        return len(self.value)
+    
+    #* TRANSFORMATION METHODS
+    # __int__
+    def __int__(self):
+        return int(self.value)
+    def __float__(self):
+        return float(self.value)
+    def __index__(self):
+        return self.value
+    
+    #* SCREEN
+    # Representation
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.value})"
+    # HTML representation
+    def _repr_html_(self):
+        return f"<p>{self.value}</p>"
+    # Printing
+    def __str__(self):
+        return str(self.value)

{memorymanagement-1.0.0 → memorymanagement-1.1.1}/memorymanagement.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: memorymanagement
-Version: 1.0.0
+Version: 1.1.1
 Summary: Adds support for memory management
-Home-page: https://github.com/Ricardo-Werner-Rivas/python-memory-management/tree/main
+Home-page: https://github.com/Ricardo-Werner-Rivas/memorymanagement/tree/PyPI
 Author: Ricardo Werner Rivas
 Author-email: ricardowernerrivas@gmail.com
 License: MIT
-Project-URL: Issues Page, https://github.com/Ricardo-Werner-Rivas/python-memory-management/issues
-Project-URL: Repository, https://github.com/Ricardo-Werner-Rivas/python-memory-management
+Project-URL: Bug Tracker, https://github.com/Ricardo-Werner-Rivas/memorymanagement/issues
+Project-URL: Repository, https://github.com/Ricardo-Werner-Rivas/memorymanagement
 Classifier: Programming Language :: Python
 Classifier: Operating System :: Microsoft :: Windows
 Description-Content-Type: text/markdown
@@ -16,6 +16,9 @@ Dynamic: license-file
 
 # `memorymanagement`
 Provides memory management support.
+
+The only Python implementation currently supported is the one made by the **CPython** team.
+The rest remain untested.
 ## Modules
 ### `cleaning`
 Provides the class `Cleaner`, which allows you to flag references stored in memory to eventually erase them.
@@ -23,19 +26,14 @@ It is also possible to modify the list of flagged references through its methods
 ### `pointers`
 Provides a safe implementation of pointers for Python.
 #### Class `Pointer`
-The pointer itself. Imitates the behaviour of C pointers. This pointer points to a reference, not to an object stored in memory.
+The pointer itself. Imitates the behaviour of C pointers. `Pointer` points to a **reference**, not to an object stored in memory.
 #### Decorator `pointerize`
 Allows functions to receive pointers instead of values.
 ## Installation
-You can install the `memorymanager` package from PyPI as follows:
-```bash
+You can install the `memorymanagement` package from **PyPI** as follows:
+```powershell
 pip install memorymanagement
 ```
-You can also install the `memorymanager` package (Test PyPI versión of `memorymanager`) from TestPyPI as follows:
-```bash
-pip install --index-url https://test.pypi.org/simple/ memorymanager
-```
-For TestPyPI versión, `--no-deps` option is not needed because it has no dependencies.
 ## How to use
 ### Class `Cleaner`
 ```py
@@ -160,3 +158,23 @@ Value: 10
 Value: 20
 
 ```
+## Contribution
+To contribute to this project fork this repository and clone your fork. Pull requests will be revised by the owner before being accepted or rejected.
+
+There are two branches:
+* **PyPI**: the main branch, for releases.
+* **TestPyPI**: for pre-releases or development versions.
+
+Pull requests from TestPyPI to PyPI will only be done by the owner when a new release is ready.
+
+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.

{memorymanagement-1.0.0 → memorymanagement-1.1.1}/memorymanagement.egg-info/SOURCES.txt

@@ -8,7 +8,7 @@ memorymanagement.egg-info/SOURCES.txt
 memorymanagement.egg-info/dependency_links.txt
 memorymanagement.egg-info/top_level.txt
 memorymanagement/cleaning/__init__.py
-memorymanagement/cleaning/cleaning.py
+memorymanagement/cleaning/core.py
 memorymanagement/pointers/__init__.py
 memorymanagement/pointers/core.py
 memorymanagement/pointers/decorators.py

{memorymanagement-1.0.0 → memorymanagement-1.1.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = memorymanagement
-version = 1.0.0
+version = 1.1.1
 author = Ricardo Werner Rivas
 author_email = ricardowernerrivas@gmail.com
 description = Adds support for memory management
@@ -8,10 +8,10 @@ long_description = file:README.md
 long_description_content_type = text/markdown
 license = MIT
 license_files = LICENSE
-url = https://github.com/Ricardo-Werner-Rivas/python-memory-management/tree/main
+url = https://github.com/Ricardo-Werner-Rivas/memorymanagement/tree/PyPI
 project_urls = 
-	Issues Page=https://github.com/Ricardo-Werner-Rivas/python-memory-management/issues
-	Repository=https://github.com/Ricardo-Werner-Rivas/python-memory-management
+	Bug Tracker=https://github.com/Ricardo-Werner-Rivas/memorymanagement/issues
+	Repository=https://github.com/Ricardo-Werner-Rivas/memorymanagement
 classifiers = 
 	Programming Language :: Python
 	Operating System :: Microsoft :: Windows

memorymanagement-1.0.0/memorymanagement/cleaning/__init__.py

@@ -1,2 +0,0 @@
-# Imports
-from .cleaning import Cleaner

memorymanagement-1.0.0/memorymanagement/pointers/__init__.py

@@ -1,3 +0,0 @@
-# Import from modules
-from .core import Pointer # Class "Pointer"
-from .decorators import pointerize # Decorator "pointerize"