obj-tag-group 0.1.0__tar.gz

obj_tag_group-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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.

obj_tag_group-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: obj_tag_group
+Version: 0.1.0
+Summary: A flexible, searchable registry that allows you to attach text tags to almost any arbitrary Python object.
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# obj_tag_group
+
+A flexible, searchable registry that allows you to attach text tags to almost any arbitrary Python object.
+
+Objects are indexed by their serialized content, allowing for quick filtering of items using regular expression searches on their associated tags.
+- For this reason, this package will fail to work on objects that cannot be serialized (such as lambda functions).
+- The tags work by creating a full copy of the object in memory, and will not reflect any future changes made to the object/s.
+
+Note: This code is very rough, unoptimized, and prone to errors. Use at your own risk.
+
+
+## Features
+
+- Add / remove tags to most Python objects, even unhashable ones such as dictionaries and lists, as well as custom classes
+- Filter and retrieve objects using regular expression queries
+- Save the entire tagged registry to disk and load it back later.
+
+
+## Installation
+
+```bash
+pip install obj_tag_group
+```

obj_tag_group-0.1.0/README.md

@@ -0,0 +1,23 @@
+# obj_tag_group
+
+A flexible, searchable registry that allows you to attach text tags to almost any arbitrary Python object.
+
+Objects are indexed by their serialized content, allowing for quick filtering of items using regular expression searches on their associated tags.
+- For this reason, this package will fail to work on objects that cannot be serialized (such as lambda functions).
+- The tags work by creating a full copy of the object in memory, and will not reflect any future changes made to the object/s.
+
+Note: This code is very rough, unoptimized, and prone to errors. Use at your own risk.
+
+
+## Features
+
+- Add / remove tags to most Python objects, even unhashable ones such as dictionaries and lists, as well as custom classes
+- Filter and retrieve objects using regular expression queries
+- Save the entire tagged registry to disk and load it back later.
+
+
+## Installation
+
+```bash
+pip install obj_tag_group
+```

obj_tag_group-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "obj_tag_group"
+version = "0.1.0"
+description = "A flexible, searchable registry that allows you to attach text tags to almost any arbitrary Python object."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/obj_tag_group"]

obj_tag_group-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

obj_tag_group-0.1.0/src/obj_tag_group/__init__.py

@@ -0,0 +1 @@
+from .reg import Tag_Group

obj_tag_group-0.1.0/src/obj_tag_group/reg.py

