winipedia-utils 0.2.63__py3-none-any.whl → 0.6.6__py3-none-any.whl

winipedia_utils/projects/project.py

@@ -1,48 +1,17 @@
 """Utilities for working with Python projects."""
 
-from types import ModuleType
+from winipedia_utils.modules.module import create_module
+from winipedia_utils.projects.poetry.config import (
+    PyprojectConfigFile,  # avoid circular import
+)
+from winipedia_utils.text.config import (
+    ConfigFile,  # avoid circular import
+)
 
-from winipedia_utils.modules.module import create_module, to_path
-from winipedia_utils.modules.package import get_src_package
-from winipedia_utils.projects.poetry.config import get_poetry_package_name
 
-
-def _create_project_root() -> None:
+def create_project_root() -> None:
     """Create the project root."""
-    src_package_name = get_poetry_package_name()
-    create_module(src_package_name, is_package=True)
-    _create_py_typed()
-
-
-def _create_py_typed() -> None:
-    """Create the py.typed file."""
-    src_package_name = get_src_package().__name__
-    py_typed_path = to_path(src_package_name, is_package=True) / "py.typed"
-    py_typed_path.touch()
-
+    ConfigFile.init_config_files()
 
-def make_name_from_package(
-    package: ModuleType,
-    split_on: str = "_",
-    join_on: str = "-",
-    *,
-    capitalize: bool = True,
-) -> str:
-    """Make a name from a package.
-
-    takes a package and makes a name from it that is readable by humans.
-
-    Args:
-        package (ModuleType): The package to make a name from
-        split_on (str, optional): what to split the package name on. Defaults to "_".
-        join_on (str, optional): what to join the package name with. Defaults to "-".
-        capitalize (bool, optional): Whether to capitalize each part. Defaults to True.
-
-    Returns:
-        str: _description_
-    """
-    package_name = package.__name__.split(".")[-1]
-    parts = package_name.split(split_on)
-    if capitalize:
-        parts = [part.capitalize() for part in parts]
-    return join_on.join(parts)
+    src_package_name = PyprojectConfigFile.get_package_name()
+    create_module(src_package_name, is_package=True)

winipedia_utils/setup.py

@@ -9,51 +9,33 @@ This script is intended to be called once at the beginning of a project.
 from collections.abc import Callable
 from typing import Any
 
-from winipedia_utils.git.gitignore.gitignore import _add_package_patterns_to_gitignore
-from winipedia_utils.git.pre_commit.config import (
-    _add_package_hook_to_pre_commit_config,
-    _pre_commit_install,
-)
-from winipedia_utils.git.pre_commit.run_hooks import _run_all_hooks
-from winipedia_utils.git.workflows.publish import _add_publish_workflow
-from winipedia_utils.git.workflows.release import _add_release_workflow
+from winipedia_utils.git.gitignore.config import GitIgnoreConfigFile
+from winipedia_utils.git.pre_commit.run_hooks import run_hooks
 from winipedia_utils.logging.logger import get_logger
-from winipedia_utils.projects.poetry.config import (
-    _add_configurations_to_pyproject_toml,
-)
-from winipedia_utils.projects.poetry.poetry import (
-    _install_dev_dependencies,
-)
-from winipedia_utils.projects.project import _create_project_root
+from winipedia_utils.projects.project import create_project_root
 
 logger = get_logger(__name__)
 
 
