swizzle 2.1.1__py3-none-any.whl → 2.2.1__py3-none-any.whl

swizzle/__init__.py

@@ -1,6 +1,5 @@
 # Copyright (c) 2024 Jan T. Müller <mail@jantmueller.com>
 
-import warnings
 from functools import wraps
 import types
 import builtins
@@ -13,19 +12,20 @@ try:
 except ImportError:
     _tuplegetter = lambda index, doc: property(_itemgetter(index), doc=doc)
 
+_type = builtins.type
 
-__version__ = "2.1.1"
+__version__ = "2.2.1"
 
 MISSING = object()
 
-def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=None, arrange_names = None, seperator = None):
+def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=None, arrange_names = None, sep = None):
     """
     Create a custom named tuple class with swizzled attributes, allowing for rearranged field names
     and customized attribute access.
 
     This function generates a new subclass of `tuple` with named fields, similar to Python's
     `collections.namedtuple`. However, it extends the functionality by allowing field names to be
-    rearranged, and attributes to be accessed with a customizable separator. The function also
+    rearranged, and attributes to be accessed with a customizable sep. The function also
     provides additional safeguards for field naming and attribute access.
 
     Args:
@@ -41,9 +41,9 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
             in which fields should be arranged in the resulting named tuple. This allows for fields
             to be rearranged and, unlike standard `namedtuple`, can include duplicates. Defaults
             to the order given in `field_names`.
-        separator (str, optional): A separator string that customizes the structure of attribute
-            access. If provided, this separator allows attributes to be accessed by combining field
-            names with the separator in between them. Defaults to no separator.
+        sep (str, optional): A separator string that customizes the structure of attribute
+            access. If provided, this sep allows attributes to be accessed by combining field
+            names with the sep in between them. Defaults to no sep.
 
     Returns:
         type: A new subclass of `tuple` with named fields and customized attribute access.
@@ -55,8 +55,8 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
           duplicates, which is not possible in a standard `namedtuple`.
         - The generated named tuple class includes methods like `_make`, `_replace`, `__repr__`,
           `_asdict`, and `__getnewargs__`, partially customized to handle the rearranged field order.
-        - The `separator` argument enables a custom structure for attribute access, allowing for
-          combined attribute names based on the provided separator. If no separator is provided,
+        - The `sep` argument enables a custom structure for attribute access, allowing for
+          combined attribute names based on the provided sep. If no sep is provided,
           standard attribute access is used.
 
     Example:
@@ -192,7 +192,7 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
         'Return self as a plain tuple.  Used by copy and pickle.'
         return _tuple(self)
 
-    @swizzle_attributes_retriever(separator=seperator, type = swizzledtuple)
+    @swizzle_attributes_retriever(sep=sep, type = swizzledtuple)
     def __getattribute__(self, attr_name):
         return super(_tuple, self).__getattribute__(attr_name)
 
@@ -245,18 +245,12 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
 
     return result
 
-# deprecated name
-def swizzlednamedtuple(typename, field_names, *, rename=False, defaults=None, module=None, arrange_names = None, seperator = None):
-    warnings.warn("swizzlednamedtuple is deprecated, use swizzledtuple instead", DeprecationWarning, stacklevel=2)
-    return swizzledtuple(typename, field_names, rename=rename, defaults=defaults, module=module, arrange_names=arrange_names, seperator=seperator)
-
-
-# Helper function to split a string based on a separator
-def split_string(string, separator):
-    if separator == '':
+# Helper function to split a string based on a sep
+def split_string(string, sep):
+    if sep == '':
         return list(string)
     else:
-        return string.split(separator)
+        return string.split(sep)
 
 # Helper function to collect attribute retrieval functions from a class or meta-class
 def collect_attribute_functions(cls):
@@ -271,7 +265,7 @@ def collect_attribute_functions(cls):
 
 # Function to combine multiple attribute retrieval functions
 
-def swizzle_attributes_retriever(attribute_funcs=None, separator=None, type = tuple):
+def swizzle_attributes_retriever(attribute_funcs=None, sep=None, type = swizzledtuple):
     def _swizzle_attributes_retriever(attribute_funcs):
         if not isinstance(attribute_funcs, list):
             attribute_funcs = [attribute_funcs]
@@ -293,16 +287,18 @@ def swizzle_attributes_retriever(attribute_funcs=None, separator=None, type = tu
 
             matched_attributes = []
             arranged_names = []
-            # If a separator is provided, split the name accordingly
-            if separator is not None:
-                attr_parts = split_string(attr_name, separator)
+            # If a sep is provided, split the name accordingly
+            if sep is not None:
+                attr_parts = split_string(attr_name, sep)
                 arranged_names = attr_parts
                 for part in attr_parts:
                     attribute = retrieve_attribute(obj, part)
                     if attribute is not MISSING:
                         matched_attributes.append(attribute)
+                    else:
+                        raise AttributeError(f"No matching attribute found for part: {part}")
             else:
-                # No separator provided, attempt to match substrings
+                # No sep provided, attempt to match substrings
                 i = 0
                 while i < len(attr_name):
                     match_found = False
@@ -318,7 +314,7 @@ def swizzle_attributes_retriever(attribute_funcs=None, separator=None, type = tu
                     if not match_found:
                         raise AttributeError(f"No matching attribute found for substring: {attr_name[i:]}")
 
-            if type == swizzledtuple or type == swizzlednamedtuple:
+            if type == swizzledtuple:
                 field_names = set(arranged_names)
                 field_values = [retrieve_attribute(obj, name) for name in field_names]
                 name = "swizzledtuple"
@@ -342,23 +338,14 @@ def swizzle_attributes_retriever(attribute_funcs=None, separator=None, type = tu
         return _swizzle_attributes_retriever
 
 # Decorator function to enable swizzling for a class
-def swizzle(cls=None, meta=False, separator=None, type = tuple, **kwargs):
-
-    if 'use_meta' in kwargs:
-        warnings.warn("The 'use_meta' argument is deprecated and will be removed in a future version. Use 'meta' instead.", DeprecationWarning, stacklevel=2)
-        meta = kwargs.pop('use_meta')
-    if '_type' in kwargs:
-        warnings.warn("The '_type' argument is deprecated and will be removed in a future version. Use 'type' instead.", DeprecationWarning, stacklevel=2)
-        type = kwargs.pop('_type')
-
-    _type = builtins.type
+def swizzle(cls=None, meta=False, sep=None, type = tuple):
 
     def class_decorator(cls):
         # Collect attribute retrieval functions from the class
         attribute_funcs = collect_attribute_functions(cls)
 
         # Apply the swizzling to the class's attribute retrieval
-        setattr(cls, attribute_funcs[-1].__name__, swizzle_attributes_retriever(attribute_funcs, separator, type))
+        setattr(cls, attribute_funcs[-1].__name__, swizzle_attributes_retriever(attribute_funcs, sep, type))
 
         # Handle meta-class swizzling if requested
         if meta:
@@ -368,11 +355,9 @@ def swizzle(cls=None, meta=False, separator=None, type = tuple, **kwargs):
                     pass
                 meta_cls = SwizzledMetaType
                 cls = meta_cls(cls.__name__, cls.__bases__, dict(cls.__dict__))
-                meta_cls = SwizzledMetaType
-                cls = meta_cls(cls.__name__, cls.__bases__, dict(cls.__dict__))
 
             meta_funcs = collect_attribute_functions(meta_cls)
-            setattr(meta_cls, meta_funcs[-1].__name__, swizzle_attributes_retriever(meta_funcs, separator, type))
+            setattr(meta_cls, meta_funcs[-1].__name__, swizzle_attributes_retriever(meta_funcs, sep, type))
 
         return cls
 

swizzle-2.2.1.dist-info/METADATA

@@ -0,0 +1,184 @@
+Metadata-Version: 2.1
+Name: swizzle
+Version: 2.2.1
+Summary: Swizzle enables the retrieval of multiple attributes, similar to swizzling in computer graphics.
+Home-page: https://github.com/janthmueller/swizzle
+Author: Jan T. Müller
+Author-email: mail@jantmueller.com
+License: MIT
+Project-URL: Documentation, https://github.com/janthmueller/swizzle/blob/main/README.md
+Project-URL: Source, https://github.com/janthmueller/swizzle
+Project-URL: Tracker, https://github.com/janthmueller/swizzle/issues
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Swizzle
+
+[![PyPI Latest Release](https://img.shields.io/pypi/v/swizzle.svg)](https://pypi.org/project/swizzle/)
+[![Pepy Total Downloads](https://img.shields.io/pepy/dt/swizzle)](https://pepy.tech/project/swizzle)
+[![GitHub License](https://img.shields.io/github/license/janthmueller/swizzle)](https://github.com/janthmueller/swizzle/blob/main/LICENSE)
+
+## Introduction
+
+**Swizzle** is a Python package that enhances attribute access, allowing for flexible retrieval of multiple attributes based on specified arrangements of their names.
+
+Managing object attributes efficiently can sometimes become cumbersome, especially when you need to access multiple attributes in various combinations. Swizzle simplifies this process by extending Python's attribute access mechanisms, enabling you to access attributes in any order or combination without explicitly referencing the instance every time or defining new methods for each combination.
+
+## Features
+
+- **Dynamic Attribute Access**: Retrieve multiple attributes in any specified arrangement.
+- **Reduced Boilerplate**: Eliminate redundant code by avoiding multiple getter methods.
+- **Integration with Existing Classes**: Works seamlessly with regular classes, `dataclass`, and even `Enum` types.
+- **Customizable Matching**: Control attribute matching behavior with parameters like `sep`.
+
+## Installation
+
+### From PyPI
+
+Install Swizzle via pip:
+
+```bash
+pip install swizzle
+```
+
+### From GitHub
+
+Install the latest version directly from GitHub:
+
+```bash
+pip install git+https://github.com/janthmueller/swizzle.git
+```
+
+## Getting Started
+
+### Basic Usage with the `@swizzle` Decorator
+
+Apply the `@swizzle` decorator to your class:
+
+```python
+import swizzle
+
+@swizzle
+class Vector:
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z
+
+v = Vector(1, 2, 3)
+
+# Access attributes in different orders
+print(v.yzx)  # Output: Vector(y=2, z=3, x=1)
+```
+
+### Using Swizzle with `dataclass`
+
+Swizzle integrates smoothly with Python's `dataclass`:
+
+```python
+import swizzle
+from dataclasses import dataclass
+
+@swizzle
+@dataclass
+class Point:
+    x: int
+    y: int
+    z: int
+
+p = Point(1, 2, 3)
+
+print(p.zxy)  # Output: Point(z=3, x=1, y=2)
+```
+
+### Swizzling Enums with `meta=True`
+
+Enable attribute swizzling directly on the class by setting `meta=True`:
+
+```python
+import swizzle
+from enum import IntEnum
+
+@swizzle(meta=True)
+class Axis(IntEnum):
+    X = 1
+    Y = 2
+    Z = 3
+
+print(Axis.YXZ)  # Output: Axis(Y=<Axis.Y: 2>, X=<Axis.X: 1>, Z=<Axis.Z: 3>)
+```
+
+## Advanced Usage
+
+### Swizzled Named Tuples with `swizzledtuple`
+
+Create swizzled named tuples inspired by `namedtuple`:
+
+```python
+from swizzle import swizzledtuple
+
+Vector = swizzledtuple('Vector', 'x y z')
+
+v = Vector(1, 2, 3)
+
+print(v.yzx)        # Output: Vector(y=2, z=3, x=1)
+print(v.yzx.xxzyzz) # Output: Vector(x=1, x=1, z=3, y=2, z=3, z=3)
+```
+
+### Custom Separators
+
+Attributes are matched from left to right, starting with the longest substring match. This behavior can be controlled by the `sep` argument in the swizzle decorator:
+
+```python
+import swizzle
+
+@swizzle(meta=True, sep='_')
+class BoundingBox:
+    x = 10
+    y = 20
+    w = 100
+    h = 200
+
+print(BoundingBox.x_y_w_h)  # Output: BoundingBox(x=10, y=20, w=100, h=200)
+```
+
+## Understanding Swizzling
+
+Swizzling allows:
+
+- **Rearrangement**: Access attributes in any order (e.g., `v.yzx`).
+- **Duplication**: Access the same attribute multiple times (e.g., `v.xxy`).
+- **Dynamic Composition**: Create new instances with desired attribute arrangements.
+
+## Benefits
+
+- **Efficient Attribute Management**: Simplify complex attribute combinations.
+- **Dynamic Access Patterns**: No need for predefined attribute combinations.
+- **Cleaner Codebase**: Reduce redundancy and improve maintainability.
+- **Enhanced Readability**: Code becomes more expressive and intuitive.
+
+## Conclusion
+
+Swizzle is a powerful tool that streamlines attribute management in Python. It offers a flexible and efficient way to access and manipulate object attributes, making your code cleaner and more maintainable.
+
+## License
+
+This project is licensed under the terms of the MIT license. See the [LICENSE](https://github.com/janthmueller/swizzle/blob/main/LICENSE) file for details.
+
+## Contributions
+
+Contributions are welcome! Feel free to submit a Pull Request or open an Issue on GitHub.
+
+## Acknowledgments
+
+Inspired by swizzling in graphics programming, Swizzle brings similar flexibility to Python attribute management.
+
+---
+
+Give Swizzle a try and see how it can simplify your Python projects!

swizzle-2.2.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+swizzle/__init__.py,sha256=_clk7y4NCO9KY-I-iSNsLc6iT8ylLcNPD4aiqoun1NE,15304
+swizzle-2.2.1.dist-info/LICENSE,sha256=WDAegKWtl3rZUiN-SQ2FEQQwEFxlM_jEKQyJRJawJXo,1070
+swizzle-2.2.1.dist-info/METADATA,sha256=vsupVSVUEg4uC3ZodBYPaLyUhvVPSXr2AgG9om0WMlY,5450
+swizzle-2.2.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+swizzle-2.2.1.dist-info/top_level.txt,sha256=XFSQti81x2zM0zAMCY1YD0lqB1eSg5my9BB03uFgCic,8
+swizzle-2.2.1.dist-info/RECORD,,

{swizzle-2.1.1.dist-info → swizzle-2.2.1.dist-info}/WHEEL

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

swizzle-2.1.1.dist-info/METADATA

@@ -1,128 +0,0 @@
-Metadata-Version: 2.1
-Name: swizzle
-Version: 2.1.1
-Summary: Swizzle enables the retrieval of multiple attributes, similar to swizzling in computer graphics.
-Home-page: https://github.com/janthmueller/swizzle
-Author: Jan T. Müller
-Author-email: mail@jantmueller.com
-License: MIT
-Project-URL: Documentation, https://github.com/janthmueller/swizzle/blob/main/README.md
-Project-URL: Source, https://github.com/janthmueller/swizzle
-Project-URL: Tracker, https://github.com/janthmueller/swizzle/issues
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# Swizzle
-[![PyPI Latest Release](https://img.shields.io/pypi/v/swizzle.svg)](https://pypi.org/project/swizzle/) 
-[![Pepy Total Downlods](https://img.shields.io/pepy/dt/swizzle)](https://pepy.tech/project/swizzle)
-[![GitHub License](https://img.shields.io/github/license/janthmueller/swizzle)](https://github.com/janthmueller/swizzle/blob/main/LICENSE)
-[![GitHub Stars](https://img.shields.io/github/stars/janthmueller/swizzle.svg)](https://github.com/janthmueller/swizzle/stargazers)
-
-**Swizzle** for Python enhances attribute lookup methods to facilitate dynamic and flexible retrieval of multiple attributes based on specified arrangements of their names.
-> **Update v2:**
-> Introducing `swizzledtuple` , a new function that allows you to create swizzled named tuples. This feature is inspired by the `namedtuple` function from the [collections module](https://docs.python.org/3/library/collections.html#collections.namedtuple) and provides a concise way to define swizzled tuples.
-> ```python
-> from swizzle import swizzledtuple
->
-> Vector = swizzledtuple('Vector', 'x y z', arrange_names = "y z x x")
->
-> # Test the swizzle
-> v = Vector(1, 2, 3)
-> print(v)  # Output: Vector(y=2, z=3, x=1, x=1)
-> print(v.yzx)  # Output: Vector(y = 2, z = 3, x = 1)
-> print(v.yzx.xxzyzz)  # Output: Vector(x=1, x=1, z=3, y=2, z=3, z=3)
->```
-
-### Swizzle Decorator:
-
-```python
-import swizzle
-
-@swizzle
-class Vector:
-    def __init__(self, x, y, z):
-        self.x = x
-        self.y = y
-        self.z = z
-
-# Test the swizzle
-print(Vector(1, 2, 3).yzx)  # Output: Vector(y = 2, z = 3, x = 1)
-```
-
-
-## Installation
-### From PyPI
-```bash
-pip install swizzle
-```
-### From GitHub
-```bash
-pip install git+https://github.com/janthmueller/swizzle.git
-```
-
-## Further Examples
-
-### Using `swizzle` with `dataclass`
-
-```python
-import swizzle
-from dataclasses import dataclass
-
-@swizzle
-@dataclass
-class Vector:
-    x: int
-    y: int
-    z: int
-
-# Test the swizzle
-print(Vector(1, 2, 3).yzx)  # Output: Vector(y = 2, z = 3, x = 1)
-```
-
-### Using `swizzle` with `IntEnum`
-
-```python
-import swizzle
-from enum import IntEnum
-
-@swizzle(meta=True)
-class Vector(IntEnum):
-    X = 1
-    Y = 2
-    Z = 3
-
-# Test the swizzle
-print(Vector.YXZ)  # Output: Vector(Y=<Vector.Y: 2>, X=<Vector.X: 1>, Z=<Vector.Z: 3>)
-```
-Setting the `meta` argument to `True` in the swizzle decorator extends the `getattr` behavior of the metaclass, enabling attribute swizzling directly on the class itself.
-
-
-### Sequential matching
-Attributes are matched from left to right, starting with the longest substring match. This behavior can be controlled by the `seperator` argument in the swizzle decorator.
-```python
-import swizzle
-
-@swizzle(meta=True)
-class Vector:
-    x = 1
-    y = 2
-    z = 3
-    xy = 4
-    yz = 5
-    xz = 6
-    xyz = 7
-
-# Test the swizzle
-print(Vector.xz)  # Output: 6
-print(Vector.yz)  # Output: 5
-print(Vector.xyyz)  # Output: Vector(xy=4, yz=5)
-print(Vector.xyzx)  # Output: Vector(xyz=7, x=1)
-```
-
-

swizzle-2.1.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-swizzle/__init__.py,sha256=_YUDBGbs3unvltIfO8A0DIsWC05vxQaklY43vsFKyK4,16370
-swizzle-2.1.1.dist-info/LICENSE,sha256=WDAegKWtl3rZUiN-SQ2FEQQwEFxlM_jEKQyJRJawJXo,1070
-swizzle-2.1.1.dist-info/METADATA,sha256=xwo2y2C9uuy_-fW5YRDQd3PtMnn7hkD9zXVlAIBqNiU,3826
-swizzle-2.1.1.dist-info/WHEEL,sha256=nCVcAvsfA9TDtwGwhYaRrlPhTLV9m-Ga6mdyDtuwK18,91
-swizzle-2.1.1.dist-info/top_level.txt,sha256=XFSQti81x2zM0zAMCY1YD0lqB1eSg5my9BB03uFgCic,8
-swizzle-2.1.1.dist-info/RECORD,,