scikit-base 0.3.0__py3-none-any.whl

skbase/tests/test_baseestimator.py

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Tests for BaseEstimator class.
+
+tests in this module:
+
+    test_baseestimator_inheritance - Test BaseEstimator inherits from BaseObject.
+    test_has_is_fitted - Test that BaseEstimator has is_fitted interface.
+    test_has_check_is_fitted - Test that BaseEstimator has check_is_fitted inteface.
+    test_is_fitted  - Test that is_fitted property returns _is_fitted as expected.
+    test_check_is_fitted_raises_error_when_unfitted - Test check_is_fitted raises error.
+"""
+
+__author__ = ["fkiraly", "RNKuhns"]
+import inspect
+from copy import deepcopy
+
+import pytest
+
+from skbase._exceptions import NotFittedError
+from skbase.base import BaseEstimator, BaseObject
+
+
+@pytest.fixture
+def fixture_estimator():
+    """Pytest fixture of BaseEstimator class."""
+    return BaseEstimator
+
+
+@pytest.fixture
+def fixture_estimator_instance():
+    """Pytest fixture of BaseEstimator instance."""
+    return BaseEstimator()
+
+
+def test_baseestimator_inheritance(fixture_estimator, fixture_estimator_instance):
+    """Check BaseEstimator correctly inherits from BaseObject."""
+    estimator_is_subclass_of_baseobejct = issubclass(fixture_estimator, BaseObject)
+    estimator_instance_is_baseobject_instance = isinstance(
+        fixture_estimator_instance, BaseObject
+    )
+    assert (
+        estimator_is_subclass_of_baseobejct
+        and estimator_instance_is_baseobject_instance
+    ), "`BaseEstimator` does not correctly inherit from `BaseObject`."
+
+
+def test_has_is_fitted(fixture_estimator_instance):
+    """Test BaseEstimator has `is_fitted` property."""
+    has_private_is_fitted = hasattr(fixture_estimator_instance, "_is_fitted")
+    has_is_fitted = hasattr(fixture_estimator_instance, "is_fitted")
+    assert (
+        has_private_is_fitted and has_is_fitted
+    ), "BaseEstimator does not have `is_fitted` property;"
+
+
+def test_has_check_is_fitted(fixture_estimator_instance):
+    """Test BaseEstimator has `check_is_fitted` method."""
+    has_check_is_fitted = hasattr(fixture_estimator_instance, "check_is_fitted")
+    is_method = inspect.ismethod(fixture_estimator_instance.check_is_fitted)
+    assert (
+        has_check_is_fitted and is_method
+    ), "`BaseEstimator` does not have `check_is_fitted` method."
+
+
+def test_is_fitted(fixture_estimator_instance):
+    """Test BaseEstimator `is_fitted` property returns expected value."""
+    expected_value_unfitted = (
+        fixture_estimator_instance.is_fitted == fixture_estimator_instance._is_fitted
+    )
+    assert (
+        expected_value_unfitted
+    ), "`BaseEstimator` property `is_fitted` does not return `_is_fitted` value."
+
+
+def test_check_is_fitted_raises_error_when_unfitted(fixture_estimator_instance):
+    """Test BaseEstimator `check_is_fitted` method raises an error."""
+    name = fixture_estimator_instance.__class__.__name__
+    match = f"This instance of {name} has not been fitted yet. Please call `fit` first."
+    with pytest.raises(NotFittedError, match=match):
+        fixture_estimator_instance.check_is_fitted()
+
+    fixture_estimator_instance._is_fitted = True
+    assert fixture_estimator_instance.check_is_fitted() is None
+
+
+class FittableCompositionDummy(BaseEstimator):
+    """Potentially composite object, for testing."""
+
+    def __init__(self, foo, bar=84):
+        self.foo = foo
+        self.foo_ = deepcopy(foo)
+        self.bar = bar
+
+    def fit(self):
+        """Fit, dummy."""
+        if hasattr(self.foo_, "fit"):
+            self.foo_.fit()
+        self._is_fitted = True
+
+
+def test_get_fitted_params():
+    """Tests fitted parameter retrieval.
+
+    Raises
+    ------
+    AssertionError if logic behind get_fitted_params is incorrect, logic tested:
+        calling get_fitted_params on a non-composite fittable returns the fitted param
+        calling get_fitted_params on a composite returns all nested params
+    """
+    non_composite = FittableCompositionDummy(foo=42)
+    composite = FittableCompositionDummy(foo=deepcopy(non_composite))
+
+    non_composite.fit()
+    composite.fit()
+
+    non_comp_f_params = non_composite.get_fitted_params()
+    comp_f_params = composite.get_fitted_params()
+
+    assert isinstance(non_comp_f_params, dict)
+    assert set(non_comp_f_params.keys()) == {"foo"}
+
+    assert isinstance(comp_f_params, dict)
+    assert set(comp_f_params) == {"foo", "foo__foo"}
+    assert comp_f_params["foo"] is composite.foo_
+    assert comp_f_params["foo"] is not composite.foo

skbase/tests/test_exceptions.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+"""Tests for skbase exceptions.
+
+tests in this module:
+
+    test_exceptions_raise_error - Test that skbase exceptions raise expected error.
+"""
+from typing import List
+
+import pytest
+
+from skbase._exceptions import FixtureGenerationError, NotFittedError
+
+__author__: List[str] = ["RNKuhns"]
+
+ALL_EXCEPTIONS = [FixtureGenerationError, NotFittedError]
+
+
+@pytest.mark.parametrize("skbase_exception", ALL_EXCEPTIONS)
+def test_exceptions_raise_error(skbase_exception):
+    """Test that skbase exceptions raise an error as expected."""
+    with pytest.raises(skbase_exception):
+        raise skbase_exception()

skbase/utils/__init__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Functionality used through `skbase`."""
+from typing import List
+
+from skbase.utils._nested_iter import flatten, is_flat, unflat_len, unflatten
+
+__author__: List[str] = ["RNKuhns", "fkiraly"]
+__all__: List[str] = ["flatten", "is_flat", "unflat_len", "unflatten"]

