ps-plugin-module-delivery 0.2.8__py3-none-any.whl

ps/plugin/module/delivery/__init__.py

@@ -0,0 +1,5 @@
+from ._delivery_module import DeliveryModule
+
+__all__ = [
+    "DeliveryModule",
+]

ps/plugin/module/delivery/_delivery_module.py

@@ -0,0 +1,179 @@
+from datetime import datetime
+from pathlib import Path
+from typing import ClassVar, Optional
+
+from cleo.events.console_command_event import ConsoleCommandEvent
+from cleo.events.console_terminate_event import ConsoleTerminateEvent
+from cleo.io.inputs.argument import Argument
+from cleo.io.inputs.input import Input
+from cleo.io.inputs.option import Option
+from cleo.io.io import IO
+from poetry.console.application import Application
+from poetry.console.commands.build import BuildCommand
+from poetry.console.commands.publish import PublishCommand
+
+from ps.di import DI
+from ps.plugin.sdk.events import ensure_argument, ensure_option
+from ps.plugin.sdk.project import Environment, filter_projects
+from ps.version import Version
+from ps.token_expressions import TokenResolverEntry
+
+from .token_resolvers import DateResolver, EnvResolver, RandResolver, VersionResolver, collect_git_info
+from .stages import (
+    DeliverableType,
+    ResolvedProjectMetadata,
+    build_projects,
+    log_resolution,
+    patch_projects,
+    publish_projects,
+    resolve_environment_metadata,
+)
+from .commands import DeliveryCommand
+
+
+BUILD_VERSION_OPTION = "build-version"
+BUILD_VERSION_OPTION_SHORT = "b"
+INPUTS_ARGUMENT = "inputs"
+
+
+def _get_inputs(input: Input) -> list[str]:
+    return input.arguments.get(INPUTS_ARGUMENT, [])
+
+
+def _get_version_option(input: Input) -> Optional[str]:
+    return input.options.get(BUILD_VERSION_OPTION, None)
+
+
+class DeliveryModule:
+    name: ClassVar[str] = "ps-delivery"
+
+    def __init__(self) -> None:
+        self._exit_code: Optional[int] = None
+
+    def poetry_activate(
+        self,
+        application: Application,
+        environment: Environment,
+        di: DI,
+        io: IO
+    ) -> bool:
+        # Extend the BuildCommand with an optional "inputs" argument
+        ensure_argument(BuildCommand, Argument(
+            name=INPUTS_ARGUMENT,
+            description="Optional inputs pointers to build. It could be project names or paths. If not provided, all discovered projects will be built.",
+            is_list=True,
+            required=False)
+        )
+        ensure_option(BuildCommand, Option(
+            name=BUILD_VERSION_OPTION,
+            description="Specify the version to build the project with.",
+            shortcut=BUILD_VERSION_OPTION_SHORT,
+            flag=False)
+        )
+        ensure_argument(PublishCommand, Argument(
+            name=INPUTS_ARGUMENT,
+            description="Optional inputs pointers to publish. It could be project names or paths. If not provided, all discovered projects will be published.",
+            is_list=True,
+            required=False)
+        )
+        ensure_option(PublishCommand, Option(
+            name=BUILD_VERSION_OPTION,
+            description="Specify the version to publish the project with.",
+            shortcut=BUILD_VERSION_OPTION_SHORT,
+            flag=False)
+        )
+
+        application.add(di.spawn(DeliveryCommand))
+
+        di.register(TokenResolverEntry).factory(lambda: ("env", EnvResolver()))
+        di.register(TokenResolverEntry).factory(lambda: ("rand", RandResolver()))
+        di.register(TokenResolverEntry).factory(lambda: ("v", VersionResolver()))
+        di.register(TokenResolverEntry).factory(lambda: ("date", DateResolver(datetime.now())))
+        di.register(TokenResolverEntry).factory(lambda env: ("git", collect_git_info(env)), env=environment.host_project.path)
+        di.register(TokenResolverEntry).factory(lambda ver: ("in", ver), ver=Version.parse(_get_version_option(io.input)))
+        return True
+
+    def poetry_command(self, event: ConsoleCommandEvent, di: DI) -> None:
+        if not isinstance(event.command, (BuildCommand, PublishCommand)):
+            return
+
+        # Disable the original command execution
+        event.disable_command()
+
+        environment = di.resolve(Environment)
+        assert environment is not None
+
+        # Filter projects based on inputs
+        inputs = _get_inputs(event.io.input)
+        # In case no inputs are provided, and the entry project is different from the host project, add the entry project path as input
+        if not inputs and environment.host_project != environment.entry_project:
+            inputs.append(str(environment.entry_project.path))
+        environment_metadata = di.satisfy(resolve_environment_metadata)()
+
+        log_resolution(event.io, environment_metadata)
+
+        filtered_projects = filter_projects(inputs, environment.projects)
+        excluded = {id(p) for p in filtered_projects if (environment_metadata.projects.get(p.path) or ResolvedProjectMetadata()).deliver != DeliverableType.ENABLED}
+        event.io.write_line("<fg=magenta>Delivery scope:</>")
+        for p in filtered_projects:
+            name = p.name.value or p.path.name
+            if id(p) in excluded:
+                event.io.write_line(f"  - <fg=dark_gray>{name} (not marked for delivery)</>")
+            else:
+                event.io.write_line(f"  - <fg=blue>{name}</>")
+        filtered_projects = [p for p in filtered_projects if id(p) not in excluded]
+        if not filtered_projects:
+            event.io.write_line("<comment>No projects found to process.</comment>")
+            return
+
+        try:
+            environment.backup_projects(filtered_projects)
+
+            # Patch all projects
+            patch_exit_code = patch_projects(event.io, filtered_projects, environment_metadata)
+            if patch_exit_code != 0:
+                self._exit_code = patch_exit_code
+                return
+
+            # Execute build or publish command
+            is_publish = isinstance(event.command, PublishCommand)
+            if is_publish:
+                opts = event.io.input.options
+                cert = opts.get("cert")
+                client_cert = opts.get("client-cert")
+                dist_dir = opts.get("dist-dir")
+                self._exit_code = publish_projects(
+                    event.io,
+                    filtered_projects,
+                    environment,
+                    environment_metadata,
+                    repository=opts.get("repository"),
+                    username=opts.get("username"),
+                    password=opts.get("password"),
+                    cert=Path(cert) if cert else None,
+                    client_cert=Path(client_cert) if client_cert else None,
+                    dist_dir=Path(dist_dir) if dist_dir else None,
+                    dry_run=bool(opts.get("dry-run")),
+                    skip_existing=bool(opts.get("skip-existing")),
+                )
+            else:
+                opts = event.io.input.options
+                self._exit_code = build_projects(
+                    event.io,
+                    filtered_projects,
+                    formats=BuildCommand._prepare_formats(opts.get("format")),
+                    clean=bool(opts.get("clean")),
+                    output=opts.get("output") or "dist",
+                    config_settings=BuildCommand._prepare_config_settings(
+                        local_version=opts.get("local-version"),
+                        config_settings=opts.get("config-settings"),
+                        io=event.io,
+                    ),
+                )
+        finally:
+            environment.restore_projects(environment.projects)
+
+    def poetry_terminate(self, event: ConsoleTerminateEvent) -> None:
+        if self._exit_code is None:
+            return
+        event.set_exit_code(self._exit_code)

