swizzle 0.1.3__tar.gz → 1.0.0__tar.gz

{swizzle-0.1.3 → swizzle-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swizzle
-Version: 0.1.3
+Version: 1.0.0
 Summary: The Swizzle Decorator enables the retrieval of multiple attributes, similar to swizzling in computer graphics.
 Home-page: https://github.com/janthmueller/swizzle
 Author: Jan T. Müller
@@ -77,7 +77,7 @@ class XYZ(IntEnum):
     Z = 3
 
 # Test the swizzle
-print(XYZ.yxz)  # Output: (<XYZ.Y: 2>, <XYZ.X: 1>, <XYZ.Z: 3>)
+print(XYZ.YXZ)  # Output: (<XYZ.Y: 2>, <XYZ.X: 1>, <XYZ.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.
 
@@ -99,8 +99,8 @@ print(xyz.yzx)  # Output: (2, 3, 1)
 ```
 
 
-### Sequential matching 
-Attributes are matched from left to right, starting with the longest substring match. 
+### Sequential matching
+Attributes are matched from left to right, starting with the longest substring match.
 ```python
 import swizzle
 
@@ -121,3 +121,5 @@ print(Test.xyyz)  # Output: (4, 5)
 print(Test.xyzx)  # Output: (7, 1)
 ```
 
+## To Do
+- [ ] Swizzle for method args (swizzle+partial)

{swizzle-0.1.3 → swizzle-1.0.0}/README.md

@@ -1,104 +1,106 @@
-# 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
-### 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 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: (<XYZ.Y: 2>, <XYZ.X: 1>, <XYZ.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.
-
-### 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 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
+### 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 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: (<XYZ.Y: 2>, <XYZ.X: 1>, <XYZ.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.
+
+### 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)
+```
+
+## To Do
+- [ ] Swizzle for method args (swizzle+partial)

{swizzle-0.1.3 → swizzle-1.0.0}/setup.py

@@ -1,43 +1,43 @@
-# Copyright (c) 2023 Jan T. Müller <mail@jantmueller.com>
-
-import sys
-import os
-from setuptools import setup, find_packages
-import swizzle
-
-if sys.version_info < (3, 6):
-    sys.exit("ERROR: swizzle requires Python 3.6+")
-
-with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
-
-setup(
-    name="swizzle",
-    version=swizzle.__version__,
-    packages=find_packages(exclude=["tests"]),
-    author="Jan T. Müller",
-    author_email="mail@jantmueller.com",
-    description="The Swizzle Decorator enables the retrieval of multiple attributes, similar to swizzling in computer graphics.",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/janthmueller/swizzle",
-    project_urls={
-        "Documentation": "https://github.com/janthmueller/swizzle/blob/main/README.md",
-        "Source": "https://github.com/janthmueller/swizzle",
-        "Tracker": "https://github.com/janthmueller/swizzle/issues",
-    },
-    license="MIT",
-    classifiers=[
-        "Intended Audience :: Developers",
-        "Topic :: Software Development :: Libraries :: Python Modules",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-        "Programming Language :: Python :: 3 :: Only",
-    ],
-    python_requires=">=3.6",
-)
-
-
-# python setup.py sdist bdist_wheel
-# twine check dist/*
-# twine upload dist/* -> insert token
+# Copyright (c) 2023 Jan T. Müller <mail@jantmueller.com>
+
+import sys
+import os
+from setuptools import setup, find_packages
+import swizzle
+
+if sys.version_info < (3, 6):
+    sys.exit("ERROR: swizzle requires Python 3.6+")
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="swizzle",
+    version=swizzle.__version__,
+    packages=find_packages(exclude=["tests"]),
+    author="Jan T. Müller",
+    author_email="mail@jantmueller.com",
+    description="The Swizzle Decorator enables the retrieval of multiple attributes, similar to swizzling in computer graphics.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/janthmueller/swizzle",
+    project_urls={
+        "Documentation": "https://github.com/janthmueller/swizzle/blob/main/README.md",
+        "Source": "https://github.com/janthmueller/swizzle",
+        "Tracker": "https://github.com/janthmueller/swizzle/issues",
+    },
+    license="MIT",
+    classifiers=[
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3 :: Only",
+    ],
+    python_requires=">=3.6",
+)
+
+
+# python setup.py sdist bdist_wheel
+# twine check dist/*
+# twine upload dist/* -> insert token

swizzle-1.0.0/swizzle/__init__.py

