scikit-base 0.3.0__py3-none-any.whl

skbase/testing/utils/deep_equals.py

@@ -0,0 +1,337 @@
+# -*- coding: utf-8 -*-
+"""Testing utility to compare equality in value for nested objects.
+
+Objects compared can have one of the following valid types:
+    types compatible with != comparison
+    pd.Series, pd.DataFrame, np.ndarray
+    lists, tuples, or dicts of a valid type (recursive)
+"""
+from inspect import isclass
+from typing import List
+
+from skbase.testing.utils._dependencies import _check_soft_dependencies
+
+__author__: List[str] = ["fkiraly"]
+__all__: List[str] = ["deep_equals"]
+
+
+def deep_equals(x, y, return_msg=False):
+    """Test two objects for equality in value.
+
+    Correct if x/y are one of the following valid types:
+        types compatible with != comparison
+        pd.Series, pd.DataFrame, np.ndarray
+        lists, tuples, or dicts of a valid type (recursive)
+
+    Important note:
+        this function will return "not equal" if types of x,y are different
+        for instant, bool and numpy.bool are *not* considered equal
+
+    Parameters
+    ----------
+    x : object
+    y : object
+    return_msg : bool, optional, default=False
+        whether to return informative message about what is not equal
+
+    Returns
+    -------
+    is_equal: bool - True if x and y are equal in value
+        x and y do not need to be equal in reference
+    msg : str, only returned if return_msg = True
+        indication of what is the reason for not being equal
+            concatenation of the following strings:
+            .type - type is not equal
+            .class - both objects are classes but not equal
+            .len - length is not equal
+            .value - value is not equal
+            .keys - if dict, keys of dict are not equal
+                    if class/object, names of attributes and methods are not equal
+            .dtype - dtype of pandas or numpy object is not equal
+            .index - index of pandas object is not equal
+            .series_equals, .df_equals, .index_equals - .equals of pd returns False
+            [i] - if tuple/list: i-th element not equal
+            [key] - if dict: value at key is not equal
+            [colname] - if pandas.DataFrame: column with name colname is not equal
+            != - call to generic != returns False
+    """
+
+    def ret(is_equal, msg):
+        if return_msg:
+            if is_equal:
+                msg = ""
+            return is_equal, msg
+        else:
+            return is_equal
+
+    if type(x) != type(y):
+        return ret(False, f".type, x.type = {type(x)} != y.type = {type(y)}")
+
+    # we now know all types are the same
+    # so now we compare values
+
+    # flag variables for available soft dependencies
+    pandas_available = _check_soft_dependencies("pandas", severity="none")
+    numpy_available = _check_soft_dependencies("numpy", severity="none")
+
+    if numpy_available:
+        import numpy as np
+
+    # pandas is a soft dependency, so we compare pandas objects separately
+    #   and only if pandas is installed in the environment
+    if _is_pandas(x) and pandas_available:
+        res = _pandas_equals(x, y, return_msg=return_msg)
+        if res is not None:
+            return _pandas_equals(x, y, return_msg=return_msg)
+
+    if numpy_available and _is_npndarray(x):
+        if x.dtype != y.dtype:
+            return ret(False, f".dtype, x.dtype = {x.dtype} != y.dtype = {y.dtype}")
+        return ret(np.array_equal(x, y, equal_nan=True), ".values")
+    # recursion through lists, tuples and dicts
+    elif isinstance(x, (list, tuple)):
+        return ret(*_tuple_equals(x, y, return_msg=True))
+    elif isinstance(x, dict):
+        return ret(*_dict_equals(x, y, return_msg=True))
+    elif isclass(x):
+        return ret(x == y, f".class, x={x.__name__} != y={y.__name__}")
+    elif type(x).__name__ == "ForecastingHorizon":
+        return ret(*_fh_equals(x, y, return_msg=True))
+    # this elif covers case where != is boolean
+    # some types return a vector upon !=, this is covered in the next elif
+    elif isinstance(x == y, bool):
+        return ret(x == y, f" !=, {x} != {y}")
+    # deal with the case where != returns a vector
+    elif numpy_available and np.any(x != y) or any(_coerce_list(x != y)):
+        return ret(False, f" !=, {x} != {y}")
+
+    return ret(True, "")
+
+
+def _is_pandas(x):
+
+    clstr = type(x).__name__
+    if clstr in ["DataFrame", "Series"]:
+        return True
+    if clstr.endswith("Index"):
+        return True
+    else:
+        return False
+
+
+def _is_npndarray(x):
+
+    clstr = type(x).__name__
+    return clstr == "ndarray"
+
+
+def _coerce_list(x):
+    """Coerce x to list."""
+    if not isinstance(x, (list, tuple)):
+        x = [x]
+    if isinstance(x, tuple):
+        x = list(x)
+
+    return x
+
+
+def _pandas_equals(x, y, return_msg=False):
+
+    import pandas as pd
+
+    def ret(is_equal, msg):
+        if return_msg:
+            if is_equal:
+                msg = ""
+            return is_equal, msg
+        else:
+            return is_equal
+
+    if isinstance(x, pd.Series):
+        if x.dtype != y.dtype:
+            return ret(False, f".dtype, x.dtype= {x.dtype} != y.dtype = {y.dtype}")
+        # if columns are object, recurse over entries and index
+        if x.dtype == "object":
+            index_equal = x.index.equals(y.index)
+            values_equal, values_msg = deep_equals(
+                list(x.to_array()), list(y.to_array()), return_msg=True
+            )
+            if not values_equal:
+                msg = ".values" + values_msg
+            elif not index_equal:
+                msg = f".index, x.index: {x.index}, y.index: {y.index}"
+            else:
+                msg = ""
+            return ret(index_equal and values_equal, msg)
+        else:
+            return ret(x.equals(y), f".series_equals, x = {x} != y = {y}")
+    elif isinstance(x, pd.DataFrame):
+        if not x.columns.equals(y.columns):
+            return ret(
+                False, f".columns, x.columns = {x.columns} != y.columns = {y.columns}"
+            )
+        # if columns are equal and at least one is object, recurse over Series
+        if sum(x.dtypes == "object") > 0:
+            for c in x.columns:
+                is_equal, msg = deep_equals(x[c], y[c], return_msg=True)
+                if not is_equal:
+                    return ret(False, f'["{c}"]' + msg)
+            return ret(True, "")
+        else:
+            return ret(x.equals(y), f".df_equals, x = {x} != y = {y}")
+    elif isinstance(x, pd.Index):
+        return ret(x.equals(y), f".index_equals, x = {x} != y = {y}")
+
+
+def _tuple_equals(x, y, return_msg=False):
+    """Test two tuples or lists for equality.
+
+    Correct if tuples/lists contain the following valid types:
+        types compatible with != comparison
+        pd.Series, pd.DataFrame, np.ndarray
+        lists, tuples, or dicts of a valid type (recursive)
+
+    Parameters
+    ----------
+    x: tuple or list
+    y: tuple or list
+    return_msg : bool, optional, default=False
+        whether to return informative message about what is not equal
+
+    Returns
+    -------
+    is_equal: bool - True if x and y are equal in value
+        x and y do not need to be equal in reference
+    msg : str, only returned if return_msg = True
+        indication of what is the reason for not being equal
+            concatenation of the following elements:
+            .len - length is not equal
+            [i] - i-th element not equal
+    """
+
+    def ret(is_equal, msg):
+        if return_msg:
+            if is_equal:
+                msg = ""
+            return is_equal, msg
+        else:
+            return is_equal
+
+    n = len(x)
+
+    if n != len(y):
+        return ret(False, f".len, x.len = {n} != y.len = {len(y)}")
+
+    # we now know dicts are same length
+    for i in range(n):
+        xi = x[i]
+        yi = y[i]
+
+        # recurse through xi/yi
+        is_equal, msg = deep_equals(xi, yi, return_msg=True)
+        if not is_equal:
+            return ret(False, f"[{i}]" + msg)
+
+    return ret(True, "")
+
+
+def _dict_equals(x, y, return_msg=False):
+    """Test two dicts for equality.
+
+    Correct if dicts contain the following valid types:
+        types compatible with != comparison
+        pd.Series, pd.DataFrame, np.ndarray
+        lists, tuples, or dicts of a valid type (recursive)
+
+    Parameters
+    ----------
+    x: dict
+    y: dict
+    return_msg : bool, optional, default=False
+        whether to return informative message about what is not equal
+
+    Returns
+    -------
+    is_equal: bool - True if x and y are equal in value
+        x and y do not need to be equal in reference
+    msg : str, only returned if return_msg = True
+        indication of what is the reason for not being equal
+            concatenation of the following strings:
+            .keys - keys are not equal
+            [key] - values at key is not equal
+    """
+
+    def ret(is_equal, msg):
+        if return_msg:
+            if is_equal:
+                msg = ""
+            return is_equal, msg
+        else:
+            return is_equal
+
+    xkeys = set(x.keys())
+    ykeys = set(y.keys())
+
+    if xkeys != ykeys:
+        xmy = xkeys.difference(ykeys)
+        ymx = ykeys.difference(xkeys)
+        diffmsg = ".keys,"
+        if len(xmy) > 0:
+            diffmsg += f" x.keys-y.keys = {xmy}."
+        if len(ymx) > 0:
+            diffmsg += f" y.keys-x.keys = {ymx}."
+        return ret(False, diffmsg)
+
+    # we now know that xkeys == ykeys
+    for key in xkeys:
+        xi = x[key]
+        yi = y[key]
+
+        # recurse through xi/yi
+        is_equal, msg = deep_equals(xi, yi, return_msg=True)
+        if not is_equal:
+            return ret(False, f"[{key}]" + msg)
+
+    return ret(True, "")
+
+
+def _fh_equals(x, y, return_msg=False):
+    """Test two forecasting horizons for equality.
+
+    Correct if both x and y are ForecastingHorizon
+
+    Parameters
+    ----------
+    x: ForcastingHorizon
+    y: ForcastingHorizon
+    return_msg : bool, optional, default=False
+        whether to return informative message about what is not equal
+
+    Returns
+    -------
+    is_equal: bool - True if x and y are equal in value
+        x and y do not need to be equal in reference
+    msg : str, only returned if return_msg = True
+        indication of what is the reason for not being equal
+            concatenation of the following strings:
+            .is_relative - x is absolute and y is relative, or vice versa
+            .values - values of x and y are not equal
+    """
+
+    def ret(is_equal, msg):
+        if return_msg:
+            if is_equal:
+                msg = ""
+            return is_equal, msg
+        else:
+            return is_equal
+
+    if x.is_relative != y.is_relative:
+        return ret(False, ".is_relative")
+
+    # recurse through values of x, y
+    is_equal, msg = deep_equals(x._values, y._values, return_msg=True)
+    if not is_equal:
+        return ret(False, ".values" + msg)
+
+    return ret(True, "")

