davinci-resolve-mcp 2.23.0

package/src/utils/timeline_kernel_probe.py

@@ -0,0 +1,185 @@
+"""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/src/utils/timeline_title_text.py

@@ -0,0 +1,87 @@
+"""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>"
+    )