listclasses 1.0.0__py3-none-any.whl

listclasses/__init__.py

@@ -0,0 +1 @@
+from .main import listclass

listclasses/main.py

@@ -0,0 +1,201 @@
+from copy import copy, deepcopy
+import types
+from typing import Union, get_args, get_origin
+
+def _type(something):
+    return type(something)
+
+
+def listclass(cls = None, *, len: int = 0, frozen: bool = False, type: type = any):
+    """
+    A listclass decorator
+
+    use case:
+
+    @listclass
+    class MyList:
+        ...
+
+    :param len: length of a listclass, 0 means that the length is dynamic
+    :param frozen: bool, is the class mutable
+    :param type: type of values, defaults to any
+    """
+
+
+    def wraps(cls):
+        original_init = getattr(cls, '__init__', None)
+        def new_init(self, *args, **kwargs):
+            if args.__len__() == len or len == 0:
+                if args.__len__() == len or len == 0:
+                    for i in range(args.__len__()):
+                        # Check if the allowed type is a modern Union (int | str) or legacy typing.Union
+                        is_union = isinstance(type, types.UnionType) or get_origin(type) is Union
+
+                        if is_union:
+                            allowed_types = get_args(type)
+                            if not isinstance(args[i], allowed_types):
+                                type_names = " | ".join(t.__name__ for t in allowed_types)
+                                got_name = _type(args[i]).__name__
+                                raise TypeError(f'Incorrect type: expected: {type_names} got: {got_name}')
+                        else:
+                            if (not isinstance(args[i], type)) and (type != any):
+                                expected_name = type.__name__ if hasattr(type, '__name__') else str(type)
+                                got_name = _type(args[i]).__name__
+                                raise TypeError(f'Incorrect type: expected: {expected_name} got: {got_name}')
+                    self._items = [*args]
+            elif args.__len__() > len:
+                raise ValueError(f'Too many items: expected: {len} got: {args.__len__()}')
+            elif args.__len__() < len:
+                raise ValueError(f'Too few items: expected: {len} got: {args.__len__()}')
+            original_init(self, **kwargs)
+
+        def new_repr(self):
+            items = [str(item) for item in self._items]
+            return f"{cls.__name__}({', '.join(items)})"
+
+        def new_setitem(self, key, value):
+            if frozen:
+                raise TypeError(f"'{cls.__name__}' object does not support item assignment")
+            # Check if the allowed type is a modern Union (int | str) or legacy typing.Union
+            is_union = isinstance(type, types.UnionType) or get_origin(type) is Union
+
+            if is_union:
+                allowed_types = get_args(type)
+                if not isinstance(args[i], allowed_types):
+                    type_names = " | ".join(t.__name__ for t in allowed_types)
+                    got_name = _type(args[i]).__name__
+                    raise TypeError(f'Incorrect type: expected: {type_names} got: {got_name}')
+            else:
+                if (not isinstance(args[i], type)) and (type != any):
+                    expected_name = type.__name__ if hasattr(type, '__name__') else str(type)
+                    got_name = _type(args[i]).__name__
+                    raise TypeError(f'Incorrect type: expected: {expected_name} got: {got_name}')
+            self._items[key] = value
+
+        def new_copy(self):
+            new_instance = cls.__new__(cls)
+            new_instance.__dict__.update(self.__dict__)
+            new_instance._items = copy(self._items)
+            return new_instance
+
+        def new_deepcopy(self, memo):
+            new_instance = cls.__new__(cls)
+            memo[id(self)] = new_instance
+            for k, v in self.__dict__.items():
+                new_instance.__dict__[k] = deepcopy(v, memo)
+            return new_instance
+
+        def print_dotted(self) -> None:
+            """
+            Prints a list in a format:
+                · list[0]\n
+                · list[1]\n
+                · list[2]
+            """
+            for item in self._items:
+                print('·', item)
+
+        def print_numbered(self) -> None:
+            """
+            Prints a list in a format:
+                1. list[0]
+                2. list[1]
+                3. list[2]
+            """
+            for i in range(self.__len__()):
+                print(str(i + 1) + ".", self[i])
+
+        def new_eq(self, other):
+            if not isinstance(other, cls):
+                return NotImplemented
+            return self._items == other._items
+
+        def new_ne(self, other):
+            if not isinstance(other, cls):
+                return NotImplemented
+            return self._items != other._items
+
+        def new_add(self, other):
+            if isinstance(other, cls):
+                items_to_add = other._items
+            elif hasattr(other, '__iter__'):
+                items_to_add = other
+            else:
+                return NotImplemented
+
+            # Tworzenie nowej instancji bez ponownego wywoływania __init__
+            new_instance = cls.__new__(cls)
+            new_instance.__dict__.update(copy.deepcopy(self.__dict__))
+            new_instance._items = self._items + list(items_to_add)
+            return new_instance
+
+        def new_iadd(self, other):
+            if isinstance(other, cls):
+                self._items.extend(other._items)
+            elif hasattr(other, '__iter__'):
+                self._items.extend(other)
+            else:
+                return NotImplemented
+            # Check if the allowed type is a modern Union (int | str) or legacy typing.Union
+            is_union = isinstance(type, types.UnionType) or get_origin(type) is Union
+            if is_union:
+                allowed_types = get_args(type)
+                if not isinstance(args[i], allowed_types):
+                    type_names = " | ".join(t.__name__ for t in allowed_types)
+                    got_name = _type(args[i]).__name__
+                    raise TypeError(f'Incorrect type: expected: {type_names} got: {got_name}')
+            else:
+                if (not isinstance(args[i], type)) and (type != any):
+                    expected_name = type.__name__ if hasattr(type, '__name__') else str(type)
+                    got_name = _type(args[i]).__name__
+                    raise TypeError(f'Incorrect type: expected: {expected_name} got: {got_name}')
+            return self
+
+        def new_class_getitem(cls, params):
+            return types.GenericAlias(cls, params)
+
+
+        cls.__init__ = new_init
+        cls.__repr__ = new_repr
+        cls.__setitem__ = new_setitem
+        cls.__eq__ = new_eq
+        cls.__ne__ = new_ne
+        cls.__class_getitem__ = new_class_getitem
+
+
+        cls.print_dotted = print_dotted
+        cls.print_numbered = print_numbered
+
+        if not frozen:
+            if len == 0:
+                cls.append = lambda self, item: self._items.append(item)
+                cls.pop = lambda self, index=-1: self._items.pop(index)
+                cls.clear = lambda self: self._items.clear()
+                cls.insert = lambda self, index, item: self._items.insert(index, item)
+                cls.__iadd__ = new_iadd
+                cls.__delitem__ = lambda self, index: self._items.__delitem__(index)
+            cls.sort = lambda self, *args, **kwargs: self._items.sort(*args, **kwargs)
+            cls.reverse = lambda self: self._items.reverse()
+        cls.__add__ = new_add
+        cls.__copy__ = new_copy
+        cls.__deepcopy__ = new_deepcopy
+        cls.count = lambda self, item: self._items.count(item)
+        cls.index = lambda self, item, *args: self._items.index(item, *args)
+        cls.__contains__ = lambda self, item: item in self._items
+        cls.contains = cls.__contains__
+
+
+        cls.__len__ = lambda self: self._items.__len__()
+        cls.__getitem__ = lambda self, index: self._items[index]
+        cls.__iter__ = lambda self: iter(self._items)
+
+
+        return cls
+
+
+    # See if we're being called as @listclass or @listclass().
+    if cls is None:
+        # We're called with parens.
+        return wraps
+    # We're called as @listclass without parens.
+    return wraps(cls)

