swizzle 2.3.0__tar.gz → 2.3.1__tar.gz

{swizzle-2.3.0/swizzle.egg-info → swizzle-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swizzle
-Version: 2.3.0
+Version: 2.3.1
 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

{swizzle-2.3.0 → swizzle-2.3.1}/swizzle/__init__.py

@@ -1,12 +1,16 @@
 # Copyright (c) 2024 Jan T. Müller <mail@jantmueller.com>
 
-from functools import wraps
-import types
 import builtins
 import sys as _sys
-
+import types
+import unicodedata
+from enum import EnumType
+from functools import wraps
 from keyword import iskeyword as _iskeyword
 from operator import itemgetter as _itemgetter
+
+from .trie import Trie
+
 try:
     from _collections import _tuplegetter
 except ImportError:
@@ -14,11 +18,21 @@ except ImportError:
 
 _type = builtins.type
 
-__version__ = "2.3.0"
+__version__ = "2.3.1"
 
 MISSING = object()
 
-def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=None, arrange_names = None, sep = None):
+
+def swizzledtuple(
+    typename,
+    field_names,
+    *,
+    rename=False,
+    defaults=None,
+    module=None,
+    arrange_names=None,
+    sep=None,
+):
     """
     Create a custom named tuple class with swizzled attributes, allowing for rearranged field names
     and customized attribute access.
@@ -41,9 +55,13 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
             in which fields should be arranged in the resulting named tuple. This allows for fields
             to be rearranged and, unlike standard `namedtuple`, can include duplicates. Defaults
             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 None.
+        sep (str, optional): A separator string used to control how attribute names are constructed.
+            If provided, fields will be joined using this separator to create compound attribute names.
+            Defaults to None.
+
+            Special case: If all field names have the same length `n` after optional renaming,
+            and `sep` is still None, then `sep` is automatically set to `"+n"` (e.g. "+2").
+            This indicates that names should be split every `n` characters for improved performance.
 
     Returns:
         type: A new subclass of `tuple` with named fields and customized attribute access.
@@ -69,29 +87,41 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
     """
 
     if isinstance(field_names, str):
-        field_names = field_names.replace(',', ' ').split()
+        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 = arrange_names.replace(",", " ").split()
         arrange_names = list(map(str, arrange_names))
-        assert set(arrange_names) == set(field_names), 'Arrangement must contain all field 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',]
+    _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()
+            if (
+                not name.isidentifier()
                 or _iskeyword(name)
                 or name in _dir
-                or name in seen):
-                field_names[index] = f'_{index}'
+                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):
@@ -99,20 +129,24 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
 
     for name in [typename] + field_names:
         if type(name) is not str:
-            raise TypeError('Type names and field names must be strings')
+            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}')
+            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}')
+            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 _dir:
+            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}')
+            raise ValueError(f"Encountered duplicate field name: {name!r}")
         seen.add(name)
 
     arrange_indices = [field_names.index(name) for name in arrange_names]
@@ -128,29 +162,30 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
     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)))))
+            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)
+    arg_list = ", ".join(field_names)
     if num_fields == 1:
-        arg_list += ','
-    repr_fmt = '(' + ', '.join(f'{name}=%r' for name in arrange_names) + ')'
+        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}',
+        "_tuple_new": tuple_new,
+        "__builtins__": {},
+        "__name__": f"swizzledtuple_{typename}",
     }
-    code = f'lambda _cls, {arg_list}: _tuple_new(_cls, ({arg_list}))'
+    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})'
+    __new__.__name__ = "__new__"
+    __new__.__doc__ = f"Create new instance of {typename}({arg_list})"
     if defaults is not None:
         __new__.__defaults__ = defaults
 
@@ -158,11 +193,14 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
     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)}')
+            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')
+    _make.__func__.__doc__ = (
+        f"Make a new {typename} object from a sequence " "or iterable"
+    )
 
     def _replace(self, /, **kwds):
         def generator():
