python-semantic-release 9.16.0__py3-none-any.whl → 9.17.0__py3-none-any.whl

{python_semantic_release-9.16.0.dist-info → python_semantic_release-9.17.0.dist-info}/METADATA

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

{python_semantic_release-9.16.0.dist-info → python_semantic_release-9.17.0.dist-info}/RECORD

@@ -1,38 +1,38 @@
-semantic_release/__init__.py,sha256=qoHIydYblv9yYDLj0kA33b0YRNJntB6JxPkiePPKdFU,1229
+semantic_release/__init__.py,sha256=HGRoymlde9dCDLCL2q3_ispJjvMuGYmdsAyWsLPpHfM,1229
 semantic_release/__main__.py,sha256=KOIBOvLruqfi5ArXcWK3ucIZ7NB55kfCbycJaxx6aQg,1485
 semantic_release/const.py,sha256=Z1o2QNh60wSLeF-_1TemMBjU3ZXbV0XghnUFsbTVfOs,831
 semantic_release/enums.py,sha256=vrEw1UNRcNrFjPqOFnuUzfeoqKj0ChixVVlyk5fqbng,1744
 semantic_release/errors.py,sha256=PY9rmviSFBZkqawW6VXbUfmF9C_RNOIObcmeGxLefMo,2904
 semantic_release/gitproject.py,sha256=G4XrucN-ZwT1Kj4RMrABcr1vWb0bjKgurEeJjcL-61c,9422
 semantic_release/globals.py,sha256=imI9WKGa6MS2pTRAZiWZ2qIJup2eWnBz3OZmIj2YIHM,158
-semantic_release/helpers.py,sha256=RaAw8OHhH5i0BvOlM_mYgL_CMHmCGW_2pMPxhmjz1v8,6895
+semantic_release/helpers.py,sha256=T7gEYx9npipoV1-lNc0n-_vwVbdVqeREpQ4mv66auTE,9529
 semantic_release/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantic_release/changelog/__init__.py,sha256=Bg6Xe5Vt32rWoMscW-hd4sUwiZqzWmsg4CD1EhMesMY,262
-semantic_release/changelog/context.py,sha256=jyVluJq8Vu6TyyzQQrsBIQRKm7kEnh1GZt8ObwibR5k,5374
-semantic_release/changelog/release_history.py,sha256=nbd-WYVfQSWN4SKPPWEGU6QgNZLBrNxKKxfhPGKqnKc,8499
-semantic_release/changelog/template.py,sha256=O4EKXVJtN1z6FowcRUiZdZmi9u_TsTiXcHmYJnGyt94,5721
+semantic_release/changelog/context.py,sha256=TcBG-fVmYuxl7uD-AtsHVVE5Md5KwCRGJQxbE3dJdTc,5459
+semantic_release/changelog/release_history.py,sha256=d_n35sJHFJHgni3-xKXfkCoMiSZLy3ChLU5e9Tn5g4c,9267
+semantic_release/changelog/template.py,sha256=R3V5m-7kv9ES23e_g37fe17tk-ESgvwV0C9rp5uoeOE,5691
 semantic_release/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-semantic_release/cli/changelog_writer.py,sha256=RupwYqApOeAMidIvjCttnyyGNRxtLftmxDBmEu5azX0,9049
+semantic_release/cli/changelog_writer.py,sha256=S91en98KrmXMA0AUwqsWa8zGY1i2-LRVFBcK0jWqfPw,9168
 semantic_release/cli/cli_context.py,sha256=Nop71LdVCJOeSUHgTXunMyK3xAu_QKQC2cRp1QBVkX0,4134
-semantic_release/cli/config.py,sha256=TnvHDaqMbNp2hWeRyi-o3UbZ1_mH766RL76N_ca2Puc,32073
+semantic_release/cli/config.py,sha256=aYquSXNdjhF45BvqcdjaQSu1DcRJeugifOvpMyknwrU,32337
 semantic_release/cli/const.py,sha256=h7XE2D0D__TAZSrUUtVszwvzpkHTMOiQCf97XQNbEvA,163
 semantic_release/cli/github_actions_output.py,sha256=6oNwjnQBg9XF5QgGc4TgbwX_-W0aj65VwGSL4ALvqVg,2296
-semantic_release/cli/masking_filter.py,sha256=DxqjiJyABlzwwwZ1r8JGQpb6QrF00StJFm0-2-s5Fv0,3071
+semantic_release/cli/masking_filter.py,sha256=ric34rnXfN5RiAVVaKnhiMJOxTnEl26kI06jQqZPZoQ,3072
 semantic_release/cli/util.py,sha256=FyXaBkeL7nXKjy3X9rQLEwvn7p46xPekp2V8Z-5MVrk,3755
 semantic_release/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantic_release/cli/commands/changelog.py,sha256=w_sXuFJHIqcueBQdeNeWn6fqbLVPPl_c-dEhv3Pb_BA,3870
 semantic_release/cli/commands/generate_config.py,sha256=2xZOu3NpyhBp0pWr7d8ugKl_kjqQgpSsSMHq5wHTfrE,1699
 semantic_release/cli/commands/main.py,sha256=237rn_Od4LOWfjUjiUKI_jSV820MfcCtRpwPjxjLbyU,4312
 semantic_release/cli/commands/publish.py,sha256=y_LalPti_kZeQJzl2CR2pTZUK8DCMvNSTe4NaMC5TJA,2875
-semantic_release/cli/commands/version.py,sha256=ztNoAUVFjXE2bjrrKXB1EUIOpwRPpnfR_zYdtnp_uQQ,24813
+semantic_release/cli/commands/version.py,sha256=y8m8ZyJe9vGhNsl5El2a4QwNM-upTRHfJS2T9zJoFWc,24824
 semantic_release/commit_parser/__init__.py,sha256=cv5HFBdw7OJd4Laj4Ex8ZZ5Tml8GwXgQcXW6Pasr2Ao,615
-semantic_release/commit_parser/_base.py,sha256=LAscBtS3_28jebRCeR-eGo3UtAsuxCWBzgb7FF4n4Vo,3046
-semantic_release/commit_parser/angular.py,sha256=zDYYOK1itsYJ0Ar7-cf29MnfrEpbQTeQCAcExWPH1fM,10486
-semantic_release/commit_parser/emoji.py,sha256=6HtvKvJZwPAvY2fNOXU_gpKf1rGrMiDd0rYamyrdQZ8,10002
-semantic_release/commit_parser/scipy.py,sha256=Fm_6WUaliLmqD397uVXwpOSDZ7LpMFu59oz-inKeHko,4526
-semantic_release/commit_parser/tag.py,sha256=4uwIKBqUM2SE6UTGIw-a7B6Jg1OONXmGwXsTyL3yZBA,3490
+semantic_release/commit_parser/_base.py,sha256=oDifeTmFDpS238cp_DDrGzfidaKeAD5olCB5IM4Q6z8,3058
+semantic_release/commit_parser/angular.py,sha256=tJqc9A-XJs85FH1EiDgm-k3_ryhPp8ln0EbrkRZkoWo,18367
+semantic_release/commit_parser/emoji.py,sha256=zXlQUwTawMq9G7Uf5nriNQJv_tXFDev9UG3CHT3_Jvs,17283
+semantic_release/commit_parser/scipy.py,sha256=0rYZglJ7uib-1Deu4J30wHh7AZS8KfO0eND82bPtDQ8,4526
+semantic_release/commit_parser/tag.py,sha256=oGB3lgyp2Eu3Tg3jjxqNzN86N6bokSaFu6f4Ir6IS_k,3546
 semantic_release/commit_parser/token.py,sha256=RXdoCmKMTKMmUJGEUvfCiAOCPRrV0WubXojwa6FbvFg,7363