listclasses-1.0.0.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: listclasses
+Version: 1.0.0
+Summary: A simple decorator to make custom sequence types
+Description-Content-Type: text/markdown
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: summary
+
+# listclasses
+A Python library providing a @listclass decorator that transforms standard classes into powerful, 
+type-safe, and highly customizable custom sequence types
+
+# Features:
+
+· Type Safety: Enforce strict data types for sequence items
+· Length Constraints: Define fixed-size or dynamic sequences
+· Immutability: Easily create read-only (frozen) collections
+· Rich API: Seamlessly integrates with built-in functions (len(), repr(), iteration, slicing)
+· Copy Support: Native support for shallow and deep copying
+· Pretty Printing: Built-in methods for clean text formatting out of the box
+· Installation: Add the listclass decorator code directly to your project
+
+```python
+from listclasses import listclass
+```
+
+# Basic Usage
+
+```python
+from listclasses import listclass
+
+@listclass
+class Inventory:
+    pass
+
+# Create an instance with initial items
+items = Inventory("Sword", "Shield", "Potion")
+
+print(items)          # Output: Inventory(Sword, Shield, Potion)
+print(items[0])       # Output: Sword
+print(len(items))     # Output: 3
+```
+
+# Advanced Configuration
+
+The @listclass decorator accepts configuration parameters to restrict container behavior
+
+## Enforcing Strict Types
+
+```python
+@listclass(type=int)
+class IntegerList:
+    pass
+
+# Works perfectly
+numbers = IntegerList(1, 2, 3)
+
+# Raises TypeError: Incorrect type: expected: int got: str
+numbers = IntegerList(1, "two", 3)
+```
+
+## Enforcing more than one type
+
+```python
+@listclass(type=int | None)
+class List:
+    pass
+
+# Works perfectly
+numbers_and_None = List(1, 2, 3, None)
+
+# Raises TypeError: Incorrect type: expected: int | None got: str
+numbers_and_None = List(1, "two", 3)
+```
+
+## Setting Fixed Lengths
+
+```python
+@listclass(len=2)
+class Coordinates:
+    pass
+
+# Works perfectly
+point = Coordinates(10, 20)
+
+# Raises ValueError: Too many items: expected: 2 got: 3
+point = Coordinates(10, 20, 30)
+```
+
+## Creating Frozen (Immutable) Lists
+
+```python
+@listclass(frozen=True)
+class ReadOnlyData:
+    pass
+
+data = ReadOnlyData("A", "B")
+
+# Raises TypeError: 'ReadOnlyData' object does not support item assignment
+data[0] = "Z"
+```
+
+## Built-in Formatting
+listclasses comes with utility methods to print your items cleanly.
+
+```python
+@listclass
+class TodoList:
+    pass
+
+todos = TodoList("Buy milk", "Clean room", "Code Python")
+
+# Dotted list format
+todos.print_dotted()
+# Output:
+# ·  Buy milk
+# ·  Clean room
+# ·  Code Python
+
+# Numbered list format
+todos.print_numbered()
+# Output:
+# 1. Buy milk
+# 2. Clean room
+# 3. Code Python
+```
+# API Reference
+
+## Decorator Arguments
+
+| Argument | Type | Default |                            Description                            |
+|:--------:|:----:|:-------:|:-----------------------------------------------------------------:|
+|   len    | int  |    0    |     Expected length of the collection. 0 means dynamic size.      |
+|   type   | type |   any   | Restricts elements to a single or multiple explicit python types. |
+|  frozen  | bool |  False  |    If True, prevents item assignment and mutating operations.     |
+
+## Available Methods
+
+Depending on configuration (frozen and len), instances support standard list operations:
+
+· Access: __getitem__, __iter__, __contains__, count(), index()
+· Mutation (Dynamic only): append(), pop(), clear(), insert(), __delitem__
+· Ordering (Mutable only): sort(), reverse()
+· Math: __add__ (+), __iadd__ (+=)

listclasses-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+listclasses/__init__.py,sha256=3b-srK06956nkAbYn-lTUM8_wai0qOk4XnY2qfSl5lw,27
+listclasses/main.py,sha256=AH4hMIjOhDLeWxGk1RS_4oq7UBsp5D1bAT1NYH4osgg,8403
+listclasses-1.0.0.dist-info/METADATA,sha256=PlbeSThXPJduGomO3lc2Qn-DPxTKhLMYKG5_kKCIfAc,3791
+listclasses-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+listclasses-1.0.0.dist-info/top_level.txt,sha256=CR2eZwcQk7brVXF6mDJ37221xXIE8VHMozrk0d1UTRY,12
+listclasses-1.0.0.dist-info/RECORD,,

listclasses-1.0.0.dist-info/WHEEL

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

listclasses-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+listclasses