scikit-base 0.7.2__py3-none-any.whl → 0.7.4__py3-none-any.whl

{scikit_base-0.7.2.dist-info → scikit_base-0.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scikit-base
-Version: 0.7.2
+Version: 0.7.4
 Summary: Base classes for sklearn-like parametric objects
 Author-email: sktime developers <sktime.toolbox@gmail.com>
 Maintainer: Franz Király
@@ -114,7 +114,7 @@ Requires-Dist: scikit-learn >=0.24.0 ; extra == 'test'
 `skbase` provides base classes for creating scikit-learn-like parametric objects,
 along with tools to make it easier to build your own packages that follow these design patterns.
 
-:rocket: Version 0.7.2 is now available. Check out our
+:rocket: Version 0.7.4 is now available. Check out our
 [release notes](https://skbase.readthedocs.io/en/latest/changelog.html).
 
 | Overview | |

{scikit_base-0.7.2.dist-info → scikit_base-0.7.4.dist-info}/RECORD

@@ -1,16 +1,16 @@
 docs/source/conf.py,sha256=kFc-4qkb0ZGD5cDej5KPJhMePp9kpVu6ZqFoF0fgovg,9951
-skbase/__init__.py,sha256=sQyqEwB4g0eTD28WSUR-p2oMyfVkfk4lapeLppVk7Ks,345
+skbase/__init__.py,sha256=abk0HlHOHt1z9B3iOIIUbVD4EdH8nJ3T-1HR7UuI9u0,345
 skbase/_exceptions.py,sha256=KXfcVa7Xit-w-Xs_qFSJOEa_Mfp1oJeiHEC3v4Z0h1Q,1112
 skbase/_nopytest_tests.py,sha256=npL5pibSgCpulEGw0NqLKcG0majh6xcdW5A4Zibf78s,1077
 skbase/base/__init__.py,sha256=5ZLlwJeyfKDA1lAylBJgZd3t5JY25xsgQB4waQnroa8,751
-skbase/base/_base.py,sha256=J-6Wwor9yn02zg4vl2WAZfE-kwdhIggfV1xYSpMwP-0,53249
+skbase/base/_base.py,sha256=1MJgavydCw-4TNqA4Na_7LMVoh4w4D5q81l15SbKJUM,53490
 skbase/base/_meta.py,sha256=VY6_R2tE885j-GTDuzLFyho5i382jOni5lkR_ykPZqo,38815
 skbase/base/_tagmanager.py,sha256=nKoiIC1yXFFSpN5ljWbMrwA-pwlbxsljgKuUywh1MR4,7289
 skbase/base/_pretty_printing/__init__.py,sha256=bVuKnwafn8c2q2AGJ9BOu9cmu-xBjiOxHf1hxjm8K2A,492
 skbase/base/_pretty_printing/_object_html_repr.py,sha256=0DHcM3AHIRkV1fCRi-G7lzDmiSTR2-MjU40iXUuV2AM,11538
 skbase/base/_pretty_printing/_pprint.py,sha256=VVnw-cywGxArfiFfVWfFSV5VMJvsxpDsJJ4RplcndqA,15634
 skbase/lookup/__init__.py,sha256=RNw1mx8nXFHsn-HgnjHzWPn9AG45jSMEKl-Z0pEH7jE,1089
-skbase/lookup/_lookup.py,sha256=YYsqz71VyPCAbqTiAm-WAuHyLUfO5pOgNlaKMdFGCOU,39824
+skbase/lookup/_lookup.py,sha256=7L1JIMCzpMdSF5ZqHNDeIaHu4QRwXoLJ4DgM1Z_uFts,39864
 skbase/lookup/tests/__init__.py,sha256=MVqGlWsUV-gQ4qzW_TqE3UmKO9IQ9mwdDlsIHaGt3bc,68
 skbase/lookup/tests/test_lookup.py,sha256=_VDReGKnJF52UtFbvg_D2vlAkVvREypwM-9jR7DPAXQ,38218
 skbase/testing/__init__.py,sha256=OdwR-aEU2KzGrU-O0gtNSMNGmF2mtgBmjAnMzcgwe6w,351
@@ -19,7 +19,7 @@ skbase/testing/utils/__init__.py,sha256=kaLuqQwJsCunRWsUb1JwTVG-iqXbzdUobuYHNHsB
 skbase/testing/utils/_conditional_fixtures.py,sha256=QwI7K28Lsy6RAkDP94goo8uWWvMzKKNOmXRFtc9RNtI,9890
 skbase/testing/utils/inspect.py,sha256=XcPdm1-J3YXCTxsrqeJlStPvbC0vH1cgaApN5lzRI2c,741
 skbase/tests/__init__.py,sha256=d2_OTTnt0GX5otQsBuNAb1evg8C5Fi0JjqK2VsfMtXU,37
-skbase/tests/conftest.py,sha256=WB8aoyiOtrQealUDCBwU35oq-KiSuz_CF235xdTgoSY,9106
+skbase/tests/conftest.py,sha256=F-D3fqengjnaVSk2L4mYh8Wg_o0kS7L3wmGi2vU1B94,9272
 skbase/tests/test_base.py,sha256=-kyVDOQRdXYsBmSTqNjZ06mjnt_OWoY2i2i71qx3TF8,50648
 skbase/tests/test_baseestimator.py,sha256=fuzpwxjYzyl-Vrte1va4AWdbYElhWnED8W10236Xprc,4731
 skbase/tests/test_exceptions.py,sha256=wOdk7Gp8pvbhucna3_9FxTk9xFLjC9XNsGsVabQLYEE,629
@@ -34,14 +34,14 @@ skbase/utils/_utils.py,sha256=A6sTIUEscEy9TjBmCvXEuhk9q8ROBPyfJGhrjlSA4LY,3134
 skbase/utils/random_state.py,sha256=QxY-M2u_6my315tdml2CukKj7ZVnbqjU_T9ZzixGuq0,5127
 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=KUr1Qat7kL1CuW78aSALPFinUiRQZUUSoBxdRbZMY4E,17318
-skbase/utils/dependencies/__init__.py,sha256=89TNnES--f1PeoPm-_h6a2mCtoGXt6mAd-n89FdusMM,352
-skbase/utils/dependencies/_dependencies.py,sha256=zmlWZ10HtiHE2PK2T7AzsFNKIA95O8hmIySlz2t4Mrs,10359
+skbase/utils/deep_equals/_deep_equals.py,sha256=-blJhvTGdk4WjiSjBo8t954LysODZwPZoPHk2SBPzCQ,17615
+skbase/utils/dependencies/__init__.py,sha256=cCUa_P-RiDs4pW6cw51uYeoBMaMa9iycwiFkwqkIizc,419
+skbase/utils/dependencies/_dependencies.py,sha256=L3_ghGBHzaHX964b0bCw7H_Q5X4ILZ5LsQYCEAmZq5U,14501
 skbase/utils/dependencies/tests/__init__.py,sha256=UqE6wenG-HffjT2Z974OLzmXG-M8PNOP9nUnNfqtfT4,74
 skbase/utils/dependencies/tests/test_check_dependencies.py,sha256=uxAC3gr4VWTlgctN90pnT1ra_UYkPxQHEla-IljX-n0,2238
 skbase/utils/tests/__init__.py,sha256=YfvP5lpCrTC_6SIakU7jBBdqYyuqE07nZ56ZYKTs3f0,165
 skbase/utils/tests/test_check.py,sha256=rMxaQtKegaKZPGjocNB9ntMwMIAq5-7SmNZuFsWFGZE,754
-skbase/utils/tests/test_deep_equals.py,sha256=kRCQ87Tb0lIjP-3kf29wND2J4pCZpBVKC8iaKd8k7YY,2635
+skbase/utils/tests/test_deep_equals.py,sha256=ZKrnCR4Ph14FgBhlIoxxpn8Pki7TGKbYYtymoJz0Fqk,2786
 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
@@ -52,9 +52,9 @@ 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=G-qwFjXk-8WvXoeOvo2omfFKKjbpWhP-sPf6hsw8q30,14131
-scikit_base-0.7.2.dist-info/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
-scikit_base-0.7.2.dist-info/METADATA,sha256=PVrJAa0Bch0rbC4ks09SBgYepftCp_QZUttyN0eGBsI,8704
-scikit_base-0.7.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-scikit_base-0.7.2.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
-scikit_base-0.7.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-scikit_base-0.7.2.dist-info/RECORD,,
+scikit_base-0.7.4.dist-info/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
+scikit_base-0.7.4.dist-info/METADATA,sha256=yktJpyUY8DuNNcflKdRmVroKTBQ1pbb-1tZldt3vGsk,8704
+scikit_base-0.7.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+scikit_base-0.7.4.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
+scikit_base-0.7.4.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+scikit_base-0.7.4.dist-info/RECORD,,

skbase/__init__.py

@@ -6,4 +6,4 @@
 The included functionality makes it easy to reuse scikit-learn and
 sktime design principles in your project.
 """
-__version__: str = "0.7.2"
+__version__: str = "0.7.4"

skbase/base/_base.py

@@ -63,7 +63,7 @@ from skbase._exceptions import NotFittedError
 from skbase.base._pretty_printing._object_html_repr import _object_html_repr
 from skbase.base._tagmanager import _FlagManager
 
-__author__: List[str] = ["mloning", "RNKuhns", "fkiraly"]
+__author__: List[str] = ["fkiraly", "mloning", "RNKuhns", "tpvasconcelos"]
 __all__: List[str] = ["BaseEstimator", "BaseObject"]
 
 
@@ -157,113 +157,11 @@ class BaseObject(_FlagManager):
         -----
         If successful, equal in value to ``type(self)(**self.get_params(deep=False))``.
         """
-        self_params = self.get_params(deep=False)
-        self_clone = self._clone(self)
-
-        # if checking the clone is turned off, return now
-        if not self.get_config()["check_clone"]:
-            return self_clone
-
-        from skbase.utils.deep_equals import deep_equals
-
-        # check that all attributes are written to the clone
-        for attrname in self_params.keys():
-            if not hasattr(self_clone, attrname):
-                raise RuntimeError(
-                    f"error in {self}.clone, __init__ must write all arguments "
-                    f"to self and not mutate them, but {attrname} was not found. "
-                    f"Please check __init__ of {self}."
-                )
-
-        clone_attrs = {attr: getattr(self_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 {self}.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}"
-            )
-
+        self_clone = _clone(self)
+        if self.get_config()["check_clone"]:
+            _check_clone(original=self, clone=self_clone)
         return self_clone
 
-    # copied from sklearn
-    def _clone(self, 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)
-        # XXX: not handling dictionaries
-        if estimator_type in (list, tuple, set, frozenset):
-            return estimator_type([self._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] = self._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
-
     @classmethod
     def _get_init_signature(cls):
         """Get class init signature.
@@ -687,16 +585,18 @@ class BaseObject(_FlagManager):
             `MyClass(**params)` or `MyClass(**params[i])` creates a valid test instance.
             `create_test_instance` uses the first (or only) dictionary in `params`
         """
+        params_with_defaults = set(cls.get_param_defaults().keys())
+        all_params = set(cls.get_param_names())
+        params_without_defaults = all_params - params_with_defaults
+
         # if non-default parameters are required, but none have been found, raise error
-        if hasattr(cls, "_required_parameters"):
-            required_parameters = getattr(cls, "_required_parameters", [])
-            if len(required_parameters) > 0:
-                raise ValueError(
-                    f"Estimator: {cls} requires "
-                    f"non-default parameters for construction, "
-                    f"but none were given. Please set them "
-                    f"as given in the extension template"
-                )
+        if len(params_without_defaults) > 0:
+            raise ValueError(
+                f"Estimator: {cls} has parameters without default values, "
+                f"but these are not set in get_test_params. "
+                f"Please set them in get_test_params, or provide default values. "
+                f"Also see the respective extension template, if applicable."
+            )
 
         # construct with parameter configuration for testing, otherwise construct with
         # default parameters (empty dict)
@@ -737,7 +637,7 @@ class BaseObject(_FlagManager):
                 "get_test_params should either return a dict or list of dict."
             )
 
-        return cls(**params)
+        return cls._safe_init_test_params(params)
 
     @classmethod
     def create_test_instances_and_names(cls, parameter_set="default"):
@@ -757,9 +657,6 @@ class BaseObject(_FlagManager):
             i-th element is name of i-th instance of obj in tests
             convention is {cls.__name__}-{i} if more than one instance
             otherwise {cls.__name__}
-        parameter_set : str, default="default"
-            Name of the set of test parameters to return, for use in tests. If no
-            special parameters are defined for a value, will return `"default"` set.
         """
         if "parameter_set" in inspect.getfullargspec(cls.get_test_params).args:
             param_list = cls.get_test_params(parameter_set=parameter_set)
@@ -780,7 +677,7 @@ class BaseObject(_FlagManager):
                     f"Error in {cls.__name__}.get_test_params, "
                     "return must be param dict for class, or list thereof"
                 )
-            objs += [cls(**params)]
+            objs += [cls._safe_init_test_params(params)]
 
         num_instances = len(param_list)
         if num_instances > 1:
@@ -790,6 +687,22 @@ class BaseObject(_FlagManager):
 
         return objs, names
 
+    @classmethod
+    def _safe_init_test_params(cls, params):
+        """Safe init of cls with params for testing.
+
+        Will raise informative error message if params are not valid.
+        """
+        try:
+            return cls(**params)
+        except Exception as e:
+            raise type(e)(
+                f"Error in {cls.__name__}.get_test_params, "
+                "return must be valid param dict for class, or list thereof, "
+                "but attempted construction raised a exception. "
+                f"Problematic parameter set: {params}. Exception raised: {e}"
+            ) from e
+
     @classmethod
     def _has_implementation_of(cls, method):
         """Check if method has a concrete implementation in this class.
@@ -1387,3 +1300,106 @@ 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)
+    # XXX: not handling dictionaries
+    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/lookup/_lookup.py

@@ -693,7 +693,6 @@ def all_objects(
     object_types=None,
     filter_tags=None,
     exclude_objects=None,
-    exclude_estimators=None,
     return_names=True,
     as_dataframe=False,
     return_tags=None,
@@ -701,7 +700,6 @@ def all_objects(
     package_name="skbase",
     path: Optional[str] = None,
     modules_to_ignore=None,
-    ignore_modules=None,
     class_lookup=None,
 ):
     """Get a list of all objects in a package with name `package_name`.
@@ -825,9 +823,12 @@ def all_objects(
         return name.startswith("_") or name.startswith("Base")
 
     def _is_estimator(name, klass):
-        # Check if klass is subclass of base estimators, not an base class itself and
+        # Check if klass is subclass of base estimators, not a base class itself and
         # not an abstract class
-        return issubclass(klass, BaseObject) and not _is_base_class(name)
+        if object_types is None:
+            return issubclass(klass, BaseObject) and not _is_base_class(name)
+        else:
+            return not _is_base_class(name)
 
     # Ignore deprecation warnings triggered at import time and from walking packages
     with warnings.catch_warnings():

skbase/tests/conftest.py

@@ -178,6 +178,10 @@ 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._pretty_printing._object_html_repr": (
             "_get_visual_block",
             "_object_html_repr",
@@ -205,6 +209,7 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
         "skbase.utils.dependencies": (
             "_check_soft_dependencies",
             "_check_python_version",
+            "_check_estimator_deps",
         ),
         "skbase.utils._iter": (
             "_format_seq_to_str",
@@ -240,6 +245,7 @@ SKBASE_FUNCTIONS_BY_MODULE.update(
         "skbase.utils.dependencies._dependencies": (
             "_check_soft_dependencies",
             "_check_python_version",
+            "_check_estimator_deps",
         ),
         "skbase.utils.random_state": (
             "check_random_state",

skbase/utils/deep_equals/_deep_equals.py

@@ -480,6 +480,14 @@ def deep_equals_custom(x, y, return_msg=False, plugins=None):
             if res is not None:
                 return res
 
+    # if the object x and y have a len() then compare of x and y lengths else continue
+    if hasattr(x, "__len__") and hasattr(y, "__len__"):
+        if len(x) != len(y):
+            return ret(
+                False,
+                f".len, x.len = {len(x)} != y.len = {len(y)}",
+            )
+
     # this if covers case where != is boolean
     # some types return a vector upon !=, this is covered in the next elif
     if isinstance(x == y, bool):

skbase/utils/dependencies/__init__.py

@@ -4,8 +4,13 @@
 """Utility functionality used through `skbase`."""
 
 from skbase.utils.dependencies._dependencies import (
+    _check_estimator_deps,
     _check_python_version,
     _check_soft_dependencies,
 )
 
-__all__ = ["_check_python_version", "_check_soft_dependencies"]
+__all__ = [
+    "_check_python_version",
+    "_check_soft_dependencies",
+    "_check_estimator_deps",
+]

skbase/utils/dependencies/_dependencies.py

@@ -18,6 +18,7 @@ def _check_soft_dependencies(
     package_import_alias=None,
     severity="error",
     obj=None,
+    msg=None,
     suppress_import_stdout=False,
 ):
     """Check if required soft dependencies are installed and raise error or warning.
@@ -40,7 +41,7 @@ def _check_soft_dependencies(
         should be provided if import name differs from package name
     severity : str, "error" (default), "warning", "none"
         behaviour for raising errors or warnings
-        "error" - raises a `ModuleNotFoundException` if one of packages is not installed
+        "error" - raises a `ModuleNotFoundError` if one of packages is not installed
         "warning" - raises a warning if one of packages is not installed
             function returns False if one of packages is not installed, otherwise True
         "none" - does not raise exception or warning
@@ -50,6 +51,8 @@ def _check_soft_dependencies(
         or a class is passed when it is called at the start of a single-class module,
         the error message is more informative and will refer to the class/object;
         if str is passed, will be used as name of the class/object or module
+    msg : str, or None, default=None
+        if str, will override the error message or warning shown with msg
     suppress_import_stdout : bool, optional. Default=False
         whether to suppress stdout printout upon import.
 
@@ -65,17 +68,24 @@ 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):
-        raise TypeError("packages must be str or tuple of str")
+        raise TypeError(
+            "packages argument of _check_soft_dependencies must be str or tuple of "
+            f"str, but found packages argument of type {type(packages)}"
+        )
 
     if package_import_alias is None:
         package_import_alias = {}
-    msg = "package_import_alias must be a dict with str keys and values"
+    msg_pkg_import_alias = (
+        "package_import_alias argument of _check_soft_dependencies must "
+        "be a dict with str keys and values, but found "
+        f"package_import_alias of type {type(package_import_alias)}"
+    )
     if not isinstance(package_import_alias, dict):
-        raise TypeError(msg)
+        raise TypeError(msg_pkg_import_alias)
     if not all(isinstance(x, str) for x in package_import_alias.keys()):
-        raise TypeError(msg)
+        raise TypeError(msg_pkg_import_alias)
     if not all(isinstance(x, str) for x in package_import_alias.values()):
-        raise TypeError(msg)
+        raise TypeError(msg_pkg_import_alias)
 
     if obj is None:
         class_name = "This functionality"
@@ -86,7 +96,17 @@ def _check_soft_dependencies(
     elif isinstance(obj, str):
         class_name = obj
     else:
-        raise TypeError("obj must be a class, an object, a str, or None")
+        raise TypeError(
+            "obj argument of _check_soft_dependencies must be a class, an object,"
+            " a str, or None, but found obj of type"
+            f" {type(obj)}"
+        )
+
+    if msg is not None and not isinstance(msg, str):
+        raise TypeError(
+            "msg argument of _check_soft_dependencies must be a str, "
+            f"or None, but found msg of type {type(msg)}"
+        )
 
     for package in packages:
         try:
@@ -94,6 +114,7 @@ def _check_soft_dependencies(
         except InvalidRequirement:
             msg_version = (
                 f"wrong format for package requirement string, "
+                f"passed via packages argument of _check_soft_dependencies, "
                 f'must be PEP 440 compatible requirement string, e.g., "pandas"'
                 f' or "pandas>1.1", but found {package!r}'
             )
@@ -118,20 +139,23 @@ def _check_soft_dependencies(
                 pkg_ref = import_module(package_import_name)
         # if package cannot be imported, make the user aware of installation requirement
         except ModuleNotFoundError as e:
-            msg = (
-                f"{e}. "
-                f"{class_name} requires package {package!r} to be present "
-                f"in the python environment, but {package!r} was not found. "
-            )
-            if obj is not None:
+            if msg is None:
+                msg = (
+                    f"{e}. "
+                    f"{class_name} requires package {package!r} to be present "
+                    f"in the python environment, but {package!r} was not found. "
+                )
+                if obj is not None:
+                    msg = msg + (
+                        f"{package!r} is a dependency of {class_name} and required "
+                        f"to construct it. "
+                    )
                 msg = msg + (
-                    f"{package!r} is a dependency of {class_name} and required "
-                    f"to construct it. "
+                    f"Please run: `pip install {package}` to "
+                    f"install the {package} package. "
                 )
-            msg = msg + (
-                f"Please run: `pip install {package}` to "
-                f"install the {package} package. "
-            )
+            # if msg is not None, none of the above is executed,
+            # so if msg is passed it overrides the default messages
 
             if severity == "error":
                 raise ModuleNotFoundError(msg) from e
@@ -227,10 +251,14 @@ def _check_python_version(obj, package=None, msg=None, severity="error"):
     if sys_version in est_specifier:
         return True
     # now we know that est_version is not compatible with sys_version
+    if isclass(obj):
+        class_name = obj.__name__
+    else:
+        class_name = type(obj).__name__
 
     if not isinstance(msg, str):
         msg = (
-            f"{type(obj).__name__} requires python version to be {est_specifier},"
+            f"{class_name} requires python version to be {est_specifier},"
             f" but system python version is {sys.version}."
         )
 
@@ -251,3 +279,67 @@ def _check_python_version(obj, package=None, msg=None, severity="error"):
             f'argument must be "error", "warning", or "none", found {severity!r}.'
         )
     return True
+
+
+def _check_estimator_deps(obj, msg=None, severity="error"):
+    """Check if object/estimator's package & python requirements are met by python env.
+
+    Convenience wrapper around `_check_python_version` and `_check_soft_dependencies`,
+    checking against estimator tags `"python_version"`, `"python_dependencies"`.
+
+    Checks whether dependency requirements of `BaseObject`-s in `obj`
+    are satisfied by the current python environment.
+
+    Parameters
+    ----------
+    obj : `BaseObject` descendant, instance or class, or list/tuple thereof
+        object(s) that this function checks compatibility of, with the python env
+    msg : str, optional, default = default message (msg below)
+        error message to be returned in the `ModuleNotFoundError`, overrides default
+    severity : str, "error" (default), "warning", or "none"
+        behaviour for raising errors or warnings
+        "error" - raises a `ModuleNotFoundError` if environment is incompatible
+        "warning" - raises a warning if environment is incompatible
+            function returns False if environment is incompatible, otherwise True
+        "none" - does not raise exception or warning
+            function returns False if environment is incompatible, otherwise True
+
+    Returns
+    -------
+    compatible : bool, whether `obj` is compatible with python environment
+        False is returned only if no exception is raised by the function
+        checks for python version using the python_version tag of obj
+        checks for soft dependencies present using the python_dependencies tag of obj
+        if `obj` contains multiple `BaseObject`-s, checks whether all are compatible
+
+    Raises
+    ------
+    ModuleNotFoundError
+        User friendly error if obj has python_version tag that is
+        incompatible with the system python version.
+        Compatible python versions are determined by the "python_version" tag of obj.
+        User friendly error if obj has package dependencies that are not satisfied.
+        Packages are determined based on the "python_dependencies" tag of obj.
+    """
+    compatible = True
+
+    # if list or tuple, recurse & iterate over element, and return conjunction
+    if isinstance(obj, (list, tuple)):
+        for x in obj:
+            x_chk = _check_estimator_deps(x, msg=msg, severity=severity)
+            compatible = compatible and x_chk
+        return compatible
+
+    compatible = compatible and _check_python_version(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
+        )
+        compatible = compatible and pkg_deps_ok
+
+    return compatible

skbase/utils/tests/test_deep_equals.py

@@ -23,6 +23,7 @@ if _check_soft_dependencies("numpy", severity="none"):
     EXAMPLES += [
         np.array([2, 3, 4]),
         np.array([2, 4, 5]),
+        np.array([2, 4, 5, 4]),
         np.nan,
         # these cases test that plugins are passed to recursions
         # in this case, the numpy equality plugin
@@ -31,6 +32,7 @@ if _check_soft_dependencies("numpy", severity="none"):
         # test case to cover branch re dtype and equal_nan
         np.array([0.1, 1], dtype="object"),
         np.array([0.2, 1], dtype="object"),
+        np.array([0.2, 1, 4], dtype="object"),
     ]
 
 if _check_soft_dependencies("pandas", severity="none"):
@@ -39,12 +41,14 @@ if _check_soft_dependencies("pandas", severity="none"):
     EXAMPLES += [
         pd.DataFrame({"a": [4, 2]}),
         pd.DataFrame({"a": [4, 3]}),
+        pd.DataFrame({"a": [4, 3, 5]}),
         pd.DataFrame({"a": ["4", "3"]}),
         (np.array([1, 2, 4]), [pd.DataFrame({"a": [4, 2]})]),
         {"foo": [42], "bar": pd.Series([1, 2])},
         {"bar": [42], "foo": pd.Series([1, 2])},
         pd.Index([1, 2, 3]),
         pd.Index([2, 3, 4]),
+        pd.Index([2, 3, 4, 6]),
     ]
 
     # nested DataFrame example