skbase/utils/_nested_iter.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Functionality for working with nested sequences."""
+from typing import List
+
+__author__: List[str] = ["RNKuhns", "fkiraly"]
+__all__: List[str] = ["flatten", "is_flat", "unflat_len", "unflatten"]
+
+
+def _remove_single(x):
+    """Remove tuple wrapping from singleton.
+
+    Parameters
+    ----------
+    x : tuple
+
+    Returns
+    -------
+    x[0] if x is a singleton, otherwise x
+    """
+    if len(x) == 1:
+        return x[0]
+    else:
+        return x
+
+
+def flatten(obj):
+    """Flatten nested list/tuple structure.
+
+    Parameters
+    ----------
+    obj: nested list/tuple structure
+
+    Returns
+    -------
+    list or tuple, tuple if obj was tuple, list otherwise
+        flat iterable, containing non-list/tuple elements in obj in same order as in obj
+
+    Example
+    -------
+    >>> flatten([1, 2, [3, (4, 5)], 6])
+    [1, 2, 3, 4, 5, 6]
+    """
+    if not isinstance(obj, (list, tuple)):
+        return [obj]
+    else:
+        return type(obj)([y for x in obj for y in flatten(x)])
+
+
+def unflatten(obj, template):
+    """Invert flattening, given template for nested list/tuple structure.
+
+    Parameters
+    ----------
+    obj : list or tuple of elements
+    template : nested list/tuple structure
+        number of non-list/tuple elements of obj and template must be equal
+
+    Returns
+    -------
+    rest : list or tuple of elements
+        has element bracketing exactly as `template`
+            and elements in sequence exactly as `obj`
+
+    Example
+    -------
+    >>> unflatten([1, 2, 3, 4, 5, 6], [6, 3, [5, (2, 4)], 1])
+    [1, 2, [3, (4, 5)], 6]
+    """
+    if not isinstance(template, (list, tuple)):
+        return obj[0]
+
+    list_or_tuple = type(template)
+    ls = [unflat_len(x) for x in template]
+    for i in range(1, len(ls)):
+        ls[i] += ls[i - 1]
+    ls = [0] + ls
+
+    res = [unflatten(obj[ls[i] : ls[i + 1]], template[i]) for i in range(len(ls) - 1)]
+
+    return list_or_tuple(res)
+
+
+def unflat_len(obj):
+    """Return number of non-list/tuple elements in obj."""
+    if not isinstance(obj, (list, tuple)):
+        return 1
+    else:
+        return sum([unflat_len(x) for x in obj])
+
+
+def is_flat(obj):
+    """Check whether list or tuple is flat, returns true if yes, false if nested."""
+    return not any(isinstance(x, (list, tuple)) for x in obj)

skbase/validate/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Tools for validating and comparing BaseObjects and collections of BaseObjects."""
+from typing import List
+
+__author__: List[str] = ["RNKuhns", "fkiraly"]
+__all__: List[str] = []