-semantic_release/commit_parser/util.py,sha256=KmJ-M-CJbc7q37GG7o595SmeBwrRrrnjP4q1C05jGYI,2463
+semantic_release/commit_parser/util.py,sha256=9diralZ8QbMOMpVEp9MtrMVdkGsD-fS1F4cmy6eyysU,3674
 semantic_release/data/templates/angular/md/.release_notes.md.j2,sha256=BzpatS7WYBcpHii8qiDemyI1ygXM6Q1nbxdcdcps__U,2107
 semantic_release/data/templates/angular/md/CHANGELOG.md.j2,sha256=FZmrQ-qOIoSoJmAa_NFaRelfmqUpypU2xlDeScdGOf4,729
 semantic_release/data/templates/angular/md/.components/changelog_header.md.j2,sha256=qNxTuSr59CV_yyimVU_RYp5azCnK0l6nJ03Zf0u5Ugg,166
@@ -53,7 +53,7 @@ semantic_release/data/templates/angular/rst/.components/macros.rst.j2,sha256=luN
 semantic_release/data/templates/angular/rst/.components/unreleased_changes.rst.j2,sha256=ARBhc1ZpKwehGKDvOMqukmN59mTJiHzHsS7rOfKYCt8,202
 semantic_release/data/templates/angular/rst/.components/versioned_changes.rst.j2,sha256=NZfn1W14QochiAJ43oNKmcrCn_vgfbkKtvOTAw1jEc8,530
 semantic_release/hvcs/__init__.py,sha256=JwoaLOF-12L-OBo_9-tOXXhdiHKeVungA9865to2oZk,494
-semantic_release/hvcs/_base.py,sha256=OSUpUkxxmhafRqz8y60DdKK8PmudzJ7rEzXgIzo3aXc,2627
+semantic_release/hvcs/_base.py,sha256=ycHg0WljEVTqjFXoGRrHMvbyqWqPs4HziB090IcPZSE,2664
 semantic_release/hvcs/bitbucket.py,sha256=Hzk27OOcpedFKVX4z3cY8DIUNNxe6D57J0d3sWNPIOY,9687
 semantic_release/hvcs/gitea.py,sha256=YTpAnJ4bBdMjIhgAvVMF8vPZ6O07IgWuXeqTbEU-GNE,12715
 semantic_release/hvcs/github.py,sha256=PLqbXDpHvXqE-uY8dmv7MuyjjnkMv0Va0vXo3UQUIUA,19937
@@ -62,14 +62,14 @@ semantic_release/hvcs/remote_hvcs_base.py,sha256=cV8qYHtP47bmfIZqV4K2EiMHskFEoIo
 semantic_release/hvcs/token_auth.py,sha256=ZjT56-NIPB4OKIt1qwHCu1TavXnrWFIBl9ARlg56hgU,663
 semantic_release/hvcs/util.py,sha256=guxisysY_IW5tv7aaV-iVPEVJzgbOs375kiRRpSquTI,2879
 semantic_release/version/__init__.py,sha256=CLhtGQry9dLIij5XyRa9ZevxU_1p8tjMTSQ-K_GMpWM,270
-semantic_release/version/algorithm.py,sha256=0cj5LqT8DpBr2zo7Va0-VP8t6a3xAIhFiTLb11xdGpo,15246
+semantic_release/version/algorithm.py,sha256=-ppIqvvcAvc4nMtsClNNEzpEHWzgv2oKFydMW6ium6M,15941
 semantic_release/version/declaration.py,sha256=f6Ld7hIhrqvDrRBapJHr-KDimuyo-4IG8009Zu9BIgU,7357
 semantic_release/version/translator.py,sha256=P1noIsVBn8u6zNOFjG0xKYOWapxqf_PHSMvMeLJ9kXg,3050
 semantic_release/version/version.py,sha256=6PCtSbLP88U1daoxnCwHc--YguZo4waGNLqJ5JfeczE,14175
-python_semantic_release-9.16.0.dist-info/AUTHORS.rst,sha256=XOReVvpymEFUPsS2QPH97jlfJBVrxwS2eu8-jVAe4gk,230
-python_semantic_release-9.16.0.dist-info/LICENSE,sha256=NE85nszX252sdQdu0xgS9qwfYES0k8qS6gW3uO4jRGE,1083
-python_semantic_release-9.16.0.dist-info/METADATA,sha256=DvS5Bk7xkZzATIIy7f5thMV7otvrLR_RN_aR_gJv91M,3812
-python_semantic_release-9.16.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-python_semantic_release-9.16.0.dist-info/entry_points.txt,sha256=r2Jql3GTQyugQnvf34l2eXk1O_Qx6llR_xixG1ZWgD0,105
-python_semantic_release-9.16.0.dist-info/top_level.txt,sha256=qYA24nyg3eP-ti5UW7Vuj2aXVmM0wqVHx4mREdRZNAA,17
-python_semantic_release-9.16.0.dist-info/RECORD,,
+python_semantic_release-9.17.0.dist-info/AUTHORS.rst,sha256=XOReVvpymEFUPsS2QPH97jlfJBVrxwS2eu8-jVAe4gk,230
+python_semantic_release-9.17.0.dist-info/LICENSE,sha256=NE85nszX252sdQdu0xgS9qwfYES0k8qS6gW3uO4jRGE,1083
+python_semantic_release-9.17.0.dist-info/METADATA,sha256=1xRK6C1aw6HjxmCa963whjgtiQPjhbOcSW0vhaghQ_M,3812
+python_semantic_release-9.17.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+python_semantic_release-9.17.0.dist-info/entry_points.txt,sha256=r2Jql3GTQyugQnvf34l2eXk1O_Qx6llR_xixG1ZWgD0,105
+python_semantic_release-9.17.0.dist-info/top_level.txt,sha256=qYA24nyg3eP-ti5UW7Vuj2aXVmM0wqVHx4mREdRZNAA,17
+python_semantic_release-9.17.0.dist-info/RECORD,,

semantic_release/__init__.py

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

semantic_release/changelog/context.py

