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

winipedia_utils/projects/poetry/config.py

@@ -3,115 +3,127 @@
 from pathlib import Path
 from typing import Any
 
-import tomlkit
-from tomlkit.toml_document import TOMLDocument
-
-from winipedia_utils.projects.poetry.poetry import logger
-
-
-def laod_pyproject_toml() -> TOMLDocument:
-    """Load the pyproject.toml file."""
-    return tomlkit.parse(Path("pyproject.toml").read_text())
-
-
-def get_dev_dependencies_from_pyproject_toml() -> set[str]:
-    """Get the dev dependencies from pyproject.toml."""
-    toml = laod_pyproject_toml()
-    dev_dependencies = (
-        toml.get("tool", {})
-        .get("poetry", {})
-        .get("group", {})
-        .get("dev", {})
-        .get("dependencies", {})
-        .keys()
-    )
-    if not dev_dependencies:
-        dev_dependencies = toml.get("dependency-groups", {}).get("dev", [])
-        dev_dependencies = [d.split("(")[0].strip() for d in dev_dependencies]
-    return set(dev_dependencies)
-
-
-def dump_pyproject_toml(toml: TOMLDocument) -> None:
-    """Dump the pyproject.toml file."""
-    with Path("pyproject.toml").open("w") as f:
-        tomlkit.dump(toml, f)
-
-
-def get_poetry_package_name() -> str:
-    """Get the name of the project from pyproject.toml."""
-    toml = laod_pyproject_toml()
-    project_dict = toml.get("project", {})
-    project_name = str(project_dict.get("name", ""))
-    return project_name.replace("-", "_")
-
-
-def _get_pyproject_toml_tool_configs() -> dict[str, Any]:
-    """Get the tool configurations for pyproject.toml."""
-    return {
-        "ruff": {
-            "exclude": [".*", "**/migrations/*.py"],
-            "lint": {
-                "select": ["ALL"],
-                "ignore": ["D203", "D213", "COM812", "ANN401"],
-                "fixable": ["ALL"],
-                "pydocstyle": {
-                    "convention": "google",
+from winipedia_utils.modules.package import get_src_package
+from winipedia_utils.projects.project import make_name_from_package
+from winipedia_utils.testing.convention import TESTS_PACKAGE_NAME
+from winipedia_utils.text.config import ConfigFile, TomlConfigFile
+
+
+class PyProjectTomlConfig(TomlConfigFile):
+    """Config file for pyproject.toml."""
+
+    PATH = Path("pyproject.toml")
+
+    def get_path(self) -> Path:
+        """Get the path to the config file."""
+        return self.PATH
+
+    def get_configs(self) -> dict[str, Any]:
+        """Get the config."""
+        return {
+            "project": {
+                "name": make_name_from_package(get_src_package(), capitalize=False),
+                "readme": "README.md",
+                "dynamic": ["dependencies"],
+            },
+            "build-system": {
+                "requires": ["poetry-core>=2.0.0,<3.0.0"],
+                "build-backend": "poetry.core.masonry.api",
+            },
+            "tool": {
+                "poetry": {
+                    "packages": [{"include": get_src_package().__name__}],
+                    "group": {
+                        "dev": {
+                            "dependencies": dict.fromkeys(
+                                [
+                                    "ruff",
+                                    "pre-commit",
+                                    "mypy",
+                                    "pytest",
+                                    "bandit",
+                                    "types-setuptools",
+                                    "types-tqdm",
+                                    "types-defusedxml",
+                                    "types-pyyaml",
+                                    "pytest-mock",
+                                ],
+                                "*",
+                            )
+                        }
+                    },
+                },
+                "ruff": {
+                    "exclude": [".*", "**/migrations/*.py"],
+                    "lint": {
+                        "select": ["ALL"],
+                        "ignore": ["D203", "D213", "COM812", "ANN401"],
+                        "fixable": ["ALL"],
+                        "pydocstyle": {"convention": "google"},
+                    },
+                },
+                "mypy": {
+                    "strict": True,
+                    "warn_unreachable": True,
+                    "show_error_codes": True,
+                    "files": ".",
                 },
+                "pytest": {"ini_options": {"testpaths": [TESTS_PACKAGE_NAME]}},
+                "bandit": {},
             },
-        },
-        "mypy": {
-            "strict": True,
-            "warn_unreachable": True,
-            "show_error_codes": True,
-            "files": ".",
-        },
-        "pytest": {
-            "ini_options": {
-                "testpaths": ["tests"],
-            }
-        },
-        "bandit": {},
-    }
-
-
-def _tool_config_is_correct(tool: str, config: dict[str, Any]) -> bool:
-    """Check if the tool configuration in pyproject.toml is correct."""
-    toml = laod_pyproject_toml()
-    actual_tools = toml.get("tool", {})
-
-    return bool(actual_tools.get(tool) == config)
-
-
-def _pyproject_tool_configs_are_correct() -> bool:
-    """Check if the tool configurations in pyproject.toml are correct."""
-    expected_tool_dict = _get_pyproject_toml_tool_configs()
-    for tool, config in expected_tool_dict.items():
-        if not _tool_config_is_correct(tool, config):
-            return False
-
-    return True
-
-
-def _add_configurations_to_pyproject_toml() -> None:
-    """Add tool.* configurations to pyproject.toml."""
-    expected_tool_dict = _get_pyproject_toml_tool_configs()
-    toml = laod_pyproject_toml()
-    actual_tool_dict = toml.get("tool", None)
-    if actual_tool_dict is None:
-        # add tool section
-        toml.add("tool", tomlkit.table())
-
-    actual_tool_dict = toml.get("tool", None)
-    if actual_tool_dict is None:
-        msg = "tool section is None after adding it"
-        raise ValueError(msg)
-
-    # update the toml dct and dump it but only update the tools specified not all tools
-    for tool, config in expected_tool_dict.items():
-        # if tool section already exists skip it
-        if not _tool_config_is_correct(tool, config):
-            logger.info("Adding tool.%s configuration to pyproject.toml", tool)
-            # updates inplace of toml_dict["tool"][tool]
-            actual_tool_dict[tool] = config
-
-    dump_pyproject_toml(toml)
+        }
+
+    def get_package_name(self) -> str:
+        """Get the package name."""
+        project_dict = self.load().get("project", {})
+        package_name = str(project_dict.get("name", ""))
+        return package_name.replace("-", "_")
+
+    def get_dev_dependencies(self) -> set[str]:
+        """Get the dev dependencies."""
+        dev_dependencies = set(
+            self.load()
+            .get("tool", {})
+            .get("poetry", {})
+            .get("group", {})
+            .get("dev", {})
+            .get("dependencies", {})
+            .keys()
+        )
+        if not dev_dependencies:
+            dev_dependencies = set(
+                self.load().get("dependency-groups", {}).get("dev", [])
+            )
+            dev_dependencies = {d.split("(")[0].strip() for d in dev_dependencies}
+        return dev_dependencies
+
+    def get_expected_dev_dependencies(self) -> set[str]:
+        """Get the expected dev dependencies."""
+        return set(
+            self.get_configs()["tool"]["poetry"]["group"]["dev"]["dependencies"].keys()
+        )
+
+
+class PyTypedConfigFile(ConfigFile):
+    """Config file for py.typed."""
+
+    def get_path(self) -> Path:
+        """Get the path to the config file."""
+        toml_config = PyProjectTomlConfig()
+        package_name = toml_config.get_package_name()
+        return Path(package_name) / "py.typed"
+
+    def load(self) -> dict[str, Any]:
+        """Load the config file."""
+        return {}
+
+    def dump(self, config: dict[str, Any]) -> None:
+        """Dump the config file."""
+        if config:
+            msg = "Cannot dump to py.typed file."
+            raise ValueError(msg)
+        self.path.touch()
+
+    def get_configs(self) -> dict[str, Any]:
+        """Get the config."""
+        return {}

winipedia_utils/projects/poetry/poetry.py

@@ -5,9 +5,8 @@ This module provides utility functions for working with Python projects
 
 import sys
 
-from winipedia_utils.consts import _DEV_DEPENDENCIES
 from winipedia_utils.logging.logger import get_logger
-from winipedia_utils.os.os import run_subprocess, which_with_raise
+from winipedia_utils.os.os import which_with_raise
 
 logger = get_logger(__name__)
 
@@ -23,9 +22,3 @@ POETRY_ADD_DEV_ARGS = [*POETRY_ADD_ARGS, "--group", "dev"]
 POETRY_RUN_PYTHON_ARGS = [*POETRY_RUN_ARGS, sys.executable]
 
 POETRY_RUN_RUFF_ARGS = [*POETRY_RUN_ARGS, "ruff"]
-
-
-def _install_dev_dependencies() -> None:
-    """Install winipedia_utils dev dependencies as dev dependencies."""
-    logger.info("Adding dev dependencies: %s", _DEV_DEPENDENCIES)
-    run_subprocess([*POETRY_ADD_DEV_ARGS, *_DEV_DEPENDENCIES], check=True)

winipedia_utils/projects/project.py

@@ -2,23 +2,17 @@
 
 from types import ModuleType
 
-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
+from winipedia_utils.modules.module import create_module
 
 
-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()
-
+    from winipedia_utils.projects.poetry.config import (  # noqa: PLC0415  # avoid circular import
+        PyProjectTomlConfig,
+    )
 
-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()
+    src_package_name = PyProjectTomlConfig().get_package_name()
+    create_module(src_package_name, is_package=True)
 
 
 def make_name_from_package(

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.pre_commit.run_hooks import run_all
 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
+from winipedia_utils.text.config import ConfigFile
 
 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]] = [
+    ConfigFile.init_config_files,
+    create_project_root,
+    run_all,
 ]
 
 
-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,95 @@
+"""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"
+
+    def load(self) -> dict[str, str]:
+        """Load the config file."""
+        return {self.CONTENT_KEY: self.path.read_text()}
+
+    def dump(self, config: dict[str, Any]) -> None:
+        """Dump the config file."""
+        self.path.write_text(config[self.CONTENT_KEY])
+
+    def get_configs(self) -> dict[str, Any]:
+        """Get the config."""
+        return {self.CONTENT_KEY: self.get_content()}
+
+    @abstractmethod
+    def get_content(self) -> str:
+        """Get the content."""
+        return self.load()[self.CONTENT_KEY]
+
+
+class ConftestConfigFile(PythonConfigFile):
+    """Config file for conftest.py."""
+
+    PATH = Path(f"{TESTS_PACKAGE_NAME}/conftest.py")
+
+    def get_path(self) -> Path:
+        """Get the path to the config file."""
+        return self.PATH
+
+    def get_content(self) -> 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(PythonConfigFile):
+    """Config file for test_0.py."""
+
+    PATH = Path(f"{TESTS_PACKAGE_NAME}/test_0.py")
+
+    def get_path(self) -> Path:
+        """Get the path to the config file."""
+        return self.PATH
+
+    def get_content(self) -> str:
+        """Get the config."""
+        return '''"""Contains an empty test."""
+
+
+def test_0() -> 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.
+    """
+
+    PATH = Path("experiment.py")
+
+    def get_path(self) -> Path:
+        """Get the path to the config file."""
+        return self.PATH
+
+    def get_content(self) -> 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
 
@@ -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,10 @@
+"""Has utils towards skipping tests."""
+
+import functools
+
+import pytest
+
+skip_fixture_test: pytest.MarkDecorator = functools.partial(
+    pytest.mark.skip,
+    reason="Fixtures are not testable bc they cannot be called directly.",
+)()

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

@@ -8,12 +8,14 @@ mechanism.
 
 import pytest
 
+from winipedia_utils.modules.module import to_module_name
+from winipedia_utils.testing.config import ZeroTestConfigFile
 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
 
 
 @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
@@ -28,6 +30,6 @@ def _test_all_funcs_and_classes_tested(request: pytest.FixtureRequest) -> None:
 
     """
     module = request.module
-    if module.__name__ == "tests.test_0":
+    if module.__name__ == to_module_name(ZeroTestConfigFile().get_path()):
         return
-    _assert_no_untested_objs(module)
+    assert_no_untested_objs(module)