ps/plugin/module/delivery/_delivery_settings.py

@@ -0,0 +1,9 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+from ps.version import VersionConstraint
+
+
+class DeliverySettings(BaseModel):
+    version_patterns: Optional[list[str]] = Field(default_factory=list, alias="version-patterns")
+    version_pinning: Optional[VersionConstraint] = Field(default=VersionConstraint.COMPATIBLE, alias="version-pinning")
+    deliver: Optional[bool] = Field(default=None, alias="deliver")

ps/plugin/module/delivery/_parallelization.py

@@ -0,0 +1,105 @@
+import logging
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Optional, TypeVar
+
+from cleo.formatters.formatter import Formatter
+from cleo.io.buffered_io import BufferedIO
+from cleo.io.io import IO
+
+T = TypeVar("T")
+
+_thread_io: threading.local = threading.local()
+
+
+class ThreadLocalIOHandler(logging.Handler):
+    def emit(self, record: logging.LogRecord) -> None:
+        bio: Optional[BufferedIO] = getattr(_thread_io, "io", None)
+        if bio is None:
+            return
+        try:
+            msg = self.format(record)
+            if record.levelname.lower() in ("warning", "error", "exception", "critical"):
+                bio.write_error_line(msg)
+            else:
+                bio.write_line(msg)
+        except Exception:
+            self.handleError(record)
+
+
+def _run_buffered(io: IO, item: T, fn: Callable[[BufferedIO, T], int]) -> tuple[int, str, str]:
+    buffered_io = BufferedIO(decorated=io.output.is_decorated())
+    buffered_io.set_verbosity(io.output.verbosity)
+    _thread_io.io = buffered_io
+    try:
+        exit_code = fn(buffered_io, item)
+    except Exception as e:
+        buffered_io.write_error_line(f"\n<error>{Formatter.escape(str(e))}</error>")
+        exit_code = 1
+    finally:
+        _thread_io.io = None
+    return exit_code, buffered_io.fetch_output(), buffered_io.fetch_error()
+
+
+def _flush(io: IO, out: str, err: str) -> None:
+    if out:
+        io.write(out)
+    if err:
+        io.write_error(err)
+
+
+def _normalize(text: str) -> str:
+    text = text.replace("\\n", "\n").replace("\r\n", "\n").replace("\r", "\n").strip()
+    lines = [line for line in text.splitlines() if line.strip()]
+    if not lines:
+        return ""
+    return "\n".join(lines) + "\n"
+
+
+def run_parallel(io: IO, items: list[T], fn: Callable[[BufferedIO, T], int]) -> int:
+    lock = threading.Lock()
+    exit_code = 0
+
+    def _run_and_flush(item: T) -> int:
+        result, out, err = _run_buffered(io, item, fn)
+        with lock:
+            _flush(io, out, err)
+        return result
+
+    with ThreadPoolExecutor() as executor:
+        results = list(executor.map(_run_and_flush, items))
+
+    for result in results:
+        if result != 0:
+            exit_code = result
+
+    return exit_code
+
+
+def run_topological(
+    io: IO,
+    items: list[T],
+    fn: Callable[[BufferedIO, T], int],
+    get_deps: Callable[[T], list[T]],
+) -> int:
+    lock = threading.Lock()
+    done_events: dict[int, threading.Event] = {id(item): threading.Event() for item in items}
+
+    def _run_and_flush(item: T) -> int:
+        for dep in get_deps(item):
+            done_events[id(dep)].wait()
+        result, out, err = _run_buffered(io, item, fn)
+        with lock:
+            _flush(io, _normalize(out), _normalize(err))
+        done_events[id(item)].set()
+        return result
+
+    with ThreadPoolExecutor() as executor:
+        futures = [executor.submit(_run_and_flush, item) for item in items]
+
+    exit_code = 0
+    for future in futures:
+        r = future.result()
+        if r != 0:
+            exit_code = r
+    return exit_code

