scikit-base 1.2.0__tar.gz → 1.2.1__tar.gz

{scikit_base-1.2.0/scikit_base.egg-info → scikit_base-1.2.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: scikit-base
-Version: 1.2.0
+Version: 1.2.1
 Summary: Base classes for sklearn-like parametric objects
-Author-email: sktime developers <sktime.toolbox@gmail.com>
+Author-email: sktime developers <info@sktime.net>
 Maintainer: Franz Király
-Maintainer-email: sktime developers <sktime.toolbox@gmail.com>
+Maintainer-email: sktime developers <info@sktime.net>
 License: BSD 3-Clause License
         
         Copyright (c) 2022, skbase Developers
@@ -50,13 +50,12 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
-Requires-Python: <3.16,>=3.10
+Requires-Python: <3.16,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: all-extras
@@ -116,7 +115,7 @@ Dynamic: license-file
 `skbase` provides base classes for creating scikit-learn-like parametric objects,
 along with tools to make it easier to build your own packages that follow these design patterns.
 
-:rocket: Version 1.2.0 is now available. Check out our
+:rocket: Version 1.2.1 is now available. Check out our
 [release notes](https://skbase.readthedocs.io/en/latest/changelog.html).
 
 | Overview | |

{scikit_base-1.2.0 → scikit_base-1.2.1}/README.md

@@ -7,7 +7,7 @@
 `skbase` provides base classes for creating scikit-learn-like parametric objects,
 along with tools to make it easier to build your own packages that follow these design patterns.
 
-:rocket: Version 1.2.0 is now available. Check out our
+:rocket: Version 1.2.1 is now available. Check out our
 [release notes](https://skbase.readthedocs.io/en/latest/changelog.html).
 
 | Overview | |

{scikit_base-1.2.0 → scikit_base-1.2.1}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "scikit-base"
-version = "1.2.0"
+version = "1.2.1"
 description = "Base classes for sklearn-like parametric objects"
 authors = [
-    {name = "sktime developers", email = "sktime.toolbox@gmail.com"},
+    {name = "sktime developers", email = "info@sktime.net"},
 ]
 maintainers = [
-    {name = "sktime developers", email = "sktime.toolbox@gmail.com"},
+    {name = "sktime developers", email = "info@sktime.net"},
     {name = "Franz Király"},
 ]
 readme = "README.md"
@@ -26,14 +26,13 @@ classifiers = [
     "Operating System :: POSIX",
     "Operating System :: Unix",
     "Operating System :: MacOS",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: 3.15",
 ]
-requires-python = ">=3.10,<3.16"
+requires-python = ">=3.11,<3.16"
 dependencies = []
 
 [project.optional-dependencies]

{scikit_base-1.2.0 → scikit_base-1.2.1/scikit_base.egg-info}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: scikit-base
-Version: 1.2.0
+Version: 1.2.1
 Summary: Base classes for sklearn-like parametric objects
-Author-email: sktime developers <sktime.toolbox@gmail.com>
+Author-email: sktime developers <info@sktime.net>
 Maintainer: Franz Király
-Maintainer-email: sktime developers <sktime.toolbox@gmail.com>
+Maintainer-email: sktime developers <info@sktime.net>
 License: BSD 3-Clause License
         
         Copyright (c) 2022, skbase Developers
@@ -50,13 +50,12 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
-Requires-Python: <3.16,>=3.10
+Requires-Python: <3.16,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: all-extras
@@ -116,7 +115,7 @@ Dynamic: license-file
 `skbase` provides base classes for creating scikit-learn-like parametric objects,
 along with tools to make it easier to build your own packages that follow these design patterns.
 
-:rocket: Version 1.2.0 is now available. Check out our
+:rocket: Version 1.2.1 is now available. Check out our
 [release notes](https://skbase.readthedocs.io/en/latest/changelog.html).
 
 | Overview | |

{scikit_base-1.2.0 → scikit_base-1.2.1}/skbase/__init__.py

@@ -7,4 +7,4 @@ The included functionality makes it easy to reuse scikit-learn and
 sktime design principles in your project.
 """
 
-__version__: str = "1.2.0"
+__version__: str = "1.2.1"

{scikit_base-1.2.0 → scikit_base-1.2.1}/skbase/base/_tagmanager.py

@@ -15,24 +15,6 @@ from functools import lru_cache
 class _FlagManager:
     """Mixin class for flag and configuration settings management."""
 
-    @staticmethod
-    @lru_cache(maxsize=None)
-    def _collect_class_flags_cached(cls, flag_attr_name):
-        """Walk the MRO once per (cls, flag_attr_name) and cache the result.
-
-        Returns the dict directly; callers are responsible for copying it
-        before handing it out or mutating it, since this is a shared cached
-        object.
-        """
-        collected_flags = {}
-        for parent_class in reversed(inspect.getmro(cls)):
-            if parent_class is object:
-                continue
-            if flag_attr_name in parent_class.__dict__:
-                more_flags = parent_class.__dict__[flag_attr_name]
-                collected_flags.update(more_flags)
-        return collected_flags
-
     @classmethod
     def _get_class_flags(cls, flag_attr_name="_flags"):
         """Get class flags from estimator class and all its parent classes.
@@ -49,7 +31,7 @@ class _FlagManager:
             class attribute via nested inheritance. NOT overridden by dynamic
             flags set by set_flags or clone_flags.
         """
-        cached = cls._collect_class_flags_cached(cls, flag_attr_name)
+        cached = _collect_class_flags_cached(cls, flag_attr_name)
         # shallow copy: cheap, and safe because tag values are immutable
         # (they are primitives types bool, etc.)
         return dict(cached)
@@ -112,9 +94,7 @@ class _FlagManager:
             and new flags from [flag_attr_name]_dynamic object attribute.
         """
         # shallow copy of the cached class-level dict
-        collected_flags = dict(
-            self._collect_class_flags_cached(type(self), flag_attr_name)
-        )
+        collected_flags = dict(_collect_class_flags_cached(type(self), flag_attr_name))
 
         if hasattr(self, f"{flag_attr_name}_dynamic"):
             collected_flags.update(getattr(self, f"{flag_attr_name}_dynamic"))
@@ -229,3 +209,21 @@ class _FlagManager:
         self._set_flags(flag_attr_name=flag_attr_name, **update_dict)
 
         return self
+
+
+@lru_cache(maxsize=None)
+def _collect_class_flags_cached(cls, flag_attr_name):
+    """Walk the MRO once per (cls, flag_attr_name) and cache the result.
+
+    Returns the dict directly; callers are responsible for copying it
+    before handing it out or mutating it, since this is a shared cached
+    object.
+    """
+    collected_flags = {}
+    for parent_class in reversed(inspect.getmro(cls)):
+        if parent_class is object:
+            continue
+        if flag_attr_name in parent_class.__dict__:
+            more_flags = parent_class.__dict__[flag_attr_name]
+            collected_flags.update(more_flags)
+    return collected_flags

{scikit_base-1.2.0 → scikit_base-1.2.1}/skbase/lookup/_lookup.py

@@ -236,7 +236,12 @@ def _filter_by_tags(obj, tag_filter=None, as_dataframe=True):
 
         # search value matches tag value iff
         # at least one element of search value matches at least one element of tag value
-        str_match = len(set(search_str).intersection(tag_value)) > 0
+        try:
+            str_match = len(set(search_str).intersection(tag_value)) > 0
+        except TypeError:
+            # only reached if there are unhashable elements, e.g., nested lists
+            # in python_dependencies, otherwise the fast set lookup is used
+            str_match = _any_element_equal(search_str, tag_value)
         re_match = any(s.fullmatch(str(tag)) for s in search_re for tag in tag_value)
         match = str_match or re_match
 
@@ -245,6 +250,42 @@ def _filter_by_tags(obj, tag_filter=None, as_dataframe=True):
     return cond_sat
 
 
+def _is_hashable(obj):
+    """Return whether obj is hashable."""
+    try:
+        hash(obj)
+    except TypeError:
+        return False
+    return True
+
+
+def _any_element_equal(left, right):
+    """Check whether any element of left is equal to any element of right.
+
+    Hashable elements are compared via set lookup, in linear time.
+    Only unhashable elements, e.g., nested lists, are compared pairwise,
+    against all elements of the other iterable.
+
+    Parameters
+    ----------
+    left, right : list
+        lists of elements to compare, may contain unhashable elements
+
+    Returns
+    -------
+    bool, whether there is an element of left equal to an element of right
+    """
+    left_hashable = {x for x in left if _is_hashable(x)}
+    left_unhashable = [x for x in left if not _is_hashable(x)]
+    right_unhashable = [y for y in right if not _is_hashable(y)]
+
+    if any(y in left_hashable for y in right if _is_hashable(y)):
+        return True
+    if any(x == y for x in left_unhashable for y in right):
+        return True
+    return any(x == y for x in left for y in right_unhashable)
+
+
 def _walk(root, exclude=None, prefix=""):
     """Recursively return all modules and sub-modules as list of strings.
 
@@ -776,6 +817,7 @@ def all_objects(
     Parameters
     ----------
     object_types: class or tuple, list of classes, default=None
+        Which kind of objects should be returned.
 
         - If class_lookup is provided, can also be str or list of str
           which kind of objects should be returned.
@@ -786,6 +828,7 @@ def all_objects(
           as `class_lookup` parameter is passed a lookup dict.
 
     return_names: bool, default=True
+        Whether to include the class name strings in the returned objects.
 
         - If True, estimator class name is included in the ``all_objects``
           return in the order: name, estimator class, optional tags, either as
@@ -793,10 +836,11 @@ def all_objects(
         - If False, estimator class name is removed from the ``all_objects`` return.
 
     filter_tags: str, list[str] or dict[str, Any], default=None
-        Filter used to determine if ``klass`` has tag or expected tag values.
+        Filter condition to filter returned objects based on their tags.
+        The filter condition is used to determine which objects are returned.
 
         - If a str or list of strings is provided, the return will be filtered
-          to keep classes that have all the tag(s) specified by the strings,
+          to keep exactly classes that have all the tag(s) specified by the strings,
           with the tag value being True.
 
         - If a dict is provided, the return will be filtered to keep exactly the classes
@@ -821,15 +865,16 @@ def all_objects(
             applied to ``tag_value``.
 
     exclude_objects: str or list[str], default=None
-        Names of estimators to exclude.
+        Names of objects to exclude.
 
     as_dataframe: bool, default=False
+        Whether to return the results as a pandas DataFrame or as a list.
 
-        - If False, `all_objects` will return a list (either a list of
-          `skbase` objects or a list of tuples, see Returns).
-        - If True, `all_objects` will return a `pandas.DataFrame` with named
-            columns for all of the attributes being returned.
-            this requires soft dependency `pandas` to be installed.
+        - If False, ``all_objectss`` will return a list - either a list of
+          ``scikit-base`` compatible classes or a list of tuples, see Returns.
+        - If True, ``all_objects`` will return a ``pandas.DataFrame`` with named
+          columns for all of the attributes being returned.
+          this requires soft dependency ``pandas`` to be installed.
 
     return_tags: str or list of str, default=None
         Names of tags to fetch and return each object's value of. The tag values
@@ -871,7 +916,7 @@ def all_objects(
 
     - a pandas.DataFrame if ``as_dataframe=True``, with columns:
 
-      - "names" with the returned class names if ``return_name=True``
+      - "names" with the returned class names if ``return_names=True``
       - "objects" with returned classes.
       - optional columns named based on tags passed in ``return_tags``
         if ``return_tags is not None``.

{scikit_base-1.2.0 → scikit_base-1.2.1}/skbase/lookup/tests/test_lookup.py

@@ -20,6 +20,7 @@ from skbase.base import BaseEstimator, BaseObject
 from skbase.base._base import TagAliaserMixin
 from skbase.lookup import all_objects, get_package_metadata
 from skbase.lookup._lookup import (
+    _any_element_equal,
     _determine_module_path,
     _filter_by_class,
     _filter_by_tags,
@@ -411,6 +412,46 @@ def test_filter_by_tags():
         assert _filter_by_tags(Parent, {7: 11})
 
 
+def test_filter_by_tags_unhashable_tag_value():
+    """Test _filter_by_tags does not fail if a tag value contains unhashable items.
+
+    For instance, python_dependencies can be a list containing a nested list.
+    """
+
+    class ClassWithNestedListTag(BaseObject):
+        _tags = {"python_dependencies": ["pkg_a", ["pkg_b>=1.0", "pkg_c<2.0"]]}
+
+    assert _filter_by_tags(ClassWithNestedListTag, {"python_dependencies": "pkg_a"})
+    assert not _filter_by_tags(ClassWithNestedListTag, {"python_dependencies": "pkg_b"})
+    assert _filter_by_tags(
+        ClassWithNestedListTag, {"python_dependencies": ["pkg_x", "pkg_a"]}
+    )
+    # nested lists can be matched, too
+    assert _filter_by_tags(
+        ClassWithNestedListTag,
+        {"python_dependencies": [["pkg_b>=1.0", "pkg_c<2.0"]]},
+    )
+
+
+def test_any_element_equal():
+    """Test _any_element_equal with hashable and unhashable elements."""
+    # hashable only
+    assert _any_element_equal(["a", "b"], ["c", "b"])
+    assert not _any_element_equal(["a", "b"], ["c", "d"])
+    assert not _any_element_equal([], ["a"])
+
+    # unhashable elements in right, left, or both
+    assert _any_element_equal(["a"], [["x"], "a"])
+    assert not _any_element_equal(["x"], [["x"], "a"])
+    assert _any_element_equal([["x"], "b"], ["c", ["x"]])
+    assert _any_element_equal([{"k": 1}], [{"k": 1}])
+    assert not _any_element_equal([["x"]], [("x",), "x"])
+
+    # hashable equal to unhashable, e.g., frozenset and set
+    assert _any_element_equal([frozenset({1})], [{1}])
+    assert _any_element_equal([{1}], [frozenset({1})])
+
+
 def test_walk_returns_expected_format(fixture_skbase_root_path):
     """Check walk function returns expected format."""
 

{scikit_base-1.2.0 → scikit_base-1.2.1}/skbase/tests/conftest.py

@@ -216,6 +216,7 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
             "_get_sklearn_clone",
             "_is_sklearn_present",
         ),
+        "skbase.base._tagmanager": ("_collect_class_flags_cached",),
         "skbase.base._pretty_printing._object_html_repr": (
             "_get_visual_block",
             "_object_html_repr",
@@ -226,6 +227,7 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
         "skbase.lookup._lookup": (
             "all_objects",
             "get_package_metadata",
+            "_any_element_equal",
             "_check_object_types",
             "_coerce_to_tuple",
             "_determine_module_path",
@@ -235,6 +237,7 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
             "_get_module_info",
             "_get_return_tags",
             "_import_module",
+            "_is_hashable",
             "_is_ignored_module",
             "_is_non_public_module",
             "_make_dataframe",

{scikit_base-1.2.0 → scikit_base-1.2.1}/skbase/utils/deep_equals/_deep_equals.py

@@ -70,10 +70,21 @@ def deep_equals(x, y, return_msg=False, plugins=None):
             .dtype - dtype of pandas or numpy object is not equal
             .index - index of pandas object is not equal
             .series_equals, .df_equals, .index_equals - .equals of pd returns False
-            [i] - if tuple/list: i-th element not equal
+            [i] - if tuple/list or object-dtype array: i-th element not equal
+                  (arrays are flattened before comparison)
             [key] - if dict: value at key is not equal
             [colname] - if pandas.DataFrame: column with name colname is not equal
             != - call to generic != returns False
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.array([1, 2], dtype=object)
+    >>> y = np.array([1, 3], dtype=object)
+    >>> deep_equals(x, y)
+    False
+    >>> deep_equals(x, y, return_msg=True)
+    (False, '[1] !=, 2 != 3')
     """
     # call deep_equals_custom with default plugins
     plugins_default = [
@@ -149,8 +160,9 @@ def _numpy_equals_plugin(x, y, return_msg=False, deep_equals=None):
         y_flat = y.flatten()
         for i in range(len(x_flat)):
             is_equal, msg = deep_equals(x_flat[i], y_flat[i], return_msg=True)
-            return ret(is_equal, f"[{i}]" + msg)
-        return ret(True, "")  # catches len(x_flat) == 0
+            if not is_equal:
+                return ret(False, f"[{i}]" + msg)
+        return ret(True, "")
     else:
         return ret(np.array_equal(x, y, equal_nan=True), ".values")
 

{scikit_base-1.2.0 → scikit_base-1.2.1}/skbase/utils/tests/test_deep_equals.py

@@ -131,6 +131,53 @@ def copy_except_if_sklearn(obj):
             return deepcopy(obj)
 
 
+@pytest.mark.skipif(
+    not _check_soft_dependencies("numpy", severity="none"),
+    reason="numpy not available",
+)
+@pytest.mark.parametrize("shape", [(3,), (1, 3), (3, 1)])
+@pytest.mark.parametrize("difference_index", [0, 1, 2])
+@pytest.mark.parametrize("nested", [False, True])
+def test_deep_equals_numpy_object_array_all_elements(shape, difference_index, nested):
+    """Compare every object-array element, including nested arrays."""
+    import numpy as np
+
+    x = np.empty(3, dtype=object)
+    for i in range(3):
+        x[i] = np.array([i, i + 1]) if nested else i
+    x = x.reshape(shape)
+    y = deepcopy(x)
+
+    assert deep_equals(x, y) is True
+    assert deep_equals(x, y, return_msg=True) == (True, "")
+
+    if nested:
+        y.flat[difference_index][1] += 1
+    else:
+        y.flat[difference_index] += 1
+
+    assert deep_equals(x, y) is False
+    is_equal, msg = deep_equals(x, y, return_msg=True)
+    assert is_equal is False
+    assert msg.startswith(f"[{difference_index}]")
+
+
+@pytest.mark.skipif(
+    not _check_soft_dependencies("numpy", severity="none"),
+    reason="numpy not available",
+)
+@pytest.mark.parametrize("shape", [(), (0,), (0, 2), (1,), (2, 2)])
+def test_deep_equals_numpy_object_array_equal(shape):
+    """Preserve equality for scalar, empty and NaN-containing object arrays."""
+    import numpy as np
+
+    x = np.full(shape, np.nan, dtype=object)
+    y = deepcopy(x)
+
+    assert deep_equals(x, y) is True
+    assert deep_equals(x, y, return_msg=True) == (True, "")
+
+
 # Add JAX examples
 if _check_soft_dependencies("jax", severity="none"):
     import jax.numpy as jnp