winipedia-utils 0.3.43__py3-none-any.whl → 0.4.18__py3-none-any.whl

winipedia_utils/git/{workflows → github/workflows}/publish.py

@@ -5,8 +5,8 @@ This workflow is used to publish the package to PyPI with poetry.
 
 from typing import Any
 
-from winipedia_utils.git.workflows.base.base import Workflow
-from winipedia_utils.git.workflows.release import ReleaseWorkflow
+from winipedia_utils.git.github.workflows.base.base import Workflow
+from winipedia_utils.git.github.workflows.release import ReleaseWorkflow
 
 
 class PublishWorkflow(Workflow):
@@ -16,7 +16,8 @@ class PublishWorkflow(Workflow):
     It publishes the package to PyPI with poetry.
     """
 
-    def get_workflow_triggers(self) -> dict[str, Any]:
+    @classmethod
+    def get_workflow_triggers(cls) -> dict[str, Any]:
         """Get the workflow triggers."""
         return {
             "workflow_run": {
@@ -25,22 +26,24 @@ class PublishWorkflow(Workflow):
             },
         }
 
-    def get_permissions(self) -> dict[str, Any]:
+    @classmethod
+    def get_permissions(cls) -> dict[str, Any]:
         """Get the workflow permissions."""
         return {
             "contents": "read",
         }
 
-    def get_jobs(self) -> dict[str, Any]:
+    @classmethod
+    def get_jobs(cls) -> dict[str, Any]:
         """Get the workflow jobs."""
-        return self.get_standard_job(
+        return cls.get_standard_job(
             steps=[
                 *(
-                    self.get_poetry_setup_steps(
+                    cls.get_poetry_setup_steps(
                         configure_pipy_token=True,
                     )
                 ),
-                self.get_publish_to_pypi_step(),
+                cls.get_publish_to_pypi_step(),
             ],
             if_condition="${{ github.event.workflow_run.conclusion == 'success' }}",
         )

winipedia_utils/git/github/workflows/release.py

@@ -0,0 +1,45 @@
+"""Contains the release workflow.
+
+This workflow is used to create a release on GitHub.
+"""
+
+from typing import Any
+
+from winipedia_utils.git.github.workflows.health_check import HealthCheckWorkflow
+
+
+class ReleaseWorkflow(HealthCheckWorkflow):
+    """Release workflow.
+
+    This workflow is triggered by a push to the main branch.
+    It creates a tag for the release and builds a changelog.
+    With tag and changelog it creates a release on GitHub
+    """
+
+    @classmethod
+    def get_workflow_triggers(cls) -> dict[str, Any]:
+        """Get the workflow triggers."""
+        return {
+            "push": {"branches": ["main"]},
+            "workflow_dispatch": {},
+            "schedule": [
+                {
+                    # run every Tuesday at 6 am
+                    "cron": "0 6 * * 2",
+                },
+            ],
+        }
+
+    @classmethod
+    def get_permissions(cls) -> dict[str, Any]:
+        """Get the workflow permissions."""
+        permissions = super().get_permissions()
+        permissions["contents"] = "write"
+        return permissions
+
+    @classmethod
+    def get_jobs(cls) -> dict[str, Any]:
+        """Get the workflow jobs."""
+        steps = super().get_jobs()
+        steps[cls.get_filename()]["steps"].extend(cls.get_release_steps())
+        return steps

winipedia_utils/git/gitignore/config.py

@@ -3,52 +3,72 @@
 from pathlib import Path
 from typing import Any
 
+import requests
+
+from winipedia_utils.testing.config import ExperimentConfigFile, LocalSecretsConfigFile
 from winipedia_utils.text.config import ConfigFile
 
 
 class GitIgnoreConfigFile(ConfigFile):
     """Config file for .gitignore."""
 
-    PATH = Path(".gitignore")
-
-    IGNORE_KEY = "ignore"
+    @classmethod
+    def get_filename(cls) -> str:
+        """Get the filename of the config file."""
+        return ""  # so it builds the path .gitignore and not gitignore.gitignore
 
-    def get_path(self) -> Path:
+    @classmethod
+    def get_parent_path(cls) -> Path:
         """Get the path to the config file."""
-        return self.PATH
+        return Path()
 
-    def load(self) -> dict[str, Any]:
-        """Load the config file."""
-        return self.load_static()
+    @classmethod
+    def get_file_extension(cls) -> str:
+        """Get the file extension of the config file."""
+        return "gitignore"
 
     @classmethod
-    def load_static(cls) -> dict[str, list[str]]:
+    def load(cls) -> list[str]:
         """Load the config file."""
-        paths = cls.PATH.read_text().splitlines()
-        return {cls.IGNORE_KEY: paths}
+        return cls.get_path().read_text().splitlines()
 
-    def dump(self, config: dict[str, Any]) -> None:
+    @classmethod
+    def dump(cls, config: list[str] | dict[str, Any]) -> None:
         """Dump the config file."""
-        patterns = config.get(self.IGNORE_KEY, [])
-        self.path.write_text("\n".join(patterns))
+        if not isinstance(config, list):
+            msg = f"Cannot dump {config} to .gitignore file."
+            raise TypeError(msg)
+        cls.get_path().write_text("\n".join(config))
 
-    def get_configs(self) -> dict[str, Any]:
+    @classmethod
+    def get_configs(cls) -> list[str]:
         """Get the config."""
-        from winipedia_utils.testing.config import (  # noqa: PLC0415  # avoid circular import
-            ExperimentConfigFile,
-        )
-
+        # fetch the standard github gitignore via https://github.com/github/gitignore/blob/main/Python.gitignore
         needed = [
-            "__pycache__/",
-            ".idea/",
-            ".mypy_cache/",
-            ".pytest_cache/",
-            ".ruff_cache/",
+            *cls.get_github_python_gitignore(),
+            "# vscode stuff",
             ".vscode/",
-            "dist/",
-            ".git/",  # for walk_os_skipping_gitignore_patterns func
-            ExperimentConfigFile.PATH.name,  # for executing experimental code
+            "",
+            "# winipedia_utils stuff",
+            "# for walk_os_skipping_gitignore_patterns func",
+            ".git/",
+            "# for executing experimental code",
+            ExperimentConfigFile.get_path().as_posix(),
+            "# for secrets used locally",
+            LocalSecretsConfigFile.get_path().as_posix(),
         ]
-        existing = self.load()[self.IGNORE_KEY]
+        existing = cls.load()
         needed = [p for p in needed if p not in set(existing)]
-        return {self.IGNORE_KEY: existing + needed}
+        return existing + needed
+
+    @classmethod
+    def get_github_python_gitignore(cls) -> list[str]:
+        """Get the standard github python gitignore."""
+        url = "https://raw.githubusercontent.com/github/gitignore/main/Python.gitignore"
+        res = requests.get(url, timeout=10)
+        if not res.ok:
+            if not Path(".gitignore").exists():
+                msg = f"Failed to fetch {url}. Cannot create .gitignore."
+                raise RuntimeError(msg)
+            return []
+        return res.text.splitlines()

winipedia_utils/git/gitignore/gitignore.py

@@ -40,7 +40,7 @@ def path_is_in_gitignore(relative_path: str | Path) -> bool:
 
     spec = pathspec.PathSpec.from_lines(
         "gitwildmatch",
-        GitIgnoreConfigFile.load_static()[GitIgnoreConfigFile.IGNORE_KEY],
+        GitIgnoreConfigFile.load(),
     )
 
     return spec.match_file(as_posix)

winipedia_utils/git/pre_commit/config.py

@@ -7,27 +7,27 @@ import winipedia_utils
 from winipedia_utils.logging.logger import get_logger
 from winipedia_utils.modules.package import make_name_from_package
 from winipedia_utils.os.os import run_subprocess
-from winipedia_utils.projects.poetry.poetry import POETRY_RUN_ARGS
 from winipedia_utils.text.config import YamlConfigFile
 
 logger = get_logger(__name__)
 
 
-class PreCommitConfigFile(YamlConfigFile):
+class PreCommitConfigConfigFile(YamlConfigFile):
     """Config file for pre-commit."""
 
-    PATH = Path(".pre-commit-config.yaml")
-
-    def __init__(self) -> None:
-        """Init the file."""
-        super().__init__()
-        self.install()
+    @classmethod
+    def get_filename(cls) -> str:
+        """Get the filename of the config file."""
+        filename = super().get_filename()
+        return f".{filename.replace('_', '-')}"
 
-    def get_path(self) -> Path:
+    @classmethod
+    def get_parent_path(cls) -> Path:
         """Get the path to the config file."""
-        return self.PATH
+        return Path()
 
-    def get_configs(self) -> dict[str, Any]:
+    @classmethod
+    def get_configs(cls) -> dict[str, Any]:
         """Get the config."""
         hook_name = make_name_from_package(winipedia_utils, capitalize=False)
         return {
@@ -38,7 +38,7 @@ class PreCommitConfigFile(YamlConfigFile):
                         {
                             "id": hook_name,
                             "name": hook_name,
-                            "entry": self.get_python_setup_script(),
+                            "entry": cls.get_python_setup_script(),
                             "language": "system",
                             "always_run": True,
                             "pass_filenames": False,
@@ -48,8 +48,13 @@ class PreCommitConfigFile(YamlConfigFile):
             ]
         }
 
+    def __init__(self) -> None:
+        """Init the file."""
+        super().__init__()
+        self.install()
+
     @classmethod
     def install(cls) -> None:
         """Installs the pre commits in the config."""
         logger.info("Running pre-commit install")
-        run_subprocess([*POETRY_RUN_ARGS, "pre-commit", "install"], check=True)
+        run_subprocess(["pre-commit", "install"], check=True)

winipedia_utils/git/pre_commit/hooks.py

@@ -42,20 +42,29 @@ def update_package_manager() -> list[str | Path]:
     return [POETRY_ARG, "self", "update"]
 
 
-def install_packages() -> list[str | Path]:
+def install_dependencies_with_dev() -> list[str | Path]:
     """Install all dependencies.
 
     This function returns the input for subprocess.run() to install all dependencies.
     """
-    return [POETRY_ARG, "install"]
+    return [POETRY_ARG, "install", "--with", "dev"]
 
 
-def update_packages() -> list[str | Path]:
+def update_dependencies_with_dev() -> list[str | Path]:
     """Update all dependencies.
 
     This function returns the input for subprocess.run() to update all dependencies.
     """
-    return [POETRY_ARG, "update"]
+    return [POETRY_ARG, "update", "--with", "dev"]
+
+
+def add_updates_to_git() -> list[str | Path]:
+    """Add the updated dependencies to git.
+
+    This function returns the input for subprocess.run() to add the updated
+    dependencies to git, so that the hook does not fail bc the file was changed.
+    """
+    return ["git", "add", "pyproject.toml"]
 
 
 def lock_dependencies() -> list[str | Path]:
@@ -66,6 +75,15 @@ def lock_dependencies() -> list[str | Path]:
     return [POETRY_ARG, "lock"]
 
 
+def add_lock_file_to_git() -> list[str | Path]:
+    """Add the lock file to git.
+
+    This function returns the input for subprocess.run() to add the lock file
+    to git, so that the hook does not fail bc the file was changed.
+    """
+    return ["git", "add", "poetry.lock"]
+
+
 def check_package_manager_configs() -> list[str | Path]:
     """Check that poetry.lock and pyproject.toml is up to date.
 