-SETUP_STEPS = [
-    _install_dev_dependencies,
-    _add_package_hook_to_pre_commit_config,
-    _pre_commit_install,
-    _add_package_patterns_to_gitignore,
-    _add_release_workflow,
-    _add_publish_workflow,
-    _add_configurations_to_pyproject_toml,
-    _create_project_root,
-    _run_all_hooks,
+SETUP_STEPS: list[Callable[..., Any]] = [
+    GitIgnoreConfigFile,  # must be first
+    create_project_root,
+    run_hooks,
 ]
 
 
-def _get_setup_steps() -> list[Callable[..., Any]]:
+def get_setup_steps() -> list[Callable[..., Any]]:
     """Get the setup steps."""
     return SETUP_STEPS
 
 
-def _setup() -> None:
+def setup() -> None:
     """Set up the project."""
-    for step in _get_setup_steps():
+    for step in get_setup_steps():
         logger.info("Running setup step: %s", step.__name__)
         step()
     logger.info("Setup complete!")
 
 
 if __name__ == "__main__":
-    _setup()
+    setup()

winipedia_utils/testing/config.py

@@ -0,0 +1,127 @@
+"""Config utilities for testing."""
+
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any
+
+from winipedia_utils.testing.convention import TESTS_PACKAGE_NAME
+from winipedia_utils.text.config import ConfigFile
+
+
+class PythonConfigFile(ConfigFile):
+    """Base class for python config files."""
+
+    CONTENT_KEY = "content"
+
+    @classmethod
+    def load(cls) -> dict[str, str]:
+        """Load the config file."""
+        return {cls.CONTENT_KEY: cls.get_path().read_text()}
+
+    @classmethod
+    def dump(cls, config: dict[str, Any] | list[Any]) -> None:
+        """Dump the config file."""
+        if not isinstance(config, dict):
+            msg = f"Cannot dump {config} to python file."
+            raise TypeError(msg)
+        cls.get_path().write_text(config[cls.CONTENT_KEY])
+
+    @classmethod
+    def get_file_extension(cls) -> str:
+        """Get the file extension of the config file."""
+        return "py"
+
+    @classmethod
+    def get_configs(cls) -> dict[str, Any]:
+        """Get the config."""
+        return {cls.CONTENT_KEY: cls.get_content_str()}
+
+    @classmethod
+    def get_file_content(cls) -> str:
+        """Get the file content."""
+        return cls.load()[cls.CONTENT_KEY]
+
+    @classmethod
+    @abstractmethod
+    def get_content_str(cls) -> str:
+        """Get the content."""
+
+    @classmethod
+    def is_correct(cls) -> bool:
+        """Check if the config is correct.
+
+        Python files are correct if they exist and contain the correct content.
+        """
+        return (
+            super().is_correct()
+            or cls.get_content_str().strip() in cls.load()[cls.CONTENT_KEY]
+        )
+
+
+class PythonTestsConfigFile(PythonConfigFile):
+    """Base class for python config files in the tests directory."""
+
+    @classmethod
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+        return Path(TESTS_PACKAGE_NAME)
+
+
+class ConftestConfigFile(PythonTestsConfigFile):
+    """Config file for conftest.py."""
+
+    @classmethod
+    def get_content_str(cls) -> str:
+        """Get the config content."""
+        return '''"""Pytest configuration for tests.
+
+This module configures pytest plugins for the test suite, setting up the necessary
+fixtures and hooks for the different
+test scopes (function, class, module, package, session).
+It also import custom plugins from tests/base/scopes.
+This file should not be modified manually.
+"""
+
+pytest_plugins = ["winipedia_utils.testing.tests.conftest"]
+'''
+
+
+class ZeroTestConfigFile(PythonTestsConfigFile):
+    """Config file for test_zero.py."""
+
+    @classmethod
+    def get_filename(cls) -> str:
+        """Get the filename of the config file."""
+        filename = super().get_filename()
+        return "_".join(reversed(filename.split("_")))
+
+    @classmethod
+    def get_content_str(cls) -> str:
+        """Get the config."""
+        return '''"""Contains an empty test."""
+
+
+def test_zero() -> None:
+    """Empty test.
+
+    Exists so that when no tests are written yet the base fixtures are executed.
+    """
+'''
+
+
+class ExperimentConfigFile(PythonConfigFile):
+    """Config file for experiment.py.
+
+    Is at root level and in .gitignore for experimentation.
+    """
+
+    @classmethod
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+        return Path()
+
+    @classmethod
+    def get_content_str(cls) -> str:
+        """Get the config."""
+        return '''"""This file is for experimentation and is ignored by git."""
+'''

winipedia_utils/testing/create_tests.py

@@ -6,7 +6,6 @@ It creates the basic test structure and generates skeleton test functions with
 NotImplementedError to indicate tests that need to be written.
 """
 
-from pathlib import Path
 from types import ModuleType
 from typing import cast
 
@@ -15,11 +14,11 @@ from winipedia_utils.modules.class_ import (
     get_all_methods_from_cls,
 )
 from winipedia_utils.modules.function import get_all_functions_from_module
+from winipedia_utils.modules.inspection import get_qualname_of_obj
 from winipedia_utils.modules.module import (
     create_module,
     get_isolated_obj_name,
     get_module_content_as_str,
-    get_qualname_of_obj,
     to_path,
 )
 from winipedia_utils.modules.package import (
@@ -28,19 +27,13 @@ from winipedia_utils.modules.package import (
     walk_package,
 )
 from winipedia_utils.testing import tests
+from winipedia_utils.testing.config import ConftestConfigFile, ZeroTestConfigFile
 from winipedia_utils.testing.convention import (
-    TESTS_PACKAGE_NAME,
     get_test_obj_from_obj,
     make_test_obj_importpath_from_obj,
     make_test_obj_name,
     reverse_make_test_obj_name,
 )
-from winipedia_utils.testing.tests.base.utils.utils import (
-    _conftest_content_is_correct,
-    _get_conftest_content,
-    _get_test_0_content,
-    _test_0_content_is_correct,
-)
 
 
 def create_tests() -> None:
@@ -63,21 +56,14 @@ def create_tests_base() -> None:
     4. Creates a conftest.py file with the appropriate pytest plugin configuration
     5. Does not overwrite anything if it already exists except conftest.py
     """
-    tests_path = Path(TESTS_PACKAGE_NAME)
     copy_package(
         src_package=tests,
         dst=".",
         with_file_content=False,
     )
-    # write pytest_plugin in the conftest.py
-    conftest_path = tests_path / "conftest.py"
-    # if conftest does not exist or the content is not the same, overwrite it
-    if not _conftest_content_is_correct(conftest_path):
-        conftest_path.write_text(_get_conftest_content())
-
-    test_0_path = tests_path / "test_0.py"
-    if not _test_0_content_is_correct(test_0_path):
-        test_0_path.write_text(_get_test_0_content())
+    # write the config files
+    _ = ConftestConfigFile()
+    _ = ZeroTestConfigFile()
 
 
 def create_tests_for_src_package() -> None:

winipedia_utils/testing/skip.py

@@ -0,0 +1,19 @@
+"""Has utils towards skipping tests."""
+
+import functools
+
+import pytest
+
+from winipedia_utils.git.github.github import running_in_github_actions
+
+skip_fixture_test: pytest.MarkDecorator = functools.partial(
+    pytest.mark.skip,
+    reason="Fixtures are not testable bc they cannot be called directly.",
+)()
+
+
+skip_in_github_actions: pytest.MarkDecorator = functools.partial(
+    pytest.mark.skipif,
+    running_in_github_actions(),
+    reason="Test cannot run in GitHub action.",
+)()

winipedia_utils/testing/tests/base/fixtures/fixture.py

@@ -4,3 +4,39 @@ This module provides custom fixtures for pytest that can be used to
 automate common testing tasks and provide consistent setup and teardown
 for tests.
 """
+
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+from winipedia_utils.text.config import ConfigFile
+
+
+@pytest.fixture
+def config_file_factory[T: ConfigFile](
+    tmp_path: Path,
+) -> Callable[[type[T]], type[T]]:
+    """Factory fixture for creating config file classes with tmp_path.
+
+    This factory wraps any ConfigFile subclass to use tmp_path for get_path().
+    Define tmp_path once here, then all test config classes inherit it.
+    """
+
+    def _make_test_config(
+        base_class: type[T],
+    ) -> type[T]:
+        """Create a test config class that uses tmp_path."""
+
+        class TestConfigFile(base_class):  # type: ignore [misc, valid-type]
+            """Test config file with tmp_path override."""
+
+            @classmethod
+            def get_path(cls) -> Path:
+                """Get the path to the config file in tmp_path."""
+                path = super().get_path()
+                return Path(tmp_path / path)
+
+        return TestConfigFile
+
+    return _make_test_config

winipedia_utils/testing/tests/base/fixtures/scopes/class_.py

@@ -9,11 +9,11 @@ mechanism.
 import pytest
 
 from winipedia_utils.testing.fixtures import autouse_class_fixture
-from winipedia_utils.testing.tests.base.utils.utils import _assert_no_untested_objs
+from winipedia_utils.testing.tests.base.utils.utils import assert_no_untested_objs
 
 
 @autouse_class_fixture
-def _test_all_methods_tested(request: pytest.FixtureRequest) -> None:
+def assert_all_methods_tested(request: pytest.FixtureRequest) -> None:
     """Verify that all methods in a class have corresponding tests.
 
     This fixture runs automatically for each test class and checks that every
@@ -30,4 +30,4 @@ def _test_all_methods_tested(request: pytest.FixtureRequest) -> None:
     class_ = request.node.cls
     if class_ is None:
         return
-    _assert_no_untested_objs(class_)
+    assert_no_untested_objs(class_)

winipedia_utils/testing/tests/base/fixtures/scopes/module.py

@@ -6,14 +6,19 @@ These fixtures are automatically applied to all test modules through pytest's au
 mechanism.
 """
 
+from typing import TYPE_CHECKING
+
 import pytest
 
 from winipedia_utils.testing.fixtures import autouse_module_fixture
-from winipedia_utils.testing.tests.base.utils.utils import _assert_no_untested_objs
+from winipedia_utils.testing.tests.base.utils.utils import assert_no_untested_objs
+
+if TYPE_CHECKING:
+    from types import ModuleType
 
 
 @autouse_module_fixture
-def _test_all_funcs_and_classes_tested(request: pytest.FixtureRequest) -> None:
+def assert_all_funcs_and_classes_tested(request: pytest.FixtureRequest) -> None:
     """Verify that all functions and classes in a module have corresponding tests.
 
     This fixture runs automatically for each test module and checks that every
@@ -27,7 +32,5 @@ def _test_all_funcs_and_classes_tested(request: pytest.FixtureRequest) -> None:
         AssertionError: If any function or class in the source module lacks a test
 
     """
-    module = request.module
-    if module.__name__ == "tests.test_0":
-        return
-    _assert_no_untested_objs(module)
+    module: ModuleType = request.module
+    assert_no_untested_objs(module)