skbase/testing/utils/inspect.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+"""Utilities for inspection of function arguments."""
+
+
+from inspect import signature
+
+
+def _get_args(function, varargs=False):
+    """Get function arguments."""
+    try:
+        params = signature(function).parameters
+    except ValueError:
+        # Error on builtin C function
+        return []
+    args = [
+        key
+        for key, param in params.items()
+        if param.kind not in (param.VAR_POSITIONAL, param.VAR_KEYWORD)
+    ]
+    if varargs:
+        varargs = [
+            param.name
+            for param in params.values()
+            if param.kind == param.VAR_POSITIONAL
+        ]
+        if len(varargs) == 0:
+            varargs = None
+        return args, varargs
+    else:
+        return args

skbase/testing/utils/tests/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+"""Testing utilities of the test framework."""

skbase/testing/utils/tests/test_check_dependencies.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+"""Tests for _check_soft_dependencies utility."""
+import pytest
+from packaging.requirements import InvalidRequirement
+
+from skbase.testing.utils._dependencies import _check_soft_dependencies
+
+
+def test_check_soft_deps():
+    """Test package availability against pyproject of skbase."""
+    # test various admissible input types, positives
+    assert _check_soft_dependencies("pytest")
+    assert _check_soft_dependencies("pytest", "numpy")
+    assert _check_soft_dependencies("pytest", "numpy")
+    assert _check_soft_dependencies(["pytest", "numpy"])
+    assert _check_soft_dependencies(("pytest", "numpy"))
+
+    # test various admissible input types, negatives
+    assert not _check_soft_dependencies("humpty", severity="none")
+    assert not _check_soft_dependencies("numpy", "dumpty", severity="none")
+    assert not _check_soft_dependencies("humpty", "numpy", severity="none")
+    assert not _check_soft_dependencies(["humpty", "humpty"], severity="none")
+    assert not _check_soft_dependencies(("humpty", "dumpty"), severity="none")
+
+    # test error raise on error severity
+    with pytest.raises(ModuleNotFoundError):
+        assert _check_soft_dependencies("humpty", severity="error")
+    with pytest.raises(ModuleNotFoundError):
+        assert _check_soft_dependencies("numpy", "dumpty", severity="error")
+
+    # test warning on warning severity
+    with pytest.warns():
+        assert not _check_soft_dependencies("humpty", severity="warning")
+    with pytest.warns():
+        assert not _check_soft_dependencies("numpy", "dumpty", severity="warning")
+
+    # test valid PEP 440 specifier strings
+    assert _check_soft_dependencies("pytest>0.0.1")
+    assert _check_soft_dependencies("pytest>=0.0.1", "numpy!=0.1.0")
+    assert not _check_soft_dependencies(("pytest", "numpy<0.1.0"), severity="none")
+    assert _check_soft_dependencies(["pytest", "numpy>0.1.0"], severity="none")
+
+    # test error on invalid PEP 440 specifier string
+    with pytest.raises(InvalidRequirement):
+        assert _check_soft_dependencies("pytest!!!!>>>0.0.1")
+    with pytest.raises(InvalidRequirement):
+        assert _check_soft_dependencies(
+            ("pytest", "!!numpy<~><>0.1.0"), severity="none"
+        )

