@hybridlabor-api/aos 4.4.0 → 4.4.2-beta.0

package/mcps/davinci-resolve-mcp/src/utils/timeline_kernel_probe.py

@@ -1,185 +0,0 @@
-"""Helpers for timeline edit kernel capability probe reports."""
-
-from __future__ import annotations
-
-from collections import Counter
-from datetime import datetime, timezone
-import json
-import re
-from typing import Any, Dict, Iterable, List, Optional
-
-
-PROBE_STATUSES = {
-    "supported",
-    "partially_supported",
-    "read_only",
-    "write_only_unverifiable",
-    "version_or_page_dependent",
-    "unsupported",
-    "not_applicable",
-    "error",
-}
-
-
-def utc_timestamp() -> str:
-    return datetime.now(timezone.utc).isoformat(timespec="seconds")
-
-
-def parse_timeline_item_property_keys(api_text: str) -> List[str]:
-    """Return documented TimelineItem GetProperty/SetProperty keys in doc order."""
-    start_marker = "The supported keys with their accepted values are:"
-    end_marker = "Values beyond the range will be clipped"
-    start = api_text.find(start_marker)
-    if start < 0:
-        return []
-    end = api_text.find(end_marker, start)
-    section = api_text[start:end if end >= 0 else None]
-    keys: List[str] = []
-    for match in re.finditer(r'^\s+"([^"]+)"\s*:', section, flags=re.MULTILINE):
-        key = match.group(1)
-        if key not in keys:
-            keys.append(key)
-    return keys
-
-
-def parse_api_class_methods(api_text: str, class_name: str) -> List[str]:
-    """Return method names documented under a top-level API class section."""
-    lines = api_text.splitlines()
-    start_index: Optional[int] = None
-    for index, line in enumerate(lines):
-        if line.strip() == class_name:
-            start_index = index + 1
-            break
-    if start_index is None:
-        return []
-
-    methods: List[str] = []
-    for line in lines[start_index:]:
-        stripped = line.strip()
-        if stripped and not line.startswith(" ") and re.fullmatch(r"[A-Za-z][A-Za-z0-9_]*", stripped):
-            break
-        match = re.match(r"\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(", line)
-        if match:
-            method = match.group(1)
-            if method not in methods:
-                methods.append(method)
-    return methods
-
-
-def ordered_unique(values: Iterable[str]) -> List[str]:
-    out: List[str] = []
-    for value in values:
-        if value not in out:
-            out.append(value)
-    return out
-
-
-def values_match(actual: Any, expected: Any) -> bool:
-    if isinstance(expected, bool):
-        return bool(actual) is expected
-    try:
-        return abs(float(actual) - float(expected)) <= 0.001
-    except (TypeError, ValueError):
-        return actual == expected
-
-
-class ProbeRecorder:
-    """Collects normalized capability probe records and renders reports."""
-
-    def __init__(self) -> None:
-        self.records: List[Dict[str, Any]] = []
-
-    def record(
-        self,
-        category: str,
-        name: str,
-        status: str,
-        *,
-        details: Optional[Dict[str, Any]] = None,
-        evidence: Optional[Any] = None,
-    ) -> Dict[str, Any]:
-        if status not in PROBE_STATUSES:
-            raise ValueError(f"unknown probe status: {status}")
-        item = {
-            "category": category,
-            "name": name,
-            "status": status,
-            "details": details or {},
-        }
-        if evidence is not None:
-            item["evidence"] = evidence
-        self.records.append(item)
-        return item
-
-    def record_exception(self, category: str, name: str, exc: Exception, *, details: Optional[Dict[str, Any]] = None):
-        payload = dict(details or {})
-        payload["exception"] = repr(exc)
-        return self.record(category, name, "error", details=payload)
-
-    def counts(self) -> Dict[str, int]:
-        counts = Counter(record["status"] for record in self.records)
-        return {status: counts.get(status, 0) for status in sorted(PROBE_STATUSES)}
-
-    def to_report(self, metadata: Dict[str, Any], artifacts: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        return {
-            "metadata": metadata,
-            "artifacts": artifacts or {},
-            "counts": self.counts(),
-            "records": self.records,
-        }
-
-
-def render_markdown_report(report: Dict[str, Any]) -> str:
-    metadata = report.get("metadata", {})
-    counts = report.get("counts", {})
-    records = report.get("records", [])
-    artifacts = report.get("artifacts", {})
-
-    title = metadata.get("title", "Timeline Edit Kernel Capability Probe")
-
-    lines = [
-        f"# {title}",
-        "",
-        "## Run",
-        "",
-        f"- Timestamp: `{metadata.get('timestamp_utc', '')}`",
-        f"- Resolve: `{metadata.get('product', '')} {metadata.get('version_string', '')}`",
-        f"- Python: `{metadata.get('python', '')}`",
-        f"- Platform: `{metadata.get('platform', '')}`",
-        f"- Project: `{metadata.get('project_name', '')}`",
-        "",
-        "## Counts",
-        "",
-    ]
-    for status in sorted(PROBE_STATUSES):
-        lines.append(f"- `{status}`: {counts.get(status, 0)}")
-
-    if artifacts:
-        lines.extend(["", "## Artifacts", ""])
-        for key, value in artifacts.items():
-            lines.append(f"- `{key}`: `{value}`")
-
-    by_category: Dict[str, List[Dict[str, Any]]] = {}
-    for record in records:
-        by_category.setdefault(record["category"], []).append(record)
-
-    lines.extend(["", "## Records", ""])
-    for category in sorted(by_category):
-        lines.extend([f"### {category}", ""])
-        lines.append("| Name | Status | Notes |")
-        lines.append("|---|---:|---|")
-        for record in by_category[category]:
-            details = record.get("details", {})
-            note_parts = []
-            for key in ("reason", "read", "write", "readback", "restore", "page", "item_type"):
-                if key in details:
-                    note_parts.append(f"{key}={json.dumps(details[key], default=str)}")
-            if not note_parts and details:
-                note_parts.append(json.dumps(details, default=str, sort_keys=True)[:220])
-            notes = "; ".join(note_parts).replace("|", "\\|")
-            lines.append(
-                f"| `{record['name']}` | `{record['status']}` | {notes} |"
-            )
-        lines.append("")
-
-    return "\n".join(lines).rstrip() + "\n"

package/mcps/davinci-resolve-mcp/src/utils/timeline_title_text.py

@@ -1,87 +0,0 @@
-"""Helpers for Edit-page Text+ / generator text via undocumented TimelineItem.GetProperty keys."""
-
-from __future__ import annotations
-
-from typing import Any, Callable, Dict, List, Optional, Tuple
-
-TITLE_TEXT_KEY_HINTS = (
-    "styled text",
-    "styledtext",
-    "text+",
-    "rich text",
-    "caption",
-    "subtitle",
-)
-
-
-def flatten_timeline_item_properties(props: Any) -> Dict[str, Any]:
-    if props is None:
-        return {}
-    if isinstance(props, dict):
-        return {str(k): v for k, v in props.items()}
-    return {}
-
-
-def timeline_item_get_property_map(
-    item: Any, serialize_fn: Callable[[Any], Any]
-) -> Tuple[Dict[str, Any], Optional[str]]:
-    last_err: Optional[str] = None
-    saw_empty_success = False
-    for getter in (lambda: item.GetProperty(), lambda: item.GetProperty("")):
-        try:
-            raw = getter()
-        except TypeError:
-            continue
-        except Exception as exc:
-            last_err = str(exc)
-            continue
-        flat = flatten_timeline_item_properties(serialize_fn(raw))
-        if flat:
-            return flat, None
-        saw_empty_success = True
-    return {}, None if saw_empty_success else last_err or "GetProperty failed"
-
-
-def candidate_title_property_keys(flat: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """Prefer dict keys that may hold Text+ / generator rich text (not in public API docs)."""
-    candidates: List[Dict[str, Any]] = []
-    for key, value in flat.items():
-        if not isinstance(value, str):
-            continue
-        stripped = value.strip()
-        if not stripped:
-            continue
-        lk = key.lower()
-        score = 0
-        for hint in TITLE_TEXT_KEY_HINTS:
-            if hint in lk:
-                score += 10
-        if stripped.startswith("<?xml") or ("<" in stripped and ">" in stripped):
-            score += 5
-        if lk == "text":
-            score += 8
-        if score > 0 or len(stripped) > 24:
-            preview = stripped[:200] + ("…" if len(stripped) > 200 else "")
-            candidates.append({"key": key, "score": score, "value_preview": preview})
-    candidates.sort(key=lambda row: (-row["score"], row["key"]))
-    return candidates
-
-
-def escape_xml_text_body(s: str) -> str:
-    return (
-        s.replace("&", "&amp;")
-        .replace("<", "&lt;")
-        .replace(">", "&gt;")
-        .replace('"', "&quot;")
-    )
-
-
-def plain_to_minimal_styled_xml(plain: str) -> str:
-    """Best-effort Text+ styled payload when only plain copy is available; Resolve may normalize."""
-    body = escape_xml_text_body(plain)
-    return (
-        '<?xml version="1.0" encoding="UTF-8"?>'
-        "<StyledElement>"
-        f"<Paragraph><TextRun>{body}</TextRun></Paragraph>"
-        "</StyledElement>"
-    )