bettergroups 0.1.0__tar.gz

bettergroups-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: bettergroups
+Version: 0.1.0
+Summary: Lightweight enhanced list and dictionary utilities.
+Author: Finni
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# bettergroups
+
+Lightweight enhanced list and dictionary utilities for Python.
+
+## Features
+
+- BetterLists
+- BetterDicts
+- groupby
+- chunk
+- Lockable structures
+- Map / Filter helpers
+
+## Installation
+
+pip install bettergroups

bettergroups-0.1.0/README.md

@@ -0,0 +1,16 @@
+# bettergroups
+
+Lightweight enhanced list and dictionary utilities for Python.
+
+## Features
+
+- BetterLists
+- BetterDicts
+- groupby
+- chunk
+- Lockable structures
+- Map / Filter helpers
+
+## Installation
+
+pip install bettergroups

bettergroups-0.1.0/bettergroups.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: bettergroups
+Version: 0.1.0
+Summary: Lightweight enhanced list and dictionary utilities.
+Author: Finni
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# bettergroups
+
+Lightweight enhanced list and dictionary utilities for Python.
+
+## Features
+
+- BetterLists
+- BetterDicts
+- groupby
+- chunk
+- Lockable structures
+- Map / Filter helpers
+
+## Installation
+
+pip install bettergroups

bettergroups-0.1.0/bettergroups.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+README.md
+bettergroups.py
+pyproject.toml
+bettergroups.egg-info/PKG-INFO
+bettergroups.egg-info/SOURCES.txt
+bettergroups.egg-info/dependency_links.txt
+bettergroups.egg-info/top_level.txt

bettergroups-0.1.0/bettergroups.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bettergroups-0.1.0/bettergroups.egg-info/top_level.txt

@@ -0,0 +1 @@
+bettergroups

bettergroups-0.1.0/bettergroups.py