skbase/testing/utils/tests/test_deep_equals.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+"""Tests for deep_equals utility."""
+from copy import deepcopy
+
+import numpy as np
+import pytest
+
+from skbase.testing.utils._dependencies import _check_soft_dependencies
+from skbase.testing.utils.deep_equals import deep_equals
+
+# examples used for comparison below
+EXAMPLES = [
+    42,
+    [],
+    ((((())))),
+    [([([([()])])])],
+    np.array([2, 3, 4]),
+    np.array([2, 4, 5]),
+]
+
+
+if _check_soft_dependencies("pandas", severity="none"):
+    import pandas as pd
+
+    EXAMPLES += [
+        pd.DataFrame({"a": [4, 2]}),
+        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])},
+    ]
+
+
+@pytest.mark.parametrize("fixture", EXAMPLES)
+def test_deep_equals_positive(fixture):
+    """Tests that deep_equals correctly identifies equal objects as equal."""
+    x = deepcopy(fixture)
+    y = deepcopy(fixture)
+
+    msg = (
+        f"deep_copy incorrectly returned False for two identical copies of "
+        f"the following object: {x}"
+    )
+    assert deep_equals(x, y), msg
+
+
+n = len(EXAMPLES)
+DIFFERENT_PAIRS = [
+    (EXAMPLES[i], EXAMPLES[j]) for i in range(n) for j in range(n) if i != j
+]
+
+
+@pytest.mark.parametrize("fixture1,fixture2", DIFFERENT_PAIRS)
+def test_deep_equals_negative(fixture1, fixture2):
+    """Tests that deep_equals correctly identifies unequal objects as unequal."""
+    x = deepcopy(fixture1)
+    y = deepcopy(fixture2)
+
+    msg = (
+        f"deep_copy incorrectly returned True when comparing "
+        f"the following, different objects: x={x}, y={y}"
+    )
+    assert not deep_equals(x, y), msg

