scikit-base 0.4.6__py3-none-any.whl → 0.5.1__py3-none-any.whl

skbase/utils/_nested_iter.py

@@ -1,180 +1,180 @@
-#!/usr/bin/env python3 -u
-# -*- coding: utf-8 -*-
-# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
-"""Functionality for working with nested sequences."""
-import collections
-from typing import List
-
-__author__: List[str] = ["RNKuhns", "fkiraly"]
-__all__: List[str] = [
-    "flatten",
-    "is_flat",
-    "_remove_single",
-    "unflat_len",
-    "unflatten",
-]
-
-
-def _remove_single(x):
-    """Remove tuple wrapping from singleton.
-
-    If the input has length 1, then the single value is extracted from the input.
-    Otherwise, the input is returned unchanged.
-
-    Parameters
-    ----------
-    x : Sequence
-        The sequence to remove a singleton value from.
-
-    Returns
-    -------
-    Any
-        The singleton value of x if x[0] is a singleton, otherwise x.
-
-    Examples
-    --------
-    >>> from skbase.utils._nested_iter import _remove_single
-    >>> _remove_single([1])
-    1
-    >>> _remove_single([1, 2, 3])
-    [1, 2, 3]
-    """
-    if len(x) == 1:
-        return x[0]
-    else:
-        return x
-
-
-def flatten(obj):
-    """Flatten nested list/tuple structure.
-
-    Converts a nested iterable or sequence to a flat output iterable/sequence
-    with the same and order of elements.
-
-    Parameters
-    ----------
-    obj : Any
-        The object to be flattened from a nested iterable/sequence structure.
-
-    Returns
-    -------
-    Sequence or Iterable
-        flat iterable/sequence, containing non-list/tuple elements in obj in
-        same order as in obj.
-
-    Examples
-    --------
-    >>> from skbase.utils import flatten
-    >>> flatten([1, 2, [3, (4, 5)], 6])
-    [1, 2, 3, 4, 5, 6]
-    """
-    if not isinstance(
-        obj, (collections.abc.Iterable, collections.abc.Sequence)
-    ) or isinstance(obj, str):
-        return [obj]
-    else:
-        return type(obj)([y for x in obj for y in flatten(x)])
-
-
-def unflatten(obj, template):
-    """Invert flattening given given template for nested list/tuple structure.
-
-    Converts an input list or tuple to a nested structure as provided in `template`
-    while preserving the order of elements in the input.
-
-    Parameters
-    ----------
-    obj : list or tuple
-        The object to be unflattened.
-    template : nested list/tuple structure
-        Number of non-list/tuple elements of obj and template must be equal.
-
-    Returns
-    -------
-    list or tuple
-        Input coerced to have elements with nested list/tuples structure exactly
-        as `template` and elements in sequence exactly as `obj`.
-
-    Examples
-    --------
-    >>> from skbase.utils import unflatten
-    >>> unflatten([1, 2, 3, 4, 5, 6], [6, 3, [5, (2, 4)], 1])
-    [1, 2, [3, (4, 5)], 6]
-    """
-    if not isinstance(template, (list, tuple)):
-        return obj[0]
-
-    list_or_tuple = type(template)
-    ls = [unflat_len(x) for x in template]
-    for i in range(1, len(ls)):
-        ls[i] += ls[i - 1]
-    ls = [0] + ls
-
-    res = [unflatten(obj[ls[i] : ls[i + 1]], template[i]) for i in range(len(ls) - 1)]
-
-    return list_or_tuple(res)
-
-
-def unflat_len(obj):
-    """Return number of elements in nested iterable or sequence structure.
-
-    Determines the total number of elements in a nested iterable/sequence structure.
-    Input that is not a iterable or sequence is considered to have length 1.
-
-    Parameters
-    ----------
-    obj : Any
-        Object to determine the unflat length.
-
-    Returns
-    -------
-    int
-        The unflat length of the input.
-
-    Examples
-    --------
-    >>> from skbase.utils import unflat_len
-    >>> unflat_len(7)
-    1
-    >>> unflat_len((1, 2))
-    2
-    >>> unflat_len([1, (2, 3), 4, 5])
-    5
-    """
-    if not isinstance(
-        obj, (collections.abc.Iterable, collections.abc.Sequence)
-    ) or isinstance(obj, str):
-        return 1
-    else:
-        return sum([unflat_len(x) for x in obj])
-
-
-def is_flat(obj):
-    """Check whether iterable or sequence is flat.
-
-    If any elements are iterables or sequences the object is considered to not be flat.
-
-    Parameters
-    ----------
-    obj : Any
-        The object to check to see if it is flat (does not have nested iterable).
-
-    Returns
-    -------
-    bool
-        Whether or not the input `obj` contains nested iterables.
-
-    Examples
-    --------
-    >>> from skbase.utils import is_flat
-    >>> is_flat([1, 2, 3, 4, 5])
-    True
-    >>> is_flat([1, (2, 3), 4, 5])
-    False
-    """
-    elements_flat = (
-        isinstance(x, (collections.abc.Iterable, collections.abc.Sequence))
-        and not isinstance(x, str)
-        for x in obj
-    )
-    return not any(elements_flat)
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Functionality for working with nested sequences."""
+import collections
+from typing import List
+
+__author__: List[str] = ["RNKuhns", "fkiraly"]
+__all__: List[str] = [
+    "flatten",
+    "is_flat",
+    "_remove_single",
+    "unflat_len",
+    "unflatten",
+]
+
+
+def _remove_single(x):
+    """Remove tuple wrapping from singleton.
+
+    If the input has length 1, then the single value is extracted from the input.
+    Otherwise, the input is returned unchanged.
+
+    Parameters
+    ----------
+    x : Sequence
+        The sequence to remove a singleton value from.
+
+    Returns
+    -------
+    Any
+        The singleton value of x if x[0] is a singleton, otherwise x.
+
+    Examples
+    --------
+    >>> from skbase.utils._nested_iter import _remove_single
+    >>> _remove_single([1])
+    1
+    >>> _remove_single([1, 2, 3])
+    [1, 2, 3]
+    """
+    if len(x) == 1:
+        return x[0]
+    else:
+        return x
+
+
+def flatten(obj):
+    """Flatten nested list/tuple structure.
+
+    Converts a nested iterable or sequence to a flat output iterable/sequence
+    with the same and order of elements.
+
+    Parameters
+    ----------
+    obj : Any
+        The object to be flattened from a nested iterable/sequence structure.
+
+    Returns
+    -------
+    Sequence or Iterable
+        flat iterable/sequence, containing non-list/tuple elements in obj in
+        same order as in obj.
+
+    Examples
+    --------
+    >>> from skbase.utils import flatten
+    >>> flatten([1, 2, [3, (4, 5)], 6])
+    [1, 2, 3, 4, 5, 6]
+    """
+    if not isinstance(
+        obj, (collections.abc.Iterable, collections.abc.Sequence)
+    ) or isinstance(obj, str):
+        return [obj]
+    else:
+        return type(obj)([y for x in obj for y in flatten(x)])
+
+
+def unflatten(obj, template):
+    """Invert flattening given given template for nested list/tuple structure.
+
+    Converts an input list or tuple to a nested structure as provided in `template`
+    while preserving the order of elements in the input.
+
+    Parameters
+    ----------
+    obj : list or tuple
+        The object to be unflattened.
+    template : nested list/tuple structure
+        Number of non-list/tuple elements of obj and template must be equal.
+
+    Returns
+    -------
+    list or tuple
+        Input coerced to have elements with nested list/tuples structure exactly
+        as `template` and elements in sequence exactly as `obj`.
+
+    Examples
+    --------
+    >>> from skbase.utils import unflatten
+    >>> unflatten([1, 2, 3, 4, 5, 6], [6, 3, [5, (2, 4)], 1])
+    [1, 2, [3, (4, 5)], 6]
+    """
+    if not isinstance(template, (list, tuple)):
+        return obj[0]
+
+    list_or_tuple = type(template)
+    ls = [unflat_len(x) for x in template]
+    for i in range(1, len(ls)):
+        ls[i] += ls[i - 1]
+    ls = [0] + ls
+
+    res = [unflatten(obj[ls[i] : ls[i + 1]], template[i]) for i in range(len(ls) - 1)]
+
+    return list_or_tuple(res)
+
+
+def unflat_len(obj):
+    """Return number of elements in nested iterable or sequence structure.
+
+    Determines the total number of elements in a nested iterable/sequence structure.
+    Input that is not a iterable or sequence is considered to have length 1.
+
+    Parameters
+    ----------
+    obj : Any
+        Object to determine the unflat length.
+
+    Returns
+    -------
+    int
+        The unflat length of the input.
+
+    Examples
+    --------
+    >>> from skbase.utils import unflat_len
+    >>> unflat_len(7)
+    1
+    >>> unflat_len((1, 2))
+    2
+    >>> unflat_len([1, (2, 3), 4, 5])
+    5
+    """
+    if not isinstance(
+        obj, (collections.abc.Iterable, collections.abc.Sequence)
+    ) or isinstance(obj, str):
+        return 1
+    else:
+        return sum([unflat_len(x) for x in obj])
+
+
+def is_flat(obj):
+    """Check whether iterable or sequence is flat.
+
+    If any elements are iterables or sequences the object is considered to not be flat.
+
+    Parameters
+    ----------
+    obj : Any
+        The object to check to see if it is flat (does not have nested iterable).
+
+    Returns
+    -------
+    bool
+        Whether or not the input `obj` contains nested iterables.
+
+    Examples
+    --------
+    >>> from skbase.utils import is_flat
+    >>> is_flat([1, 2, 3, 4, 5])
+    True
+    >>> is_flat([1, (2, 3), 4, 5])
+    False
+    """
+    elements_flat = (
+        isinstance(x, (collections.abc.Iterable, collections.abc.Sequence))
+        and not isinstance(x, str)
+        for x in obj
+    )
+    return not any(elements_flat)

skbase/utils/_utils.py

@@ -1,91 +1,91 @@
-#!/usr/bin/env python3 -u
-# -*- coding: utf-8 -*-
-# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
-"""Functionality for working with sequences."""
-from typing import Any, Iterable, List, MutableMapping, Optional, Union
-
-__author__: List[str] = ["RNKuhns"]
-__all__: List[str] = ["subset_dict_keys"]
-
-
-def subset_dict_keys(
-    input_dict: MutableMapping[Any, Any],
-    keys: Union[Iterable, int, float, bool, str, type],
-    prefix: Optional[str] = None,
-    remove_prefix: bool = True,
-):
-    """Subset dictionary so it only contains specified keys.
-
-    Subsets `input_dict` so that it only contains `keys`. If `prefix` is passed,
-    subsets to `f"{prefix}__{key}"` for all `key` in `keys`. When
-    ``remove_prefix=True`` the the prefix is removed from the keys of the
-    return dictionary (For any keys with prefix the return is `{key}` instead
-    of `f"{prefix}__{key}"`).
-
-    Parameters
-    ----------
-    input_dict : dict
-        Dictionary to subset by keys
-    keys : iterable, int, float, bool, str or type
-        The keys that should be retained in the output dictionary.
-    prefix : str, default=None
-        An optional prefix that is added to all keys. If `prefix` is passed,
-        the passed keys are converted to `f"{prefix}__{key}"` when subsetting
-        the dictionary. Results in all keys being coerced to str.
-    remove_prefix : bool, default=True
-        Whether to remove prefix in output keys.
-
-    Returns
-    -------
-    `subsetted_dict` : dict
-        `dict_to_subset` subset to keys in `keys` described as above
-
-    Notes
-    -----
-    Passing `prefix` will turn non-str keys into str keys.
-
-    Examples
-    --------
-    >>> from skbase.utils import subset_dict_keys
-    >>> some_dict = {"some_param__a": 1, "some_param__b": 2, "some_param__c": 3}
-
-    >>> subset_dict_keys(some_dict, "some_param__a")
-    {'some_param__a': 1}
-
-    >>> subset_dict_keys(some_dict, ("some_param__a", "some_param__b"))
-    {'some_param__a': 1, 'some_param__b': 2}
-
-    >>> subset_dict_keys(some_dict, ("a", "b"), prefix="some_param")
-    {'a': 1, 'b': 2}
-
-    >>> subset_dict_keys(some_dict, ("a", "b"), prefix="some_param", \
-    remove_prefix=False)
-    {'some_param__a': 1, 'some_param__b': 2}
-
-    >>> subset_dict_keys(some_dict, \
-    (c for c in ("some_param__a", "some_param__b")))
-    {'some_param__a': 1, 'some_param__b': 2}
-    """
-
-    def rem_prefix(x):
-        if not remove_prefix or prefix is None:
-            return x
-        prefix__ = f"{prefix}__"
-        if x.startswith(prefix__):
-            return x[len(prefix__) :]
-        # The way this is used below, this else shouldn't really execute
-        # But its here for completeness in case something goes wrong
-        else:
-            return x  # pragma: no cover
-
-    # Handle passage of certain scalar values
-    if isinstance(keys, (str, float, int, bool, type)):
-        keys = [keys]
-
-    if prefix is not None:
-        keys = [f"{prefix}__{key}" for key in keys]
-    else:
-        keys = list(keys)
-    subsetted_dict = {rem_prefix(k): v for k, v in input_dict.items() if k in keys}
-
-    return subsetted_dict
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Functionality for working with sequences."""
+from typing import Any, Iterable, List, MutableMapping, Optional, Union
+
+__author__: List[str] = ["RNKuhns"]
+__all__: List[str] = ["subset_dict_keys"]
+
+
+def subset_dict_keys(
+    input_dict: MutableMapping[Any, Any],
+    keys: Union[Iterable, int, float, bool, str, type],
+    prefix: Optional[str] = None,
+    remove_prefix: bool = True,
+):
+    """Subset dictionary so it only contains specified keys.
+
+    Subsets `input_dict` so that it only contains `keys`. If `prefix` is passed,
+    subsets to `f"{prefix}__{key}"` for all `key` in `keys`. When
+    ``remove_prefix=True`` the the prefix is removed from the keys of the
+    return dictionary (For any keys with prefix the return is `{key}` instead
+    of `f"{prefix}__{key}"`).
+
+    Parameters
+    ----------
+    input_dict : dict
+        Dictionary to subset by keys
+    keys : iterable, int, float, bool, str or type
+        The keys that should be retained in the output dictionary.
+    prefix : str, default=None
+        An optional prefix that is added to all keys. If `prefix` is passed,
+        the passed keys are converted to `f"{prefix}__{key}"` when subsetting
+        the dictionary. Results in all keys being coerced to str.
+    remove_prefix : bool, default=True
+        Whether to remove prefix in output keys.
+
+    Returns
+    -------
+    `subsetted_dict` : dict
+        `dict_to_subset` subset to keys in `keys` described as above
+
+    Notes
+    -----
+    Passing `prefix` will turn non-str keys into str keys.
+
+    Examples
+    --------
+    >>> from skbase.utils import subset_dict_keys
+    >>> some_dict = {"some_param__a": 1, "some_param__b": 2, "some_param__c": 3}
+
+    >>> subset_dict_keys(some_dict, "some_param__a")
+    {'some_param__a': 1}
+
+    >>> subset_dict_keys(some_dict, ("some_param__a", "some_param__b"))
+    {'some_param__a': 1, 'some_param__b': 2}
+
+    >>> subset_dict_keys(some_dict, ("a", "b"), prefix="some_param")
+    {'a': 1, 'b': 2}
+
+    >>> subset_dict_keys(some_dict, ("a", "b"), prefix="some_param", \
+    remove_prefix=False)
+    {'some_param__a': 1, 'some_param__b': 2}
+
+    >>> subset_dict_keys(some_dict, \
+    (c for c in ("some_param__a", "some_param__b")))
+    {'some_param__a': 1, 'some_param__b': 2}
+    """
+
+    def rem_prefix(x):
+        if not remove_prefix or prefix is None:
+            return x
+        prefix__ = f"{prefix}__"
+        if x.startswith(prefix__):
+            return x[len(prefix__) :]
+        # The way this is used below, this else shouldn't really execute
+        # But its here for completeness in case something goes wrong
+        else:
+            return x  # pragma: no cover
+
+    # Handle passage of certain scalar values
+    if isinstance(keys, (str, float, int, bool, type)):
+        keys = [keys]
+
+    if prefix is not None:
+        keys = [f"{prefix}__{key}" for key in keys]
+    else:
+        keys = list(keys)
+    subsetted_dict = {rem_prefix(k): v for k, v in input_dict.items() if k in keys}
+
+    return subsetted_dict