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

skbase/utils/tests/test_iter.py

@@ -1,127 +1,127 @@
-#!/usr/bin/env python3 -u
-# -*- coding: utf-8 -*-
-# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
-"""Tests of the functionality for working with iterables.
-
-tests in this module incdlue:
-
-- test_format_seq_to_str: verify that _format_seq_to_str outputs expected format.
-- test_format_seq_to_str_raises: verify _format_seq_to_str raises error on unexpected
-  output.
-- test_scalar_to_seq_expected_output: verify that _scalar_to_seq returns exepcted
-  output.
-- test_scalar_to_seq_raises: verify that _scalar_to_seq raises error when an
-  invalid value is provided for sequence_type parameter.
-- test_make_strings_unique_output: verify make_strings_unique output is expected.
-"""
-import pytest
-
-from skbase.base import BaseEstimator, BaseObject
-from skbase.utils._iter import _format_seq_to_str, _scalar_to_seq, make_strings_unique
-
-__author__ = ["RNKuhns"]
-
-
-def test_format_seq_to_str():
-    """Test _format_seq_to_str returns expected output."""
-    # Test basic functionality (including ability to handle str and non-str)
-    seq = [1, 2, "3", 4]
-    assert _format_seq_to_str(seq) == "1, 2, 3, 4"
-
-    # Test use of last_sep
-    assert _format_seq_to_str(seq, last_sep="and") == "1, 2, 3 and 4"
-    assert _format_seq_to_str(seq, last_sep="or") == "1, 2, 3 or 4"
-
-    # Test use of different sep argument
-    assert _format_seq_to_str(seq, sep=";") == "1;2;3;4"
-
-    # Verify things work with BaseObject and BaseEstimator instances
-    seq = [BaseEstimator(), BaseObject(), 1]
-    assert _format_seq_to_str(seq) == "BaseEstimator(), BaseObject(), 1"
-
-    # Test use of last_sep
-    assert (
-        _format_seq_to_str(seq, last_sep="and") == "BaseEstimator(), BaseObject() and 1"
-    )
-    assert (
-        _format_seq_to_str(seq, last_sep="or") == "BaseEstimator(), BaseObject() or 1"
-    )
-
-    # Test use of different sep argument
-    assert _format_seq_to_str(seq, sep=";") == "BaseEstimator();BaseObject();1"
-
-    # Test using remove_type_text keyword
-    assert (
-        _format_seq_to_str([list, tuple], remove_type_text=False)
-        == "<class 'list'>, <class 'tuple'>"
-    )
-    assert _format_seq_to_str([list, tuple], remove_type_text=True) == "list, tuple"
-    assert (
-        _format_seq_to_str([list, tuple], last_sep="and", remove_type_text=True)
-        == "list and tuple"
-    )
-
-    # Test with scalar inputs
-    assert _format_seq_to_str(7) == "7"  # int, float, bool primitives cast to str
-    assert _format_seq_to_str("some_str") == "some_str"
-    # Verify that keywords don't affect output
-    assert _format_seq_to_str(7, sep=";") == "7"
-    assert _format_seq_to_str(7, last_sep="or") == "7"
-    # Verify with types
-    assert _format_seq_to_str(object) == "object"
-    assert _format_seq_to_str(int) == "int"
-
-
-def test_format_seq_to_str_raises():
-    """Test _format_seq_to_str raises error when input is unexpected type."""
-    with pytest.raises(TypeError, match="`seq` must be a sequence or scalar.*"):
-        _format_seq_to_str((c for c in [1, 2, 3]))
-
-
-def test_scalar_to_seq_expected_output():
-    """Test _scalar_to_seq returns expected output."""
-    assert _scalar_to_seq(7) == (7,)
-    # Verify it works with scalar classes and objects
-    assert _scalar_to_seq(BaseObject) == (BaseObject,)
-    assert _scalar_to_seq(BaseObject()) == (BaseObject(),)
-    # Verify strings treated like scalar not sequence
-    assert _scalar_to_seq("some_str") == ("some_str",)
-    assert _scalar_to_seq("some_str", sequence_type=list) == ["some_str"]
-
-    # Verify sequences returned unchanged
-    assert _scalar_to_seq((1, 2)) == (1, 2)
-
-
-def test_scalar_to_seq_raises():
-    """Test scalar_to_seq raises error when `sequence_type` is unexpected type."""
-    with pytest.raises(
-        ValueError,
-        match="`sequence_type` must be a subclass of collections.abc.Sequence.",
-    ):
-        _scalar_to_seq(7, sequence_type=int)
-
-    with pytest.raises(
-        ValueError,
-        match="`sequence_type` must be a subclass of collections.abc.Sequence.",
-    ):
-        _scalar_to_seq(7, sequence_type=dict)
-
-
-def test_make_strings_unique_output():
-    """Test make_strings_unique outputs expected unique strings."""
-    # case with already unique string list
-    some_strs = ["abc", "bcd"]
-    assert make_strings_unique(some_strs) == ["abc", "bcd"]
-    # Case where some strings repeated
-    some_strs = ["abc", "abc", "bcd"]
-    assert make_strings_unique(some_strs) == ["abc_1", "abc_2", "bcd"]
-    # Case when input is tuple
-    assert make_strings_unique(tuple(some_strs)) == ("abc_1", "abc_2", "bcd")
-
-    # Case where more than one level of making things unique is needed
-    some_strs = ["abc", "abc", "bcd", "abc_1"]
-    assert make_strings_unique(some_strs) == ["abc_1_1", "abc_2", "bcd", "abc_1_2"]
-
-    # Case when input is not flat
-    some_strs = ["abc_1", ("abc_2", "bcd")]
-    assert make_strings_unique(some_strs) == ["abc_1", ("abc_2", "bcd")]
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Tests of the functionality for working with iterables.
+
+tests in this module incdlue:
+
+- test_format_seq_to_str: verify that _format_seq_to_str outputs expected format.
+- test_format_seq_to_str_raises: verify _format_seq_to_str raises error on unexpected
+  output.
+- test_scalar_to_seq_expected_output: verify that _scalar_to_seq returns exepcted
+  output.
+- test_scalar_to_seq_raises: verify that _scalar_to_seq raises error when an
+  invalid value is provided for sequence_type parameter.
+- test_make_strings_unique_output: verify make_strings_unique output is expected.
+"""
+import pytest
+
+from skbase.base import BaseEstimator, BaseObject
+from skbase.utils._iter import _format_seq_to_str, _scalar_to_seq, make_strings_unique
+
+__author__ = ["RNKuhns"]
+
+
+def test_format_seq_to_str():
+    """Test _format_seq_to_str returns expected output."""
+    # Test basic functionality (including ability to handle str and non-str)
+    seq = [1, 2, "3", 4]
+    assert _format_seq_to_str(seq) == "1, 2, 3, 4"
+
+    # Test use of last_sep
+    assert _format_seq_to_str(seq, last_sep="and") == "1, 2, 3 and 4"
+    assert _format_seq_to_str(seq, last_sep="or") == "1, 2, 3 or 4"
+
+    # Test use of different sep argument
+    assert _format_seq_to_str(seq, sep=";") == "1;2;3;4"
+
+    # Verify things work with BaseObject and BaseEstimator instances
+    seq = [BaseEstimator(), BaseObject(), 1]
+    assert _format_seq_to_str(seq) == "BaseEstimator(), BaseObject(), 1"
+
+    # Test use of last_sep
+    assert (
+        _format_seq_to_str(seq, last_sep="and") == "BaseEstimator(), BaseObject() and 1"
+    )
+    assert (
+        _format_seq_to_str(seq, last_sep="or") == "BaseEstimator(), BaseObject() or 1"
+    )
+
+    # Test use of different sep argument
+    assert _format_seq_to_str(seq, sep=";") == "BaseEstimator();BaseObject();1"
+
+    # Test using remove_type_text keyword
+    assert (
+        _format_seq_to_str([list, tuple], remove_type_text=False)
+        == "<class 'list'>, <class 'tuple'>"
+    )
+    assert _format_seq_to_str([list, tuple], remove_type_text=True) == "list, tuple"
+    assert (
+        _format_seq_to_str([list, tuple], last_sep="and", remove_type_text=True)
+        == "list and tuple"
+    )
+
+    # Test with scalar inputs
+    assert _format_seq_to_str(7) == "7"  # int, float, bool primitives cast to str
+    assert _format_seq_to_str("some_str") == "some_str"
+    # Verify that keywords don't affect output
+    assert _format_seq_to_str(7, sep=";") == "7"
+    assert _format_seq_to_str(7, last_sep="or") == "7"
+    # Verify with types
+    assert _format_seq_to_str(object) == "object"
+    assert _format_seq_to_str(int) == "int"
+
+
+def test_format_seq_to_str_raises():
+    """Test _format_seq_to_str raises error when input is unexpected type."""
+    with pytest.raises(TypeError, match="`seq` must be a sequence or scalar.*"):
+        _format_seq_to_str((c for c in [1, 2, 3]))
+
+
+def test_scalar_to_seq_expected_output():
+    """Test _scalar_to_seq returns expected output."""
+    assert _scalar_to_seq(7) == (7,)
+    # Verify it works with scalar classes and objects
+    assert _scalar_to_seq(BaseObject) == (BaseObject,)
+    assert _scalar_to_seq(BaseObject()) == (BaseObject(),)
+    # Verify strings treated like scalar not sequence
+    assert _scalar_to_seq("some_str") == ("some_str",)
+    assert _scalar_to_seq("some_str", sequence_type=list) == ["some_str"]
+
+    # Verify sequences returned unchanged
+    assert _scalar_to_seq((1, 2)) == (1, 2)
+
+
+def test_scalar_to_seq_raises():
+    """Test scalar_to_seq raises error when `sequence_type` is unexpected type."""
+    with pytest.raises(
+        ValueError,
+        match="`sequence_type` must be a subclass of collections.abc.Sequence.",
+    ):
+        _scalar_to_seq(7, sequence_type=int)
+
+    with pytest.raises(
+        ValueError,
+        match="`sequence_type` must be a subclass of collections.abc.Sequence.",
+    ):
+        _scalar_to_seq(7, sequence_type=dict)
+
+
+def test_make_strings_unique_output():
+    """Test make_strings_unique outputs expected unique strings."""
+    # case with already unique string list
+    some_strs = ["abc", "bcd"]
+    assert make_strings_unique(some_strs) == ["abc", "bcd"]
+    # Case where some strings repeated
+    some_strs = ["abc", "abc", "bcd"]
+    assert make_strings_unique(some_strs) == ["abc_1", "abc_2", "bcd"]
+    # Case when input is tuple
+    assert make_strings_unique(tuple(some_strs)) == ("abc_1", "abc_2", "bcd")
+
+    # Case where more than one level of making things unique is needed
+    some_strs = ["abc", "abc", "bcd", "abc_1"]
+    assert make_strings_unique(some_strs) == ["abc_1_1", "abc_2", "bcd", "abc_1_2"]
+
+    # Case when input is not flat
+    some_strs = ["abc_1", ("abc_2", "bcd")]
+    assert make_strings_unique(some_strs) == ["abc_1", ("abc_2", "bcd")]

skbase/utils/tests/test_nested_iter.py

@@ -1,84 +1,84 @@
-#!/usr/bin/env python3 -u
-# -*- coding: utf-8 -*-
-# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
-"""Tests of the functionality for working with iterables.
-
-tests in this module incdlue:
-
-- test_remove_single
-- test_flatten
-- test_unflatten
-- test_unflat_len
-- test_is_flat
-"""
-# import pytest
-
-from skbase.base import BaseEstimator, BaseObject
-from skbase.utils._nested_iter import (
-    _remove_single,
-    flatten,
-    is_flat,
-    unflat_len,
-    unflatten,
-)
-
-__author__ = ["RNKuhns"]
-
-
-def test_remove_single():
-    """Test _remove_single output is as expected."""
-    # Verify that length > 1 sequence not impacted.
-    assert _remove_single([1, 2, 3]) == [1, 2, 3]
-
-    # Verify single member of sequence is removed as expected
-    assert _remove_single([1]) == 1
-
-
-def test_flatten():
-    """Test flatten output is as expected."""
-    assert flatten([1, 2, [3, (4, 5)], 6]) == [1, 2, 3, 4, 5, 6]
-
-    # Verify functionality with classes and objects
-    assert flatten((BaseObject, 7, (BaseObject, BaseEstimator))) == (
-        BaseObject,
-        7,
-        BaseObject,
-        BaseEstimator,
-    )
-    assert flatten((BaseObject(), 7, (BaseObject, BaseEstimator()))) == (
-        BaseObject(),
-        7,
-        BaseObject,
-        BaseEstimator(),
-    )
-
-
-def test_unflatten():
-    """Test output of unflatten."""
-    assert unflatten([1, 2, 3, 4, 5, 6], [6, 3, [5, (2, 4)], 1]) == [
-        1,
-        2,
-        [3, (4, 5)],
-        6,
-    ]
-
-
-def test_unflat_len():
-    """Test output of unflat_len."""
-    assert unflat_len(7) == 1
-    assert unflat_len((1, 2)) == 2
-    assert unflat_len([1, (2, 3), 4, 5]) == 5
-    assert unflat_len([1, 2, (c for c in (2, 3, 4))]) == 5
-    assert unflat_len((c for c in [1, 2, (c for c in (2, 3, 4))])) == 5
-
-
-def test_is_flat():
-    """Test output of is_flat."""
-    assert is_flat([1, 2, 3, 4, 5]) is True
-    assert is_flat([1, (2, 3), 4, 5]) is False
-    # Check with flat generator
-    assert is_flat((c for c in [1, 2, 3])) is True
-    # Check with nested generator
-    assert is_flat([1, 2, (c for c in (2, 3, 4))]) is False
-    # Check with generator nested in a generator
-    assert is_flat((c for c in [1, 2, (c for c in (2, 3, 4))])) is False
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Tests of the functionality for working with iterables.
+
+tests in this module incdlue:
+
+- test_remove_single
+- test_flatten
+- test_unflatten
+- test_unflat_len
+- test_is_flat
+"""
+# import pytest
+
+from skbase.base import BaseEstimator, BaseObject
+from skbase.utils._nested_iter import (
+    _remove_single,
+    flatten,
+    is_flat,
+    unflat_len,
+    unflatten,
+)
+
+__author__ = ["RNKuhns"]
+
+
+def test_remove_single():
+    """Test _remove_single output is as expected."""
+    # Verify that length > 1 sequence not impacted.
+    assert _remove_single([1, 2, 3]) == [1, 2, 3]
+
+    # Verify single member of sequence is removed as expected
+    assert _remove_single([1]) == 1
+
+
+def test_flatten():
+    """Test flatten output is as expected."""
+    assert flatten([1, 2, [3, (4, 5)], 6]) == [1, 2, 3, 4, 5, 6]
+
+    # Verify functionality with classes and objects
+    assert flatten((BaseObject, 7, (BaseObject, BaseEstimator))) == (
+        BaseObject,
+        7,
+        BaseObject,
+        BaseEstimator,
+    )
+    assert flatten((BaseObject(), 7, (BaseObject, BaseEstimator()))) == (
+        BaseObject(),
+        7,
+        BaseObject,
+        BaseEstimator(),
+    )
+
+
+def test_unflatten():
+    """Test output of unflatten."""
+    assert unflatten([1, 2, 3, 4, 5, 6], [6, 3, [5, (2, 4)], 1]) == [
+        1,
+        2,
+        [3, (4, 5)],
+        6,
+    ]
+
+
+def test_unflat_len():
+    """Test output of unflat_len."""
+    assert unflat_len(7) == 1
+    assert unflat_len((1, 2)) == 2
+    assert unflat_len([1, (2, 3), 4, 5]) == 5
+    assert unflat_len([1, 2, (c for c in (2, 3, 4))]) == 5
+    assert unflat_len((c for c in [1, 2, (c for c in (2, 3, 4))])) == 5
+
+
+def test_is_flat():
+    """Test output of is_flat."""
+    assert is_flat([1, 2, 3, 4, 5]) is True
+    assert is_flat([1, (2, 3), 4, 5]) is False
+    # Check with flat generator
+    assert is_flat((c for c in [1, 2, 3])) is True
+    # Check with nested generator
+    assert is_flat([1, 2, (c for c in (2, 3, 4))]) is False
+    # Check with generator nested in a generator
+    assert is_flat((c for c in [1, 2, (c for c in (2, 3, 4))])) is False

