scikit-base 0.7.8__tar.gz → 0.8.1__tar.gz

{scikit_base-0.7.8/scikit_base.egg-info → scikit_base-0.8.1}/PKG-INFO

@@ -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
@@ -92,7 +92,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: test
@@ -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 → scikit_base-0.8.1}/README.md

@@ -7,14 +7,14 @@
 `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 → scikit_base-0.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scikit-base"
-version = "0.7.8"
+version = "0.8.1"
 description = "Base classes for sklearn-like parametric objects"
 authors = [
     {name = "sktime developers", email = "sktime.toolbox@gmail.com"},
@@ -73,7 +73,7 @@ docs = [
     "sphinx-issues<5.0.0",
     "sphinx-gallery<0.17.0",
     "sphinx-panels",
-    "sphinx-design<0.6.0",
+    "sphinx-design<0.7.0",
     "Sphinx<8.0.0,!=7.2.0",
     "tabulate",
 ]

{scikit_base-0.7.8 → scikit_base-0.8.1/scikit_base.egg-info}/PKG-INFO

@@ -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
@@ -92,7 +92,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: test
@@ -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 → scikit_base-0.8.1}/scikit_base.egg-info/SOURCES.txt

@@ -44,6 +44,7 @@ skbase/utils/_iter.py
 skbase/utils/_nested_iter.py
 skbase/utils/_utils.py
 skbase/utils/random_state.py
+skbase/utils/stdout_mute.py
 skbase/utils/deep_equals/__init__.py
 skbase/utils/deep_equals/_common.py
 skbase/utils/deep_equals/_deep_equals.py

{scikit_base-0.7.8 → scikit_base-0.8.1}/scikit_base.egg-info/requires.txt

@@ -21,7 +21,7 @@ pydata-sphinx-theme
 sphinx-issues<5.0.0
 sphinx-gallery<0.17.0
 sphinx-panels
-sphinx-design<0.6.0
+sphinx-design<0.7.0
 Sphinx!=7.2.0,<8.0.0
 tabulate
 

{scikit_base-0.7.8 → scikit_base-0.8.1}/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"

{scikit_base-0.7.8 → scikit_base-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

{scikit_base-0.7.8 → scikit_base-0.8.1}/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

{scikit_base-0.7.8 → scikit_base-0.8.1}/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):

{scikit_base-0.7.8 → scikit_base-0.8.1}/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",),

{scikit_base-0.7.8 → scikit_base-0.8.1}/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 == []
 
 

{scikit_base-0.7.8 → scikit_base-0.8.1}/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:

scikit_base-0.8.1/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

{scikit_base-0.7.8 → scikit_base-0.8.1}/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,