scikit-base 0.7.7__py3-none-any.whl → 0.8.0__py3-none-any.whl

{scikit_base-0.7.7.dist-info → scikit_base-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scikit-base
-Version: 0.7.7
+Version: 0.8.0
 Summary: Base classes for sklearn-like parametric objects
 Author-email: sktime developers <sktime.toolbox@gmail.com>
 Maintainer: Franz Király
@@ -75,9 +75,9 @@ Requires-Dist: nbsphinx >=0.8.6 ; extra == 'docs'
 Requires-Dist: numpydoc ; extra == 'docs'
 Requires-Dist: pydata-sphinx-theme ; extra == 'docs'
 Requires-Dist: sphinx-issues <5.0.0 ; extra == 'docs'
-Requires-Dist: sphinx-gallery <0.16.0 ; extra == 'docs'
+Requires-Dist: sphinx-gallery <0.17.0 ; extra == 'docs'
 Requires-Dist: sphinx-panels ; extra == 'docs'
-Requires-Dist: sphinx-design <0.6.0 ; extra == 'docs'
+Requires-Dist: sphinx-design <0.7.0 ; extra == 'docs'
 Requires-Dist: Sphinx !=7.2.0,<8.0.0 ; extra == 'docs'
 Requires-Dist: tabulate ; extra == 'docs'
 Provides-Extra: linters
@@ -114,14 +114,14 @@ Requires-Dist: scikit-learn >=0.24.0 ; extra == 'test'
 `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 0.7.7 is now available. Check out our
+:rocket: Version 0.8.0 is now available. Check out our
 [release notes](https://skbase.readthedocs.io/en/latest/changelog.html).
 
 | Overview | |
 |---|---|
 | **CI/CD** | [![Tests](https://github.com/sktime/skbase/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/sktime/skbase/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/sktime/skbase/branch/main/graph/badge.svg?token=2J424NLO82)](https://codecov.io/gh/sktime/skbase) [![Documentation Status](https://readthedocs.org/projects/skbase/badge/?version=latest)](https://skbase.readthedocs.io/en/latest/?badge=latest) [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/sktime/skbase/main.svg)](https://results.pre-commit.ci/latest/github/sktime/skbase/main) |
 | **Code** |  [![!pypi](https://img.shields.io/pypi/v/scikit-base?color=orange)](https://pypi.org/project/scikit-base/)  [![!python-versions](https://img.shields.io/pypi/pyversions/scikit-base)](https://www.python.org/) [![!black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit) |
-| **Downloads** | [![Downloads](https://static.pepy.tech/personalized-badge/scikit-base?period=week&units=international_system&left_color=grey&right_color=blue&left_text=weekly%20(pypi))](https://pepy.tech/project/scikit-base) [![Downloads](https://static.pepy.tech/personalized-badge/scikit-base?period=month&units=international_system&left_color=grey&right_color=blue&left_text=monthly%20(pypi))](https://pepy.tech/project/scikit-base) [![Downloads](https://static.pepy.tech/personalized-badge/scikit-base?period=total&units=international_system&left_color=grey&right_color=blue&left_text=cumulative%20(pypi))](https://pepy.tech/project/scikit-base) |
+| **Downloads** | ![PyPI - Downloads](https://img.shields.io/pypi/dw/scikit-base) ![PyPI - Downloads](https://img.shields.io/pypi/dm/scikit-base) [![Downloads](https://static.pepy.tech/personalized-badge/scikit-base?period=total&units=international_system&left_color=grey&right_color=blue&left_text=cumulative%20(pypi))](https://pepy.tech/project/scikit-base) |
 | **Citation** | [![DOI](https://zenodo.org/badge/494649836.svg)](https://zenodo.org/doi/10.5281/zenodo.10980557) |
 
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->

{scikit_base-0.7.7.dist-info → scikit_base-0.8.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 docs/source/conf.py,sha256=kFc-4qkb0ZGD5cDej5KPJhMePp9kpVu6ZqFoF0fgovg,9951
-skbase/__init__.py,sha256=YvN4Wfd8JtwkiUCAJlCkMKjP6-kEmxv_yHPOIqRdP_8,345
+skbase/__init__.py,sha256=dc-gpNeQnwKO9izn78U5iB3Fj9AREwfkW5v6Cd-Pefk,345
 skbase/_exceptions.py,sha256=KXfcVa7Xit-w-Xs_qFSJOEa_Mfp1oJeiHEC3v4Z0h1Q,1112
 skbase/_nopytest_tests.py,sha256=npL5pibSgCpulEGw0NqLKcG0majh6xcdW5A4Zibf78s,1077
 skbase/base/__init__.py,sha256=5ZLlwJeyfKDA1lAylBJgZd3t5JY25xsgQB4waQnroa8,751
@@ -12,16 +12,16 @@ skbase/base/_pretty_printing/_pprint.py,sha256=VVnw-cywGxArfiFfVWfFSV5VMJvsxpDsJ
 skbase/base/_pretty_printing/tests/__init__.py,sha256=rakHMQAO1NfuMabw-VsqVA9Jd1YQyuSop-Oc3tgc4w0,77
 skbase/base/_pretty_printing/tests/test_pprint.py,sha256=8_CFX9v41ZA-aWkAxm9UZSWcOaXt-u1sLwsNPZOSL24,731
 skbase/lookup/__init__.py,sha256=RNw1mx8nXFHsn-HgnjHzWPn9AG45jSMEKl-Z0pEH7jE,1089
-skbase/lookup/_lookup.py,sha256=7L1JIMCzpMdSF5ZqHNDeIaHu4QRwXoLJ4DgM1Z_uFts,39864
+skbase/lookup/_lookup.py,sha256=C3k07rxCPz5tJG0-lKBCH6rQedJOiuTv0ja0_Hxe_XM,45083
 skbase/lookup/tests/__init__.py,sha256=MVqGlWsUV-gQ4qzW_TqE3UmKO9IQ9mwdDlsIHaGt3bc,68
-skbase/lookup/tests/test_lookup.py,sha256=_VDReGKnJF52UtFbvg_D2vlAkVvREypwM-9jR7DPAXQ,38218
+skbase/lookup/tests/test_lookup.py,sha256=cldy5v_K_GmAXWe-90eTIoHIm5g5-C77ffkYCWjw7bU,39743
 skbase/testing/__init__.py,sha256=OdwR-aEU2KzGrU-O0gtNSMNGmF2mtgBmjAnMzcgwe6w,351
 skbase/testing/test_all_objects.py,sha256=FooQ_pukjKKK7q3q7gXGH5pDcg8A4xEmkBAMcAF7jcs,36166
 skbase/testing/utils/__init__.py,sha256=kaLuqQwJsCunRWsUb1JwTVG-iqXbzdUobuYHNHsBlQQ,113
 skbase/testing/utils/_conditional_fixtures.py,sha256=QwI7K28Lsy6RAkDP94goo8uWWvMzKKNOmXRFtc9RNtI,9890
 skbase/testing/utils/inspect.py,sha256=e6F7AIuDhBTpgK8KKmiuwxeggrMjC7DHuSAKA1jOU2A,761
 skbase/tests/__init__.py,sha256=d2_OTTnt0GX5otQsBuNAb1evg8C5Fi0JjqK2VsfMtXU,37
-skbase/tests/conftest.py,sha256=Y_c9eCa1dxLx8y5uG3a4XD3Kj6mM-qpf10SYsMu-X2Y,9297
+skbase/tests/conftest.py,sha256=3n8QyF9_WjqC5x40dSR92pzQja4ECoW4cyGZIhj1gS8,9375
 skbase/tests/test_base.py,sha256=-kyVDOQRdXYsBmSTqNjZ06mjnt_OWoY2i2i71qx3TF8,50648
 skbase/tests/test_baseestimator.py,sha256=fuzpwxjYzyl-Vrte1va4AWdbYElhWnED8W10236Xprc,4731
 skbase/tests/test_exceptions.py,sha256=wOdk7Gp8pvbhucna3_9FxTk9xFLjC9XNsGsVabQLYEE,629
@@ -36,7 +36,7 @@ skbase/utils/_utils.py,sha256=A6sTIUEscEy9TjBmCvXEuhk9q8ROBPyfJGhrjlSA4LY,3134
 skbase/utils/random_state.py,sha256=QxY-M2u_6my315tdml2CukKj7ZVnbqjU_T9ZzixGuq0,5127
 skbase/utils/deep_equals/__init__.py,sha256=1II3GWV1c1s43y62IidMiTjjyOnE9MFysQ5AKCXMB2g,235
 skbase/utils/deep_equals/_common.py,sha256=O0ODPJGwdq6G-KdeGoHgyote53tNcxu3y2jHvej3bdQ,1273
-skbase/utils/deep_equals/_deep_equals.py,sha256=XtC3GohsVpXzKtBKY8ejYoJ2q1vPqcpXnTBRqZnj0T8,18331
+skbase/utils/deep_equals/_deep_equals.py,sha256=DT6nE0p1IGsLb82h3JJu24_nWeNE2HI46eL2qPlqxbo,19151
 skbase/utils/dependencies/__init__.py,sha256=cCUa_P-RiDs4pW6cw51uYeoBMaMa9iycwiFkwqkIizc,419
 skbase/utils/dependencies/_dependencies.py,sha256=P_kqwGOxbGlbTdOfQ8HFHRm-UsAcSWQF-1jcqrzo4IU,14502
 skbase/utils/dependencies/tests/__init__.py,sha256=UqE6wenG-HffjT2Z974OLzmXG-M8PNOP9nUnNfqtfT4,74
@@ -54,9 +54,9 @@ skbase/validate/_types.py,sha256=riVEVlj8ipErZX07OVbzv6zdGKssfegHyMr8XwaBm6M,121
 skbase/validate/tests/__init__.py,sha256=wunQBy6rajyrDymKvuFVajsBjj90VP5IFey5b6ZIRCk,70
 skbase/validate/tests/test_iterable_named_objects.py,sha256=NaEwdmtQJJy4GXMSh9ULOaR4ua7R11BcE6Khz5RKWUk,7438
 skbase/validate/tests/test_type_validations.py,sha256=G-qwFjXk-8WvXoeOvo2omfFKKjbpWhP-sPf6hsw8q30,14131
-scikit_base-0.7.7.dist-info/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
-scikit_base-0.7.7.dist-info/METADATA,sha256=6NYEZDPKup4OGIt6IAYfnnloTUtKhTOm-x14aTWiliM,8821
-scikit_base-0.7.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-scikit_base-0.7.7.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
-scikit_base-0.7.7.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-scikit_base-0.7.7.dist-info/RECORD,,
+scikit_base-0.8.0.dist-info/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
+scikit_base-0.8.0.dist-info/METADATA,sha256=xCuladQzebhI2968jGsodpDLWaMY08x9zjjI2rrEZgo,8529
+scikit_base-0.8.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+scikit_base-0.8.0.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
+scikit_base-0.8.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+scikit_base-0.8.0.dist-info/RECORD,,

skbase/__init__.py

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

skbase/lookup/_lookup.py

@@ -20,10 +20,12 @@ import io
 import os
 import pathlib
 import pkgutil
+import re
 import sys
 import warnings
 from collections.abc import Iterable
 from copy import deepcopy
+from functools import lru_cache
 from operator import itemgetter
 from types import ModuleType
 from typing import Any, List, Mapping, MutableMapping, Optional, Sequence, Tuple, Union
@@ -189,48 +191,86 @@ def _filter_by_tags(obj, tag_filter=None, as_dataframe=True):
     if tag_filter is None:
         return True
 
+    type_msg = (
+        "filter_tags argument of all_objects must be "
+        "a dict with str or re.Pattern keys, "
+        "str, or iterable of str, "
+        "but found"
+    )
+
     if not isinstance(tag_filter, (str, Iterable, dict)):
-        raise TypeError(
-            "tag_filter argument of _filter_by_tags must be "
-            "a dict with str keys, str, or iterable of str, "
-            f"but found tag_filter of type {type(tag_filter)}"
-        )
+        raise TypeError(f"{type_msg} type {type(tag_filter)}")
 
     if not hasattr(obj, "get_class_tag"):
         return False
 
     klass_tags = obj.get_class_tags().keys()
 
+    # todo 0.9.0: remove the warning message
+    # i.e., this message and all warnings referring to it
+    warn_msg = (
+        "The meaning of filter_tags arguments in all_objects of type str "
+        "and iterable of str will change from scikit-base 0.9.0. "
+        "Currently, str or iterable of str arguments select objects that possess the "
+        "tag(s) with the specified name, of any value. "
+        "From 0.9.0 onwards, str or iterable of str "
+        "will select objects that possess the tag with the specified name, "
+        "with the value True (boolean). See scikit-base issue #326 for the rationale "
+        "behind this change. "
+        "To retain previous behaviour, that is, "
+        "to select objects that possess the tag with the specified name, of any value, "
+        "use a dict with the tag name as key, and re.Pattern('*?') as value. "
+        "That is, from re import Pattern, and pass {tag_name: Pattern('*?')} "
+        "as filter_tags, and similarly with multiple tag names. "
+    )
+
     # case: tag_filter is string
     if isinstance(tag_filter, str):
+        # todo 0.9.0: reomove this warning
+        warnings.warn(warn_msg, DeprecationWarning, stacklevel=2)
+        # todo 0.9.0: replace this line
         return tag_filter in klass_tags
+        # by this line
+        # tag_filter = {tag_filter: True}
 
     # case: tag_filter is iterable of str but not dict
     # If a iterable of strings is provided, check that all are in the returned tag_dict
     if isinstance(tag_filter, Iterable) and not isinstance(tag_filter, dict):
         if not all(isinstance(t, str) for t in tag_filter):
-            raise ValueError(
-                "tag_filter argument of _filter_by_tags must be "
-                f"a dict with str keys, str, or iterable of str, but found {tag_filter}"
-            )
+            raise ValueError(f"{type_msg} {tag_filter}")
+        # todo 0.9.0: reomove this warning
+        warnings.warn(warn_msg, DeprecationWarning, stacklevel=2)
+        # todo 0.9.0: replace this line
         return all(tag in klass_tags for tag in tag_filter)
+        # by this line
+        # tag_filter = {tag: True for tag in tag_filter}
 
     # case: tag_filter is dict
+    # check that all keys are str
     if not all(isinstance(t, str) for t in tag_filter.keys()):
-        raise ValueError(
-            "tag_filter argument of _filter_by_tags must be "
-            f"a dict with str keys, str, or iterable of str, but found {tag_filter}"
-        )
+        raise ValueError(f"{type_msg} {tag_filter}")
 
     cond_sat = True
 
     for key, search_value in tag_filter.items():
         if not isinstance(search_value, list):
             search_value = [search_value]
+
+        # split search_value into strings/other and re.Pattern
+        search_re = [s for s in search_value if isinstance(s, re.Pattern)]
+        search_str = [s for s in search_value if not isinstance(s, re.Pattern)]
+
         tag_value = obj.get_class_tag(key)
         if not isinstance(tag_value, list):
             tag_value = [tag_value]
-        cond_sat = cond_sat and len(set(search_value).intersection(tag_value)) > 0
+
+        # 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
+        re_match = any(s.fullmatch(str(tag)) for s in search_re for tag in tag_value)
+        match = str_match or re_match
+
+        cond_sat = cond_sat and match
 
     return cond_sat
 
@@ -295,11 +335,7 @@ def _import_module(
 
     # if suppress_import_stdout:
     # setup text trap, import
-    if suppress_import_stdout:
-        temp_stdout = sys.stdout
-        sys.stdout = io.StringIO()
-
-    try:
+    with StdoutMute(active=suppress_import_stdout):
         if isinstance(module, str):
             imported_mod = importlib.import_module(module)
         elif isinstance(module, importlib.machinery.SourceFileLoader):
@@ -308,18 +344,6 @@ def _import_module(
 
             loader = spec.loader
             loader.exec_module(imported_mod)
-        exc = None
-    except Exception as e:
-        # we store the exception so we can restore the stdout first
-        exc = e
-
-    # if we set up a text trap, restore it to the initial value
-    if suppress_import_stdout:
-        sys.stdout = temp_stdout
-
-    # if we encountered an exception, now raise it
-    if exc is not None:
-        raise exc
 
     return imported_mod
 
@@ -689,6 +713,8 @@ def get_package_metadata(
     return module_info
 
 
+# todo 0.9.0: change docstring to reflect handling of filter_tags
+# in case of str or iterable of str
 def all_objects(
     object_types=None,
     filter_tags=None,
@@ -702,16 +728,19 @@ def all_objects(
     modules_to_ignore=None,
     class_lookup=None,
 ):
-    """Get a list of all objects in a package with name `package_name`.
+    """Get a list of all objects in a package, optionally filtered by type and tags.
 
     This function crawls the package/module to retrieve all classes
-    that are descendents of BaseObject. By default it does this for the `skbase`
-    package, but users can specify `package_name` or `path` to another project
-    and `all_objects` will crawl and retrieve BaseObjects found in that project.
+    that are descendents of ``BaseObject``, or another specified class,
+    from a module and all submodules, specified by  ``package_name`` oand``path``.
+
+    The retrieved objects can be filtered by type, tags, and excluded by name.
+
+    ``all_objects`` will crawl and return references to the retrieved classes.
 
     Parameters
     ----------
-    object_types: class or list of classes, default=None
+    object_types: class or tuple, list of classes, default=None
 
         - If class_lookup is provided, can also be str or list of str
           which kind of objects should be returned.
@@ -723,29 +752,40 @@ def all_objects(
 
     return_names: bool, default=True
 
-        - If True, estimator class name is included in the all_estimators()
+        - If True, estimator class name is included in the ``all_objects``
           return in the order: name, estimator class, optional tags, either as
-          a tuple or as pandas.DataFrame columns.
-        - If False, estimator class name is removed from the all_estimators()
-          return.
+          a tuple or as ``pandas.DataFrame`` columns.
+        - 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 used to determine if ``klass`` has tag or expected tag values.
 
         - 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.
-        - If a dict is provided, the return will be filtered to keep classes
-          that have all dict keys as tags. Tag values are also checked such that:
-
-          - If a dict key maps to a single value only classes with tag values equal
-            to the value are returned.
-          - If a dict key maps to multiple values (e.g., list) only classes with
-            tag values in these values are returned.
-          - If tag values are iterable,
-            condition is "at least one search value is contained in tag values".
+        - If a dict is provided, the return will be filtered to keep exactly the classes
+          where tags satisfy all the filter conditions specified by ``filter_tags``.
+          Filter conditions are as follows, for ``tag_name: search_value`` pairs in
+          the ``filter_tags`` dict.
+
+          - If ``klass`` does not have a tag with name ``tag_name``, it is excluded.
+            Otherwise, let ``tag_value`` be the value of the tag with name ``tag_name``.
+          - If ``search_value`` is a string, and ``tag_value`` is a string,
+            the filter condition is that ``search_value`` must match the tag value.
+          - If ``search_value`` is a string, and ``tag_value`` is a list,
+            the filter condition is that ``search_value`` is contained in ``tag_value``.
+          - If ``search_value`` is a ``re.Pattern``, and ``tag_value`` is a string,
+            the filter condition is that ``search_value.fullmatch(tag_value)``
+            is true, i.e., the regex matches the tag value.
+          - If ``search_value`` is a ``re.Pattern``, and ``tag_value`` is a list,
+            the filter condition is that at least one element of ``tag_value``
+            matches the regex.
+          - If ``search_value`` is iterable, then the filter condition is that
+            at least one element of ``search_value`` satisfies the above conditions,
+            applied to ``tag_value``.
 
     exclude_objects: str or list[str], default=None
         Names of estimators to exclude.
+
     as_dataframe: bool, default=False
 
         - If False, `all_objects` will return a list (either a list of
@@ -758,130 +798,93 @@ def all_objects(
         Names of tags to fetch and return each object's value of. The tag values
         named in return_tags will be fetched for each object and will be appended
         as either columns or tuple entries.
+
     package_name : str, default="skbase".
         Should be set to default to package or module name that objects will
-        be retrieved from. Objects will be searched inside `package_name`,
-        including in sub-modules (e.g., in package_name, package_name.module1,
-        package.module2, and package.module1.module3).
+        be retrieved from. Objects will be searched inside ``package_name``,
+        including in sub-modules (e.g., in ``package_name``, ``package_name.module1``,
+        ``package.module2``, and ``package.module1.module3``).
+
     path : str, default=None
         If provided, this should be the path that should be used as root
         to find `package_name` and start the search for any submodules/packages.
         This can be left at the default value (None) if searching in an installed
         package.
+
     modules_to_ignore : str or list[str], default=None
         The modules that should be ignored when searching across the modules to
-        gather objects. If passed, `all_objects` ignores modules or submodules
+        gather objects. If passed, ``all_objects`` ignores modules or submodules
         of a module whose name is in the provided string(s). E.g., if
-        `modules_to_ignore` contains the string `"foo"`, then `"bar.foo"`,
-        `"foo"`, `"foo.bar"`, `"bar.foo.bar"` are ignored.
+        ``modules_to_ignore`` contains the string ``"foo"``, then ``"bar.foo"``,
+        ``"foo"``, ``"foo.bar"``, ``"bar.foo.bar"`` are ignored.
 
     class_lookup : dict[str, class], default=None
         Dictionary of string aliases for classes used in object_types. If provided,
-        `object_types` can accept str values or a list of string values.
+        ``object_types`` can accept str values or a list of string values.
 
-    Other Parameters
-    ----------------
     suppress_import_stdout : bool, default=True
         Whether to suppress stdout printout upon import.
+        If True, ``all_objects`` will suppress any stdout printout internally.
+        If False, ``all_objects`` will not suppress any stdout printout arising
+        from crawling the package.
 
     Returns
     -------
-    all_estimators will return one of the following:
+    ``all_objects`` will return one of the following:
 
-    - a pandas.DataFrame if `as_dataframe=True`, with columns:
+    - 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_name=True``
       - "objects" with returned classes.
-      - optional columns named based on tags passed in `return_tags`
-        if `return_tags is not None`.
+      - optional columns named based on tags passed in ``return_tags``
+        if ``return_tags is not None``.
 
-    - a list if `as_dataframe=False`, where list elements are:
+    - a list if ``as_dataframe=False``, where list elements are:
 
-      - classes (that inherit from BaseObject) in alphabetic order by class name
-        if `return_names=False` and `return_tags=None.
-      - (name, class) tuples in alphabetic order by name if `return_names=True`
-        and `return_tags=None`.
+      - classes (that inherit from ``BaseObject``) in alphabetic order by class name
+        if ``return_names=False`` and ``return_tags=None``.
+      - (name, class) tuples in alphabetic order by name if ``return_names=True``
+        and ``return_tags=None``.
       - (name, class, tag-value1, ..., tag-valueN) tuples in alphabetic order by name
-        if `return_names=True` and `return_tags is not None`.
+        if ``return_names=True`` and ``return_tags is not None``.
       - (class, tag-value1, ..., tag-valueN) tuples in alphabetic order by
-        class name if `return_names=False` and `return_tags is not None`.
+        class name if ``return_names=False`` and ``return_tags is not None``.
 
     References
     ----------
-    Modified version of scikit-learn's and sktime's `all_estimators()` to allow
-    users to find BaseObjects in `skbase` and other packages.
+    Modified version of ``scikit-learn``'s and sktime's ``all_estimators`` to allow
+    users to find ``BaseObject`` descendants in ``skbase`` and other packages.
     """
-    module, root, _ = _determine_module_path(package_name, path)
-    if modules_to_ignore is None:
-        modules_to_ignore = []
-    if exclude_objects is None:
-        exclude_objects = []
+    _, root, _ = _determine_module_path(package_name, path)
+    modules_to_ignore = _coerce_to_tuple(modules_to_ignore)
+    exclude_objects = _coerce_to_tuple(exclude_objects)
 
-    all_estimators = []
-
-    def _is_base_class(name):
-        return name.startswith("_") or name.startswith("Base")
-
-    def _is_estimator(name, klass):
-        # Check if klass is subclass of base estimators, not a base class itself and
-        # not an abstract class
-        if object_types is None:
-            return issubclass(klass, BaseObject) and not _is_base_class(name)
-        else:
-            return not _is_base_class(name)
+    if object_types is None:
+        obj_types = BaseObject
+    else:
+        obj_types = _check_object_types(object_types, class_lookup)
 
     # Ignore deprecation warnings triggered at import time and from walking packages
-    with warnings.catch_warnings():
+    with warnings.catch_warnings(), StdoutMute(active=suppress_import_stdout):
         warnings.simplefilter("ignore", category=FutureWarning)
         warnings.simplefilter("module", category=ImportWarning)
         warnings.filterwarnings(
             "ignore", category=UserWarning, message=".*has been moved to.*"
         )
-        prefix = f"{package_name}."
-        for module_name, _, _ in _walk(
-            root=root, exclude=modules_to_ignore, prefix=prefix
-        ):
-            # Filter modules
-            if _is_non_public_module(module_name):
-                continue
-
-            try:
-                if suppress_import_stdout:
-                    # setup text trap, import, then restore
-                    sys.stdout = io.StringIO()
-                    module = importlib.import_module(module_name)
-                    sys.stdout = sys.__stdout__
-                else:
-                    module = importlib.import_module(module_name)
-                classes = inspect.getmembers(module, inspect.isclass)
-                # Filter classes
-                estimators = [
-                    (klass.__name__, klass)
-                    for _, klass in classes
-                    if _is_estimator(klass.__name__, klass)
-                ]
-                all_estimators.extend(estimators)
-            except ModuleNotFoundError as e:
-                # Skip missing soft dependencies
-                if "soft dependency" not in str(e):
-                    raise e
-                warnings.warn(str(e), ImportWarning, stacklevel=2)
-
-    # Drop duplicates
-    all_estimators = set(all_estimators)
+        all_estimators = _walk_and_retrieve_all_objs(
+            root=root, package_name=package_name, modules_to_ignore=modules_to_ignore
+        )
 
     # Filter based on given estimator types
-    if object_types:
-        obj_types = _check_object_types(object_types, class_lookup)
-        all_estimators = [
-            (n, est) for (n, est) in all_estimators if _filter_by_class(est, obj_types)
-        ]
+    all_estimators = [
+        (n, est) for (n, est) in all_estimators if _filter_by_class(est, obj_types)
+    ]
 
     # Filter based on given exclude list
     if exclude_objects:
         exclude_objects = check_sequence(
             exclude_objects,
-            sequence_type=list,
+            sequence_type=tuple,
             element_type=str,
             coerce_scalar_input=True,
             sequence_name="exclude_object",
@@ -1020,3 +1023,123 @@ def _make_dataframe(all_objects, columns):
     import pandas as pd
 
     return pd.DataFrame(all_objects, columns=columns)
+
+
+class StdoutMute:
+    """A context manager to suppress stdout.
+
+    This class is used to suppress stdout when importing modules.
+
+    Also downgrades any ModuleNotFoundError to a warning if the error message
+    contains the substring "soft dependency".
+
+    Parameters
+    ----------
+    active : bool, default=True
+        Whether to suppress stdout or not.
+        If True, stdout is suppressed.
+        If False, stdout is not suppressed, and the context manager does nothing
+        except catch and suppress ModuleNotFoundError.
+    """
+
+    def __init__(self, active=True):
+        self.active = active
+
+    def __enter__(self):
+        """Context manager entry point."""
+        # capture stdout if active
+        # store the original stdout so it can be restored in __exit__
+        if self.active:
+            self._stdout = sys.stdout
+            sys.stdout = io.StringIO()
+
+    def __exit__(self, type, value, traceback):  # noqa: A002
+        """Context manager exit point."""
+        # restore stdout if active
+        # if not active, nothing needs to be done, since stdout was not replaced
+        if self.active:
+            sys.stdout = self._stdout
+
+        if type is not None:
+            # if a ModuleNotFoundError is raised,
+            # we suppress to a warning if "soft dependency" is in the error message
+            # otherwise, raise
+            if type is ModuleNotFoundError:
+                if "soft dependency" not in str(value):
+                    return False
+                warnings.warn(str(value), ImportWarning, stacklevel=2)
+                return True
+
+            # all other exceptions are raised
+            return False
+        # if no exception was raised, return True to indicate successful exit
+        # return statement not needed as type was None, but included for clarity
+        return True
+
+
+def _coerce_to_tuple(x):
+    if x is None:
+        return ()
+    elif isinstance(x, tuple):
+        return x
+    elif isinstance(x, list):
+        return tuple(x)
+    else:
+        return (x,)
+
+
+@lru_cache(maxsize=100)
+def _walk_and_retrieve_all_objs(root, package_name, modules_to_ignore):
+    """Walk through the package and retrieve all BaseObject descendants.
+
+    Excludes objects:
+
+    * located in modules with a subpath starting with underscore
+    * located in modules with a subpath in ``modules_to_ignore``
+    * whose name starts with an underscore or ``"Base"``
+
+    Parameters
+    ----------
+    root : str or path-like
+        Root path in which to look for submodules. Can be a string path,
+        pathlib.Path or other path-like object.
+    package_name : str
+        The name of the package/module to return metadata for.
+    modules_to_ignore : tuple[str]
+        The modules that should be ignored when searching across the modules to
+        gather objects. If passed, `all_objects` ignores modules or submodules
+        of a module whose name is in the provided string(s). E.g., if
+        `modules_to_ignore` contains the string `"foo"`, then `"bar.foo"`,
+        `"foo"`, `"foo.bar"`, `"bar.foo.bar"` are ignored.
+
+    Returns
+    -------
+    all_estimators : tuple of (str, class) tuples
+        List of all estimators found in the package.
+    """
+    prefix = f"{package_name}."
+
+    def _is_base_class(name):
+        return name.startswith("_") or name.startswith("Base")
+
+    all_estimators = []
+
+    for module_name, _, _ in _walk(root=root, exclude=modules_to_ignore, prefix=prefix):
+        # Filter modules
+        if _is_non_public_module(module_name):
+            continue
+
+        module = importlib.import_module(module_name)
+        classes = inspect.getmembers(module, inspect.isclass)
+        # Filter classes
+        estimators = [
+            (klass.__name__, klass)
+            for _, klass in classes
+            if not _is_base_class(klass.__name__)
+        ]
+        all_estimators.extend(estimators)
+
+    # Drop duplicates
+    all_estimators = set(all_estimators)
+    all_estimators = tuple(all_estimators)
+    return all_estimators

skbase/lookup/tests/test_lookup.py

@@ -6,6 +6,7 @@
 # conditions see https://github.com/sktime/sktime/blob/main/LICENSE
 import importlib
 import pathlib
+import sys
 from copy import deepcopy
 from types import ModuleType
 from typing import List
@@ -42,7 +43,7 @@ from skbase.tests.mock_package.test_mock_package import (
     NotABaseObject,
 )
 
-__author__: List[str] = ["RNKuhns"]
+__author__: List[str] = ["RNKuhns", "fkiraly"]
 __all__: List[str] = []
 
 
@@ -395,15 +396,15 @@ def test_filter_by_tags():
     assert _filter_by_tags(Parent, {"E": 1, "B": 2}) is False
 
     # Iterable tags should be all strings
-    with pytest.raises(ValueError, match=r"tag_filter"):
+    with pytest.raises(ValueError, match=r"filter_tags"):
         assert _filter_by_tags(Parent, ("A", "B", 3))
 
     # Tags that aren't iterable have to be strings
-    with pytest.raises(TypeError, match=r"tag_filter"):
+    with pytest.raises(TypeError, match=r"filter_tags"):
         assert _filter_by_tags(Parent, 7.0)
 
     # Dictionary tags should have string keys
-    with pytest.raises(ValueError, match=r"tag_filter"):
+    with pytest.raises(ValueError, match=r"filter_tags"):
         assert _filter_by_tags(Parent, {7: 11})
 
 
@@ -848,7 +849,14 @@ def test_all_objects_returns_expected_types(
     exclude_objects,
     suppress_import_stdout,
 ):
-    """Test that all_objects return argument has correct type."""
+    """Test that all_objects return argument has correct type.
+
+    Also tested: sys.stdout is unchanged after function call, see bug #327.
+    """
+    # we will check later that sys.stdout is unchanged
+    initial_stdout = sys.stdout
+
+    # call all_objects
     objs = all_objects(
         package_name="skbase",
         exclude_objects=exclude_objects,
@@ -858,6 +866,11 @@ def test_all_objects_returns_expected_types(
         modules_to_ignore=modules_to_ignore,
         suppress_import_stdout=suppress_import_stdout,
     )
+
+    # verify sys.stdout is unchanged
+    assert sys.stdout == initial_stdout
+
+    # verify output has expected types
     if isinstance(modules_to_ignore, str):
         modules_to_ignore = (modules_to_ignore,)
     if (
@@ -984,6 +997,43 @@ def test_all_object_tag_filter(tag_filter):
         assert len(unfiltered_classes) > len(filtered_classes)
 
 
+def test_all_object_tag_filter_regex():
+    """Test all_objects filters by tag as expected, when using regex."""
+    import re
+
+    # search for class where "A" has at least one 1, and "C" has "23" in the tag value
+    # this sohuld find Parent but not Child
+    filter_tags = {"A": re.compile(r"^(?=.*1).*$"), "C": re.compile(r".+23.+")}
+
+    # Results applying filter
+    objs = all_objects(
+        package_name="skbase",
+        return_names=True,
+        as_dataframe=True,
+        return_tags=None,
+        filter_tags=filter_tags,
+    )
+    filtered_classes = objs.iloc[:, 1].tolist()
+    # Verify filtered results have right output type
+    _check_all_object_output_types(
+        objs, as_dataframe=True, return_names=True, return_tags=None
+    )
+
+    # Results without filter
+    objs = all_objects(
+        package_name="skbase",
+        return_names=True,
+        as_dataframe=True,
+        return_tags=None,
+    )
+    unfiltered_classes = objs.iloc[:, 1].tolist()
+
+    # as stated above, we should find only Parent (and not Child)
+    assert len(unfiltered_classes) > len(filtered_classes)
+    names = [kls.__name__ for kls in filtered_classes]
+    assert "Parent" in names
+
+
 @pytest.mark.parametrize("class_lookup", [{"base_object": BaseObject}])
 @pytest.mark.parametrize("class_filter", [None, "base_object"])
 def test_all_object_class_lookup(class_lookup, class_filter):

skbase/tests/conftest.py

@@ -99,7 +99,7 @@ SKBASE_PUBLIC_CLASSES_BY_MODULE = {
         "BaseMetaEstimatorMixin",
     ),
     "skbase.base._pretty_printing._pprint": ("KeyValTuple", "KeyValTupleParam"),
-    "skbase.lookup._lookup": (),
+    "skbase.lookup._lookup": ("StdoutMute",),
     "skbase.testing": ("BaseFixtureGenerator", "QuickTester", "TestAllObjects"),
     "skbase.testing.test_all_objects": (
         "BaseFixtureGenerator",
@@ -203,6 +203,7 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
             "_import_module",
             "_check_object_types",
             "_get_module_info",
+            "_coerce_to_tuple",
         ),
         "skbase.testing.utils.inspect": ("_get_args",),
         "skbase.utils._check": ("_is_scalar_nan",),
@@ -237,6 +238,7 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
             "_numpy_equals_plugin",
             "_pandas_equals",
             "_pandas_equals_plugin",
+            "_safe_any_unequal",
             "_safe_len",
             "_softdep_available",
             "_tuple_equals",

skbase/utils/deep_equals/_deep_equals.py

@@ -503,18 +503,50 @@ def deep_equals_custom(x, y, return_msg=False, plugins=None):
     if isinstance(x == y, bool):
         return ret(x == y, f" !=, {x} != {y}")
 
-    # check if numpy is available
-    numpy_available = _softdep_available("numpy")
-    if numpy_available:
-        import numpy as np
-
     # deal with the case where != returns a vector
-    if numpy_available and np.any(x != y) or np.any(_coerce_list(x != y)):
+    if _safe_any_unequal(x, y):
         return ret(False, f" !=, {x} != {y}")
 
     return ret(True, "")
 
 
+def _safe_any_unequal(x, y):
+    """Return whether any of x != y, if != results in iterable, False on exception.
+
+    Written very defensively to avoid exceptions, as exceptions may be raised
+    since any(x != y) or the safer np.any(x != y) may not be boolean,
+    e.g., in pathological cases of nested objects.
+    """
+    try:
+        unequal = x != y
+    except Exception:
+        return False
+
+    # check if numpy is available
+    numpy_available = _softdep_available("numpy")
+
+    if not numpy_available:
+        try:
+            any_un = any(unequal)
+            if isinstance(any_un, bool):
+                return any_un
+            else:
+                return False
+        except Exception:
+            return False
+
+    import numpy as np
+
+    try:
+        any_un = np.any(x != y) or np.any(_coerce_list(x != y))
+        if isinstance(any_un, bool) or any_un.dtype == "bool":
+            return any_un
+        else:
+            return False
+    except Exception:
+        return False
+
+
 def _safe_len(x):
     """Return length of x if len(x) does not result in exception, else -1."""
     if hasattr(x, "__len__"):