common-python-tasks 0.3.1__py3-none-any.whl → 0.4.1__py3-none-any.whl

common_python_tasks/data/fastapi/compose-base.yml.j2

@@ -9,7 +9,8 @@ x-common-environment: &common-environment
 x-common-build-args: &common-build-args
   PACKAGE_NAME: ${PACKAGE_NAME}
   PYTHON_VERSION: ${PYTHON_VERSION}
-  POETRY_VERSION: ${POETRY_VERSION}
+  PACKAGE_MANAGER: ${PACKAGE_MANAGER}
+  PACKAGE_MANAGER_VERSION: ${PACKAGE_MANAGER_VERSION}
 
 services:
   api:

common_python_tasks/data/fastapi/compose-db.yml.j2

@@ -8,7 +8,8 @@ x-common-environment: &common-environment
 x-common-build-args: &common-build-args
   PACKAGE_NAME: ${PACKAGE_NAME}
   PYTHON_VERSION: ${PYTHON_VERSION}
-  POETRY_VERSION: ${POETRY_VERSION}
+  PACKAGE_MANAGER: ${PACKAGE_MANAGER}
+  PACKAGE_MANAGER_VERSION: ${PACKAGE_MANAGER_VERSION}
   WORKDIR_PATH: ${WORKDIR_PATH}
 
 services:

common_python_tasks/data/generic/.dockerignore

@@ -6,5 +6,3 @@
 !LICENSE
 
 !src
-
-!.git

common_python_tasks/data/generic/Dockerfile.j2

@@ -7,20 +7,48 @@ ARG PYTHON_VERSION=3
 # See https://hub.docker.com/_/python for available variants
 ARG PYTHON_VARIANT=slim
 ARG WORKDIR_PATH=/workspace
+{% set package_manager = PACKAGE_MANAGER|default('poetry') %}
 
 FROM python:${PYTHON_VERSION} AS builder
 
+ARG PACKAGE_VERSION
+
+{% if package_manager == 'poetry' %}
 ARG POETRY_VERSION
 ARG POETRY_DYNAMIC_VERSIONING_PLUGIN_VERSION
 ARG POETRY_PLUGIN_EXPORT_VERSION
-ARG TOMLKIT_VERSION
 
-# Install Poetry and required Poetry plugins for build
-RUN --mount=type=cache,target=/root/.cache/pip,id=pip-cache{{ CACHE_ID_SUFFIX }} pip install --root-user-action=ignore \
-    "poetry==$POETRY_VERSION" \
-    "poetry-dynamic-versioning[plugin]==$POETRY_DYNAMIC_VERSIONING_PLUGIN_VERSION" \
-    "poetry-plugin-export==$POETRY_PLUGIN_EXPORT_VERSION" \
-    "tomlkit==$TOMLKIT_VERSION"
+# Bypass VCS-based version detection: use the host-computed version directly.
+# This avoids requiring a .git directory in the build context and prevents
+# false dirty-version detection from a partial working tree.
+ENV POETRY_DYNAMIC_VERSIONING_BYPASS=${PACKAGE_VERSION}
+
+# Install Poetry and required Poetry plugins for package build
+RUN --mount=type=cache,target=/root/.cache/pip,id=pip-cache{{ CACHE_ID_SUFFIX }} \
+    sh -c 'set -eu; \
+    poetry_spec="poetry"; \
+    if [ -n "${POETRY_VERSION:-}" ]; then poetry_spec="poetry==$POETRY_VERSION"; fi; \
+    dynamic_spec="poetry-dynamic-versioning[plugin]"; \
+    if [ -n "${POETRY_DYNAMIC_VERSIONING_PLUGIN_VERSION:-}" ]; then dynamic_spec="poetry-dynamic-versioning[plugin]==$POETRY_DYNAMIC_VERSIONING_PLUGIN_VERSION"; fi; \
+    export_spec="poetry-plugin-export"; \
+    if [ -n "${POETRY_PLUGIN_EXPORT_VERSION:-}" ]; then export_spec="poetry-plugin-export==$POETRY_PLUGIN_EXPORT_VERSION"; fi; \
+    pip install --root-user-action=ignore "$poetry_spec" "$dynamic_spec" "$export_spec"'
+{% else %}
+ARG UV_VERSION
+
+# Bypass VCS-based version detection: use the host-computed version directly.
+# This avoids requiring a .git directory in the build context and prevents
+# false dirty-version detection from a partial working tree.
+ENV UV_DYNAMIC_VERSIONING_BYPASS=${PACKAGE_VERSION}
+
+# Install uv for package build and dependency export steps
+RUN --mount=type=cache,target=/root/.cache/pip,id=pip-cache{{ CACHE_ID_SUFFIX }} \
+    sh -c 'if [ -n "${UV_VERSION:-}" ]; then \
+        pip install --root-user-action=ignore "uv==$UV_VERSION"; \
+    else \
+        pip install --root-user-action=ignore uv; \
+    fi'
+{% endif %}
 
 # Build package
 WORKDIR /tmp/build
