python-semantic-release 10.4.1__py3-none-any.whl → 10.5.1__py3-none-any.whl

{python_semantic_release-10.4.1.dist-info → python_semantic_release-10.5.1.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: python-semantic-release
-Version: 10.4.1
+Version: 10.5.1
 Summary: Automatic Semantic Versioning for Python projects
-Author-email: Rolf Erik Lekang <me@rolflekang.com>
+Author-email: Rolf Erik Lekang <me@rolflekang.com>, codejedi365 <codejedi365@gmail.com>
 License: MIT
 Project-URL: changelog, https://github.com/python-semantic-release/python-semantic-release/blob/master/CHANGELOG.md
 Project-URL: documentation, https://python-semantic-release.readthedocs.io
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: ~=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
@@ -26,7 +27,7 @@ Requires-Dist: gitpython~=3.0
 Requires-Dist: requests~=2.25
 Requires-Dist: jinja2~=3.1
 Requires-Dist: python-gitlab<7.0.0,>=4.0.0
-Requires-Dist: tomlkit~=0.11
+Requires-Dist: tomlkit~=0.13.0
 Requires-Dist: dotty-dict~=1.3
 Requires-Dist: importlib-resources~=6.0
 Requires-Dist: pydantic~=2.0
@@ -35,11 +36,12 @@ Requires-Dist: shellingham~=1.5
 Requires-Dist: Deprecated~=1.2
 Provides-Extra: build
 Requires-Dist: build~=1.2; extra == "build"
+Requires-Dist: tomlkit~=0.13.0; extra == "build"
 Provides-Extra: docs
-Requires-Dist: Sphinx~=6.0; extra == "docs"
-Requires-Dist: sphinxcontrib-apidoc==0.5.0; extra == "docs"
+Requires-Dist: Sphinx~=7.4; extra == "docs"
+Requires-Dist: sphinxcontrib-apidoc==0.6.0; extra == "docs"
 Requires-Dist: sphinx-autobuild==2024.2.4; extra == "docs"
-Requires-Dist: furo~=2024.1; extra == "docs"
+Requires-Dist: furo~=2025.9; extra == "docs"
 Provides-Extra: test
 Requires-Dist: coverage[toml]~=7.0; extra == "test"
 Requires-Dist: filelock~=3.15; extra == "test"
@@ -48,9 +50,9 @@ Requires-Dist: freezegun~=1.5; extra == "test"
 Requires-Dist: pyyaml~=6.0; extra == "test"
 Requires-Dist: pytest~=8.3; extra == "test"
 Requires-Dist: pytest-clarity~=1.0; extra == "test"
-Requires-Dist: pytest-cov<7.0.0,>=5.0.0; extra == "test"
+Requires-Dist: pytest-cov<8.0.0,>=5.0.0; extra == "test"
 Requires-Dist: pytest-env~=1.0; extra == "test"
-Requires-Dist: pytest-lazy-fixtures~=1.1.1; extra == "test"
+Requires-Dist: pytest-lazy-fixtures~=1.4; extra == "test"
 Requires-Dist: pytest-mock~=3.0; extra == "test"
 Requires-Dist: pytest-order~=1.3; extra == "test"
 Requires-Dist: pytest-pretty~=1.2; extra == "test"
@@ -58,7 +60,7 @@ Requires-Dist: pytest-xdist~=3.0; extra == "test"
 Requires-Dist: responses~=0.25.0; extra == "test"
 Requires-Dist: requests-mock~=1.10; extra == "test"
 Provides-Extra: dev
-Requires-Dist: pre-commit~=3.5; extra == "dev"
+Requires-Dist: pre-commit~=4.3; extra == "dev"
 Requires-Dist: tox~=4.11; extra == "dev"
 Requires-Dist: ruff==0.6.1; extra == "dev"
 Provides-Extra: mypy

{python_semantic_release-10.4.1.dist-info → python_semantic_release-10.5.1.dist-info}/RECORD

@@ -1,31 +1,31 @@
-python_semantic_release-10.4.1.dist-info/licenses/LICENSE,sha256=NE85nszX252sdQdu0xgS9qwfYES0k8qS6gW3uO4jRGE,1083
+python_semantic_release-10.5.1.dist-info/licenses/LICENSE,sha256=NE85nszX252sdQdu0xgS9qwfYES0k8qS6gW3uO4jRGE,1083
 semantic_release/__init__.py,sha256=tRJWhrn_dUt0QycXD2DoJSfEP5uwmxngH7jvbG2i-hA,1317
 semantic_release/__main__.py,sha256=pksxr6g1vkKq98Q1lShsxG8tk55IMiSMHzAHKyFU5x0,1704
 semantic_release/const.py,sha256=wInJR7vcOgT1ysm5VuJQ6lD_ZGYnCwRVKz7Uz3htQc4,861
 semantic_release/enums.py,sha256=vrEw1UNRcNrFjPqOFnuUzfeoqKj0ChixVVlyk5fqbng,1744
-semantic_release/errors.py,sha256=PY9rmviSFBZkqawW6VXbUfmF9C_RNOIObcmeGxLefMo,2904
-semantic_release/gitproject.py,sha256=UMvxcxqu9jRnZ3C5miNYYDh2i6hygLNEqo3-TuW4Pj4,9423
+semantic_release/errors.py,sha256=FyocaqHbRhux-iNmCf9nI7awyUaGKjG9_5C_QDvhEas,3399
+semantic_release/gitproject.py,sha256=qF4GVZh-aaS4bVV3OmFQLmXMAxHNFyZCwUaWPtUmZ1k,16546
 semantic_release/globals.py,sha256=IBhBbhZr2jx8dmpySnnu9m9jOGYu9Yu-vqHvAGQxgnw,464
 semantic_release/helpers.py,sha256=2uQXOiuiemiviVD52SH2FF6cn14p_gqvREeHvP7dexw,10012
 semantic_release/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantic_release/changelog/__init__.py,sha256=Bg6Xe5Vt32rWoMscW-hd4sUwiZqzWmsg4CD1EhMesMY,262
-semantic_release/changelog/context.py,sha256=WeLQ2BvYEWunIF8XEl6ldQE4IRg0d7r8mYSBi-TqK7o,5988
+semantic_release/changelog/context.py,sha256=234LLcB_uuGaQ5N_zTbcQYF27ZwYIBmicIWkhFs7-aQ,5993
 semantic_release/changelog/release_history.py,sha256=kX6D9VReq85wnHz0D6JpmJJCfWA6axV6RToSM0O5laU,10602
 semantic_release/changelog/template.py,sha256=eqOjtVfBbksgTK4CAZOajfkaAcKueJ-FhFv99U3-J5E,5695
 semantic_release/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantic_release/cli/changelog_writer.py,sha256=2jP5b0LK61Y2tb22GQSFFmwHwXd2WjbopgsMAmsQsfY,9284
 semantic_release/cli/cli_context.py,sha256=Nop71LdVCJOeSUHgTXunMyK3xAu_QKQC2cRp1QBVkX0,4134
-semantic_release/cli/config.py,sha256=dCQ1HqzBc_8RG_oTQtBMuCnM7zOEj9E1bDblxobg8os,33569
+semantic_release/cli/config.py,sha256=zNXlJHZBnFk2GEemgCg2Yw42EWihtFMot1twI7bEN-g,33668
 semantic_release/cli/const.py,sha256=h7XE2D0D__TAZSrUUtVszwvzpkHTMOiQCf97XQNbEvA,163
 semantic_release/cli/github_actions_output.py,sha256=yC0nsMvEFGACjDwB8DdmGKwNGI8aIIhDxRHrmcS7tzA,5410
-semantic_release/cli/masking_filter.py,sha256=GsTyaoZbUVJLXVMqeXhCttXK84UnBQ8cNDSHxd52sOc,3218
+semantic_release/cli/masking_filter.py,sha256=7t7XFL7Iy4QTvaYevZ-jnTkJBz15GoBw1vjW3hihe38,3159
 semantic_release/cli/util.py,sha256=4rf4xDHb7l-XpdcFNtslFz1xHslnBu6cTgWHXVnQXQs,3746
 semantic_release/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantic_release/cli/commands/changelog.py,sha256=wJfd4VVfrGnu2jnIpG25cdVcbXIX-ElKl3b2jdtPPa0,5391
 semantic_release/cli/commands/generate_config.py,sha256=2xZOu3NpyhBp0pWr7d8ugKl_kjqQgpSsSMHq5wHTfrE,1699
 semantic_release/cli/commands/main.py,sha256=u1zhkkvKCZ2TtUqjzvdFTe5UZsvfws_pjqqo6CY0bBo,4351
 semantic_release/cli/commands/publish.py,sha256=CE_LJTxFnc337MfpsfdJopi7QCwwE13GqGNQ-dNgWis,2871
-semantic_release/cli/commands/version.py,sha256=vlBNbQq0rW930UpI983-Rr-71fdK6qVPjMiRqMTBBUE,26616
+semantic_release/cli/commands/version.py,sha256=BvSEDFX5p8Mzl8gSBV0O0WjQn3TpD7zeS7gBLnyIjWQ,29424
 semantic_release/commit_parser/__init__.py,sha256=uCC2YI-EDPUAa6TwWYJA8TS7baWE2bXrLEGcrhJKofI,1323
 semantic_release/commit_parser/_base.py,sha256=DLsHnbXG-39JkUbcnsBCSV2GmV35w1rasyoMhK8G0UE,3058
 semantic_release/commit_parser/angular.py,sha256=MY_fo9F4EZ-ac8wYzBR0uD94O5Li2D-8zEMR01wss4c,18534
@@ -70,15 +70,15 @@ semantic_release/hvcs/util.py,sha256=PUNV4yUlpzDtNCFmh2joaPdU4JyfUBnVp0zaQsT9EDQ
 semantic_release/version/__init__.py,sha256=CLhtGQry9dLIij5XyRa9ZevxU_1p8tjMTSQ-K_GMpWM,270
 semantic_release/version/algorithm.py,sha256=IxgYNF78W7qdMzdV4WsoljwfJgB-sn2XdfkevD0aZlo,16254
 semantic_release/version/declaration.py,sha256=eot_lUyFaEhzK4bPncfv9tahf51LdxZP6EaS54h3aAs,3635
-semantic_release/version/translator.py,sha256=LjmsMHWJJOG8ES6lRhjQsP2t8pmw4Ux1XVYzvROMR_M,3047
-semantic_release/version/version.py,sha256=3QlPKsrmNnFH71GlsYvpI-WwhpkJEs_JrDBbMaepwJY,14183
+semantic_release/version/translator.py,sha256=iIfu3WreB9qqPHgqJLILbBluVQQNcpP0DEsnn_WzAaM,3689
+semantic_release/version/version.py,sha256=Y3Qqqv7CypirikT7jNqqFMNAvR2UjV-VQx-c2G0mZc0,14519
 semantic_release/version/declarations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantic_release/version/declarations/enum.py,sha256=3n5Py9DoFkmItIdsmtQrJgmAhepTv_1EnogzSdXu1Wg,244
 semantic_release/version/declarations/i_version_replacer.py,sha256=oP6BxJuxwI44roI6448tomShv1sMoy9ry8TlhhIQtfc,2416
-semantic_release/version/declarations/pattern.py,sha256=MpUmsHYGAVAuFSKSb29FLcWeUCEHG_TRyhMO-2DWAAs,8308
+semantic_release/version/declarations/pattern.py,sha256=sKk0uQpJjWVZc8RJUjxQoEPUvFLxXNGGBow5h1IqCTM,8378
 semantic_release/version/declarations/toml.py,sha256=2K4DtX5Qq1iHT8cG8mISPTMmp50w6Av0KmLAKZPYqq8,4931
-python_semantic_release-10.4.1.dist-info/METADATA,sha256=_p8pbdBeY6Sz6ch5N7HguLDiBT2IzfNR5NflXHrTt38,3927
-python_semantic_release-10.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-python_semantic_release-10.4.1.dist-info/entry_points.txt,sha256=kzkCyDJsMOwgpFwEWKE9wxN1tXaUP6g6GIO4xtc0QuE,162
-python_semantic_release-10.4.1.dist-info/top_level.txt,sha256=qYA24nyg3eP-ti5UW7Vuj2aXVmM0wqVHx4mREdRZNAA,17
-python_semantic_release-10.4.1.dist-info/RECORD,,
+python_semantic_release-10.5.1.dist-info/METADATA,sha256=BMnYUZ_wcxmoCISQx404tvKP6cj-yrPjvXJjcN7RJ3s,4064
+python_semantic_release-10.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_semantic_release-10.5.1.dist-info/entry_points.txt,sha256=kzkCyDJsMOwgpFwEWKE9wxN1tXaUP6g6GIO4xtc0QuE,162
+python_semantic_release-10.5.1.dist-info/top_level.txt,sha256=qYA24nyg3eP-ti5UW7Vuj2aXVmM0wqVHx4mREdRZNAA,17
+python_semantic_release-10.5.1.dist-info/RECORD,,

semantic_release/changelog/context.py

@@ -119,7 +119,7 @@ def read_file(filepath: str) -> str:
             return rfd.read()
 
     except FileNotFoundError as err:
-        logging.warning(err)
+        logging.warning(str(err))
         return ""
 
 

semantic_release/cli/commands/version.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING
 import click
 import shellingham  # type: ignore[import]
 from click_option_group import MutuallyExclusiveOptionGroup, optgroup
-from git import Repo
+from git import GitCommandError, Repo
 from requests import HTTPError
 
 from semantic_release.changelog.release_history import ReleaseHistory
@@ -27,9 +27,14 @@ from semantic_release.const import DEFAULT_SHELL, DEFAULT_VERSION
 from semantic_release.enums import LevelBump
 from semantic_release.errors import (
     BuildDistributionsError,
+    DetachedHeadGitError,
     GitCommitEmptyIndexError,
+    GitFetchError,
     InternalError,
+    LocalGitError,
     UnexpectedResponse,
+    UnknownUpstreamBranchError,
+    UpstreamBranchChangedError,
 )
 from semantic_release.gitproject import GitProject
 from semantic_release.globals import logger
@@ -75,10 +80,13 @@ def is_forced_prerelease(
     )
 
 
-def last_released(repo_dir: Path, tag_format: str) -> tuple[Tag, Version] | None:
+def last_released(
+    repo_dir: Path, tag_format: str, add_partial_tags: bool = False
+) -> tuple[Tag, Version] | None:
     with Repo(str(repo_dir)) as git_repo:
         ts_and_vs = tags_and_versions(
-            git_repo.tags, VersionTranslator(tag_format=tag_format)
+            git_repo.tags,
+            VersionTranslator(tag_format=tag_format, add_partial_tags=add_partial_tags),
         )
 
     return ts_and_vs[0] if ts_and_vs else None
@@ -449,7 +457,11 @@ def version(  # noqa: C901
     if print_last_released or print_last_released_tag:
         # TODO: get tag format a better way
         if not (
-            last_release := last_released(config.repo_dir, tag_format=config.tag_format)
+            last_release := last_released(
+                config.repo_dir,
+                tag_format=config.tag_format,
+                add_partial_tags=config.add_partial_tags,
+            )
         ):
             logger.warning("No release tags found.")
             return
@@ -470,6 +482,7 @@ def version(  # noqa: C901
     major_on_zero = runtime.major_on_zero
     no_verify = runtime.no_git_verify
     opts = runtime.global_cli_options
+    add_partial_tags = config.add_partial_tags
     gha_output = VersionGitHubActionsOutput(
         gh_client=hvcs_client if isinstance(hvcs_client, Github) else None,
         mode=(
@@ -491,6 +504,17 @@ def version(  # noqa: C901
         logger.info("Forcing use of %s as the prerelease token", prerelease_token)
         translator.prerelease_token = prerelease_token
 
+    # Check if the repository is shallow and unshallow it if necessary
+    # This ensures we have the full history for commit analysis
+    project = GitProject(
+        directory=runtime.repo_dir,
+        commit_author=runtime.commit_author,
+        credential_masker=runtime.masker,
+    )
+    if project.is_shallow_clone():
+        logger.info("Repository is a shallow clone, converting to full clone...")
+        project.git_unshallow(noop=opts.noop)
+
     # Only push if we're committing changes
     if push_changes and not commit_changes and not create_tag:
         logger.info("changes will not be pushed because --no-commit disables pushing")
@@ -683,12 +707,6 @@ def version(  # noqa: C901
         license_name="" if not isinstance(license_cfg, str) else license_cfg,
     )
 
-    project = GitProject(
-        directory=runtime.repo_dir,
-        commit_author=runtime.commit_author,
-        credential_masker=runtime.masker,
-    )
-
     # Preparing for committing changes; we always stage files even if we're not committing them in order to support a two-stage commit
     project.git_add(paths=all_paths_to_add, noop=opts.noop)
     if commit_changes:
@@ -727,6 +745,33 @@ def version(  # noqa: C901
         )
 
         if commit_changes:
+            # Verify that the upstream branch has not changed before pushing
+            # This prevents conflicts if another commit was pushed while we were preparing the release
+            # We check HEAD~1 because we just made a release commit
+            try:
+                project.verify_upstream_unchanged(
+                    local_ref="HEAD~1",
+                    upstream_ref=config.remote.name,
+                    noop=opts.noop,
+                )
+            except UpstreamBranchChangedError as exc:
+                click.echo(str(exc), err=True)
+                click.echo(
+                    "Upstream branch has changed. Please pull the latest changes and try again.",
+                    err=True,
+                )
+                ctx.exit(1)
+            except (
+                DetachedHeadGitError,
+                GitCommandError,
+                UnknownUpstreamBranchError,
+                GitFetchError,
+                LocalGitError,
+            ) as exc:
+                click.echo(str(exc), err=True)
+                click.echo("Unable to verify upstream due to error!", err=True)
+                ctx.exit(1)
+
             # TODO: integrate into push branch
             with Repo(str(runtime.repo_dir)) as git_repo:
                 active_branch = git_repo.active_branch.name
@@ -744,6 +789,27 @@ def version(  # noqa: C901
                 tag=new_version.as_tag(),
                 noop=opts.noop,
             )
+            # Create or update partial tags for releases
+            if add_partial_tags and not prerelease:
+                partial_tags = [new_version.as_major_tag(), new_version.as_minor_tag()]
+                # If build metadata is set, also retag the version without the metadata
+                if build_metadata:
+                    partial_tags.append(new_version.as_patch_tag())
+
+                for partial_tag in partial_tags:
+                    project.git_tag(
+                        tag_name=partial_tag,
+                        message=f"{partial_tag} => {new_version.as_tag()}",
+                        isotimestamp=commit_date.isoformat(),
+                        noop=opts.noop,
+                        force=True,
+                    )
+                    project.git_push_tag(
+                        remote_url=remote_url,
+                        tag=partial_tag,
+                        noop=opts.noop,
+                        force=True,
+                    )
 
     # Update GitHub Actions output value now that release has occurred
     gha_output.released = True

semantic_release/cli/config.py

@@ -366,6 +366,7 @@ class RawConfig(BaseModel):
     remote: RemoteConfig = RemoteConfig()
     no_git_verify: bool = False
     tag_format: str = "v{version}"
+    add_partial_tags: bool = False
     publish: PublishConfig = PublishConfig()
     version_toml: Optional[Tuple[str, ...]] = None
     version_variables: Optional[Tuple[str, ...]] = None
@@ -827,7 +828,9 @@ class RuntimeContext:
 
         # version_translator
         version_translator = VersionTranslator(
-            tag_format=raw.tag_format, prerelease_token=branch_config.prerelease_token
+            tag_format=raw.tag_format,
+            prerelease_token=branch_config.prerelease_token,
+            add_partial_tags=raw.add_partial_tags,
         )
 
         build_cmd_env = {}

semantic_release/cli/masking_filter.py

@@ -62,9 +62,7 @@ class MaskingFilter(LoggingFilter):
 
     def mask(self, msg: str) -> str:
         if not isinstance(msg, str):
-            logger.debug(  # type: ignore[unreachable]
-                "cannot mask object of type %s", type(msg)
-            )
+            logger.debug("cannot mask object of type %s", type(msg))
             return msg
         for mask, values in self._redact_patterns.items():
             repl_string = (

semantic_release/errors.py

@@ -106,3 +106,19 @@ class GitTagError(SemanticReleaseBaseError):
 
 class GitPushError(SemanticReleaseBaseError):
     """Raised when there is a failure to push to the git remote."""
+
+
+class GitFetchError(SemanticReleaseBaseError):
+    """Raised when there is a failure to fetch from the git remote."""
+
+
+class LocalGitError(SemanticReleaseBaseError):
+    """Raised when there is a failure with local git operations."""
+
+
+class UnknownUpstreamBranchError(SemanticReleaseBaseError):
+    """Raised when the upstream branch cannot be determined."""
+
+
+class UpstreamBranchChangedError(SemanticReleaseBaseError):
+    """Raised when the upstream branch has changed before pushing."""

semantic_release/gitproject.py

@@ -12,11 +12,16 @@ from git import GitCommandError, Repo
 from semantic_release.cli.masking_filter import MaskingFilter
 from semantic_release.cli.util import indented, noop_report
 from semantic_release.errors import (
+    DetachedHeadGitError,
     GitAddError,
     GitCommitEmptyIndexError,
     GitCommitError,
+    GitFetchError,
     GitPushError,
     GitTagError,
+    LocalGitError,
+    UnknownUpstreamBranchError,
+    UpstreamBranchChangedError,
 )
 from semantic_release.globals import logger
 
@@ -85,6 +90,42 @@ class GitProject:
         with Repo(str(self.project_root)) as repo:
             return repo.is_dirty()
 
+    def is_shallow_clone(self) -> bool:
+        """
+        Check if the repository is a shallow clone.
+
+        :return: True if the repository is a shallow clone, False otherwise
+        """
+        with Repo(str(self.project_root)) as repo:
+            shallow_file = Path(repo.git_dir, "shallow")
+            return shallow_file.exists()
+
+    def git_unshallow(self, noop: bool = False) -> None:
+        """
+        Convert a shallow clone to a full clone by fetching the full history.
+
+        :param noop: Whether or not to actually run the unshallow command
+        """
+        if noop:
+            noop_report("would have run:\n" "    git fetch --unshallow")
+            return
+
+        with Repo(str(self.project_root)) as repo:
+            try:
+                self.logger.info("Converting shallow clone to full clone...")
+                repo.git.fetch("--unshallow")
+                self.logger.info("Repository unshallowed successfully")
+            except GitCommandError as err:
+                # If the repository is already a full clone, git fetch --unshallow will fail
+                # with "fatal: --unshallow on a complete repository does not make sense"
+                # We can safely ignore this error by checking the stderr message
+                stderr = str(err.stderr) if err.stderr else ""
+                if "does not make sense" in stderr or "complete repository" in stderr:
+                    self.logger.debug("Repository is already a full clone")
+                else:
+                    self.logger.exception(str(err))
+                    raise
+
     def git_add(
         self,
         paths: Sequence[Path | str],
@@ -197,7 +238,12 @@ class GitProject:
                     raise GitCommitError("Failed to commit changes") from err
 
     def git_tag(
-        self, tag_name: str, message: str, isotimestamp: str, noop: bool = False
+        self,
+        tag_name: str,
+        message: str,
+        isotimestamp: str,
+        force: bool = False,
+        noop: bool = False,
     ) -> None:
         try:
             datetime.fromisoformat(isotimestamp)
@@ -207,21 +253,25 @@ class GitProject:
         if noop:
             command = str.join(
                 " ",
-                [
-                    f"GIT_COMMITTER_DATE={isotimestamp}",
-                    *(
-                        [
-                            f"GIT_AUTHOR_NAME={self._commit_author.name}",
-                            f"GIT_AUTHOR_EMAIL={self._commit_author.email}",
-                            f"GIT_COMMITTER_NAME={self._commit_author.name}",
-                            f"GIT_COMMITTER_EMAIL={self._commit_author.email}",
-                        ]
-                        if self._commit_author
-                        else [""]
-                    ),
-                    f"git tag -a {tag_name} -m '{message}'",
-                ],
-            )
+                filter(
+                    None,
+                    [
+                        f"GIT_COMMITTER_DATE={isotimestamp}",
+                        *(
+                            [
+                                f"GIT_AUTHOR_NAME={self._commit_author.name}",
+                                f"GIT_AUTHOR_EMAIL={self._commit_author.email}",
+                                f"GIT_COMMITTER_NAME={self._commit_author.name}",
+                                f"GIT_COMMITTER_EMAIL={self._commit_author.email}",
+                            ]
+                            if self._commit_author
+                            else [""]
+                        ),
+                        f"git tag -a {tag_name} -m '{message}'",
+                        "--force" if force else "",
+                    ],
+                ),
+            ).strip()
 
             noop_report(
                 indented(
@@ -238,7 +288,7 @@ class GitProject:
             {"GIT_COMMITTER_DATE": isotimestamp},
         ):
             try:
-                repo.git.tag("-a", tag_name, m=message)
+                repo.git.tag(tag_name, a=True, m=message, force=force)
             except GitCommandError as err:
                 self.logger.exception(str(err))
                 raise GitTagError(f"Failed to create tag ({tag_name})") from err
@@ -264,13 +314,15 @@ class GitProject:
                     f"Failed to push branch ({branch}) to remote"
                 ) from err
 
-    def git_push_tag(self, remote_url: str, tag: str, noop: bool = False) -> None:
+    def git_push_tag(
+        self, remote_url: str, tag: str, noop: bool = False, force: bool = False
+    ) -> None:
         if noop:
             noop_report(
                 indented(
                     f"""\
                     would have run:
-                        git push {self._cred_masker.mask(remote_url)} tag {tag}
+                        git push {self._cred_masker.mask(remote_url)} tag {tag} {"--force" if force else ""}
                     """  # noqa: E501
                 )
             )
@@ -278,7 +330,122 @@ class GitProject:
 
         with Repo(str(self.project_root)) as repo:
             try:
-                repo.git.push(remote_url, "tag", tag)
+                repo.git.push(remote_url, "tag", tag, force=force)
             except GitCommandError as err:
                 self.logger.exception(str(err))
                 raise GitPushError(f"Failed to push tag ({tag}) to remote") from err
+
+    def verify_upstream_unchanged(  # noqa: C901
+        self, local_ref: str = "HEAD", upstream_ref: str = "origin", noop: bool = False
+    ) -> None:
+        """
+        Verify that the upstream branch has not changed since the given local reference.
+
+        :param local_ref: The local reference to compare against upstream (default: HEAD)
+        :param upstream_ref: The name of the upstream remote or specific remote branch (default: origin)
+        :param noop: Whether to skip the actual verification (for dry-run mode)
+
+        :raises UpstreamBranchChangedError: If the upstream branch has changed
+        """
+        if not local_ref.strip():
+            raise ValueError("Local reference cannot be empty")
+        if not upstream_ref.strip():
+            raise ValueError("Upstream reference cannot be empty")
+
+        if noop:
+            noop_report(
+                indented(
+                    """\
+                    would have verified that upstream branch has not changed
+                    """
+                )
+            )
+            return
+
+        with Repo(str(self.project_root)) as repo:
+            # Get the current active branch
+            try:
+                active_branch = repo.active_branch
+            except TypeError:
+                # When in detached HEAD state, active_branch raises TypeError
+                err_msg = (
+                    "Repository is in detached HEAD state, cannot verify upstream state"
+                )
+                raise DetachedHeadGitError(err_msg) from None
+
+            # Get the tracking branch (upstream branch)
+            if (tracking_branch := active_branch.tracking_branch()) is not None:
+                upstream_full_ref_name = tracking_branch.name
+                self.logger.info("Upstream branch name: %s", upstream_full_ref_name)
+            else:
+                # If no tracking branch is set, derive it
+                upstream_name = (
+                    upstream_ref.strip()
+                    if upstream_ref.find("/") == -1
+                    else upstream_ref.strip().split("/", maxsplit=1)[0]
+                )
+
+                if not repo.remotes or upstream_name not in repo.remotes:
+                    err_msg = "No remote found; cannot verify upstream state!"
+                    raise UnknownUpstreamBranchError(err_msg)
+
+                upstream_full_ref_name = (
+                    f"{upstream_name}/{active_branch.name}"
+                    if upstream_ref.find("/") == -1
+                    else upstream_ref.strip()
+                )
+
+                if upstream_full_ref_name not in repo.refs:
+                    err_msg = f"No upstream branch found for '{active_branch.name}'; cannot verify upstream state!"
+                    raise UnknownUpstreamBranchError(err_msg)
+
+            # Extract the remote name from the tracking branch
+            # tracking_branch.name is in the format "remote/branch"
+            remote_name, remote_branch_name = upstream_full_ref_name.split(
+                "/", maxsplit=1
+            )
+            remote_ref_obj = repo.remotes[remote_name]
+
+            # Fetch the latest changes from the remote
+            self.logger.info("Fetching latest changes from remote '%s'", remote_name)
+            try:
+                remote_ref_obj.fetch()
+            except GitCommandError as err:
+                self.logger.exception(str(err))
+                err_msg = f"Failed to fetch from remote '{remote_name}'"
+                raise GitFetchError(err_msg) from err
+
+            # Get the SHA of the upstream branch
+            try:
+                upstream_commit_ref = remote_ref_obj.refs[remote_branch_name].commit
+                upstream_sha = upstream_commit_ref.hexsha
+            except AttributeError as err:
+                self.logger.exception(str(err))
+                err_msg = f"Unable to determine upstream branch SHA for '{upstream_full_ref_name}'"
+                raise GitFetchError(err_msg) from err
+
+            # Get the SHA of the specified ref (default: HEAD)
+            try:
+                local_commit = repo.commit(repo.git.rev_parse(local_ref))
+            except GitCommandError as err:
+                self.logger.exception(str(err))
+                err_msg = f"Unable to determine the SHA for local ref '{local_ref}'"
+                raise LocalGitError(err_msg) from err
+
+            # Compare the two SHAs
+            if local_commit.hexsha != upstream_sha and not any(
+                commit.hexsha == upstream_sha for commit in local_commit.iter_parents()
+            ):
+                err_msg = str.join(
+                    "\n",
+                    (
+                        f"[LOCAL SHA] {local_commit.hexsha} != {upstream_sha} [UPSTREAM SHA].",
+                        f"Upstream branch '{upstream_full_ref_name}' has changed!",
+                    ),
+                )
+                raise UpstreamBranchChangedError(err_msg)
+
+            self.logger.info(
+                "Verified upstream branch '%s' has not changed",
+                upstream_full_ref_name,
+            )

semantic_release/version/declarations/pattern.py

@@ -228,8 +228,8 @@ class PatternVersionDeclaration(IVersionReplacer):
                 # Negative lookbehind to ensure we don't match part of a variable name
                 f"""(?x)(?P<quote1>['"])?(?<![\\w.-]){regex_escape(variable)}(?P=quote1)?""",
                 # Supports walrus, equals sign, double-equals, colon, or @ as assignment operator
-                # ignoring whitespace separation
-                r"\s*(:=|==|[:=@])\s*",
+                # ignoring whitespace separation. Also allows a space as the separator for c-macro style definitions.
+                r"\s*(:=|==|[:=@ ])\s*",
                 # Supports optional matching quotations around a version pattern (tag or raw format)
                 f"""(?P<quote2>['"])?{value_replace_pattern_str}(?P=quote2)?""",
             ],

semantic_release/version/translator.py

@@ -1,12 +1,16 @@
 from __future__ import annotations
 
-import re
+from re import VERBOSE, compile as regexp, escape as regex_escape
+from typing import TYPE_CHECKING
 
 from semantic_release.const import SEMVER_REGEX
 from semantic_release.globals import logger
 from semantic_release.helpers import check_tag_format
 from semantic_release.version.version import Version
 
+if TYPE_CHECKING:
+    from re import Pattern
+
 
 class VersionTranslator:
     """
@@ -17,7 +21,7 @@ class VersionTranslator:
     _VERSION_REGEX = SEMVER_REGEX
 
     @classmethod
-    def _invert_tag_format_to_re(cls, tag_format: str) -> re.Pattern[str]:
+    def _invert_tag_format_to_re(cls, tag_format: str) -> Pattern[str]:
         r"""
         Unpick the "tag_format" format string and create a regex which can be used to
         convert a tag to a version string.
@@ -31,9 +35,11 @@ class VersionTranslator:
         >>> assert m is not None
         >>> assert m.expand(r"\g<version>") == version
         """
-        pat = re.compile(
-            tag_format.replace(r"{version}", r"(?P<version>.*)"),
-            flags=re.VERBOSE,
+        pat = regexp(
+            regex_escape(tag_format).replace(
+                regex_escape(r"{version}"), r"(?P<version>.+)"
+            ),
+            flags=VERBOSE,
         )
         logger.debug("inverted tag_format %r to %r", tag_format, pat.pattern)
         return pat
@@ -42,11 +48,19 @@ class VersionTranslator:
         self,
         tag_format: str = "v{version}",
         prerelease_token: str = "rc",  # noqa: S107
+        add_partial_tags: bool = False,
     ) -> None:
         check_tag_format(tag_format)
         self.tag_format = tag_format
         self.prerelease_token = prerelease_token
+        self.add_partial_tags = add_partial_tags
         self.from_tag_re = self._invert_tag_format_to_re(self.tag_format)
+        self.partial_tag_re = regexp(
+            regex_escape(tag_format).replace(
+                regex_escape(r"{version}"), r"[0-9]+(\.(0|[1-9][0-9]*))?$"
+            ),
+            flags=VERBOSE,
+        )
 
     def from_string(self, version_str: str) -> Version:
         """
@@ -69,6 +83,10 @@ class VersionTranslator:
         tag_match = self.from_tag_re.match(tag)
         if not tag_match:
             return None
+        if self.add_partial_tags:
+            partial_tag_match = self.partial_tag_re.match(tag)
+            if partial_tag_match:
+                return None
         raw_version_str = tag_match.group("version")
         return self.from_string(raw_version_str)
 

semantic_release/version/version.py

@@ -203,6 +203,15 @@ class Version:
     def as_tag(self) -> str:
         return self.tag_format.format(version=str(self))
 
+    def as_major_tag(self) -> str:
+        return self.tag_format.format(version=f"{self.major}")
+
+    def as_minor_tag(self) -> str:
+        return self.tag_format.format(version=f"{self.major}.{self.minor}")
+
+    def as_patch_tag(self) -> str:
+        return self.tag_format.format(version=f"{self.major}.{self.minor}.{self.patch}")
+
     def as_semver_tag(self) -> str:
         return f"v{self!s}"