@@ -0,0 +1,112 @@
+from functools import wraps
+import sys
+import types
+
+__version__ = "1.0.0"
+MISSING = object()
+
+
+# Helper function to split a string based on a separator
+def split_string(string, separator):
+    if separator == '':
+        return list(string)
+    else:
+        return string.split(separator)
+
+# Helper function to collect attribute retrieval functions from a class or meta-class
+def collect_attribute_functions(cls):
+    funcs = []
+    if hasattr(cls, '__getattribute__'):
+        funcs.append(cls.__getattribute__)
+    if hasattr(cls, '__getattr__'):
+        funcs.append(cls.__getattr__)
+    if not funcs:
+        raise AttributeError("No __getattr__ or __getattribute__ found on the class or meta-class")
+    return funcs
+
+# Function to combine multiple attribute retrieval functions
+def swizzle_attributes_retriever(attribute_funcs, separator=None):
+    def retrieve_attribute(obj, attr_name):
+        for func in attribute_funcs:
+            try:
+                return func(obj, attr_name)
+            except AttributeError:
+                continue
+        return MISSING
+
+    @wraps(attribute_funcs[-1])
+    def retrieve_swizzled_attributes(obj, attr_name):
+        # Attempt to find an exact attribute match
+        attribute = retrieve_attribute(obj, attr_name)
+        if attribute is not MISSING:
+            return attribute
+
+        matched_attributes = []
+
+        # If a separator is provided, split the name accordingly
+        if separator is not None:
+            attr_parts = split_string(attr_name, separator)
+            for part in attr_parts:
+                attribute = retrieve_attribute(obj, part)
+                if attribute is not MISSING:
+                    matched_attributes.append(attribute)
+        else:
+            # No separator provided, attempt to match substrings
+            i = 0
+            while i < len(attr_name):
+                match_found = False
+                for j in range(len(attr_name), i, -1):
+                    substring = attr_name[i:j]
+                    attribute = retrieve_attribute(obj, substring)
+                    if attribute is not MISSING:
+                        matched_attributes.append(attribute)
+                        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: {attr_name[i:]}")
+
+        return tuple(matched_attributes)
+
+    return retrieve_swizzled_attributes
+
+# Decorator function to enable swizzling for a class
+def swizzle(cls=None, use_meta=False, separator=None):
+    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))
+
+        # Handle meta-class swizzling if requested
+        if use_meta:
+            meta_cls = type(cls)
+            if meta_cls == type:
+                class SwizzledMetaType(meta_cls):
+                    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))
+
+        return cls
+
+    if cls is None:
+        return class_decorator
+    else:
+        return class_decorator(cls)
+
+
+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, sep = None):
+        return swizzle(cls, meta, sep)
+
+sys.modules[__name__] = Swizzle()

{swizzle-0.1.3 → swizzle-1.0.0}/swizzle.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swizzle
-Version: 0.1.3
+Version: 1.0.0
 Summary: The Swizzle Decorator enables the retrieval of multiple attributes, similar to swizzling in computer graphics.
 Home-page: https://github.com/janthmueller/swizzle
 Author: Jan T. Müller
@@ -77,7 +77,7 @@ class XYZ(IntEnum):
     Z = 3
 
 # Test the swizzle
-print(XYZ.yxz)  # Output: (<XYZ.Y: 2>, <XYZ.X: 1>, <XYZ.Z: 3>)
+print(XYZ.YXZ)  # Output: (<XYZ.Y: 2>, <XYZ.X: 1>, <XYZ.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.
 
@@ -99,8 +99,8 @@ print(xyz.yzx)  # Output: (2, 3, 1)
 ```
 
 
-### Sequential matching 
-Attributes are matched from left to right, starting with the longest substring match. 
+### Sequential matching
+Attributes are matched from left to right, starting with the longest substring match.
 ```python
 import swizzle
 
@@ -121,3 +121,5 @@ print(Test.xyyz)  # Output: (4, 5)
 print(Test.xyzx)  # Output: (7, 1)
 ```
 
+## To Do
+- [ ] Swizzle for method args (swizzle+partial)

swizzle-0.1.3/swizzle/__init__.py

@@ -1,80 +0,0 @@
-from functools import wraps
-import sys
-import types
-
-__version__ = "0.1.3"
-
-def _split(s, sep):
-    if sep == '':
-        return list(s)
-    else:
-        return s.split(sep)
-    
-def _swizzle(func, sep = None):
-    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."""
-        try:
-            return func(obj, name)
-        except AttributeError:
-            pass
-        if sep is not None:
-            names = _split(name, sep)
-            found_attributes = [func(obj, n) for n in names]
-        else:
-            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, sep = None):
-    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, sep)) 
-
-        # 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, sep))
-        return cls
-
-    if cls is None:
-        return decorator
-    else:
-        return decorator(cls)
-        
-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, sep = None):
-        return swizzle(cls, meta, sep)
-
-sys.modules[__name__] = Swizzle()
-