skbase/tests/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+"""Tests."""

skbase/tests/conftest.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+"""Common functionality for skbase unit tests."""
+from typing import List
+
+from skbase.base import BaseEstimator, BaseObject
+
+__all__: List[str] = [
+    "SKBASE_BASE_CLASSES",
+    "SKBASE_MODULES",
+    "SKBASE_PUBLIC_MODULES",
+    "SKBASE_PUBLIC_CLASSES_BY_MODULE",
+    "SKBASE_CLASSES_BY_MODULE",
+    "SKBASE_PUBLIC_FUNCTIONS_BY_MODULE",
+    "SKBASE_FUNCTIONS_BY_MODULE",
+]
+__author__: List[str] = ["fkiraly", "RNKuhns"]
+
+SKBASE_BASE_CLASSES = (BaseObject, BaseEstimator)
+SKBASE_MODULES = (
+    "skbase",
+    "skbase._exceptions",
+    "skbase.base",
+    "skbase.base._base",
+    "skbase.base._meta",
+    "skbase.lookup",
+    "skbase.lookup.tests",
+    "skbase.lookup.tests.test_lookup",
+    "skbase.lookup._lookup",
+    "skbase.testing",
+    "skbase.testing.test_all_objects",
+    "skbase.testing.utils",
+    "skbase.testing.utils._conditional_fixtures",
+    "skbase.testing.utils._dependencies",
+    "skbase.testing.utils.deep_equals",
+    "skbase.testing.utils.inspect",
+    "skbase.testing.utils.tests",
+    "skbase.testing.utils.tests.test_deep_equals",
+    "skbase.tests",
+    "skbase.tests.conftest",
+    "skbase.tests.test_base",
+    "skbase.tests.test_baseestimator",
+    "skbase.tests.mock_package.test_mock_package",
+    "skbase.utils",
+    "skbase.utils._nested_iter",
+    "skbase.validate",
+    "skbase.validate._types",
+)
+SKBASE_PUBLIC_MODULES = (
+    "skbase",
+    "skbase.base",
+    "skbase.lookup",
+    "skbase.lookup.tests",
+    "skbase.lookup.tests.test_lookup",
+    "skbase.testing",
+    "skbase.testing.test_all_objects",
+    "skbase.testing.utils",
+    "skbase.testing.utils.deep_equals",
+    "skbase.testing.utils.inspect",
+    "skbase.testing.utils.tests",
+    "skbase.testing.utils.tests.test_deep_equals",
+    "skbase.tests",
+    "skbase.tests.conftest",
+    "skbase.tests.test_base",
+    "skbase.tests.test_baseestimator",
+    "skbase.tests.mock_package.test_mock_package",
+    "skbase.utils",
+    "skbase.validate",
+)
+SKBASE_PUBLIC_CLASSES_BY_MODULE = {
+    "skbase._exceptions": ("FixtureGenerationError", "NotFittedError"),
+    "skbase.base": ("BaseEstimator", "BaseMetaEstimator", "BaseObject"),
+    "skbase.base._base": ("BaseEstimator", "BaseObject"),
+    "skbase.base._meta": ("BaseMetaEstimator",),
+    "skbase.lookup._lookup": ("ClassInfo", "FunctionInfo", "ModuleInfo"),
+    "skbase.testing": ("BaseFixtureGenerator", "QuickTester", "TestAllObjects"),
+    "skbase.testing.test_all_objects": (
+        "BaseFixtureGenerator",
+        "QuickTester",
+        "TestAllObjects",
+    ),
+}
+SKBASE_CLASSES_BY_MODULE = SKBASE_PUBLIC_CLASSES_BY_MODULE.copy()
+SKBASE_CLASSES_BY_MODULE.update({"skbase.base._meta": ("BaseMetaEstimator",)})
+SKBASE_PUBLIC_FUNCTIONS_BY_MODULE = {
+    "skbase.lookup": ("all_objects", "get_package_metadata"),
+    "skbase.lookup._lookup": ("all_objects", "get_package_metadata"),
+    "skbase.testing.utils._conditional_fixtures": (
+        "create_conditional_fixtures_and_names",
+    ),
+    "skbase.testing.utils.deep_equals": ("deep_equals",),
+    "skbase.utils": ("flatten", "is_flat", "unflat_len", "unflatten"),
+    "skbase.utils._nested_iter": (
+        "flatten",
+        "is_flat",
+        "unflat_len",
+        "unflatten",
+    ),
+}
+SKBASE_FUNCTIONS_BY_MODULE = SKBASE_PUBLIC_FUNCTIONS_BY_MODULE.copy()
+SKBASE_FUNCTIONS_BY_MODULE.update(
+    {
+        "skbase.lookup._lookup": (
+            "_determine_module_path",
+            "_get_return_tags",
+            "_is_ignored_module",
+            "all_objects",
+            "_is_non_public_module",
+            "get_package_metadata",
+            "_make_dataframe",
+            "_walk",
+            "_filter_by_tags",
+            "_filter_by_class",
+            "_import_module",
+            "_check_object_types",
+            "_get_module_info",
+        ),
+        "skbase.testing.utils._dependencies": (
+            "_check_soft_dependencies",
+            "_check_python_version",
+        ),
+        "skbase.testing.utils.deep_equals": (
+            "_pandas_equals",
+            "_dict_equals",
+            "_is_pandas",
+            "_tuple_equals",
+            "_fh_equals",
+            "deep_equals",
+            "_is_npndarray",
+            "_coerce_list",
+        ),
+        "skbase.testing.utils.inspect": ("_get_args",),
+        "skbase.utils._nested_iter": (
+            "_remove_single",
+            "flatten",
+            "is_flat",
+            "unflat_len",
+            "unflatten",
+        ),
+        "skbase.validate._types": (
+            "_check_iterable_of_class_or_error",
+            "_check_list_of_str",
+            "_check_list_of_str_or_error",
+        ),
+    }
+)
+
+
+# Fixture class for testing tag system
+class Parent(BaseObject):
+    """Parent class to test BaseObject's usage."""
+
+    _tags = {"A": "1", "B": 2, "C": 1234, "3": "D"}
+
+    def __init__(self, a="something", b=7, c=None):
+        self.a = a
+        self.b = b
+        self.c = c
+        super().__init__()
+
+    def some_method(self):
+        """To be implemented by child class."""
+        pass
+
+
+# Fixture class for testing tag system, child overrides tags
+class Child(Parent):
+    """Child class that is child of FixtureClassParent."""
+
+    _tags = {"A": 42, "3": "E"}
+    __author__ = ["fkiraly", "RNKuhns"]
+
+    def some_method(self):
+        """Child class' implementation."""
+        pass
+
+    def some_other_method(self):
+        """To be implemented in the child class."""
+        pass

skbase/tests/mock_package/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+"""Mock package for skbase testing."""
+from typing import List
+
+__author__: List[str] = ["fkiraly", "RNKuhns"]