rdc-cli 0.2.0__py3-none-any.whl

rdc/discover.py

@@ -0,0 +1,84 @@
+"""Renderdoc module discovery.
+
+Searches for the renderdoc Python module in standard locations
+and returns the imported module if found and ABI-compatible.
+"""
+
+from __future__ import annotations
+
+import importlib
+import logging
+import os
+import shutil
+import sys
+from pathlib import Path
+from types import ModuleType
+
+log = logging.getLogger(__name__)
+
+_SYSTEM_PATHS = [
+    "/usr/lib/renderdoc",
+    "/usr/local/lib/renderdoc",
+]
+
+
+def find_renderdoc() -> ModuleType | None:
+    """Discover and import the renderdoc module.
+
+    Search order:
+        1. ``RENDERDOC_PYTHON_PATH`` environment variable
+        2. System paths (``/usr/lib/renderdoc``, ``/usr/local/lib/renderdoc``)
+        3. Sibling directory of ``renderdoccmd`` on PATH
+    """
+    candidates: list[str] = []
+
+    env_path = os.environ.get("RENDERDOC_PYTHON_PATH")
+    if env_path:
+        candidates.append(env_path)
+
+    candidates.extend(_SYSTEM_PATHS)
+
+    cmd = shutil.which("renderdoccmd")
+    if cmd:
+        candidates.append(str(Path(cmd).resolve().parent))
+
+    # Try already-importable module first (e.g. site-packages)
+    mod = _try_import()
+    if mod is not None:
+        return mod
+
+    for path in candidates:
+        if not Path(path).is_dir():
+            continue
+        mod = _try_import_from(path)
+        if mod is not None:
+            return mod
+
+    return None
+
+
+def _try_import() -> ModuleType | None:
+    """Try bare import without path manipulation."""
+    try:
+        return importlib.import_module("renderdoc")
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _try_import_from(directory: str) -> ModuleType | None:
+    """Add *directory* to sys.path, attempt import, clean up on failure.
+
+    On success the directory stays in sys.path so that subsequent
+    ``import renderdoc`` calls succeed.  On failure it is removed.
+    """
+    if directory in sys.path:
+        return _try_import()
+
+    sys.path.insert(0, directory)
+    try:
+        mod = importlib.import_module("renderdoc")
+    except Exception:  # noqa: BLE001
+        sys.path.pop(0)
+        return None
+    log.debug("renderdoc found at %s", directory)
+    return mod

rdc/formatters/json_fmt.py

@@ -0,0 +1,20 @@
+"""JSON and JSONL output formatters for rdc-cli."""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any, TextIO
+
+
+def write_json(data: Any, *, out: TextIO | None = None, indent: int = 2) -> None:
+    """Write data as formatted JSON to the given output stream."""
+    dest = out or sys.stdout
+    dest.write(json.dumps(data, default=str, indent=indent) + "\n")
+
+
+def write_jsonl(rows: list[dict[str, Any]], *, out: TextIO | None = None) -> None:
+    """Write rows as JSONL (one JSON object per line)."""
+    dest = out or sys.stdout
+    for row in rows:
+        dest.write(json.dumps(row, default=str) + "\n")

rdc/formatters/tsv.py

@@ -0,0 +1,60 @@
+"""TSV output formatter for rdc-cli.
+
+All list commands output tab-separated values with optional header row.
+Numbers are always raw (e.g. 1200000 not 1.2M). Empty fields are '-'.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any, TextIO
+
+
+def escape_field(value: Any) -> str:
+    """Escape a field value for TSV output.
+
+    Rules:
+    - None or empty string → '-'
+    - Tabs → '\\t'
+    - Newlines → '\\n'
+    - Everything else → str(value)
+    """
+    if value is None:
+        return "-"
+    s = str(value)
+    if not s:
+        return "-"
+    return s.replace("\t", "\\t").replace("\n", "\\n")
+
+
+def format_row(fields: list[Any]) -> str:
+    """Format a single TSV row."""
+    return "\t".join(escape_field(f) for f in fields)
+
+
+def write_tsv(
+    rows: list[list[Any]],
+    *,
+    header: list[str] | None = None,
+    no_header: bool = False,
+    out: TextIO | None = None,
+) -> None:
+    """Write rows as TSV to the given output stream.
+
+    Args:
+        rows: List of rows, each row is a list of field values.
+        header: Column names for the header row.
+        no_header: If True, skip the header row even if provided.
+        out: Output stream. Defaults to sys.stdout.
+    """
+    dest = out or sys.stdout
+    if header and not no_header:
+        dest.write(format_row(header) + "\n")
+    for row in rows:
+        dest.write(format_row(row) + "\n")
+
+
+def write_footer(message: str, err: TextIO | None = None) -> None:
+    """Write a footer/summary line to stderr."""
+    dest = err or sys.stderr
+    dest.write(message + "\n")

rdc/protocol.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class JsonRpcRequest:
+    jsonrpc: str
+    method: str
+    id: int
+    params: dict[str, Any] | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "jsonrpc": self.jsonrpc,
+            "method": self.method,
+            "id": self.id,
+        }
+        if self.params is not None:
+            payload["params"] = self.params
+        return payload
+
+
+def _request(method: str, request_id: int, params: dict[str, Any] | None = None) -> JsonRpcRequest:
+    if request_id < 0:
+        raise ValueError("request id must be >= 0")
+    return JsonRpcRequest(jsonrpc="2.0", method=method, id=request_id, params=params)
+
+
+def ping_request(token: str, request_id: int = 1) -> dict[str, Any]:
+    return _request("ping", request_id, {"_token": token}).to_dict()
+
+
+def status_request(token: str, request_id: int = 1) -> dict[str, Any]:
+    return _request("status", request_id, {"_token": token}).to_dict()
+
+
+def goto_request(token: str, eid: int, request_id: int = 1) -> dict[str, Any]:
+    return _request("goto", request_id, {"_token": token, "eid": eid}).to_dict()
+
+
+def shutdown_request(token: str, request_id: int = 1) -> dict[str, Any]:
+    return _request("shutdown", request_id, {"_token": token}).to_dict()
+
+
+def count_request(
+    token: str,
+    what: str,
+    *,
+    pass_name: str | None = None,
+    request_id: int = 1,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {"_token": token, "what": what}
+    if pass_name is not None:
+        params["pass"] = pass_name
+    return _request("count", request_id, params).to_dict()
+
+
+def shader_map_request(token: str, request_id: int = 1) -> dict[str, Any]:
+    return _request("shader_map", request_id, {"_token": token}).to_dict()

rdc/services/__init__.py

@@ -0,0 +1 @@
+"""Service layer for rdc-cli."""