compose2pod 0.1.7__tar.gz → 0.2.0__tar.gz

{compose2pod-0.1.7 → compose2pod-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compose2pod
-Version: 0.1.7
+Version: 0.2.0
 Summary: Convert a Docker Compose file into a script that runs its services as a single Podman pod
 Keywords: podman,docker-compose,compose,pod,ci,testing,containers
 Author: Artur Shiriev
@@ -24,7 +24,13 @@ Project-URL: Changelog, https://github.com/modern-python/compose2pod/releases
 Provides-Extra: yaml
 Description-Content-Type: text/markdown
 
-# compose2pod
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)"  srcset="https://raw.githubusercontent.com/modern-python/.github/main/brand/projects/compose2pod/lockup-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/modern-python/.github/main/brand/projects/compose2pod/lockup-light.svg">
+    <img alt="compose2pod" src="https://raw.githubusercontent.com/modern-python/.github/main/brand/projects/compose2pod/lockup.png" width="420">
+  </picture>
+</p>
 
 [![PyPI version](https://img.shields.io/pypi/v/compose2pod.svg)](https://pypi.org/project/compose2pod/)
 [![Supported Python versions](https://img.shields.io/pypi/pyversions/compose2pod.svg)](https://pypi.org/project/compose2pod/)
@@ -72,8 +78,9 @@ it: `image`/`build`, `command`, `environment`/`env_file`, short-form bind
 `volumes`, `healthcheck` (CMD/CMD-SHELL), `depends_on` (all conditions), and
 network `aliases`. Compose extension fields (any `x-`-prefixed key) and YAML
 anchors are accepted as-is, so a top-level `x-*` anchor block for shared
-config just works. `${VAR}`-style variable interpolation is resolved against
-the process environment (no `.env` file support). See
+config just works. `${VAR}`-style variable interpolation is left live in the
+generated script, resolved by its shell against the environment present
+when the script runs (no `.env` file support). See
 `architecture/supported-subset.md` for the full accept/ignore/reject matrix.
 
 ## Status

{compose2pod-0.1.7 → compose2pod-0.2.0}/README.md

@@ -1,4 +1,10 @@
-# compose2pod
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)"  srcset="https://raw.githubusercontent.com/modern-python/.github/main/brand/projects/compose2pod/lockup-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/modern-python/.github/main/brand/projects/compose2pod/lockup-light.svg">
+    <img alt="compose2pod" src="https://raw.githubusercontent.com/modern-python/.github/main/brand/projects/compose2pod/lockup.png" width="420">
+  </picture>
+</p>
 
 [![PyPI version](https://img.shields.io/pypi/v/compose2pod.svg)](https://pypi.org/project/compose2pod/)
 [![Supported Python versions](https://img.shields.io/pypi/pyversions/compose2pod.svg)](https://pypi.org/project/compose2pod/)
@@ -46,8 +52,9 @@ it: `image`/`build`, `command`, `environment`/`env_file`, short-form bind
 `volumes`, `healthcheck` (CMD/CMD-SHELL), `depends_on` (all conditions), and
 network `aliases`. Compose extension fields (any `x-`-prefixed key) and YAML
 anchors are accepted as-is, so a top-level `x-*` anchor block for shared
-config just works. `${VAR}`-style variable interpolation is resolved against
-the process environment (no `.env` file support). See
+config just works. `${VAR}`-style variable interpolation is left live in the
+generated script, resolved by its shell against the environment present
+when the script runs (no `.env` file support). See
 `architecture/supported-subset.md` for the full accept/ignore/reject matrix.
 
 ## Status

{compose2pod-0.1.7 → compose2pod-0.2.0}/compose2pod/__init__.py

@@ -2,14 +2,16 @@
 
 from compose2pod.emit import EmitOptions, emit_script
 from compose2pod.exceptions import UnsupportedComposeError
-from compose2pod.interpolate import interpolate
+from compose2pod.extends import resolve_extends
 from compose2pod.parsing import validate
+from compose2pod.shell import to_shell
 
 
 __all__ = [
     "EmitOptions",
     "UnsupportedComposeError",
     "emit_script",
-    "interpolate",
+    "resolve_extends",
+    "to_shell",
     "validate",
 ]

{compose2pod-0.1.7 → compose2pod-0.2.0}/compose2pod/cli.py

@@ -3,16 +3,14 @@
 import argparse
 import contextlib
 import json
-import os
-import re
 import sys
 from pathlib import Path
 from types import ModuleType
 from typing import Any
 
-from compose2pod.emit import EmitOptions, emit_script
+from compose2pod.emit import POD_NAME_PATTERN, EmitOptions, emit_script, referenced_variables
 from compose2pod.exceptions import UnsupportedComposeError
-from compose2pod.interpolate import interpolate
+from compose2pod.extends import resolve_extends
 from compose2pod.parsing import validate
 
 
@@ -21,9 +19,6 @@ with contextlib.suppress(ImportError):  # the optional [yaml] extra is not insta
     import yaml as _yaml
 
 
-POD_NAME_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.-]*$")
-
-
 def _load_yaml(text: str) -> Any:  # noqa: ANN401 - returns arbitrary parsed compose data
     if _yaml is None:
         msg = "YAML input requires the 'yaml' extra: pip install compose2pod[yaml] (or pipe JSON via yq)"
@@ -73,7 +68,7 @@ def main(argv: list[str] | None = None) -> int:
         help="target exit code treated as success in addition to 0",
     )
     args = parser.parse_args(argv)
-    if not POD_NAME_PATTERN.match(args.pod_name):
+    if not POD_NAME_PATTERN.fullmatch(args.pod_name):
         sys.stderr.write(f"compose2pod: error: invalid pod name {args.pod_name!r}\n")
         return 2
     if args.file:
@@ -89,24 +84,25 @@ def main(argv: list[str] | None = None) -> int:
     except (json.JSONDecodeError, UnsupportedComposeError) as error:
         sys.stderr.write(f"compose2pod: error: could not parse compose input: {error}\n")
         return 2
+    options = EmitOptions(
+        target=args.target,
+        ci_image=args.image,
+        command=args.command,
+        pod=args.pod_name,
+        project_dir=args.project_dir,
+        artifacts=args.artifact,
+        allow_exit_codes=args.allow_exit_code,
+    )
     try:
-        compose, interpolation_warnings = interpolate(compose, os.environ)
-        warnings = [*interpolation_warnings, *validate(compose)]
-        script = emit_script(
-            compose=compose,
-            options=EmitOptions(
-                target=args.target,
-                ci_image=args.image,
-                command=args.command,
-                pod=args.pod_name,
-                project_dir=args.project_dir,
-                artifacts=args.artifact,
-                allow_exit_codes=args.allow_exit_code,
-            ),
-        )
+        compose = resolve_extends(compose)
+        warnings = validate(compose)
+        script = emit_script(compose=compose, options=options)
     except UnsupportedComposeError as error:
         sys.stderr.write(f"compose2pod: error: {error}\n")
         return 2
+    referenced = referenced_variables(compose, options)
+    if referenced:
+        sys.stderr.write("compose2pod: note: script references variables at run time: " + ", ".join(referenced) + "\n")
     for warning in warnings:
         sys.stderr.write(f"compose2pod: {warning}\n")
     sys.stdout.write(script)

compose2pod-0.2.0/compose2pod/emit.py

@@ -0,0 +1,274 @@
+"""Render the podman-pod test script for a target service and its dependencies."""
+
+import dataclasses
+import re
+import shlex
+from pathlib import Path
+from typing import Any
+
+from compose2pod import stores
+from compose2pod.exceptions import UnsupportedComposeError
+from compose2pod.graph import depends_on, hostnames, startup_order
+from compose2pod.healthcheck import health_cmd, interval_seconds
+from compose2pod.keys import SERVICE_KEYS, Token, _Expand, _key_value_pairs
+from compose2pod.pod import pod_create_flags
+from compose2pod.resources import deploy_resource_flags
+from compose2pod.shell import to_shell, variable_names
+
+
+HEALTHY_WAIT_BUDGET_SECONDS = 120
+POD_NAME_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.-]*$")
+
+
+def image_for(svc: dict[str, Any], ci_image: str) -> Token:
+    """Services with a build section run the freshly built CI image."""
+    if "build" in svc:
+        return ci_image
+    return _Expand(value=svc["image"])
+
+
+def command_tokens(svc: dict[str, Any]) -> list[Token]:
+    """Service command as argv tokens; compose string form means shell form."""
+    command = svc.get("command")
+    if command is None:
+        return []
+    if isinstance(command, str):
+        return ["/bin/sh", "-c", _Expand(value=command)]
+    return [_Expand(value=str(token)) for token in command]
+
+
+def entrypoint_tokens(svc: dict[str, Any]) -> list[Token]:
+    """Service entrypoint as argv tokens; compose string form means shell form."""
+    entrypoint = svc.get("entrypoint")
+    if entrypoint is None:
+        return []
+    if isinstance(entrypoint, str):
+        return ["/bin/sh", "-c", _Expand(value=entrypoint)]
+    return [_Expand(value=str(token)) for token in entrypoint]
+
+
+def _add_health_flags(flags: list[Token], healthcheck: dict[str, Any]) -> None:
+    """Add healthcheck flags to the flags list."""
+    cmd = health_cmd(healthcheck.get("test"))
+    if cmd is not None:
+        flags += ["--health-cmd", _Expand(value=cmd)]
+        if "timeout" in healthcheck:
+            flags += ["--health-timeout", str(healthcheck["timeout"])]
+        if "start_period" in healthcheck:
+            flags += ["--health-start-period", str(healthcheck["start_period"])]
+        if "retries" in healthcheck:
+            flags += ["--health-retries", str(healthcheck["retries"])]
+
+
+def _add_env_flags(flags: list[Token], svc: dict[str, Any], project_dir: str) -> None:
+    """Add -e and --env-file flags to the flags list."""
+    # A null environment value means "pass KEY through from the host" (bare `-e KEY`).
+    for pair in _key_value_pairs(svc.get("environment") or {}):
+        flags += ["-e", _Expand(value=str(pair))]
+    env_files = svc.get("env_file") or []
+    if isinstance(env_files, str):
+        env_files = [env_files]
+    for env_file in env_files:
+        flags += ["--env-file", _Expand(value=str(Path(project_dir, env_file)))]
+
+
+def _add_volume_flags(flags: list[Token], svc: dict[str, Any], project_dir: str) -> None:
+    """Add -v and --tmpfs flags to the flags list."""
+    for volume in svc.get("volumes") or []:
+        if ":" not in volume:
+            # Anonymous volume: a bare container path, no host source to translate.
+            flags += ["-v", _Expand(value=volume)]
+            continue
+        source, destination = volume.split(":", 1)
+        if source.startswith("."):
+            # Relative bind mount: resolve against project_dir.
+            source = str(Path(project_dir, source))
+        # Absolute bind mount (starts with "/") and named volume (bare
+        # identifier) are both kept as-is — neither is a path to translate.
+        flags += ["-v", _Expand(value=f"{source}:{destination}")]
+    tmpfs = svc.get("tmpfs") or []
+    if isinstance(tmpfs, str):
+        tmpfs = [tmpfs]
+    for mount in tmpfs:
+        flags += ["--tmpfs", _Expand(value=mount)]
+
+
+def run_flags(name: str, svc: dict[str, Any], pod: str, project_dir: str) -> list[Token]:
+    """Flag tokens (unquoted) for `podman run` of one service."""
+    flags: list[Token] = ["--pod", pod, "--name", f"{pod}-{name}"]
+    _add_env_flags(flags, svc, project_dir)
+    _add_volume_flags(flags, svc, project_dir)
+    _add_health_flags(flags, svc.get("healthcheck") or {})
+    for key, spec in SERVICE_KEYS.items():
+        if key in svc:
+            flags += spec.emit(svc[key])
+    flags += stores.flags(svc, pod)
+    flags += deploy_resource_flags(svc)
+    return flags
+
+
+_SCRIPT_HEADER = """\
+#!/bin/sh
+# Generated by compose2pod -- do not edit, regenerate instead.
+set -eu
+
+wait_healthy() {
+  ctr=$1
+  attempts=$2
+  interval=$3
+  i=0
+  while [ "$i" -lt "$attempts" ]; do
+    if podman healthcheck run "$ctr"; then
+      return 0
+    fi
+    i=$((i + 1))
+    sleep "$interval"
+  done
+  echo "wait_healthy: $ctr did not become healthy after $attempts attempts" >&2
+  podman logs "$ctr" >&2 || true
+  return 1
+}
+"""
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class EmitOptions:
+    """Options for emit_script rendering."""
+
+    target: str
+    ci_image: str
+    command: str
+    pod: str
+    project_dir: str
+    artifacts: list[str]
+    allow_exit_codes: list[int]
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class PlannedScript:
+    """The rendered pod script and the run-time variables it expands.
+
+    Both are products of a single `_plan` traversal, so they cannot drift.
+    """
+
+    script: str
+    variables: list[str]
+
+
+def _render(tokens: list[Token]) -> str:
+    return " ".join(to_shell(token.value) if isinstance(token, _Expand) else shlex.quote(token) for token in tokens)
+
+
+def _collect_vars(tokens: list[Token], names: set[str]) -> None:
+    """Add the run-time variables any `_Expand` tokens expand to `names`."""
+    for token in tokens:
+        if isinstance(token, _Expand):
+            names.update(variable_names(token.value))
+
+
+def _run_tokens(name: str, services: dict[str, Any], options: EmitOptions) -> list[Token]:
+    svc = services[name]
+    tokens = run_flags(name, svc, options.pod, options.project_dir)
+    entrypoint = entrypoint_tokens(svc)
+    if entrypoint:
+        tokens += ["--entrypoint", entrypoint[0]]
+    tokens.append(image_for(svc, options.ci_image))
+    tokens += entrypoint[1:]
+    if name == options.target and options.command:
+        tokens.extend(shlex.split(options.command))
+    elif not isinstance(svc.get("entrypoint"), str):
+        # A string (shell-form) entrypoint runs via `sh -c`; the service command
+        # is ignored, matching Docker. List/exec form appends the command.
+        tokens.extend(command_tokens(svc))
+    return tokens
+
+
+def _emit_target(lines: list[str], run_tokens: list[Token], options: EmitOptions) -> None:
+    target_ctr = shlex.quote(f"{options.pod}-{options.target}")
+    lines.append("rc=0")
+    lines.append(f"podman run {_render(run_tokens)} || rc=$?")
+    for artifact in options.artifacts:
+        source, destination = artifact.split(":", 1)
+        lines.append(f"podman cp {target_ctr}:{shlex.quote(source)} {shlex.quote(destination)} || true")
+    allowed = "|".join(str(code) for code in [0, *options.allow_exit_codes])
+    lines.append('case "$rc" in')
+    lines.append(f"  {allowed}) ;;")
+    lines.append('  *) echo "target service failed with exit code $rc" >&2')
+    lines.append(
+        "     podman inspect --format "
+        "'OOMKilled={{.State.OOMKilled}} ExitCode={{.State.ExitCode}}' " + target_ctr + " >&2 || true"
+    )
+    lines.append("     podman ps -a --format '{{.Names}} {{.Status}}' >&2 || true")
+    lines.append('     exit "$rc" ;;')
+    lines.append("esac")
+
+
+def _plan(compose: dict[str, Any], options: EmitOptions) -> PlannedScript:
+    """Walk the target's dependency closure once, building the script and its variables.
+
+    Every token source is visited a single time and feeds both outputs: each
+    service's `_run_tokens` and the `pod_create_flags` render into lines *and*
+    have their `_Expand` variables collected, so the script and the variable
+    list cannot disagree about what the script expands at run time.
+    """
+    services = compose["services"]
+    hosts = hostnames(services)
+    order = startup_order(services, options.target)
+    completion_gated = {
+        dep
+        for svc in services.values()
+        for dep, condition in depends_on(svc).items()
+        if condition == "service_completed_successfully"
+    }
+    names: set[str] = set()
+
+    lines = [_SCRIPT_HEADER]
+    teardown = f"podman pod rm -f {shlex.quote(options.pod)} >/dev/null 2>&1 || true"
+    store_teardown = stores.teardown_line(compose, order, options.pod)
+    if store_teardown:
+        teardown += f"; {store_teardown}"
+    lines.append(f"trap '{teardown}' EXIT")
+    pod_flags = pod_create_flags(services, order, hosts)
+    _collect_vars(pod_flags, names)
+    pod_create = f"podman pod create --name {shlex.quote(options.pod)}"
+    if pod_flags:
+        pod_create += " " + _render(pod_flags)
+    lines.append(pod_create)
+    lines.extend(stores.create_lines(compose, order, options.pod, options.project_dir))
+    names |= stores.referenced_variables(compose, order, options.project_dir)
+    waited: set[str] = set()
+    for name in order:
+        for dep, condition in depends_on(services[name]).items():
+            if condition == "service_healthy" and dep not in waited:
+                interval = interval_seconds((services[dep].get("healthcheck") or {}).get("interval"))
+                attempts = max(HEALTHY_WAIT_BUDGET_SECONDS // interval, 1)
+                lines.append(f"wait_healthy {shlex.quote(f'{options.pod}-{dep}')} {attempts} {interval}")
+                waited.add(dep)
+        run_tokens = _run_tokens(name, services, options)
+        _collect_vars(run_tokens, names)
+        if name == options.target:
+            _emit_target(lines, run_tokens, options)
+        elif name in completion_gated:
+            lines.append(f"podman run --rm {_render(run_tokens)}")
+        else:
+            lines.append(f"podman run -d {_render(run_tokens)}")
+    return PlannedScript(script="\n".join(lines) + "\n", variables=sorted(names))
+
+
+def emit_script(compose: dict[str, Any], options: EmitOptions) -> str:
+    """Render the full pod test script for `target` and its dependency closure."""
+    if not POD_NAME_PATTERN.fullmatch(options.pod):
+        msg = f"invalid pod name {options.pod!r}"
+        raise UnsupportedComposeError(msg)
+    return _plan(compose, options).script
+
+
+def referenced_variables(compose: dict[str, Any], options: EmitOptions) -> list[str]:
+    """Variable names the emitted script expands at run time (sorted, unique).
+
+    Projects the same `_plan` traversal `emit_script` renders from, so it counts
+    exactly the values that pass through `to_shell` -- never a `${VAR}` in a
+    field emitted literally, and never the `--command` override (a literal CLI
+    value).
+    """
+    return _plan(compose, options).variables

compose2pod-0.2.0/compose2pod/extends.py

@@ -0,0 +1,127 @@
+"""Resolve same-file compose `extends`: flatten each service's inheritance."""
+
+from typing import Any
+
+from compose2pod.exceptions import UnsupportedComposeError
+
+
+_MERGE_KEYS = {"environment", "labels", "annotations", "extra_hosts", "ulimits", "healthcheck", "depends_on"}
+_CONCAT_KEYS = {
+    "cap_add",
+    "cap_drop",
+    "security_opt",
+    "devices",
+    "group_add",
+    "secrets",
+    "configs",
+    "volumes",
+    "tmpfs",
+    "env_file",
+}
+
+
+def _extends_target(name: str, ext: Any) -> str:  # noqa: ANN401 - Compose values are untyped
+    """Return the referenced service name, after refusing cross-file and malformed forms."""
+    if not isinstance(ext, dict):
+        msg = f"service {name!r}: 'extends' must be a mapping with a 'service' key"
+        raise UnsupportedComposeError(msg)
+    if "file" in ext:
+        msg = f"service {name!r}: extends with 'file:' (cross-file) is not supported"
+        raise UnsupportedComposeError(msg)
+    unknown = set(ext) - {"service"}
+    if unknown:
+        msg = f"service {name!r}: unsupported 'extends' keys {sorted(unknown)}"
+        raise UnsupportedComposeError(msg)
+    service = ext.get("service")
+    if not isinstance(service, str):
+        msg = f"service {name!r}: extends 'service' must be a string"
+        raise UnsupportedComposeError(msg)
+    return service
+
+
+def _env_list_to_map(items: list[Any]) -> dict[str, Any]:
+    """Normalize a `[KEY=value, BARE]` environment list to a mapping (bare -> None)."""
+    result: dict[str, Any] = {}
+    for item in items:
+        key, sep, value = str(item).partition("=")
+        result[key] = value if sep else None
+    return result
+
+
+def _as_mapping(key: str, name: str, value: Any) -> dict[str, Any]:  # noqa: ANN401 - Compose values are untyped
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, list):
+        if key == "environment":
+            return _env_list_to_map(value)
+        if key == "depends_on":
+            return {dep: {} for dep in value}
+    msg = f"service {name!r}: cannot merge {key!r} across incompatible forms"
+    raise UnsupportedComposeError(msg)
+
+
+def _as_list(key: str, name: str, value: Any) -> list[Any]:  # noqa: ANN401 - Compose values are untyped
+    if isinstance(value, list):
+        return list(value)
+    if isinstance(value, str):
+        return [value]
+    msg = f"service {name!r}: cannot merge {key!r} across incompatible forms"
+    raise UnsupportedComposeError(msg)
+
+
+def _merge(base: dict[str, Any], local: dict[str, Any], name: str) -> dict[str, Any]:
+    """Merge `local` onto `base` per key category: mapping-merge, sequence-concat, else override."""
+    merged: dict[str, Any] = dict(base)
+    for key, local_val in local.items():
+        if key in base and key in _MERGE_KEYS:
+            merged[key] = {**_as_mapping(key, name, base[key]), **_as_mapping(key, name, local_val)}
+        elif key in base and key in _CONCAT_KEYS:
+            merged[key] = _as_list(key, name, base[key]) + _as_list(key, name, local_val)
+        else:
+            merged[key] = local_val
+    return merged
+
+
+def resolve_extends(compose: Any) -> Any:  # noqa: ANN401 - Compose values are untyped
+    """Return a new document with every service's same-file `extends` flattened.
+
+    Transitive and cycle-checked; cross-file (`file:`) extends is refused. A
+    non-dict document or non-dict `services` is returned unchanged for
+    `validate()` to reject.
+    """
+    if not isinstance(compose, dict):
+        return compose
+    services = compose.get("services")
+    if not isinstance(services, dict):
+        return compose
+    resolved: dict[str, Any] = {}
+    resolving: set[str] = set()
+
+    def resolve(name: str) -> Any:  # noqa: ANN401 - Compose values are untyped
+        if name in resolved:
+            return resolved[name]
+        svc = services[name]
+        ext = svc.get("extends") if isinstance(svc, dict) else None
+        if ext is None:
+            resolved[name] = svc
+            return svc
+        if name in resolving:
+            msg = f"extends cycle involving {name!r}"
+            raise UnsupportedComposeError(msg)
+        resolving.add(name)
+        base_name = _extends_target(name, ext)
+        if base_name not in services:
+            msg = f"service {name!r}: extends unknown service {base_name!r}"
+            raise UnsupportedComposeError(msg)
+        base = resolve(base_name)
+        local = {key: value for key, value in svc.items() if key != "extends"}
+        resolving.discard(name)
+        if not isinstance(base, dict):
+            resolved[name] = local
+            return local
+        merged = _merge(base, local, name)
+        resolved[name] = merged
+        return merged
+
+    new_services = {name: resolve(name) for name in services}
+    return {**compose, "services": new_services}

{compose2pod-0.1.7 → compose2pod-0.2.0}/compose2pod/graph.py

@@ -10,24 +10,44 @@ def depends_on(svc: dict[str, Any]) -> dict[str, str]:
     deps = svc.get("depends_on") or {}
     if isinstance(deps, list):
         return cast(dict[str, str], dict.fromkeys(deps, "service_started"))
-    return {name: spec.get("condition", "service_started") for name, spec in deps.items()}
+    if not isinstance(deps, dict):
+        msg = "'depends_on' must be a list or mapping"
+        raise UnsupportedComposeError(msg)
+    result: dict[str, str] = {}
+    for dep, spec in deps.items():
+        if not isinstance(spec, dict):
+            msg = f"depends_on entry {dep!r} must be a mapping"
+            raise UnsupportedComposeError(msg)
+        result[dep] = spec.get("condition", "service_started")
+    return result
+
+
+def _host_names(name: str, svc: dict[str, Any]) -> list[str]:
+    """Names one service is reachable by: hostname, container_name, and network aliases."""
+    result: list[str] = []
+    for key in ("hostname", "container_name"):
+        value = svc.get(key)
+        if value is not None and not isinstance(value, str):
+            msg = f"service {name!r}: {key} must be a string"
+            raise UnsupportedComposeError(msg)
+        if value:
+            result.append(value)
+    networks = svc.get("networks")
+    if networks is not None and not isinstance(networks, list | dict):
+        msg = f"service {name!r}: networks must be a list or mapping"
+        raise UnsupportedComposeError(msg)
+    if isinstance(networks, dict):
+        for network in networks.values():
+            if isinstance(network, dict):
+                result.extend(network.get("aliases") or [])
+    return result
 
 
 def hostnames(services: dict[str, Any]) -> list[str]:
     """All names other services may use to reach a service: names, hostnames/container names, then aliases."""
     names = list(services)
-    for svc in services.values():
-        hostname = svc.get("hostname")
-        if hostname:
-            names.append(hostname)
-        container_name = svc.get("container_name")
-        if container_name:
-            names.append(container_name)
-        networks = svc.get("networks")
-        if isinstance(networks, dict):
-            for network in networks.values():
-                if isinstance(network, dict):
-                    names.extend(network.get("aliases") or [])
+    for name, svc in services.items():
+        names.extend(_host_names(name, svc))
     return names
 
 

{compose2pod-0.1.7 → compose2pod-0.2.0}/compose2pod/healthcheck.py

@@ -1,6 +1,7 @@
 """Healthcheck translation: compose healthcheck -> podman --health-* values."""
 
 import json
+import math
 from typing import Any
 
 from compose2pod.exceptions import UnsupportedComposeError
@@ -43,12 +44,16 @@ def interval_seconds(duration: object) -> int:
     """Compose duration ('1s', '2m', '500ms', int) to whole seconds, minimum 1."""
     if duration is None:
         return 1
-    if isinstance(duration, (int, float)):
+    if isinstance(duration, (int, float)) and math.isfinite(duration):
         return max(int(duration), 1)
+    # Non-finite floats (inf/nan) fall through to the guarded parse below and are refused.
     text = str(duration).strip()
-    if text.endswith("ms"):
-        return max(int(float(text[:-2]) / 1000), 1)
-    if text.endswith("m"):
-        return max(int(float(text[:-1])) * 60, 1)
-    text = text.removesuffix("s")
-    return max(int(float(text)), 1)
+    try:
+        if text.endswith("ms"):
+            return max(int(float(text[:-2]) / 1000), 1)
+        if text.endswith("m"):
+            return max(int(float(text[:-1])) * 60, 1)
+        return max(int(float(text.removesuffix("s"))), 1)
+    except (ValueError, OverflowError):
+        msg = f"unsupported healthcheck interval {duration!r} (use forms like '30s', '2m', '500ms')"
+        raise UnsupportedComposeError(msg) from None