@@ -28,15 +56,24 @@ COPY . /tmp/build/
 
 {% if HAS_DEBUG_DEPS %}
 # Export debug requirements when the project defines a debug dependency group
+{% if package_manager == 'poetry' %}
 RUN --mount=type=cache,target=/root/.cache/pip,id=pip-cache{{ CACHE_ID_SUFFIX }} \
     poetry export --only debug --without-hashes -f requirements.txt --output requirements-debug.txt
+{% else %}
+RUN --mount=type=cache,target=/root/.cache/uv,id=uv-cache{{ CACHE_ID_SUFFIX }} \
+    uv export --group debug --no-hashes --format requirements-txt --output-file requirements-debug.txt
+{% endif %}
 {% endif %}
 
-# Build the wheel, caching Poetry's cache directory to speed up subsequent builds.
+# Build the wheel, caching the package-manager cache directory to speed up subsequent builds.
 # If running this in a CI system, you must be using a persistent builder to take
 # advantage of the cache mount, and you should configure your CI to persist the
 # cache directory between builds
+{% if package_manager == 'poetry' %}
 RUN --mount=type=cache,target=/root/.cache/pypoetry,id=pypoetry-cache{{ CACHE_ID_SUFFIX }} poetry build --format=wheel
+{% else %}
+RUN --mount=type=cache,target=/root/.cache/uv,id=uv-cache{{ CACHE_ID_SUFFIX }} uv build --wheel
+{% endif %}
 
 FROM python:${PYTHON_VERSION}-${PYTHON_VARIANT} AS runtime
 ARG WORKDIR_PATH=/workspace

common_python_tasks/docker.py

