compose2pod 0.1.0__tar.gz

compose2pod-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: compose2pod
+Version: 0.1.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
+Author-email: Artur Shiriev <me@shiriev.ru>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Testing
+Requires-Dist: pyyaml>=6 ; extra == 'yaml'
+Requires-Python: >=3.10, <4
+Project-URL: Repository, https://github.com/modern-python/compose2pod
+Project-URL: Issues, https://github.com/modern-python/compose2pod/issues
+Project-URL: Changelog, https://github.com/modern-python/compose2pod/releases
+Provides-Extra: yaml
+Description-Content-Type: text/markdown
+
+# compose2pod
+
+Convert a Docker Compose file into a POSIX `sh` script that runs its services as a **single Podman pod**.
+
+Built for CI and test environments where you can't use `docker compose` or `podman kube play`:
+
+- **No bridge networking / netavark.** Unprivileged CI containers often have a read-only `/proc/sys`, so netavark fails to create bridge networks. A single pod shares one network namespace with no bridge: services talk over `127.0.0.1`, and names resolve via `--add-host`.
+- **No systemd.** Podman healthchecks are normally scheduled by systemd timers. compose2pod gates startup by polling `podman healthcheck run` directly, so `depends_on: service_healthy` works without systemd.
+- **No heavy runtime.** The core is stdlib-only — no dependencies, no compiled wheels — so it installs and runs in minimal Python images.
+
+## Install
+
+```bash
+pip install compose2pod            # core: reads compose as JSON
+pip install compose2pod[yaml]      # optional: read YAML directly (adds PyYAML)
+```
+
+## Usage
+
+```bash
+# YAML directly (needs the [yaml] extra)
+compose2pod docker-compose.yml --target app --image myimage:ci > run.sh
+
+# Or stay dependency-free by piping JSON (e.g. via yq)
+yq -o=json '.' docker-compose.yml | compose2pod --target app --image myimage:ci > run.sh
+
+sh ./run.sh
+```
+
+## Supported compose subset
+
+compose2pod supports an honest subset and errors clearly on anything outside it. See the design spec for the full matrix: `image`/`build`, `command`, `environment`/`env_file`, short-form bind `volumes`, `healthcheck` (CMD/CMD-SHELL), `depends_on` (all conditions), and network `aliases`.
+
+## Status
+
+Beta. Part of the [modern-python](https://github.com/modern-python) family. MIT licensed.

compose2pod-0.1.0/README.md

@@ -0,0 +1,36 @@
+# compose2pod
+
+Convert a Docker Compose file into a POSIX `sh` script that runs its services as a **single Podman pod**.
+
+Built for CI and test environments where you can't use `docker compose` or `podman kube play`:
+
+- **No bridge networking / netavark.** Unprivileged CI containers often have a read-only `/proc/sys`, so netavark fails to create bridge networks. A single pod shares one network namespace with no bridge: services talk over `127.0.0.1`, and names resolve via `--add-host`.
+- **No systemd.** Podman healthchecks are normally scheduled by systemd timers. compose2pod gates startup by polling `podman healthcheck run` directly, so `depends_on: service_healthy` works without systemd.
+- **No heavy runtime.** The core is stdlib-only — no dependencies, no compiled wheels — so it installs and runs in minimal Python images.
+
+## Install
+
+```bash
+pip install compose2pod            # core: reads compose as JSON
+pip install compose2pod[yaml]      # optional: read YAML directly (adds PyYAML)
+```
+
+## Usage
+
+```bash
+# YAML directly (needs the [yaml] extra)
+compose2pod docker-compose.yml --target app --image myimage:ci > run.sh
+
+# Or stay dependency-free by piping JSON (e.g. via yq)
+yq -o=json '.' docker-compose.yml | compose2pod --target app --image myimage:ci > run.sh
+
+sh ./run.sh
+```
+
+## Supported compose subset
+
+compose2pod supports an honest subset and errors clearly on anything outside it. See the design spec for the full matrix: `image`/`build`, `command`, `environment`/`env_file`, short-form bind `volumes`, `healthcheck` (CMD/CMD-SHELL), `depends_on` (all conditions), and network `aliases`.
+
+## Status
+
+Beta. Part of the [modern-python](https://github.com/modern-python) family. MIT licensed.

compose2pod-0.1.0/compose2pod/__init__.py

@@ -0,0 +1,13 @@
+"""compose2pod: convert a Docker Compose file into a single-Podman-pod run script."""
+
+from compose2pod.emit import EmitOptions, emit_script
+from compose2pod.exceptions import UnsupportedComposeError
+from compose2pod.parsing import validate
+
+
+__all__ = [
+    "EmitOptions",
+    "UnsupportedComposeError",
+    "emit_script",
+    "validate",
+]

compose2pod-0.1.0/compose2pod/__main__.py

@@ -0,0 +1,9 @@
+"""python -m compose2pod entry point."""
+
+import sys
+
+from compose2pod.cli import main
+
+
+if __name__ == "__main__":  # pragma: no cover - exercised via subprocess in tests
+    sys.exit(main())

compose2pod-0.1.0/compose2pod/cli.py

@@ -0,0 +1,110 @@
+"""Command-line interface: read a compose document and emit the pod script."""
+
+import argparse
+import contextlib
+import json
+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.exceptions import UnsupportedComposeError
+from compose2pod.parsing import validate
+
+
+_yaml: ModuleType | None = None
+with contextlib.suppress(ImportError):  # the optional [yaml] extra is not installed
+    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)"
+        raise UnsupportedComposeError(msg)
+    try:
+        return _yaml.safe_load(text)
+    except _yaml.YAMLError as error:
+        msg = f"invalid YAML: {error}"
+        raise UnsupportedComposeError(msg) from error
+
+
+def _read_compose(text: str, fmt: str) -> Any:  # noqa: ANN401 - returns arbitrary parsed compose data
+    if fmt == "json":
+        return json.loads(text)
+    if fmt == "yaml":
+        return _load_yaml(text)
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return _load_yaml(text)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="compose2pod",
+        description="Convert a Docker Compose document to a podman-pod run script (stdout).",
+    )
+    parser.add_argument("file", nargs="?", help="compose file to read (default: stdin)")
+    parser.add_argument("--target", required=True, help="service to run in the foreground with --command")
+    parser.add_argument("--image", required=True, help="CI image replacing services that have a build section")
+    parser.add_argument("--project-dir", default=".", help="host path relative volume/env_file sources resolve to")
+    parser.add_argument("--command", default="", help="shell command overriding the target service command")
+    parser.add_argument("--pod-name", default="test-pod")
+    parser.add_argument("--format", choices=("auto", "json", "yaml"), default="auto")
+    parser.add_argument(
+        "--artifact",
+        action="append",
+        default=[],
+        metavar="SRC:DST",
+        help="file to podman-cp out of the target container after it exits",
+    )
+    parser.add_argument(
+        "--allow-exit-code",
+        type=int,
+        action="append",
+        default=[],
+        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):
+        sys.stderr.write(f"compose2pod: error: invalid pod name {args.pod_name!r}\n")
+        return 2
+    if args.file:
+        try:
+            text = Path(args.file).read_text()
+        except OSError as error:
+            sys.stderr.write(f"compose2pod: error: could not read file: {error}\n")
+            return 2
+    else:
+        text = sys.stdin.read()
+    try:
+        compose = _read_compose(text, args.format)
+    except (json.JSONDecodeError, UnsupportedComposeError) as error:
+        sys.stderr.write(f"compose2pod: error: could not parse compose input: {error}\n")
+        return 2
+    try:
+        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,
+            ),
+        )
+    except UnsupportedComposeError as error:
+        sys.stderr.write(f"compose2pod: error: {error}\n")
+        return 2
+    for warning in warnings:
+        sys.stderr.write(f"compose2pod: {warning}\n")
+    sys.stdout.write(script)
+    return 0

