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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scikit-base
-Version: 0.8.0
+Version: 0.8.2
 Summary: Base classes for sklearn-like parametric objects
 Author-email: sktime developers <sktime.toolbox@gmail.com>
 Maintainer: Franz Király
@@ -75,10 +75,10 @@ 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.17.0 ; extra == 'docs'
+Requires-Dist: sphinx-gallery <0.18.0 ; extra == 'docs'
 Requires-Dist: sphinx-panels ; extra == 'docs'
 Requires-Dist: sphinx-design <0.7.0 ; extra == 'docs'
-Requires-Dist: Sphinx !=7.2.0,<8.0.0 ; extra == 'docs'
+Requires-Dist: Sphinx !=7.2.0,<9.0.0 ; extra == 'docs'
 Requires-Dist: tabulate ; extra == 'docs'
 Provides-Extra: linters
 Requires-Dist: mypy ; extra == 'linters'
@@ -114,7 +114,7 @@ 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.8.0 is now available. Check out our
+:rocket: Version 0.8.2 is now available. Check out our
 [release notes](https://skbase.readthedocs.io/en/latest/changelog.html).
 
 | Overview | |

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

@@ -1,9 +1,9 @@
 docs/source/conf.py,sha256=kFc-4qkb0ZGD5cDej5KPJhMePp9kpVu6ZqFoF0fgovg,9951
-skbase/__init__.py,sha256=dc-gpNeQnwKO9izn78U5iB3Fj9AREwfkW5v6Cd-Pefk,345
+skbase/__init__.py,sha256=DIqf7QEkt2QDidE-9-ErW63rmELfeU2h8gu_iYsXzlY,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,7 +12,7 @@ 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=C3k07rxCPz5tJG0-lKBCH6rQedJOiuTv0ja0_Hxe_XM,45083
+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=cldy5v_K_GmAXWe-90eTIoHIm5g5-C77ffkYCWjw7bU,39743
 skbase/testing/__init__.py,sha256=OdwR-aEU2KzGrU-O0gtNSMNGmF2mtgBmjAnMzcgwe6w,351
@@ -21,8 +21,8 @@ skbase/testing/utils/__init__.py,sha256=kaLuqQwJsCunRWsUb1JwTVG-iqXbzdUobuYHNHsB
 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=3n8QyF9_WjqC5x40dSR92pzQja4ECoW4cyGZIhj1gS8,9375
-skbase/tests/test_base.py,sha256=-kyVDOQRdXYsBmSTqNjZ06mjnt_OWoY2i2i71qx3TF8,50648
+skbase/tests/conftest.py,sha256=dSZMtEE6cGB76iWtrHQY0iLpLFUt6Ir8xKNmzpwo0PY,9673
+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=GRDKuzVqyo1SFRMOyHntYOMMKGr3vJ5414jJjtH3dao,21182
 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.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/validate/tests/test_type_validations.py,sha256=oIysbDxRlbBMcCOrDMW6MM6VqhhMWJxNP6NO9Id9Q5g,14133
+scikit_base-0.8.2.dist-info/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
+scikit_base-0.8.2.dist-info/METADATA,sha256=8kQ1XizgepOCLIkY1WdFrBLJl6ShYR5_pm_Pqr1tyW0,8529
+scikit_base-0.8.2.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+scikit_base-0.8.2.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
+scikit_base-0.8.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+scikit_base-0.8.2.dist-info/RECORD,,

{scikit_base-0.8.0.dist-info → scikit_base-0.8.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (72.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.8.0"
+__version__: str = "0.8.2"

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,12 +16,10 @@ 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 re
-import sys
 import warnings
 from collections.abc import Iterable
 from copy import deepcopy
@@ -31,6 +29,7 @@ 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"]
@@ -335,7 +334,7 @@ def _import_module(
 
     # if suppress_import_stdout:
     # setup text trap, import
-    with StdoutMute(active=suppress_import_stdout):
+    with StdoutMuteNCatchMNF(active=suppress_import_stdout):
         if isinstance(module, str):
             imported_mod = importlib.import_module(module)
         elif isinstance(module, importlib.machinery.SourceFileLoader):
@@ -865,7 +864,7 @@ def all_objects(
         obj_types = _check_object_types(object_types, class_lookup)
 
     # Ignore deprecation warnings triggered at import time and from walking packages
-    with warnings.catch_warnings(), StdoutMute(active=suppress_import_stdout):
+    with warnings.catch_warnings(), StdoutMuteNCatchMNF(active=suppress_import_stdout):
         warnings.simplefilter("ignore", category=FutureWarning)
         warnings.simplefilter("module", category=ImportWarning)
         warnings.filterwarnings(
@@ -1025,7 +1024,7 @@ def _make_dataframe(all_objects, columns):
     return pd.DataFrame(all_objects, columns=columns)
 
 
-class StdoutMute:
+class StdoutMuteNCatchMNF(StdoutMute):
     """A context manager to suppress stdout.
 
     This class is used to suppress stdout when importing modules.
@@ -1042,39 +1041,26 @@ class StdoutMute:
         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 _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):

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": ("StdoutMute",),
+    "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(
@@ -248,7 +251,12 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
         "skbase.utils.dependencies._dependencies": (
             "_check_soft_dependencies",
             "_check_python_version",
+            "_check_env_marker",
             "_check_estimator_deps",
+            "_get_pkg_version",
+            "_get_installed_packages",
+            "_normalize_requirement",
+            "_raise_at_severity",
         ),
         "skbase.utils.random_state": (
             "check_random_state",

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,25 +1,25 @@
 # -*- 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
+from functools import lru_cache
+from importlib.metadata import distributions
 from inspect import isclass
-from typing import List
 
+from packaging.markers import InvalidMarker, Marker
 from packaging.requirements import InvalidRequirement, Requirement
-from packaging.specifiers import InvalidSpecifier, SpecifierSet
-
-__author__: List[str] = ["fkiraly", "mloning"]
+from packaging.specifiers import InvalidSpecifier, Specifier, SpecifierSet
+from packaging.version import InvalidVersion, Version
 
 
+# todo 0.10.0: remove suppress_import_stdout argument
 def _check_soft_dependencies(
     *packages,
-    package_import_alias=None,
+    package_import_alias="deprecated",
     severity="error",
     obj=None,
     msg=None,
-    suppress_import_stdout=False,
+    suppress_import_stdout="deprecated",
 ):
     """Check if required soft dependencies are installed and raise error or warning.
 
@@ -28,43 +28,63 @@ def _check_soft_dependencies(
     packages : str or list/tuple of str, or length-1-tuple containing list/tuple of str
         str should be package names and/or package version specifications to check.
         Each str must be a PEP 440 compatible specifier string, for a single package.
-        For instance, the PEP 440 compatible package name such as "pandas";
-        or a package requirement specifier string such as "pandas>1.2.3".
+        For instance, the PEP 440 compatible package name such as ``"pandas"``;
+        or a package requirement specifier string such as ``"pandas>1.2.3"``.
         arg can be str, kwargs tuple, or tuple/list of str, following calls are valid:
-        `_check_soft_dependencies("package1")`
-        `_check_soft_dependencies("package1", "package2")`
-        `_check_soft_dependencies(("package1", "package2"))`
-        `_check_soft_dependencies(["package1", "package2"])`
-    package_import_alias : dict with str keys and values, optional, default=empty
-        key-value pairs are package name, import name
-        import name is str used in python import, i.e., from import_name import ...
-        should be provided if import name differs from package name
+        ``_check_soft_dependencies("package1")``
+        ``_check_soft_dependencies("package1", "package2")``
+        ``_check_soft_dependencies(("package1", "package2"))``
+        ``_check_soft_dependencies(["package1", "package2"])``
+
+    package_import_alias : ignored, present only for backwards compatibility
+
     severity : str, "error" (default), "warning", "none"
-        behaviour for raising errors or warnings
-        "error" - raises a `ModuleNotFoundError` if one of packages is not installed
-        "warning" - raises a warning if one of packages is not installed
-            function returns False if one of packages is not installed, otherwise True
-        "none" - does not raise exception or warning
-            function returns False if one of packages is not installed, otherwise True
+        whether the check should raise an error, a warning, or nothing
+
+        * "error" - raises a ``ModuleNotFoundError`` if one of packages is not installed
+        * "warning" - raises a warning if one of packages is not installed
+          function returns False if one of packages is not installed, otherwise True
+        * "none" - does not raise exception or warning
+          function returns False if one of packages is not installed, otherwise True
+
     obj : python class, object, str, or None, default=None
         if self is passed here when _check_soft_dependencies is called within __init__,
         or a class is passed when it is called at the start of a single-class module,
         the error message is more informative and will refer to the class/object;
         if str is passed, will be used as name of the class/object or module
+
     msg : str, or None, default=None
         if str, will override the error message or warning shown with msg
-    suppress_import_stdout : bool, optional. Default=False
-        whether to suppress stdout printout upon import.
 
     Raises
     ------
+    InvalidRequirement
+        if package requirement strings are not PEP 440 compatible
     ModuleNotFoundError
         error with informative message, asking to install required soft dependencies
+    TypeError, ValueError
+        on invalid arguments
 
     Returns
     -------
     boolean - whether all packages are installed, only if no exception is raised
     """
+    # todo 0.10.0: remove this warning
+    if suppress_import_stdout != "deprecated":
+        warnings.warn(
+            "In skbase _check_soft_dependencies, the suppress_import_stdout argument "
+            "is deprecated and no longer has any effect. "
+            "The argument will be removed in version 0.10.0, so users of the "
+            "_check_soft_dependencies utility should not pass this argument anymore. "
+            "The _check_soft_dependencies utility also no longer causes imports, "
+            "hence no stdout "
+            "output is created from imports, for any setting of the "
+            "suppress_import_stdout argument. If you wish to import packages "
+            "and make use of stdout prints, import the package directly instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
     if len(packages) == 1 and isinstance(packages[0], (tuple, list)):
         packages = packages[0]
     if not all(isinstance(x, str) for x in packages):
@@ -73,20 +93,6 @@ def _check_soft_dependencies(
             f"str, but found packages argument of type {type(packages)}"
         )
 
-    if package_import_alias is None:
-        package_import_alias = {}
-    msg_pkg_import_alias = (
-        "package_import_alias argument of _check_soft_dependencies must "
-        "be a dict with str keys and values, but found "
-        f"package_import_alias of type {type(package_import_alias)}"
-    )
-    if not isinstance(package_import_alias, dict):
-        raise TypeError(msg_pkg_import_alias)
-    if not all(isinstance(x, str) for x in package_import_alias.keys()):
-        raise TypeError(msg_pkg_import_alias)
-    if not all(isinstance(x, str) for x in package_import_alias.values()):
-        raise TypeError(msg_pkg_import_alias)
-
     if obj is None:
         class_name = "This functionality"
     elif not isclass(obj):
@@ -111,6 +117,7 @@ def _check_soft_dependencies(
     for package in packages:
         try:
             req = Requirement(package)
+            req = _normalize_requirement(req)
         except InvalidRequirement:
             msg_version = (
                 f"wrong format for package requirement string, "
@@ -123,58 +130,34 @@ def _check_soft_dependencies(
         package_name = req.name
         package_version_req = req.specifier
 
-        # determine the package import
-        if package_name in package_import_alias.keys():
-            package_import_name = package_import_alias[package_name]
-        else:
-            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:
-                pkg_ref = import_module(package_import_name)
-        # if package cannot be imported, make the user aware of installation requirement
-        except ModuleNotFoundError as e:
-            if msg is None:
+        pkg_env_version = _get_pkg_version(package_name)
+
+        # if package not present, make the user aware of installation reqs
+        if pkg_env_version is None:
+            if obj is None and msg is None:
                 msg = (
-                    f"{e}. "
                     f"{class_name} requires package {package!r} to be present "
                     f"in the python environment, but {package!r} was not found. "
                 )
-                if obj is not None:
-                    msg = msg + (
-                        f"{package!r} is a dependency of {class_name} and required "
-                        f"to construct it. "
-                    )
-                msg = msg + (
-                    f"Please run: `pip install {package}` to "
-                    f"install the {package} package. "
+            elif msg is None:  # obj is not None, msg is None
+                msg = (
+                    f"{class_name} requires package {package!r} to be present "
+                    f"in the python environment, but {package!r} was not found. "
+                    f"{package!r} is a dependency of {class_name} and required "
+                    f"to construct it. "
                 )
+            msg = msg + (
+                f"Please run: `pip install {package}` to "
+                f"install the {package} package. "
+            )
             # if msg is not None, none of the above is executed,
             # so if msg is passed it overrides the default messages
 
-            if severity == "error":
-                raise ModuleNotFoundError(msg) from e
-            elif severity == "warning":
-                warnings.warn(msg, stacklevel=2)
-                return False
-            elif severity == "none":
-                return False
-            else:
-                raise RuntimeError(
-                    "Error in calling _check_soft_dependencies, severity "
-                    'argument must be "error", "warning", or "none",'
-                    f"found {severity!r}."
-                ) from e
+            _raise_at_severity(msg, severity, caller="_check_soft_dependencies")
+            return False
 
         # now we check compatibility with the version specifier if non-empty
         if package_version_req != SpecifierSet(""):
-            pkg_env_version = pkg_ref.__version__
-
             msg = (
                 f"{class_name} requires package {package!r} to be present "
                 f"in the python environment, with version {package_version_req}, "
@@ -188,23 +171,67 @@ def _check_soft_dependencies(
 
             # raise error/warning or return False if version is incompatible
             if pkg_env_version not in package_version_req:
-                if severity == "error":
-                    raise ModuleNotFoundError(msg)
-                elif severity == "warning":
-                    warnings.warn(msg, stacklevel=2)
-                elif severity == "none":
-                    return False
-                else:
-                    raise RuntimeError(
-                        "Error in calling _check_soft_dependencies, severity argument"
-                        f' must be "error", "warning", or "none", found {severity!r}.'
-                    )
+                _raise_at_severity(msg, severity, caller="_check_soft_dependencies")
+                return False
 
     # if package can be imported and no version issue was caught for any string,
     # then obj is compatible with the requirements and we should return True
     return True
 
 
+@lru_cache
+def _get_installed_packages_private():
+    """Get a dictionary of installed packages and their versions.
+
+    Same as _get_installed_packages, but internal to avoid mutating the lru_cache
+    by accident.
+    """
+    dists = distributions()
+    packages = {dist.metadata["Name"]: dist.version for dist in dists}
+    return packages
+
+
+def _get_installed_packages():
+    """Get a dictionary of installed packages and their versions.
+
+    Returns
+    -------
+    dict : dictionary of installed packages and their versions
+        keys are PEP 440 compatible package names, values are package versions
+        MAJOR.MINOR.PATCH version format is used for versions, e.g., "1.2.3"
+    """
+    return _get_installed_packages_private().copy()
+
+
+def _get_pkg_version(package_name):
+    """Check whether package is available in environment, and return its version if yes.
+
+    Returns ``Version`` object from ``lru_cache``, this should not be mutated.
+
+    Parameters
+    ----------
+    package_name : str, optional, default=None
+        name of package to check,
+        PEP 440 compatibe specifier string, e.g., "pandas" or "sklearn".
+        This is the pypi package name, not the import name, e.g.,
+        ``scikit-learn``, not ``sklearn``.
+
+    Returns
+    -------
+    None, if package is not found in python environment.
+    ``importlib`` ``Version`` of package, if present in environment.
+    """
+    pkgs = _get_installed_packages()
+    pkg_vers_str = pkgs.get(package_name, None)
+    if pkg_vers_str is None:
+        return None
+    try:
+        pkg_env_version = Version(pkg_vers_str)
+    except InvalidVersion:
+        pkg_env_version = None
+    return pkg_env_version
+
+
 def _check_python_version(obj, package=None, msg=None, severity="error"):
     """Check if system python version is compatible with requirements of obj.
 
@@ -212,13 +239,22 @@ def _check_python_version(obj, package=None, msg=None, severity="error"):
     ----------
     obj : BaseObject descendant
         used to check python version
+
     package : str, default = None
         if given, will be used in error message as package name
+
     msg : str, optional, default = default message (msg below)
-        error message to be returned in the `ModuleNotFoundError`, overrides default
-    severity : str, "error" (default), "warning", or "none"
+        error message to be returned in the ``ModuleNotFoundError``, overrides default
+
+    severity : str, "error" (default), "warning", "none"
         whether the check should raise an error, a warning, or nothing
 
+        * "error" - raises a ``ModuleNotFoundError`` if one of packages is not installed
+        * "warning" - raises a warning if one of packages is not installed
+          function returns False if one of packages is not installed, otherwise True
+        * "none" - does not raise exception or warning
+          function returns False if one of packages is not installed, otherwise True
+
     Returns
     -------
     compatible : bool, whether obj is compatible with system python version
@@ -251,6 +287,7 @@ def _check_python_version(obj, package=None, msg=None, severity="error"):
     if sys_version in est_specifier:
         return True
     # now we know that est_version is not compatible with sys_version
+
     if isclass(obj):
         class_name = obj.__name__
     else:
@@ -267,18 +304,80 @@ def _check_python_version(obj, package=None, msg=None, severity="error"):
                 f" This is due to python version requirements of the {package} package."
             )
 
-    if severity == "error":
-        raise ModuleNotFoundError(msg)
-    elif severity == "warning":
-        warnings.warn(msg, stacklevel=2)
-    elif severity == "none":
-        return False
+    _raise_at_severity(msg, severity, caller="_check_python_version")
+    return False
+
+
+def _check_env_marker(obj, package=None, msg=None, severity="error"):
+    """Check if packaging marker tag is with requirements of obj.
+
+    Parameters
+    ----------
+    obj : BaseObject descendant
+        used to check python version
+    package : str, default = None
+        if given, will be used in error message as package name
+    msg : str, optional, default = default message (msg below)
+        error message to be returned in the `ModuleNotFoundError`, overrides default
+
+    severity : str, "error" (default), "warning", "none"
+        whether the check should raise an error, a warning, or nothing
+
+        * "error" - raises a ``ModuleNotFoundError`` if one of packages is not installed
+        * "warning" - raises a warning if one of packages is not installed
+          function returns False if one of packages is not installed, otherwise True
+        * "none" - does not raise exception or warning
+          function returns False if one of packages is not installed, otherwise True
+
+    Returns
+    -------
+    compatible : bool, whether obj is compatible with system python version
+        check is using the python_version tag of obj
+
+    Raises
+    ------
+    InvalidMarker
+        User friendly error if obj has env_marker tag that is not a
+        packaging compatible marker string
+    ModuleNotFoundError
+        User friendly error if obj has an env_marker tag that is
+        incompatible with the python environment. If package is given,
+        error message gives package as the reason for incompatibility.
+    """
+    est_marker_tag = obj.get_class_tag("env_marker", tag_value_default="None")
+    if est_marker_tag in ["None", None]:
+        return True
+
+    try:
+        est_marker = Marker(est_marker_tag)
+    except InvalidMarker:
+        msg_version = (
+            f"wrong format for env_marker tag, "
+            f"must be PEP 508 compatible specifier string, e.g., "
+            f'platform_system!="windows", but found {est_marker_tag!r}'
+        )
+        raise InvalidMarker(msg_version) from None
+
+    if est_marker.evaluate():
+        return True
+    # now we know that est_marker is not compatible with the environment
+
+    if isclass(obj):
+        class_name = obj.__name__
     else:
-        raise RuntimeError(
-            "Error in calling _check_python_version, severity "
-            f'argument must be "error", "warning", or "none", found {severity!r}.'
+        class_name = type(obj).__name__
+
+    if not isinstance(msg, str):
+        msg = (
+            f"{class_name} requires an environment to satisfy "
+            f"packaging marker spec {est_marker}, but environment does not satisfy it."
         )
-    return True
+
+        if package is not None:
+            msg += f" This is due to requirements of the {package} package."
+
+    _raise_at_severity(msg, severity, caller="_check_env_marker")
+    return False
 
 
 def _check_estimator_deps(obj, msg=None, severity="error"):
@@ -292,17 +391,20 @@ def _check_estimator_deps(obj, msg=None, severity="error"):
 
     Parameters
     ----------
-    obj : `BaseObject` descendant, instance or class, or list/tuple thereof
+    obj : BaseObject descendant, instance or class, or list/tuple thereof
         object(s) that this function checks compatibility of, with the python env
+
     msg : str, optional, default = default message (msg below)
-        error message to be returned in the `ModuleNotFoundError`, overrides default
-    severity : str, "error" (default), "warning", or "none"
-        behaviour for raising errors or warnings
-        "error" - raises a `ModuleNotFoundError` if environment is incompatible
-        "warning" - raises a warning if environment is incompatible
-            function returns False if environment is incompatible, otherwise True
-        "none" - does not raise exception or warning
-            function returns False if environment is incompatible, otherwise True
+        error message to be returned in the ``ModuleNotFoundError``, overrides default
+
+    severity : str, "error" (default), "warning", "none"
+        whether the check should raise an error, a warning, or nothing
+
+        * "error" - raises a ``ModuleNotFoundError`` if one of packages is not installed
+        * "warning" - raises a warning if one of packages is not installed
+          function returns False if one of packages is not installed, otherwise True
+        * "none" - does not raise exception or warning
+          function returns False if one of packages is not installed, otherwise True
 
     Returns
     -------
@@ -331,6 +433,7 @@ def _check_estimator_deps(obj, msg=None, severity="error"):
         return compatible
 
     compatible = compatible and _check_python_version(obj, severity=severity)
+    compatible = compatible and _check_env_marker(obj, severity=severity)
 
     pkg_deps = obj.get_class_tag("python_dependencies", None)
     pck_alias = obj.get_class_tag("python_dependencies_alias", None)
@@ -343,3 +446,97 @@ def _check_estimator_deps(obj, msg=None, severity="error"):
         compatible = compatible and pkg_deps_ok
 
     return compatible
+
+
+def _normalize_requirement(req):
+    """Normalize packaging Requirement by removing build metadata from versions.
+
+    Parameters
+    ----------
+    req : packaging.requirements.Requirement
+        requirement string to normalize, e.g., Requirement("pandas>1.2.3+foobar")
+
+    Returns
+    -------
+    normalized_req : packaging.requirements.Requirement
+        normalized requirement object with build metadata removed from versions,
+        e.g., Requirement("pandas>1.2.3")
+    """
+    # Process each specifier in the requirement
+    normalized_specs = []
+    for spec in req.specifier:
+        # Parse the version and remove the build metadata
+        spec_v = Version(spec.version)
+        version_wo_build_metadata = f"{spec_v.major}.{spec_v.minor}.{spec_v.micro}"
+
+        # Create a new specifier without the build metadata
+        normalized_spec = Specifier(f"{spec.operator}{version_wo_build_metadata}")
+        normalized_specs.append(normalized_spec)
+
+    # Reconstruct the specifier set
+    normalized_specifier_set = SpecifierSet(",".join(str(s) for s in normalized_specs))
+
+    # Create a new Requirement object with the normalized specifiers
+    normalized_req = Requirement(f"{req.name}{normalized_specifier_set}")
+
+    return normalized_req
+
+
+def _raise_at_severity(
+    msg,
+    severity,
+    exception_type=None,
+    warning_type=None,
+    stacklevel=2,
+    caller="_raise_at_severity",
+):
+    """Raise exception or warning or take no action, based on severity.
+
+    Parameters
+    ----------
+    msg : str
+        message to raise or warn
+
+    severity : str, "error" (default), "warning", "none"
+        whether the check should raise an error, a warning, or nothing
+
+        * "error" - raises a ``ModuleNotFoundError`` if one of packages is not installed
+        * "warning" - raises a warning if one of packages is not installed
+          function returns False if one of packages is not installed, otherwise True
+        * "none" - does not raise exception or warning
+          function returns False if one of packages is not installed, otherwise True
+
+    exception_type : Exception, default=ModuleNotFoundError
+        exception type to raise if severity="severity"
+    warning_type : warning, default=Warning
+        warning type to raise if severity="warning"
+    stacklevel : int, default=2
+        stacklevel for warnings, if severity="warning"
+    caller : str, default="_raise_at_severity"
+        caller name, used in exception if severity not in ["error", "warning", "none"]
+
+    Returns
+    -------
+    None
+
+    Raises
+    ------
+    exception : exception_type, if severity="error"
+    warning : warning+type, if severity="warning"
+    ValueError : if severity not in ["error", "warning", "none"]
+    """
+    if exception_type is None:
+        exception_type = ModuleNotFoundError
+
+    if severity == "error":
+        raise exception_type(msg)
+    elif severity == "warning":
+        warnings.warn(msg, category=warning_type, stacklevel=stacklevel)
+    elif severity == "none":
+        return None
+    else:
+        raise ValueError(
+            f"Error in calling {caller}, severity "
+            f'argument must be "error", "warning", or "none", found {severity!r}.'
+        )
+    return None

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,