skbase/utils/tests/test_utils.py

@@ -1,37 +1,37 @@
-#!/usr/bin/env python3 -u
-# -*- coding: utf-8 -*-
-# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
-"""Tests of the functionality for miscellaneous utilities.
-
-tests in this module incdlue:
-
-- test_subset_dict_keys_output: verify that subset_dict_keys outputs expected format.
-"""
-from skbase.utils import subset_dict_keys
-
-__author__ = ["RNKuhns"]
-
-
-def test_subset_dict_keys_output():
-    """Test subset_dict_keys outputs expected result."""
-    some_dict = {"some_param__a": 1, "some_param__b": 2, "some_param__c": 3}
-
-    assert subset_dict_keys(some_dict, "some_param__a") == {"some_param__a": 1}
-
-    assert subset_dict_keys(some_dict, ("some_param__a", "some_param__b")) == {
-        "some_param__a": 1,
-        "some_param__b": 2,
-    }
-
-    assert subset_dict_keys(some_dict, ("a", "b"), prefix="some_param") == {
-        "a": 1,
-        "b": 2,
-    }
-
-    assert subset_dict_keys(
-        some_dict, ("a", "b"), prefix="some_param", remove_prefix=False
-    ) == {"some_param__a": 1, "some_param__b": 2}
-
-    assert subset_dict_keys(
-        some_dict, (c for c in ("some_param__a", "some_param__b"))
-    ) == {"some_param__a": 1, "some_param__b": 2}
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Tests of the functionality for miscellaneous utilities.
+
+tests in this module incdlue:
+
+- test_subset_dict_keys_output: verify that subset_dict_keys outputs expected format.
+"""
+from skbase.utils import subset_dict_keys
+
+__author__ = ["RNKuhns"]
+
+
+def test_subset_dict_keys_output():
+    """Test subset_dict_keys outputs expected result."""
+    some_dict = {"some_param__a": 1, "some_param__b": 2, "some_param__c": 3}
+
+    assert subset_dict_keys(some_dict, "some_param__a") == {"some_param__a": 1}
+
+    assert subset_dict_keys(some_dict, ("some_param__a", "some_param__b")) == {
+        "some_param__a": 1,
+        "some_param__b": 2,
+    }
+
+    assert subset_dict_keys(some_dict, ("a", "b"), prefix="some_param") == {
+        "a": 1,
+        "b": 2,
+    }
+
+    assert subset_dict_keys(
+        some_dict, ("a", "b"), prefix="some_param", remove_prefix=False
+    ) == {"some_param__a": 1, "some_param__b": 2}
+
+    assert subset_dict_keys(
+        some_dict, (c for c in ("some_param__a", "some_param__b"))
+    ) == {"some_param__a": 1, "some_param__b": 2}

skbase/validate/__init__.py

@@ -1,22 +1,22 @@
-#!/usr/bin/env python3 -u
-# -*- coding: utf-8 -*-
-# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
-"""Tools for validating and comparing BaseObjects and collections of BaseObjects."""
-from typing import List
-
-from skbase.validate._named_objects import (
-    check_sequence_named_objects,
-    is_named_object_tuple,
-    is_sequence_named_objects,
-)
-from skbase.validate._types import check_sequence, check_type, is_sequence
-
-__author__: List[str] = ["RNKuhns", "fkiraly"]
-__all__: List[str] = [
-    "check_sequence",
-    "check_sequence_named_objects",
-    "check_type",
-    "is_named_object_tuple",
-    "is_sequence",
-    "is_sequence_named_objects",
-]
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Tools for validating and comparing BaseObjects and collections of BaseObjects."""
+from typing import List
+
+from skbase.validate._named_objects import (
+    check_sequence_named_objects,
+    is_named_object_tuple,
+    is_sequence_named_objects,
+)
+from skbase.validate._types import check_sequence, check_type, is_sequence
+
+__author__: List[str] = ["RNKuhns", "fkiraly"]
+__all__: List[str] = [
+    "check_sequence",
+    "check_sequence_named_objects",
+    "check_type",
+    "is_named_object_tuple",
+    "is_sequence",
+    "is_sequence_named_objects",
+]