@@ -174,33 +212,29 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
 
         result = self._make(iter(generator()))
         if kwds:
-            raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
+            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')
+    _replace.__doc__ = (
+        f"Return a new {typename} object replacing specified " "fields with new values"
+    )
 
     def __repr__(self):
-        'Return a nicely formatted representation string'
+        "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 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 self as a plain tuple.  Used by copy and pickle."
         return _tuple(self)
 
-    @swizzle_attributes_retriever(sep=sep, type = swizzledtuple)
+    @swizzle_attributes_retriever(sep=sep, type=swizzledtuple, only_attrs=field_names)
     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)
@@ -227,11 +261,9 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
             defaults=filtered_values,
             module=module,
             arrange_names=arrange_names[index],
-            sep=sep
+            sep=sep,
         )()
 
-
-
     for method in (
         __new__,
         _make.__func__,
@@ -240,29 +272,29 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
         _asdict,
         __getnewargs__,
         __getattribute__,
-        __getitem__
+        __getitem__,
     ):
-        method.__qualname__ = f'{typename}.{method.__name__}'
+        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__,
-        '__getitem__': __getitem__
+        "__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__,
+        "__getitem__": __getitem__,
     }
     seen = set()
     for index, name in enumerate(arrange_names):
         if name in seen:
             continue
-        doc = _sys.intern(f'Alias for field number {index}')
+        doc = _sys.intern(f"Alias for field number {index}")
         class_namespace[name] = _tuplegetter(index, doc)
         seen.add(name)
 
@@ -270,10 +302,10 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
 
     if module is None:
         try:
-            module = _sys._getframemodulename(1) or '__main__'
+            module = _sys._getframemodulename(1) or "__main__"
         except AttributeError:
             try:
-                module = _sys._getframe(1).f_globals.get('__name__', '__main__')
+                module = _sys._getframe(1).f_globals.get("__name__", "__main__")
             except (AttributeError, ValueError):
                 pass
     if module is not None:
@@ -281,27 +313,69 @@ def swizzledtuple(typename, field_names, *, rename=False, defaults=None, module=
 
     return result
 
+
 # Helper function to split a string based on a sep
 def split_string(string, sep):
-    if sep == '':
-        return list(string)
+    if sep[0] == "+":
+        n = int(sep)
+        return [string[i : i + n] for i in range(0, len(string), n)]
     else:
         return string.split(sep)
 
+
 # Helper function to collect attribute retrieval functions from a class or meta-class
 def collect_attribute_functions(cls):
     funcs = []
-    if hasattr(cls, '__getattribute__'):
+    if hasattr(cls, "__getattribute__"):
         funcs.append(cls.__getattribute__)
-    if hasattr(cls, '__getattr__'):
+    if hasattr(cls, "__getattr__"):
         funcs.append(cls.__getattr__)
     if not funcs:
-        raise AttributeError("No __getattr__ or __getattribute__ found on the class or meta-class")
+        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, sep=None, type = swizzledtuple):
+
+def is_valid_sep(s):
+    # if not s:
+    #     return False
+    if s[0] == "+" and s[1:].isdigit():
+        return True
+    for ch in s:
+        if ch == "_":
+            continue
+        cat = unicodedata.category(ch)
+        if not (cat.startswith("L") or cat == "Nd"):
+            return False
+    return True
+
+
+def swizzle_attributes_retriever(
+    attribute_funcs=None, sep=None, type=swizzledtuple, only_attrs=None
+):
+    trie = None
+
+    if sep == "":
+        sep = "+1"  # for backwards compatibility, remove on next version
+
+    if sep is None and only_attrs:
+        only_attrs_length = set(len(fname) for fname in only_attrs)
+        if len(only_attrs_length) == 1:
+            sep = f"+{next(iter(only_attrs_length))}"
+        else:
+            trie = Trie(only_attrs)
+
+    if sep is not None and not is_valid_sep(sep):
+        raise ValueError(
+            f"Invalid value for sep: {sep!r}. Must be either:"
+            " (1) a non-empty string containing only letters, digits, or underscores, "
+            "or (2) a pattern of the form '+N' where N is a positive integer."
+        )
+
     def _swizzle_attributes_retriever(attribute_funcs):
         if not isinstance(attribute_funcs, list):
             attribute_funcs = [attribute_funcs]
