python-semantic-release 9.8.4__tar.gz → 9.8.6__tar.gz

{python_semantic_release-9.8.4/python_semantic_release.egg-info → python_semantic_release-9.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-semantic-release
-Version: 9.8.4
+Version: 9.8.6
 Summary: Automatic Semantic Versioning for Python projects
 Author-email: Rolf Erik Lekang <me@rolflekang.com>
 License: MIT

{python_semantic_release-9.8.4 → python_semantic_release-9.8.6}/docs/configuration.rst

@@ -561,7 +561,7 @@ Author used in commits in the format ``name <email>``.
 .. note::
   If you are using the built-in GitHub Action, the default value is set to
   ``github-actions <actions@github.com>``. You can modify this with the
-  ``git_committer_name`` and ``git_committer_name`` inputs.
+  ``git_committer_name`` and ``git_committer_email`` inputs.
 
 .. seealso::
    - :ref:`github-actions`

{python_semantic_release-9.8.4 → python_semantic_release-9.8.6}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-semantic-release"
-version = "9.8.4"
+version = "9.8.6"
 description = "Automatic Semantic Versioning for Python projects"
 requires-python = ">=3.8"
 license = { text = "MIT" }

{python_semantic_release-9.8.4 → python_semantic_release-9.8.6/python_semantic_release.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-semantic-release
-Version: 9.8.4
+Version: 9.8.6
 Summary: Automatic Semantic Versioning for Python projects
 Author-email: Rolf Erik Lekang <me@rolflekang.com>
 License: MIT

{python_semantic_release-9.8.4 → python_semantic_release-9.8.6}/semantic_release/__init__.py

@@ -24,7 +24,7 @@ from semantic_release.version import (
     tags_and_versions,
 )
 
-__version__ = "9.8.4"
+__version__ = "9.8.6"
 
 __all__ = [
     "CommitParser",

{python_semantic_release-9.8.4 → python_semantic_release-9.8.6}/semantic_release/changelog/release_history.py

@@ -41,6 +41,13 @@ class ReleaseHistory:
         unreleased: dict[str, list[ParseResult]] = defaultdict(list)
         released: dict[Version, Release] = {}
 
+        # Performance optimization: create a mapping of tag sha to version
+        # so we can quickly look up the version for a given commit based on sha
+        tag_sha_2_version_lookup = {
+            tag.commit.hexsha: (tag, version)
+            for tag, version in all_git_tags_and_versions
+        }
+
         # Strategy:
         # Loop through commits in history, parsing as we go.
         # Add these commits to `unreleased` as a key-value mapping
@@ -54,7 +61,7 @@ class ReleaseHistory:
         is_commit_released = False
         the_version: Version | None = None
 
-        for commit in repo.iter_commits():
+        for commit in repo.iter_commits("HEAD", topo_order=True):
             # mypy will be happy if we make this an explicit string
             commit_message = str(commit.message)
 
@@ -64,46 +71,44 @@ class ReleaseHistory:
             )
             log.debug("commit has type %s", commit_type)
 
-            for tag, version in all_git_tags_and_versions:
-                if tag.commit == commit:
-                    # we have found the latest commit introduced by this tag
-                    # so we create a new Release entry
-                    log.debug("found commit %s for tag %s", commit.hexsha, tag.name)
-                    is_commit_released = True
-                    the_version = version
-
-                    # tag.object is a Commit if the tag is lightweight, otherwise
-                    # it is a TagObject with additional metadata about the tag
-                    if isinstance(tag.object, TagObject):
-                        tagger = tag.object.tagger
-                        committer = tag.object.tagger.committer()
-                        _tz = timezone(
-                            timedelta(seconds=-1 * tag.object.tagger_tz_offset)
-                        )
-                        tagged_date = datetime.fromtimestamp(
-                            tag.object.tagged_date, tz=_tz
-                        )
-                    else:
-                        # For some reason, sometimes tag.object is a Commit
-                        tagger = tag.object.author
-                        committer = tag.object.author
-                        _tz = timezone(
-                            timedelta(seconds=-1 * tag.object.author_tz_offset)
-                        )
-                        tagged_date = datetime.fromtimestamp(
-                            tag.object.committed_date, tz=_tz
-                        )
-
-                    release = Release(
-                        tagger=tagger,
-                        committer=committer,
-                        tagged_date=tagged_date,
-                        elements=defaultdict(list),
-                        version=the_version,
+            log.debug("checking if commit %s matches any tags", commit.hexsha)
+            t_v = tag_sha_2_version_lookup.get(commit.hexsha, None)
+
+            if t_v is None:
+                log.debug("no tags correspond to commit %s", commit.hexsha)
+            else:
+                # Unpack the tuple (overriding the current version)
+                tag, the_version = t_v
+                # we have found the latest commit introduced by this tag
+                # so we create a new Release entry
+                log.debug("found commit %s for tag %s", commit.hexsha, tag.name)
+                is_commit_released = True
+
+                # tag.object is a Commit if the tag is lightweight, otherwise
+                # it is a TagObject with additional metadata about the tag
+                if isinstance(tag.object, TagObject):
+                    tagger = tag.object.tagger
+                    committer = tag.object.tagger.committer()
+                    _tz = timezone(timedelta(seconds=-1 * tag.object.tagger_tz_offset))
+                    tagged_date = datetime.fromtimestamp(tag.object.tagged_date, tz=_tz)
+                else:
+                    # For some reason, sometimes tag.object is a Commit
+                    tagger = tag.object.author
+                    committer = tag.object.author
+                    _tz = timezone(timedelta(seconds=-1 * tag.object.author_tz_offset))
+                    tagged_date = datetime.fromtimestamp(
+                        tag.object.committed_date, tz=_tz
                     )
 
-                    released.setdefault(the_version, release)
-                    break
+                release = Release(
+                    tagger=tagger,
+                    committer=committer,
+                    tagged_date=tagged_date,
+                    elements=defaultdict(list),
+                    version=the_version,
+                )
+
+                released.setdefault(the_version, release)
 
             if any(pat.match(commit_message) for pat in exclude_commit_patterns):
                 log.debug(

{python_semantic_release-9.8.4 → python_semantic_release-9.8.6}/semantic_release/cli/cli_context.py

@@ -34,10 +34,17 @@ class CliContextObj:
         logger: logging.Logger,
         global_opts: GlobalCommandLineOptions,
     ) -> None:
-        self._runtime_ctx: RuntimeContext | None = None
         self.ctx = ctx
         self.logger = logger
         self.global_opts = global_opts
+        self._raw_config: RawConfig | None = None
+        self._runtime_ctx: RuntimeContext | None = None
+
+    @property
+    def raw_config(self) -> RawConfig:
+        if self._raw_config is None:
+            self._raw_config = self._init_raw_config()
+        return self._raw_config
 
     @property
     def runtime_ctx(self) -> RuntimeContext:
@@ -49,7 +56,7 @@ class CliContextObj:
             self._runtime_ctx = self._init_runtime_ctx()
         return self._runtime_ctx
 
-    def _init_runtime_ctx(self) -> RuntimeContext:
+    def _init_raw_config(self) -> RawConfig:
         config_path = Path(self.global_opts.config_file)
         conf_file_exists = config_path.exists()
         was_conf_file_user_provided = bool(
@@ -60,6 +67,7 @@ class CliContextObj:
             )
         )
 
+        # TODO: Evaluate Exeception catches
         try:
             if was_conf_file_user_provided and not conf_file_exists:
                 raise FileNotFoundError(  # noqa: TRY301
@@ -74,24 +82,36 @@ class CliContextObj:
                     "configuration empty, falling back to default configuration"
                 )
 
-            raw_config = RawConfig.model_validate(config_obj)
+            return RawConfig.model_validate(config_obj)
+        except FileNotFoundError as exc:
+            click.echo(str(exc), err=True)
+            self.ctx.exit(2)
+        except (
+            ValidationError,
+            InvalidConfiguration,
+            InvalidGitRepositoryError,
+        ) as exc:
+            click.echo(str(exc), err=True)
+            self.ctx.exit(1)
+
+    def _init_runtime_ctx(self) -> RuntimeContext:
+        # TODO: Evaluate Exception catches
+        try:
             runtime = RuntimeContext.from_raw_config(
-                raw_config,
+                self.raw_config,
                 global_cli_options=self.global_opts,
             )
-        except (DetachedHeadGitError, NotAReleaseBranch) as exc:
+        except NotAReleaseBranch as exc:
             rprint(f"[bold {'red' if self.global_opts.strict else 'orange1'}]{exc!s}")
             # If not strict, exit 0 so other processes can continue. For example, in
             # multibranch CI it might be desirable to run a non-release branch's pipeline
             # without specifying conditional execution of PSR based on branch name
             self.ctx.exit(2 if self.global_opts.strict else 0)
-        except FileNotFoundError as exc:
-            click.echo(str(exc), err=True)
-            self.ctx.exit(2)
         except (
-            ValidationError,
+            DetachedHeadGitError,
             InvalidConfiguration,
             InvalidGitRepositoryError,
+            ValidationError,
         ) as exc:
             click.echo(str(exc), err=True)
             self.ctx.exit(1)

{python_semantic_release-9.8.4 → python_semantic_release-9.8.6}/semantic_release/cli/commands/version.py

@@ -4,6 +4,7 @@ import logging
 import os
 import subprocess
 import sys
+from collections import defaultdict
 from datetime import datetime
 from typing import TYPE_CHECKING
 
@@ -160,8 +161,17 @@ def shell(
     if not shell:
         raise TypeError("'shell' is None")
 
+    shell_cmd_param = defaultdict(
+        lambda: "-c",
+        {
+            "cmd": "/c",
+            "powershell": "-Command",
+            "pwsh": "-Command",
+        },
+    )
+
     return subprocess.run(  # noqa: S603
-        [shell, "-c" if shell != "cmd" else "/c", cmd],
+        [shell, shell_cmd_param[shell], cmd],
         env=(env or {}),
         check=check,
     )
@@ -413,26 +423,28 @@ def version(  # noqa: C901
     * Create a release (if supported) in the remote VCS for this tag
     """
     ctx = click.get_current_context()
-    runtime = cli_ctx.runtime_ctx
-    translator = runtime.version_translator
+
+    # Enable any cli overrides of configuration before asking for the runtime context
+    config = cli_ctx.raw_config
 
     # We can short circuit updating the release if we are only printing the last released version
     if print_last_released or print_last_released_tag:
         # TODO: get tag format a better way
-        if not (last_release := last_released(runtime.repo_dir, translator.tag_format)):
+        if not (
+            last_release := last_released(config.repo_dir, tag_format=config.tag_format)
+        ):
             log.warning("No release tags found.")
             return
 
         click.echo(last_release[0] if print_last_released_tag else last_release[1])
         return
 
+    # TODO: figure out --print of next version with & without branch validation
+    # do you always need a prerelease token if its not --as-prerelease?
+    runtime = cli_ctx.runtime_ctx
+    translator = runtime.version_translator
+
     parser = runtime.commit_parser
-    forced_level_bump = None if not force_level else LevelBump.from_string(force_level)
-    prerelease = is_forced_prerelease(
-        as_prerelease=as_prerelease,
-        forced_level_bump=forced_level_bump,
-        prerelease=runtime.prerelease,
-    )
     hvcs_client = runtime.hvcs_client
     assets = runtime.assets
     commit_author = runtime.commit_author
@@ -442,6 +454,13 @@ def version(  # noqa: C901
     opts = runtime.global_cli_options
     gha_output = VersionGitHubActionsOutput(released=False)
 
+    forced_level_bump = None if not force_level else LevelBump.from_string(force_level)
+    prerelease = is_forced_prerelease(
+        as_prerelease=as_prerelease,
+        forced_level_bump=forced_level_bump,
+        prerelease=runtime.prerelease,
+    )
+
     if prerelease_token:
         log.info("Forcing use of %s as the prerelease token", prerelease_token)
         translator.prerelease_token = prerelease_token

{python_semantic_release-9.8.4 → python_semantic_release-9.8.6}/tests/command_line/test_main.py

@@ -85,8 +85,8 @@ def test_not_a_release_branch_detached_head_exit_code(
     cli_cmd = [MAIN_PROG_NAME, VERSION_SUBCMD, "--no-commit"]
     result = cli_runner.invoke(main, cli_cmd[1:])
 
-    # as non-strict, this will return success exit code
-    assert_successful_exit_code(result, cli_cmd)
+    # detached head states should throw an error as release branches cannot be determined
+    assert_exit_code(1, result, cli_cmd)
     assert expected_err_msg in result.stderr
 
 

{python_semantic_release-9.8.4 → python_semantic_release-9.8.6}/tests/command_line/test_version.py

@@ -16,6 +16,7 @@ import tomlkit
 from pytest_lazyfixture import lazy_fixture
 
 from semantic_release.cli.commands.main import main
+from semantic_release.hvcs.github import Github
 
 from tests.const import (
     EXAMPLE_PROJECT_NAME,
@@ -53,6 +54,7 @@ if TYPE_CHECKING:
         UpdatePyprojectTomlFn,
         UseReleaseNotesTemplateFn,
     )
+    from tests.fixtures.git_repo import SimulateChangeCommitsNReturnChangelogEntryFn
 
 
 @pytest.mark.parametrize(
@@ -656,7 +658,7 @@ def test_version_version_no_verify(
     assert head_before in repo_with_single_branch_angular_commits.head.commit.parents
 
 
-@pytest.mark.parametrize("shell", ("/usr/bin/bash", "/usr/bin/zsh", "powershell"))
+@pytest.mark.parametrize("shell", ("/usr/bin/bash", "/usr/bin/zsh"))
 def test_version_runs_build_command(
     repo_with_git_flow_angular_commits: Repo,
     cli_runner: CliRunner,
@@ -737,7 +739,7 @@ def test_version_runs_build_command(
         )
 
 
-@pytest.mark.parametrize("shell", ("powershell", "cmd"))
+@pytest.mark.parametrize("shell", ("powershell", "pwsh", "cmd"))
 def test_version_runs_build_command_windows(
     repo_with_git_flow_angular_commits: Repo,
     cli_runner: CliRunner,
@@ -799,7 +801,7 @@ def test_version_runs_build_command_windows(
         # Evaluate
         assert_successful_exit_code(result, cli_cmd)
         patched_subprocess_run.assert_called_once_with(
-            [exe, "-c" if shell != "cmd" else "/c", build_command],
+            [exe, "/c" if shell == "cmd" else "-Command", build_command],
             check=True,
             env={
                 "NEW_VERSION": "1.2.1",  # injected into environment
@@ -1001,6 +1003,33 @@ def test_version_exit_code_when_not_strict(
     assert_successful_exit_code(result, cli_cmd)
 
 
+@pytest.mark.parametrize(
+    "is_strict, exit_code", [(True, 2), (False, 0)], ids=["strict", "non-strict"]
+)
+def test_version_on_nonrelease_branch(
+    repo_with_single_branch_angular_commits: Repo,
+    cli_runner: CliRunner,
+    is_strict: bool,
+    exit_code: int,
+):
+    branch = repo_with_single_branch_angular_commits.create_head("next")
+    branch.checkout()
+    expected_error_msg = (
+        f"branch '{branch.name}' isn't in any release groups; no release will be made\n"
+    )
+
+    # Act
+    cli_cmd = list(
+        filter(None, [MAIN_PROG_NAME, "--strict" if is_strict else "", VERSION_SUBCMD])
+    )
+    result = cli_runner.invoke(main, cli_cmd[1:])
+
+    # Evaluate (expected -> actual)
+    assert_exit_code(exit_code, result, cli_cmd)
+    assert not result.stdout
+    assert expected_error_msg == result.stderr
+
+
 def test_custom_release_notes_template(
     mocked_git_push: MagicMock,
     repo_with_no_tags_angular_commits: Repo,
@@ -1017,7 +1046,7 @@ def test_custom_release_notes_template(
     runtime_context_with_no_tags = retrieve_runtime_context(
         repo_with_no_tags_angular_commits
     )
-    cli_cmd = ["semantic-release", VERSION_SUBCMD, "--skip-build", "--vcs-release"]
+    cli_cmd = [MAIN_PROG_NAME, VERSION_SUBCMD, "--skip-build", "--vcs-release"]
 
     # Act
     result = cli_runner.invoke(main, cli_cmd[1:])
@@ -1056,7 +1085,7 @@ def test_version_tag_only_push(
 
     # Act
     cli_cmd = [
-        "semantic-release",
+        MAIN_PROG_NAME,
         VERSION_SUBCMD,
         "--tag",
         "--no-commit",
@@ -1219,3 +1248,102 @@ def test_version_print_last_released_prints_nothing_if_no_tags(
     assert_successful_exit_code(result, cli_cmd)
     assert result.stdout == ""
     assert "No release tags found." in caplog.text
+
+
+def test_version_print_last_released_on_detached_head(
+    cli_runner: CliRunner,
+    repo_with_single_branch_tag_commits: Repo,
+):
+    last_version = "0.1.1"
+    repo_with_single_branch_tag_commits.git.checkout("HEAD", detach=True)
+
+    cli_cmd = [MAIN_PROG_NAME, VERSION_SUBCMD, "--print-last-released"]
+
+    # Act
+    result = cli_runner.invoke(main, cli_cmd[1:])
+
+    # Evaluate (expected -> actual)
+    assert_successful_exit_code(result, cli_cmd)
+    assert not result.stderr
+    assert last_version == result.stdout.rstrip()
+
+
+def test_version_print_last_released_on_nonrelease_branch(
+    cli_runner: CliRunner,
+    repo_with_single_branch_tag_commits: Repo,
+):
+    last_version = "0.1.1"
+    repo_with_single_branch_tag_commits.create_head("next").checkout()
+
+    cli_cmd = [MAIN_PROG_NAME, VERSION_SUBCMD, "--print-last-released"]
+
+    # Act
+    result = cli_runner.invoke(main, cli_cmd[1:])
+
+    # Evaluate (expected -> actual)
+    assert_successful_exit_code(result, cli_cmd)
+    assert not result.stderr
+    assert last_version == result.stdout.rstrip()
+
+
+def test_version_print_last_released_tag_on_detached_head(
+    cli_runner: CliRunner,
+    repo_with_single_branch_tag_commits: Repo,
+):
+    last_version = "v0.1.1"
+    repo_with_single_branch_tag_commits.git.checkout("HEAD", detach=True)
+
+    cli_cmd = [MAIN_PROG_NAME, VERSION_SUBCMD, "--print-last-released-tag"]
+
+    # Act
+    result = cli_runner.invoke(main, cli_cmd[1:])
+
+    # Evaluate (expected -> actual)
+    assert_successful_exit_code(result, cli_cmd)
+    assert not result.stderr
+    assert last_version == result.stdout.rstrip()
+
+
+def test_version_print_last_released_tag_on_nonrelease_branch(
+    cli_runner: CliRunner,
+    repo_with_single_branch_tag_commits: Repo,
+):
+    last_version_tag = "v0.1.1"
+    repo_with_single_branch_tag_commits.create_head("next").checkout()
+
+    cli_cmd = [MAIN_PROG_NAME, VERSION_SUBCMD, "--print-last-released-tag"]
+
+    # Act
+    result = cli_runner.invoke(main, cli_cmd[1:])
+
+    # Evaluate (expected -> actual)
+    assert_successful_exit_code(result, cli_cmd)
+    assert not result.stderr
+    assert last_version_tag == result.stdout.rstrip()
+
+
+def test_version_print_next_version_fails_on_detached_head(
+    cli_runner: CliRunner,
+    example_git_ssh_url: str,
+    repo_with_single_branch_tag_commits: Repo,
+    simulate_change_commits_n_rtn_changelog_entry: SimulateChangeCommitsNReturnChangelogEntryFn,
+):
+    # Setup
+    repo_with_single_branch_tag_commits.git.checkout("HEAD", detach=True)
+    simulate_change_commits_n_rtn_changelog_entry(
+        repo_with_single_branch_tag_commits,
+        ["fix: make a patch fix to codebase"],
+        Github(example_git_ssh_url),
+    )
+    expected_error_msg = (
+        "Detached HEAD state cannot match any release groups; no release will be made\n"
+    )
+
+    # Act
+    cli_cmd = [MAIN_PROG_NAME, VERSION_SUBCMD, "--print"]
+    result = cli_runner.invoke(main, cli_cmd[1:])
+
+    # Evaluate (expected -> actual)
+    assert_exit_code(1, result, cli_cmd)
+    assert not result.stdout
+    assert expected_error_msg == result.stderr