ps/plugin/module/delivery/commands/__init__.py

@@ -0,0 +1,5 @@
+from ._delivery_command import DeliveryCommand
+
+__all__ = [
+    "DeliveryCommand",
+]

ps/plugin/module/delivery/commands/_delivery_command.py

@@ -0,0 +1,65 @@
+from cleo.commands.command import Command
+from cleo.io.inputs.option import Option
+
+from ps.di import DI
+from ..output import DeliveryRenderer, FormattedDeliveryRenderer, JsonDeliveryRenderer
+from ps.plugin.sdk.project import Environment
+
+from ..stages import (
+    DeliverableType,
+    ResolvedProjectMetadata,
+    build_dependency_tree,
+    build_publish_waves,
+    resolve_environment_metadata,
+)
+
+
+class DeliveryCommand(Command):
+    name = "delivery"
+    description = "Display the workspace delivery plan."
+    arguments = []
+    options = [
+        Option("--json", flag=True, description="Output as JSON"),
+        Option("--publish-order", flag=True, description="Show publish order"),
+        Option("--dependency-tree", flag=True, description="Show dependency tree"),
+        Option("--projects", flag=True, description="Show projects"),
+    ]
+
+    def __init__(self, di: DI) -> None:
+        super().__init__()
+        self._di = di
+
+    def handle(self) -> int:
+        io = self.io
+        environment = self._di.resolve(Environment)
+        assert environment is not None
+
+        environment_metadata = self._di.satisfy(resolve_environment_metadata)()
+        all_projects = list(environment.projects)
+        filtered = [
+            p for p in all_projects
+            if (environment_metadata.projects.get(p.path) or ResolvedProjectMetadata()).deliver == DeliverableType.ENABLED
+        ]
+
+        renderer: DeliveryRenderer = JsonDeliveryRenderer(io) if self.option("json") else FormattedDeliveryRenderer(io)
+        show_publish_order = self.option("publish-order")
+        show_dependency_tree = self.option("dependency-tree")
+        show_projects = self.option("projects")
+        has_filter = show_publish_order or show_dependency_tree or show_projects
+
+        if not has_filter or show_projects:
+            renderer.render_resolution("Projects", environment_metadata.resolutions)
+
+        if not has_filter or show_dependency_tree:
+            nodes = build_dependency_tree(all_projects, environment, environment_metadata)
+            renderer.render_dependency_tree("Dependency tree", nodes)
+
+        if not has_filter or show_publish_order:
+            if not filtered:
+                renderer.render_message("<comment>No deliverable projects.</comment>")
+            else:
+                waves = build_publish_waves(filtered, environment, environment_metadata)
+                renderer.render_publish_waves("Publish order", waves)
+
+        renderer.flush()
+        return 0

