File size: 4,877 Bytes
90cd4d1 | 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 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 | """AgentArk task catalog compatibility and selection (standard library only).
A task's labeled env_version is its minimum supported environment version.
All later environment versions are supported by project policy. This is not
a statement that every task has been executed on every later environment.
"""
import argparse
import json
import re
from pathlib import Path
COMPATIBILITY_POLICY = {
"id": "minimum-env-version-v1",
"rule": "environment_version >= min_env_version",
"minimum_field": "min_env_version",
"legacy_minimum_field": "env_version",
"specifier_field": "env_version_spec",
"forward_compatible": True,
"version_comparison": "numeric dotted components; missing components are zero",
"compatible_env_versions_semantics": "known published compatible versions; not exhaustive and not a test matrix",
"validation_semantics": "existing validation fields and evidence describe actual tests only",
"requirements_semantics": "platform and separately declared wrapper/capability requirements still apply",
}
def version_key(value: str) -> tuple[int, ...]:
"""Compare 1.0.10 numerically; regard 1.0 and 1.0.0 as equal."""
if not isinstance(value, str) or not re.fullmatch(r"\d+(?:\.\d+)*", value):
raise ValueError(f"Expected a numeric dotted environment version, got {value!r}")
parts = [int(part) for part in value.split(".")]
while len(parts) > 1 and parts[-1] == 0:
parts.pop()
return tuple(parts)
def minimum_env_version(row: dict) -> str:
labeled = row["env_version"]
minimum = row.get("min_env_version", labeled)
if version_key(minimum) != version_key(labeled):
raise ValueError(f"Minimum contradicts labeled env_version for {row.get('path', row.get('task_id'))}")
return minimum
def supports_environment(row: dict, env_version: str) -> bool:
return version_key(env_version) >= version_key(minimum_env_version(row))
def normalize_task(row: dict, published_env_versions) -> dict:
"""Add range metadata without altering artifact identity or test evidence."""
minimum = minimum_env_version(row)
known = set(published_env_versions) | set(row.get("compatible_env_versions", [])) | {minimum}
for version in known:
version_key(version)
compatible = sorted((v for v in known if supports_environment(row, v)), key=lambda v: (version_key(v), v))
return {
**row,
"min_env_version": minimum,
"env_version_spec": f">={minimum}",
"env_compatibility_policy": COMPATIBILITY_POLICY["id"],
"compatible_env_versions": compatible,
}
def select_tasks(rows: list[dict], env_version: str, platform: str | None = None,
task_ids: set[int] | None = None) -> list[dict]:
"""Latest compatible task version per task/platform; no downloads or install.
An unsupported new task version must not hide an older compatible version.
Separately declared requirements are returned intact for the caller to honor.
"""
version_key(env_version)
selected = {}
def rank(row):
task_version = row["task_version"]
if task_version.startswith("v"):
task_version = task_version[1:]
return version_key(task_version), version_key(minimum_env_version(row)), row["path"]
for row in rows:
if platform is not None and row["platform"] != platform:
continue
if task_ids is not None and int(row["task_id"]) not in task_ids:
continue
if not supports_environment(row, env_version):
continue
key = (int(row["task_id"]), row["platform"])
if key not in selected or rank(row) > rank(selected[key]):
selected[key] = row
return [selected[key] for key in sorted(selected)]
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--registry", type=Path, required=True, help="Downloaded registry/tasks.jsonl")
parser.add_argument("--env-version", required=True)
parser.add_argument("--platform", choices=("windows", "linux"))
parser.add_argument("--task-id", type=int, action="append", help="Repeat to select multiple task IDs")
args = parser.parse_args()
rows = [json.loads(line) for line in args.registry.read_text(encoding="utf-8-sig").splitlines() if line.strip()]
try:
selected = select_tasks(rows, args.env_version, args.platform, set(args.task_id) if args.task_id else None)
if args.task_id and {int(r["task_id"]) for r in selected} != set(args.task_id):
parser.error("At least one requested task has no compatible artifact for this environment/platform")
except (ValueError, KeyError) as exc:
parser.error(str(exc))
for row in selected:
print(json.dumps(row, ensure_ascii=False, sort_keys=True))
if __name__ == "__main__":
main()
|