@@ -8,6 +8,8 @@ from pathlib import Path
 from re import compile as regexp
 from typing import TYPE_CHECKING, Any, Callable, Literal
 
+from semantic_release.helpers import sort_numerically
+
 if TYPE_CHECKING:  # pragma: no cover
     from jinja2 import Environment
 
@@ -87,6 +89,7 @@ def make_changelog_context(
             read_file,
             convert_md_to_rst,
             autofit_text_width,
+            sort_numerically,
         ),
     )
 

semantic_release/changelog/release_history.py

@@ -102,75 +102,85 @@ class ReleaseHistory:
 
                 released.setdefault(the_version, release)
 
-            # mypy will be happy if we make this an explicit string
-            commit_message = str(commit.message)
-
             log.info(
                 "parsing commit [%s] %s",
                 commit.hexsha[:8],
-                commit_message.replace("\n", " ")[:54],
-            )
-            parse_result = commit_parser.parse(commit)
-            commit_type = (
-                "unknown" if isinstance(parse_result, ParseError) else parse_result.type
-            )
-
-            has_exclusion_match = any(
-                pattern.match(commit_message) for pattern in exclude_commit_patterns
-            )
-
-            commit_level_bump = (
-                LevelBump.NO_RELEASE
-                if isinstance(parse_result, ParseError)
-                else parse_result.bump
+                str(commit.message).replace("\n", " ")[:54],
             )
+            # returns a ParseResult or list of ParseResult objects,
+            # it is usually one, but we split a commit if a squashed merge is detected
+            parse_results = commit_parser.parse(commit)
+            if not isinstance(parse_results, list):
+                parse_results = [parse_results]
+
+            is_squash_commit = bool(len(parse_results) > 1)
+
+            # iterate through parsed commits to add to changelog definition
+            for parsed_result in parse_results:
+                commit_message = str(parsed_result.commit.message)
+                commit_type = (
+                    "unknown"
+                    if isinstance(parsed_result, ParseError)
+                    else parsed_result.type
+                )
+                log.debug("commit has type '%s'", commit_type)
 