ps/plugin/module/delivery/output/__init__.py

@@ -0,0 +1,23 @@
+from ._formatted import FormattedDeliveryRenderer
+from ._json import JsonDeliveryRenderer
+from ._models import (
+    DependencyNode,
+    DependencyResolution,
+    ProjectResolution,
+    ProjectSummary,
+    PublishWave,
+    VersionPatternResult,
+)
+from ._protocol import DeliveryRenderer
+
+__all__ = [
+    "DeliveryRenderer",
+    "DependencyNode",
+    "DependencyResolution",
+    "FormattedDeliveryRenderer",
+    "JsonDeliveryRenderer",
+    "ProjectResolution",
+    "ProjectSummary",
+    "PublishWave",
+    "VersionPatternResult",
+]

ps/plugin/module/delivery/output/_formatted.py

@@ -0,0 +1,112 @@
+from cleo.io.io import IO
+
+from ._models import DependencyNode, DependencyResolution, ProjectResolution, PublishWave
+from ._protocol import DeliveryRenderer
+
+
+class FormattedDeliveryRenderer(DeliveryRenderer):
+    def __init__(self, io: IO) -> None:
+        self._io = io
+
+    def render_resolution(self, title: str, resolutions: list[ProjectResolution]) -> None:
+        self._io.write_line("")
+        self._io.write_line(f"<fg=magenta>{title}:</>")
+        for r in resolutions:
+            self._io.write_line(f"<fg=magenta>Resolving project:</> <fg=blue>{r.name}</> [<fg=dark_gray>{r.path}</>]")
+
+            if r.deliver == "Enabled":
+                deliver_label = "<fg=green>Enabled</>"
+            elif r.deliver == "DisabledByPackageMode":
+                deliver_label = "<fg=red>Disabled (package-mode)</>"
+            else:
+                deliver_label = "<fg=red>Disabled (deliver option)</>"
+            self._io.write_line(f"  - Deliverable: {deliver_label}")
+
+            if self._io.is_verbose():
+                for i, pr in enumerate(r.pattern_results, 1):
+                    if pr.matched:
+                        self._io.write_line(f"  <fg=dark_gray>[{i}]</> <fg=green>matched</> '<fg=cyan>{pr.pattern}</>' -> <fg=green>{pr.resolved_raw}</>")
+                    elif pr.condition and pr.errors:
+                        self._io.write_line(f"  <fg=dark_gray>[{i}]</> <fg=red>error</>   '<fg=cyan>{pr.pattern}</>' condition invalid: {'; '.join(pr.errors)}")
+                    elif pr.condition and not pr.condition_matched:
+                        self._io.write_line(f"  <fg=dark_gray>[{i}]</> <fg=yellow>skipped</> '<fg=cyan>{pr.pattern}</>' condition '<fg=dark_gray>{pr.condition}</>'")
+                    elif pr.errors and not pr.condition:
+                        self._io.write_line(f"  <fg=dark_gray>[{i}]</> <fg=red>error</>   '<fg=cyan>{pr.pattern}</>' invalid: {'; '.join(pr.errors)}")
+                    elif pr.resolved_raw:
+                        self._io.write_line(f"  <fg=dark_gray>[{i}]</> <fg=yellow>failed</>  '<fg=cyan>{pr.pattern}</>' -> '<fg=yellow>{pr.resolved_raw}</>' not a valid version")
+                    else:
+                        self._io.write_line(f"  <fg=dark_gray>[{i}]</> <fg=dark_gray>ignored</> '<fg=cyan>{pr.pattern}</>'")
+
+            if r.version:
+                if self._io.is_verbose():
+                    self._io.write_line(f"  - Version: <fg=green>{r.version}</> (Pattern: '<fg=cyan>{r.matched_pattern}</>', Pinning rule: <fg=cyan>{r.pinning}</>)")
+                else:
+                    self._io.write_line(f"  - Version: <fg=green>{r.version}</>")
+
+            self._render_dependencies(r.dependencies)
+
+    def render_dependency_tree(self, title: str, roots: list[DependencyNode]) -> None:
+        self._io.write_line("")
+        self._io.write_line(f"<fg=magenta>{title}:</>")
+        for i, root in enumerate(roots):
+            is_last = i == len(roots) - 1
+            self._print_node(
+                root,
+                "  " + ("└── " if is_last else "├── "),
+                "  " + ("    " if is_last else "│   "),
+            )
+
+    def _print_node(self, node: DependencyNode, prefix: str, child_prefix: str) -> None:
+        self._io.write_line(f"{prefix}<fg=blue>{node.name}</> <fg=green>{node.version}</>")
+        for i, child in enumerate(node.children):
+            is_last = i == len(node.children) - 1
+            self._print_node(
+                child,
+                child_prefix + ("└── " if is_last else "├── "),
+                child_prefix + ("    " if is_last else "│   "),
+            )
+
+    def render_publish_waves(self, title: str, waves: list[PublishWave]) -> None:
+        self._io.write_line("")
+        self._io.write_line(f"<fg=magenta>{title}:</>")
+        for i, wave in enumerate(waves):
+            is_last_wave = i == len(waves) - 1
+            wave_prefix = "└── " if is_last_wave else "├── "
+            child_prefix = "    " if is_last_wave else "│   "
+            self._io.write_line(f"  {wave_prefix}<fg=magenta>Wave {wave.index}</>")
+            for j, p in enumerate(wave.projects):
+                is_last_item = j == len(wave.projects) - 1
+                item_prefix = "└── " if is_last_item else "├── "
+                self._io.write_line(f"  {child_prefix}{item_prefix}<fg=blue>{p.name}</> <fg=green>{p.version}</>")
+
+    def _render_dependencies(self, dependencies: list[DependencyResolution]) -> None:
+        for dep in dependencies:
+            if dep.is_project:
+                base_line = f"  - Project dependency '<fg=cyan>{dep.name}</>'"
+                if self._io.is_verbose() and dep.path:
+                    self._io.write_line(f"{base_line} [<fg=dark_gray>{dep.path}</>]")
+                else:
+                    self._io.write_line(base_line)
+            elif dep.source == "skipped":
+                if self._io.is_debug():
+                    self._io.write_line(f"  <fg=dark_gray>- Dependency '<fg=cyan>{dep.name}</> skipped (no version constraint).</>")
+            else:
+                base_line = f"  - Dependency '<fg=cyan>{dep.name}</>': <fg=green>{dep.constraint}</>"
+                detail = None
+                if dep.source == "host":
+                    detail = f"Resolved from <fg=cyan>host</>: <fg=green>{dep.constraint}</>"
+                elif dep.source in ("host-no-constraint", "not-found"):
+                    detail = f"from <fg=cyan>{dep.source}</>"
+                elif dep.source == "direct" and self._io.is_debug():
+                    detail = "<fg=dark_gray>direct</>"
+
+                if detail and self._io.is_verbose():
+                    self._io.write_line(f"{base_line} ({detail})")
+                elif not self._io.is_debug() or detail:
+                    self._io.write_line(base_line)
+
+    def render_message(self, text: str) -> None:
+        self._io.write_line(text)
+
+    def flush(self) -> None:
+        pass