@@ -328,11 +402,25 @@ def swizzle_attributes_retriever(attribute_funcs=None, sep=None, type = swizzled
                 attr_parts = split_string(attr_name, sep)
                 arranged_names = attr_parts
                 for part in attr_parts:
+                    if only_attrs and part not in only_attrs:
+                        raise AttributeError(
+                            f"Attribute {part} is not part of an allowed field for swizzling"
+                        )
                     attribute = retrieve_attribute(obj, part)
                     if attribute is not MISSING:
                         matched_attributes.append(attribute)
                     else:
-                        raise AttributeError(f"No matching attribute found for part: {part}")
+                        raise AttributeError(f"No matching attribute found for {part}")
+            elif only_attrs:
+                arranged_names = trie.split_longest_prefix(attr_name)
+                if arranged_names is None:
+                    raise AttributeError(f"No matching attribute found for {attr_name}")
+                for name in arranged_names:
+                    attribute = retrieve_attribute(obj, name)
+                    if attribute is not MISSING:
+                        matched_attributes.append(attribute)
+                    else:
+                        raise AttributeError(f"No matching attribute found for {name}")
             else:
                 # No sep provided, attempt to match substrings
                 i = 0
@@ -348,7 +436,9 @@ def swizzle_attributes_retriever(attribute_funcs=None, sep=None, type = swizzled
                             match_found = True
                             break
                     if not match_found:
-                        raise AttributeError(f"No matching attribute found for substring: {attr_name[i:]}")
+                        raise AttributeError(
+                            f"No matching attribute found for substring: {attr_name[i:]}"
+                        )
 
             if type == swizzledtuple:
                 field_names = set(arranged_names)
@@ -359,11 +449,15 @@ def swizzle_attributes_retriever(attribute_funcs=None, sep=None, type = swizzled
                 elif hasattr(obj, "__class__"):
                     if hasattr(obj.__class__, "__name__"):
                         name = obj.__class__.__name__
-                result = type(name, field_names, arrange_names=arranged_names)
+                result = type(
+                    name,
+                    field_names,
+                    arrange_names=arranged_names,
+                    sep=sep,
+                )
                 result = result(*field_values)
                 return result
 
-
             return type(matched_attributes)
 
         return retrieve_swizzled_attributes
@@ -373,28 +467,66 @@ def swizzle_attributes_retriever(attribute_funcs=None, sep=None, type = swizzled
     else:
         return _swizzle_attributes_retriever
 
-# Decorator function to enable swizzling for a class
-def swizzle(cls=None, meta=False, sep=None, type = tuple):
+
+def swizzle(cls=None, meta=False, sep=None, type=tuple, only_attrs=None):
+
+    def preserve_metadata(
+        target,
+        source,
+        keys=("__name__", "__qualname__", "__doc__", "__module__", "__annotations__"),
+    ):
+        for key in keys:
+            if hasattr(source, key):
+                try:
+                    setattr(target, key, getattr(source, key))
+                except (TypeError, AttributeError):
+                    pass  # some attributes may be read-only
 
     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, sep, type))
+        setattr(
+            cls,
+            attribute_funcs[-1].__name__,
+            swizzle_attributes_retriever(attribute_funcs, sep, type, only_attrs),
+        )
 
         # Handle meta-class swizzling if requested
         if meta:
             meta_cls = _type(cls)
-            if meta_cls == _type:
-                class SwizzledMetaType(meta_cls):
+
+            class SwizzledMetaType(meta_cls):
+                pass
+
+            if meta_cls == EnumType:
+
+                def cfem_dummy(*args, **kwargs):
                     pass
-                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, sep, type))
+                cfem = SwizzledMetaType._check_for_existing_members_
+                SwizzledMetaType._check_for_existing_members_ = cfem_dummy
+
+            class SwizzledClass(cls, metaclass=SwizzledMetaType):
+                pass
+
+            if meta_cls == EnumType:
+                SwizzledMetaType._check_for_existing_members_ = cfem
 
