scikit-base 0.11.0__py3-none-any.whl → 0.12.2__py3-none-any.whl

{scikit_base-0.11.0.dist-info → scikit_base-0.12.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: scikit-base
-Version: 0.11.0
+Version: 0.12.2
 Summary: Base classes for sklearn-like parametric objects
 Author-email: sktime developers <sktime.toolbox@gmail.com>
 Maintainer: Franz Király
@@ -50,37 +50,22 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: <3.14,>=3.8
+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<5.0.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,<9.0.0; extra == "docs"
-Requires-Dist: tabulate; extra == "docs"
 Provides-Extra: linters
 Requires-Dist: mypy; extra == "linters"
 Requires-Dist: isort; extra == "linters"
@@ -96,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"
@@ -105,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>
 
@@ -115,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.11.0 is now available. Check out our
+:rocket: Version 0.12.2 is now available. Check out our
 [release notes](https://skbase.readthedocs.io/en/latest/changelog.html).
 
 | Overview | |
@@ -141,7 +141,7 @@ For trouble shooting or more information, see our
 [detailed installation instructions](https://skbase.readthedocs.io/en/latest/user_documentation/installation.html).
 
 - **Operating system**: macOS X · Linux · Windows 8.1 or higher
-- **Python version**: Python 3.8, 3.9, 3.10, 3.11 and 3.12
+- **Python version**: Python 3.9, 3.10, 3.11, 3.12, and 3.13
 - **Package managers**: [pip]
 
 [pip]: https://pip.pypa.io/en/stable/
@@ -161,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.11.0.dist-info → scikit_base-0.12.2.dist-info}/RECORD

@@ -1,10 +1,13 @@
 docs/source/conf.py,sha256=kFc-4qkb0ZGD5cDej5KPJhMePp9kpVu6ZqFoF0fgovg,9951
-skbase/__init__.py,sha256=3ZfMbj4QCdGwbCtma3Y0qaEtFcDdYFMtXBFOqZRIJY8,346
+scikit_base-0.12.2.dist-info/licenses/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
+skbase/__init__.py,sha256=5SckxWhIw301-BYxKlAns_hbBTHaoKcxx7u8_3OVml0,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=T4Cy3Fu3q3GARVImbwNZCCrObAreWB2u5icllcDp0E4,69090
-skbase/base/_meta.py,sha256=VY6_R2tE885j-GTDuzLFyho5i382jOni5lkR_ykPZqo,38815
+skbase/base/_base.py,sha256=4U87g1P7MFSvd5_6uNZXTXXJX8zcy8yHP1U5p1J-pHQ,66020
+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=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
@@ -16,13 +19,13 @@ skbase/lookup/_lookup.py,sha256=COZhLXRVZUdisoiS53J1LZylyjlM8TX-P9erEp6bk9I,4302
 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=tssOYrrWIRDr__UatmRfNTWt_nPa4ShbLRG0cEyfsD0,10190
-skbase/tests/test_base.py,sha256=TjJ8m3jeeBJUs_rMpfdGetC1eCHDlCb1UgfkLh7pEYI,50857
+skbase/tests/conftest.py,sha256=pHzQlpGJatKlGc80WtMitgPeHiaiYIkXzUEXkJIvnGs,10757
+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
@@ -38,14 +41,15 @@ skbase/utils/stderr_mute.py,sha256=VGMAjYgEjl-T-cFEzGJp_ry2iNR8wYLKL9SDhT8OZ7s,2
 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=6G1wnNoLj7tXPJA0Da1inBiOryUYoJDuzTdVOodIJYA,22368
+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=uIgAO2xkTlmKYH-4_38Asba7590QTzHkyDrDkFqoQss,4169
 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
@@ -57,9 +61,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.11.0.dist-info/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
-scikit_base-0.11.0.dist-info/METADATA,sha256=t0KmfRFbU5282LWhx_tgT7g7Y8juO8HbmLLEOgy8I-s,8535
-scikit_base-0.11.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-scikit_base-0.11.0.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
-scikit_base-0.11.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-scikit_base-0.11.0.dist-info/RECORD,,
+scikit_base-0.12.2.dist-info/METADATA,sha256=2ists-o7LlPIz2vgdnkdftBDCtNhdXBHqGahd8yV0iI,8794
+scikit_base-0.12.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+scikit_base-0.12.2.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
+scikit_base-0.12.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+scikit_base-0.12.2.dist-info/RECORD,,

{scikit_base-0.11.0.dist-info → scikit_base-0.12.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (78.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.11.0"
+__version__: str = "0.12.2"

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

@@ -60,6 +60,7 @@ from copy import deepcopy
 from typing import List
 
 from skbase._exceptions import NotFittedError
+from skbase.base._clone_base import _check_clone, _clone
 from skbase.base._pretty_printing._object_html_repr import _object_html_repr
 from skbase.base._tagmanager import _FlagManager
 
@@ -175,11 +176,41 @@ class BaseObject(_FlagManager):
         ------
         RuntimeError if the clone is non-conforming, due to faulty ``__init__``.
         """
-        self_clone = _clone(self)
+        # get plugins for cloning, if present (empty by default)
+        clone_plugins = self._get_clone_plugins()
+
+        # clone the object
+        self_clone = _clone(self, base_cls=BaseObject, clone_plugins=clone_plugins)
+
+        # check the clone, if check_clone is set (False by default)
         if self.get_config()["check_clone"]:
             _check_clone(original=self, clone=self_clone)
+
+        # return the clone
         return self_clone
 
+    @classmethod
+    def _get_clone_plugins(cls):
+        """Get clone plugins for BaseObject.
+
+        Can be overridden in subclasses to add custom clone plugins.
+
+        If implemented, must return a list of clone plugins for descendants.
+
+        Plugins are loaded ahead of the default plugins, and are used in the order
+        they are returned.
+        This allows extenders to override the default behaviours, if desired.
+
+        Returns
+        -------
+        list of str
+            List of clone plugins for descendants.
+            Each plugin must inherit from ``BaseCloner``
+            in ``skbase.base._clone_plugins``, and implement
+            the methods ``_check`` and ``_clone``.
+        """
+        return None
+
     @classmethod
     def _get_init_signature(cls):
         """Get class init signature.
@@ -1138,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
@@ -1653,107 +1690,3 @@ class BaseEstimator(BaseObject):
             fitted parameters, keyed by names of fitted parameter
         """
         return self._get_fitted_params_default()
-
-
-# Adapted from sklearn's `_clone_parametrized()`
-def _clone(estimator, *, safe=True):
-    """Construct a new unfitted estimator with the same parameters.
-
-    Clone does a deep copy of the model in an estimator
-    without actually copying attached data. It returns a new estimator
-    with the same parameters that has not been fitted on any data.
-
-    Parameters
-    ----------
-    estimator : {list, tuple, set} of estimator instance or a single \
-            estimator instance
-        The estimator or group of estimators to be cloned.
-    safe : bool, default=True
-        If safe is False, clone will fall back to a deep copy on objects
-        that are not estimators.
-
-    Returns
-    -------
-    estimator : object
-        The deep copy of the input, an estimator if input is an estimator.
-
-    Notes
-    -----
-    If the estimator's `random_state` parameter is an integer (or if the
-    estimator doesn't have a `random_state` parameter), an *exact clone* is
-    returned: the clone and the original estimator will give the exact same
-    results. Otherwise, *statistical clone* is returned: the clone might
-    return different results from the original estimator. More details can be
-    found in :ref:`randomness`.
-    """
-    estimator_type = type(estimator)
-    if estimator_type is dict:
-        return {k: _clone(v, safe=safe) for k, v in estimator.items()}
-    if estimator_type in (list, tuple, set, frozenset):
-        return estimator_type([_clone(e, safe=safe) for e in estimator])
-    elif not hasattr(estimator, "get_params") or isinstance(estimator, type):
-        if not safe:
-            return deepcopy(estimator)
-        else:
-            if isinstance(estimator, type):
-                raise TypeError(
-                    "Cannot clone object. "
-                    + "You should provide an instance of "
-                    + "scikit-learn estimator instead of a class."
-                )
-            else:
-                raise TypeError(
-                    "Cannot clone object '%s' (type %s): "
-                    "it does not seem to be a scikit-learn "
-                    "estimator as it does not implement a "
-                    "'get_params' method." % (repr(estimator), type(estimator))
-                )
-
-    klass = estimator.__class__
-    new_object_params = estimator.get_params(deep=False)
-    for name, param in new_object_params.items():
-        new_object_params[name] = _clone(param, safe=False)
-    new_object = klass(**new_object_params)
-    params_set = new_object.get_params(deep=False)
-
-    # quick sanity check of the parameters of the clone
-    for name in new_object_params:
-        param1 = new_object_params[name]
-        param2 = params_set[name]
-        if param1 is not param2:
-            raise RuntimeError(
-                "Cannot clone object %s, as the constructor "
-                "either does not set or modifies parameter %s" % (estimator, name)
-            )
-
-    # This is an extension to the original sklearn implementation
-    if isinstance(estimator, BaseObject) and estimator.get_config()["clone_config"]:
-        new_object.set_config(**estimator.get_config())
-
-    return new_object
-
-
-def _check_clone(original, clone):
-    from skbase.utils.deep_equals import deep_equals
-
-    self_params = original.get_params(deep=False)
-
-    # check that all attributes are written to the clone
-    for attrname in self_params.keys():
-        if not hasattr(clone, attrname):
-            raise RuntimeError(
-                f"error in {original}.clone, __init__ must write all arguments "
-                f"to self and not mutate them, but {attrname} was not found. "
-                f"Please check __init__ of {original}."
-            )
-
-    clone_attrs = {attr: getattr(clone, attr) for attr in self_params.keys()}
-
-    # check equality of parameters post-clone and pre-clone
-    clone_attrs_valid, msg = deep_equals(self_params, clone_attrs, return_msg=True)
-    if not clone_attrs_valid:
-        raise RuntimeError(
-            f"error in {original}.clone, __init__ must write all arguments "
-            f"to self and not mutate them, but this is not the case. "
-            f"Error on equality check of arguments (x) vs parameters (y): {msg}"
-        )

skbase/base/_clone_base.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+# Elements of BaseObject reuse code developed in scikit-learn. These elements
+# are copyrighted by the scikit-learn developers, BSD-3-Clause License. For
+# conditions see https://github.com/scikit-learn/scikit-learn/blob/main/COPYING
+"""Logic and plugins for cloning objects.
+
+This module contains logic for cloning objects:
+
+_clone(estimator, *, safe=True, plugins=None) - central entry point for cloning
+_check_clone(original, clone) - validation utility to check clones
+
+Default plugins for _clone are stored in _clone_plugins:
+
+DEFAULT_CLONE_PLUGINS - list with default plugins for cloning
+
+Each element of DEFAULT_CLONE_PLUGINS inherits from BaseCloner, with methods:
+
+* check(obj) -> boolean - fast checker whether plugin applies
+* clone(obj) -> type(obj) - method to clone obj
+"""
+__all__ = ["_clone", "_check_clone"]
+
+from skbase.base._clone_plugins import DEFAULT_CLONE_PLUGINS
+
+
+# Adapted from sklearn's `_clone_parametrized()`
+def _clone(estimator, *, safe=True, clone_plugins=None, base_cls=None):
+    """Construct a new unfitted estimator with the same parameters.
+
+    Clone does a deep copy of the model in an estimator
+    without actually copying attached data. It returns a new estimator
+    with the same parameters that has not been fitted on any data.
+
+    Parameters
+    ----------
+    estimator : {list, tuple, set} of estimator instance or a single estimator instance
+        The estimator or group of estimators to be cloned.
+    safe : bool, default=True
+        If ``safe`` is False, clone will fall back to a deep copy on objects
+        that are not estimators.
+    clone_plugins : list of BaseCloner clone plugins, concrete descendant classes.
+        Must implement ``_check`` and ``_clone`` method, see ``BaseCloner`` interface.
+        If passed, will work through clone plugins in ``clone_plugins``
+        before working through ``DEFAULT_CLONE_PLUGINS``. To override
+        a cloner in ``DEAULT_CLONE_PLUGINS``, simply ensure a cloner with
+        the same ``_check`` logis is present in ``clone_plugins``.
+    base_cls : reference to BaseObject
+        Reference to the BaseObject class from skbase.base._base.
+        Present for easy reference, fast imports, and potential extensions.
+
+    Returns
+    -------
+    estimator : object
+        The deep copy of the input, an estimator if input is an estimator.
+
+    Notes
+    -----
+    If the estimator's `random_state` parameter is an integer (or if the
+    estimator doesn't have a `random_state` parameter), an *exact clone* is
+    returned: the clone and the original estimator will give the exact same
+    results. Otherwise, *statistical clone* is returned: the clone might
+    return different results from the original estimator. More details can be
+    found in :ref:`randomness`.
+    """
+    # handle cloning plugins:
+    # if no plugins provided by user, work through the DEFAULT_CLONE_PLUGINS
+    # if provided by user, work through user provided plugins first, then defaults
+    if clone_plugins is not None:
+        all_plugins = clone_plugins.copy()
+        all_plugins.append(DEFAULT_CLONE_PLUGINS.copy())
+    else:
+        all_plugins = DEFAULT_CLONE_PLUGINS
+
+    for cloner_plugin in all_plugins:
+        cloner = cloner_plugin(safe=safe, clone_plugins=all_plugins, base_cls=base_cls)
+        # we clone with the first plugin in the list that:
+        # 1. claims it is applicable, via check
+        # 2. does not produce an Exception when cloning
+        if cloner.check(obj=estimator):
+            return cloner.clone(obj=estimator)
+
+    raise RuntimeError(
+        "Error in skbase _clone, catch-all plugin did not catch all "
+        "remaining cases. This is likely due to custom modification of the module."
+    )
+
+
+def _check_clone(original, clone):
+    """Check that clone is a valid clone of original.
+
+    Called from BaseObject.clone to validate the clone, if
+    the config flag check_clone is set to True.
+
+    Parameters
+    ----------
+    original : object
+        The original object.
+    clone : object
+        The cloned object.
+
+    Raises
+    ------
+    RuntimeError
+        If the clone is not a valid clone of the original.
+    """
+    from skbase.utils.deep_equals import deep_equals
+
+    self_params = original.get_params(deep=False)
+
+    # check that all attributes are written to the clone
+    for attrname in self_params.keys():
+        if not hasattr(clone, attrname):
+            raise RuntimeError(
+                f"error in {original}.clone, __init__ must write all arguments "
+                f"to self and not mutate them, but {attrname} was not found. "
+                f"Please check __init__ of {original}."
+            )
+
+    clone_attrs = {attr: getattr(clone, attr) for attr in self_params.keys()}
+
+    # check equality of parameters post-clone and pre-clone
+    clone_attrs_valid, msg = deep_equals(self_params, clone_attrs, return_msg=True)
+    if not clone_attrs_valid:
+        raise RuntimeError(
+            f"error in {original}.clone, __init__ must write all arguments "
+            f"to self and not mutate them, but this is not the case. "
+            f"Error on equality check of arguments (x) vs parameters (y): {msg}"
+        )

skbase/base/_clone_plugins.py

@@ -0,0 +1,215 @@
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+# Elements of BaseObject reuse code developed in scikit-learn. These elements
+# are copyrighted by the scikit-learn developers, BSD-3-Clause License. For
+# conditions see https://github.com/scikit-learn/scikit-learn/blob/main/COPYING
+"""Logic and plugins for cloning objects - default plugins.
+
+This module contains default plugins for _clone, from _clone_base.
+
+DEFAULT_CLONE_PLUGINS - list with default plugins for cloning
+
+Each element of DEFAULT_CLONE_PLUGINS inherits from BaseCloner, with methods:
+
+* check(obj) -> boolean - fast checker whether plugin applies
+* clone(obj) -> type(obj) - method to clone obj
+"""
+from functools import lru_cache
+from inspect import isclass
+
+
+# imports wrapped in functions to avoid exceptions on skbase init
+# wrapped in _safe_import to avoid exceptions on skbase init
+@lru_cache(maxsize=None)
+def _is_sklearn_present():
+    """Check whether scikit-learn is present."""
+    from skbase.utils.dependencies import _check_soft_dependencies
+
+    return _check_soft_dependencies("scikit-learn")
+
+
+@lru_cache(maxsize=None)
+def _get_sklearn_clone():
+    """Get sklearn's clone function."""
+    from skbase.utils.dependencies._import import _safe_import
+
+    return _safe_import("sklearn.base:clone", condition=_is_sklearn_present())
+
+
+class BaseCloner:
+    """Base class for clone plugins.
+
+    Concrete classes must inherit methods:
+
+    * check(obj) -> boolean - fast checker whether plugin applies
+    * clone(obj) -> type(obj) - method to clone obj
+    """
+
+    def __init__(self, safe, clone_plugins=None, base_cls=None):
+        self.safe = safe
+        self.clone_plugins = clone_plugins
+        self.base_cls = base_cls
+
+    def check(self, obj):
+        """Check whether the plugin applies to obj."""
+        try:
+            return self._check(obj)
+        except Exception:
+            return False
+
+    def clone(self, obj):
+        """Return a clone of obj."""
+        return self._clone(obj)
+
+    def recursive_clone(self, obj, **kwargs):
+        """Recursive call to _clone, for explicit code and to avoid circular imports."""
+        from skbase.base._clone_base import _clone
+
+        recursion_kwargs = {
+            "safe": self.safe,
+            "clone_plugins": self.clone_plugins,
+            "base_cls": self.base_cls,
+        }
+        recursion_kwargs.update(kwargs)
+        return _clone(obj, **recursion_kwargs)
+
+
+class _CloneClass(BaseCloner):
+    """Clone plugin for classes. Returns the class."""
+
+    def _check(self, obj):
+        """Check whether the plugin applies to obj."""
+        return isclass(obj)
+
+    def _clone(self, obj):
+        """Return a clone of obj."""
+        return obj
+
+
+class _CloneDict(BaseCloner):
+    """Clone plugin for dicts. Performs recursive cloning."""
+
+    def _check(self, obj):
+        """Check whether the plugin applies to obj."""
+        return isinstance(obj, dict)
+
+    def _clone(self, obj):
+        """Return a clone of obj."""
+        _clone = self.recursive_clone
+        return {k: _clone(v) for k, v in obj.items()}
+
+
+class _CloneListTupleSet(BaseCloner):
+    """Clone plugin for lists, tuples, sets. Performs recursive cloning."""
+
+    def _check(self, obj):
+        """Check whether the plugin applies to obj."""
+        return isinstance(obj, (list, tuple, set, frozenset))
+
+    def _clone(self, obj):
+        """Return a clone of obj."""
+        _clone = self.recursive_clone
+        return type(obj)([_clone(e) for e in obj])
+
+
+def _default_clone(estimator, recursive_clone):
+    """Clone estimator. Default used in skbase native and generic get_params clone."""
+    klass = estimator.__class__
+    new_object_params = estimator.get_params(deep=False)
+    for name, param in new_object_params.items():
+        new_object_params[name] = recursive_clone(param, safe=False)
+    new_object = klass(**new_object_params)
+    params_set = new_object.get_params(deep=False)
+
+    # quick sanity check of the parameters of the clone
+    for name in new_object_params:
+        param1 = new_object_params[name]
+        param2 = params_set[name]
+        if param1 is not param2:
+            raise RuntimeError(
+                "Cannot clone object %s, as the constructor "
+                "either does not set or modifies parameter %s" % (estimator, name)
+            )
+
+    return new_object
+
+
+class _CloneSkbase(BaseCloner):
+    """Clone plugin for scikit-base BaseObject descendants."""
+
+    def _check(self, obj):
+        """Check whether the plugin applies to obj."""
+        return isinstance(obj, self.base_cls)
+
+    def _clone(self, obj):
+        """Return a clone of obj."""
+        new_object = _default_clone(estimator=obj, recursive_clone=self.recursive_clone)
+
+        # Ensure that configs are retained in the new object
+        if obj.get_config()["clone_config"]:
+            new_object.set_config(**obj.get_config())
+
+        return new_object
+
+
+class _CloneSklearn(BaseCloner):
+    """Clone plugin for scikit-learn BaseEstimator descendants."""
+
+    def _check(self, obj):
+        """Check whether the plugin applies to obj."""
+        if not _is_sklearn_present():
+            return False
+
+        from sklearn.base import BaseEstimator
+
+        return isinstance(obj, BaseEstimator)
+
+    def _clone(self, obj):
+        """Return a clone of obj."""
+        _sklearn_clone = _get_sklearn_clone()
+        return _sklearn_clone(obj)
+
+
+class _CloneGetParams(BaseCloner):
+    """Clone plugin for objects that implement get_params but are not the above."""
+
+    def _check(self, obj):
+        """Check whether the plugin applies to obj."""
+        return hasattr(obj, "get_params")
+
+    def _clone(self, obj):
+        """Return a clone of obj."""
+        return _default_clone(estimator=obj, recursive_clone=self.recursive_clone)
+
+
+class _CloneCatchAll(BaseCloner):
+    """Catch-all plug-in to deal, catches all objects at the end of list."""
+
+    def _check(self, obj):
+        """Check whether the plugin applies to obj."""
+        return True
+
+    def _clone(self, obj):
+        """Return a clone of obj."""
+        from copy import deepcopy
+
+        if not self.safe:
+            return deepcopy(obj)
+        else:
+            raise TypeError(
+                "Cannot clone object '%s' (type %s): "
+                "it does not seem to be a scikit-base object or scikit-learn "
+                "estimator, as it does not implement a "
+                "'get_params' method." % (repr(obj), type(obj))
+            )
+
+
+DEFAULT_CLONE_PLUGINS = [
+    _CloneClass,
+    _CloneDict,
+    _CloneListTupleSet,
+    _CloneSkbase,
+    _CloneSklearn,
+    _CloneGetParams,
+    _CloneCatchAll,
+]

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

@@ -22,6 +22,8 @@ SKBASE_MODULES = (
     "skbase._nopytest_tests",
     "skbase.base",
     "skbase.base._base",
+    "skbase.base._clone_base",
+    "skbase.base._clone_plugins",
     "skbase.base._meta",
     "skbase.base._pretty_printing",
     "skbase.base._pretty_printing._object_html_repr",
@@ -53,6 +55,7 @@ SKBASE_MODULES = (
     "skbase.utils.deep_equals._deep_equals",
     "skbase.utils.dependencies",
     "skbase.utils.dependencies._dependencies",
+    "skbase.utils.dependencies._import",
     "skbase.utils.random_state",
     "skbase.utils.stderr_mute",
     "skbase.utils.stdout_mute",
@@ -96,6 +99,7 @@ SKBASE_PUBLIC_CLASSES_BY_MODULE = {
         "BaseObject",
     ),
     "skbase.base._base": ("BaseEstimator", "BaseObject"),
+    "skbase.base._clone_plugins": ("BaseCloner",),
     "skbase.base._meta": (
         "BaseMetaObject",
         "BaseMetaObjectMixin",
@@ -116,6 +120,16 @@ SKBASE_PUBLIC_CLASSES_BY_MODULE = {
 SKBASE_CLASSES_BY_MODULE = SKBASE_PUBLIC_CLASSES_BY_MODULE.copy()
 SKBASE_CLASSES_BY_MODULE.update(
     {
+        "skbase.base._clone_plugins": (
+            "BaseCloner",
+            "_CloneClass",
+            "_CloneSkbase",
+            "_CloneSklearn",
+            "_CloneDict",
+            "_CloneListTupleSet",
+            "_CloneGetParams",
+            "_CloneCatchAll",
+        ),
         "skbase.base._meta": (
             "BaseMetaObject",
             "BaseMetaObjectMixin",
@@ -184,10 +198,8 @@ SKBASE_PUBLIC_FUNCTIONS_BY_MODULE = {
 SKBASE_FUNCTIONS_BY_MODULE = SKBASE_PUBLIC_FUNCTIONS_BY_MODULE.copy()
 SKBASE_FUNCTIONS_BY_MODULE.update(
     {
-        "skbase.base._base": (
-            "_clone",
-            "_check_clone",
-        ),
+        "skbase.base._clone_base": {"_check_clone", "_clone"},
+        "skbase.base._clone_plugins": ("_default_clone",),
         "skbase.base._pretty_printing._object_html_repr": (
             "_get_visual_block",
             "_object_html_repr",
@@ -218,6 +230,7 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
             "_check_python_version",
             "_check_estimator_deps",
         ),
+        "skbase.utils.dependencies._import": ("_safe_import",),
         "skbase.utils._iter": (
             "_format_seq_to_str",
             "_remove_type_text",
@@ -259,6 +272,7 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
             "_get_pkg_version",
             "_get_installed_packages",
             "_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]):
@@ -1123,8 +1075,8 @@ def test_clone_class_rather_than_instance_raises_error(
     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_sklearn_composite(fixture_class_parent: Type[Parent]):
-    """Test clone with keyword parameter set to None."""
+def test_clone_sklearn_composite():
+    """Test clone with a composite of sklearn and skbase."""
     from sklearn.ensemble import GradientBoostingRegressor
 
     sklearn_obj = GradientBoostingRegressor(random_state=5, learning_rate=0.02)
@@ -1134,6 +1086,23 @@ def test_clone_sklearn_composite(fixture_class_parent: Type[Parent]):
     assert composite_set.get_params()["a__random_state"] == 42
 
 
+@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_sklearn_composite_retains_config():
+    """Test that clone retains sklearn config if inside skbase composite."""
+    from sklearn.preprocessing import StandardScaler
+
+    sklearn_obj_w_config = StandardScaler().set_output(transform="pandas")
+
+    composite = ResetTester(a=sklearn_obj_w_config)
+    composite_clone = composite.clone()
+
+    assert hasattr(composite_clone.a, "_sklearn_output_config")
+    assert composite_clone.a._sklearn_output_config.get("transform", None) == "pandas"
+
+
 # Tests of BaseObject pretty printing representation inspired by sklearn
 def test_baseobject_repr(
     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,10 +13,10 @@ from packaging.version import InvalidVersion, Version
 
 def _check_soft_dependencies(
     *packages,
-    package_import_alias="deprecated",
     severity="error",
     obj=None,
     msg=None,
+    normalize_reqs=True,
 ):
     """Check if required soft dependencies are installed and raise error or warning.
 
@@ -53,6 +53,16 @@ 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.
+
     Raises
     ------
     InvalidRequirement
@@ -98,7 +108,8 @@ def _check_soft_dependencies(
     for package in packages:
         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, "
@@ -112,6 +123,8 @@ def _check_soft_dependencies(
         package_version_req = req.specifier
 
         pkg_env_version = _get_pkg_version(package_name)
+        if normalize_reqs:
+            pkg_env_version = _normalize_version(pkg_env_version)
 
         # if package not present, make the user aware of installation reqs
         if pkg_env_version is None:
@@ -129,7 +142,7 @@ def _check_soft_dependencies(
                 )
             msg = msg + (
                 f"Please run: `pip install {package}` to "
-                f"install the {package} package. "
+                f"install the {package!r} package. "
             )
             # if msg is not None, none of the above is executed,
             # so if msg is passed it overrides the default messages
@@ -223,7 +236,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 +261,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 +285,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 +312,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 +334,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 +452,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 +478,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 +492,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/_import.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+"""Utility for safe import."""
+import importlib
+
+
+def _safe_import(path, condition=True):
+    """Safely imports an object from a module given its string location.
+
+    Parameters
+    ----------
+    path: str
+        A string representing the module and object.
+        In the form ``"module.submodule:object"``.
+    condition: bool, default=True
+        If False, the import will not be attempted.
+
+    Returns
+    -------
+    Any: The imported object, or None if it could not be imported.
+    """
+    if not condition:
+        return None
+    try:
+        module_name, object_name = path.split(":")
+        module = importlib.import_module(module_name)
+        return getattr(module, object_name, None)
+    except (ImportError, AttributeError, ValueError):
+        return None

skbase/utils/dependencies/tests/test_check_dependencies.py

@@ -1,9 +1,11 @@
 # -*- 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 +49,53 @@ def test_check_soft_deps():
         assert _check_soft_dependencies(
             ("pytest", "!!numpy<~><>0.1.0"), severity="none"
         )
+
+
+@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/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