swizzle 0.1.4__tar.gz → 2.0.0__tar.gz

swizzle-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jan T. Mueller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

swizzle-2.0.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: swizzle
+Version: 2.0.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 version](https://badge.fury.io/py/swizzle.svg)](https://badge.fury.io/py/swizzle)
+[![Downloads](https://pepy.tech/badge/swizzle)](https://pepy.tech/project/swizzle)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](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 `swizzlednamedtuple` , 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 swizzlednamedtuple
+> Vector = swizzlednamedtuple('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.0.0/README.md

@@ -0,0 +1,107 @@
+# Swizzle
+[![PyPI version](https://badge.fury.io/py/swizzle.svg)](https://badge.fury.io/py/swizzle)
+[![Downloads](https://pepy.tech/badge/swizzle)](https://pepy.tech/project/swizzle)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](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 `swizzlednamedtuple` , 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 swizzlednamedtuple
+> Vector = swizzlednamedtuple('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-0.1.4 → swizzle-2.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) 2024 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="Swizzle 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-2.0.0/swizzle/__init__.py

@@ -0,0 +1,329 @@
+# Copyright (c) 2024 Jan T. Müller <mail@jantmueller.com>
+
+from functools import wraps
+import types
+import sys as _sys
+
+from keyword import iskeyword as _iskeyword
+from operator import itemgetter as _itemgetter
+try:
+    from _collections import _tuplegetter
+except ImportError:
+    _tuplegetter = lambda index, doc: property(_itemgetter(index), doc=doc)
+
+
+__version__ = "2.0.0"
+
+MISSING = object()
+
+def swizzlednamedtuple(typename, field_names, *, rename=False, defaults=None, module=None, arrange_names = None, seperator = None):
+    # Validate the field names. Skip duplicate and underscore checks.
+    if isinstance(field_names, str):
+        field_names = field_names.replace(',', ' ').split()
+    field_names = list(map(str, field_names))
+    if arrange_names is not None:
+        if isinstance(arrange_names, str):
+            arrange_names = arrange_names.replace(',', ' ').split()
+        arrange_names = list(map(str, arrange_names))
+        assert set(arrange_names) == set(field_names), 'Arrangement must contain all field names'
+    else:
+        arrange_names = field_names.copy()
+
+
+    typename = _sys.intern(str(typename))
+
+    _dir = dir(tuple) + ['__match_args__', '__module__', '__slots__', '_asdict', '_field_defaults', '_fields', '_make', '_replace',]
+    if rename:
+        seen = set()
+        name_newname = {}
+        for index, name in enumerate(field_names):
+            if (not name.isidentifier()
+                or _iskeyword(name)
+                or name in _dir
+                or name in seen):
+                field_names[index] = f'_{index}'
+            name_newname[name] = field_names[index]
+            seen.add(name)
+        for index, name in enumerate(arrange_names):
+            arrange_names[index] = name_newname[name]
+
+    for name in [typename] + field_names:
+        if type(name) is not str:
+            raise TypeError('Type names and field names must be strings')
+        if not name.isidentifier():
+            raise ValueError('Type names and field names must be valid '
+                             f'identifiers: {name!r}')
+        if _iskeyword(name):
+            raise ValueError('Type names and field names cannot be a '
+                             f'keyword: {name!r}')
+    seen = set()
+    for name in field_names:
+        if name in _dir and not rename:
+            raise ValueError('Field names cannot be an attribute name which would shadow the namedtuple methods or attributes'
+                             f'{name!r}')
+        if name in seen:
+            raise ValueError(f'Encountered duplicate field name: {name!r}')
+        seen.add(name)
+
+    arrange_indices = [field_names.index(name) for name in arrange_names]
+
+    def tuple_new(cls, iterable):
+        new = []
+        _iterable = list(iterable)
+        for index in arrange_indices:
+            new.append(_iterable[index])
+        return tuple.__new__(cls, new)
+
+    field_defaults = {}
+    if defaults is not None:
+        defaults = tuple(defaults)
+        if len(defaults) > len(field_names):
+            raise TypeError('Got more default values than field names')
+        field_defaults = dict(reversed(list(zip(reversed(field_names),
+                                                reversed(defaults)))))
+
+    field_names = tuple(map(_sys.intern, field_names))
+    arrange_names = tuple(map(_sys.intern, arrange_names))
+    num_fields = len(field_names)
+    num_arrange_fields = len(arrange_names)
+    arg_list = ', '.join(field_names)
+    if num_fields == 1:
+        arg_list += ','
+    repr_fmt = '(' + ', '.join(f'{name}=%r' for name in arrange_names) + ')'
+    _dict, _tuple, _len, _map, _zip = dict, tuple, len, map, zip
+
+    namespace = {
+        '_tuple_new': tuple_new,
+        '__builtins__': {},
+        '__name__': f'namedtuple_{typename}',
+    }
+    code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))'
+    __new__ = eval(code, namespace)
+    __new__.__name__ = '__new__'
+    __new__.__doc__ = f'Create new instance of {typename}({arg_list})'
+    if defaults is not None:
+        __new__.__defaults__ = defaults
+
+    @classmethod
+    def _make(cls, iterable):
+        result = tuple_new(cls, iterable)
+        if _len(result) != num_arrange_fields:
+            raise TypeError(f'Expected {num_arrange_fields} arguments, got {len(result)}')
+        return result
+
+    _make.__func__.__doc__ = (f'Make a new {typename} object from a sequence '
+                              'or iterable')
+
+    def _replace(self, /, **kwds):
+        def generator():
+            for name in field_names:
+                if name in kwds:
+                    yield kwds.pop(name)
+                else:
+                    yield getattr(self, name)
+
+        result = self._make(iter(generator()))
+        if kwds:
+            raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
+        return result
+
+    _replace.__doc__ = (f'Return a new {typename} object replacing specified '
+                        'fields with new values')
+
+    def __repr__(self):
+        'Return a nicely formatted representation string'
+        return self.__class__.__name__ + repr_fmt % self
+
+    def _asdict(self):
+        'Return a new dict which maps field names to their values.'
+        return _dict(_zip(arrange_names, self))
+
+    def __getnewargs__(self):
+        'Return self as a plain tuple.  Used by copy and pickle.'
+        return _tuple(self)
+
+    @swizzle_attributes_retriever(separator=seperator, type = swizzlednamedtuple)
+    def __getattribute__(self, attr_name):
+        return super(_tuple, self).__getattribute__(attr_name)
+
+
+
+    for method in (
+        __new__,
+        _make.__func__,
+        _replace,
+        __repr__,
+        _asdict,
+        __getnewargs__,
+        __getattribute__,
+    ):
+        method.__qualname__ = f'{typename}.{method.__name__}'
+
+    class_namespace = {
+        '__doc__': f'{typename}({arg_list})',
+        '__slots__': (),
+        '_fields': field_names,
+        '_field_defaults': field_defaults,
+        '__new__': __new__,
+        '_make': _make,
+        '_replace': _replace,
+        '__repr__': __repr__,
+        '_asdict': _asdict,
+        '__getnewargs__': __getnewargs__,
+        '__getattribute__': __getattribute__
+    }
+    seen = set()
+    for index, name in enumerate(arrange_names):
+        if name in seen:
+            continue
+        doc = _sys.intern(f'Alias for field number {index}')
+        class_namespace[name] = _tuplegetter(index, doc)
+        seen.add(name)
+
+    result = type(typename, (tuple,), class_namespace)
+
+    if module is None:
+        try:
+            module = _sys._getframemodulename(1) or '__main__'
+        except AttributeError:
+            try:
+                module = _sys._getframe(1).f_globals.get('__name__', '__main__')
+            except (AttributeError, ValueError):
+                pass
+    if module is not None:
+        result.__module__ = module
+
+    return result
+
+
+# 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=None, separator=None, type = tuple):
+    def _swizzle_attributes_retriever(attribute_funcs):
+        if not isinstance(attribute_funcs, list):
+            attribute_funcs = [attribute_funcs]
+
+        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 = []
+            arranged_names = []
+            # If a separator is provided, split the name accordingly
+            if separator is not None:
+                attr_parts = split_string(attr_name, separator)
+                arranged_names = attr_parts
+                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)
+                            arranged_names.append(substring)
+                            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:]}")
+
+            if type == swizzlednamedtuple:
+                field_names = set(arranged_names)
+                field_values = [retrieve_attribute(obj, name) for name in field_names]
+                name = "swizzlednamedtuple"
+                if hasattr(obj, "__name__"):
+                    name = obj.__name__
+                elif hasattr(obj, "__class__"):
+                    if hasattr(obj.__class__, "__name__"):
+                        name = obj.__class__.__name__
+                result = type(name, field_names, arrange_names=arranged_names)
+                result = result(*field_values)
+                return result
+
+
+            return type(matched_attributes)
+
+        return retrieve_swizzled_attributes
+
+    if attribute_funcs is not None:
+        return _swizzle_attributes_retriever(attribute_funcs)
+    else:
+        return _swizzle_attributes_retriever
+
+# Decorator function to enable swizzling for a class
+def swizzle(cls=None, use_meta=False, separator=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))
+
+        # Handle meta-class swizzling if requested
+        if use_meta:
+            print(cls)
+            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, _type))
+
+        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, type = swizzlednamedtuple):
+        return swizzle(cls, meta, sep, type)
+
+_sys.modules[__name__] = Swizzle()

