lkj 0.1.32__tar.gz → 0.1.34__tar.gz

{lkj-0.1.32 → lkj-0.1.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lkj
-Version: 0.1.32
+Version: 0.1.34
 Summary: A dump of homeless useful utils
 Home-page: https://github.com/thorwhalen/lkj
 Author: Thor Whalen

{lkj-0.1.32 → lkj-0.1.34}/lkj/__init__.py

@@ -31,30 +31,12 @@ from lkj.loggers import (
     wrapped_print,
 )
 from lkj.importing import import_object, register_namespace_forwarding
+from lkj.chunking import chunk_iterable, chunker
 from lkj.misc import identity, value_in_interval
 
 ddir = lambda obj: list(filter(lambda x: not x.startswith("_"), dir(obj)))
 
 
-def chunker(a, chk_size, *, include_tail=True):
-    """Chunks an iterable into non-overlapping chunks of size chk_size.
-
-    >>> list(chunker(range(8), 3))
-    [(0, 1, 2), (3, 4, 5), (6, 7)]
-    >>> list(chunker(range(8), 3, include_tail=False))
-    [(0, 1, 2), (3, 4, 5)]
-    """
-    from itertools import zip_longest
-
-    it = iter(a)
-    if include_tail:
-        sentinel = object()
-        for chunk in zip_longest(*([it] * chk_size), fillvalue=sentinel):
-            yield tuple(item for item in chunk if item is not sentinel)
-    else:
-        yield from zip(*([it] * chk_size))
-
-
 def user_machine_id():
     """Get an ID for the current computer/user that calls this function."""
     return __import__("platform").node()

lkj-0.1.34/lkj/chunking.py

@@ -0,0 +1,112 @@
+"""Tools for chunking (segumentation, batching, slicing, etc.)"""
+
+from itertools import zip_longest, chain, islice
+
+from typing import (
+    Iterable,
+    Union,
+    Dict,
+    List,
+    Tuple,
+    Mapping,
+    TypeVar,
+    Iterator,
+    Callable,
+    Optional,
+    T,
+)
+
+KT = TypeVar("KT")  # there's a typing.KT, but pylance won't allow me to use it!
+VT = TypeVar("VT")  # there's a typing.VT, but pylance won't allow me to use it!
+
+
+def chunk_iterable(
+    iterable: Union[Iterable[T], Mapping[KT, VT]],
+    chk_size: int,
+    *,
+    chunk_type: Optional[Callable[..., Union[Iterable[T], Mapping[KT, VT]]]] = None,
+) -> Iterator[Union[List[T], Tuple[T, ...], Dict[KT, VT]]]:
+    """
+    Divide an iterable into chunks/batches of a specific size.
+
+    Handles both mappings (e.g. dicts) and non-mappings (lists, tuples, sets...)
+    as you probably expect it to (if you give a dict input, it will chunk on the
+    (key, value) items and return dicts of these).
+    Thought note that you always can control the type of the chunks with the
+    `chunk_type` argument.
+
+    Args:
+        iterable: The iterable or mapping to divide.
+        chk_size: The size of each chunk.
+        chunk_type: The type of the chunks (list, tuple, set, dict...).
+
+    Returns:
+        An iterator of dicts if the input is a Mapping, otherwise an iterator
+        of collections (list, tuple, set...).
+
+    Examples:
+        >>> list(chunk_iterable([1, 2, 3, 4, 5], 2))
+        [[1, 2], [3, 4], [5]]
+
+        >>> list(chunk_iterable((1, 2, 3, 4, 5), 3, chunk_type=tuple))
+        [(1, 2, 3), (4, 5)]
+
+        >>> list(chunk_iterable({"a": 1, "b": 2, "c": 3}, 2))
+        [{'a': 1, 'b': 2}, {'c': 3}]
+
+        >>> list(chunk_iterable({"x": 1, "y": 2, "z": 3}, 1, chunk_type=dict))
+        [{'x': 1}, {'y': 2}, {'z': 3}]
+    """
+    if isinstance(iterable, Mapping):
+        if chunk_type is None:
+            chunk_type = dict
+        it = iter(iterable.items())
+        for first in it:
+            yield {
+                key: value for key, value in chain([first], islice(it, chk_size - 1))
+            }
+    else:
+        if chunk_type is None:
+            if isinstance(iterable, (list, tuple, set)):
+                chunk_type = type(iterable)
+            else:
+                chunk_type = list
+        it = iter(iterable)
+        for first in it:
+            yield chunk_type(chain([first], islice(it, chk_size - 1)))
+
+
+def chunker(
+    a: Iterable[T], chk_size: int, *, include_tail: bool = True
+) -> Iterator[Tuple[T, ...]]:
+    """
+    Chunks an iterable into non-overlapping chunks of size `chk_size`.
+
+    Note: This chunker is simpler, but also less efficient than `chunk_iterable`.
+    It does have the extra `include_tail` argument, though.
+    Though note that you can get the effect of `include_tail=False` in `chunk_iterable`
+    by using `filter(lambda x: len(x) == chk_size, chunk_iterable(...))`.
+
+    Args:
+        a: The iterable to be chunked.
+        chk_size: The size of each chunk.
+        include_tail: If True, includes the remaining elements as the last chunk
+                      even if they are fewer than `chk_size`. Defaults to True.
+
+    Returns:
+        An iterator of tuples, where each tuple is a chunk of size `chk_size`
+        (or fewer elements if `include_tail` is True).
+
+    Examples:
+        >>> list(chunker(range(8), 3))
+        [(0, 1, 2), (3, 4, 5), (6, 7)]
+        >>> list(chunker(range(8), 3, include_tail=False))
+        [(0, 1, 2), (3, 4, 5)]
+    """
+    it = iter(a)
+    if include_tail:
+        sentinel = object()
+        for chunk in zip_longest(*([it] * chk_size), fillvalue=sentinel):
+            yield tuple(item for item in chunk if item is not sentinel)
+    else:
+        yield from zip(*([it] * chk_size))

{lkj-0.1.32 → lkj-0.1.34}/lkj/strings.py

@@ -201,29 +201,41 @@ def regex_based_substitution(replacements: dict, regex=None, s: str = None):
     'I like orange and grapes.'
 
     You have access to the ``replacements`` and ``regex`` attributes of the
-    ``substitute`` function:
+    ``substitute`` function. See how the replacements dict has been ordered by
+    descending length of keys. This is to ensure that longer keys are replaced
+    before shorter keys, avoiding partial replacements.
 
     >>> substitute.replacements
-    {'apple': 'orange', 'banana': 'grape'}
+    {'banana': 'grape', 'apple': 'orange'}
 
     """
     import re
     from functools import partial
 
     if regex is None and s is None:
-        replacements = dict(replacements)
-
-        if not replacements:  # if replacements iterable is empty.
-            return lambda s: s  # return identity function
-
-        regex = re.compile("|".join(re.escape(key) for key in replacements.keys()))
-
-        substitute = partial(regex_based_substitution, replacements, regex)
-        substitute.replacements = replacements
+        # Sort keys by length while maintaining value alignment
+        sorted_replacements = sorted(
+            replacements.items(), key=lambda x: len(x[0]), reverse=True
+        )
+
+        # Create regex pattern from sorted keys (without escaping to allow regex)
+        sorted_keys = [pair[0] for pair in sorted_replacements]
+        sorted_values = [pair[1] for pair in sorted_replacements]
+        regex = re.compile("|".join(sorted_keys))
+
+        # Prepare the substitution function with aligned replacements
+        aligned_replacements = dict(zip(sorted_keys, sorted_values))
+        substitute = partial(regex_based_substitution, aligned_replacements, regex)
+        substitute.replacements = aligned_replacements
         substitute.regex = regex
         return substitute
-    else:
+    elif s is not None:
+        # Perform substitution using the compiled regex and aligned replacements
         return regex.sub(lambda m: replacements[m.group(0)], s)
+    else:
+        raise ValueError(
+            "Invalid usage: provide either `s` or let the function construct itself."
+        )
 
 
 from typing import Callable, Iterable, Sequence

{lkj-0.1.32 → lkj-0.1.34}/lkj.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lkj
-Version: 0.1.32
+Version: 0.1.34
 Summary: A dump of homeless useful utils
 Home-page: https://github.com/thorwhalen/lkj
 Author: Thor Whalen

{lkj-0.1.32 → lkj-0.1.34}/lkj.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 setup.cfg
 setup.py
 lkj/__init__.py
+lkj/chunking.py
 lkj/dicts.py
 lkj/filesys.py
 lkj/funcs.py

{lkj-0.1.32 → lkj-0.1.34}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = lkj
-version = 0.1.32
+version = 0.1.34
 url = https://github.com/thorwhalen/lkj
 platforms = any
 description_file = README.md