rigyard 1.0.0__py3-none-any.whl

rigyard/__init__.py

@@ -0,0 +1,19 @@
+"""Configuration-driven tooling for containerized development workflows."""
+
+from .config.loader import load_config, load_values
+from .errors import RigyardError
+from .parameters.context import ResolvedContext, ResolvedValue, ValueSource
+from .parameters.resolver import RuntimeValueResolver, collect_prompts
+from .version import __version__
+
+__all__ = [
+    "RuntimeValueResolver",
+    "ResolvedContext",
+    "ResolvedValue",
+    "RigyardError",
+    "ValueSource",
+    "__version__",
+    "load_config",
+    "collect_prompts",
+    "load_values",
+]

rigyard/__main__.py

@@ -0,0 +1,3 @@
+from .cli.main import main
+
+main()

rigyard/application/__init__.py

@@ -0,0 +1,30 @@
+"""Reusable application use cases shared by command and menu frontends."""
+
+from .builds import BuildProjectUseCase
+from .containers import CreateContainerUseCase
+from .images import BuildImageUseCase
+from .parameters import (
+    InspectParametersUseCase,
+    ResolveParametersUseCase,
+    ValidateConfigUseCase,
+)
+from .project import ProjectContext
+from .requests import BuildImageRequest, ResolutionRequest
+from .scenarios import PlanScenarioUseCase
+from .tasks import ExecuteTaskUseCase
+from .tests import ExecuteTestUseCase
+
+__all__ = [
+    "BuildImageRequest",
+    "BuildImageUseCase",
+    "BuildProjectUseCase",
+    "CreateContainerUseCase",
+    "ExecuteTestUseCase",
+    "ExecuteTaskUseCase",
+    "InspectParametersUseCase",
+    "PlanScenarioUseCase",
+    "ProjectContext",
+    "ResolutionRequest",
+    "ResolveParametersUseCase",
+    "ValidateConfigUseCase",
+]

rigyard/application/builds.py

@@ -0,0 +1,60 @@
+"""Shared application use case for configured project builds."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import datetime
+
+from ..builds.backend import BuildBackend
+from ..builds.models import BuildPlan, BuildResult, BuildSpec
+from ..builds.planner import BuildPlanner
+from ..parameters.prompt import Formatter
+from ..parameters.sources import DynamicSources
+from .project import project_context
+from .requests import ResolutionRequest
+from .resolution import resolve_definition
+
+
+class BuildProjectUseCase:
+    def __init__(
+        self,
+        backend: BuildBackend,
+        *,
+        sources: DynamicSources | None = None,
+        formatter: Formatter | None = None,
+    ) -> None:
+        self.backend = backend
+        self.sources = dict(sources or {})
+        self.formatter = formatter
+
+    def plan(
+        self,
+        build_name: str,
+        request: ResolutionRequest,
+        *,
+        environment: Mapping[str, str] | None = None,
+        now: datetime | None = None,
+    ) -> BuildPlan:
+        project = project_context(
+            request.config_path,
+            request.project,
+            environment=environment,
+            timestamp=now,
+            workspace_root=request.workspace_root,
+        )
+        spec = resolve_definition(
+            project,
+            request,
+            "builds",
+            build_name,
+            BuildSpec,
+            sources=self.sources,
+            formatter=self.formatter,
+        )
+        return BuildPlanner().create_plan(
+            build_name,
+            spec,
+        )
+
+    def execute(self, plan: BuildPlan) -> BuildResult:
+        return self.backend.execute(plan)

rigyard/application/containers.py

@@ -0,0 +1,63 @@
+"""Shared application use case for CLI and menu container creation."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import datetime
+
+from ..containers.backend import ContainerBackend
+from ..containers.models import ContainerCreateResult, ContainerRunPlan, ContainerSpec
+from ..containers.planner import ContainerRunPlanner
+from ..containers.service import ContainerCreateService
+from ..parameters.prompt import Formatter
+from ..parameters.sources import DynamicSources
+from .project import project_context
+from .requests import ResolutionRequest
+from .resolution import resolve_definition
+
+
+class CreateContainerUseCase:
+    def __init__(
+        self,
+        backend: ContainerBackend,
+        *,
+        sources: DynamicSources | None = None,
+        formatter: Formatter | None = None,
+    ) -> None:
+        self.service = ContainerCreateService(backend)
+        self.sources = dict(sources or {})
+        self.formatter = formatter
+
+    def plan(
+        self,
+        container_name: str,
+        request: ResolutionRequest,
+        *,
+        environment: Mapping[str, str] | None = None,
+        now: datetime | None = None,
+    ) -> ContainerRunPlan:
+        project = project_context(
+            request.config_path,
+            request.project,
+            environment=environment,
+            timestamp=now,
+            workspace_root=request.workspace_root,
+        )
+        spec = resolve_definition(
+            project,
+            request,
+            "containers",
+            container_name,
+            ContainerSpec,
+            sources=self.sources,
+            formatter=self.formatter,
+        )
+        return ContainerRunPlanner().plan(
+            container_name,
+            spec,
+            project.config_path,
+            project.environment,
+        )
+
+    def execute(self, plan: ContainerRunPlan) -> ContainerCreateResult:
+        return self.service.create(plan)

