yolop 0.14.0

Yolop — a terminal coding agent built on everruns-runtime
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#!/usr/bin/env python3
"""Print publishable workspace crates in dependency-first order for yolop.

The order is derived from Cargo metadata rather than duplicated in the release
workflow, so adding a new in-workspace dependency cannot silently omit it from
publishing.
"""

from __future__ import annotations

import json
import subprocess
from collections.abc import Mapping, Sequence
from typing import Any


def load_metadata() -> Mapping[str, Any]:
    output = subprocess.check_output(
        ["cargo", "metadata", "--no-deps", "--format-version", "1"], text=True
    )
    return json.loads(output)


def publish_order(metadata: Mapping[str, Any], root_name: str = "yolop") -> list[str]:
    packages = {
        package["name"]: package
        for package in metadata["packages"]
        if package["id"] in metadata["workspace_members"]
    }
    if root_name not in packages:
        raise ValueError(f"workspace package {root_name!r} not found")

    ordered: list[str] = []
    visiting: set[str] = set()
    visited: set[str] = set()

    def visit(name: str) -> None:
        if name in visited:
            return
        if name in visiting:
            raise ValueError(f"workspace dependency cycle involving {name}")
        visiting.add(name)
        package = packages[name]
        dependencies: Sequence[Mapping[str, Any]] = package.get("dependencies", [])
        for dependency in dependencies:
            dependency_name = dependency["name"]
            if dependency.get("path") and dependency_name in packages:
                visit(dependency_name)
        visiting.remove(name)
        visited.add(name)
        if package.get("publish") != []:
            ordered.append(name)

    # Visit every publishable workspace package, including independent
    # first-party extensions that are not dependencies of the yolop binary.
    # Keep the root package last so a release publishes supporting packages
    # before the primary binary.
    for name in sorted(packages):
        if name != root_name:
            visit(name)
    visit(root_name)
    return ordered


def main() -> None:
    for crate in publish_order(load_metadata()):
        print(crate)


if __name__ == "__main__":
    main()