@@ -0,0 +1,108 @@
+import pickle
+import re
+import hashlib
+from collections import defaultdict
+
+class Tag_Group:
+    def __init__(self):
+        self.tags = defaultdict(set)
+        self.hashes = defaultdict(set)
+        self.unhash = {}
+
+    def hash_item(self, obj):
+        """Uses pickle to create a key for an item"""
+        try:
+            pickled_data = pickle.dumps(obj, protocol=pickle.HIGHEST_PROTOCOL)
+            item_hash = hashlib.sha256(pickled_data).hexdigest()
+            return item_hash, pickled_data
+        except (pickle.PicklingError, AttributeError, TypeError):
+            raise TypeError(f"""Object of type {type(obj).__name__} cannot be serialized with pickle.
+           Ensure it doesn't contain unpicklable elements like open files or lambdas.""")
+
+    def tag_object(self, obj, tags):
+        """
+        Associates one or more tags with an arbitrary object.
+        'tags' can be a single string or an iterable of strings.
+        """
+        key, pickled_data = self.hash_item(obj)
+        self.unhash[key] = pickled_data
+        
+        if isinstance(tags, str):
+            tags = (tags,)
+        
+        for tag in tags:
+            self.tags[key].add(tag)
+            self.hashes[tag].add(key)
+    
+    def untag_object(self, obj, tags = None):
+        """
+        Removes tags from an object.
+        
+        If 'tags' is provided (string or iterable of strings), only those tags will be removed.
+        If no tags are provided, completely removes an object and all its associated tags from tracking.
+        """
+        key, _ = self.hash_item(obj)
+        if key not in self.unhash:
+            return
+        
+        if tags is not None:
+            if isinstance(tags, str):
+                tags = (tags,)
+            
+            for tag in tags:
+                if tag in self.tags[key]:
+                    self.tags[key].discard(tag)
+                if tag in self.hashes and key in self.hashes[tag]:
+                    self.hashes[tag].discard(key)
+                    if not self.hashes[tag]:
+                        del self.hashes[tag]
+            
+            if not self.tags[key]:
+                del self.tags[key]
+                del self.unhash[key]
+        
+        else:
+            item_tags = self.tags.pop(key, set())
+            for tag in item_tags:
+                if key in self.hashes[tag]:
+                    self.hashes[tag].discard(key)
+                if not self.hashes[tag]:
+                    del self.hashes[tag]
+            del self.unhash[key]
+
+    def get_tags(self, obj):
+        """Returns the set of tags associated with a specific object."""
+        obj_key, _ = self.hash_item(obj)
+        return self.tags.get(obj_key, set())
+
+    def filter_tags(self, pattern, flags=0):
+        """
+        Filters and returns a list of objects where at least one 
+        associated tag matches the provided regular expression.
+        """
+        compiled_search = re.compile(pattern, flags).search
+        matches = set()
+
+        for tag, hashset in self.hashes.items():
+            if compiled_search(tag):
+                matches.update(hashset)
+
+        return [pickle.loads(self.unhash[hashed_item]) for hashed_item in matches]
+    
+    def save_to_file(self, filename):
+        """Serializes the entire Tag_Group registry state to a file."""
+        with open(filename, 'wb') as f:
+            pickle.dump(self, f, protocol=pickle.HIGHEST_PROTOCOL)
+            
+    @classmethod
+    def load_from_file(cls, filename):
+        """
+        Loads and returns a saved Tag_Group instance from a file.
+        If the file doesn't exist, returns a fresh, empty Tag_Group instance.
+        """
+        try:
+            with open(filename, 'rb') as f:
+                return pickle.load(f)
+        except FileNotFoundError:
+            print(f"File '{filename}' not found. Initializing a new registry.")
+            return cls()

obj_tag_group-0.1.0/src/obj_tag_group.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: obj_tag_group
+Version: 0.1.0
+Summary: A flexible, searchable registry that allows you to attach text tags to almost any arbitrary Python object.
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# obj_tag_group
+
+A flexible, searchable registry that allows you to attach text tags to almost any arbitrary Python object.
+
+Objects are indexed by their serialized content, allowing for quick filtering of items using regular expression searches on their associated tags.
+- For this reason, this package will fail to work on objects that cannot be serialized (such as lambda functions).
+- The tags work by creating a full copy of the object in memory, and will not reflect any future changes made to the object/s.
+
+Note: This code is very rough, unoptimized, and prone to errors. Use at your own risk.
+
+
+## Features
+
+- Add / remove tags to most Python objects, even unhashable ones such as dictionaries and lists, as well as custom classes
+- Filter and retrieve objects using regular expression queries
+- Save the entire tagged registry to disk and load it back later.
+
+
+## Installation
+
+```bash
+pip install obj_tag_group
+```

obj_tag_group-0.1.0/src/obj_tag_group.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/obj_tag_group/__init__.py
+src/obj_tag_group/reg.py
+src/obj_tag_group.egg-info/PKG-INFO
+src/obj_tag_group.egg-info/SOURCES.txt
+src/obj_tag_group.egg-info/dependency_links.txt
+src/obj_tag_group.egg-info/top_level.txt

obj_tag_group-0.1.0/src/obj_tag_group.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

obj_tag_group-0.1.0/src/obj_tag_group.egg-info/top_level.txt

@@ -0,0 +1 @@
+obj_tag_group