rigyard/application/definitions.py

@@ -0,0 +1,29 @@
+"""Application access to the canonical source-qualified definition catalog."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..config.catalog import Definition, DefinitionCatalog
+from ..config.models import RigyardConfig
+
+
+def find_definition(
+    config: RigyardConfig,
+    kind: str,
+    name: str,
+    source_path: Path | None,
+    config_path: Path,
+) -> Definition | None:
+    return DefinitionCatalog(config, config_path).find(kind, name, source_path)
+
+
+def definition_source_paths(
+    config: RigyardConfig,
+    config_path: Path,
+    source_path: Path | None = None,
+) -> dict[str, Path]:
+    return {
+        item.prefix: item.source_path
+        for item in DefinitionCatalog(config, config_path).selected(source_path)
+    }

rigyard/application/images.py

@@ -0,0 +1,61 @@
+"""Application use case for building a configured image."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import datetime
+
+from ..images.backend import ImageBuildBackend
+from ..images.models import ImageBuildPlan, ImageBuildResult, ImageSpec
+from ..images.planner import ImageBuildPlanner
+from ..images.service import ImageBuildService
+from ..parameters.prompt import Formatter
+from ..parameters.sources import DynamicSources
+from .project import project_context
+from .requests import BuildImageRequest
+from .resolution import resolve_definition
+
+
+class BuildImageUseCase:
+    def __init__(
+        self,
+        backend: ImageBuildBackend,
+        *,
+        sources: DynamicSources | None = None,
+        formatter: Formatter | None = None,
+    ) -> None:
+        self.backend = backend
+        self.sources = dict(sources or {})
+        self.formatter = formatter
+
+    def plan(
+        self,
+        request: BuildImageRequest,
+        *,
+        environment: Mapping[str, str] | None = None,
+        now: datetime | None = None,
+    ) -> ImageBuildPlan:
+        project = project_context(
+            request.config_path,
+            request.project,
+            environment=environment,
+            timestamp=now,
+            workspace_root=request.workspace_root,
+        )
+        spec = resolve_definition(
+            project,
+            request.resolution_request(),
+            "images",
+            request.image_name,
+            ImageSpec,
+            sources=self.sources,
+            formatter=self.formatter,
+        )
+        return ImageBuildPlanner().create_plan(
+            request.image_name,
+            spec,
+            project.config_path,
+        )
+
+    def execute(self, plan: ImageBuildPlan) -> ImageBuildResult:
+        return ImageBuildService(self.backend).build(plan)

rigyard/application/parameters.py

