swizzle 0.1.0__py3-none-any.whl

swizzle/__init__.py

@@ -0,0 +1,70 @@
+from functools import wraps
+import sys
+import types
+import inspect
+
+__version__ = "0.1.0"
+
+def _swizzle(func):
+    def _getattr(obj, name, default=object()):
+        try:
+            return func(obj, name)
+        except AttributeError:
+            return default
+
+    @wraps(func)
+    def _swizzle_attributes(obj, name):
+        """Find attributes of an object that match substrings of a given name."""
+        found_attributes = []
+        sentinel = object()
+        i = 0
+        while i < len(name):
+            match_found = False
+            for j in range(len(name), i, -1):
+                substr = name[i:j]
+                attr = _getattr(obj, substr, sentinel)
+                if attr is not sentinel:
+                    found_attributes.append(attr)
+                    i = j  # Move index to end of the matched substring
+                    match_found = True
+                    break
+            if not match_found:
+                raise AttributeError(f"No matching attribute found for substring: {name[i:]}")
+        return tuple(found_attributes)
+    return _swizzle_attributes
+    
+def swizzle(cls=None, meta = False):
+    def decorator(cls):
+        # Decorate the class's __getattr__ or __getattribute__
+        cls_fn = cls.__getattr__ if hasattr(cls, '__getattr__') else cls.__getattribute__
+        setattr(cls, cls_fn.__name__, _swizzle(cls_fn)) 
+
+        # Handle the meta class
+        if meta:
+            meta_cls = type(cls)
+            if meta_cls == type:
+                class SwizzleType(meta_cls): pass
+                meta_cls = SwizzleType
+                cls = meta_cls(cls.__name__, cls.__bases__, dict(cls.__dict__))
+            meta_fn = meta_cls.__getattr__ if hasattr(meta_cls, '__getattr__') else meta_cls.__getattribute__
+            setattr(meta_cls, meta_fn.__name__, _swizzle(meta_fn))
+        return cls
+
+    if cls is None:
+        return decorator
+    else:
+        return decorator(cls)
+        
+
+
+# make swizzle a callable module
+class Swizzle(types.ModuleType):
+    def __init__(self):
+        types.ModuleType.__init__(self, __name__)
+        self.__dict__.update(sys.modules[__name__].__dict__)
+    
+    def __call__(self, cls=None, meta=False):
+        return swizzle(cls, meta)
+
+sys.modules[__name__] = Swizzle()
+        

swizzle-0.1.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.1
+Name: swizzle
+Version: 0.1.0
+Summary: Transforms a string representation of a Python literal into the corresponding Python object.
+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
+
+# Swizzle Decorator
+
+The **Swizzle Decorator** for Python enhances attribute lookup methods (`__getattr__` or `__getattribute__`) to facilitate dynamic and flexible retrieval of multiple attributes based on specified arrangements of their names. This concept is reminiscent of swizzling in computer graphics, where it allows efficient access to components of vectors or coordinates in various orders:
+
+```python
+import swizzle
+
+@swizzle
+class Vector:
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z
+
+print(Vector(1, 2, 3).yzx)  # Output: (2, 3, 1)
+```
+
+## Installation
+```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 XYZ:
+    x: int
+    y: int
+    z: int
+
+# Test the swizzle
+xyz = XYZ(1, 2, 3)
+print(xyz.yzx)  # Output: (2, 3, 1)
+```
+
+### Using `swizzle` with `IntEnum`
+
+```python
+import swizzle
+from enum import IntEnum
+
+@swizzle(meta=True)
+class XYZ(IntEnum):
+    X = 1
+    Y = 2
+    Z = 3
+
+# Test the swizzle
+print(XYZ.yxz)  # Output: (2, 3, 1)
+```
+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.
+
+### Using `swizzle` with `NamedTuple`
+
+```python
+import swizzle
+from typing import NamedTuple
+
+@swizzle
+class XYZ(NamedTuple):
+    x: int
+    y: int
+    z: int
+
+# Test the swizzle
+xyz = XYZ(1, 2, 3)
+print(xyz.yzx)  # Output: (2, 3, 1)
+```
+
+
+### Sequential matching 
+Attributes are matched from left to right, starting with the longest substring match. 
+```python
+import swizzle
+
+@swizzle(meta=True)
+class Test:
+    x = 1
+    y = 2
+    z = 3
+    xy = 4
+    yz = 5
+    xz = 6
+    xyz = 7
+
+# Test the swizzle
+print(Test.xz)  # Output: (6,)
+print(Test.yz)  # Output: (5,)
+print(Test.xyyz)  # Output: (4, 5)
+print(Test.xyzx)  # Output: (7, 1)
+```
+

swizzle-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+swizzle/__init__.py,sha256=6xrT6tZERBQWGNPvWofOiSnVGzq-0-nRWbAjt9-czJY,2281
+swizzle-0.1.0.dist-info/METADATA,sha256=f4MejVS5TgwsY0hroO6wR7gWIJjLl1Guzx4K_zhm8j4,2807
+swizzle-0.1.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+swizzle-0.1.0.dist-info/top_level.txt,sha256=XFSQti81x2zM0zAMCY1YD0lqB1eSg5my9BB03uFgCic,8
+swizzle-0.1.0.dist-info/RECORD,,

swizzle-0.1.0.dist-info/WHEEL

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

swizzle-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+swizzle