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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scikit-base
-Version: 0.10.0
+Version: 0.11.0
 Summary: Base classes for sklearn-like parametric objects
 Author-email: sktime developers <sktime.toolbox@gmail.com>
 Maintainer: Franz Király
@@ -55,7 +55,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
-Requires-Python: <3.13,>=3.8
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: all_extras
@@ -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.10.0 is now available. Check out our
+:rocket: Version 0.11.0 is now available. Check out our
 [release notes](https://skbase.readthedocs.io/en/latest/changelog.html).
 
 | Overview | |

{scikit_base-0.10.0.dist-info → scikit_base-0.11.0.dist-info}/RECORD

@@ -1,16 +1,16 @@
 docs/source/conf.py,sha256=kFc-4qkb0ZGD5cDej5KPJhMePp9kpVu6ZqFoF0fgovg,9951
-skbase/__init__.py,sha256=ijKJmq7q7n8M2vBZeg6CArqqmb0nQw4HRzDkH7qfgGo,346
-skbase/_exceptions.py,sha256=KXfcVa7Xit-w-Xs_qFSJOEa_Mfp1oJeiHEC3v4Z0h1Q,1112
+skbase/__init__.py,sha256=3ZfMbj4QCdGwbCtma3Y0qaEtFcDdYFMtXBFOqZRIJY8,346
+skbase/_exceptions.py,sha256=asAhMbBeMwRBU_HDPFzwVCz8sb9_itG_6JVq3v_RZv8,1100
 skbase/_nopytest_tests.py,sha256=npL5pibSgCpulEGw0NqLKcG0majh6xcdW5A4Zibf78s,1077
 skbase/base/__init__.py,sha256=5ZLlwJeyfKDA1lAylBJgZd3t5JY25xsgQB4waQnroa8,751
-skbase/base/_base.py,sha256=g1_FoVzGIehmDyZxHZYzNxCXs3ouaxCKBenFhmiWBSY,57547
+skbase/base/_base.py,sha256=T4Cy3Fu3q3GARVImbwNZCCrObAreWB2u5icllcDp0E4,69090
 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=jvng-RT2JH4RElJkYBNdfu-lRKzlqZeBgqsNl2kNDKM,11677
 skbase/base/_pretty_printing/_pprint.py,sha256=VVnw-cywGxArfiFfVWfFSV5VMJvsxpDsJJ4RplcndqA,15634
 skbase/base/_pretty_printing/tests/__init__.py,sha256=rakHMQAO1NfuMabw-VsqVA9Jd1YQyuSop-Oc3tgc4w0,77
-skbase/base/_pretty_printing/tests/test_pprint.py,sha256=8_CFX9v41ZA-aWkAxm9UZSWcOaXt-u1sLwsNPZOSL24,731
+skbase/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/tests/__init__.py,sha256=MVqGlWsUV-gQ4qzW_TqE3UmKO9IQ9mwdDlsIHaGt3bc,68
@@ -22,7 +22,7 @@ skbase/testing/utils/_conditional_fixtures.py,sha256=QwI7K28Lsy6RAkDP94goo8uWWvM
 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=kIhBDcTajAvrOh_BNX8gNuwDWhhGPc-jV6qGE5JPAUk,50827
+skbase/tests/test_base.py,sha256=TjJ8m3jeeBJUs_rMpfdGetC1eCHDlCb1UgfkLh7pEYI,50857
 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
@@ -45,7 +45,7 @@ skbase/utils/dependencies/tests/__init__.py,sha256=UqE6wenG-HffjT2Z974OLzmXG-M8P
 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=kYR-wRvc_GGdlCwZPPlUL1NvUzJKIvpWTa3Hk8rdQZA,3985
+skbase/utils/tests/test_deep_equals.py,sha256=WdWpaUPi8m_kzP2IbQcPdfWmerEDVd-AaBuGiG_aPcE,3848
 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 +57,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=oIysbDxRlbBMcCOrDMW6MM6VqhhMWJxNP6NO9Id9Q5g,14133
-scikit_base-0.10.0.dist-info/LICENSE,sha256=W2h8EYZ_G_mvCmCmXTTYqv66QF5NgSMbzLYJdk8qHVg,1525
-scikit_base-0.10.0.dist-info/METADATA,sha256=CHSh6Vqbx4uvBeqURw1_3Qoy7zc9UuG2X-87fPZoLdU,8484
-scikit_base-0.10.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-scikit_base-0.10.0.dist-info/top_level.txt,sha256=FbRMsZcP-O6pMLGZpxA5pQ-ClfRzoB6Yr-hTViYqwT0,57
-scikit_base-0.10.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-scikit_base-0.10.0.dist-info/RECORD,,
+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,,

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.10.0"
+__version__: str = "0.11.0"

skbase/_exceptions.py

@@ -21,11 +21,10 @@ class FixtureGenerationError(Exception):
 class NotFittedError(ValueError, AttributeError):
     """Exception class to raise if estimator is used before fitting.
 
-    This class inherits from both ValueError and AttributeError to help with
+    This class inherits from both ``ValueError`` and ``AttributeError`` to help with
     exception handling.
 
     References
     ----------
-    [1] scikit-learn's NotFittedError
-    [2] sktime's NotFittedError
+    .. [1] Based on scikit-learn's NotFittedError
     """

skbase/base/_base.py

@@ -89,10 +89,11 @@ class BaseObject(_FlagManager):
     def __eq__(self, other):
         """Equality dunder. Checks equal class and parameters.
 
-        Returns True iff result of get_params(deep=False)
+        Returns True iff result of ``get_params(deep=False)``
         results in equal parameter sets.
 
-        Nested BaseObject descendants from get_params are compared via __eq__ as well.
+        Nested BaseObject descendants from ``get_params`` are compared via
+        ``__eq__`` as well.
         """
         from skbase.utils.deep_equals import deep_equals
 
@@ -107,24 +108,33 @@ class BaseObject(_FlagManager):
     def reset(self):
         """Reset the object to a clean post-init state.
 
-        Using reset, runs __init__ with current values of hyper-parameters
-        (result of get_params). This Removes any object attributes, except:
+        Results in setting ``self`` to the state it had directly
+        after the constructor call, with the same hyper-parameters.
+        Config values set by ``set_config`` are also retained.
 
-            - hyper-parameters = arguments of __init__
-            - object attributes containing double-underscores, i.e., the string "__"
+        A ``reset`` call deletes any object attributes, except:
+
+        - hyper-parameters = arguments of ``__init__`` written to ``self``,
+          e.g., ``self.paramname`` where ``paramname`` is an argument of ``__init__``
+        - object attributes containing double-underscores, i.e., the string "__".
+          For instance, an attribute named "__myattr" is retained.
+        - config attributes, configs are retained without change.
+          That is, results of ``get_config`` before and after ``reset`` are equal.
 
         Class and object methods, and class attributes are also unaffected.
 
+        Equivalent to ``clone``, with the exception that ``reset``
+        mutates ``self`` instead of returning a new object.
+
+        After a ``self.reset()`` call,
+        ``self`` is equal in value and state, to the object obtained after
+        a constructor call``type(self)(**self.get_params(deep=False))``.
+
         Returns
         -------
         self
             Instance of class reset to a clean post-init state but retaining
             the current hyper-parameter values.
-
-        Notes
-        -----
-        Equivalent to sklearn.clone but overwrites self. After self.reset()
-        call, self is equal in value to `type(self)(**self.get_params(deep=False))`
         """
         # retrieve parameters to copy them later
         params = self.get_params(deep=False)
@@ -149,13 +159,21 @@ class BaseObject(_FlagManager):
         A clone is a different object without shared references, in post-init state.
         This function is equivalent to returning ``sklearn.clone`` of ``self``.
 
+        Equivalent to constructing a new instance of ``type(self)``, with
+        parameters of ``self``, that is,
+        ``type(self)(**self.get_params(deep=False))``.
+
+        If configs were set on ``self``, the clone will also have the same configs
+        as the original,
+        equivalent to calling ``cloned_self.set_config(**self.get_config())``.
+
+        Also equivalent in value to a call of ``self.reset``,
+        with the exception that ``clone`` returns a new object,
+        instead of mutating ``self`` like ``reset``.
+
         Raises
         ------
         RuntimeError if the clone is non-conforming, due to faulty ``__init__``.
-
-        Notes
-        -----
-        If successful, equal in value to ``type(self)(**self.get_params(deep=False))``.
         """
         self_clone = _clone(self)
         if self.get_config()["check_clone"]:
@@ -175,7 +193,7 @@ class BaseObject(_FlagManager):
 
         Raises
         ------
-        RuntimeError if cls has varargs in __init__.
+        RuntimeError if ``cls`` has varargs in ``__init__``.
         """
         # fetch the constructor or the original constructor before
         # deprecation wrapping if any
@@ -218,7 +236,7 @@ class BaseObject(_FlagManager):
         Returns
         -------
         param_names: list[str]
-            List of parameter names of cls.
+            List of parameter names of ``cls``.
             If ``sort=False``, in same order as they appear in the class ``__init__``.
             If ``sort=True``, alphabetically ordered.
         """
@@ -238,8 +256,9 @@ class BaseObject(_FlagManager):
         Returns
         -------
         default_dict: dict[str, Any]
-            Keys are all parameters of cls that have a default defined in __init__
-            values are the defaults, as defined in __init__.
+            Keys are all parameters of ``cls`` that have
+            a default defined in ``__init__``.
+            Values are the defaults, as defined in ``__init__``.
         """
         parameters = cls._get_init_signature()
         default_dict = {
@@ -255,9 +274,11 @@ class BaseObject(_FlagManager):
         deep : bool, default=True
             Whether to return parameters of components.
 
-            * If True, will return a dict of parameter name : value for this object,
-              including parameters of components (= BaseObject-valued parameters).
-            * If False, will return a dict of parameter name : value for this object,
+            * If ``True``, will return a ``dict`` of
+              parameter name : value for this object,
+              including parameters of components (= ``BaseObject``-valued parameters).
+            * If ``False``, will return a ``dict``
+              of parameter name : value for this object,
               but not include parameters of components.
 
         Returns
@@ -266,14 +287,14 @@ class BaseObject(_FlagManager):
             Dictionary of parameters, paramname : paramvalue
             keys-value pairs include:
 
-            * always: all parameters of this object, as via `get_param_names`
+            * always: all parameters of this object, as via ``get_param_names``
               values are parameter value for that key, of this object
               values are always identical to values passed at construction
-            * if `deep=True`, also contains keys/value pairs of component parameters
-              parameters of components are indexed as `[componentname]__[paramname]`
-              all parameters of `componentname` appear as `paramname` with its value
-            * if `deep=True`, also contains arbitrary levels of component recursion,
-              e.g., `[componentname]__[componentcomponentname]__[paramname]`, etc
+            * if ``deep=True``, also contains keys/value pairs of component parameters
+              parameters of components are indexed as ``[componentname]__[paramname]``
+              all parameters of ``componentname`` appear as ``paramname`` with its value
+            * if ``deep=True``, also contains arbitrary levels of component recursion,
+              e.g., ``[componentname]__[componentcomponentname]__[paramname]``, etc
         """
         params = {key: getattr(self, key) for key in self.get_param_names()}
 
@@ -302,7 +323,7 @@ class BaseObject(_FlagManager):
         ----------
         **params : dict
             BaseObject parameters, keys must be ``<component>__<parameter>`` strings.
-            __ suffixes can alias full strings, if unique among get_params keys.
+            ``__`` suffixes can alias full strings, if unique among get_params keys.
 
         Returns
         -------
@@ -375,16 +396,18 @@ class BaseObject(_FlagManager):
         ------
         alias_dict: dict with str keys, all keys in valid_params
             values are as in d, with keys replaced by following rule:
-            If key is a __ suffix of exactly one key in valid_params,
-                it is replaced by that key. Otherwise an exception is raised.
-            A __ suffix of a str is any str obtained as suffix from partition by __.
-            Else, i.e., if key is in valid_params or not a __ suffix,
-            the key is replaced by itself, i.e., left unchanged.
+
+            * If key is a ``__`` suffix of exactly one key in ``valid_params``,
+              it is replaced by that key. Otherwise an exception is raised.
+            * A ``__``-suffix of a ``str`` is any ``str`` obtained as suffix
+              from partition by the string ``"__"``.
+              Else, i.e., if key is in valid_params or not a ``__``-suffix,
+              the key is replaced by itself, i.e., left unchanged.
 
         Raises
         ------
-        ValueError if at least one key of d is neither contained in valid_params,
-            nor is it a __ suffix of exactly one key in valid_params
+        ValueError if at least one key of d is neither contained in ``valid_params``,
+            nor is it a ``__``-suffix of exactly one key in ``valid_params``
         """
 
         def _is_suffix(x, y):
@@ -419,39 +442,92 @@ class BaseObject(_FlagManager):
 
     @classmethod
     def get_class_tags(cls):
-        """Get class tags from the class and all its parent classes.
+        """Get class tags from class, with tag level inheritance from parent classes.
 
-        Retrieves tag: value pairs from _tags class attribute. Does not return
-        information from dynamic tags (set via set_tags or clone_tags)
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        The ``get_class_tags`` method is a class method,
+        and retrieves the value of a tag
+        taking into account only class-level tag values and overrides.
+
+        It returns a dictionary with keys being keys of any attribute of ``_tags``
+        set in the class or any of its parent classes.
+
+        Values are the corresponding tag values, with overrides in the following
+        order of descending priority:
+
+        1. Tags set in the ``_tags`` attribute of the class.
+        2. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
+
+        Instances can override these tags depending on hyper-parameters.
+
+        To retrieve tags with potential instance overrides, use
+        the ``get_tags`` method instead.
+
+        Does not take into account dynamic tag overrides on instances,
+        set via ``set_tags`` or ``clone_tags``,
         that are defined on instances.
 
+        For including overrides from dynamic tags, use ``get_tags``.
+
         Returns
         -------
         collected_tags : dict
-            Dictionary of class tag name: tag value pairs. Collected from _tags
-            class attribute via nested inheritance.
+            Dictionary of tag name : tag value pairs. Collected from ``_tags``
+            class attribute via nested inheritance. NOT overridden by dynamic
+            tags set by ``set_tags`` or ``clone_tags``.
         """
         return cls._get_class_flags(flag_attr_name="_tags")
 
     @classmethod
     def get_class_tag(cls, tag_name, tag_value_default=None):
-        """Get a class tag's value.
+        """Get class tag value from class, with tag level inheritance from parents.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
 
-        Does not return information from dynamic tags (set via set_tags or clone_tags)
+        The ``get_class_tag`` method is a class method, and retrieves the value of a tag
+        taking into account only class-level tag values and overrides.
+
+        It returns the value of the tag with name ``tag_name`` from the object,
+        taking into account tag overrides, in the following
+        order of descending priority:
+
+        1. Tags set in the ``_tags`` attribute of the class.
+        2. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
+
+        Does not take into account dynamic tag overrides on instances,
+        set via ``set_tags`` or ``clone_tags``,
         that are defined on instances.
 
+        To retrieve tag values with potential instance overrides, use
+        the ``get_tag`` method instead.
+
         Parameters
         ----------
         tag_name : str
             Name of tag value.
-        tag_value_default : any
+        tag_value_default : any type
             Default/fallback value if tag is not found.
 
         Returns
         -------
         tag_value :
-            Value of the `tag_name` tag in self. If not found, returns
-            `tag_value_default`.
+            Value of the ``tag_name`` tag in ``self``.
+            If not found, returns ``tag_value_default``.
         """
         return cls._get_class_flag(
             flag_name=tag_name,
@@ -460,19 +536,60 @@ class BaseObject(_FlagManager):
         )
 
     def get_tags(self):
-        """Get tags from skbase class and dynamic tag overrides.
+        """Get tags from instance, with tag level inheritance and overrides.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        The ``get_tags`` method returns a dictionary of tags,
+        with keys being keys of any attribute of ``_tags``
+        set in the class or any of its parent classes, or tags set via ``set_tags``
+        or ``clone_tags``.
+
+        Values are the corresponding tag values, with overrides in the following
+        order of descending priority:
+
+        1. Tags set via ``set_tags`` or ``clone_tags`` on the instance,
+          at construction of the instance.
+        2. Tags set in the ``_tags`` attribute of the class.
+        3. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
 
         Returns
         -------
         collected_tags : dict
-            Dictionary of tag name : tag value pairs. Collected from _tags
+            Dictionary of tag name : tag value pairs. Collected from ``_tags``
             class attribute via nested inheritance and then any overrides
-            and new tags from _tags_dynamic object attribute.
+            and new tags from ``_tags_dynamic`` object attribute.
         """
         return self._get_flags(flag_attr_name="_tags")
 
     def get_tag(self, tag_name, tag_value_default=None, raise_error=True):
-        """Get tag value from object class and dynamic tag overrides.
+        """Get tag value from instance, with tag level inheritance and overrides.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        The ``get_tag`` method retrieves the value of a single tag
+        with name ``tag_name`` from the instance,
+        taking into account tag overrides, in the following
+        order of descending priority:
+
+        1. Tags set via ``set_tags`` or ``clone_tags`` on the instance,
+          at construction of the instance.
+        2. Tags set in the ``_tags`` attribute of the class.
+        3. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
 
         Parameters
         ----------
@@ -481,18 +598,20 @@ class BaseObject(_FlagManager):
         tag_value_default : any type, optional; default=None
             Default/fallback value if tag is not found
         raise_error : bool
-            whether a ValueError is raised when the tag is not found
+            whether a ``ValueError`` is raised when the tag is not found
 
         Returns
         -------
         tag_value : Any
-            Value of the `tag_name` tag in self. If not found, returns an error if
-            `raise_error` is True, otherwise it returns `tag_value_default`.
+            Value of the ``tag_name`` tag in ``self``.
+            If not found, raises an error if
+            ``raise_error`` is True, otherwise it returns ``tag_value_default``.
 
         Raises
         ------
-        ValueError if raise_error is True i.e. if `tag_name` is not in
-        self.get_tags().keys()
+        ValueError, if ``raise_error`` is ``True``.
+            The ``ValueError`` is then raised if ``tag_name`` is
+            not in ``self.get_tags().keys()``.
         """
         return self._get_flag(
             flag_name=tag_name,
@@ -502,7 +621,25 @@ class BaseObject(_FlagManager):
         )
 
     def set_tags(self, **tag_dict):
-        """Set dynamic tags to given values.
+        """Set instance level tag overrides to given values.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        ``set_tags`` sets dynamic tag overrides
+        to the values as specified in ``tag_dict``, with keys being the tag name,
+        and dict values being the value to set the tag to.
+
+        The ``set_tags`` method
+        should be called only in the ``__init__`` method of an object,
+        during construction, or directly after construction via ``__init__``.
+
+        Current tag values can be inspected by ``get_tags`` or ``get_tag``.
 
         Parameters
         ----------
@@ -513,10 +650,6 @@ class BaseObject(_FlagManager):
         -------
         Self
             Reference to self.
-
-        Notes
-        -----
-        Changes object state by setting tag values in tag_dict as dynamic tags in self.
         """
         self._set_flags(flag_attr_name="_tags", **tag_dict)
 
@@ -525,22 +658,39 @@ class BaseObject(_FlagManager):
     def clone_tags(self, estimator, tag_names=None):
         """Clone tags from another object as dynamic override.
 
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        ``clone_tags`` sets dynamic tag overrides
+        from another object, ``estimator``.
+
+        The ``clone_tags`` method
+        should be called only in the ``__init__`` method of an object,
+        during construction, or directly after construction via ``__init__``.
+
+        The dynamic tags are set to the values of the tags in ``estimator``,
+        with the names specified in ``tag_names``.
+
+        The default of ``tag_names`` writes all tags from ``estimator`` to ``self``.
+
+        Current tag values can be inspected by ``get_tags`` or ``get_tag``.
+
         Parameters
         ----------
         estimator : An instance of :class:BaseObject or derived class
         tag_names : str or list of str, default = None
-            Names of tags to clone. If None then all tags in estimator are used
-            as `tag_names`.
+            Names of tags to clone.
+            The default (``None``) clones all tags from ``estimator``.
 
         Returns
         -------
-        Self :
-            Reference to self.
-
-        Notes
-        -----
-        Changes object state by setting tag values in tag_set from estimator as
-        dynamic tags in self.
+        self :
+            Reference to ``self``.
         """
         self._clone_flags(
             estimator=estimator, flag_names=tag_names, flag_attr_name="_tags"
@@ -551,6 +701,17 @@ class BaseObject(_FlagManager):
     def get_config(self):
         """Get config flags for self.
 
+        Configs are key-value pairs of ``self``,
+        typically used as transient flags for controlling behaviour.
+
+        ``get_config`` returns dynamic configs, which override the default configs.
+
+        Default configs are set in the class attribute ``_config`` of
+        the class or its parent classes,
+        and are overridden by dynamic configs set via ``set_config``.
+
+        Configs are retained under ``clone`` or ``reset`` calls.
+
         Returns
         -------
         config_dict : dict
@@ -563,6 +724,17 @@ class BaseObject(_FlagManager):
     def set_config(self, **config_dict):
         """Set config flags to given values.
 
+        Configs are key-value pairs of ``self``,
+        typically used as transient flags for controlling behaviour.
+
+        ``set_config`` sets dynamic configs, which override the default configs.
+
+        Default configs are set in the class attribute ``_config`` of
+        the class or its parent classes,
+        and are overridden by dynamic configs set via ``set_config``.
+
+        Configs are retained under ``clone`` or ``reset`` calls.
+
         Parameters
         ----------
         config_dict : dict
@@ -584,6 +756,21 @@ class BaseObject(_FlagManager):
     def get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the skbase object.
 
+        ``get_test_params`` is a unified interface point to store
+        parameter settings for testing purposes. This function is also
+        used in ``create_test_instance`` and ``create_test_instances_and_names``
+        to construct test instances.
+
+        ``get_test_params`` should return a single ``dict``, or a ``list`` of ``dict``.
+
+        Each ``dict`` is a parameter configuration for testing,
+        and can be used to construct an "interesting" test instance.
+        A call to ``cls(**params)`` should
+        be valid for all dictionaries ``params`` in the return of ``get_test_params``.
+
+        The ``get_test_params`` need not return fixed lists of dictionaries,
+        it can also return dynamic or stochastic parameter settings.
+
         Parameters
         ----------
         parameter_set : str, default="default"
@@ -630,11 +817,6 @@ class BaseObject(_FlagManager):
         -------
         instance : instance of the class with default parameters
 
-        Notes
-        -----
-        `get_test_params` can return dict or list of dict.
-        This function takes first or single dict that get_test_params returns, and
-        constructs the object with that.
         """
         if "parameter_set" in inspect.getfullargspec(cls.get_test_params).args:
             params = cls.get_test_params(parameter_set=parameter_set)
@@ -665,11 +847,11 @@ class BaseObject(_FlagManager):
         Returns
         -------
         objs : list of instances of cls
-            i-th instance is cls(**cls.get_test_params()[i])
+            i-th instance is ``cls(**cls.get_test_params()[i])``
         names : list of str, same length as objs
-            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__}
+            i-th element is name of i-th instance of obj in tests.
+            The naming convention is ``{cls.__name__}-{i}`` if more than one instance,
+            otherwise ``{cls.__name__}``
         """
         if "parameter_set" in inspect.getfullargspec(cls.get_test_params).args:
             param_list = cls.get_test_params(parameter_set=parameter_set)
@@ -760,7 +942,7 @@ class BaseObject(_FlagManager):
         -------
         composite: bool
             Whether an object has any parameters whose values
-            are BaseObjects.
+            are ``BaseObject`` descendant instances.
         """
         # walk through method resolution order and inspect methods
         #   of classes and direct parents, "adjacent" classes in mro
@@ -772,7 +954,7 @@ class BaseObject(_FlagManager):
     def _components(self, base_class=None):
         """Return references to all state changing BaseObject type attributes.
 
-        This *excludes* the blue-print-like components passed in the __init__.
+        This *excludes* the blue-print-like components passed in the ``__init__``.
 
         Caution: this method returns *references* and not *copies*.
             Writing to the reference will change the respective attribute of self.
@@ -780,7 +962,7 @@ class BaseObject(_FlagManager):
         Parameters
         ----------
         base_class : class, optional, default=None, must be subclass of BaseObject
-            if not None, sub-sets return dict to only descendants of base_class
+            if not ``None``, sub-sets return dict to only descendants of ``base_class``
 
         Returns
         -------
@@ -990,26 +1172,43 @@ class TagAliaserMixin:
     def get_class_tags(cls):
         """Get class tags from class, with tag level inheritance from parent classes.
 
-        Every ``scikit-base`` compatible class has a set of tags,
-        which are used to store metadata about the object.
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
 
-        This is a class method, and retrieves tags applicable to the class,
-        with tag level overrides in the following order of decreasing priority:
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
 
-        1. class tags of the class, of which the object is an instance
-        2. class tags of all parent classes, in method resolution order
+        The ``get_class_tags`` method is a class method,
+        and retrieves the value of a tag
+        taking into account only class-level tag values and overrides.
+
+        It returns a dictionary with keys being keys of any attribute of ``_tags``
+        set in the class or any of its parent classes.
+
+        Values are the corresponding tag values, with overrides in the following
+        order of descending priority:
+
+        1. Tags set in the ``_tags`` attribute of the class.
+        2. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
 
         Instances can override these tags depending on hyper-parameters.
 
         To retrieve tags with potential instance overrides, use
         the ``get_tags`` method instead.
 
-        Returns
-        -------
+        Does not take into account dynamic tag overrides on instances,
+        set via ``set_tags`` or ``clone_tags``,
+        that are defined on instances.
+
+        For including overrides from dynamic tags, use ``get_tags``.
+
         collected_tags : dict
-            Dictionary of tag name : tag value pairs. Collected from _tags
+            Dictionary of tag name : tag value pairs. Collected from ``_tags``
             class attribute via nested inheritance. NOT overridden by dynamic
-            tags set by set_tags or mirror_tags.
+            tags set by ``set_tags`` or ``clone_tags``.
         """
         collected_tags = super(TagAliaserMixin, cls).get_class_tags()
         collected_tags = cls._complete_dict(collected_tags)
@@ -1019,17 +1218,24 @@ class TagAliaserMixin:
     def get_class_tag(cls, tag_name, tag_value_default=None):
         """Get class tag value from class, with tag level inheritance from parents.
 
-        Every ``scikit-base`` compatible class has a set of tags,
+        Every ``scikit-base`` compatible object has a dictionary of tags,
         which are used to store metadata about the object.
 
-        This is a class method, and retrieves the value of a tag applicable
-        to the class,
-        with tag level overrides in the following order of decreasing priority:
+        The ``get_class_tag`` method is a class method,
+        and retrieves the value of a tag
+        taking into account only class-level tag values and overrides.
 
-        1. class tags of the class, of which the object is an instance
-        2. class tags of all parent classes, in method resolution order
+        It returns the value of the tag with name ``tag_name`` from the object,
+        taking into account tag overrides, in the following
+        order of descending priority:
 
-        Instances can override these tags depending on hyper-parameters.
+        1. Tags set in the ``_tags`` attribute of the class.
+        2. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
+
+        Does not take into account dynamic tag overrides on instances,
+        set via ``set_tags`` or ``clone_tags``,
+        that are defined on instances.
 
         To retrieve tag values with potential instance overrides, use
         the ``get_tag`` method instead.
@@ -1044,8 +1250,8 @@ class TagAliaserMixin:
         Returns
         -------
         tag_value :
-            Value of the `tag_name` tag in self. If not found, returns
-            `tag_value_default`.
+            Value of the ``tag_name`` tag in ``self``.
+            If not found, returns ``tag_value_default``.
         """
         cls._deprecate_tag_warn([tag_name])
         return super(TagAliaserMixin, cls).get_class_tag(
@@ -1055,22 +1261,34 @@ class TagAliaserMixin:
     def get_tags(self):
         """Get tags from instance, with tag level inheritance and overrides.
 
-        Every ``scikit-base`` compatible object has a set of tags,
-        which are used to store metadata about the object.
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
 
-        This method retrieves all tags as a dictionary, with tag level overrides in the
-        following order of decreasing priority:
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
 
-        1. dynamic tags set at construction, e.g., dependent on hyper-parameters
-        2. class tags of the class, of which the object is an instance
-        3. class tags of all parent classes, in method resolution order
+        The ``get_tags`` method returns a dictionary of tags,
+        with keys being keys of any attribute of ``_tags``
+        set in the class or any of its parent classes, or tags set via ``set_tags``
+        or ``clone_tags``.
+
+        Values are the corresponding tag values, with overrides in the following
+        order of descending priority:
+
+        1. Tags set via ``set_tags`` or ``clone_tags`` on the instance,
+          at construction of the instance.
+        2. Tags set in the ``_tags`` attribute of the class.
+        3. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
 
         Returns
         -------
         collected_tags : dict
-            Dictionary of tag name : tag value pairs. Collected from _tags
+            Dictionary of tag name : tag value pairs. Collected from ``_tags``
             class attribute via nested inheritance and then any overrides
-            and new tags from _tags_dynamic object attribute.
+            and new tags from ``_tags_dynamic`` object attribute.
         """
         collected_tags = super(TagAliaserMixin, self).get_tags()
         collected_tags = self._complete_dict(collected_tags)
@@ -1079,15 +1297,24 @@ class TagAliaserMixin:
     def get_tag(self, tag_name, tag_value_default=None, raise_error=True):
         """Get tag value from instance, with tag level inheritance and overrides.
 
-        Every ``scikit-base`` compatible object has a set of tags,
-        which are used to store metadata about the object.
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
 
-        This method retrieves the value of a single tag, with tag level overrides in the
-        following order of decreasing priority:
+        The ``get_tag`` method retrieves the value of a single tag
+        with name ``tag_name`` from the instance,
+        taking into account tag overrides, in the following
+        order of descending priority:
 
-        1. dynamic tags set at construction, e.g., dependent on hyper-parameters
-        2. class tags of the class, of which the object is an instance
-        3. class tags of all parent classes, in method resolution order
+        1. Tags set via ``set_tags`` or ``clone_tags`` on the instance,
+          at construction of the instance.
+        2. Tags set in the ``_tags`` attribute of the class.
+        3. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
 
         Parameters
         ----------
@@ -1096,18 +1323,20 @@ class TagAliaserMixin:
         tag_value_default : any type, optional; default=None
             Default/fallback value if tag is not found
         raise_error : bool
-            whether a ValueError is raised when the tag is not found
+            whether a ``ValueError`` is raised when the tag is not found
 
         Returns
         -------
-        tag_value :
-            Value of the `tag_name` tag in self. If not found, returns an error if
-            raise_error is True, otherwise it returns `tag_value_default`.
+        tag_value : Any
+            Value of the ``tag_name`` tag in ``self``.
+            If not found, raises an error if
+            ``raise_error`` is True, otherwise it returns ``tag_value_default``.
 
         Raises
         ------
-        ValueError if raise_error is True i.e. if tag_name is not in self.get_tags(
-        ).keys()
+        ValueError, if ``raise_error`` is ``True``.
+            The ``ValueError`` is then raised if ``tag_name`` is
+            not in ``self.get_tags().keys()``.
         """
         self._deprecate_tag_warn([tag_name])
         return super(TagAliaserMixin, self).get_tag(
@@ -1117,22 +1346,35 @@ class TagAliaserMixin:
         )
 
     def set_tags(self, **tag_dict):
-        """Set dynamic tags to given values.
+        """Set instance level tag overrides to given values.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags,
+        which are used to store metadata about the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object. They may be used for metadata inspection,
+        or for controlling behaviour of the object.
+
+        ``set_tags`` sets dynamic tag overrides
+        to the values as specified in ``tag_dict``, with keys being the tag name,
+        and dict values being the value to set the tag to.
+
+        The ``set_tags`` method
+        should be called only in the ``__init__`` method of an object,
+        during construction, or directly after construction via ``__init__``.
+
+        Current tag values can be inspected by ``get_tags`` or ``get_tag``.
 
         Parameters
         ----------
-        tag_dict : dict
-            Dictionary of tag name : tag value pairs.
+        **tag_dict : dict
+            Dictionary of tag name: tag value pairs.
 
         Returns
         -------
-        Self :
+        Self
             Reference to self.
-
-        Notes
-        -----
-        Changes object state by setting tag values in tag_dict as dynamic tags
-        in self.
         """
         self._deprecate_tag_warn(tag_dict.keys())
 
@@ -1203,13 +1445,13 @@ class BaseEstimator(BaseObject):
     def __init__(self):
         """Construct BaseEstimator."""
         self._is_fitted = False
-        super(BaseEstimator, self).__init__()
+        super().__init__()
 
     @property
     def is_fitted(self):
-        """Whether `fit` has been called.
+        """Whether ``fit`` has been called.
 
-        Inspects object's `_is_fitted` attribute that should initialize to False
+        Inspects object's ``_is_fitted` attribute that should initialize to ``False``
         during object construction, and be set to True in calls to an object's
         `fit` method.
 
@@ -1218,14 +1460,25 @@ class BaseEstimator(BaseObject):
         bool
             Whether the estimator has been `fit`.
         """
-        return self._is_fitted
+        if hasattr(self, "_is_fitted"):
+            return self._is_fitted
+        else:
+            return False
 
-    def check_is_fitted(self):
+    def check_is_fitted(self, method_name=None):
         """Check if the estimator has been fitted.
 
-        Inspects object's `_is_fitted` attribute that should initialize to False
-        during object construction, and be set to True in calls to an object's
-        `fit` method.
+        Check if ``_is_fitted`` attribute is present and ``True``.
+        The ``is_fitted``
+        attribute should be set to ``True`` in calls to an object's ``fit`` method.
+
+        If not, raises a ``NotFittedError``.
+
+        Parameters
+        ----------
+        method_name : str, optional
+            Name of the method that called this function. If provided, the error
+            message will include this information.
 
         Raises
         ------
@@ -1233,10 +1486,17 @@ class BaseEstimator(BaseObject):
             If the estimator has not been fitted yet.
         """
         if not self.is_fitted:
-            raise NotFittedError(
-                f"This instance of {self.__class__.__name__} has not been fitted yet. "
-                f"Please call `fit` first."
-            )
+            if method_name is None:
+                msg = (
+                    f"This instance of {self.__class__.__name__} has not been fitted "
+                    f"yet. Please call `fit` first."
+                )
+            else:
+                msg = (
+                    f"This instance of {self.__class__.__name__} has not been fitted "
+                    f"yet. Please call `fit` before calling `{method_name}`."
+                )
+            raise NotFittedError(msg)
 
     def get_fitted_params(self, deep=True):
         """Get fitted parameters.
@@ -1261,19 +1521,15 @@ class BaseEstimator(BaseObject):
             Dictionary of fitted parameters, paramname : paramvalue
             keys-value pairs include:
 
-            * always: all fitted parameters of this object, as via `get_param_names`
+            * always: all fitted parameters of this object, as via ``get_param_names``
               values are fitted parameter value for that key, of this object
-            * if `deep=True`, also contains keys/value pairs of component parameters
-              parameters of components are indexed as `[componentname]__[paramname]`
-              all parameters of `componentname` appear as `paramname` with its value
-            * if `deep=True`, also contains arbitrary levels of component recursion,
-              e.g., `[componentname]__[componentcomponentname]__[paramname]`, etc
+            * if ``deep=True``, also contains keys/value pairs of component parameters
+              parameters of components are indexed as ``[componentname]__[paramname]``
+              all parameters of ``componentname`` appear as ``paramname`` with its value
+            * if ``deep=True``, also contains arbitrary levels of component recursion,
+              e.g., ``[componentname]__[componentcomponentname]__[paramname]``, etc
         """
-        if not self.is_fitted:
-            raise NotFittedError(
-                f"estimator of type {type(self).__name__} has not been "
-                "fitted yet, please call fit on data before get_fitted_params"
-            )
+        self.check_is_fitted(method_name="get_fitted_params")
 
         # collect non-nested fitted params of self
         fitted_params = self._get_fitted_params()

skbase/base/_pretty_printing/tests/test_pprint.py

@@ -2,7 +2,10 @@
 # copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
 """Tests for skbase pretty printing functionality."""
 
+import pytest
+
 from skbase.base import BaseObject
+from skbase.utils.dependencies import _check_soft_dependencies
 
 
 class CompositionDummy(BaseObject):
@@ -15,6 +18,10 @@ class CompositionDummy(BaseObject):
         super(CompositionDummy, self).__init__()
 
 
+@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_sklearn_compatibility():
     """Test that the pretty printing functions are compatible with sklearn."""
     from sklearn.ensemble import RandomForestRegressor

skbase/tests/test_base.py

@@ -1022,7 +1022,7 @@ def test_nested_config_after_clone_tags(clone_config):
 
 
 @pytest.mark.skipif(
-    not _check_soft_dependencies("sklearn", severity="none"),
+    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]):
@@ -1037,7 +1037,7 @@ def test_clone_param_is_none(fixture_class_parent: Type[Parent]):
 
 
 @pytest.mark.skipif(
-    not _check_soft_dependencies("sklearn", severity="none"),
+    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]):
@@ -1057,7 +1057,7 @@ def test_clone_empty_array(fixture_class_parent: Type[Parent]):
 
 
 @pytest.mark.skipif(
-    not _check_soft_dependencies("sklearn", severity="none"),
+    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]):
@@ -1076,7 +1076,7 @@ def test_clone_sparse_matrix(fixture_class_parent: Type[Parent]):
 
 
 @pytest.mark.skipif(
-    not _check_soft_dependencies("sklearn", severity="none"),
+    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]):
@@ -1105,7 +1105,7 @@ def test_clone_estimator_types(fixture_class_parent: Type[Parent]):
 
 
 @pytest.mark.skipif(
-    not _check_soft_dependencies("sklearn", severity="none"),
+    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_class_rather_than_instance_raises_error(
@@ -1120,7 +1120,7 @@ def test_clone_class_rather_than_instance_raises_error(
 
 
 @pytest.mark.skipif(
-    not _check_soft_dependencies("sklearn", severity="none"),
+    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]):

skbase/utils/tests/test_deep_equals.py

@@ -71,9 +71,7 @@ if _check_soft_dependencies("pandas", severity="none"):
 
     EXAMPLES += [X]
 
-if _check_soft_dependencies(
-    "scikit-learn", package_import_alias={"scikit-learn": "sklearn"}, severity="none"
-):
+if _check_soft_dependencies("scikit-learn", severity="none"):
     from sklearn.ensemble import RandomForestRegressor
 
     EXAMPLES += [RandomForestRegressor()]
@@ -115,16 +113,12 @@ def test_deep_equals_negative(fixture1, fixture2):
 def copy_except_if_sklearn(obj):
     """Copy obj if it is not a scikit-learn estimator.
 
-    We use this functoin as deep_copy should return True for
+    We use this function as deep_copy should return True for
     identical sklearn estimators, but False for different copies.
 
     This is the current status quo, possibly we want to change this in the future.
     """
-    if not _check_soft_dependencies(
-        "scikit-learn",
-        package_import_alias={"scikit-learn": "sklearn"},
-        severity="none",
-    ):
+    if not _check_soft_dependencies("scikit-learn", severity="none"):
         return deepcopy(obj)
     else:
         from sklearn.base import BaseEstimator