winipedia-utils 0.5.29__tar.gz → 0.6.1__tar.gz

{winipedia_utils-0.5.29 → winipedia_utils-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winipedia-utils
-Version: 0.5.29
+Version: 0.6.1
 Summary: A package with many utility functions
 License-Expression: MIT
 License-File: LICENSE
@@ -153,21 +153,28 @@ When you commit code using `git commit`, the following checks run automatically:
 
 Info: If git commit fails bc of ModuleNotFoundError or smth similar, you need to run `poetry run git commit` instead.
 winipedia_utils hook is a python script that depends on winipedia_utils being installed. Poetry is needed to install winipedia_utils.
-Usually VSCode or other IDEs activates the venv automatically when opening the terminal but if not you need to activate it manually or run `poetry run git commit` instead.
-
-1. Patch version (poetry version patch)
-2. Add version patch to git (git add pyproject.toml)
-3. Update package manager (poetry self update)
-4. Install packages (poetry install --with dev)
-5. Update packages (poetry update --with dev (winipedia_utils forces all dependencies with * to be updated to latest compatible version))
-6. Lock dependencies (poetry lock)
-7. Check package manager configs (poetry check --strict)
-8. Create tests (python -m winipedia_utils.testing.create_tests)
-9. Lint code (ruff check --fix)
-10. Format code (ruff format)
-11. Check static types (mypy)
-12. Check security (bandit -c pyproject.toml -r .)
-13. Run tests (pytest (uses pyproject.toml as config))
+Usually VSCode or other IDEs activates the venv automatically when opening the terminal but if not you need to activate it manually or run `poetry run git commit` instead. It fails fast, so if one hook in winipedia_utils hook fails, the others don't run bc sys.exit(1) is called.
+
+Hooks run in the following order:
+
+- Fetch latest changes (git fetch origin)
+- Stash changes (git stash push -m "WIP: Stashed changes before rebasing")
+- Rebase on main (git rebase origin/main)
+- Pop stashed changes (git stash pop)
+- Add popped stash to git (git add ., bc unstashing unadds the changes and pre-commit fails, be aware that this might add changes you didn't want to commit, so inspect the changes before committing)
+- Patch version (poetry version patch)
+- Add version patch to git (git add pyproject.toml)
+- Update package manager (poetry self update)
+- Install packages (poetry install --with dev)
+- Update packages (poetry update --with dev (winipedia_utils forces all dependencies with * to be updated to latest compatible version))
+- Lock dependencies (poetry lock)
+- Check package manager configs (poetry check --strict)
+- Create tests (python -m winipedia_utils.testing.create_tests)
+- Lint code (ruff check --fix)
+- Format code (ruff format)
+- Check static types (mypy)
+- Check security (bandit -c pyproject.toml -r .)
+- Run tests (pytest (uses pyproject.toml as config))
 
 ### Auto-generated Test Structure
 

{winipedia_utils-0.5.29 → winipedia_utils-0.6.1}/README.md

@@ -126,21 +126,28 @@ When you commit code using `git commit`, the following checks run automatically:
 
 Info: If git commit fails bc of ModuleNotFoundError or smth similar, you need to run `poetry run git commit` instead.
 winipedia_utils hook is a python script that depends on winipedia_utils being installed. Poetry is needed to install winipedia_utils.
-Usually VSCode or other IDEs activates the venv automatically when opening the terminal but if not you need to activate it manually or run `poetry run git commit` instead.
-
-1. Patch version (poetry version patch)
-2. Add version patch to git (git add pyproject.toml)
-3. Update package manager (poetry self update)
-4. Install packages (poetry install --with dev)
-5. Update packages (poetry update --with dev (winipedia_utils forces all dependencies with * to be updated to latest compatible version))
-6. Lock dependencies (poetry lock)
-7. Check package manager configs (poetry check --strict)
-8. Create tests (python -m winipedia_utils.testing.create_tests)
-9. Lint code (ruff check --fix)
-10. Format code (ruff format)
-11. Check static types (mypy)
-12. Check security (bandit -c pyproject.toml -r .)
-13. Run tests (pytest (uses pyproject.toml as config))
+Usually VSCode or other IDEs activates the venv automatically when opening the terminal but if not you need to activate it manually or run `poetry run git commit` instead. It fails fast, so if one hook in winipedia_utils hook fails, the others don't run bc sys.exit(1) is called.
+
+Hooks run in the following order:
+
+- Fetch latest changes (git fetch origin)
+- Stash changes (git stash push -m "WIP: Stashed changes before rebasing")
+- Rebase on main (git rebase origin/main)
+- Pop stashed changes (git stash pop)
+- Add popped stash to git (git add ., bc unstashing unadds the changes and pre-commit fails, be aware that this might add changes you didn't want to commit, so inspect the changes before committing)
+- Patch version (poetry version patch)
+- Add version patch to git (git add pyproject.toml)
+- Update package manager (poetry self update)
+- Install packages (poetry install --with dev)
+- Update packages (poetry update --with dev (winipedia_utils forces all dependencies with * to be updated to latest compatible version))
+- Lock dependencies (poetry lock)
+- Check package manager configs (poetry check --strict)
+- Create tests (python -m winipedia_utils.testing.create_tests)
+- Lint code (ruff check --fix)
+- Format code (ruff format)
+- Check static types (mypy)
+- Check security (bandit -c pyproject.toml -r .)
+- Run tests (pytest (uses pyproject.toml as config))
 
 ### Auto-generated Test Structure
 

{winipedia_utils-0.5.29 → winipedia_utils-0.6.1}/pyproject.toml

@@ -1,7 +1,7 @@
 # Project section
 [project]
 name = "winipedia-utils"
-version = "0.5.29"
+version = "0.6.1"
 description = "A package with many utility functions"
 readme = "README.md"
 requires-python = ">=3.12"

{winipedia_utils-0.5.29 → winipedia_utils-0.6.1}/winipedia_utils/git/github/workflows/base/base.py

@@ -441,6 +441,19 @@ class Workflow(YamlConfigFile):
             step=step,
         )
 
+    @classmethod
+    def step_patch_version(
+        cls,
+        *,
+        step: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Get the patch version step."""
+        return cls.get_step(
+            step_func=cls.step_patch_version,
+            run="poetry version patch && git add pyproject.toml",
+            step=step,
+        )
+
     @classmethod
     def step_checkout_repository(
         cls,
@@ -596,10 +609,15 @@ class Workflow(YamlConfigFile):
         *,
         step: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        """Get the run pre-commit hooks step."""
+        """Get the run pre-commit hooks step.
+
+        Patching version is useful to have at least a minimal version bump when
+        creating a release and it also makes sure git stash pop does not fail when
+        there are no changes.
+        """
         return cls.get_step(
             step_func=cls.step_run_pre_commit_hooks,
-            run="poetry run pre-commit run --all-files --verbose",
+            run="poetry version patch && git add pyproject.toml && poetry run pre-commit run --all-files --verbose",  # noqa: E501
             env={"REPO_TOKEN": cls.insert_repo_token()},
             step=step,
         )
@@ -707,6 +725,7 @@ class Workflow(YamlConfigFile):
         with_: dict[str, Any] = {"path": str(path)}
         if name is not None:
             with_["name"] = name
+        with_["merge-multiple"] = "true"
         return cls.get_step(
             step_func=cls.step_download_artifacts,
             uses="actions/download-artifact@main",
@@ -749,12 +768,13 @@ class Workflow(YamlConfigFile):
         artifacts_pattern: str = ARTIFACTS_PATTERN,
     ) -> dict[str, Any]:
         """Get the create release step."""
+        version = cls.insert_version_from_extract_version_step()
         return cls.get_step(
             step_func=cls.step_create_release,
             uses="ncipollo/release-action@main",
             with_={
-                "tag": cls.insert_version_from_extract_version_step(),
-                "name": f"{cls.insert_repository_name()} {cls.insert_version()}",
+                "tag": version,
+                "name": f"{cls.insert_repository_name()} {version}",
                 "body": cls.insert_changelog(),
                 cls.ARTIFACTS_FOLDER: artifacts_pattern,
             },

{winipedia_utils-0.5.29 → winipedia_utils-0.6.1}/winipedia_utils/git/pre_commit/hooks.py

@@ -13,13 +13,54 @@ from winipedia_utils.projects.poetry.poetry import (
 )
 
 
-def patch_version() -> list[str]:
-    """Patch the version in pyproject.toml.
+def fetch_latest_changes() -> list[str]:
+    """Fetch the latest changes from origin.
 
-    This function returns the input for subprocess.run() to patch the version
-    in pyproject.toml.
+    This function returns the input for subprocess.run() to fetch the latest
+    changes from origin.
     """
-    return [POETRY_ARG, "version", "patch"]
+    return ["git", "fetch", "origin"]
+
+
+def stash_changes() -> list[str]:
+    """Stash the changes.
+
+    This function returns the input for subprocess.run() to stash the changes.
+    """
+    return [
+        "git",
+        "stash",
+        "push",
+        "-m",
+        "WIP: Temporarily stashed changes before rebasing",
+    ]
+
+
+def rebase_on_main() -> list[str]:
+    """Rebase the current branch on origin/main.
+
+    This function returns the input for subprocess.run() to rebase the current
+    branch on origin/main.
+    """
+    return ["git", "rebase", "origin/main"]
+
+
+def pop_stashed_changes() -> list[str]:
+    """Pop the stashed changes.
+
+    This function returns the input for subprocess.run() to pop the stashed changes.
+    """
+    return ["git", "stash", "pop"]
+
+
+def add_popped_stash_to_git() -> list[str]:
+    """Add the unstashed changes to git.
+
+    This function returns the input for subprocess.run() to add the unstashed
+    changes to git.
+    We must do git add . because unstashing unadds the changes and pre-commit fails
+    """
+    return ["git", "add", "."]
 
 
 def add_version_patch_to_git() -> list[str]:

{winipedia_utils-0.5.29 → winipedia_utils-0.6.1}/winipedia_utils/git/pre_commit/run_hooks.py

@@ -19,7 +19,6 @@ def run_hooks() -> None:
     """Import all funcs defined in hooks.py and runs them."""
     hook_funcs = get_all_functions_from_module(hooks)
 
-    exit_code = 0
     for hook_func in hook_funcs:
         subprocess_args = hook_func()
         result = run_subprocess(
@@ -44,7 +43,7 @@ Stderr:
 
 ---------------------------------------------------------------------------------------------
 """
-            exit_code = 1
+
         # make the dashes always the same lentgth by adjusting to len of hook name
         num_dashes = 50 - len(hook_func.__name__)
         log_method(
@@ -53,6 +52,5 @@ Stderr:
             "-" * num_dashes,
             status_str,
         )
-
-    if exit_code != 0:
-        sys.exit(exit_code)
+        if not passed:
+            sys.exit(1)