skbase/validate/_types.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: skbase developers, BSD-3-Clause License (see LICENSE file)
+"""Tools for validating types."""
+import inspect
+from collections.abc import Iterable
+from typing import List
+
+__author__: List[str] = ["RNKuhns", "fkiraly"]
+__all__: List[str] = []
+
+
+def _check_list_of_str(obj, name="obj"):
+    """Check whether obj is a list of str.
+
+    Parameters
+    ----------
+    obj : any object, check whether is list of str
+    name : str, default="obj", name of obj to display in error message
+
+    Returns
+    -------
+    obj, unaltered
+
+    Raises
+    ------
+    TypeError if obj is not list of str
+    """
+    if not isinstance(obj, list) or not all(isinstance(x, str) for x in obj):
+        raise TypeError(f"{name} must be a list of str")
+    return obj
+
+
+def _check_list_of_str_or_error(arg_to_check, arg_name):
+    """Check that certain arguments are str or list of str.
+
+    Parameters
+    ----------
+    arg_to_check: any
+        Argument we are testing the type of.
+    arg_name: str,
+        name of the argument we are testing, will be added to the error if
+        ``arg_to_check`` is not a str or a list of str.
+
+    Returns
+    -------
+    arg_to_check: list of str,
+        if arg_to_check was originally a str it converts it into a list of str
+        so that it can be iterated over.
+
+    Raises
+    ------
+    TypeError if arg_to_check is not a str or list of str.
+    """
+    # check that return_tags has the right type:
+    if isinstance(arg_to_check, str):
+        arg_to_check = [arg_to_check]
+    elif not isinstance(arg_to_check, list) or not all(
+        isinstance(value, str) for value in arg_to_check
+    ):
+        raise TypeError(
+            f"Input error. Argument {arg_name} must be either\
+             a str or list of str"
+        )
+    return arg_to_check
+
+
+def _check_iterable_of_class_or_error(arg_to_check, arg_name, coerce_to_list=False):
+    """Check that certain arguments are class or list of class.
+
+    Parameters
+    ----------
+    arg_to_check: any
+        Argument we are testing the type of.
+    arg_name: str
+        name of the argument we are testing, will be added to the error if
+        ``arg_to_check`` is not a str or a list of str.
+    coerce_to_list : bool, default=False
+        Whether `arg_to_check` should be coerced to a list prior to return.
+
+    Returns
+    -------
+    arg_to_check: list of class,
+        If `arg_to_check` was originally a class it converts it into a list
+        containing the class so it can be iterated over. Otherwise,
+        `arg_to_check` is returned.
+
+    Raises
+    ------
+    TypeError:
+        If `arg_to_check` is not a class or iterable of class.
+    """
+    # check that return_tags has the right type:
+    if inspect.isclass(arg_to_check):
+        arg_to_check = [arg_to_check]
+    elif not (
+        isinstance(arg_to_check, Iterable)
+        and all(inspect.isclass(value) for value in arg_to_check)
+    ):
+        raise TypeError(
+            f"Input error. Argument {arg_name} must be either\
+             a class or an iterable of classes"
+        )
+    elif coerce_to_list:
+        arg_to_check = list(arg_to_check)
+    return arg_to_check