swizzle 0.1.3__py3-none-any.whl → 1.0.0__py3-none-any.whl

swizzle/__init__.py

@@ -1,80 +1,112 @@
-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()
-        
+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.dist-info → swizzle-1.0.0.dist-info}/METADATA

@@ -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-1.0.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+swizzle/__init__.py,sha256=9LHl0nK4LB9aEm4264zzhCLL_yF6_2k3-hHdORzapVU,4151
+swizzle-1.0.0.dist-info/METADATA,sha256=B8VrYh-Lm_Ixg_J-GrVdNAbpOP3oR6ouRVUSLii8izI,2963
+swizzle-1.0.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+swizzle-1.0.0.dist-info/top_level.txt,sha256=XFSQti81x2zM0zAMCY1YD0lqB1eSg5my9BB03uFgCic,8
+swizzle-1.0.0.dist-info/RECORD,,

{swizzle-0.1.3.dist-info → swizzle-1.0.0.dist-info}/WHEEL

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

swizzle-0.1.3.dist-info/RECORD

@@ -1,5 +0,0 @@
-swizzle/__init__.py,sha256=Y3Z1mQdZbcjFE612dzwlqMby_qtJtSf68NgmylPPHGw,2684
-swizzle-0.1.3.dist-info/METADATA,sha256=ueORk9NK-YFClvH7EvL7nTFwmXUaaNHkFUZfafMPw6c,2908
-swizzle-0.1.3.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-swizzle-0.1.3.dist-info/top_level.txt,sha256=XFSQti81x2zM0zAMCY1YD0lqB1eSg5my9BB03uFgCic,8
-swizzle-0.1.3.dist-info/RECORD,,