@@ -0,0 +1,295 @@
+import collections as clc # if this fails your cooked
+
+# btw 300 lines ain't that bad
+
+# made by Finni
+
+__all__ = ['BetterLists', 'Groups', 'BetterDicts', 'groupby', 'chunk']
+
+__version__ = "0.1.0"
+
+def groupby(iterable, key_func):
+        result = {}
+        for item in iterable:
+            key = key_func(item)
+            result.setdefault(key, []).append(item)
+        return result
+
+def chunk(iterable, size):
+    return [iterable[i:i+size] for i in range(0, len(iterable), size)]
+
+class BetterDicts:
+    def __init__(self, d=None):
+        if d is None: # check if input was made, if not keep the list empty
+            self.data = {}
+        else: # if there is input for the list make the input
+            self.data = dict(d)
+        self.locked = False
+        # self.original = self.data
+
+    def add(self, name, value):
+        '''add to a dictionary'''
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        self.data[name] = value
+
+    def remove(self, name):
+        '''remove from a dictionary'''
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        del self.data[name]
+
+    def pop(self, key, default=None):
+        '''pop something from a dictionary'''
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        return self.data.pop(key, default)
+
+    def invert(self):
+        '''returns an inverted version of itself'''
+        return BetterDicts({v: k for k, v in self.data.items()})
+
+    def dupe(self):
+        '''duplicate a dictionary'''
+        return BetterDicts(self.data.copy())
+
+    def combine(self, other):
+        '''combine two dictionarys'''
+        if isinstance(other, BetterDicts):
+            other = other.data
+        elif not isinstance(other, dict):
+            raise TypeError("Can only combine with dict or BetterDicts")
+
+        new_data = self.data.copy()
+
+        for key, value in other.items():
+            if key in new_data:
+                if isinstance(new_data[key], list):
+                    new_data[key].append(value)
+                else:
+                    new_data[key] = [new_data[key], value]
+            else:
+                new_data[key] = value
+
+        return BetterDicts(new_data)
+    
+    def get(self, keyname):
+        '''return the value of a key'''
+        return self.data.get(keyname)
+    
+    # def _default(self):
+        # '''Reset a dictionary to the first time it was made'''
+        # self.data.clear()
+        # self.data = self.original
+
+    def empty(self):
+        '''Empty everything inside a dictionary'''
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        self.data.clear()
+
+    def copy(self):
+        '''return a copy of itself'''
+        return BetterDicts(self.data.copy())
+
+    def map_values(self, func):
+        return BetterDicts({k: func(v) for k, v in self.data.items()})
+
+    def filter(self, func):
+        return BetterDicts({k: v for k, v in self.data.items() if func(k, v)})
+
+    def keys(self):
+        return self.data.keys()
+
+    def values(self):
+        return self.data.values()
+
+    def items(self):
+        return self.data.items()
+
+    def lock(self):
+        '''make an object uneditable'''
+        self.locked = True
+
+    def unlock(self):
+        '''make an object editable'''
+        self.locked = False
+
+    # not gonna go over the dunder methods
+    def __str__(self):
+        return str(self.data)
+    def __repr__(self):
+        return f"BetterDicts(data:{self.data},locked:{self.locked})"
+    def __len__(self):
+        return len(self.data)
+    def __getitem__(self, key):
+        return self.data[key]
+    def __setitem__(self, key, value):
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        self.data[key] = value
+    def __delitem__(self, key):
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        del self.data[key]
+    def __contains__(self, key):
+        return key in self.data
+    def __iter__(self):
+        return iter(self.data)
+    def __eq__(self, other):
+        if isinstance(other, BetterDicts):
+            return self.data == other.data
+        if isinstance(other, dict):
+            return self.data == other
+        return False
+    def __bool__(self):
+        return bool(self.data)
+    def __or__(self, other):
+        return self.combine(other)
+
+class BetterLists:
+    def __init__(self, d=None):
+        if d is None: # check if input was made, if not keep the list empty
+            self.data = []
+        else: # if there is input for the list make the input
+            self.data = list(d)
+        self.locked = False
+    def add(self, d):
+        '''add something to a list'''
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        self.data.append(d)
+
+    def remove(self,d):
+        '''remove something from a list'''
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        self.data.remove(d)
+
+    def dupe(self):
+        '''copy a list to a new list'''
+        return BetterLists(self.data.copy())
+
+    def sorted(self, reverse=False):
+        '''return a sorted version of a list'''
+        return BetterLists(sorted(self.data, reverse=reverse))
+    
+    def combine(self, other):
+        '''return a list combined with another list'''
+        if isinstance(other, BetterLists):
+            return BetterLists(self.data + other.data)
+        raise TypeError("Must combine with another BetterLists")
+    
+    def insert(self,d,pos):
+        '''insert data to a position of a list'''
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        self.data.insert(pos,d)
+
+    def count(self, char):
+        '''count the instances of a character'''
+        return self.data.count(char)
+
+    def countinfo(self, char):
+        '''count the instances of a character with extra info'''
+        return f'character: {char}, shows {self.data.count(char)} times' 
+
+    def showtype(self, t):
+        '''return all instances of a certant type in a list'''
+        returns = []
+
+        if not isinstance(t, type): # check if t is a type
+            raise TypeError('Expected a type')
+
+        for i in range(len(self.data)):
+            if isinstance(self.data[i], t):
+                returns.append(self.data[i])
+
+        return returns
+
+    def showstrs(self):
+        '''return all the strings inside of a list'''
+        return self.showtype(str) 
+    
+    def showints(self):
+        '''return all the ints inside of a list'''
+        return self.showtype(int)
+
+    def showlists(self):
+        '''return all the lists inside of a list'''
+        return self.showtype(list)
+    
+    def showdicts(self):
+        '''return all the dicts inside of a list'''
+        return self.showtype(dict)
+    
+    def countall(self):
+        '''count everything inside of a list'''
+        return clc.Counter(self.data)
+    
+    def empty(self):
+        '''clear everything inside a list'''
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        self.data.clear()
+
+    def deldupes(self):
+        '''Deletes all duplicates in a list'''
+        if not self.locked:
+            return BetterLists(dict.fromkeys(self.data)) # dictionarys can't have duplicate keys
+        raise RuntimeError("Object is locked")
+
+    def extend(self, other):
+        '''add elements from an iterable'''
+        if self.locked:
+            raise RuntimeError("Object is locked")
+        if isinstance(other, BetterLists):
+            other = other.data
+        if isinstance(other, BetterDicts):
+            other = other.data
+        self.data.extend(other)
+
+    def filter(self, func):
+        return BetterLists([x for x in self.data if func(x)])
+
+    def map(self, func):
+        return BetterLists([func(x) for x in self.data])
+
+    def first(self):
+        '''return the first item in a list'''
+        return self.data[0] if self.data else None
+
+    def last(self):
+        '''return the last item in a list'''
+        return self.data[-1] if self.data else None
+
+    def lock(self):
+        '''make an object uneditable'''
+        self.locked = True
+    
+    def unlock(self):
+        '''make an object editable'''
+        self.locked = False
+
+    # dunder methods im not gonna explain
+    def __str__(self):
+        return f'{self.data}'
+    def __len__(self):
+        return len(self.data)
+    def __getitem__(self, index):
+        return self.data[index]
+    def __iter__(self):
+        return iter(self.data)
+    def __contains__(self, item):
+        return item in self.data
+    def __repr__(self):
+        return f"BetterLists(data:{self.data},locked:{self.locked})"
+    def __bool__(self):
+        return bool(self.data)
+    def __add__(self, other):
+        if isinstance(other, BetterLists):
+            return BetterLists(self.data + other.data)
+        raise TypeError
+
+if __name__ == "__main__":
+    pass

bettergroups-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bettergroups"
+version = "0.1.0"
+description = "Lightweight enhanced list and dictionary utilities."
+readme = "README.md"
+requires-python = ">=3.7"
+authors = [
+  {name = "Finni"}
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]

bettergroups-0.1.0/setup.cfg

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