ps/plugin/module/delivery/output/_json.py

@@ -0,0 +1,76 @@
+import json
+from typing import Any
+
+from cleo.io.io import IO
+
+from ._models import DependencyNode, ProjectResolution, PublishWave
+from ._protocol import DeliveryRenderer
+
+
+class JsonDeliveryRenderer(DeliveryRenderer):
+    def __init__(self, io: IO) -> None:
+        self._io = io
+        self._data: dict[str, Any] = {}
+
+    def render_resolution(self, title: str, resolutions: list[ProjectResolution]) -> None:
+        self._data[self._key(title)] = [
+            {
+                "name": r.name,
+                "path": r.path,
+                "version": r.version,
+                "deliver": r.deliver,
+                "pinning": r.pinning,
+                "matched_pattern": r.matched_pattern,
+                "pattern_results": [
+                    {
+                        "pattern": pr.pattern,
+                        "condition": pr.condition,
+                        "condition_matched": pr.condition_matched,
+                        "resolved_raw": pr.resolved_raw,
+                        "matched": pr.matched,
+                        "errors": pr.errors,
+                    }
+                    for pr in r.pattern_results
+                ],
+                "dependencies": [
+                    {
+                        "name": d.name,
+                        "constraint": d.constraint,
+                        "is_project": d.is_project,
+                        "path": d.path,
+                        "source": d.source,
+                    }
+                    for d in r.dependencies
+                ],
+            }
+            for r in resolutions
+        ]
+
+    def render_dependency_tree(self, title: str, roots: list[DependencyNode]) -> None:
+        self._data[self._key(title)] = [self._node_to_dict(n) for n in roots]
+
+    def render_publish_waves(self, title: str, waves: list[PublishWave]) -> None:
+        self._data[self._key(title)] = [
+            {
+                "wave": w.index,
+                "projects": [{"name": p.name, "version": p.version} for p in w.projects],
+            }
+            for w in waves
+        ]
+
+    def render_message(self, text: str) -> None:
+        pass
+
+    def flush(self) -> None:
+        self._io.write_line(json.dumps(self._data, indent=2))
+        self._data = {}
+
+    def _node_to_dict(self, node: DependencyNode) -> dict:
+        result: dict[str, Any] = {"name": node.name, "version": node.version}
+        if node.children:
+            result["children"] = [self._node_to_dict(c) for c in node.children]
+        return result
+
+    @staticmethod
+    def _key(title: str) -> str:
+        return title.lower().replace(" ", "_")