-            # Skip excluded commits except for any commit causing a version bump
-            # Reasoning: if a commit causes a version bump, and no other commits
-            # are included, then the changelog will be empty. Even if ther was other
-            # commits included, the true reason for a version bump would be missing.
-            if has_exclusion_match and commit_level_bump == LevelBump.NO_RELEASE:
-                log.info(
-                    "Excluding commit [%s] %s",
-                    commit.hexsha[:8],
-                    commit_message.replace("\n", " ")[:50],
+                has_exclusion_match = any(
+                    pattern.match(commit_message) for pattern in exclude_commit_patterns
                 )
-                continue
 
-            if (
-                isinstance(parse_result, ParsedCommit)
-                and not parse_result.include_in_changelog
-            ):
-                log.info(
-                    str.join(
-                        " ",
-                        [
-                            "Excluding commit %s (%s) because parser determined",
-                            "it should not included in the changelog",
-                        ],
-                    ),
-                    commit.hexsha[:8],
-                    commit_message.replace("\n", " ")[:20],
+                commit_level_bump = (
+                    LevelBump.NO_RELEASE
+                    if isinstance(parsed_result, ParseError)
+                    else parsed_result.bump
                 )
-                continue
 
-            if the_version is None:
+                # Skip excluded commits except for any commit causing a version bump
+                # Reasoning: if a commit causes a version bump, and no other commits
+                # are included, then the changelog will be empty. Even if ther was other
+                # commits included, the true reason for a version bump would be missing.
+                if has_exclusion_match and commit_level_bump == LevelBump.NO_RELEASE:
+                    log.info(
+                        "Excluding %s commit[%s] %s",
+                        "piece of squashed" if is_squash_commit else "",
+                        parsed_result.short_hash,
+                        commit_message.split("\n", maxsplit=1)[0][:20],
+                    )
+                    continue
+
+                if (
+                    isinstance(parsed_result, ParsedCommit)
+                    and not parsed_result.include_in_changelog
+                ):
+                    log.info(
+                        str.join(
+                            " ",
+                            [
+                                "Excluding commit[%s] because parser determined",
+                                "it should not included in the changelog",
+                            ],
+                        ),
+                        parsed_result.short_hash,
+                    )
+                    continue
+
+                if the_version is None:
+                    log.info(
+                        "[Unreleased] adding commit[%s] to unreleased '%s'",
+                        parsed_result.short_hash,
+                        commit_type,
+                    )
+                    unreleased[commit_type].append(parsed_result)
+                    continue
+
                 log.info(
-                    "[Unreleased] adding '%s' commit(%s) to list",
-                    commit.hexsha[:8],
+                    "[%s] adding commit[%s] to release '%s'",
+                    the_version,
+                    parsed_result.short_hash,
                     commit_type,
                 )
-                unreleased[commit_type].append(parse_result)
-                continue
-
-            log.info(
-                "[%s] adding '%s' commit(%s) to release",
-                the_version,
-                commit_type,
-                commit.hexsha[:8],
-            )
 
-            released[the_version]["elements"][commit_type].append(parse_result)
+                released[the_version]["elements"][commit_type].append(parsed_result)
 
         return cls(unreleased=unreleased, released=released)
 

semantic_release/changelog/template.py

@@ -54,7 +54,6 @@ def environment(
         autoescape_value = dynamic_import(autoescape)
     else:
         autoescape_value = autoescape
-    log.debug("%s", locals())
 
     return ComplexDirectorySandboxedEnvironment(
         block_start_string=block_start_string,

semantic_release/cli/changelog_writer.py

@@ -24,6 +24,7 @@ from semantic_release.cli.const import (
 )
 from semantic_release.cli.util import noop_report
 from semantic_release.errors import InternalError
+from semantic_release.helpers import sort_numerically
 
 if TYPE_CHECKING:  # pragma: no cover
     from jinja2 import Environment
@@ -254,7 +255,11 @@ def generate_release_notes(
         version=release["version"],
         release=release,
         mask_initial_release=mask_initial_release,
-        filters=(*hvcs_client.get_changelog_context_filters(), autofit_text_width),
+        filters=(
+            *hvcs_client.get_changelog_context_filters(),
+            autofit_text_width,
+            sort_numerically,
+        ),
     ).bind_to_environment(
         # Use a new, non-configurable environment for release notes -
         # not user-configurable at the moment

semantic_release/cli/commands/version.py

@@ -65,7 +65,7 @@ def is_forced_prerelease(
     log.debug(
         "%s: %s",
         is_forced_prerelease.__name__,
-        ", ".join(f"{k} = {v}" for k, v in local_vars),
+        str.join(", ", iter(f"{k} = {v}" for k, v in local_vars)),
     )
     return (
         as_prerelease

semantic_release/cli/config.py

@@ -602,7 +602,12 @@ class RuntimeContext:
         # Retrieve details from repository
         with Repo(str(raw.repo_dir)) as git_repo:
             try:
-                remote_url = raw.remote.url or git_repo.remote(raw.remote.name).url
+                # Get the remote url by calling out to `git remote get-url`. This returns
+                # the expanded url, taking into account any insteadOf directives
+                # in the git configuration.
+                remote_url = raw.remote.url or git_repo.git.remote(
+                    "get-url", raw.remote.name
+                )
                 active_branch = git_repo.active_branch.name
             except ValueError as err:
                 raise MissingGitRemote(

semantic_release/cli/masking_filter.py

@@ -27,7 +27,7 @@ class MaskingFilter(logging.Filter):
 
     def add_mask_for(self, data: str, name: str = "redacted") -> MaskingFilter:
         if data and data not in self._UNWANTED:
-            log.debug("Adding redact pattern %r to _redact_patterns", name)
+            log.debug("Adding redact pattern '%r' to redact_patterns", name)
             self._redact_patterns[name].add(data)
         return self
 

semantic_release/commit_parser/_base.py

@@ -81,4 +81,4 @@ class CommitParser(ABC, Generic[_TT, _OPTS]):
         return self.parser_options()  # type: ignore[return-value]
 
     @abstractmethod
-    def parse(self, commit: Commit) -> _TT: ...
+    def parse(self, commit: Commit) -> _TT | list[_TT]: ...

semantic_release/commit_parser/angular.py

@@ -10,8 +10,10 @@ import re
 from functools import reduce
 from itertools import zip_longest
 from re import compile as regexp
+from textwrap import dedent
 from typing import TYPE_CHECKING, Tuple
 
+from git.objects.commit import Commit
 from pydantic.dataclasses import dataclass
 
 from semantic_release.commit_parser._base import CommitParser, ParserOptions
@@ -23,11 +25,13 @@ from semantic_release.commit_parser.token import (
 )
 from semantic_release.commit_parser.util import (
     breaking_re,
+    deep_copy_commit,
+    force_str,
     parse_paragraphs,
-    sort_numerically,
 )
 from semantic_release.enums import LevelBump
 from semantic_release.errors import InvalidParserOptions
+from semantic_release.helpers import sort_numerically, text_reducer
 
 if TYPE_CHECKING:  # pragma: no cover
     from git.objects.commit import Commit
@@ -93,6 +97,10 @@ class AngularParserOptions(ParserOptions):
     default_bump_level: LevelBump = LevelBump.NO_RELEASE
     """The minimum bump level to apply to valid commit message."""
 
+    # TODO: breaking change v10, change default to True
+    parse_squash_commits: bool = False
+    """Toggle flag for whether or not to parse squash commits"""
+
     @property
     def tag_to_level(self) -> dict[str, LevelBump]:
         """A mapping of commit tags to the level bump they should result in."""
@@ -142,14 +150,23 @@ class AngularCommitParser(CommitParser[ParseResult, AngularParserOptions]):
                 )
             ) from err
 
-        self.re_parser = regexp(
+        self.commit_prefix = regexp(
             str.join(
                 "",
                 [
-                    r"^" + commit_type_pattern.pattern,
+                    f"^{commit_type_pattern.pattern}",
                     r"(?:\((?P<scope>[^\n]+)\))?",
                     # TODO: remove ! support as it is not part of the angular commit spec (its part of conventional commits spec)
                     r"(?P<break>!)?:\s+",
+                ],
+            )
+        )
+
+        self.re_parser = regexp(
+            str.join(
+                "",
+                [
+                    self.commit_prefix.pattern,
                     r"(?P<subject>[^\n]+)",
                     r"(?:\n\n(?P<text>.+))?",  # commit body
                 ],
@@ -171,6 +188,42 @@ class AngularCommitParser(CommitParser[ParseResult, AngularParserOptions]):
             ),
             flags=re.MULTILINE | re.IGNORECASE,
         )
+        self.filters = {
+            "typo-extra-spaces": (regexp(r"(\S)  +(\S)"), r"\1 \2"),
+            "git-header-commit": (
+                regexp(r"^[\t ]*commit [0-9a-f]+$\n?", flags=re.MULTILINE),
+                "",
+            ),
+            "git-header-author": (
+                regexp(r"^[\t ]*Author: .+$\n?", flags=re.MULTILINE),
+                "",
+            ),
+            "git-header-date": (
+                regexp(r"^[\t ]*Date: .+$\n?", flags=re.MULTILINE),
+                "",
+            ),
+            "git-squash-heading": (
+                regexp(
+                    r"^[\t ]*Squashed commit of the following:.*$\n?",
+                    flags=re.MULTILINE,
+                ),
+                "",
+            ),
+            "git-squash-commit-prefix": (
+                regexp(
+                    str.join(
+                        "",
+                        [
+                            r"^(?:[\t ]*[*-][\t ]+|[\t ]+)?",  # bullet points or indentation
+                            commit_type_pattern.pattern + r"\b",  # prior to commit type
+                        ],
+                    ),
+                    flags=re.MULTILINE,
+                ),
+                # move commit type to the start of the line
+                r"\1",
+            ),
+        }
 
     @staticmethod
     def get_default_options() -> AngularParserOptions:
@@ -216,7 +269,7 @@ class AngularCommitParser(CommitParser[ParseResult, AngularParserOptions]):
             return None
 
         parsed_break = parsed.group("break")
-        parsed_scope = parsed.group("scope")
+        parsed_scope = parsed.group("scope") or ""
         parsed_subject = parsed.group("subject")
         parsed_text = parsed.group("text")
         parsed_type = parsed.group("type")
@@ -262,24 +315,170 @@ class AngularCommitParser(CommitParser[ParseResult, AngularParserOptions]):
             linked_merge_request=linked_merge_request,
         )
 
+    def parse_commit(self, commit: Commit) -> ParseResult:
+        if not (parsed_msg_result := self.parse_message(force_str(commit.message))):
+            return _logged_parse_error(
+                commit,
+                f"Unable to parse commit message: {commit.message!r}",
+            )
+
+        return ParsedCommit.from_parsed_message_result(commit, parsed_msg_result)
+
     # Maybe this can be cached as an optimization, similar to how
     # mypy/pytest use their own caching directories, for very large commit
     # histories?
     # The problem is the cache likely won't be present in CI environments
-    def parse(self, commit: Commit) -> ParseResult:
+    def parse(self, commit: Commit) -> ParseResult | list[ParseResult]:
         """
-        Attempt to parse the commit message with a regular expression into a
-        ParseResult
+        Parse a commit message
+
+        If the commit message is a squashed merge commit, it will be split into
+        multiple commits, each of which will be parsed separately. Single commits
+        will be returned as a list of a single ParseResult.
         """
-        if not (pmsg_result := self.parse_message(str(commit.message))):
-            return _logged_parse_error(
-                commit, f"Unable to parse commit message: {commit.message!r}"
+        separate_commits: list[Commit] = (
+            self.unsquash_commit(commit)
+            if self.options.parse_squash_commits
+            else [commit]
+        )
+
+        # Parse each commit individually if there were more than one
+        parsed_commits: list[ParseResult] = list(
+            map(self.parse_commit, separate_commits)
+        )
+
+        def add_linked_merge_request(
+            parsed_result: ParseResult, mr_number: str
+        ) -> ParseResult:
+            return (
+                parsed_result
+                if not isinstance(parsed_result, ParsedCommit)
+                else ParsedCommit(
+                    **{
+                        **parsed_result._asdict(),
+                        "linked_merge_request": mr_number,
+                    }
+                )
+            )
+
+        # TODO: improve this for other VCS systems other than GitHub & BitBucket
+        # Github works as the first commit in a squash merge commit has the PR number
+        # appended to the first line of the commit message
+        lead_commit = next(iter(parsed_commits))
+
+        if isinstance(lead_commit, ParsedCommit) and lead_commit.linked_merge_request:
+            # If the first commit has linked merge requests, assume all commits
+            # are part of the same PR and add the linked merge requests to all
+            # parsed commits
+            parsed_commits = [
+                lead_commit,
+                *map(
+                    lambda parsed_result, mr=lead_commit.linked_merge_request: (  # type: ignore[misc]
+                        add_linked_merge_request(parsed_result, mr)
+                    ),
+                    parsed_commits[1:],
+                ),
+            ]
+
+        elif isinstance(lead_commit, ParseError) and (
+            mr_match := self.mr_selector.search(force_str(lead_commit.message))
+        ):
+            # Handle BitBucket Squash Merge Commits (see #1085), which have non angular commit
+            # format but include the PR number in the commit subject that we want to extract
+            linked_merge_request = mr_match.group("mr_number")
+
+            # apply the linked MR to all commits
+            parsed_commits = [
+                add_linked_merge_request(parsed_result, linked_merge_request)
+                for parsed_result in parsed_commits
+            ]
+
+        return parsed_commits
+
+    def unsquash_commit(self, commit: Commit) -> list[Commit]:
+        # GitHub EXAMPLE:
+        # feat(changelog): add autofit_text_width filter to template environment (#1062)
+        #
+        # This change adds an equivalent style formatter that can apply a text alignment
+        # to a maximum width and also maintain an indent over paragraphs of text
+        #
+        # * docs(changelog-templates): add definition & usage of autofit_text_width template filter
+        #
+        # * test(changelog-context): add test cases to check autofit_text_width filter use
+        #
+        # `git merge --squash` EXAMPLE:
+        # Squashed commit of the following:
+        #
+        # commit 63ec09b9e844e616dcaa7bae35a0b66671b59fbb
+        # Author: codejedi365 <codejedi365@gmail.com>
+        # Date:   Sun Oct 13 12:05:23 2024 -0600
+        #
+        #     feat(release-config): some commit subject
+        #
+
+        # Return a list of artificial commits (each with a single commit message)
+        return [
+            # create a artificial commit object (copy of original but with modified message)
+            Commit(
+                **{
+                    **deep_copy_commit(commit),
+                    "message": commit_msg,
+                }
             )
+            for commit_msg in self.unsquash_commit_message(force_str(commit.message))
+        ] or [commit]
 
-        logger.debug(
-            "commit %s introduces a %s level_bump",
-            commit.hexsha[:8],
-            pmsg_result.bump,
+    def unsquash_commit_message(self, message: str) -> list[str]:
+        normalized_message = message.replace("\r", "").strip()
+
+        # split by obvious separate commits (applies to manual git squash merges)
+        obvious_squashed_commits = self.filters["git-header-commit"][0].split(
+            normalized_message
+        )
+
+        separate_commit_msgs: list[str] = reduce(
+            lambda all_msgs, msgs: all_msgs + msgs,
+            map(self._find_squashed_commits_in_str, obvious_squashed_commits),
+            [],
         )
 
-        return ParsedCommit.from_parsed_message_result(commit, pmsg_result)
+        return separate_commit_msgs
+
+    def _find_squashed_commits_in_str(self, message: str) -> list[str]:
+        separate_commit_msgs: list[str] = []
+        current_msg = ""
+
+        for paragraph in filter(None, message.strip().split("\n\n")):
+            # Apply filters to normalize the paragraph
+            clean_paragraph = reduce(text_reducer, self.filters.values(), paragraph)
+
+            # remove any filtered (and now empty) paragraphs (ie. the git headers)
+            if not clean_paragraph.strip():
+                continue
+
+            # Check if the paragraph is the start of a new angular commit
+            if not self.commit_prefix.search(clean_paragraph):
+                if not separate_commit_msgs and not current_msg:
+                    # if there are no separate commit messages and no current message
+                    # then this is the first commit message
+                    current_msg = dedent(clean_paragraph)
+                    continue
+
+                # append the paragraph as part of the previous commit message
+                if current_msg:
+                    current_msg += f"\n\n{dedent(clean_paragraph)}"
+                # else: drop the paragraph
+                continue
+
+            # Since we found the start of the new commit, store any previous commit
+            # message separately and start the new commit message
+            if current_msg:
+                separate_commit_msgs.append(current_msg)
+
+            current_msg = clean_paragraph
+
+        # Store the last commit message (if its not empty)
+        if current_msg:
+            separate_commit_msgs.append(current_msg)
+
+        return separate_commit_msgs

semantic_release/commit_parser/emoji.py

@@ -7,6 +7,7 @@ import re
 from functools import reduce
 from itertools import zip_longest
 from re import compile as regexp
+from textwrap import dedent
 from typing import Tuple
 
 from git.objects.commit import Commit
@@ -18,9 +19,14 @@ from semantic_release.commit_parser.token import (
     ParsedMessageResult,
     ParseResult,
 )
-from semantic_release.commit_parser.util import parse_paragraphs, sort_numerically
+from semantic_release.commit_parser.util import (
+    deep_copy_commit,
+    force_str,
+    parse_paragraphs,
+)
 from semantic_release.enums import LevelBump
 from semantic_release.errors import InvalidParserOptions
+from semantic_release.helpers import sort_numerically, text_reducer
 
 logger = logging.getLogger(__name__)
 
@@ -60,7 +66,7 @@ class EmojiParserOptions(ParserOptions):
     )
     """Commit-type prefixes that should result in a patch release bump."""
 
-    other_allowed_tags: Tuple[str, ...] = ()
+    other_allowed_tags: Tuple[str, ...] = (":memo:", ":checkmark:")
     """Commit-type prefixes that are allowed but do not result in a version bump."""
 
     allowed_tags: Tuple[str, ...] = (
@@ -74,11 +80,6 @@ class EmojiParserOptions(ParserOptions):
     default_bump_level: LevelBump = LevelBump.NO_RELEASE
     """The minimum bump level to apply to valid commit message."""
 
-    @property
-    def tag_to_level(self) -> dict[str, LevelBump]:
-        """A mapping of commit tags to the level bump they should result in."""
-        return self._tag_to_level
-
     parse_linked_issues: bool = False
     """
     Whether to parse linked issues from the commit message.
@@ -92,6 +93,15 @@ class EmojiParserOptions(ParserOptions):
     a whitespace separator.
     """
 
+    # TODO: breaking change v10, change default to True
+    parse_squash_commits: bool = False
+    """Toggle flag for whether or not to parse squash commits"""
+
+    @property
+    def tag_to_level(self) -> dict[str, LevelBump]:
+        """A mapping of commit tags to the level bump they should result in."""
+        return self._tag_to_level
+
     def __post_init__(self) -> None:
         self._tag_to_level: dict[str, LevelBump] = {
             str(tag): level
@@ -132,7 +142,7 @@ class EmojiCommitParser(CommitParser[ParseResult, EmojiParserOptions]):
         emojis_in_precedence_order = list(self.options.tag_to_level.keys())[::-1]
 
         try:
-            self.emoji_selector = regexp(
+            highest_emoji_pattern = regexp(
                 r"(?P<type>%s)" % str.join("|", emojis_in_precedence_order)
             )
         except re.error as err:
@@ -147,6 +157,16 @@ class EmojiCommitParser(CommitParser[ParseResult, EmojiParserOptions]):
                 )
             ) from err
 
+        self.emoji_selector = regexp(
+            str.join(
+                "",
+                [
+                    f"^{highest_emoji_pattern.pattern}",
+                    r"(?:\((?P<scope>[^)]+)\))?:?",
+                ],
+            )
+        )
+
         # GitHub & Gitea use (#123), GitLab uses (!123), and BitBucket uses (pull request #123)
         self.mr_selector = regexp(
             r"[\t ]+\((?:pull request )?(?P<mr_number>[#!]\d+)\)[\t ]*$"
@@ -163,6 +183,44 @@ class EmojiCommitParser(CommitParser[ParseResult, EmojiParserOptions]):
             flags=re.MULTILINE | re.IGNORECASE,
         )
 
+        self.filters = {
+            "typo-extra-spaces": (regexp(r"(\S)  +(\S)"), r"\1 \2"),
+            "git-header-commit": (
+                regexp(r"^[\t ]*commit [0-9a-f]+$\n?", flags=re.MULTILINE),
+                "",
+            ),
+            "git-header-author": (
+                regexp(r"^[\t ]*Author: .+$\n?", flags=re.MULTILINE),
+                "",
+            ),
+            "git-header-date": (
+                regexp(r"^[\t ]*Date: .+$\n?", flags=re.MULTILINE),
+                "",
+            ),
+            "git-squash-heading": (
+                regexp(
+                    r"^[\t ]*Squashed commit of the following:.*$\n?",
+                    flags=re.MULTILINE,
+                ),
+                "",
+            ),
+            "git-squash-commit-prefix": (
+                regexp(
+                    str.join(
+                        "",
+                        [
+                            r"^(?:[\t ]*[*-][\t ]+|[\t ]+)?",  # bullet points or indentation
+                            highest_emoji_pattern.pattern
+                            + r"(\W)",  # prior to commit type
+                        ],
+                    ),
+                    flags=re.MULTILINE,
+                ),
+                # move commit type to the start of the line
+                r"\1\2",
+            ),
+        }
+
     @staticmethod
     def get_default_options() -> EmojiParserOptions:
         return EmojiParserOptions()
@@ -209,11 +267,9 @@ class EmojiCommitParser(CommitParser[ParseResult, EmojiParserOptions]):
             # subject = self.mr_selector.sub("", subject).strip()
 
         # Search for emoji of the highest importance in the subject
-        primary_emoji = (
-            match.group("type")
-            if (match := self.emoji_selector.search(subject))
-            else "Other"
-        )
+        match = self.emoji_selector.search(subject)
+        primary_emoji = match.group("type") if match else "Other"
+        parsed_scope = (match.group("scope") if match else None) or ""
 
         level_bump = self.options.tag_to_level.get(
             primary_emoji, self.options.default_bump_level
@@ -235,7 +291,7 @@ class EmojiCommitParser(CommitParser[ParseResult, EmojiParserOptions]):
             bump=level_bump,
             type=primary_emoji,
             category=primary_emoji,
-            scope="",  # TODO: add scope support
+            scope=parsed_scope,
             # TODO: breaking change v10, removes breaking change footers from descriptions
             # descriptions=(
             #     descriptions[:1] if level_bump is LevelBump.MAJOR else descriptions
@@ -248,17 +304,149 @@ class EmojiCommitParser(CommitParser[ParseResult, EmojiParserOptions]):
             linked_merge_request=linked_merge_request,
         )
 
-    def parse(self, commit: Commit) -> ParseResult:
+    def parse_commit(self, commit: Commit) -> ParseResult:
+        return ParsedCommit.from_parsed_message_result(
+            commit, self.parse_message(force_str(commit.message))
+        )
+
+    def parse(self, commit: Commit) -> ParseResult | list[ParseResult]:
         """
-        Attempt to parse the commit message with a regular expression into a
-        ParseResult
+        Parse a commit message
+
+        If the commit message is a squashed merge commit, it will be split into
+        multiple commits, each of which will be parsed separately. Single commits
+        will be returned as a list of a single ParseResult.
         """
-        pmsg_result = self.parse_message(str(commit.message))
+        separate_commits: list[Commit] = (
+            self.unsquash_commit(commit)
+            if self.options.parse_squash_commits
+            else [commit]
+        )
+
+        # Parse each commit individually if there were more than one
+        parsed_commits: list[ParseResult] = list(
+            map(self.parse_commit, separate_commits)
+        )
+
+        def add_linked_merge_request(
+            parsed_result: ParseResult, mr_number: str
+        ) -> ParseResult:
+            return (
+                parsed_result
+                if not isinstance(parsed_result, ParsedCommit)
+                else ParsedCommit(
+                    **{
+                        **parsed_result._asdict(),
+                        "linked_merge_request": mr_number,
+                    }
+                )
+            )
+
+        # TODO: improve this for other VCS systems other than GitHub & BitBucket
+        # Github works as the first commit in a squash merge commit has the PR number
+        # appended to the first line of the commit message
+        lead_commit = next(iter(parsed_commits))
+
+        if isinstance(lead_commit, ParsedCommit) and lead_commit.linked_merge_request:
+            # If the first commit has linked merge requests, assume all commits
+            # are part of the same PR and add the linked merge requests to all
+            # parsed commits
+            parsed_commits = [
+                lead_commit,
+                *map(
+                    lambda parsed_result, mr=lead_commit.linked_merge_request: (  # type: ignore[misc]
+                        add_linked_merge_request(parsed_result, mr)
+                    ),
+                    parsed_commits[1:],
+                ),
+            ]
 
-        logger.debug(
-            "commit %s introduces a %s level_bump",
-            commit.hexsha[:8],
-            pmsg_result.bump,
+        return parsed_commits
+
+    def unsquash_commit(self, commit: Commit) -> list[Commit]:
+        # GitHub EXAMPLE:
+        # ✨(changelog): add autofit_text_width filter to template environment (#1062)
+        #
+        # This change adds an equivalent style formatter that can apply a text alignment
+        # to a maximum width and also maintain an indent over paragraphs of text
+        #
+        # * 🌐 Support Japanese language
+        #
+        # * ✅(changelog-context): add test cases to check autofit_text_width filter use
+        #
+        # `git merge --squash` EXAMPLE:
+        # Squashed commit of the following:
+        #
+        # commit 63ec09b9e844e616dcaa7bae35a0b66671b59fbb
+        # Author: codejedi365 <codejedi365@gmail.com>
+        # Date:   Sun Oct 13 12:05:23 2024 -0000
+        #
+        #     ⚡️ (homepage): Lazyload home screen images
+        #
+        #
+        # Return a list of artificial commits (each with a single commit message)
+        return [
+            # create a artificial commit object (copy of original but with modified message)
+            Commit(
+                **{
+                    **deep_copy_commit(commit),
+                    "message": commit_msg,
+                }
+            )
+            for commit_msg in self.unsquash_commit_message(force_str(commit.message))
+        ] or [commit]
+
+    def unsquash_commit_message(self, message: str) -> list[str]:
+        normalized_message = message.replace("\r", "").strip()
+
+        # split by obvious separate commits (applies to manual git squash merges)
+        obvious_squashed_commits = self.filters["git-header-commit"][0].split(
+            normalized_message
         )
 
-        return ParsedCommit.from_parsed_message_result(commit, pmsg_result)
+        separate_commit_msgs: list[str] = reduce(
+            lambda all_msgs, msgs: all_msgs + msgs,
+            map(self._find_squashed_commits_in_str, obvious_squashed_commits),
+            [],
+        )
+
+        return separate_commit_msgs
+
+    def _find_squashed_commits_in_str(self, message: str) -> list[str]:
+        separate_commit_msgs: list[str] = []
+        current_msg = ""
+
+        for paragraph in filter(None, message.strip().split("\n\n")):
+            # Apply filters to normalize the paragraph
+            clean_paragraph = reduce(text_reducer, self.filters.values(), paragraph)
+
+            # remove any filtered (and now empty) paragraphs (ie. the git headers)
+            if not clean_paragraph.strip():
+                continue
+
+            # Check if the paragraph is the start of a new angular commit
+            if not self.emoji_selector.search(clean_paragraph):
+                if not separate_commit_msgs and not current_msg:
+                    # if there are no separate commit messages and no current message
+                    # then this is the first commit message
+                    current_msg = dedent(clean_paragraph)
+                    continue
+
+                # append the paragraph as part of the previous commit message
+                if current_msg:
+                    current_msg += f"\n\n{dedent(clean_paragraph)}"
+                # else: drop the paragraph
+                continue
+
+            # Since we found the start of the new commit, store any previous commit
+            # message separately and start the new commit message
+            if current_msg:
+                separate_commit_msgs.append(current_msg)
+
+            current_msg = clean_paragraph
+
+        # Store the last commit message (if its not empty)
+        if current_msg:
+            separate_commit_msgs.append(current_msg)
+
+        return separate_commit_msgs

semantic_release/commit_parser/scipy.py

@@ -74,21 +74,21 @@ def _logged_parse_error(commit: Commit, error: str) -> ParseError:
 
 tag_to_section = {
     "API": "breaking",
-    "BENCH": "None",
+    "BENCH": "none",
     "BLD": "fix",
     "BUG": "fix",
     "DEP": "breaking",
-    "DEV": "None",
+    "DEV": "none",
     "DOC": "documentation",
     "ENH": "feature",
     "MAINT": "fix",
-    "REV": "Other",
-    "STY": "None",
-    "TST": "None",
-    "REL": "None",
+    "REV": "other",
+    "STY": "none",
+    "TST": "none",
+    "REL": "none",
     # strictly speaking not part of the standard
     "FEAT": "feature",
-    "TEST": "None",
+    "TEST": "none",
 }
 
 

semantic_release/commit_parser/tag.py

@@ -1,5 +1,7 @@
 """Legacy commit parser from Python Semantic Release 1.0"""
 
+from __future__ import annotations
+
 import logging
 import re
 
@@ -41,7 +43,7 @@ class TagCommitParser(CommitParser[ParseResult, TagParserOptions]):
     def get_default_options() -> TagParserOptions:
         return TagParserOptions()
 
-    def parse(self, commit: Commit) -> ParseResult:
+    def parse(self, commit: Commit) -> ParseResult | list[ParseResult]:
         message = str(commit.message)
 
         # Attempt to parse the commit message with a regular expression

semantic_release/commit_parser/util.py

@@ -1,20 +1,27 @@
 from __future__ import annotations
 
+from contextlib import suppress
+from copy import deepcopy
 from functools import reduce
 from re import MULTILINE, compile as regexp
 from typing import TYPE_CHECKING
 
+# TODO: remove in v10
+from semantic_release.helpers import (
+    sort_numerically,  # noqa: F401 # TODO: maintained for compatibility
+)
+
 if TYPE_CHECKING:  # pragma: no cover
     from re import Pattern
-    from typing import Sequence, TypedDict
+    from typing import Any, TypedDict
+
+    from git import Commit
 
     class RegexReplaceDef(TypedDict):
         pattern: Pattern
         repl: str
 
 
-number_pattern = regexp(r"(\d+)")
-
 breaking_re = regexp(r"BREAKING[ -]CHANGE:\s?(.*)")
 
 un_word_wrap: RegexReplaceDef = {
@@ -73,5 +80,42 @@ def parse_paragraphs(text: str) -> list[str]:
     )
 
 
-def sort_numerically(iterable: Sequence[str] | set[str]) -> list[str]:
-    return sorted(iterable, key=lambda x: int((number_pattern.search(x) or [-1])[0]))
+def force_str(msg: str | bytes | bytearray | memoryview) -> str:
+    # This shouldn't be a thing but typing is being weird around what
+    # git.commit.message returns and the memoryview type won't go away
+    message = msg.tobytes() if isinstance(msg, memoryview) else msg
+    return (
+        message.decode("utf-8")
+        if isinstance(message, (bytes, bytearray))
+        else str(message)
+    )
+
+
+def deep_copy_commit(commit: Commit) -> dict[str, Any]:
+    keys = [
+        "repo",
+        "binsha",
+        "author",
+        "authored_date",
+        "committer",
+        "committed_date",
+        "message",
+        "tree",
+        "parents",
+        "encoding",
+        "gpgsig",
+        "author_tz_offset",
+        "committer_tz_offset",
+    ]
+    kwargs = {}
+    for key in keys:
+        with suppress(ValueError):
+            if hasattr(commit, key) and (value := getattr(commit, key)) is not None:
+                if key in ["parents", "repo", "tree"]:
+                    # These tend to have circular references so don't deepcopy them
+                    kwargs[key] = value
+                    continue
+
+                kwargs[key] = deepcopy(value)
+
+    return kwargs

semantic_release/helpers.py

@@ -1,16 +1,97 @@
+from __future__ import annotations
+
 import importlib.util
 import logging
 import os
 import re
 import string
 import sys
-from functools import lru_cache, wraps
+from functools import lru_cache, reduce, wraps
 from pathlib import Path, PurePosixPath
-from typing import Any, Callable, NamedTuple, TypeVar
+from re import IGNORECASE, compile as regexp
+from typing import TYPE_CHECKING, Any, Callable, NamedTuple, TypeVar
 from urllib.parse import urlsplit
 
+if TYPE_CHECKING:  # pragma: no cover
+    from re import Pattern
+    from typing import Iterable
+
+
 log = logging.getLogger(__name__)
 
+number_pattern = regexp(r"(?P<prefix>\S*?)(?P<number>\d[\d,]*)\b")
+hex_number_pattern = regexp(
+    r"(?P<prefix>\S*?)(?:0x)?(?P<number>[0-9a-f]+)\b", IGNORECASE
+)
+
+
+def get_number_from_str(
+    string: str, default: int = -1, interpret_hex: bool = False
+) -> int:
+    if interpret_hex and (match := hex_number_pattern.search(string)):
+        return abs(int(match.group("number"), 16))
+
+    if match := number_pattern.search(string):
+        return int(match.group("number"))
+
+    return default
+
+
+def sort_numerically(
+    iterable: Iterable[str], reverse: bool = False, allow_hex: bool = False
+) -> list[str]:
+    # Alphabetically sort prefixes first, then sort by number
+    alphabetized_list = sorted(iterable)
+
+    # Extract prefixes in order to group items by prefix
+    unmatched_items = []
+    prefixes: dict[str, list[str]] = {}
+    for item in alphabetized_list:
+        if not (
+            pattern_match := (
+                (hex_number_pattern.search(item) if allow_hex else None)
+                or number_pattern.search(item)
+            )
+        ):
+            unmatched_items.append(item)
+            continue
+
+        prefix = prefix if (prefix := pattern_match.group("prefix")) else ""
+
+        if prefix not in prefixes:
+            prefixes[prefix] = []
+
+        prefixes[prefix].append(item)
+
+    # Sort prefixes and items by number mixing in unmatched items as alphabetized with other prefixes
+    return reduce(
+        lambda acc, next_item: acc + next_item,
+        [
+            (
+                sorted(
+                    prefixes[prefix],
+                    key=lambda x: get_number_from_str(
+                        x, default=-1, interpret_hex=allow_hex
+                    ),
+                    reverse=reverse,
+                )
+                if prefix in prefixes
+                else [prefix]
+            )
+            for prefix in sorted([*prefixes.keys(), *unmatched_items])
+        ],
+        [],
+    )
+
+
+def text_reducer(text: str, filter_pair: tuple[Pattern[str], str]) -> str:
+    """Reduce function to apply mulitple filters to a string"""
+    if not text:  # abort if the paragraph is empty
+        return text
+
+    filter_pattern, replacement = filter_pair
+    return filter_pattern.sub(replacement, text)
+
 
 def format_arg(value: Any) -> str:
     """Helper to format an argument an argument for logging"""
@@ -69,7 +150,6 @@ def dynamic_import(import_path: str) -> Any:
     Dynamically import an object from a conventionally formatted "module:attribute"
     string
     """
-    log.debug("Trying to import %s", import_path)
     module_name, attr = import_path.split(":", maxsplit=1)
 
     # Check if the module is a file path, if it can be resolved and exists on disk then import as a file
@@ -78,10 +158,11 @@ def dynamic_import(import_path: str) -> Any:
         module_path = (
             module_filepath.stem
             if Path(module_name).is_absolute()
-            else str(Path(module_name).with_suffix("")).replace(os.sep, ".")
+            else str(Path(module_name).with_suffix("")).replace(os.sep, ".").lstrip(".")
         )
 
         if module_path not in sys.modules:
+            log.debug("Loading '%s' from file '%s'", module_path, module_filepath)
             spec = importlib.util.spec_from_file_location(
                 module_path, str(module_filepath)
             )
@@ -96,7 +177,9 @@ def dynamic_import(import_path: str) -> Any:
 
     # Otherwise, import as a module
     try:
+        log.debug("Importing module '%s'", module_name)
         module = importlib.import_module(module_name)
+        log.debug("Loading '%s' from module '%s'", attr, module_name)
         return getattr(module, attr)
     except TypeError as err:
         raise ImportError(

semantic_release/hvcs/_base.py

@@ -30,7 +30,7 @@ class HvcsBase(metaclass=ABCMeta):
     """
 
     def __init__(self, remote_url: str, *args: Any, **kwargs: Any) -> None:
-        self._remote_url = remote_url
+        self._remote_url = remote_url if parse_git_url(remote_url) else ""
         self._name: str | None = None
         self._owner: str | None = None
 

semantic_release/version/algorithm.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 from contextlib import suppress
+from functools import reduce
 from queue import LifoQueue
 from typing import TYPE_CHECKING, Iterable
 
@@ -89,7 +90,6 @@ def _traverse_graph_for_commits(
             # Add all parent commits to the stack from left to right so that the rightmost is popped first
             # as the left side is generally the merged into branch
             for parent in node.parents:
-                logger.debug("queuing parent commit %s", parent.hexsha[:7])
                 stack.put(parent)
 
         return commits
@@ -347,11 +347,25 @@ def next_version(
     )
 
     # Step 5. Parse the commits to determine the bump level that should be applied
-    parsed_levels: set[LevelBump] = {
+    parsed_levels: set[LevelBump] = {  # type: ignore[var-annotated]  # too complex for type checkers
         parsed_result.bump  # type: ignore[union-attr] # too complex for type checkers
         for parsed_result in filter(
-            lambda parsed_result: isinstance(parsed_result, ParsedCommit),
-            map(commit_parser.parse, commits_since_last_release),
+            # Filter out any non-ParsedCommit results (i.e. ParseErrors)
+            lambda parsed_result: isinstance(parsed_result, ParsedCommit),  # type: ignore[arg-type]
+            reduce(
+                # Accumulate all parsed results into a single list
+                lambda accumulated_results, parsed_results: [
+                    *accumulated_results,
+                    *(
+                        parsed_results
+                        if isinstance(parsed_results, Iterable)
+                        else [parsed_results]  # type: ignore[list-item]
+                    ),
+                ],
+                # apply the parser to each commit in the history (could return multiple results per commit)
+                map(commit_parser.parse, commits_since_last_release),
+                [],
+            ),
         )
     }