csrd-utils 0.3.82__tar.gz → 0.3.85__tar.gz

{csrd_utils-0.3.82 → csrd_utils-0.3.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csrd-utils
-Version: 0.3.82
+Version: 0.3.85
 Summary: CLI utilities for csrd service generation and feature augmentation
 Project-URL: Repository, https://github.com/csrd-api/fastapi-common
 Project-URL: Documentation, https://github.com/csrd-api/fastapi-common/tree/main/packages/utils
@@ -8,7 +8,9 @@ Project-URL: Changelog, https://github.com/csrd-api/fastapi-common/blob/main/CHA
 License: MIT
 Requires-Python: >=3.12
 Requires-Dist: cookiecutter<3,>=2.6
+Requires-Dist: pydantic<3,>=2.6
 Requires-Dist: pyyaml<7,>=6
+Requires-Dist: ruamel-yaml<1,>=0.18
 Description-Content-Type: text/markdown
 
 # csrd-utils

{csrd_utils-0.3.82 → csrd_utils-0.3.85}/pyproject.toml

@@ -1,12 +1,14 @@
 [project]
 name = "csrd-utils"
-version = "0.3.82"
+version = "0.3.85"
 description = "CLI utilities for csrd service generation and feature augmentation"
 license = { text = "MIT" }
 requires-python = ">=3.12"
 dependencies = [
     "cookiecutter>=2.6,<3",
     "PyYAML>=6,<7",
+    "pydantic>=2.6,<3",
+    "ruamel.yaml>=0.18,<1",
 ]
 readme = "README.md"
 

{csrd_utils-0.3.82 → csrd_utils-0.3.85}/src/csrd_utils/__main__.py

@@ -3,6 +3,7 @@
 import argparse
 import json
 import shutil
+import sys
 from contextlib import suppress
 from importlib.metadata import version
 from pathlib import Path
@@ -24,6 +25,9 @@ from .cluster import (
 from .doctor import run_doctor
 from .generator import generate_platform_service, generate_service
 from .resources import features_path
+from .v2.compose import apply as v2_compose_apply
+from .v2.compose import validate as v2_compose_validate
+from .v2.generate import run_generate_menu as run_v2_generate_menu
 
 
 class GenerateServiceArgs(TypedDict):
@@ -57,6 +61,7 @@ class GenerateWorkspaceArgs(TypedDict):
     output_dir: Path
     overwrite_if_exists: bool
     generate: str
+    git_init: bool
 
 
 class ExtractWorkspaceServiceArgs(TypedDict):
@@ -416,12 +421,14 @@ def _collect_new_workspace_config(args: argparse.Namespace) -> GenerateWorkspace
     generate = args.generate or _prompt_choice(
         "Generate in workspace now", ["none", "service", "cluster"], "service"
     )
+    git_init = _prompt_bool("Initialize git repository", True)
     return GenerateWorkspaceArgs(
         {
             "name": name,
             "output_dir": output_dir,
             "overwrite_if_exists": args.force,
             "generate": generate,
+            "git_init": git_init,
         }
     )
 
@@ -438,6 +445,10 @@ def _create_workspace(config: GenerateWorkspaceArgs) -> Path:
         )
 
     _write_workspace_marker(workspace_root)
+
+    if config.get("git_init", False):
+        _git_init(workspace_root)
+
     return workspace_root
 
 
@@ -577,6 +588,20 @@ def _write_workspace_marker(path: Path) -> None:
     (path / WORKSPACE_MARKER).write_text("workspace: csrd\n", encoding="utf-8")
 
 
+def _git_init(path: Path) -> None:
+    """Run ``git init`` inside *path* if not already a git repository."""
+    import subprocess
+
+    if (path / ".git").exists():
+        return
+    subprocess.run(
+        ["git", "init"],
+        cwd=path,
+        check=True,
+        capture_output=True,
+    )
+
+
 def _is_workspace(path: Path) -> bool:
     return (path / WORKSPACE_MARKER).is_file()
 
@@ -1199,6 +1224,76 @@ def _build_parser() -> argparse.ArgumentParser:
     completion_sub = completion.add_subparsers(dest="completion_shell", required=True)
     completion_sub.add_parser("bash", help="Print bash completion script")
 
+    v2 = sub.add_parser("v2", help="Preview next-gen generator and compose workflow")
+    v2_sub = v2.add_subparsers(dest="v2_command")
+
+    v2_generate = v2_sub.add_parser("generate", help="Open interactive v2 generator menu")
+    v2_generate.add_argument(
+        "target",
+        nargs="?",
+        choices=["workspace", "preset", "add-service", "add-infra", "remove-infra", "empty"],
+        help="Direct generator target (workspace, preset, add-service, add-infra, remove-infra)",
+    )
+    v2_generate.add_argument(
+        "--name",
+        dest="generate_name",
+        help="Workspace or service name",
+    )
+    v2_generate.add_argument(
+        "--git-init",
+        action="store_true",
+        default=False,
+        help="Initialize a git repository in the generated workspace",
+    )
+    v2_generate.add_argument(
+        "--features",
+        dest="features",
+        nargs="*",
+        choices=["database", "caching", "messaging"],
+        default=None,
+        help="Service capabilities to wire (for add-service)",
+    )
+    v2_generate.add_argument(
+        "--port",
+        dest="port",
+        type=int,
+        default=None,
+        help="Service port (for add-service)",
+    )
+    v2_generate.add_argument(
+        "--infra-type",
+        dest="infra_type",
+        choices=["postgres", "mariadb", "sqlite", "redis", "rabbitmq"],
+        default=None,
+        help="Infrastructure type (for add-infra)",
+    )
+
+    v2_compose = v2_sub.add_parser("compose", help="Compose v2 operations")
+    v2_compose_sub = v2_compose.add_subparsers(dest="v2_compose_command")
+
+    v2_compose_validate = v2_compose_sub.add_parser("validate", help="Validate csrd-compose.yaml")
+    v2_compose_validate.add_argument(
+        "--output", type=Path, default=Path.cwd(), help="Workspace root"
+    )
+    v2_compose_validate.add_argument(
+        "--json", action="store_true", help="Print validated compose spec as JSON"
+    )
+
+    v2_compose_plan = v2_compose_sub.add_parser("plan", help="Preview resolved compose baseline")
+    v2_compose_plan.add_argument("--output", type=Path, default=Path.cwd(), help="Workspace root")
+    v2_compose_plan.add_argument("--json", action="store_true", help="Print plan payload as JSON")
+
+    v2_compose_apply = v2_compose_sub.add_parser(
+        "apply", help="Render baseline workspace artifacts"
+    )
+    v2_compose_apply.add_argument("--output", type=Path, default=Path.cwd(), help="Workspace root")
+    v2_compose_apply.add_argument(
+        "--git-init",
+        action="store_true",
+        default=False,
+        help="Initialize a git repository in the workspace",
+    )
+
     return parser
 
 
@@ -1323,9 +1418,106 @@ def _run_audit(service: Path | None, as_json: bool) -> int:
 
 
 def main() -> int:
+    # Shorthand: `csrd v2 compose <path>` => `csrd v2 compose apply --output <path>`
+    raw_argv = sys.argv[1:]
+    if len(raw_argv) >= 3 and raw_argv[0] == "v2" and raw_argv[1] == "compose":
+        third = raw_argv[2]
+        if third not in {"validate", "plan", "apply", "-h", "--help"} and not third.startswith("-"):
+            shorthand_dir = Path(third).resolve()
+            has_compose_spec = (shorthand_dir / "csrd-compose.yaml").is_file() or (
+                shorthand_dir / "csrd-compose.yml"
+            ).is_file()
+            if not has_compose_spec:
+                print(f"ERROR: Compose shorthand requires csrd-compose.yaml in: {shorthand_dir}")
+                print(
+                    "Hint: create a spec first (csrd v2 generate empty --name <name>) "
+                    "or use explicit apply: csrd v2 compose apply --output <path>"
+                )
+                return 1
+            sys.argv = [
+                sys.argv[0],
+                "v2",
+                "compose",
+                "apply",
+                "--output",
+                third,
+                *raw_argv[3:],
+            ]
+
     parser = _build_parser()
     args = parser.parse_args()
 
+    if args.command == "v2":
+        if getattr(args, "v2_command", None) == "generate":
+            return run_v2_generate_menu(
+                target=getattr(args, "target", None),
+                name=getattr(args, "generate_name", None),
+                git_init=getattr(args, "git_init", False),
+                features=getattr(args, "features", None),
+                port=getattr(args, "port", None),
+                infra_type=getattr(args, "infra_type", None),
+            )
+
+        if getattr(args, "v2_command", None) != "compose":
+            parser.print_help()
+            return 0
+
+        compose_command = getattr(args, "v2_compose_command", None)
+        if compose_command is None:
+            parser.print_help()
+            return 0
+
+        output_dir = Path(args.output).resolve()
+        try:
+            if compose_command == "apply":
+                generated_root = v2_compose_apply(
+                    output_dir, git_init=getattr(args, "git_init", False)
+                )
+                print(f"Rendered compose workspace at: {generated_root}")
+                return 0
+
+            if compose_command == "validate":
+                spec = v2_compose_validate(output_dir)
+                if args.json:
+                    print(json.dumps(spec.model_dump(mode="python"), indent=2, sort_keys=True))
+                else:
+                    print(f"Compose spec valid: {output_dir / 'csrd-compose.yaml'}")
+                return 0
+
+            if compose_command == "plan":
+                spec = v2_compose_validate(output_dir)
+                payload = {
+                    "workspace": spec.workspace.name,
+                    "version": spec.version,
+                    "services": len(spec.services),
+                    "infra": len(spec.infra),
+                    "presets": [preset.name for preset in spec.presets],
+                    "overrides_keys": sorted(spec.overrides.keys()),
+                }
+                if args.json:
+                    print(json.dumps(payload, indent=2, sort_keys=True))
+                else:
+                    print("Compose v2 plan")
+                    print(f"- workspace: {payload['workspace']}")
+                    print(f"- version: {payload['version']}")
+                    print(f"- services: {payload['services']}")
+                    print(f"- infra: {payload['infra']}")
+                    presets = payload["presets"]
+                    overrides_keys = payload["overrides_keys"]
+                    assert isinstance(presets, list)
+                    assert isinstance(overrides_keys, list)
+                    print(f"- presets: {', '.join(presets) if presets else '<none>'}")
+                    print(
+                        f"- overrides: {', '.join(overrides_keys) if overrides_keys else '<none>'}"
+                    )
+                return 0
+        except ValueError as exc:
+            print(f"ERROR: {exc}")
+            return 1
+
+        parser.print_help()
+        return 0
+
     if args.command == "new" and args.new_command == "service":
         try:
             service_config = _collect_new_service_config(args)

csrd_utils-0.3.85/src/csrd_utils/v2/__init__.py

@@ -0,0 +1 @@
+"""Namespace package for next-gen csrd compose and generate flows."""

csrd_utils-0.3.85/src/csrd_utils/v2/compose/__init__.py

@@ -0,0 +1,180 @@
+"""Compose package namespace."""
+
+from pathlib import Path
+
+from .loader import (
+    SPEC_FILENAME,
+    default_spec,
+    load_spec,
+    save_spec,
+    spec_file_path,
+)
+from .presets import (
+    PRESET_REGISTRY,
+    PresetDefinition,
+    list_presets,
+    members_for_category,
+)
+from .renderer import render_workspace
+from .spec import (
+    INFRA_ALL_TYPES,
+    INFRA_CATEGORIES,
+    INFRA_DATABASES,
+    ComposeSpec,
+    InfraNode,
+    ServiceNode,
+)
+from .yaml_editor import (
+    deep_merge,
+    dumps_yaml,
+    ensure_list_item,
+    load_yaml,
+    save_yaml,
+    set_key,
+)
+
+
+def apply(output_dir: Path, *, git_init: bool = False) -> Path:
+    """Apply baseline empty-workspace rendering into `output_dir`."""
+
+    return render_workspace(output_dir, git_init=git_init)
+
+
+def validate(output_dir: Path) -> ComposeSpec:
+    """Validate and return the canonical compose spec for a workspace."""
+
+    return load_spec(spec_file_path(output_dir))
+
+
+def add_service(output_dir: Path, service: ServiceNode) -> ComposeSpec:
+    """Append a service to the workspace spec and persist to disk.
+
+    Returns the updated spec.
+    """
+
+    spec_path = spec_file_path(output_dir)
+    spec = load_spec(spec_path)
+
+    existing_names = {s.name for s in spec.services}
+    if service.name in existing_names:
+        raise ValueError(f"Service '{service.name}' already exists in workspace spec")
+
+    spec.services.append(service)
+    save_spec(spec, spec_path)
+    return spec
+
+
+def add_infra(output_dir: Path, infra: InfraNode) -> ComposeSpec:
+    # ...existing docstring and body...
+    """Add or replace an infrastructure entry in the workspace spec.
+
+    Database types are mutually exclusive — adding one replaces any existing
+    database entry.  Other infra types (redis, rabbitmq) are singletons that
+    cannot be duplicated.
+
+    Returns the updated spec.
+    """
+
+    spec_path = spec_file_path(output_dir)
+    spec = load_spec(spec_path)
+
+    existing_types = {i.type for i in spec.infra}
+
+    if infra.type in INFRA_DATABASES:
+        # Remove any existing database entry (mutually exclusive)
+        spec.infra = [i for i in spec.infra if i.type not in INFRA_DATABASES]
+    elif infra.type in existing_types:
+        raise ValueError(f"Infra '{infra.type}' already exists in workspace spec")
+
+    spec.infra.append(infra)
+    save_spec(spec, spec_path)
+    return spec
+
+
+def remove_infra(output_dir: Path, infra_type: str) -> ComposeSpec:
+    """Remove an infrastructure entry from the workspace spec.
+
+    Raises ``ValueError`` if *infra_type* is not currently configured.
+
+    Returns the updated spec.
+    """
+
+    spec_path = spec_file_path(output_dir)
+    spec = load_spec(spec_path)
+
+    existing_types = {i.type for i in spec.infra}
+    if infra_type not in existing_types:
+        raise ValueError(f"Infra '{infra_type}' is not configured in workspace spec")
+
+    spec.infra = [i for i in spec.infra if i.type != infra_type]
+    save_spec(spec, spec_path)
+    return spec
+
+
+def available_infra(workspace_dir: Path) -> list[str]:
+    """Return infra types not yet present in the workspace spec.
+
+    Database types are mutually exclusive — if any database is already
+    configured, all database options are excluded.
+    """
+
+    spec_path = spec_file_path(workspace_dir)
+    if not spec_path.is_file():
+        return sorted(INFRA_ALL_TYPES)
+
+    spec = load_spec(spec_path)
+    existing = {i.type for i in spec.infra}
+
+    available: list[str] = []
+    has_db = bool(existing & INFRA_DATABASES)
+    for infra_type in sorted(INFRA_ALL_TYPES):
+        if infra_type in existing:
+            continue
+        if has_db and infra_type in INFRA_DATABASES:
+            continue
+        available.append(infra_type)
+    return available
+
+
+def configured_infra(workspace_dir: Path) -> list[str]:
+    """Return infra types currently configured in the workspace spec."""
+
+    spec_path = spec_file_path(workspace_dir)
+    if not spec_path.is_file():
+        return []
+
+    spec = load_spec(spec_path)
+    return sorted(i.type for i in spec.infra)
+
+
+__all__ = [
+    "INFRA_ALL_TYPES",
+    "INFRA_CATEGORIES",
+    "INFRA_DATABASES",
+    "PRESET_REGISTRY",
+    "SPEC_FILENAME",
+    "ComposeSpec",
+    "InfraNode",
+    "PresetDefinition",
+    "ServiceNode",
+    "add_infra",
+    "add_service",
+    "apply",
+    "available_infra",
+    "configured_infra",
+    "deep_merge",
+    "default_spec",
+    "dumps_yaml",
+    "ensure_list_item",
+    "list_presets",
+    "load_spec",
+    "load_yaml",
+    "members_for_category",
+    "remove_infra",
+    "render_workspace",
+    "save_spec",
+    "save_yaml",
+    "set_key",
+    "spec_file_path",
+    "validate",
+]

csrd_utils-0.3.85/src/csrd_utils/v2/compose/git.py

@@ -0,0 +1,17 @@
+"""Git integration helpers for compose workspaces."""
+
+import subprocess
+from pathlib import Path
+
+
+def maybe_git_init(output_dir: Path) -> None:
+    """Run ``git init`` inside *output_dir* if the directory is not already a git repo."""
+
+    if (output_dir / ".git").exists():
+        return
+    subprocess.run(
+        ["git", "init"],
+        cwd=output_dir,
+        check=True,
+        capture_output=True,
+    )

csrd_utils-0.3.85/src/csrd_utils/v2/compose/infra.py

@@ -0,0 +1,178 @@
+"""Infrastructure container definitions for docker-compose rendering.
+
+Each definition is a pure data function — no I/O, no side effects.
+The renderer calls these to build the ``services`` and ``volumes``
+sections of ``docker-compose.yml``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models import InfraRenderer
+
+# ---------------------------------------------------------------------------
+# Healthcheck presets
+# ---------------------------------------------------------------------------
+
+
+def _healthcheck(
+    test: list[str], interval: str = "5s", timeout: str = "3s", retries: int = 3
+) -> dict[str, Any]:
+    return {
+        "test": test,
+        "interval": interval,
+        "timeout": timeout,
+        "retries": retries,
+        "start_period": "10s",
+    }
+
+
+# ---------------------------------------------------------------------------
+# Container definitions
+# ---------------------------------------------------------------------------
+
+
+def postgres_service() -> tuple[dict[str, Any], dict[str, None]]:
+    """Return (service_dict, volumes_dict) for a Postgres container."""
+
+    service: dict[str, Any] = {
+        "image": "postgres:16-alpine",
+        "restart": "unless-stopped",
+        "environment": {
+            "POSTGRES_DB": "${DB_NAME:-service_db}",
+            "POSTGRES_USER": "${DB_USER:-service_user}",
+            "POSTGRES_PASSWORD": "${DB_PASSWORD:-change_me}",
+        },
+        "ports": ["5432:5432"],
+        "volumes": ["postgres-data:/var/lib/postgresql/data"],
+        "healthcheck": _healthcheck(
+            ["CMD-SHELL", "pg_isready -U ${DB_USER:-service_user} -d ${DB_NAME:-service_db}"],
+        ),
+    }
+    volumes: dict[str, None] = {"postgres-data": None}
+    return service, volumes
+
+
+def mariadb_service() -> tuple[dict[str, Any], dict[str, None]]:
+    """Return (service_dict, volumes_dict) for a MariaDB container."""
+
+    service: dict[str, Any] = {
+        "image": "mariadb:11",
+        "restart": "unless-stopped",
+        "environment": {
+            "MYSQL_ROOT_PASSWORD": "${MYSQL_ROOT_PASSWORD:-change_me_root}",
+            "MYSQL_DATABASE": "${DB_NAME:-service_db}",
+            "MYSQL_USER": "${DB_USER:-service_user}",
+            "MYSQL_PASSWORD": "${DB_PASSWORD:-change_me}",
+        },
+        "ports": ["3306:3306"],
+        "volumes": ["mariadb-data:/var/lib/mysql"],
+        "healthcheck": _healthcheck(
+            ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"],
+        ),
+    }
+    volumes: dict[str, None] = {"mariadb-data": None}
+    return service, volumes
+
+
+def redis_service() -> tuple[dict[str, Any], dict[str, None]]:
+    """Return (service_dict, volumes_dict) for a Redis container."""
+
+    service: dict[str, Any] = {
+        "image": "redis:7-alpine",
+        "restart": "unless-stopped",
+        "ports": ["6379:6379"],
+        "healthcheck": _healthcheck(
+            ["CMD", "redis-cli", "ping"],
+        ),
+    }
+    return service, {}
+
+
+def rabbitmq_service() -> tuple[dict[str, Any], dict[str, None]]:
+    """Return (service_dict, volumes_dict) for a RabbitMQ container."""
+
+    service: dict[str, Any] = {
+        "image": "rabbitmq:3-management-alpine",
+        "restart": "unless-stopped",
+        "environment": {
+            "RABBITMQ_DEFAULT_USER": "${RABBITMQ_USER:-service_rabbit}",
+            "RABBITMQ_DEFAULT_PASS": "${RABBITMQ_PASSWORD:-change_me}",
+        },
+        "ports": ["5672:5672", "15672:15672"],
+        "healthcheck": _healthcheck(
+            ["CMD", "rabbitmq-diagnostics", "-q", "ping"],
+        ),
+    }
+    return service, {}
+
+
+# ---------------------------------------------------------------------------
+# Registry
+# ---------------------------------------------------------------------------
+
+INFRA_RENDERERS: dict[str, InfraRenderer] = {
+    "postgres": postgres_service,
+    "mariadb": mariadb_service,
+    "redis": redis_service,
+    "rabbitmq": rabbitmq_service,
+}
+"""Map infra type name → factory that returns ``(service_dict, volumes_dict)``."""
+
+
+def render_infra(infra_type: str) -> tuple[str, dict[str, Any], dict[str, None]]:
+    """Render an infra type into its compose service name, service dict, and volumes.
+
+    Raises ``KeyError`` if *infra_type* has no renderer (e.g. ``sqlite``
+    which needs no container).
+    """
+
+    factory = INFRA_RENDERERS[infra_type]
+    service_def, volumes = factory()
+    return infra_type, service_def, volumes
+
+
+# ---------------------------------------------------------------------------
+# Service environment wiring
+# ---------------------------------------------------------------------------
+
+
+def service_env_block(db_type: str) -> dict[str, str]:
+    """Return the environment variables a service needs to connect to *db_type*.
+
+    For ``postgres``/``mariadb`` the vars point at the shared infra container.
+    For ``sqlite`` the var points at a local file path (volume-mounted).
+    """
+
+    if db_type == "postgres":
+        return {
+            "DB_HOST": "postgres",
+            "DB_PORT": "5432",
+            "DB_NAME": "${DB_NAME:-service_db}",
+            "DB_USER": "${DB_USER:-service_user}",
+            "DB_PASSWORD": "${DB_PASSWORD:-change_me}",
+        }
+    if db_type == "mariadb":
+        return {
+            "DB_HOST": "mariadb",
+            "DB_PORT": "3306",
+            "DB_NAME": "${DB_NAME:-service_db}",
+            "DB_USER": "${DB_USER:-service_user}",
+            "DB_PASSWORD": "${DB_PASSWORD:-change_me}",
+        }
+    if db_type == "sqlite":
+        # DB_PATH is set per-service in the renderer; this is the base template.
+        return {}
+    return {}
+
+
+def service_depends_on(db_type: str) -> dict[str, Any]:
+    """Return ``depends_on`` entries for a service wired to *db_type*.
+
+    ``sqlite`` returns empty (no container dependency).
+    """
+
+    if db_type in {"postgres", "mariadb"}:
+        return {db_type: {"condition": "service_healthy"}}
+    return {}