swizzle-2.0.0/swizzle.egg-info/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: swizzle
+Version: 2.0.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 version](https://badge.fury.io/py/swizzle.svg)](https://badge.fury.io/py/swizzle)
+[![Downloads](https://pepy.tech/badge/swizzle)](https://pepy.tech/project/swizzle)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](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 `swizzlednamedtuple` , 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 swizzlednamedtuple
+> Vector = swizzlednamedtuple('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-0.1.4 → swizzle-2.0.0}/swizzle.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 setup.py
 swizzle/__init__.py

swizzle-0.1.4/PKG-INFO

@@ -1,126 +0,0 @@
-Metadata-Version: 2.1
-Name: swizzle
-Version: 0.1.4
-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
-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
-### 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
-- [ ] Add support for module-level swizzling
-- [ ] Swizzle for method args (swizzle+partial)

swizzle-0.1.4/README.md

@@ -1,107 +0,0 @@
-# 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
-- [ ] Add support for module-level swizzling
-- [ ] Swizzle for method args (swizzle+partial)

swizzle-0.1.4/swizzle/__init__.py

@@ -1,80 +0,0 @@
-from functools import wraps
-import sys
-import types
-
-__version__ = "0.1.4"
-
-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()
-        

swizzle-0.1.4/swizzle.egg-info/PKG-INFO

@@ -1,126 +0,0 @@
-Metadata-Version: 2.1
-Name: swizzle
-Version: 0.1.4
-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
-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
-### 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
-- [ ] Add support for module-level swizzling
-- [ ] Swizzle for method args (swizzle+partial)