+            # Preserve metadata on swizzled meta and class
+            preserve_metadata(SwizzledMetaType, meta_cls)
+            preserve_metadata(SwizzledClass, cls)
+
+            meta_cls = SwizzledMetaType
+            cls = SwizzledClass
+
+            meta_funcs = collect_attribute_functions(meta_cls)
+            setattr(
+                meta_cls,
+                meta_funcs[-1].__name__,
+                swizzle_attributes_retriever(meta_funcs, sep, type, only_attrs),
+            )
         return cls
 
     if cls is None:
@@ -408,7 +540,10 @@ class Swizzle(types.ModuleType):
         types.ModuleType.__init__(self, __name__)
         self.__dict__.update(_sys.modules[__name__].__dict__)
 
-    def __call__(self, cls=None, meta=False, sep = None, type = swizzledtuple):
-        return swizzle(cls, meta, sep, type)
+    def __call__(
+        self, cls=None, meta=False, sep=None, type=swizzledtuple, only_attrs=None
+    ):
+        return swizzle(cls, meta, sep, type, only_attrs)
+
 
 _sys.modules[__name__] = Swizzle()

swizzle-2.3.1/swizzle/trie.py

@@ -0,0 +1,61 @@
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.is_end = False
+
+    def add(self, word):
+        node = self
+        for char in word:
+            if char not in node.children:
+                node.children[char] = TrieNode()
+            node = node.children[char]
+        node.is_end = True
+
+    def step(self, char):
+        return self.children.get(char)
+
+
+class Trie:
+    def __init__(self, words=None):
+        self.root = TrieNode()
+        if words:
+            for word in words:
+                self.add(word)
+
+    def add(self, word):
+        self.root.add(word)
+
+    def split_longest_prefix(self, query):
+        result = []
+        length = len(query)
+        i = 0
+        while i < length:
+            node = self.root
+            longest_end = -1
+            j = i
+            children = node.children  # cache children dict
+            while j < length:
+                next_node = children.get(query[j])
+                if not next_node:
+                    break
+                node = next_node
+                children = node.children  # update cache
+                j += 1
+                if node.is_end:
+                    longest_end = j
+            if longest_end == -1:
+                return None
+            result.append(query[i:longest_end])
+            i = longest_end
+        return result
+
+
+if __name__ == "__main__":
+    words = ["mango", "man", "go", "bat", "manbat"]
+    trie = Trie(words)
+
+    print(trie.split_longest_prefix("mangomanmanbat"))  # ['mango', 'man', 'bat']
+    print(trie.split_longest_prefix("manbat"))  # ['manbat']
+    print(trie.split_longest_prefix("mango"))  # ['mango']
+    print(trie.split_longest_prefix("mangoman"))  # ['mango', 'man']
+    print(trie.split_longest_prefix("unknownword"))  # None

{swizzle-2.3.0 → swizzle-2.3.1/swizzle.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swizzle
-Version: 2.3.0
+Version: 2.3.1
 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

{swizzle-2.3.0 → swizzle-2.3.1}/swizzle.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 setup.py
 swizzle/__init__.py
+swizzle/trie.py
 swizzle.egg-info/PKG-INFO
 swizzle.egg-info/SOURCES.txt
 swizzle.egg-info/dependency_links.txt