scikit-base 0.12.0__py3-none-any.whl → 0.12.3__py3-none-any.whl

{scikit_base-0.12.0.dist-info → scikit_base-0.12.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: scikit-base
-Version: 0.12.0
+Version: 0.12.3
 Summary: Base classes for sklearn-like parametric objects
 Author-email: sktime developers <sktime.toolbox@gmail.com>
 Maintainer: Franz Király
@@ -58,28 +58,14 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Provides-Extra: all_extras
+Provides-Extra: all-extras
 Requires-Dist: numpy; extra == "all-extras"
 Requires-Dist: pandas; extra == "all-extras"
-Provides-Extra: binder
-Requires-Dist: jupyter; extra == "binder"
 Provides-Extra: dev
 Requires-Dist: scikit-learn>=0.24.0; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
-Provides-Extra: docs
-Requires-Dist: jupyter; extra == "docs"
-Requires-Dist: myst-parser; extra == "docs"
-Requires-Dist: nbsphinx>=0.8.6; extra == "docs"
-Requires-Dist: numpydoc; extra == "docs"
-Requires-Dist: pydata-sphinx-theme; extra == "docs"
-Requires-Dist: sphinx-issues<6.0.0; extra == "docs"
-Requires-Dist: sphinx-gallery<0.19.0; extra == "docs"
-Requires-Dist: sphinx-panels; extra == "docs"
-Requires-Dist: sphinx-design<0.7.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"
 Requires-Dist: isort; extra == "linters"
@@ -95,6 +81,20 @@ Requires-Dist: pandas-vet; extra == "linters"
 Requires-Dist: flake8-print; extra == "linters"
 Requires-Dist: pep8-naming; extra == "linters"
 Requires-Dist: doc8; extra == "linters"
+Provides-Extra: binder
+Requires-Dist: jupyter; extra == "binder"
+Provides-Extra: docs
+Requires-Dist: jupyter; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: nbsphinx>=0.8.6; extra == "docs"
+Requires-Dist: numpydoc; extra == "docs"
+Requires-Dist: pydata-sphinx-theme; extra == "docs"
+Requires-Dist: sphinx-issues<6.0.0; extra == "docs"
+Requires-Dist: sphinx-gallery<0.20.0; extra == "docs"
+Requires-Dist: sphinx-panels; extra == "docs"
+Requires-Dist: sphinx-design<0.7.0; extra == "docs"
+Requires-Dist: Sphinx!=7.2.0,<9.0.0; extra == "docs"
+Requires-Dist: tabulate; extra == "docs"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: coverage; extra == "test"
@@ -104,6 +104,7 @@ Requires-Dist: numpy; extra == "test"
 Requires-Dist: scipy; extra == "test"
 Requires-Dist: pandas; extra == "test"
 Requires-Dist: scikit-learn>=0.24.0; extra == "test"
+Dynamic: license-file
 
 <a href="https://skbase.readthedocs.io/en/latest/"><img src="https://github.com/sktime/skbase/blob/main/docs/source/images/skbase-logo-with-name.png" width="175" align="right" /></a>
 
@@ -114,7 +115,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.12.0 is now available. Check out our
+:rocket: Version 0.12.3 is now available. Check out our
 [release notes](https://skbase.readthedocs.io/en/latest/changelog.html).
 
 | Overview | |
@@ -160,3 +161,13 @@ or, if you want to install with the maximum set of dependencies, use:
 ```bash
 pip install scikit-base[all_extras]
 ```
+
+## Contributors ✨
+
+This project follows the
+[all-contributors](https://github.com/all-contributors/all-contributors) specification.
+Contributions of any kind welcome!
+
+Thanks go to these wonderful people:
+
+[skbase contributors](https://github.com/sktime/skbase/graphs/contributors)

{scikit_base-0.12.0.dist-info → scikit_base-0.12.3.dist-info}/RECORD

@@ -1,12 +1,13 @@
 docs/source/conf.py,sha256=kFc-4qkb0ZGD5cDej5KPJhMePp9kpVu6ZqFoF0fgovg,9951
-skbase/__init__.py,sha256=WEOqt1h0pUasRLXHL63vuu7eUGzR-CzdszMmunJyH70,346
+scikit_base-0.12.3.dist-info/licenses/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
+skbase/__init__.py,sha256=no3sDP1mhGmvqUpwxDRk8Igl935OXfuteZibStVCwD8,346
 skbase/_exceptions.py,sha256=asAhMbBeMwRBU_HDPFzwVCz8sb9_itG_6JVq3v_RZv8,1100
-skbase/_nopytest_tests.py,sha256=npL5pibSgCpulEGw0NqLKcG0majh6xcdW5A4Zibf78s,1077
+skbase/_nopytest_tests.py,sha256=NnFa4WPrjxUCcBvIlkCh7q-4WfMFVErSEPMK4OJPFtY,1078
 skbase/base/__init__.py,sha256=5ZLlwJeyfKDA1lAylBJgZd3t5JY25xsgQB4waQnroa8,751
-skbase/base/_base.py,sha256=frYe-ycOLR8t-swr_ROwBTgFIFC2JEGV15yfqS0BJ5s,65942
+skbase/base/_base.py,sha256=Uq49QGwIG2GJviSic5Uin88WIdBhzMfbZaR103zjCTc,66355
 skbase/base/_clone_base.py,sha256=u-uw9mOLUf0QKxvM4ibeClYRTSf7wwcKDvAoiuh0Y-Q,5281
 skbase/base/_clone_plugins.py,sha256=61_FqlE0oCDFymFtzrSSWlbm_yg5ugCyFnhNLF2MdSo,6693
-skbase/base/_meta.py,sha256=VY6_R2tE885j-GTDuzLFyho5i382jOni5lkR_ykPZqo,38815
+skbase/base/_meta.py,sha256=vW6f4rf64ijJ7fj0CVfoAui6nC1ujTSd_gtuAcC8d9g,39073
 skbase/base/_tagmanager.py,sha256=nKoiIC1yXFFSpN5ljWbMrwA-pwlbxsljgKuUywh1MR4,7289
 skbase/base/_pretty_printing/__init__.py,sha256=bVuKnwafn8c2q2AGJ9BOu9cmu-xBjiOxHf1hxjm8K2A,492
 skbase/base/_pretty_printing/_object_html_repr.py,sha256=jvng-RT2JH4RElJkYBNdfu-lRKzlqZeBgqsNl2kNDKM,11677
@@ -14,17 +15,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=pBNy6CjXXNKFZDEkJ1Atpa03m4UA3ZPFbpw-YvPzXE8,1031
 skbase/lookup/__init__.py,sha256=RNw1mx8nXFHsn-HgnjHzWPn9AG45jSMEKl-Z0pEH7jE,1089
-skbase/lookup/_lookup.py,sha256=COZhLXRVZUdisoiS53J1LZylyjlM8TX-P9erEp6bk9I,43025
+skbase/lookup/_lookup.py,sha256=FCEqbvPGEgm94IcGwY6EPEmpknnZTquDb5VInUPqj3A,43722
 skbase/lookup/tests/__init__.py,sha256=MVqGlWsUV-gQ4qzW_TqE3UmKO9IQ9mwdDlsIHaGt3bc,68
 skbase/lookup/tests/test_lookup.py,sha256=kAgsGyp4EYrXZnqezya-PI14m9mm8-ePoR0Wf-Cu-oo,39782
 skbase/testing/__init__.py,sha256=OdwR-aEU2KzGrU-O0gtNSMNGmF2mtgBmjAnMzcgwe6w,351
-skbase/testing/test_all_objects.py,sha256=YoG4Ogg8X9etZoGhPhcwzLTzBCq6GyOncEIRo0qR1Og,36373
+skbase/testing/test_all_objects.py,sha256=WCdpQ0cYxeAoBkmT1Dh-iDeHdbgqZlTB6SOBQLDLV7I,36372
 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=mTtbBiKzmC2dRF3vir_Kh1EmcAhkxNfNsmxIvbmcfos,10723
-skbase/tests/test_base.py,sha256=TDnXM805Ak50DgrG-tzRzcZy9CagpCtq-jIdRzKS0PY,51553
+skbase/tests/conftest.py,sha256=sTp5aMUGipa8C3AcqBF1f6pyMTGdGIYJsQ4u-k9h3sw,11083
+skbase/tests/test_base.py,sha256=DQzJFtGc7gFOyPRc3b-LfAtFONI4BntanKBicm85rws,49439
 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
@@ -35,20 +36,21 @@ skbase/utils/_check.py,sha256=75rXeB1KI-DXbOoa3KnU4zxAmLk4NBk1yAGkRlbVyIo,1394
 skbase/utils/_iter.py,sha256=puDa2z2DIVDsm48eycrkvkAiTEWswgs9lpxxgwes43w,7653
 skbase/utils/_nested_iter.py,sha256=omDI2Y75ajWTSV9d59iJTj1RcCk5YFbc7cZNQjz8AC8,4566
 skbase/utils/_utils.py,sha256=A6sTIUEscEy9TjBmCvXEuhk9q8ROBPyfJGhrjlSA4LY,3134
+skbase/utils/doctest_run.py,sha256=IfqnVKvLoajf048ul-wthLUkOcXcl8drokxu2Mx_YFk,1875
 skbase/utils/random_state.py,sha256=QxY-M2u_6my315tdml2CukKj7ZVnbqjU_T9ZzixGuq0,5127
 skbase/utils/stderr_mute.py,sha256=VGMAjYgEjl-T-cFEzGJp_ry2iNR8wYLKL9SDhT8OZ7s,2046
 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/deep_equals/_deep_equals.py,sha256=zKJx6xPUOHCYrqJh322TA9BW2c10gLgmbrHqKW6siqk,19225
 skbase/utils/dependencies/__init__.py,sha256=cCUa_P-RiDs4pW6cw51uYeoBMaMa9iycwiFkwqkIizc,419
-skbase/utils/dependencies/_dependencies.py,sha256=muUbqw4vmmn6YvkugIhlaqGKgW8pSermnhvn5DvahQs,20763
+skbase/utils/dependencies/_dependencies.py,sha256=7LE-juUaJ9--Pi2xBdZ5y3BA7eZDII1rkfgK6iyAwoQ,27779
 skbase/utils/dependencies/_import.py,sha256=PoaZE6WiCTp-vuvrkrM6EO2wWvX6owanQ0uESFhqLtQ,802
 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/dependencies/tests/test_check_dependencies.py,sha256=IBErD_ejAqE16Y9GL_frLOoHzZz0UgVZueHGbKch1Sk,6933
 skbase/utils/tests/__init__.py,sha256=YfvP5lpCrTC_6SIakU7jBBdqYyuqE07nZ56ZYKTs3f0,165
 skbase/utils/tests/test_check.py,sha256=rMxaQtKegaKZPGjocNB9ntMwMIAq5-7SmNZuFsWFGZE,754
-skbase/utils/tests/test_deep_equals.py,sha256=WdWpaUPi8m_kzP2IbQcPdfWmerEDVd-AaBuGiG_aPcE,3848
+skbase/utils/tests/test_deep_equals.py,sha256=VVsNAfiGC3GOG_9qtsrWR6Z4d6WwRy_HhE4n-Sv3Lgo,3868
 skbase/utils/tests/test_iter.py,sha256=XIJPZ3QjVR5szj5oNS9DBwum6WXRGHSAiC0O9MW4maY,4918
 skbase/utils/tests/test_nested_iter.py,sha256=lZF9jiU_6xw1dOo2QrrVF96Pw8ThutQuVlRspIgNy80,2230
 skbase/utils/tests/test_random_state.py,sha256=XW1KIFy2S-MQjlx4lUdP8K-w1N9eEUWa7PP_Yve7d78,3934
@@ -60,9 +62,8 @@ skbase/validate/_types.py,sha256=riVEVlj8ipErZX07OVbzv6zdGKssfegHyMr8XwaBm6M,121
 skbase/validate/tests/__init__.py,sha256=wunQBy6rajyrDymKvuFVajsBjj90VP5IFey5b6ZIRCk,70
 skbase/validate/tests/test_iterable_named_objects.py,sha256=NaEwdmtQJJy4GXMSh9ULOaR4ua7R11BcE6Khz5RKWUk,7438
 skbase/validate/tests/test_type_validations.py,sha256=oIysbDxRlbBMcCOrDMW6MM6VqhhMWJxNP6NO9Id9Q5g,14133
-scikit_base-0.12.0.dist-info/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
-scikit_base-0.12.0.dist-info/METADATA,sha256=4pzEkNaQD8FLpiTLpKs2CVQ-kBZyuUnsRP_9a1tDmZw,8487
-scikit_base-0.12.0.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-scikit_base-0.12.0.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
-scikit_base-0.12.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-scikit_base-0.12.0.dist-info/RECORD,,
+scikit_base-0.12.3.dist-info/METADATA,sha256=ZGSLbIzWsvGqx6ZL1X3uHow6xbIhC6LuWOMh2nPi0t4,8794
+scikit_base-0.12.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+scikit_base-0.12.3.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
+scikit_base-0.12.3.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+scikit_base-0.12.3.dist-info/RECORD,,

{scikit_base-0.12.0.dist-info → scikit_base-0.12.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (80.9.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.12.0"
+__version__: str = "0.12.3"

skbase/_nopytest_tests.py

@@ -7,7 +7,7 @@ from skbase.lookup import all_objects
 
 MODULES_TO_IGNORE = ("tests", "testing", "dependencies", "all")
 
-# all_objectscrawls all modules excepting pytest test files
+# all_objects crawls all modules excepting pytest test files
 # if it encounters an unisolated import, it will throw an exception
 results = all_objects(modules_to_ignore=MODULES_TO_IGNORE)
 

skbase/base/_base.py

@@ -1169,13 +1169,19 @@ class BaseObject(_FlagManager):
 class TagAliaserMixin:
     """Mixin class for tag aliasing and deprecation of old tags.
 
-    To deprecate tags, add the TagAliaserMixin to BaseObject or BaseEstimator.
-    alias_dict contains the deprecated tags, and supports removal and renaming.
-        For removal, add an entry "old_tag_name": ""
-        For renaming, add an entry "old_tag_name": "new_tag_name"
-    deprecate_dict contains the version number of renaming or removal.
-        the keys in deprecate_dict should be the same as in alias_dict.
-        values in deprecate_dict should be strings, the version of removal/renaming.
+    To deprecate tags, add the ``TagAliaserMixin`` to ``BaseObject``
+    or ``BaseEstimator``.
+
+    ``alias_dict`` contains the deprecated tags, and supports removal and renaming.
+
+    * For removal, add an entry ``"old_tag_name": ""``
+    * For renaming, add an entry ``"old_tag_name": "new_tag_name"``
+
+    ``deprecate_dict`` contains the version number of renaming or removal.
+
+    * The keys in ``deprecate_dict`` should be the same as in alias_dict.
+    * Values in ``deprecate_dict`` should be strings, the version of
+    removal/renaming, in PEP 440 format, e.g., ``"1.0.0"``.
 
     The class will ensure that new tags alias old tags and vice versa, during
     the deprecation period. Informative warnings will be raised whenever the
@@ -1195,6 +1201,9 @@ class TagAliaserMixin:
     # key = old tag; value = version in which tag will be removed, as string
     deprecate_dict = {"old_tag": "0.12.0", "tag_to_remove": "99.99.99"}
 
+    # package name used for deprecation warnings
+    _package_name = ""
+
     def __init__(self):
         """Construct TagAliaserMixin."""
         super(TagAliaserMixin, self).__init__()
@@ -1242,6 +1251,7 @@ class TagAliaserMixin:
             tags set by ``set_tags`` or ``clone_tags``.
         """
         collected_tags = super(TagAliaserMixin, cls).get_class_tags()
+        cls._deprecate_tag_warn(collected_tags)
         collected_tags = cls._complete_dict(collected_tags)
         return collected_tags
 
@@ -1322,6 +1332,7 @@ class TagAliaserMixin:
             and new tags from ``_tags_dynamic`` object attribute.
         """
         collected_tags = super(TagAliaserMixin, self).get_tags()
+        self._deprecate_tag_warn(collected_tags)
         collected_tags = self._complete_dict(collected_tags)
         return collected_tags
 
@@ -1452,14 +1463,19 @@ class TagAliaserMixin:
             if tag_name in cls.alias_dict.keys():
                 version = cls.deprecate_dict[tag_name]
                 new_tag = cls.alias_dict[tag_name]
-                msg = f"tag {tag_name!r} will be removed in sktime version {version}"
+                pkg_name = cls._package_name
+                if pkg_name != "":
+                    pkg_name = f"{pkg_name} "
+                msg = (
+                    f"tag {tag_name!r} will be removed in {pkg_name} version {version}"
+                )
                 if new_tag != "":
                     msg += (
                         f" and replaced by {new_tag!r}, please use {new_tag!r} instead"
                     )
                 else:
                     msg += ", please remove code that access or sets {tag_name!r}"
-                warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+                warnings.warn(msg, category=FutureWarning, stacklevel=2)
 
 
 class BaseEstimator(BaseObject):

skbase/base/_meta.py

@@ -360,6 +360,7 @@ class _MetaObjectMixin:
         cls_type=None,
         allow_dict=False,
         allow_mix=True,
+        allow_empty=False,
         clone=True,
     ):
         """Check that objects is a list of objects or sequence of named objects.
@@ -373,10 +374,14 @@ class _MetaObjectMixin:
             Name of checked attribute in error messages.
         cls_type : class or tuple of classes, default=BaseEstimator.
             class(es) that all objects are checked to be an instance of.
+        allow_dict : bool, default=False
+            Whether ``objs`` can be a dictionary mapping str names to objects.
         allow_mix : bool, default=True
-            Whether mix of objects and (str, objects) is allowed in `objs.`
+            Whether mix of objects and (str, objects) is allowed in ``objs``.
+        allow_empty : bool, default=False
+            Whether ``objs`` can be empty.
         clone : bool, default=True
-            Whether objects or named objects in `objs` are returned as clones
+            Whether objects or named objects in ``objs`` are returned as clones
             (True) or references (False).
 
         Returns
@@ -421,7 +426,7 @@ class _MetaObjectMixin:
 
         if (
             objs is None
-            or len(objs) == 0
+            or (not allow_empty and len(objs) == 0)
             or not (isinstance(objs, list) or (allow_dict and isinstance(objs, dict)))
         ):
             raise TypeError(msg)

skbase/lookup/_lookup.py

@@ -430,7 +430,7 @@ def _get_module_info(
         authors = ", ".join(authors)
     # Compile information on classes in the module
     module_classes: MutableMapping = {}  # of ClassInfo type
-    for name, klass in inspect.getmembers(module, inspect.isclass):
+    for name, klass in _get_members_uw(module, inspect.isclass):
         # Skip a class if non-public items should be excluded and it starts with "_"
         if (
             (exclude_non_public_items and klass.__name__.startswith("_"))
@@ -440,7 +440,9 @@ def _get_module_info(
         ):
             continue
         # Otherwise, store info about the class
-        if klass.__module__ == module.__name__ or name in designed_imports:
+        uw_klass = inspect.unwrap(klass)  # unwrap any decorators
+        klassname = uw_klass.__name__
+        if uw_klass.__module__ == module.__name__ or name in designed_imports:
             klass_authors = getattr(klass, "__author__", authors)
             if isinstance(klass_authors, (list, tuple)):
                 klass_authors = ", ".join(klass_authors)
@@ -453,9 +455,9 @@ def _get_module_info(
                 )
             module_classes[name] = {
                 "klass": klass,
-                "name": klass.__name__,
+                "name": klassname,
                 "description": (
-                    "" if klass.__doc__ is None else klass.__doc__.split("\n")[0]
+                    "" if uw_klass.__doc__ is None else uw_klass.__doc__.split("\n")[0]
                 ),
                 "tags": (
                     klass.get_class_tags() if hasattr(klass, "get_class_tags") else None
@@ -464,23 +466,25 @@ def _get_module_info(
                 "is_base_class": klass in package_base_classes,
                 "is_base_object": issubclass(klass, BaseObject),
                 "authors": klass_authors,
-                "module_name": module.__name__,
+                "module_name": uw_klass.__module__,
             }
 
     module_functions: MutableMapping = {}  # of FunctionInfo type
-    for name, func in inspect.getmembers(module, inspect.isfunction):
-        if func.__module__ == module.__name__ or name in designed_imports:
+    for name, func in _get_members_uw(module, inspect.isfunction):
+        uw_func = inspect.unwrap(func)  # unwrap any decorators
+        funcname = uw_func.__name__
+        if uw_func.__module__ == module.__name__ or name in designed_imports:
             # Skip a class if non-public items should be excluded and it starts with "_"
-            if exclude_non_public_items and func.__name__.startswith("_"):
+            if exclude_non_public_items and funcname.startswith("_"):
                 continue
             # Otherwise, store info about the class
             module_functions[name] = {
                 "func": func,
-                "name": func.__name__,
+                "name": funcname,
                 "description": (
-                    "" if func.__doc__ is None else func.__doc__.split("\n")[0]
+                    "" if uw_func.__doc__ is None else uw_func.__doc__.split("\n")[0]
                 ),
-                "module_name": module.__name__,
+                "module_name": uw_func.__module__,
             }
 
     # Combine all the information on the module together
@@ -505,6 +509,22 @@ def _get_module_info(
     return module_info
 
 
+def _get_members_uw(module, predicate=None):
+    """Get members of a module. Same as inspect.getmembers, but robust to decorators."""
+    for name, obj in vars(module).items():
+        if not callable(obj):
+            continue
+
+        try:
+            unwrapped = inspect.unwrap(obj)
+        except ValueError:
+            continue  # skip circular wrappers or broken decorators
+
+        if predicate is not None and not predicate(unwrapped):
+            continue
+        yield name, obj
+
+
 def get_package_metadata(
     package_name: str,
     path: Optional[str] = None,
@@ -876,7 +896,7 @@ def all_objects(
 
     # remove names if return_names=False
     if not return_names:
-        all_estimators = [estimator for (name, estimator) in all_estimators]
+        all_estimators = [estimator for (_, estimator) in all_estimators]
         columns = ["object"]
     else:
         columns = ["name", "object"]

skbase/testing/test_all_objects.py

@@ -226,7 +226,7 @@ class BaseFixtureGenerator:
     @pytest.fixture(scope="function")
     def object_instance(self, request):
         """object_instance fixture definition for indirect use."""
-        # esetimator_instance is cloned at the start of every test
+        # estimator_instance is cloned at the start of every test
         return request.param.clone()
 
 

skbase/tests/conftest.py

@@ -56,6 +56,7 @@ SKBASE_MODULES = (
     "skbase.utils.dependencies",
     "skbase.utils.dependencies._dependencies",
     "skbase.utils.dependencies._import",
+    "skbase.utils.doctest_run",
     "skbase.utils.random_state",
     "skbase.utils.stderr_mute",
     "skbase.utils.stdout_mute",
@@ -83,6 +84,7 @@ SKBASE_PUBLIC_MODULES = (
     "skbase.utils",
     "skbase.utils.deep_equals",
     "skbase.utils.dependencies",
+    "skbase.utils.doctest_run",
     "skbase.utils.random_state",
     "skbase.utils.stderr_mute",
     "skbase.utils.stdout_mute",
@@ -188,6 +190,7 @@ SKBASE_PUBLIC_FUNCTIONS_BY_MODULE = {
     "skbase.utils._utils": ("subset_dict_keys",),
     "skbase.utils.deep_equals": ("deep_equals",),
     "skbase.utils.deep_equals._deep_equals": ("deep_equals", "deep_equals_custom"),
+    "skbase.utils.doctest_run": ("run_doctest",),
     "skbase.utils.random_state": (
         "check_random_state",
         "sample_dependent_seed",
@@ -199,7 +202,11 @@ SKBASE_FUNCTIONS_BY_MODULE = SKBASE_PUBLIC_FUNCTIONS_BY_MODULE.copy()
 SKBASE_FUNCTIONS_BY_MODULE.update(
     {
         "skbase.base._clone_base": {"_check_clone", "_clone"},
-        "skbase.base._clone_plugins": ("_default_clone",),
+        "skbase.base._clone_plugins": (
+            "_default_clone",
+            "_get_sklearn_clone",
+            "_is_sklearn_present",
+        ),
         "skbase.base._pretty_printing._object_html_repr": (
             "_get_visual_block",
             "_object_html_repr",
@@ -208,20 +215,22 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
         ),
         "skbase.base._pretty_printing._pprint": ("_changed_params", "_safe_repr"),
         "skbase.lookup._lookup": (
+            "all_objects",
+            "get_package_metadata",
+            "_check_object_types",
+            "_coerce_to_tuple",
             "_determine_module_path",
+            "_filter_by_tags",
+            "_filter_by_class",
+            "_get_members_uw",
+            "_get_module_info",
             "_get_return_tags",
+            "_import_module",
             "_is_ignored_module",
-            "all_objects",
             "_is_non_public_module",
-            "get_package_metadata",
             "_make_dataframe",
             "_walk",
-            "_filter_by_tags",
-            "_filter_by_class",
-            "_import_module",
-            "_check_object_types",
-            "_get_module_info",
-            "_coerce_to_tuple",
+            "_walk_and_retrieve_all_objs",
         ),
         "skbase.testing.utils.inspect": ("_get_args",),
         "skbase.utils._check": ("_is_scalar_nan",),
@@ -265,13 +274,15 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
             "deep_equals_custom",
         ),
         "skbase.utils.dependencies._dependencies": (
-            "_check_soft_dependencies",
-            "_check_python_version",
             "_check_env_marker",
             "_check_estimator_deps",
+            "_check_python_version",
+            "_check_soft_dependencies",
             "_get_pkg_version",
             "_get_installed_packages",
+            "_get_installed_packages_private",
             "_normalize_requirement",
+            "_normalize_version",
             "_raise_at_severity",
         ),
         "skbase.utils.random_state": (

skbase/tests/test_base.py

@@ -51,10 +51,7 @@ __all__ = [
     "test_clone",
     "test_clone_2",
     "test_clone_raises_error_for_nonconforming_objects",
-    "test_clone_param_is_none",
-    "test_clone_empty_array",
-    "test_clone_sparse_matrix",
-    "test_clone_nan",
+    "test_clone_none_and_empty_array_nan_sparse_matrix",
     "test_clone_estimator_types",
     "test_clone_class_rather_than_instance_raises_error",
     "test_clone_sklearn_composite",
@@ -1025,75 +1022,30 @@ def test_nested_config_after_clone_tags(clone_config):
     not _check_soft_dependencies("scikit-learn", severity="none"),
     reason="skip test if sklearn is not available",
 )  # sklearn is part of the dev dependency set, test should be executed with that
-def test_clone_param_is_none(fixture_class_parent: Type[Parent]):
-    """Test clone with keyword parameter set to None."""
-    from sklearn.base import clone
-
-    base_obj = fixture_class_parent(c=None)
-    new_base_obj = clone(base_obj)
-    new_base_obj2 = base_obj.clone()
-    assert base_obj.c is new_base_obj.c
-    assert base_obj.c is new_base_obj2.c
-
-
-@pytest.mark.skipif(
-    not _check_soft_dependencies("scikit-learn", severity="none"),
-    reason="skip test if sklearn is not available",
-)  # sklearn is part of the dev dependency set, test should be executed with that
-def test_clone_empty_array(fixture_class_parent: Type[Parent]):
-    """Test clone with keyword parameter is scipy sparse matrix.
-
-    This test is based on scikit-learn regression test to make sure clone
-    works with default parameter set to scipy sparse matrix.
-    """
-    from sklearn.base import clone
-
-    # Regression test for cloning estimators with empty arrays
-    base_obj = fixture_class_parent(c=np.array([]))
-    new_base_obj = clone(base_obj)
-    new_base_obj2 = base_obj.clone()
-    np.testing.assert_array_equal(base_obj.c, new_base_obj.c)
-    np.testing.assert_array_equal(base_obj.c, new_base_obj2.c)
-
-
-@pytest.mark.skipif(
-    not _check_soft_dependencies("scikit-learn", severity="none"),
-    reason="skip test if sklearn is not available",
-)  # sklearn is part of the dev dependency set, test should be executed with that
-def test_clone_sparse_matrix(fixture_class_parent: Type[Parent]):
-    """Test clone with keyword parameter is scipy sparse matrix.
-
-    This test is based on scikit-learn regression test to make sure clone
-    works with default parameter set to scipy sparse matrix.
-    """
-    from sklearn.base import clone
-
-    base_obj = fixture_class_parent(c=sp.csr_matrix(np.array([[0]])))
-    new_base_obj = clone(base_obj)
-    new_base_obj2 = base_obj.clone()
-    np.testing.assert_array_equal(base_obj.c, new_base_obj.c)
-    np.testing.assert_array_equal(base_obj.c, new_base_obj2.c)
-
-
-@pytest.mark.skipif(
-    not _check_soft_dependencies("scikit-learn", severity="none"),
-    reason="skip test if sklearn is not available",
-)  # sklearn is part of the dev dependency set, test should be executed with that
-def test_clone_nan(fixture_class_parent: Type[Parent]):
-    """Test clone with keyword parameter is np.nan.
-
-    This test is based on scikit-learn regression test to make sure clone
-    works with default parameter set to np.nan.
-    """
+@pytest.mark.parametrize(
+    "c_value",
+    [
+        None,
+        np.array([]),
+        sp.csr_matrix(np.array([[0]])),
+        np.nan,
+    ],
+)
+def test_clone_none_and_empty_array_nan_sparse_matrix(
+    fixture_class_parent: Type[Parent], c_value
+):
     from sklearn.base import clone
 
-    # Regression test for cloning estimators with default parameter as np.nan
-    base_obj = fixture_class_parent(c=np.nan)
+    base_obj = fixture_class_parent(c=c_value)
     new_base_obj = clone(base_obj)
     new_base_obj2 = base_obj.clone()
 
-    assert base_obj.c is new_base_obj.c
-    assert base_obj.c is new_base_obj2.c
+    if isinstance(base_obj.c, (np.ndarray, type(sp.csr_matrix(np.array([[0]]))))):
+        np.testing.assert_array_equal(base_obj.c, new_base_obj.c)
+        np.testing.assert_array_equal(base_obj.c, new_base_obj2.c)
+    else:
+        assert base_obj.c is new_base_obj.c
+        assert base_obj.c is new_base_obj2.c
 
 
 def test_clone_estimator_types(fixture_class_parent: Type[Parent]):

skbase/utils/deep_equals/_deep_equals.py

@@ -267,6 +267,7 @@ def _pandas_equals(x, y, return_msg=False, deep_equals=None):
                 return ret(
                     False, f".dtypes, x.dtypes = {x.dtypes} != y.dtypes = {y.dtypes}"
                 )
+        return ret(x.equals(y), "index.equals, x = {} != y = {}", [x, y])
     else:
         raise RuntimeError(
             f"Unexpected type of pandas object in _pandas_equals: type(x)={type(x)},"

skbase/utils/dependencies/_dependencies.py

@@ -13,27 +13,40 @@ from packaging.version import InvalidVersion, Version
 
 def _check_soft_dependencies(
     *packages,
-    package_import_alias="deprecated",
     severity="error",
     obj=None,
     msg=None,
+    normalize_reqs=True,
+    case_sensitive=False,
 ):
     """Check if required soft dependencies are installed and raise error or warning.
 
     Parameters
     ----------
-    packages : str or list/tuple of str, or length-1-tuple containing list/tuple of str
+    packages : str or list/tuple of str nested up to two levels
         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"``.
         arg can be str, kwargs tuple, or tuple/list of str, following calls are valid:
-        ``_check_soft_dependencies("package1")``
+
+        * ``_check_soft_dependencies("package1")``
+        * ``_check_soft_dependencies("package1", "package2")``
+        * ``_check_soft_dependencies(("package1", "package2"))``
+        * ``_check_soft_dependencies(["package1", "package2"])``
+        * ``_check_soft_dependencies(("package1", "package2"), "package3")``
+        * ``_check_soft_dependencies(["package1", "package2"], "package3")``
+        * ``_check_soft_dependencies((["package1", "package2"], "package3"))``
+
+        The first level is interpreted as conjunction, the second level as disjunction,
+        that is, conjunction = "and", disjunction = "or".
+
+        In case of more than a single arg, an outer level of "and" (brackets)
+        is added, that is,
+
         ``_check_soft_dependencies("package1", "package2")``
-        ``_check_soft_dependencies(("package1", "package2"))``
-        ``_check_soft_dependencies(["package1", "package2"])``
 
-    package_import_alias : ignored, present only for backwards compatibility
+        is the same as ``_check_soft_dependencies(("package1", "package2"))``
 
     severity : str, "error" (default), "warning", "none"
         whether the check should raise an error, a warning, or nothing
@@ -53,6 +66,29 @@ def _check_soft_dependencies(
     msg : str, or None, default=None
         if str, will override the error message or warning shown with msg
 
+    normalize_reqs : bool, default=True
+        whether to normalize the requirement strings before checking them,
+        by removing build metadata from versions.
+        If set True, pre, post, and dev versions are removed from all version strings.
+
+        Example if True:
+        requirement "my_pkg==2.3.4.post1" will be normalized to "my_pkg==2.3.4";
+        an actual version "my_pkg==2.3.4.post1" will be considered compatible with
+        "my_pkg==2.3.4". If False, the this situation would raise an error.
+
+    case_sensitive : bool, default=False
+        whether package names are case sensitive or not.
+        pypi package names are case sensitive, but pypi disallows
+        multiple package names that differ only in case.
+        Hence there is at most a single correct case for a given package name,
+        and a user will most likely intend to refer to the correct package,
+        even when providing an incorrect case for the pypi name.
+
+        * If set to True, package names are case sensitive, and the check will fail
+          if the correct case is not provided, e.g., ``mapie`` instead of ``MAPIE``.
+        * If set to False, package names are case insensitive, and the check will pass
+          for all case combinations, e.g., ``mapie``, ``MAPIE``, ``Mapie``, ``mApIe``.
+
     Raises
     ------
     InvalidRequirement
@@ -68,10 +104,26 @@ def _check_soft_dependencies(
     """
     if len(packages) == 1 and isinstance(packages[0], (tuple, list)):
         packages = packages[0]
-    if not all(isinstance(x, str) for x in packages):
+
+    def _is_str_or_tuple_of_strs(obj):
+        """Check that obj is a str or list/tuple nesting up to 1st level of str.
+
+        Valid examples:
+
+        * "pandas"
+        * ("pandas", "scikit-learn")
+        * ["pandas", "scikit-learn"]
+        """
+        if isinstance(obj, (tuple, list)):
+            return all(isinstance(x, str) for x in obj)
+
+        return isinstance(obj, str)
+
+    if not all(_is_str_or_tuple_of_strs(x) for x in packages):
         raise TypeError(
-            "packages argument of _check_soft_dependencies must be str or tuple of "
-            f"str, but found packages argument of type {type(packages)}"
+            "packages argument of _check_soft_dependencies must be str or tuple/list "
+            "of str or of tuple/list of str, "
+            f"but found packages argument of type {type(packages)}"
         )
 
     if obj is None:
@@ -95,10 +147,24 @@ def _check_soft_dependencies(
             f"or None, but found msg of type {type(msg)}"
         )
 
-    for package in packages:
+    def _get_pkg_version_and_req(package):
+        """Get package version and requirement object from package string.
+
+        Parameters
+        ----------
+        package : str
+
+        Returns
+        -------
+        package_version_req: SpecifierSet
+            version requirement object from package string
+        pkg_env_version: Version
+            version object of package in python environment
+        """
         try:
             req = Requirement(package)
-            req = _normalize_requirement(req)
+            if normalize_reqs:
+                req = _normalize_requirement(req)
         except InvalidRequirement:
             msg_version = (
                 f"wrong format for package requirement string, "
@@ -111,25 +177,70 @@ def _check_soft_dependencies(
         package_name = req.name
         package_version_req = req.specifier
 
-        pkg_env_version = _get_pkg_version(package_name)
+        pkg_env_version = _get_pkg_version(package_name, case_sensitive=case_sensitive)
+        if normalize_reqs:
+            pkg_env_version = _normalize_version(pkg_env_version)
+
+        return package_version_req, pkg_env_version
+
+    # each element of the list "package" must be satisfied
+    for package_req in packages:
+        # for elemehts, two cases can happen:
+        #
+        # 1. package is a string, e.g., "pandas". Then this must be present.
+        # 2. package is a tuple or list, e.g., ("pandas", "scikit-learn").
+        #    Then at least one of these must be present.
+        if not isinstance(package_req, (tuple, list)):
+            package_req = (package_req,)
+        else:
+            package_req = tuple(package_req)
+
+        def _is_version_req_satisfied(pkg_env_version, pkg_version_req):
+            if pkg_env_version is None:
+                return False
+            if pkg_version_req != SpecifierSet(""):
+                return pkg_env_version in pkg_version_req
+            else:
+                return True
+
+        pkg_version_reqs = []
+        pkg_env_versions = []
+        nontrivital_bound = []
+        req_sat = []
+
+        for package in package_req:
+            pkg_version_req, pkg_env_version = _get_pkg_version_and_req(package)
+            pkg_version_reqs.append(pkg_version_req)
+            pkg_env_versions.append(pkg_env_version)
+            nontrivital_bound.append(pkg_version_req != SpecifierSet(""))
+            req_sat.append(_is_version_req_satisfied(pkg_env_version, pkg_version_req))
+
+        package_req_strs = [f"{x!r}" for x in package_req]
+        # example: ["'scipy<1.7.0'"] or ["'scipy<1.7.0'", "'numpy'"]
+
+        package_str_q = " or ".join(package_req_strs)
+        # example: "'scipy<1.7.0'"" or "'scipy<1.7.0' or 'numpy'""
+
+        package_str = " or ".join(f"`pip install {r}`" for r in package_req)
+        # example: "pip install scipy<1.7.0 or pip install numpy"
 
         # if package not present, make the user aware of installation reqs
-        if pkg_env_version is None:
+        if all(pkg_env_version is None for pkg_env_version in pkg_env_versions):
             if obj is None and 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"{class_name} requires package {package_str_q} to be present "
+                    f"in the python environment, but {package_str_q} was not found. "
                 )
             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"{class_name} requires package {package_str_q} to be present "
+                    f"in the python environment, but {package_str_q} was not found. "
+                    f"{package_str_q} 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. "
+                f"To install the requirement {package_str_q}, please run: "
+                f"{package_str} "
             )
             # if msg is not None, none of the above is executed,
             # so if msg is passed it overrides the default messages
@@ -138,22 +249,28 @@ def _check_soft_dependencies(
             return False
 
         # now we check compatibility with the version specifier if non-empty
-        if package_version_req != SpecifierSet(""):
+        if not any(req_sat):
+            reqs_not_satisfied = [
+                x for x in zip(package_req, pkg_env_versions, req_sat) if x[2] is False
+            ]
+            actual_vers = [f"{x[0]} {x[1]}" for x in reqs_not_satisfied]
+            pkg_env_version_str = ", ".join(actual_vers)
+
             msg = (
-                f"{class_name} requires package {package!r} to be present "
-                f"in the python environment, with version {package_version_req}, "
-                f"but incompatible version {pkg_env_version} was found. "
+                f"{class_name} requires package {package_str_q} to be present "
+                f"in the python environment, with versions as specified, "
+                f"but incompatible version {pkg_env_version_str} was found. "
             )
             if obj is not None:
                 msg = msg + (
-                    f"{package!r}, with version {package_version_req},"
-                    f"is a dependency of {class_name} and required to construct it. "
+                    f"This version requirement is not one by sktime, but specific "
+                    f"to the module, class or object with name {obj}."
                 )
 
             # raise error/warning or return False if version is incompatible
-            if pkg_env_version not in package_version_req:
-                _raise_at_severity(msg, severity, caller="_check_soft_dependencies")
-                return False
+
+            _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
@@ -161,7 +278,7 @@ def _check_soft_dependencies(
 
 
 @lru_cache
-def _get_installed_packages_private():
+def _get_installed_packages_private(lowercase=False):
     """Get a dictionary of installed packages and their versions.
 
     Same as _get_installed_packages, but internal to avoid mutating the lru_cache
@@ -179,22 +296,30 @@ def _get_installed_packages_private():
     # such as in deployment environments like databricks.
     # the "version" contract ensures we always get the version that corresponds
     # to the importable distribution, i.e., the top one in the sys.path.
+    if lowercase:
+        package_versions = {k.lower(): v for k, v in package_versions.items()}
     return package_versions
 
 
-def _get_installed_packages():
+def _get_installed_packages(lowercase=False):
     """Get a dictionary of installed packages and their versions.
 
+    Parameters
+    ----------
+    lowercase : bool, default=False
+        whether to lowercase the package names in the returned dictionary.
+
     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()
+    return _get_installed_packages_private(lowercase=lowercase).copy()
 
 
-def _get_pkg_version(package_name):
+@lru_cache
+def _get_pkg_version(package_name, case_sensitive=False):
     """Check whether package is available in environment, and return its version if yes.
 
     Returns ``Version`` object from ``lru_cache``, this should not be mutated.
@@ -207,12 +332,27 @@ def _get_pkg_version(package_name):
         This is the pypi package name, not the import name, e.g.,
         ``scikit-learn``, not ``sklearn``.
 
+    case_sensitive : bool, default=False
+        whether package names are case sensitive or not.
+        pypi package names are case sensitive, but pypi disallows
+        multiple package names that differ only in case.
+        Hence there is at most a single correct case for a given package name,
+        and a user will most likely intend to refer to the correct package,
+        even when providing an incorrect case for the pypi name.
+
+        * If set to True, package names are case sensitive, and None is returned
+          if the correct case is not provided, e.g., ``mapie`` instead of ``MAPIE``.
+        * If set to False, package names are case insensitive, and a version is returned
+          for all case combinations, e.g., ``mapie``, ``MAPIE``, ``Mapie``, ``mApIe``.
+
     Returns
     -------
     None, if package is not found in python environment.
     ``importlib`` ``Version`` of package, if present in environment.
     """
-    pkgs = _get_installed_packages()
+    pkgs = _get_installed_packages(lowercase=not case_sensitive)
+    if not case_sensitive:
+        package_name = package_name.lower()
     pkg_vers_str = pkgs.get(package_name, None)
     if pkg_vers_str is None:
         return None
@@ -223,7 +363,9 @@ def _get_pkg_version(package_name):
     return pkg_env_version
 
 
-def _check_python_version(obj, package=None, msg=None, severity="error"):
+def _check_python_version(
+    obj, package=None, msg=None, severity="error", prereleases=True
+):
     """Check if system python version is compatible with requirements of obj.
 
     Parameters
@@ -246,6 +388,13 @@ def _check_python_version(obj, package=None, msg=None, severity="error"):
         * "none" - does not raise exception or warning
           function returns False if one of packages is not installed, otherwise True
 
+    prereleases: str, default = True
+        Whether prerelease versions are considered compatible.
+        If True, allows prerelease versions to be considered compatible.
+        If False, always considers prerelease versions as incompatible, i.e., always
+        raises error, warning, or returns False, if the system python version is a
+        prerelease.
+
     Returns
     -------
     compatible : bool, whether obj is compatible with system python version
@@ -263,7 +412,7 @@ def _check_python_version(obj, package=None, msg=None, severity="error"):
         return True
 
     try:
-        est_specifier = SpecifierSet(est_specifier_tag)
+        est_specifier = SpecifierSet(est_specifier_tag, prereleases=prereleases)
     except InvalidSpecifier:
         msg_version = (
             f"wrong format for python_version tag, "
@@ -290,6 +439,9 @@ def _check_python_version(obj, package=None, msg=None, severity="error"):
             f" but system python version is {sys.version}."
         )
 
+        if "rc" in sys_version:
+            msg += " This is due to the release candidate status of your system Python."
+
         if package is not None:
             msg += (
                 f" This is due to python version requirements of the {package} package."
@@ -309,7 +461,7 @@ def _check_env_marker(obj, package=None, msg=None, severity="error"):
     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
+        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
@@ -427,13 +579,10 @@ def _check_estimator_deps(obj, msg=None, severity="error"):
     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)
     if pkg_deps is not None and not isinstance(pkg_deps, list):
         pkg_deps = [pkg_deps]
     if pkg_deps is not None:
-        pkg_deps_ok = _check_soft_dependencies(
-            *pkg_deps, severity=severity, obj=obj, package_import_alias=pck_alias
-        )
+        pkg_deps_ok = _check_soft_dependencies(*pkg_deps, severity=severity, obj=obj)
         compatible = compatible and pkg_deps_ok
 
     return compatible
@@ -456,12 +605,9 @@ def _normalize_requirement(req):
     # 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_version = _normalize_version(spec.version)
+        normalized_spec = Specifier(f"{spec.operator}{normalized_version}")
         normalized_specs.append(normalized_spec)
 
     # Reconstruct the specifier set
@@ -473,6 +619,29 @@ def _normalize_requirement(req):
     return normalized_req
 
 
+def _normalize_version(version):
+    """Normalize version string by removing build metadata.
+
+    Parameters
+    ----------
+    version : packaging.version.Version
+        version object to normalize, e.g., Version("1.2.3+foobar")
+
+    Returns
+    -------
+    normalized_version : packaging.version.Version
+        normalized version object with build metadata removed, e.g., Version("1.2.3")
+    """
+    if version is None:
+        return None
+    if not isinstance(version, Version):
+        version_obj = Version(version)
+    else:
+        version_obj = version
+    normalized_version = f"{version_obj.major}.{version_obj.minor}.{version_obj.micro}"
+    return normalized_version
+
+
 def _raise_at_severity(
     msg,
     severity,

skbase/utils/dependencies/tests/test_check_dependencies.py

@@ -1,9 +1,14 @@
 # -*- coding: utf-8 -*-
 """Tests for _check_soft_dependencies utility."""
+from unittest.mock import patch
+
 import pytest
 from packaging.requirements import InvalidRequirement
 
-from skbase.utils.dependencies._dependencies import _check_soft_dependencies
+from skbase.utils.dependencies import (
+    _check_python_version,
+    _check_soft_dependencies,
+)
 
 
 def test_check_soft_deps():
@@ -47,3 +52,121 @@ def test_check_soft_deps():
         assert _check_soft_dependencies(
             ("pytest", "!!numpy<~><>0.1.0"), severity="none"
         )
+
+
+def test_check_soft_dependencies_nested():
+    """Test check_soft_dependencies with ."""
+    ALWAYS_INSTALLED = "pytest"  # noqa: N806
+    ALWAYS_INSTALLED2 = "numpy"  # noqa: N806
+    ALWAYS_INSTALLED_W_V = "pytest>=0.5.0"  # noqa: N806
+    ALWAYS_INSTALLED_W_V2 = "numpy>=0.1.0"  # noqa: N806
+    NEVER_INSTALLED = "nonexistent__package_foo_bar"  # noqa: N806
+    NEVER_INSTALLED_W_V = "pytest<0.1.0"  # noqa: N806
+
+    # Test that the function does not raise an error when all dependencies are installed
+    _check_soft_dependencies(ALWAYS_INSTALLED)
+    _check_soft_dependencies(ALWAYS_INSTALLED, ALWAYS_INSTALLED2)
+    _check_soft_dependencies(ALWAYS_INSTALLED_W_V)
+    _check_soft_dependencies(ALWAYS_INSTALLED_W_V, ALWAYS_INSTALLED_W_V2)
+    _check_soft_dependencies(ALWAYS_INSTALLED, ALWAYS_INSTALLED2, ALWAYS_INSTALLED_W_V2)
+    _check_soft_dependencies([ALWAYS_INSTALLED, ALWAYS_INSTALLED2])
+
+    # Test that error is raised when a dependency is not installed
+    with pytest.raises(ModuleNotFoundError):
+        _check_soft_dependencies(NEVER_INSTALLED)
+    with pytest.raises(ModuleNotFoundError):
+        _check_soft_dependencies(NEVER_INSTALLED, ALWAYS_INSTALLED)
+    with pytest.raises(ModuleNotFoundError):
+        _check_soft_dependencies([ALWAYS_INSTALLED, NEVER_INSTALLED])
+    with pytest.raises(ModuleNotFoundError):
+        _check_soft_dependencies(ALWAYS_INSTALLED, NEVER_INSTALLED_W_V)
+    with pytest.raises(ModuleNotFoundError):
+        _check_soft_dependencies([ALWAYS_INSTALLED, NEVER_INSTALLED_W_V])
+
+    # disjunction cases, "or" - positive cases
+    _check_soft_dependencies([[ALWAYS_INSTALLED, NEVER_INSTALLED]])
+    _check_soft_dependencies(
+        [
+            [ALWAYS_INSTALLED, NEVER_INSTALLED],
+            [ALWAYS_INSTALLED_W_V, NEVER_INSTALLED_W_V],
+            ALWAYS_INSTALLED2,
+        ]
+    )
+
+    # disjunction cases, "or" - negative cases
+    with pytest.raises(ModuleNotFoundError):
+        _check_soft_dependencies([[NEVER_INSTALLED, NEVER_INSTALLED_W_V]])
+    with pytest.raises(ModuleNotFoundError):
+        _check_soft_dependencies(
+            [
+                [NEVER_INSTALLED, NEVER_INSTALLED_W_V],
+                [ALWAYS_INSTALLED, NEVER_INSTALLED],
+                ALWAYS_INSTALLED2,
+            ]
+        )
+    with pytest.raises(ModuleNotFoundError):
+        _check_soft_dependencies(
+            [
+                ALWAYS_INSTALLED2,
+                [ALWAYS_INSTALLED, NEVER_INSTALLED],
+                NEVER_INSTALLED_W_V,
+            ]
+        )
+    with pytest.raises(ModuleNotFoundError):
+        _check_soft_dependencies(
+            [
+                [ALWAYS_INSTALLED, ALWAYS_INSTALLED2],
+                NEVER_INSTALLED,
+                ALWAYS_INSTALLED2,
+            ]
+        )
+
+
+@patch("skbase.utils.dependencies._dependencies.sys")
+@pytest.mark.parametrize(
+    "mock_release_version, prereleases, expect_exception",
+    [
+        (True, True, False),
+        (True, False, True),
+        (False, False, False),
+        (False, True, False),
+    ],
+)
+def test_check_python_version(
+    mock_sys, mock_release_version, prereleases, expect_exception
+):
+    from skbase.base import BaseObject
+
+    if mock_release_version:
+        mock_sys.version = "3.8.1rc"
+    else:
+        mock_sys.version = "3.8.1"
+
+    class DummyObjectClass(BaseObject):
+        _tags = {
+            "python_version": ">=3.7.1",  # PEP 440 version specifier, e.g., ">=3.7"
+            "python_dependencies": None,  # PEP 440 dependency strs, e.g., "pandas>=1.0"
+            "env_marker": None,  # PEP 508 environment marker, e.g., "os_name=='posix'"
+        }
+        """Define dummy class to test set_tags."""
+
+    dummy_object_instance = DummyObjectClass()
+
+    try:
+        _check_python_version(dummy_object_instance, prereleases=prereleases)
+    except ModuleNotFoundError as exception:
+        expected_msg = (
+            f"{type(dummy_object_instance).__name__} requires python version "
+            f"to be {dummy_object_instance.get_tags()['python_version']}, "
+            f"but system python version is {mock_sys.version}. "
+            "This is due to the release candidate status of your system Python."
+        )
+
+        if not expect_exception or exception.msg != expected_msg:
+            # Throw Error since exception is not expected or has not the correct message
+            raise AssertionError(
+                "ModuleNotFoundError should be NOT raised by:",
+                f"\n\t - mock_release_version: {mock_release_version},",
+                f"\n\t - prereleases: {prereleases},",
+                f"\nERROR MESSAGE: {exception.msg}",
+            ) from exception

skbase/utils/doctest_run.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""Doctest utilities."""
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+
+import contextlib
+import doctest
+import io
+
+
+def run_doctest(
+    f,
+    verbose=False,
+    name=None,
+    compileflags=None,
+    optionflags=doctest.ELLIPSIS,
+    raise_on_error=True,
+):
+    """Run doctests for a given function or class, and return or raise.
+
+    Parameters
+    ----------
+    f : callable
+        Function or class to run doctests for.
+    verbose : bool, optional (default=False)
+        If True, print the results of the doctests.
+    name : str, optional (default=f.__name__, if available, otherwise "NoName")
+        Name of the function or class.
+    compileflags : int, optional (default=None)
+        Flags to pass to the Python parser.
+    optionflags : int, optional (default=doctest.ELLIPSIS)
+        Flags to control the behaviour of the doctest.
+    raise_on_error : bool, optional (default=True)
+        If True, raise an exception if the doctests fail.
+
+    Returns
+    -------
+    doctest_output : str
+        Output of the doctests.
+
+    Raises
+    ------
+    RuntimeError
+        If raise_on_error=True and the doctests fail.
+    """
+    doctest_output_io = io.StringIO()
+    with contextlib.redirect_stdout(doctest_output_io):
+        doctest.run_docstring_examples(
+            f=f,
+            globs=globals(),
+            verbose=verbose,
+            name=name,
+            compileflags=compileflags,
+            optionflags=optionflags,
+        )
+    doctest_output = doctest_output_io.getvalue()
+
+    if name is None:
+        name = f.__name__ if hasattr(f, "__name__") else "NoName"
+
+    if raise_on_error and len(doctest_output) > 0:
+        raise RuntimeError(
+            f"Docstring examples failed doctests "
+            f"for {name}, doctest output: {doctest_output}"
+        )
+    return doctest_output

skbase/utils/tests/test_deep_equals.py

@@ -12,7 +12,7 @@ EXAMPLES = [
     42,
     [],
     ((((())))),
-    [([([([()])])])],
+    [[[[()]]]],
     3.5,
     4.2,
 ]
@@ -56,6 +56,7 @@ if _check_soft_dependencies("pandas", severity="none"):
         pd.Index([1, 2, 3]),
         pd.Index([2, 3, 4]),
         pd.Index([2, 3, 4, 6]),
+        pd.Index([None]),
     ]
 
     # nested DataFrame example