@@ -93,7 +93,6 @@ def _safe_unlink(path: Path | str | None) -> None:
 
 
 def _build_docker_build_command(
-    *,
     context_path: Path,
     dockerfile_path: Path,
     build_args: dict[str, str],
@@ -152,35 +151,60 @@ def prune_images_keep(
 
     retain_count = int(keep) + 1
 
-    res = utils.run_command(
-        [
-            "docker",
-            "image",
-            "ls",
-            "--format",
-            "{{.Repository}}:{{.Tag}}",
-            "--filter",
-            f"reference={full_name}:*",
-        ],
-        capture_output=True,
-        acceptable_returncodes={0, 1},
+    def _list_images_for_reference(reference: str) -> list[str]:
+        res = utils.run_command(
+            [
+                "docker",
+                "image",
+                "ls",
+                "--format",
+                "{{.Repository}}:{{.Tag}}",
+                "--filter",
+                f"reference={reference}:*",
+            ],
+            capture_output=True,
+            acceptable_returncodes={0, 1},
+        )
+        if res.returncode != 0:
+            LOGGER.warning("Failed to list images for pruning: %s", reference)
+            return []
+
+        return [
+            line.strip()
+            for line in res.stdout.splitlines()
+            if line.strip() and not line.strip().startswith("<none>")
+        ]
+
+    parsed_full_name = utils.parse_image_reference(full_name)
+    short_reference = utils.compose_image_name(package_name, fully_qualified=False)
+    full_reference = utils.compose_image_name(
+        package_name,
+        registry=parsed_full_name["registry"],
+        namespace=parsed_full_name["namespace"],
     )
-    if res.returncode != 0:
-        LOGGER.exception("Failed to list images for pruning: %s", full_name)
-        return
 
-    lines = [
-        line.strip()
-        for line in res.stdout.splitlines()
-        if line.strip() and not line.strip().startswith("<none>")
+    lines = _list_images_for_reference(full_reference)
+    lines += [
+        line
+        for line in _list_images_for_reference(short_reference)
+        if line not in lines
     ]
-    tags_in_order = []
+
+    tags_in_order: list[str] = []
+    seen_tags: set[str] = set()
     for entry in lines:
-        if ":" not in entry:
+        try:
+            parsed_entry = utils.parse_image_reference(entry)
+        except ValueError:
             continue
-        repo, tag = entry.rsplit(":", 1)
-        if entry.startswith(full_name) or repo.endswith(package_name):
-            tags_in_order.append(tag)
+
+        if (
+            parsed_entry["repository"] == package_name
+            and parsed_entry["tag"]
+            and parsed_entry["tag"] not in seen_tags
+        ):
+            tags_in_order.append(parsed_entry["tag"])
+            seen_tags.add(parsed_entry["tag"])
 
     candidates = [t for t in tags_in_order if t not in protect_tags]
     if len(candidates) <= retain_count:
@@ -188,7 +212,18 @@ def prune_images_keep(
 
     to_delete = candidates[retain_count:]
     for tag in to_delete:
-        for img in (f"{package_name}:{tag}", f"{full_name}:{tag}"):
+        short_image = utils.compose_image_name(
+            package_name,
+            tag=tag,
+            fully_qualified=False,
+        )
+        full_image = utils.compose_image_name(
+            package_name,
+            tag=tag,
+            registry=parsed_full_name["registry"],
+            namespace=parsed_full_name["namespace"],
+        )
+        for img in (short_image, full_image):
             try:
                 LOGGER.info("Pruning image %s", img)
                 utils.run_command(["docker", "rmi", img], acceptable_returncodes={0, 1})
@@ -295,12 +330,12 @@ def build_deps_image(
 
     full_tag = f"{deps_image_name}:{deps_tag}"
     build_cmd = _build_docker_build_command(
-        context_path=context_path,
-        dockerfile_path=dockerfile_path,
-        build_args=build_args,
-        archs=archs,
-        no_cache=no_cache,
-        plain=plain,
+        context_path,
+        dockerfile_path,
+        build_args,
+        archs,
+        no_cache,
+        plain,
         tags=[full_tag],
     )
 
@@ -369,6 +404,7 @@ def build_image(
     try:
         archs = _resolve_archs(single_arch)
         files_to_ignore = [Path(".dockerignore")] if temp_dockerignore_created else []
+        package_version = git.get_version(ignore=files_to_ignore)
         version_string = git.get_image_tag(ignore=files_to_ignore)
 
         dockerfile_source = (
@@ -400,26 +436,51 @@ def build_image(
             tag = BuildTag.LATEST if not git.has_tags_later_in_history() else None
 
         version_tag = f"{version_string}{suffix}"
-        commit_tag = f"{utils.run_command(['git', 'rev-parse', '--short', 'HEAD'], capture_output=True).stdout.strip()}{'-dirty' if git.get_dirty_files(ignore=files_to_ignore) else ''}{suffix}"
+        if git.git_available():
+            commit_hash = utils.run_command(
+                ["git", "rev-parse", "--short", "HEAD"],
+                capture_output=True,
+                acceptable_returncodes={0},
+            ).stdout.strip()
+            dirty_suffix = (
+                "-dirty" if git.get_dirty_files(ignore=files_to_ignore) else ""
+            )
+            commit_tag = f"{commit_hash}{dirty_suffix}{suffix}"
+        else:
+            commit_tag = version_tag
+
         python_version = platform.python_version()
-        poetry_version = project.get_poetry_version()
+        package_manager = project.get_package_manager()
+        package_manager_version = project.get_package_manager_version(package_manager)
 
-        build_args = _merge_build_args(
-            {
-                "PYTHON_VERSION": python_version,
-                "POETRY_VERSION": poetry_version,
+        manager_build_args: dict[str, str | None]
+        if package_manager == project.PackageManager.POETRY:
+            manager_build_args = {
+                "POETRY_VERSION": package_manager_version,
                 "POETRY_DYNAMIC_VERSIONING_PLUGIN_VERSION": project.get_installed_requirement_version(
                     "poetry-dynamic-versioning[plugin]"
                 ),
                 "POETRY_PLUGIN_EXPORT_VERSION": project.get_installed_requirement_version(
                     "poetry-plugin-export"
                 ),
-                "TOMLKIT_VERSION": project.get_installed_requirement_version("tomlkit"),
+            }
+        else:
+            manager_build_args = {
+                "UV_VERSION": package_manager_version,
+            }
+
+        build_args = _merge_build_args(
+            {
+                "PYTHON_VERSION": python_version,
+                "PACKAGE_MANAGER": package_manager,
+                "PACKAGE_MANAGER_VERSION": package_manager_version,
+                "PACKAGE_VERSION": package_version,
                 "PACKAGE_NAME": utils.get_package_name(use_underscores=True),
                 "AUTHORS": ",".join(
                     [f"{name} <{email}>" for name, email in project.get_authors()]
                 ),
                 "GIT_COMMIT": commit_tag,
+                **manager_build_args,
             },
             extra_build_args,
         )
@@ -432,26 +493,36 @@ def build_image(
             image_name if image_name is not None else utils.get_package_name()
         )
         orig_full_name = utils.get_full_image_name()
-        if image_name is None:
-            image_full_name = orig_full_name
-        else:
-            if "/" in orig_full_name:
-                prefix = orig_full_name.rsplit("/", 1)[0]
-                image_full_name = f"{prefix}/{image_name}"
-            else:
-                image_full_name = image_name
+
+        parsed_full_name = utils.parse_image_reference(orig_full_name)
+        short_tags = [
+            utils.compose_image_name(image_short_name, tag=t, fully_qualified=False)
+            for t in tags_to_use
+        ]
+        full_tags = [
+            utils.compose_image_name(
+                image_short_name,
+                tag=t,
+                registry=parsed_full_name["registry"],
+                namespace=parsed_full_name["namespace"],
+            )
+            for t in tags_to_use
+        ]
+
+        all_tags: list[str] = []
+        for resolved_tag in [*short_tags, *full_tags]:
+            if resolved_tag not in all_tags:
+                all_tags.append(resolved_tag)
+
         build_cmd = _build_docker_build_command(
-            context_path=context_path,
-            dockerfile_path=dockerfile_path,
-            build_args=build_args,
-            archs=archs,
-            no_cache=no_cache,
-            plain=plain,
+            context_path,
+            dockerfile_path,
+            build_args,
+            archs,
+            no_cache,
+            plain,
             target=None if omit_target else target,
-            tags=[
-                *[f"{image_short_name}:{t}" for t in tags_to_use],
-                *[f"{image_full_name}:{t}" for t in tags_to_use],
-            ],
+            tags=all_tags,
         )
         utils.run_command(build_cmd)
         delete_temp_file = True

common_python_tasks/docker_compose.py

@@ -14,7 +14,7 @@ from poethepoet_tasks import TaskCollection
 
 from . import utils
 from .env import get_workdir_path
-from .project import get_poetry_version
+from .project import get_package_manager, get_package_manager_version
 
 LOGGER = logging.getLogger(__name__)
 
@@ -232,7 +232,8 @@ _COMPOSE_VAR_REQUIREMENTS: dict[str, dict[str, set[str]]] = {
             "ENVIRONMENT",
             "IMAGE_TAG",
             "PYTHON_VERSION",
-            "POETRY_VERSION",
+            "PACKAGE_MANAGER",
+            "PACKAGE_MANAGER_VERSION",
         },
         "compose-db": {
             "PACKAGE_NAME",
@@ -242,7 +243,8 @@ _COMPOSE_VAR_REQUIREMENTS: dict[str, dict[str, set[str]]] = {
             "DB_PORT",
             "IMAGE_TAG",
             "PYTHON_VERSION",
-            "POETRY_VERSION",
+            "PACKAGE_MANAGER",
+            "PACKAGE_MANAGER_VERSION",
             "POSTGRES_VERSION",
             "WORKDIR_PATH",
         },
@@ -328,9 +330,10 @@ def get_compose_env(
         "ENVIRONMENT": os.getenv("ENVIRONMENT", "production"),
         "IMAGE_TAG": image_tag or "latest",
         "PACKAGE_NAME": package_name,
+        "PACKAGE_MANAGER": get_package_manager(),
+        "PACKAGE_MANAGER_VERSION": get_package_manager_version(),
         "PACKAGE_UNDERSCORE_NAME": utils.package_name_to_underscore(package_name),
         "WORKDIR_PATH": get_workdir_path(),
-        "POETRY_VERSION": get_poetry_version(),
         "POSTGRES_VERSION": os.getenv("POSTGRES_VERSION", "17"),
         "PYTHON_VERSION": platform.python_version(),
         "SECRET_KEY": os.getenv("SECRET_KEY", ""),
@@ -375,6 +378,8 @@ def load_compose_files(
         cleaned up **after** `docker compose` down`.
     """
 
+    from .env import split_colon_delimited_values
+
     compose_files_env = os.getenv("COMPOSE_FILE")
     if compose_files_env:
         LOGGER.debug(
@@ -382,14 +387,14 @@ def load_compose_files(
             compose_files_env,
         )
         return (
-            [Path(f.strip()) for f in compose_files_env.split(":") if f.strip()],
+            [Path(path) for path in split_colon_delimited_values(compose_files_env)],
             [],
             [],
         )
 
-    compose_type = os.environ["COMPOSE_TYPE"]
+    compose_type = get_compose_type()
     compose_addons_str = os.getenv("COMPOSE_ADDONS", "")
-    compose_addons = [a.strip() for a in compose_addons_str.split(":") if a.strip()]
+    compose_addons = split_colon_delimited_values(compose_addons_str)
 
     LOGGER.debug(
         "Loading compose files for type '%s' with addons: %s%s",
@@ -459,7 +464,7 @@ def load_compose_files(
 
     overlay_files_str = os.getenv("COMPOSE_OVERLAY_FILES", "")
     if overlay_files_str:
-        overlay_files = [f.strip() for f in overlay_files_str.split(":") if f.strip()]
+        overlay_files = split_colon_delimited_values(overlay_files_str)
         LOGGER.debug("Adding overlay compose files: %s", overlay_files)
         for overlay_file in overlay_files:
             files_and_cleanups.append((Path(overlay_file), False))
@@ -497,6 +502,7 @@ def run_docker_compose_command(
     *args: str | None,
     compose_files: list[Path],
     compose_env: dict[str, str],
+    tasks: TaskCollection,
 ) -> None:
     """Run `docker compose` with standard file and env-file arguments.
 
@@ -512,7 +518,7 @@ def run_docker_compose_command(
 
     utils.run_command(
         [
-            *compose_cmd_prefix(compose_files),
+            *compose_cmd_prefix(compose_files, tasks),
             *[arg for arg in args if arg is not None],
         ],
         env=compose_env,

common_python_tasks/env.py

@@ -1,8 +1,8 @@
 import logging
 import os
 import secrets
+import shlex
 from pathlib import Path
-from shlex import split as shlex_split
 
 from . import utils
 
@@ -14,6 +14,7 @@ TRUTHY_VALUES = {
     "yes",
     "on",
     "enabled",
+    "enable",
     "y",
     "t",
 }
@@ -75,7 +76,7 @@ def parse_container_extensions() -> list[dict]:
     exts: list[dict] = []
     files_raw = os.getenv("CONTAINER_EXTENSION_FILES")
     if files_raw:
-        for part in [p.strip() for p in files_raw.split(":") if p.strip()]:
+        for part in split_colon_delimited_values(files_raw):
             pth = Path(part)
             exts.append(
                 {
@@ -91,7 +92,7 @@ def parse_container_extensions() -> list[dict]:
             )
     bundles_raw = os.getenv("CONTAINER_EXTENSIONS")
     if bundles_raw:
-        for part in (p.strip() for p in bundles_raw.split(":")):
+        for part in split_colon_delimited_values(bundles_raw):
             if not part:
                 continue
             if "=" in part:
@@ -180,24 +181,64 @@ def load_container_env_file(path: str | None = None) -> str | None:
     return container_env if container_env else None
 
 
-def split_colon_delimited_values(value: str) -> list[str]:
-    """Split a colon-delimited string while preserving quoted substrings.
+def split_delimited_values(
+    value: str,
+    separators: str = ":",
+    allow_whitespace: bool = False,
+) -> list[str]:
+    """Split a delimited string while preserving quoted substrings.
 
     Args:
-        value: The colon-delimited string to split.
+        value: The string to split.
+        separators: Explicit separator characters to use.
+        allow_whitespace: Treat whitespace as additional separators.
 
     Returns:
-        A list of strings representing the split values.
+        A list of strings representing the parsed tokens.
     """
     if not value or not value.strip():
         return []
 
-    try:
-        tokens = shlex_split(value.replace(":", " "), comments=True)
-    except ValueError as exc:
-        raise ValueError(f"Unable to parse colon-delimited values: {exc}") from exc
+    lexer = shlex.shlex(value, posix=True)
+    lexer.whitespace = separators + (" \t\r\n" if allow_whitespace else "")
+    lexer.whitespace_split = True
+    lexer.commenters = "#"
+    return [token for token in lexer if token.strip()]
 
-    return [token for token in tokens if token.strip()]
+
+def split_colon_delimited_values(value: str) -> list[str]:
+    """Split a colon- or whitespace-delimited string while preserving quoted substrings."""
+    return split_delimited_values(value, separators=":", allow_whitespace=True)
+
+
+def split_colon_or_whitespace_delimited_values(value: str) -> list[str]:
+    """Split a colon- or whitespace-delimited string while preserving quoted substrings."""
+    return split_colon_delimited_values(value)
+
+
+def parse_container_build_args(
+    cli_build_args: list[str] | None,
+    env_build_args: str | None,
+) -> dict[str, str] | None:
+    """Parse container build args from CLI or environment input."""
+    if cli_build_args is not None:
+        build_arg_tokens = [
+            token.strip() for token in cli_build_args if token and token.strip()
+        ]
+    elif env_build_args:
+        build_arg_tokens = split_colon_delimited_values(env_build_args)
+    else:
+        return None
+
+    parsed_build_args: dict[str, str] = {}
+    for token in build_arg_tokens:
+        if "=" not in token:
+            LOGGER.warning("Ignoring invalid build-arg token: %s", token)
+            continue
+        key, value = token.split("=", 1)
+        parsed_build_args[key.strip()] = value.strip()
+
+    return parsed_build_args or None
 
 
 def parse_container_env_tokens(value: str | list[str] | None) -> list[str]:

common_python_tasks/git.py

@@ -96,7 +96,7 @@ def compute_next_release_version(
     Returns:
         A `NextReleaseVersion` with the serialized new version and normalized component.
     """
-    current_version_text = project.get_project_version_from_poetry()
+    current_version_text = project.get_project_version()
     release_component = (
         infer_bump_component_from_git_cliff() if component is None else component
     )
@@ -181,14 +181,11 @@ def infer_bump_component_from_git_cliff() -> ReleaseComponent:
     except Exception:
         utils.fatal(f"Unable to parse bumped version from git-cliff: {version_text!r}")
 
-    current_version = project.get_project_version_from_poetry()
+    current_version = project.get_project_version()
     try:
         current = Version.parse(current_version)
     except Exception:
-        utils.fatal(
-            "Unable to parse current version from Poetry output: "
-            f"{current_version!r}"
-        )
+        utils.fatal("Unable to parse current project version: " f"{current_version!r}")
 
     def _parse_semver(version_value: str | Any) -> tuple[int, int, int]:
         if not isinstance(version_value, str):
@@ -220,6 +217,20 @@ def infer_bump_component_from_git_cliff() -> ReleaseComponent:
     )
 
 
+def git_available() -> bool:
+    """Return `True` if Git is installed and the current directory is a repository."""
+
+    if shutil.which("git") is None:
+        return False
+
+    result = utils.run_command(
+        ["git", "rev-parse", "--is-inside-work-tree"],
+        capture_output=True,
+        acceptable_returncodes={0, 1, 128},
+    )
+    return result.returncode == 0
+
+
 def get_dirty_files(ignore: list[Path] | None = None) -> list[Path]:
     """Get dirty git files excluding any specified paths.
 
@@ -233,6 +244,9 @@ def get_dirty_files(ignore: list[Path] | None = None) -> list[Path]:
     if ignore is None:
         ignore = []
 
+    if not git_available():
+        return []
+
     ignore_set = {Path(p) for p in ignore}
 
     return [
@@ -260,6 +274,10 @@ def get_version(ignore: list[Path] | None = None) -> str:
     if ignore is None:
         ignore = []
 
+    if not git_available():
+        LOGGER.warning("Git is unavailable. Falling back to placeholder version 0.0.0.")
+        return "0.0.0"
+
     dirty_files = get_dirty_files(ignore=ignore)
     LOGGER.debug("Dirty files: %s", dirty_files)
 
@@ -296,6 +314,9 @@ def has_tags_later_in_history() -> bool:
         `True` if tags are later in history, else `False`.
     """
 
+    if not git_available():
+        return False
+
     result = utils.run_command(
         ["git", "tag"],
         capture_output=True,