scikit-base 0.7.8__py3-none-any.whl → 0.8.1__py3-none-any.whl

{scikit_base-0.7.8.dist-info → scikit_base-0.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scikit-base
-Version: 0.7.8
+Version: 0.8.1
 Summary: Base classes for sklearn-like parametric objects
 Author-email: sktime developers <sktime.toolbox@gmail.com>
 Maintainer: Franz Király
@@ -77,7 +77,7 @@ Requires-Dist: pydata-sphinx-theme ; extra == 'docs'
 Requires-Dist: sphinx-issues <5.0.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.8 is now available. Check out our
+:rocket: Version 0.8.1 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.8.dist-info → scikit_base-0.8.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
 docs/source/conf.py,sha256=kFc-4qkb0ZGD5cDej5KPJhMePp9kpVu6ZqFoF0fgovg,9951
-skbase/__init__.py,sha256=Ab3YMPkln7mapnxZqpr62oT-wBkvDnVIudmtwXuMOkc,345
+skbase/__init__.py,sha256=jicuZQgA7WNCyhMFQBTRDzUnL7dB0XNhHU2aejwwIB4,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
-skbase/base/_base.py,sha256=1MJgavydCw-4TNqA4Na_7LMVoh4w4D5q81l15SbKJUM,53490
+skbase/base/_base.py,sha256=Lb1Ec-IZW7v-OTKtfjFMPpS69gmGurEQ17MujOrtReY,53970
 skbase/base/_meta.py,sha256=VY6_R2tE885j-GTDuzLFyho5i382jOni5lkR_ykPZqo,38815
 skbase/base/_tagmanager.py,sha256=nKoiIC1yXFFSpN5ljWbMrwA-pwlbxsljgKuUywh1MR4,7289
 skbase/base/_pretty_printing/__init__.py,sha256=bVuKnwafn8c2q2AGJ9BOu9cmu-xBjiOxHf1hxjm8K2A,492
@@ -12,17 +12,17 @@ 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=Kt_Jnt-ikWYCMuYQAWc-ym0Aiu-wnG4YXwGQj6WtWJk,44606
 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=2vK_pJVsHIyArS7TEMOkwNW84vtCEw_c5v6FLGZDB5k,9330
-skbase/tests/test_base.py,sha256=-kyVDOQRdXYsBmSTqNjZ06mjnt_OWoY2i2i71qx3TF8,50648
+skbase/tests/conftest.py,sha256=gU64Q6iCW6gzWtJNxQwqrkpCUWY8ht0H1AnToKZS1Gc,9497
+skbase/tests/test_base.py,sha256=kIhBDcTajAvrOh_BNX8gNuwDWhhGPc-jV6qGE5JPAUk,50827
 skbase/tests/test_baseestimator.py,sha256=fuzpwxjYzyl-Vrte1va4AWdbYElhWnED8W10236Xprc,4731
 skbase/tests/test_exceptions.py,sha256=wOdk7Gp8pvbhucna3_9FxTk9xFLjC9XNsGsVabQLYEE,629
 skbase/tests/test_meta.py,sha256=TTZW_BlEbirLjeEQCV1x3IYCf6V2ULJ_KfyVHgs0wkU,5662
@@ -34,11 +34,12 @@ skbase/utils/_iter.py,sha256=puDa2z2DIVDsm48eycrkvkAiTEWswgs9lpxxgwes43w,7653
 skbase/utils/_nested_iter.py,sha256=omDI2Y75ajWTSV9d59iJTj1RcCk5YFbc7cZNQjz8AC8,4566
 skbase/utils/_utils.py,sha256=A6sTIUEscEy9TjBmCvXEuhk9q8ROBPyfJGhrjlSA4LY,3134
 skbase/utils/random_state.py,sha256=QxY-M2u_6my315tdml2CukKj7ZVnbqjU_T9ZzixGuq0,5127
+skbase/utils/stdout_mute.py,sha256=XeeNst0oN2D77x85N0pQsBv_iYj6gtlliNS7WadwypQ,2046
 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=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/_dependencies.py,sha256=emca3oXmDXZd5ihVQdwuHUsPTterrUMbuhEgqIROAwA,14340
 skbase/utils/dependencies/tests/__init__.py,sha256=UqE6wenG-HffjT2Z974OLzmXG-M8PNOP9nUnNfqtfT4,74
 skbase/utils/dependencies/tests/test_check_dependencies.py,sha256=uxAC3gr4VWTlgctN90pnT1ra_UYkPxQHEla-IljX-n0,2238
 skbase/utils/tests/__init__.py,sha256=YfvP5lpCrTC_6SIakU7jBBdqYyuqE07nZ56ZYKTs3f0,165
@@ -53,10 +54,10 @@ skbase/validate/_named_objects.py,sha256=mWco9seUhAWbfsvW2yd6NGqDF7jCC-BV7EEakmW
 skbase/validate/_types.py,sha256=riVEVlj8ipErZX07OVbzv6zdGKssfegHyMr8XwaBm6M,12121
 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.8.dist-info/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
-scikit_base-0.7.8.dist-info/METADATA,sha256=rgk5oZpH5IuzFto5-MiPcfKEIj7CBozcW5BZPvh2TNY,8821
-scikit_base-0.7.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-scikit_base-0.7.8.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
-scikit_base-0.7.8.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-scikit_base-0.7.8.dist-info/RECORD,,
+skbase/validate/tests/test_type_validations.py,sha256=oIysbDxRlbBMcCOrDMW6MM6VqhhMWJxNP6NO9Id9Q5g,14133
+scikit_base-0.8.1.dist-info/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
+scikit_base-0.8.1.dist-info/METADATA,sha256=dwSrgzJLUtgNrpL8yN2yhCKgNQcSQRvVdJV_6ZQCIyY,8529
+scikit_base-0.8.1.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+scikit_base-0.8.1.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
+scikit_base-0.8.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+scikit_base-0.8.1.dist-info/RECORD,,

{scikit_base-0.7.8.dist-info → scikit_base-0.8.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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.8"
+__version__: str = "0.8.1"

skbase/base/_base.py

@@ -206,16 +206,29 @@ class BaseObject(_FlagManager):
         return parameters
 
     @classmethod
-    def get_param_names(cls):
+    def get_param_names(cls, sort=True):
         """Get object's parameter names.
 
+        Parameters
+        ----------
+        sort : bool, default=True
+            Whether to return the parameter names sorted in alphabetical order (True),
+            or in the order they appear in the class ``__init__`` (False).
+
         Returns
         -------
         param_names: list[str]
-            Alphabetically sorted list of parameter names of cls.
+            List of parameter names of cls.
+            If ``sort=False``, in same order as they appear in the class ``__init__``.
+            If ``sort=True``, alphabetically ordered.
         """
+        if sort is None:
+            sort = True
+
         parameters = cls._get_init_signature()
-        param_names = sorted([p.name for p in parameters])
+        param_names = [p.name for p in parameters]
+        if sort:
+            param_names = sorted(param_names)
         return param_names
 
     @classmethod
@@ -586,7 +599,7 @@ class BaseObject(_FlagManager):
             `create_test_instance` uses the first (or only) dictionary in `params`
         """
         params_with_defaults = set(cls.get_param_defaults().keys())
-        all_params = set(cls.get_param_names())
+        all_params = set(cls.get_param_names(sort=False))
         params_without_defaults = all_params - params_with_defaults
 
         # if non-default parameters are required, but none have been found, raise error

skbase/lookup/_lookup.py

@@ -16,19 +16,20 @@ all_objects(object_types, filter_tags)
 # https://github.com/sktime/sktime/blob/main/LICENSE
 import importlib
 import inspect
-import io
 import os
 import pathlib
 import pkgutil
-import sys
+import re
 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
 
 from skbase.base import BaseObject
+from skbase.utils.stdout_mute import StdoutMute
 from skbase.validate import check_sequence
 
 __all__: List[str] = ["all_objects", "get_package_metadata"]
@@ -189,48 +190,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 +334,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 StdoutMuteNCatchMNF(active=suppress_import_stdout):
         if isinstance(module, str):
             imported_mod = importlib.import_module(module)
         elif isinstance(module, importlib.machinery.SourceFileLoader):
@@ -308,18 +343,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 +712,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 +727,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 +751,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 +797,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(), StdoutMuteNCatchMNF(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 +1022,110 @@ def _make_dataframe(all_objects, columns):
     import pandas as pd
 
     return pd.DataFrame(all_objects, columns=columns)
+
+
+class StdoutMuteNCatchMNF(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 _handle_exit_exceptions(self, type, value, traceback):  # noqa: A002
+        """Handle exceptions raised during __exit__.
+
+        Parameters
+        ----------
+        type : type
+            The type of the exception raised.
+            Known to be not-None and Exception subtype when this method is called.
+        """
+        # 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
+
+
+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

@@ -54,6 +54,7 @@ SKBASE_MODULES = (
     "skbase.utils.dependencies",
     "skbase.utils.dependencies._dependencies",
     "skbase.utils.random_state",
+    "skbase.utils.stdout_mute",
     "skbase.validate",
     "skbase.validate._named_objects",
     "skbase.validate._types",
@@ -79,6 +80,7 @@ SKBASE_PUBLIC_MODULES = (
     "skbase.utils.deep_equals",
     "skbase.utils.dependencies",
     "skbase.utils.random_state",
+    "skbase.utils.stdout_mute",
     "skbase.validate",
 )
 SKBASE_PUBLIC_CLASSES_BY_MODULE = {
@@ -99,13 +101,14 @@ SKBASE_PUBLIC_CLASSES_BY_MODULE = {
         "BaseMetaEstimatorMixin",
     ),
     "skbase.base._pretty_printing._pprint": ("KeyValTuple", "KeyValTupleParam"),
-    "skbase.lookup._lookup": (),
+    "skbase.lookup._lookup": ("StdoutMuteNCatchMNF",),
     "skbase.testing": ("BaseFixtureGenerator", "QuickTester", "TestAllObjects"),
     "skbase.testing.test_all_objects": (
         "BaseFixtureGenerator",
         "QuickTester",
         "TestAllObjects",
     ),
+    "skbase.utils.stdout_mute": ("StdoutMute",),
 }
 SKBASE_CLASSES_BY_MODULE = SKBASE_PUBLIC_CLASSES_BY_MODULE.copy()
 SKBASE_CLASSES_BY_MODULE.update(
@@ -203,6 +206,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",),

skbase/tests/test_base.py

@@ -706,16 +706,21 @@ def test_get_init_signature_raises_error_for_invalid_signature(
         fixture_invalid_init._get_init_signature()
 
 
+@pytest.mark.parametrize("sort", [True, False])
 def test_get_param_names(
     fixture_object: Type[BaseObject],
     fixture_class_parent: Type[Parent],
     fixture_class_parent_expected_params: Dict[str, Any],
+    sort: bool,
 ):
     """Test that get_param_names returns list of string parameter names."""
-    param_names = fixture_class_parent.get_param_names()
-    assert param_names == sorted([*fixture_class_parent_expected_params])
+    param_names = fixture_class_parent.get_param_names(sort=sort)
+    if sort:
+        assert param_names == sorted([*fixture_class_parent_expected_params])
+    else:
+        assert param_names == [*fixture_class_parent_expected_params]
 
-    param_names = fixture_object.get_param_names()
+    param_names = fixture_object.get_param_names(sort=sort)
     assert param_names == []
 
 

skbase/utils/dependencies/_dependencies.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 """Utility to check soft dependency imports, and raise warnings or errors."""
-import io
 import sys
 import warnings
 from importlib import import_module
@@ -10,6 +9,8 @@ from typing import List
 from packaging.requirements import InvalidRequirement, Requirement
 from packaging.specifiers import InvalidSpecifier, SpecifierSet
 
+from skbase.utils.stdout_mute import StdoutMute
+
 __author__: List[str] = ["fkiraly", "mloning"]
 
 
@@ -130,12 +131,7 @@ def _check_soft_dependencies(
             package_import_name = package_name
         # attempt import - if not possible, we know we need to raise warning/exception
         try:
-            if suppress_import_stdout:
-                # setup text trap, import, then restore
-                sys.stdout = io.StringIO()
-                pkg_ref = import_module(package_import_name)
-                sys.stdout = sys.__stdout__
-            else:
+            with StdoutMute(active=suppress_import_stdout):
                 pkg_ref = import_module(package_import_name)
         # if package cannot be imported, make the user aware of installation requirement
         except ModuleNotFoundError as e:

skbase/utils/stdout_mute.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+"""Context manager to suppress stdout."""
+
+__author__ = ["fkiraly"]
+
+import io
+import sys
+
+
+class StdoutMute:
+    """A context manager to suppress stdout.
+
+    Exception handling on exit can be customized by overriding
+    the ``_handle_exit_exceptions`` method.
+
+    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:
+            return self._handle_exit_exceptions(type, value, traceback)
+
+        # 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 _handle_exit_exceptions(self, type, value, traceback):  # noqa: A002
+        """Handle exceptions raised during __exit__.
+
+        Parameters
+        ----------
+        type : type
+            The type of the exception raised.
+            Known to be not-None and Exception subtype when this method is called.
+        value : Exception
+            The exception instance raised.
+        traceback : traceback
+            The traceback object associated with the exception.
+        """
+        # by default, all exceptions are raised
+        return False

skbase/validate/tests/test_type_validations.py

@@ -127,10 +127,10 @@ def test_is_sequence_output():
     )
 
     # Test with 3rd party types works in default way via exact type
-    assert is_sequence([1.2, 4.7], element_type=np.float_) is False
-    assert is_sequence([np.float_(1.2), np.float_(4.7)], element_type=np.float_) is True
+    assert is_sequence([1.2, 4.7], element_type=np.float64) is False
+    assert is_sequence([np.float64(1.2), np.float64(4.7)], element_type=np.float64)
 
-    # np.nan is float, not int or np.float_
+    # np.nan is float, not int or np.float64
     assert is_sequence([np.nan, 4.8], element_type=float) is True
     assert is_sequence([np.nan, 4], element_type=int) is False
 
@@ -243,11 +243,11 @@ def test_check_sequence_output():
         TypeError,
         match="Invalid sequence: .*",
     ):
-        check_sequence([1.2, 4.7], element_type=np.float_)
-    input_seq = [np.float_(1.2), np.float_(4.7)]
-    assert check_sequence(input_seq, element_type=np.float_) == input_seq
+        check_sequence([1.2, 4.7], element_type=np.float64)
+    input_seq = [np.float64(1.2), np.float64(4.7)]
+    assert check_sequence(input_seq, element_type=np.float64) == input_seq
 
-    # np.nan is float, not int or np.float_
+    # np.nan is float, not int or np.float64
     assert check_sequence([np.nan, 4.8], element_type=float) == [np.nan, 4.8]
     assert check_sequence([np.nan, 4.8, 7], element_type=(float, int)) == [
         np.nan,