compose2pod-0.1.0/compose2pod/emit.py

@@ -0,0 +1,171 @@
+"""Render the podman-pod test script for a target service and its dependencies."""
+
+import dataclasses
+import shlex
+from pathlib import Path
+from typing import Any
+
+from compose2pod.graph import depends_on, hostnames, startup_order
+from compose2pod.healthcheck import health_cmd, interval_seconds
+
+
+HEALTHY_WAIT_BUDGET_SECONDS = 120
+
+
+def image_for(svc: dict[str, Any], ci_image: str) -> str:
+    """Services with a build section run the freshly built CI image."""
+    if "build" in svc:
+        return ci_image
+    return svc["image"]
+
+
+def command_tokens(svc: dict[str, Any]) -> list[str]:
+    """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", command]
+    return list(command)
+
+
+def _add_health_flags(flags: list[str], 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", 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 run_flags(name: str, svc: dict[str, Any], pod: str, hosts: list[str], project_dir: str) -> list[str]:
+    """Flag tokens (unquoted) for `podman run` of one service."""
+    flags = ["--pod", pod, "--name", f"{pod}-{name}"]
+    for host in hosts:
+        flags += ["--add-host", f"{host}:127.0.0.1"]
+    environment = svc.get("environment") or {}
+    pairs = environment if isinstance(environment, list) else [f"{k}={v}" for k, v in environment.items()]
+    for pair in pairs:
+        flags += ["-e", 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", str(Path(project_dir, env_file))]
+    for volume in svc.get("volumes") or []:
+        source, destination = volume.split(":", 1)
+        if not source.startswith("/"):
+            source = str(Path(project_dir, source))
+        flags += ["-v", f"{source}:{destination}"]
+    healthcheck = svc.get("healthcheck") or {}
+    _add_health_flags(flags, healthcheck)
+    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)
+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]
+
+
+def _render(tokens: list[str]) -> str:
+    return " ".join(shlex.quote(token) for token in tokens)
+
+
+def _run_tokens(name: str, services: dict[str, Any], options: EmitOptions, hosts: list[str]) -> list[str]:
+    svc = services[name]
+    tokens = run_flags(name, svc, options.pod, hosts, options.project_dir)
+    tokens.append(image_for(svc, options.ci_image))
+    if name == options.target and options.command:
+        tokens.extend(shlex.split(options.command))
+    else:
+        tokens.extend(command_tokens(svc))
+    return tokens
+
+
+def _emit_target(lines: list[str], run_tokens: list[str], 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 emit_script(compose: dict[str, Any], options: EmitOptions) -> str:
+    """Render the full pod test script for `target` and its dependency closure."""
+    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"
+    }
+
+    lines = [_SCRIPT_HEADER]
+    lines.append(f"trap 'podman pod rm -f {shlex.quote(options.pod)} >/dev/null 2>&1 || true' EXIT")
+    lines.append(f"podman pod create --name {shlex.quote(options.pod)}")
+    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, hosts)
+        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 "\n".join(lines) + "\n"

compose2pod-0.1.0/compose2pod/exceptions.py

@@ -0,0 +1,5 @@
+"""Exceptions for compose2pod."""
+
+
+class UnsupportedComposeError(Exception):
+    """Raised when the compose file uses a construct outside the supported subset."""

compose2pod-0.1.0/compose2pod/graph.py

@@ -0,0 +1,52 @@
+"""Dependency graph: normalize depends_on, collect hostnames, compute startup order."""
+
+from typing import Any, cast
+
+from compose2pod.exceptions import UnsupportedComposeError
+
+
+def depends_on(svc: dict[str, Any]) -> dict[str, str]:
+    """Normalize dependencies of a service to a name -> condition mapping."""
+    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()}
+
+
+def hostnames(services: dict[str, Any]) -> list[str]:
+    """All names other services may use to reach a service: names, then aliases."""
+    names = list(services)
+    for svc in services.values():
+        networks = svc.get("networks")
+        if isinstance(networks, dict):
+            for network in networks.values():
+                if isinstance(network, dict):
+                    names.extend(network.get("aliases") or [])
+    return names
+
+
+def startup_order(services: dict[str, Any], target: str) -> list[str]:
+    """Dependency closure of target in start order (dependencies first, target last)."""
+    if target not in services:
+        msg = f"target service '{target}' not found"
+        raise UnsupportedComposeError(msg)
+    order: list[str] = []
+    state: dict[str, str] = {}
+
+    def visit(name: str) -> None:
+        if state.get(name) == "visiting":
+            msg = f"dependency cycle involving '{name}'"
+            raise UnsupportedComposeError(msg)
+        if state.get(name) == "done":
+            return
+        if name not in services:
+            msg = f"unknown dependency '{name}'"
+            raise UnsupportedComposeError(msg)
+        state[name] = "visiting"
+        for dep in depends_on(services[name]):
+            visit(dep)
+        state[name] = "done"
+        order.append(name)
+
+    visit(target)
+    return order

compose2pod-0.1.0/compose2pod/healthcheck.py

@@ -0,0 +1,54 @@
+"""Healthcheck translation: compose healthcheck -> podman --health-* values."""
+
+import json
+from typing import Any
+
+from compose2pod.exceptions import UnsupportedComposeError
+
+
+_CMD_MIN_LENGTH = 2
+
+
+def has_healthcheck(svc: dict[str, Any]) -> bool:
+    """Report whether the service defines a healthcheck with a non-disabled test."""
+    test = (svc.get("healthcheck") or {}).get("test")
+    return test is not None and test not in ("NONE", ["NONE"])
+
+
+def health_cmd(test: object) -> str | None:
+    """Compose healthcheck `test` value to a podman --health-cmd value."""
+    if test is None or test in ("NONE", ["NONE"]):
+        return None
+    if isinstance(test, str):
+        return test
+    if not isinstance(test, list) or not test:
+        msg = f"unsupported healthcheck test: {test!r}"
+        raise UnsupportedComposeError(msg)
+    kind = test[0]
+    if kind == "CMD-SHELL":
+        if len(test) < _CMD_MIN_LENGTH:
+            msg = f"unsupported healthcheck test: {test!r}"
+            raise UnsupportedComposeError(msg)
+        return test[1]  # ty: ignore
+    if kind == "CMD":
+        if len(test) < _CMD_MIN_LENGTH:
+            msg = f"unsupported healthcheck test: {test!r}"
+            raise UnsupportedComposeError(msg)
+        return json.dumps(test[1:])
+    msg = f"unsupported healthcheck test kind: {kind!r}"
+    raise UnsupportedComposeError(msg)
+
+
+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)):
+        return max(int(duration), 1)
+    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)

compose2pod-0.1.0/compose2pod/parsing.py

@@ -0,0 +1,86 @@
+"""Validate a compose document against the supported subset."""
+
+from typing import Any
+
+from compose2pod.exceptions import UnsupportedComposeError
+from compose2pod.graph import depends_on
+from compose2pod.healthcheck import has_healthcheck
+
+
+SUPPORTED_SERVICE_KEYS = {
+    "image",
+    "build",
+    "command",
+    "environment",
+    "env_file",
+    "volumes",
+    "healthcheck",
+    "depends_on",
+    "networks",
+}
+IGNORED_SERVICE_KEYS = {"ports", "restart", "stdin_open", "tty"}
+SUPPORTED_HEALTHCHECK_KEYS = {"test", "interval", "timeout", "retries", "start_period"}
+SUPPORTED_TOP_LEVEL_KEYS = {"services", "version", "name", "networks"}
+DEPENDS_ON_CONDITIONS = {"service_started", "service_healthy", "service_completed_successfully"}
+
+
+def _validate_service(name: str, svc: dict[str, Any]) -> list[str]:
+    """Validate one service; returns warnings, raises UnsupportedComposeError."""
+    warnings: list[str] = []
+    for key in sorted(svc):
+        if key in IGNORED_SERVICE_KEYS:
+            warnings.append(f"service {name!r}: ignoring '{key}'")
+        elif key not in SUPPORTED_SERVICE_KEYS:
+            msg = f"service {name!r}: unsupported key '{key}'"
+            raise UnsupportedComposeError(msg)
+    for key in sorted(svc.get("healthcheck") or {}):
+        if key not in SUPPORTED_HEALTHCHECK_KEYS:
+            msg = f"service {name!r}: unsupported healthcheck key '{key}'"
+            raise UnsupportedComposeError(msg)
+    for volume in svc.get("volumes") or []:
+        if not isinstance(volume, str):
+            msg = f"service {name!r}: only short volume syntax is supported"
+            raise UnsupportedComposeError(msg)
+        source = volume.split(":", 1)[0]
+        if not source.startswith((".", "/")):
+            msg = f"service {name!r}: named volume '{source}' is not supported (bind mounts only)"
+            raise UnsupportedComposeError(msg)
+    return warnings
+
+
+def _validate_depends_on(services: dict[str, Any]) -> None:
+    """Cross-service depends_on checks: known conditions, service_healthy needs a healthcheck."""
+    for name, svc in services.items():
+        for dep, condition in depends_on(svc).items():
+            if condition not in DEPENDS_ON_CONDITIONS:
+                msg = f"service {name!r}: depends_on {dep!r} has unsupported condition {condition!r}"
+                raise UnsupportedComposeError(msg)
+            if condition == "service_healthy" and dep in services and not has_healthcheck(services[dep]):
+                msg = f"service {name!r}: depends on {dep!r} (service_healthy) but {dep!r} has no healthcheck"
+                raise UnsupportedComposeError(msg)
+
+
+def validate(compose: dict[str, Any]) -> list[str]:
+    """Check the compose document against the supported subset.
+
+    Returns human-readable warnings for ignored constructs.
+    Raises UnsupportedComposeError for anything that would change behavior silently.
+    """
+    if not isinstance(compose, dict):
+        msg = f"compose document must be a mapping, got {type(compose).__name__}"
+        raise UnsupportedComposeError(msg)
+    warnings: list[str] = []
+    unknown_top = set(compose) - SUPPORTED_TOP_LEVEL_KEYS
+    if unknown_top:
+        msg = f"unsupported top-level keys: {sorted(unknown_top)}"
+        raise UnsupportedComposeError(msg)
+    if "networks" in compose:
+        warnings.append("ignoring top-level 'networks' (all services share the pod namespace)")
+    services = compose.get("services") or {}
+    if not services:
+        msg = "no services defined"
+        raise UnsupportedComposeError(msg)
+    for name, svc in services.items():
+        warnings.extend(_validate_service(name, svc))
+    _validate_depends_on(services)
+    return warnings

compose2pod-0.1.0/pyproject.toml

@@ -0,0 +1,86 @@
+[project]
+name = "compose2pod"
+description = "Convert a Docker Compose file into a script that runs its services as a single Podman pod"
+authors = [{ name = "Artur Shiriev", email = "me@shiriev.ru" }]
+requires-python = ">=3.10,<4"
+license = "MIT"
+readme = "README.md"
+keywords = ["podman", "docker-compose", "compose", "pod", "ci", "testing", "containers"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Testing",
+]
+version = "0.1.0"
+
+[project.optional-dependencies]
+yaml = ["PyYAML>=6"]
+
+[project.scripts]
+compose2pod = "compose2pod.cli:main"
+
+[project.urls]
+Repository = "https://github.com/modern-python/compose2pod"
+Issues = "https://github.com/modern-python/compose2pod/issues"
+Changelog = "https://github.com/modern-python/compose2pod/releases"
+
+[build-system]
+requires = ["uv_build>=0.11,<1.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "compose2pod"
+module-root = ""
+
+[dependency-groups]
+dev = [
+    "pytest",
+    "pytest-cov",
+]
+lint = [
+    "ruff",
+    "ty",
+    "eof-fixer",
+    "typing-extensions",
+    "types-PyYAML",
+]
+
+[tool.ruff]
+fix = true
+unsafe-fixes = true
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "D1",     # allow missing docstrings
+    "S101",   # allow asserts
+    "TCH",    # ignore flake8-type-checking
+    "FBT",    # allow boolean args
+    "D203",   # "one-blank-line-before-class" conflicting with D211
+    "D213",   # "multi-line-summary-second-line" conflicting with D212
+    "COM812", # flake8-commas "Trailing comma missing"
+    "ISC001", # flake8-implicit-str-concat
+]
+isort.lines-after-imports = 2
+isort.no-lines-before = ["standard-library", "local-folder"]
+
+[tool.pytest.ini_options]
+addopts = ""
+testpaths = ["tests"]
+pythonpath = ["."]
+
+[tool.coverage]
+report.exclude_also = ["if typing.TYPE_CHECKING:"]
+# The __main__.py shim is a pure `sys.exit(main())` entrypoint exercised only via
+# subprocess (tests/test_cli.py::test_python_m_runs), which the parent coverage process
+# can't measure; omit it rather than enable subprocess/branch coverage machinery.
+run.omit = ["compose2pod/__main__.py"]