ps/plugin/module/delivery/output/_models.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class VersionPatternResult:
+    pattern: str
+    condition: str = ""
+    condition_matched: Optional[bool] = None
+    resolved_raw: str = ""
+    matched: bool = False
+    errors: list[str] = field(default_factory=list)
+
+
+@dataclass
+class DependencyResolution:
+    name: str
+    constraint: str
+    is_project: bool = False
+    path: str = ""
+    source: str = ""
+
+
+@dataclass
+class ProjectResolution:
+    name: str
+    path: str
+    version: str
+    deliver: str
+    pinning: str = ""
+    matched_pattern: str = ""
+    pattern_results: list[VersionPatternResult] = field(default_factory=list)
+    dependencies: list[DependencyResolution] = field(default_factory=list)
+
+
+@dataclass
+class ProjectSummary:
+    name: str
+    version: str
+    deliver: str
+
+
+@dataclass
+class DependencyNode:
+    name: str
+    version: str
+    children: list["DependencyNode"] = field(default_factory=list)
+
+
+@dataclass
+class PublishWave:
+    index: int
+    projects: list[ProjectSummary] = field(default_factory=list)

ps/plugin/module/delivery/output/_protocol.py

@@ -0,0 +1,22 @@
+from abc import abstractmethod
+from typing import Protocol, runtime_checkable
+
+from ._models import DependencyNode, ProjectResolution, PublishWave
+
+
+@runtime_checkable
+class DeliveryRenderer(Protocol):
+    @abstractmethod
+    def render_resolution(self, title: str, resolutions: list[ProjectResolution]) -> None: ...
+
+    @abstractmethod
+    def render_dependency_tree(self, title: str, roots: list[DependencyNode]) -> None: ...
+
+    @abstractmethod
+    def render_publish_waves(self, title: str, waves: list[PublishWave]) -> None: ...
+
+    @abstractmethod
+    def render_message(self, text: str) -> None: ...
+
+    @abstractmethod
+    def flush(self) -> None: ...