winipedia_utils/git/pre_commit/run_hooks.py

@@ -42,4 +42,5 @@ def run_hooks() -> None:
             passed_str,
         )
 
-    sys.exit(exit_code)
+    if exit_code != 0:
+        sys.exit(exit_code)

winipedia_utils/iterating/iterate.py

@@ -78,10 +78,9 @@ def nested_structure_is_subset(
         if not nested_structure_is_subset(
             value, actual_value, on_false_dict_action, on_false_list_action
         ):
-            fixed = False
+            all_good = False
             if on_false_action is not None:
                 on_false_action(subset, superset, key_or_index)
-                fixed = nested_structure_is_subset(subset, superset)
-            if not fixed:
-                all_good = False
+                all_good = nested_structure_is_subset(subset, superset)
+
     return all_good

winipedia_utils/modules/module.py

@@ -215,6 +215,8 @@ def import_obj_from_importpath(
         return import_module(importpath)
     except ImportError:
         # might be a class or function
+        if "." not in importpath:
+            raise
         module_name, obj_name = importpath.rsplit(".", 1)
         module = import_module(module_name)
         obj: Callable[..., Any] | type | ModuleType = getattr(module, obj_name)

winipedia_utils/modules/package.py

@@ -183,7 +183,8 @@ def find_packages(
     )
 
     if exclude is None:
-        exclude = GitIgnoreConfigFile.load_static()[GitIgnoreConfigFile.IGNORE_KEY]
+        # must init GitIgnoreConfigFile to create .gitignore if it does not exist
+        exclude = GitIgnoreConfigFile.load()
         exclude = [
             p.replace("/", ".").removesuffix(".") for p in exclude if p.endswith("/")
         ]

winipedia_utils/projects/poetry/config.py

@@ -1,23 +1,23 @@
 """Config utilities for poetry and pyproject.toml."""
 
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 from winipedia_utils.modules.package import get_src_package, make_name_from_package
 from winipedia_utils.testing.convention import TESTS_PACKAGE_NAME
 from winipedia_utils.text.config import ConfigFile, TomlConfigFile
 
 
-class PyProjectTomlConfig(TomlConfigFile):
+class PyprojectConfigFile(TomlConfigFile):
     """Config file for pyproject.toml."""
 
-    PATH = Path("pyproject.toml")
-
-    def get_path(self) -> Path:
+    @classmethod
+    def get_parent_path(cls) -> Path:
         """Get the path to the config file."""
-        return self.PATH
+        return Path()
 
-    def get_configs(self) -> dict[str, Any]:
+    @classmethod
+    def get_configs(cls) -> dict[str, Any]:
         """Get the config."""
         return {
             "project": {
@@ -32,21 +32,14 @@ class PyProjectTomlConfig(TomlConfigFile):
             "tool": {
                 "poetry": {
                     "packages": [{"include": get_src_package().__name__}],
+                    "dependencies": dict.fromkeys(
+                        cls.get_dependencies(),
+                        "*",
+                    ),
                     "group": {
                         "dev": {
                             "dependencies": dict.fromkeys(
-                                [
-                                    "ruff",
-                                    "pre-commit",
-                                    "mypy",
-                                    "pytest",
-                                    "bandit",
-                                    "types-setuptools",
-                                    "types-tqdm",
-                                    "types-defusedxml",
-                                    "types-pyyaml",
-                                    "pytest-mock",
-                                ],
+                                cls.get_dev_dependencies(),
                                 "*",
                             )
                         }
@@ -72,16 +65,23 @@ class PyProjectTomlConfig(TomlConfigFile):
             },
         }
 
-    def get_package_name(self) -> str:
+    @classmethod
+    def get_package_name(cls) -> str:
         """Get the package name."""
-        project_dict = self.load().get("project", {})
+        project_dict = cls.load().get("project", {})
         package_name = str(project_dict.get("name", ""))
         return package_name.replace("-", "_")
 
-    def get_dev_dependencies(self) -> set[str]:
+    @classmethod
+    def get_all_dependencies(cls) -> set[str]:
+        """Get all dependencies."""
+        return cls.get_dependencies() | cls.get_dev_dependencies()
+
+    @classmethod
+    def get_dev_dependencies(cls) -> set[str]:
         """Get the dev dependencies."""
         dev_dependencies = set(
-            self.load()
+            cls.load()
             .get("tool", {})
             .get("poetry", {})
             .get("group", {})
@@ -91,38 +91,76 @@ class PyProjectTomlConfig(TomlConfigFile):
         )
         if not dev_dependencies:
             dev_dependencies = set(
-                self.load().get("dependency-groups", {}).get("dev", [])
+                cls.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]:
+    @classmethod
+    def get_dependencies(cls) -> set[str]:
+        """Get the dependencies."""
+        return set(
+            cls.load().get("tool", {}).get("poetry", {}).get("dependencies", {}).keys()
+        )
+
+    @classmethod
+    def get_expected_dev_dependencies(cls) -> set[str]:
         """Get the expected dev dependencies."""
         return set(
-            self.get_configs()["tool"]["poetry"]["group"]["dev"]["dependencies"].keys()
+            cls.get_configs()["tool"]["poetry"]["group"]["dev"]["dependencies"].keys()
         )
 
+    @classmethod
+    def get_authors(cls) -> list[dict[str, str]]:
+        """Get the authors."""
+        return cast(
+            "list[dict[str, str]]", cls.load().get("project", {}).get("authors", [])
+        )
 
-class PyTypedConfigFile(ConfigFile):
+    @classmethod
+    def get_main_author(cls) -> dict[str, str]:
+        """Get the main author.
+
+        Assumes the main author is the first author.
+        """
+        return cls.get_authors()[0]
+
+    @classmethod
+    def get_main_author_name(cls) -> str:
+        """Get the main author name."""
+        return cls.get_main_author()["name"]
+
+
+class TypedConfigFile(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"
+    @classmethod
+    def get_file_extension(cls) -> str:
+        """Get the file extension of the config file."""
+        return "typed"
 
-    def load(self) -> dict[str, Any]:
+    @classmethod
+    def load(cls) -> dict[str, Any] | list[Any]:
         """Load the config file."""
         return {}
 
-    def dump(self, config: dict[str, Any]) -> None:
+    @classmethod
+    def dump(cls, config: dict[str, Any] | list[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]:
+    @classmethod
+    def get_configs(cls) -> dict[str, Any] | list[Any]:
         """Get the config."""
         return {}
+
+
+class PyTypedConfigFile(ConfigFile):
+    """Config file for py.typed."""
+
+    @classmethod
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+        return Path(PyprojectConfigFile.get_package_name())

winipedia_utils/projects/project.py

@@ -2,7 +2,7 @@
 
 from winipedia_utils.modules.module import create_module
 from winipedia_utils.projects.poetry.config import (
-    PyProjectTomlConfig,  # avoid circular import
+    PyprojectConfigFile,  # avoid circular import
 )
 from winipedia_utils.text.config import (
     ConfigFile,  # avoid circular import
@@ -13,5 +13,5 @@ def create_project_root() -> None:
     """Create the project root."""
     ConfigFile.init_config_files()
 
-    src_package_name = PyProjectTomlConfig().get_package_name()
+    src_package_name = PyprojectConfigFile.get_package_name()
     create_module(src_package_name, is_package=True)

winipedia_utils/setup.py

@@ -9,6 +9,7 @@ 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.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.project import create_project_root
@@ -17,6 +18,7 @@ logger = get_logger(__name__)
 
 
 SETUP_STEPS: list[Callable[..., Any]] = [
+    GitIgnoreConfigFile,  # must be first
     create_project_root,
     run_hooks,
 ]