diff --git a/.all-contributorsrc b/.all-contributorsrc index 31755537..0b6188d7 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -163,6 +163,16 @@ ] }, { + "login": "arnavk23", + "name": "Arnav Kapoor", + "avatar_url": "https://avatars.githubusercontent.com/u/arnavk23?v=4", + "profile": "https://github.com/arnavk23", + "contributions": [ + "bug", + "code", + "test" + ] + }, "login": "RecreationalMath", "name": "Nirbhai Singh", "avatar_url": "https://avatars.githubusercontent.com/u/6928297?v=4", diff --git a/skbase/lookup/tests/test_lookup.py b/skbase/lookup/tests/test_lookup.py index fc029316..feb63535 100644 --- a/skbase/lookup/tests/test_lookup.py +++ b/skbase/lookup/tests/test_lookup.py @@ -31,19 +31,19 @@ ) from skbase.tests.conftest import ( SKBASE_BASE_CLASSES, - SKBASE_CLASSES_BY_MODULE, - SKBASE_FUNCTIONS_BY_MODULE, - SKBASE_MODULES, - SKBASE_PUBLIC_CLASSES_BY_MODULE, - SKBASE_PUBLIC_FUNCTIONS_BY_MODULE, - SKBASE_PUBLIC_MODULES, - ClassWithABTrue, - Parent, ) -from skbase.tests.mock_package.test_mock_package import ( +from skbase.tests.mock_package import ( + MOCK_PACKAGE_CLASSES_BY_MODULE, + MOCK_PACKAGE_FUNCTIONS_BY_MODULE, + MOCK_PACKAGE_MODULES, MOCK_PACKAGE_OBJECTS, + MOCK_PACKAGE_PUBLIC_CLASSES_BY_MODULE, + MOCK_PACKAGE_PUBLIC_FUNCTIONS_BY_MODULE, + MOCK_PACKAGE_PUBLIC_MODULES, + ClassWithABTrue, CompositionDummy, NotABaseObject, + Parent, ) __author__: List[str] = ["RNKuhns", "fkiraly"] @@ -715,49 +715,75 @@ def test_get_package_metadata_tag_filter(tag_filter): assert len(unfiltered_classes) > len(filtered_classes) +def test_get_return_tags(): + """Test _get_return_tags returns expected.""" + + def _test_get_return_tags_output(results, num_requested_tags): + return isinstance(results, tuple) and len(results) == num_requested_tags + + # Verify return with tags that exist + tags = Parent.get_class_tags() + tag_names = [*tags.keys()] + results = _get_return_tags(Parent, tag_names) + assert ( + _test_get_return_tags_output(results, len(tag_names)) + and tuple(tags.values()) == results + ) + + # Verify results when some exist and some don't exist + tag_names += ["a_tag_that_does_not_exist"] + results = _get_return_tags(Parent, tag_names) + assert _test_get_return_tags_output(results, len(tag_names)) + + # Verify return when all tags don't exist + tag_names = ["a_tag_that_does_not_exist"] + results = _get_return_tags(Parent, tag_names) + assert _test_get_return_tags_output(results, len(tag_names)) and results[0] is None + + @pytest.mark.parametrize("exclude_non_public_modules", [True, False]) @pytest.mark.parametrize("exclude_non_public_items", [True, False]) -def test_get_package_metadata_returns_expected_results( +def test_get_package_metadata_returns_expected_results_mock_package( exclude_non_public_modules, exclude_non_public_items ): - """Test that get_package_metadata_returns expected results using skbase.""" + """Test that get_package_metadata returns expected results for mock package. + + This test validates the lookup retrieval against configuration constants + that define the expected classes and functions for each module in the + mock package, checking both public and non-public items. + """ results = get_package_metadata( - "skbase", + "skbase.tests.mock_package", exclude_non_public_items=exclude_non_public_items, exclude_non_public_modules=exclude_non_public_modules, package_base_classes=SKBASE_BASE_CLASSES, - modules_to_ignore="tests", - classes_to_exclude=TagAliaserMixin, - suppress_import_stdout=False, + modules_to_ignore=None, + suppress_import_stdout=True, ) - public_modules_excluding_tests = [ - module - for module in SKBASE_PUBLIC_MODULES - if not _is_ignored_module(module, modules_to_ignore="tests") - ] - modules_excluding_tests = [ - module - for module in SKBASE_MODULES - if not _is_ignored_module(module, modules_to_ignore="tests") - ] + + # Determine which modules to expect based on parameters if exclude_non_public_modules: - assert tuple(results.keys()) == tuple(public_modules_excluding_tests) + expected_modules = MOCK_PACKAGE_PUBLIC_MODULES else: - assert tuple(results.keys()) == tuple(modules_excluding_tests) + expected_modules = MOCK_PACKAGE_MODULES + + # Verify we got the expected modules + assert set(results.keys()) == set(expected_modules) + # Verify each module has the expected classes and functions for module in results: if exclude_non_public_items: - module_funcs = SKBASE_PUBLIC_FUNCTIONS_BY_MODULE.get(module, ()) - module_classes = SKBASE_PUBLIC_CLASSES_BY_MODULE.get(module, ()) + module_funcs = MOCK_PACKAGE_PUBLIC_FUNCTIONS_BY_MODULE.get(module, ()) + module_classes = MOCK_PACKAGE_PUBLIC_CLASSES_BY_MODULE.get(module, ()) which_str = "public" - fun_str = "SKBASE_PUBLIC_FUNCTIONS_BY_MODULE" - cls_str = "SKBASE_PUBLIC_CLASSES_BY_MODULE" + fun_str = "MOCK_PACKAGE_PUBLIC_FUNCTIONS_BY_MODULE" + cls_str = "MOCK_PACKAGE_PUBLIC_CLASSES_BY_MODULE" else: - module_funcs = SKBASE_FUNCTIONS_BY_MODULE.get(module, ()) - module_classes = SKBASE_CLASSES_BY_MODULE.get(module, ()) + module_funcs = MOCK_PACKAGE_FUNCTIONS_BY_MODULE.get(module, ()) + module_classes = MOCK_PACKAGE_CLASSES_BY_MODULE.get(module, ()) which_str = "all" - fun_str = "SKBASE_FUNCTIONS_BY_MODULE" - cls_str = "SKBASE_CLASSES_BY_MODULE" + fun_str = "MOCK_PACKAGE_FUNCTIONS_BY_MODULE" + cls_str = "MOCK_PACKAGE_CLASSES_BY_MODULE" # Verify expected functions are returned retrieved_funcs = set(results[module]["functions"].keys()) @@ -769,7 +795,7 @@ def test_get_package_metadata_returns_expected_results( f"for {which_str} functions in module {module} do not match expected. " f"Expected: {expected_funcs}; " f"retrieved: {retrieved_funcs}. " - f"Expected functions are stored in {fun_str}, in test_lookup." + f"Expected functions are stored in {fun_str}, in mock_package." ) raise AssertionError(msg) @@ -783,11 +809,11 @@ def test_get_package_metadata_returns_expected_results( f"for {which_str} classes in module {module} do not match expected. " f"Expected: {expected_cls}; " f"retrieved: {retrieved_cls}. " - f"Expected functions are stored in {cls_str}, in test_lookup." + f"Expected classes are stored in {cls_str}, in mock_package." ) raise AssertionError(msg) - # Verify class metadata attributes correct + # Verify class metadata attributes are correct for klass, klass_metadata in results[module]["classes"].items(): if klass_metadata["klass"] in SKBASE_BASE_CLASSES: assert ( @@ -812,32 +838,6 @@ def test_get_package_metadata_returns_expected_results( assert klass_metadata["is_concrete_implementation"] is False -def test_get_return_tags(): - """Test _get_return_tags returns expected.""" - - def _test_get_return_tags_output(results, num_requested_tags): - return isinstance(results, tuple) and len(results) == num_requested_tags - - # Verify return with tags that exist - tags = Parent.get_class_tags() - tag_names = [*tags.keys()] - results = _get_return_tags(Parent, tag_names) - assert ( - _test_get_return_tags_output(results, len(tag_names)) - and tuple(tags.values()) == results - ) - - # Verify results when some exist and some don't exist - tag_names += ["a_tag_that_does_not_exist"] - results = _get_return_tags(Parent, tag_names) - assert _test_get_return_tags_output(results, len(tag_names)) - - # Verify return when all tags don't exist - tag_names = ["a_tag_that_does_not_exist"] - results = _get_return_tags(Parent, tag_names) - assert _test_get_return_tags_output(results, len(tag_names)) and results[0] is None - - def test_get_package_metadata_matches_expected_representation_mock_package(): """Verify get_package_metadata returns the expected representation for the controlled `skbase.tests.mock_package` mock package. @@ -1033,7 +1033,7 @@ def test_all_objects_class_filter(class_filter): """Test all_objects filters by class type as expected.""" # Results applying filter objs = all_objects( - package_name="skbase", + package_name="skbase.tests.mock_package", return_names=True, as_dataframe=True, return_tags=None, @@ -1047,7 +1047,7 @@ def test_all_objects_class_filter(class_filter): # Results without filter objs = all_objects( - package_name="skbase", + package_name="skbase.tests.mock_package", return_names=True, as_dataframe=True, return_tags=None, @@ -1073,7 +1073,7 @@ def test_all_object_tag_filter(tag_filter): """Test all_objects filters by tag as expected.""" # Results applying filter objs = all_objects( - package_name="skbase", + package_name="skbase.tests.mock_package", return_names=True, as_dataframe=True, return_tags=None, @@ -1087,7 +1087,7 @@ def test_all_object_tag_filter(tag_filter): # Results without filter objs = all_objects( - package_name="skbase", + package_name="skbase.tests.mock_package", return_names=True, as_dataframe=True, return_tags=None, @@ -1148,7 +1148,7 @@ def test_all_object_class_lookup(class_lookup, class_filter): """Test all_objects class_lookup parameter works as expected..""" # Results applying filter objs = all_objects( - package_name="skbase", + package_name="skbase.tests.mock_package", return_names=True, as_dataframe=True, return_tags=None, @@ -1171,7 +1171,7 @@ def test_all_object_class_lookup_invalid_object_types_raises( # Results applying filter with pytest.raises(ValueError): all_objects( - package_name="skbase", + package_name="skbase.tests.mock_package", return_names=True, as_dataframe=True, return_tags=None, diff --git a/skbase/testing/test_all_objects.py b/skbase/testing/test_all_objects.py index d8a715e1..231307b6 100644 --- a/skbase/testing/test_all_objects.py +++ b/skbase/testing/test_all_objects.py @@ -745,7 +745,7 @@ def test_object_tags(self, object_class): assert isinstance(tags, dict), msg assert len(tags) > 0, f"_tags dict of class {object_class} is empty" if self.valid_tags is None: - invalid_tags = tags + invalid_tags = [] else: invalid_tags = [ tag for tag in tags.keys() if tag not in self.valid_tags diff --git a/skbase/tests/conftest.py b/skbase/tests/conftest.py index a95879ca..cd9145e8 100644 --- a/skbase/tests/conftest.py +++ b/skbase/tests/conftest.py @@ -7,326 +7,10 @@ __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"] -# bug 442 fixed: metaclasses now discovered correctly on all Python versions -IMPORT_CLS = ("CommonMagicMeta", "MagicAttribute") - SKBASE_BASE_CLASSES = (BaseObject, BaseEstimator) -SKBASE_MODULES = ( - "skbase", - "skbase._exceptions", - "skbase._nopytest_tests", - "skbase.base", - "skbase.base._base", - "skbase.base._clone_base", - "skbase.base._clone_plugins", - "skbase.base._meta", - "skbase.base._pretty_printing", - "skbase.base._pretty_printing._object_html_repr", - "skbase.base._pretty_printing._pprint", - "skbase.base._tagmanager", - "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.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._check", - "skbase.utils._iter", - "skbase.utils._nested_iter", - "skbase.utils._utils", - "skbase.utils.deep_equals", - "skbase.utils.deep_equals._common", - "skbase.utils.deep_equals._deep_equals", - "skbase.utils.dependencies", - "skbase.utils.dependencies._dependencies", - "skbase.utils.dependencies._import", - "skbase.utils.doctest_run", - "skbase.utils.git_diff", - "skbase.utils.random_state", - "skbase.utils.stderr_mute", - "skbase.utils.stdout_mute", - "skbase.validate", - "skbase.validate._named_objects", - "skbase.validate._type_checks", -) -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.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.deep_equals", - "skbase.utils.dependencies", - "skbase.utils.doctest_run", - "skbase.utils.git_diff", - "skbase.utils.random_state", - "skbase.utils.stderr_mute", - "skbase.utils.stdout_mute", - "skbase.validate", -) -SKBASE_PUBLIC_CLASSES_BY_MODULE = { - "skbase._exceptions": ("FixtureGenerationError", "NotFittedError"), - "skbase.base": ( - "BaseEstimator", - "BaseMetaEstimator", - "BaseMetaEstimatorMixin", - "BaseMetaObject", - "BaseMetaObjectMixin", - "BaseObject", - ), - "skbase.base._base": ("BaseEstimator", "BaseObject"), - "skbase.base._clone_plugins": ("BaseCloner",), - "skbase.base._meta": ( - "BaseMetaObject", - "BaseMetaObjectMixin", - "BaseMetaEstimator", - "BaseMetaEstimatorMixin", - ), - "skbase.base._pretty_printing._pprint": ("KeyValTuple", "KeyValTupleParam"), - "skbase.lookup._lookup": ("StdoutMuteNCatchMNF",), - "skbase.testing": ("BaseFixtureGenerator", "QuickTester", "TestAllObjects"), - "skbase.testing.test_all_objects": ( - "BaseFixtureGenerator", - "QuickTester", - "TestAllObjects", - ), - "skbase.utils.dependencies._import": IMPORT_CLS, - "skbase.utils.stderr_mute": ("StderrMute",), - "skbase.utils.stdout_mute": ("StdoutMute",), -} -SKBASE_CLASSES_BY_MODULE = SKBASE_PUBLIC_CLASSES_BY_MODULE.copy() -SKBASE_CLASSES_BY_MODULE.update( - { - "skbase.base._clone_plugins": ( - "BaseCloner", - "_CloneClass", - "_CloneSkbase", - "_CloneSklearn", - "_CloneDict", - "_CloneListTupleSet", - "_CloneGetParams", - "_CloneCatchAll", - ), - "skbase.base._meta": ( - "BaseMetaObject", - "BaseMetaObjectMixin", - "BaseMetaEstimator", - "BaseMetaEstimatorMixin", - "_MetaObjectMixin", - "_MetaTagLogicMixin", - ), - "skbase.base._pretty_printing._object_html_repr": ("_VisualBlock",), - "skbase.base._pretty_printing._pprint": ( - "KeyValTuple", - "KeyValTupleParam", - "_BaseObjectPrettyPrinter", - ), - "skbase.base._tagmanager": ("_FlagManager",), - } -) -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.validate": ( - "check_sequence_named_objects", - "check_sequence", - "check_type", - "is_named_object_tuple", - "is_sequence", - "is_sequence_named_objects", - ), - "skbase.validate._named_objects": ( - "check_sequence_named_objects", - "is_named_object_tuple", - "is_sequence_named_objects", - ), - "skbase.utils": ( - "check_random_state", - "deep_equals", - "git_diff", - "flatten", - "is_flat", - "make_strings_unique", - "sample_dependent_seed", - "set_random_state", - "subset_dict_keys", - "unflat_len", - "unflatten", - ), - "skbase.utils._iter": ("make_strings_unique",), - "skbase.utils._nested_iter": ( - "flatten", - "is_flat", - "unflat_len", - "unflatten", - ), - "skbase.utils._utils": ("subset_dict_keys",), - "skbase.utils.deep_equals": ("deep_equals",), - "skbase.utils.deep_equals._deep_equals": ("deep_equals", "deep_equals_custom"), - "skbase.utils.doctest_run": ("run_doctest",), - "skbase.utils.git_diff": ("git_diff",), - "skbase.utils.random_state": ( - "check_random_state", - "sample_dependent_seed", - "set_random_state", - ), - "skbase.validate._type_checks": ("check_sequence", "check_type", "is_sequence"), -} -SKBASE_FUNCTIONS_BY_MODULE = SKBASE_PUBLIC_FUNCTIONS_BY_MODULE.copy() -SKBASE_FUNCTIONS_BY_MODULE.update( - { - "skbase.base._clone_base": {"_check_clone", "_clone"}, - "skbase.base._clone_plugins": ( - "_default_clone", - "_get_sklearn_clone", - "_is_sklearn_present", - ), - "skbase.base._pretty_printing._object_html_repr": ( - "_get_visual_block", - "_object_html_repr", - "_write_base_object_html", - "_write_label_html", - ), - "skbase.base._pretty_printing._pprint": ("_changed_params", "_safe_repr"), - "skbase.lookup._lookup": ( - "all_objects", - "get_package_metadata", - "_check_object_types", - "_coerce_to_tuple", - "_determine_module_path", - "_filter_by_tags", - "_filter_by_class", - "_get_members_uw", - "_get_module_info", - "_get_return_tags", - "_import_module", - "_is_ignored_module", - "_is_non_public_module", - "_make_dataframe", - "_walk", - "_walk_and_retrieve_all_objs", - ), - "skbase.testing.utils.inspect": ("_get_args",), - "skbase.utils._check": ("_is_scalar_nan",), - "skbase.utils.dependencies": ( - "_check_soft_dependencies", - "_check_python_version", - "_check_estimator_deps", - "_safe_import", - ), - "skbase.utils.dependencies._import": ("_safe_import", "_create_mock_class"), - "skbase.utils._iter": ( - "_format_seq_to_str", - "_remove_type_text", - "_scalar_to_seq", - "make_strings_unique", - ), - "skbase.utils._nested_iter": ( - "flatten", - "is_flat", - "_remove_single", - "unflat_len", - "unflatten", - ), - "skbase.utils._utils": ("subset_dict_keys",), - "skbase.utils.deep_equals": ("deep_equals",), - "skbase.utils.deep_equals._common": ("_make_ret", "_ret"), - "skbase.utils.deep_equals._deep_equals": ( - "_coerce_list", - "_dict_equals", - "_fh_equals_plugin", - "_is_npnan", - "_is_npndarray", - "_is_pandas", - "_jax_equals_plugin", - "_numpy_equals_plugin", - "_pandas_equals", - "_pandas_equals_plugin", - "_safe_any_unequal", - "_safe_len", - "_softdep_available", - "_tuple_equals", - "deep_equals", - "deep_equals_custom", - ), - "skbase.utils.git_diff": ( - "_get_packages_with_changed_specs", - "git_diff", - "_get_packages_with_changed_specs_list", - "_get_module_from_class", - "_get_path_from_module", - "_get_changed_lines", - "_run_git_diff", - "_is_module_changed", - "_is_class_changed", - ), - "skbase.utils.dependencies._dependencies": ( - "_check_env_marker", - "_check_estimator_deps", - "_check_python_version", - "_check_soft_dependencies", - "_get_pkg_version", - "_get_installed_packages", - "_get_installed_packages_private", - "_normalize_requirement", - "_normalize_version", - "_raise_at_severity", - "_norm_pkgname", - ), - "skbase.utils.random_state": ( - "check_random_state", - "sample_dependent_seed", - "set_random_state", - ), - "skbase.validate._named_objects": ( - "check_sequence_named_objects", - "is_named_object_tuple", - "is_sequence_named_objects", - "_named_baseobject_error_msg", - ), - "skbase.validate._type_checks": ( - "check_sequence", - "check_type", - "is_sequence", - "_convert_scalar_seq_type_input_to_tuple", - ), - } -) # Fixture class for testing tag system diff --git a/skbase/tests/mock_package/__init__.py b/skbase/tests/mock_package/__init__.py index ec467ed8..a8bc0c67 100644 --- a/skbase/tests/mock_package/__init__.py +++ b/skbase/tests/mock_package/__init__.py @@ -3,4 +3,29 @@ from typing import List +from .test_fixtures import Child # noqa: F401 +from .test_fixtures import ClassWithABTrue # noqa: F401 +from .test_fixtures import Parent # noqa: F401 +from .test_mock_package import MOCK_PACKAGE_CLASSES_BY_MODULE # noqa: F401 +from .test_mock_package import MOCK_PACKAGE_FUNCTIONS_BY_MODULE # noqa: F401 +from .test_mock_package import MOCK_PACKAGE_MODULES # noqa: F401 +from .test_mock_package import MOCK_PACKAGE_OBJECTS # noqa: F401 +from .test_mock_package import MOCK_PACKAGE_PUBLIC_CLASSES_BY_MODULE # noqa: F401 +from .test_mock_package import MOCK_PACKAGE_PUBLIC_FUNCTIONS_BY_MODULE # noqa: F401 +from .test_mock_package import MOCK_PACKAGE_PUBLIC_MODULES # noqa: F401 +from .test_mock_package import AnotherClass # noqa: F401 +from .test_mock_package import CompositionDummy # noqa: F401 +from .test_mock_package import InheritsFromBaseObject # noqa: F401 +from .test_mock_package import NotABaseObject # noqa: F401 + +__all__: List[str] = [ + "MOCK_PACKAGE_OBJECTS", + "MOCK_PACKAGE_PUBLIC_CLASSES_BY_MODULE", + "MOCK_PACKAGE_CLASSES_BY_MODULE", + "MOCK_PACKAGE_PUBLIC_FUNCTIONS_BY_MODULE", + "MOCK_PACKAGE_FUNCTIONS_BY_MODULE", + "MOCK_PACKAGE_PUBLIC_MODULES", + "MOCK_PACKAGE_MODULES", +] + __author__: List[str] = ["fkiraly", "RNKuhns"] diff --git a/skbase/tests/mock_package/_private_pkg/__init__.py b/skbase/tests/mock_package/_private_pkg/__init__.py new file mode 100644 index 00000000..1520548d --- /dev/null +++ b/skbase/tests/mock_package/_private_pkg/__init__.py @@ -0,0 +1,2 @@ +# -*- coding: utf-8 -*- +"""Private subpackage for mock lookup discovery tests.""" diff --git a/skbase/tests/mock_package/_private_pkg/test_module.py b/skbase/tests/mock_package/_private_pkg/test_module.py new file mode 100644 index 00000000..0ec0b109 --- /dev/null +++ b/skbase/tests/mock_package/_private_pkg/test_module.py @@ -0,0 +1,30 @@ +# -*- coding: utf-8 -*- +"""Private module in mock package for non-public lookup coverage.""" + +from skbase.base import BaseObject + + +class PrivateModuleClass(BaseObject): + """Represent a publicly named class in a private module.""" + + +class _PrivateModuleHiddenClass(BaseObject): + """Represent a non-public class in a private module.""" + + +def private_module_public_function(): + """Return marker for a public function in a private module.""" + return "visible-only-when-non-public-modules-included" + + +def _private_module_hidden_function(): + """Return marker for a private function in a private module.""" + return "visible-only-when-non-public-items-included" + + +__all__ = [ + "PrivateModuleClass", + "_PrivateModuleHiddenClass", + "private_module_public_function", + "_private_module_hidden_function", +] diff --git a/skbase/tests/mock_package/subpkg/__init__.py b/skbase/tests/mock_package/subpkg/__init__.py new file mode 100644 index 00000000..2ad3b493 --- /dev/null +++ b/skbase/tests/mock_package/subpkg/__init__.py @@ -0,0 +1,3 @@ +"""Subpackage in mock package to test recursive walking.""" + +__all__ = ["test_module_b"] diff --git a/skbase/tests/mock_package/subpkg/test_module_b.py b/skbase/tests/mock_package/subpkg/test_module_b.py new file mode 100644 index 00000000..ec10b405 --- /dev/null +++ b/skbase/tests/mock_package/subpkg/test_module_b.py @@ -0,0 +1,10 @@ +# -*- coding: utf-8 -*- +"""Module inside subpackage to test recursive discovery.""" + + +def subpkg_fn(): + """Return the string "ok" to indicate functionality.""" + return "ok" + + +__all__ = ["subpkg_fn"] diff --git a/skbase/tests/mock_package/test_fixtures.py b/skbase/tests/mock_package/test_fixtures.py new file mode 100644 index 00000000..23a618ca --- /dev/null +++ b/skbase/tests/mock_package/test_fixtures.py @@ -0,0 +1,47 @@ +# -*- coding: utf-8 -*- +"""Additional fixture classes for the mock package used in lookup tests.""" + +from typing import List + +from skbase.base import BaseObject + +__author__: List[str] = ["fkiraly", "RNKuhns"] + + +class Parent(BaseObject): + """Parent class to test tag inheritance and class filters.""" + + _tags = {"A": "1", "B": 2, "C": 1234, "3": "D"} + + def __init__(self, a="something", b=7, c=None): + """Initialize the fixture with simple attributes.""" + self.a = a + self.b = b + self.c = c + super().__init__() + + def some_method(self): + """Placeholder method used in tests.""" + pass + + +class Child(Parent): + """Child class that overrides some tags.""" + + _tags = {"A": 42, "3": "E"} + __author__ = ["fkiraly", "RNKuhns"] + + def some_method(self): + """Child placeholder method used in tests.""" + pass + + +class ClassWithABTrue(Parent): + """Child class that sets A and B tags to True.""" + + _tags = {"A": True, "B": True} + __author__ = ["fkiraly", "RNKuhns"] + + def some_method(self): + """Placeholder method used in tests.""" + pass diff --git a/skbase/tests/mock_package/test_mock_package.py b/skbase/tests/mock_package/test_mock_package.py index 2ecbf6b9..6254b6df 100644 --- a/skbase/tests/mock_package/test_mock_package.py +++ b/skbase/tests/mock_package/test_mock_package.py @@ -6,6 +6,8 @@ from skbase.base import BaseObject +from .test_fixtures import Child, ClassWithABTrue, Parent + __all__: List[str] = [ "CompositionDummy", "InheritsFromBaseObject", @@ -72,4 +74,96 @@ class _NonPublicClass(BaseObject): CompositionDummy, InheritsFromBaseObject, _NonPublicClass, + Parent, + Child, + ClassWithABTrue, ] + +# Expected public classes by module for validation +MOCK_PACKAGE_PUBLIC_CLASSES_BY_MODULE = { + "skbase.tests.mock_package._private_pkg.test_module": ("PrivateModuleClass",), + "skbase.tests.mock_package.test_mock_package": ( + "AnotherClass", + "CompositionDummy", + "InheritsFromBaseObject", + "NotABaseObject", + ), + "skbase.tests.mock_package.test_fixtures": ( + "Child", + "ClassWithABTrue", + "Parent", + ), +} + +# Expected all classes by module (including non-public) for validation +MOCK_PACKAGE_CLASSES_BY_MODULE = { + "skbase.tests.mock_package._private_pkg.test_module": ( + "PrivateModuleClass", + "_PrivateModuleHiddenClass", + ), + "skbase.tests.mock_package.test_mock_package": ( + "AnotherClass", + "CompositionDummy", + "InheritsFromBaseObject", + "NotABaseObject", + "_NonPublicClass", + ), + "skbase.tests.mock_package.test_fixtures": ( + "Child", + "ClassWithABTrue", + "Parent", + ), + "skbase.tests.mock_package.test_private_module": ("_PrivateThing",), +} + +# Expected public functions by module for validation +MOCK_PACKAGE_PUBLIC_FUNCTIONS_BY_MODULE = { + "skbase.tests.mock_package._private_pkg.test_module": ( + "private_module_public_function", + ), + "skbase.tests.mock_package.test_module_public": ( + "decorated_function", + "my_decorator", + "simple_function", + ), + "skbase.tests.mock_package.subpkg.test_module_b": ("subpkg_fn",), +} + +# Expected all functions by module (including non-public) for validation +MOCK_PACKAGE_FUNCTIONS_BY_MODULE = { + "skbase.tests.mock_package._private_pkg.test_module": ( + "private_module_public_function", + "_private_module_hidden_function", + ), + "skbase.tests.mock_package.test_module_public": ( + "decorated_function", + "_private_helper", + "my_decorator", + "simple_function", + ), + "skbase.tests.mock_package.subpkg.test_module_b": ("subpkg_fn",), +} + +# List of all public modules in mock package +MOCK_PACKAGE_PUBLIC_MODULES = ( + "skbase.tests.mock_package", + "skbase.tests.mock_package.subpkg", + "skbase.tests.mock_package.subpkg.test_module_b", + "skbase.tests.mock_package.test_fixtures", + "skbase.tests.mock_package.test_mock_package", + "skbase.tests.mock_package.test_module_public", + "skbase.tests.mock_package.test_private_module", +) + +# List of all modules (including non-public) in mock package +MOCK_PACKAGE_MODULES = ( + "skbase.tests.mock_package", + "skbase.tests.mock_package._private_pkg", + "skbase.tests.mock_package._private_pkg.test_module", + "skbase.tests.mock_package.subpkg", + "skbase.tests.mock_package.subpkg.test_module_b", + "skbase.tests.mock_package.test_fixtures", + "skbase.tests.mock_package.test_mock_package", + "skbase.tests.mock_package.test_module_public", + "skbase.tests.mock_package.test_private_module", +) diff --git a/skbase/tests/mock_package/test_module_public.py b/skbase/tests/mock_package/test_module_public.py new file mode 100644 index 00000000..a352fd0c --- /dev/null +++ b/skbase/tests/mock_package/test_module_public.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +"""Public module in mock package with decorated and plain functions.""" + +from functools import wraps + + +def simple_function(x): + """Double the given input and return the result.""" + return x * 2 + + +def my_decorator(func): + @wraps(func) + def wrapper(*args, **kwargs): + return func(*args, **kwargs) + + return wrapper + + +@my_decorator +def decorated_function(y): + """Increment the given input by one and return the result.""" + return y + 1 + + +def _private_helper(z): + """Private helper to exercise non-public function filtering.""" + return z - 1 + + +__all__ = ["simple_function", "decorated_function"] diff --git a/skbase/tests/mock_package/test_private_module.py b/skbase/tests/mock_package/test_private_module.py new file mode 100644 index 00000000..49d13e66 --- /dev/null +++ b/skbase/tests/mock_package/test_private_module.py @@ -0,0 +1,18 @@ +# -*- coding: utf-8 -*- +"""Non-public module in mock package; contains a non-public BaseObject subclass. + +This module's class name begins with an underscore and should be ignored by +`all_objects` when `exclude_non_public_items` is True. +""" + +from skbase.base import BaseObject + + +class _PrivateThing(BaseObject): + """A non-public BaseObject subclass that should be ignored by discovery.""" + + def __init__(self): + super().__init__() + + +__all__ = ["_PrivateThing"]