@@ -0,0 +1,301 @@
+"""Application boundary for inline runtime value discovery and resolution."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from typing import Any, TypeVar
+
+from pydantic import BaseModel
+
+from ..builds.models import BuildSpec
+from ..config.catalog import DefinitionCatalog
+from ..config.loader import load_config, load_values
+from ..config.models import RigyardConfig
+from ..containers.models import ContainerSpec
+from ..errors import ResolutionError
+from ..images.models import ImageSpec
+from ..parameters.context import ResolvedContext
+from ..parameters.prompt import Formatter
+from ..parameters.resolver import (
+    RuntimeValueResolver,
+    collect_prompts,
+    flatten_values,
+    materialize_as,
+)
+from ..parameters.sources import DynamicSources
+from ..parameters.templates import (
+    SourceAwareStringTemplateRenderer,
+    StringTemplateRenderer,
+    TemplateContext,
+    validate_template_syntax,
+)
+from ..scenarios.models import (
+    ScenarioComposeSpec,
+    ScenarioInstanceSpec,
+    ScenarioProfileSpec,
+    ScenarioStartupSpec,
+    ScenarioTemplate,
+)
+from ..tasks.models import TaskSpec
+from ..tests.models import TestSpec
+from .definitions import definition_source_paths
+from .project import project_context
+from .requests import ResolutionRequest
+
+ModelT = TypeVar("ModelT", bound=BaseModel)
+
+
+class ValidateConfigUseCase:
+    def execute(
+        self,
+        config_path: str | Path,
+        *,
+        workspace_root: str | Path | None = None,
+    ) -> RigyardConfig:
+        config = load_config(config_path, workspace_root=workspace_root)
+        _validate_config_templates(config, config_path)
+        return config
+
+
+class InspectParametersUseCase:
+    def execute(
+        self,
+        config_path: str | Path,
+        source_path: Path | None = None,
+        *,
+        workspace_root: str | Path | None = None,
+    ) -> dict[str, Any]:
+        config = load_config(config_path, workspace_root=workspace_root)
+        _validate_config_templates(config, config_path)
+        prompts = _collect_config_prompts(config, Path(config_path), source_path)
+        return {
+            "version": config.version,
+            "runtime_values": RuntimeValueResolver(prompts).inspect(),
+        }
+
+
+class ResolveParametersUseCase:
+    def __init__(
+        self,
+        sources: DynamicSources | None = None,
+        formatter: Formatter | None = None,
+    ) -> None:
+        self.sources = dict(sources or {})
+        self.formatter = formatter
+
+    def execute(
+        self, request: ResolutionRequest, *, allow_missing: bool = False
+    ) -> ResolvedContext:
+        project = project_context(
+            request.config_path,
+            request.project,
+            workspace_root=request.workspace_root,
+        )
+        config = project.config
+        template_context = TemplateContext.capture(
+            project.environment,
+            now=project.timestamp,
+            config_path=project.config_path,
+            workspace_root=project.workspace_root,
+            variables=config.variables,
+        )
+        renderer = SourceAwareStringTemplateRenderer(
+            template_context,
+            definition_source_paths(config, project.config_path, request.source_path),
+        )
+        context = resolve_prompts(
+            config,
+            request,
+            allow_missing=allow_missing,
+            renderer=renderer,
+            sources=self.sources,
+            formatter=self.formatter,
+            environment=project.environment,
+        )
+        if not allow_missing:
+            targets: dict[str, type[BaseModel]] = {
+                "images": ImageSpec,
+                "containers": ContainerSpec,
+                "builds": BuildSpec,
+                "tests": TestSpec,
+                "tasks": TaskSpec,
+            }
+            for entry in DefinitionCatalog(config, project.config_path).selected(
+                request.source_path
+            ):
+                if isinstance(entry.value, ScenarioTemplate):
+                    scenario = entry.value
+                    if scenario.compose is not None:
+                        materialize_as(
+                            scenario.compose,
+                            f"{entry.prefix}.compose",
+                            context,
+                            ScenarioComposeSpec,
+                            renderer,
+                        )
+                    materialize_as(
+                        scenario.startup,
+                        f"{entry.prefix}.startup",
+                        context,
+                        ScenarioStartupSpec,
+                        renderer,
+                    )
+                    for name, instance in scenario.instances.items():
+                        materialize_as(
+                            instance,
+                            f"{entry.prefix}.instances.{name}",
+                            context,
+                            ScenarioInstanceSpec,
+                            renderer,
+                        )
+                    for name, profile in scenario.profiles.items():
+                        materialize_as(
+                            profile,
+                            f"{entry.prefix}.profiles.{name}",
+                            context,
+                            ScenarioProfileSpec,
+                            renderer,
+                        )
+                else:
+                    materialize_as(
+                        entry.value, entry.prefix, context, targets[entry.kind], renderer
+                    )
+        return context
+
+
+def _validate_config_templates(config: RigyardConfig, config_path: str | Path) -> None:
+    base = TemplateContext.capture({}, config_path=config_path)
+    previous: list[str] = []
+    for name, value in config.variables.items():
+        StringTemplateRenderer(base, variable_names=previous).validate(value, f"variables.{name}")
+        previous.append(name)
+    renderer = StringTemplateRenderer(base, variable_names=config.variables)
+    for entry in DefinitionCatalog(config, Path(config_path)).entries:
+        validate_template_syntax(entry.value, entry.prefix, renderer=renderer)
+
+
+def resolve_prompts(
+    template: BaseModel,
+    request: ResolutionRequest,
+    *,
+    prefix: str = "",
+    allow_missing: bool = False,
+    renderer: StringTemplateRenderer | None = None,
+    sources: DynamicSources | None = None,
+    formatter: Formatter | None = None,
+    environment: Mapping[str, str] | None = None,
+) -> ResolvedContext:
+    prompts = (
+        _collect_config_prompts(template, request.config_path, request.source_path)
+        if isinstance(template, RigyardConfig) and not prefix
+        else collect_prompts(template, prefix)
+    )
+    values = load_values(request.values_path) if request.values_path else {}
+    return RuntimeValueResolver(
+        prompts,
+        render_default=default_display_renderer(renderer),
+        sources=sources,
+        formatter=formatter,
+    ).resolve(
+        values=values,
+        environ=environment if environment is not None else _request_environment(request),
+        overrides=request.overrides,
+        interactive=request.interactive,
+        input_fn=request.input_fn,
+        allow_missing=allow_missing,
+    )
+
+
+def _collect_config_prompts(
+    config: RigyardConfig,
+    config_path: Path,
+    source_path: Path | None = None,
+) -> dict[str, Any]:
+    prompts: dict[str, Any] = {}
+    for entry in DefinitionCatalog(config, config_path).selected(source_path):
+        prompts.update(collect_prompts(entry.value, entry.prefix))
+    return prompts
+
+
+def _available_prompts(root: BaseModel, request: ResolutionRequest) -> dict[str, Any]:
+    if not isinstance(root, RigyardConfig):
+        return collect_prompts(root)
+    prompts: dict[str, Any] = {}
+    for entry in DefinitionCatalog(root, request.config_path).entries:
+        prompts.update(collect_prompts(entry.value, entry.prefix))
+    return prompts
+
+
+def resolve_template(
+    root: BaseModel,
+    template: BaseModel,
+    request: ResolutionRequest,
+    prefix: str,
+    target: type[ModelT],
+    renderer: StringTemplateRenderer | None = None,
+    sources: DynamicSources | None = None,
+    formatter: Formatter | None = None,
+    environment: Mapping[str, str] | None = None,
+) -> tuple[ModelT, ResolvedContext]:
+    selected = collect_prompts(template, prefix)
+    context = resolve_selected_prompts(
+        root,
+        selected,
+        request,
+        renderer=renderer,
+        sources=sources,
+        formatter=formatter,
+        environment=environment,
+    )
+    return materialize_as(template, prefix, context, target, renderer), context
+
+
+def resolve_selected_prompts(
+    root: BaseModel,
+    selected: dict[str, Any],
+    request: ResolutionRequest,
+    *,
+    renderer: StringTemplateRenderer | None = None,
+    sources: DynamicSources | None = None,
+    formatter: Formatter | None = None,
+    environment: Mapping[str, str] | None = None,
+) -> ResolvedContext:
+    """Resolve an explicitly composed set of prompt paths from one config root."""
+
+    available = _available_prompts(root, request)
+    available.update(selected)
+    values = load_values(request.values_path) if request.values_path else {}
+    flat_values = flatten_values(values)
+    unknown = (set(flat_values) | set(request.overrides)) - set(available)
+    if unknown:
+        raise ResolutionError(f"unknown runtime value(s): {', '.join(sorted(unknown))}")
+    return RuntimeValueResolver(
+        selected,
+        render_default=default_display_renderer(renderer),
+        sources=sources,
+        formatter=formatter,
+    ).resolve(
+        values={key: value for key, value in flat_values.items() if key in selected},
+        environ=environment if environment is not None else _request_environment(request),
+        overrides={key: value for key, value in request.overrides.items() if key in selected},
+        interactive=request.interactive,
+        input_fn=request.input_fn,
+    )
+
+
+def _request_environment(request: ResolutionRequest) -> Mapping[str, str] | None:
+    return request.project.environment if request.project is not None else None
+
+
+def default_display_renderer(
+    renderer: StringTemplateRenderer | None,
+) -> Callable[[str, Any], str] | None:
+    """Adapt a template renderer for rendering prompt defaults in hints."""
+    if renderer is None:
+        return None
+
+    def render(path: str, value: Any) -> str:
+        return str(renderer.render_value(value, path))
+
+    return render

rigyard/application/project.py

@@ -0,0 +1,77 @@
+"""A stable project snapshot shared across one frontend operation."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from types import MappingProxyType
+
+from ..config.loader import load_config
+from ..config.models import RigyardConfig
+
+
+@dataclass(frozen=True)
+class ProjectContext:
+    """Configuration and host context captured together at one point in time."""
+
+    config_path: Path
+    config: RigyardConfig
+    environment: Mapping[str, str]
+    timestamp: datetime
+    workspace_root: Path = field(default_factory=lambda: Path.cwd().resolve())
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "config_path", Path(self.config_path))
+        object.__setattr__(self, "workspace_root", Path(self.workspace_root).resolve())
+        object.__setattr__(self, "environment", MappingProxyType(dict(self.environment)))
+
+    @classmethod
+    def capture(
+        cls,
+        config_path: str | Path,
+        *,
+        config: RigyardConfig | None = None,
+        environment: Mapping[str, str] | None = None,
+        timestamp: datetime | None = None,
+        workspace_root: str | Path | None = None,
+    ) -> ProjectContext:
+        path = Path(config_path)
+        root = Path.cwd().resolve() if workspace_root is None else Path(workspace_root).resolve()
+        return cls(
+            config_path=path,
+            config=load_config(path, workspace_root=root) if config is None else config,
+            environment=os.environ if environment is None else environment,
+            timestamp=datetime.now().astimezone() if timestamp is None else timestamp,
+            workspace_root=root,
+        )
+
+
+def project_context(
+    config_path: str | Path,
+    current: ProjectContext | None,
+    *,
+    environment: Mapping[str, str] | None = None,
+    timestamp: datetime | None = None,
+    workspace_root: str | Path | None = None,
+) -> ProjectContext:
+    """Reuse a supplied snapshot while honoring explicit test/runtime overrides."""
+
+    if current is None:
+        return ProjectContext.capture(
+            config_path,
+            environment=environment,
+            timestamp=timestamp,
+            workspace_root=workspace_root,
+        )
+    if environment is None and timestamp is None and workspace_root is None:
+        return current
+    return ProjectContext(
+        config_path=current.config_path,
+        config=current.config,
+        environment=current.environment if environment is None else environment,
+        timestamp=current.timestamp if timestamp is None else timestamp,
+        workspace_root=current.workspace_root if workspace_root is None else Path(workspace_root),
+    )