swizzle 2.2.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

swizzle/__init__.py

@@ -14,7 +14,7 @@ except ImportError:
 
 _type = builtins.type
 
-__version__ = "2.2.0"
+__version__ = "2.3.0"
 
 MISSING = object()
 
@@ -43,7 +43,7 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
             to the order given in `field_names`.
         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.
+            names with the sep in between them. Defaults to None.
 
     Returns:
         type: A new subclass of `tuple` with named fields and customized attribute access.
@@ -196,6 +196,40 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
     def __getattribute__(self, attr_name):
         return super(_tuple, self).__getattribute__(attr_name)
 
+    # def __getitem__(self, index):
+    #     a_names = arrange_names[index]
+    #     _sep = '' if sep is None else sep
+    #     return getattr(self, _sep.join(a_names))
+
+    def __getitem__(self, index):
+        if not isinstance(index, slice):
+            return _tuple.__getitem__(self, index)
+
+        selected_indices = arrange_indices[index]
+        selected_values = _tuple.__getitem__(self, index)
+
+        seen = set()
+        filtered = [
+            (i, v, field_names[i])
+            for i, v in zip(selected_indices, selected_values)
+            if not (i in seen or seen.add(i))
+        ]
+
+        if filtered:
+            _, filtered_values, filtered_names = zip(*filtered)
+        else:
+            filtered_values, filtered_names = (), ()
+
+        return swizzledtuple(
+            typename,
+            filtered_names,
+            rename=rename,
+            defaults=filtered_values,
+            module=module,
+            arrange_names=arrange_names[index],
+            sep=sep
+        )()
+
 
 
     for method in (
@@ -206,6 +240,7 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
         _asdict,
         __getnewargs__,
         __getattribute__,
+        __getitem__
     ):
         method.__qualname__ = f'{typename}.{method.__name__}'
 
@@ -220,7 +255,8 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
         '__repr__': __repr__,
         '_asdict': _asdict,
         '__getnewargs__': __getnewargs__,
-        '__getattribute__': __getattribute__
+        '__getattribute__': __getattribute__,
+        '__getitem__': __getitem__
     }
     seen = set()
     for index, name in enumerate(arrange_names):

swizzle-2.3.0.dist-info/METADATA

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: swizzle
+Version: 2.3.0
+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
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# 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.3.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+swizzle/__init__.py,sha256=oEH3oUXQiz3nl6yf0tkFyHkiK43iPNeXhP9qSsUd5yw,16406
+swizzle-2.3.0.dist-info/licenses/LICENSE,sha256=WDAegKWtl3rZUiN-SQ2FEQQwEFxlM_jEKQyJRJawJXo,1070
+swizzle-2.3.0.dist-info/METADATA,sha256=-eXIDaSiwrN82ROSZmJF5UDRScA5aNUQF-T8y_BaXA0,5684
+swizzle-2.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+swizzle-2.3.0.dist-info/top_level.txt,sha256=XFSQti81x2zM0zAMCY1YD0lqB1eSg5my9BB03uFgCic,8
+swizzle-2.3.0.dist-info/RECORD,,

{swizzle-2.2.0.dist-info → swizzle-2.3.0.dist-info}/WHEEL

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

swizzle-2.2.0.dist-info/METADATA

@@ -1,128 +0,0 @@
-Metadata-Version: 2.1
-Name: swizzle
-Version: 2.2.0
-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 `sep` 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.2.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-swizzle/__init__.py,sha256=tdMYMDJVpTR3TGGyvQz5r6Qm48uzwdpfxt8EnmqTFbU,15304
-swizzle-2.2.0.dist-info/LICENSE,sha256=WDAegKWtl3rZUiN-SQ2FEQQwEFxlM_jEKQyJRJawJXo,1070
-swizzle-2.2.0.dist-info/METADATA,sha256=5GpqF5HP7Zlj3HGy-3z0r4Z79U10ODitqRJ5iwoQ4t4,3819
-swizzle-2.2.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-swizzle-2.2.0.dist-info/top_level.txt,sha256=XFSQti81x2zM0zAMCY1YD0lqB1eSg5my9BB03uFgCic,8
-swizzle-2.2.0.dist-info/RECORD,,