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

package/mcps/davinci-resolve-mcp/package.json

@@ -1,52 +0,0 @@
-{
-  "name": "davinci-resolve-mcp",
-  "version": "2.57.5",
-  "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
-  "license": "MIT",
-  "author": "Samuel Gursky <samgursky@gmail.com>",
-  "homepage": "https://github.com/samuelgursky/davinci-resolve-mcp#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/samuelgursky/davinci-resolve-mcp.git"
-  },
-  "bugs": {
-    "url": "https://github.com/samuelgursky/davinci-resolve-mcp/issues"
-  },
-  "type": "module",
-  "bin": {
-    "davinci-resolve-mcp": "./bin/davinci-resolve-mcp.mjs"
-  },
-  "files": [
-    "bin/",
-    "src/**/*.py",
-    "docs/**/*.md",
-    "docs/reference/resolve_scripting_api.txt",
-    "examples/**/*.md",
-    "scripts/**/*.py",
-    "install.py",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE",
-    "SECURITY.md",
-    "AGENTS.md",
-    "CLAUDE.md"
-  ],
-  "scripts": {
-    "smoke": "node bin/davinci-resolve-mcp.mjs --help && node bin/davinci-resolve-mcp.mjs --version",
-    "pack:check": "npm pack --dry-run"
-  },
-  "keywords": [
-    "davinci-resolve",
-    "resolve",
-    "mcp",
-    "model-context-protocol",
-    "video-editing",
-    "post-production"
-  ],
-  "engines": {
-    "node": ">=18.17"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}

package/mcps/davinci-resolve-mcp/release-notes/v2.22.0.md

@@ -1,51 +0,0 @@
-## v2.22.0
-
-v2.22.0 adds configurable MCP update prompting, conversation-level setup
-defaults, optional timed media-analysis marker writeback, and a read-only
-metadata field inventory for mapping Resolve metadata writeback safely.
-
-### Added
-
-- Added persisted MCP update policies: `prompt`, `auto`, `notify`, and `never`.
-- Added installer update prompts with update now, continue, snooze, ignore,
-  safe auto-update, and disable-check choices.
-- Added Resolve-side update controls:
-  `resolve_control.mcp_update_status`, `set_mcp_update_policy`,
-  `ignore_mcp_update`, `snooze_mcp_update`, and
-  `clear_mcp_update_preferences`.
-- Added the `setup` compound tool for media-analysis defaults and update
-  preferences.
-- Added `media_pool.metadata_field_inventory` for read-only metadata,
-  clip-property, inferred Metadata-panel group, and analysis writeback field
-  mapping.
-- Added optional `media_analysis.publish_clip_metadata` timed marker writeback
-  for slate claps, best moments, and QC warnings.
-- Added `tests/live_metadata_field_inventory_validation.py` for disposable
-  Resolve validation of metadata inventory behavior.
-
-### Changed
-
-- Bumped version surfaces to `2.22.0`.
-- Updated compound tool count to 32 and kernel action count to 136.
-- Documented update policy controls, setup defaults, timed marker choices,
-  metadata field inventory, and live metadata inventory validation.
-- Timed marker writeback now prompts with `yes`, `no`, `default_yes`, and
-  `default_no` when no explicit choice or saved default exists.
-
-### Validation
-
-- `venv/bin/python tests/test_import.py`
-- `venv/bin/python scripts/audit_api_parity.py`
-- `git diff --check`
-- `venv/bin/python -m unittest tests.test_media_analysis tests.test_update_check tests.test_media_pool_ingest_probe`
-- Live validation via connected MCP server on DaVinci Resolve Studio 20.3.2.9
-  with a disposable project and synthetic media only. Verified
-  `metadata_field_inventory`, `MediaPool.ExportMetadata()` header comparison,
-  default analysis writeback field mapping, and `SetMetadata()` readback for
-  analysis and slate fields.
-
-### Notes
-
-- The standalone live metadata inventory harness could not attach to Resolve
-  from this shell, so equivalent validation was run through the already
-  connected MCP process.

package/mcps/davinci-resolve-mcp/release-notes/v2.23.0.md

@@ -1,51 +0,0 @@
-## v2.23.0
-
-v2.23.0 adds the first npm installer, a local control panel, durable
-media-analysis jobs, and a searchable SQLite analysis index while keeping the
-existing Python installer as the source of truth.
-
-### Added
-
-- Added the `davinci-resolve-mcp` npm package and CLI:
-  `setup`, `doctor`, `server`, `control-panel`, `--help`, and `--version`.
-- Added managed per-user npm installs that copy packaged source into a stable
-  application-data directory before running `install.py`.
-- Added the local single-user control panel for Resolve/server status,
-  source-safe media-analysis jobs, analysis search, and preferences.
-- Added durable media-analysis job actions:
-  `start_batch_job`, `run_batch_job_slice`, `batch_job_status`,
-  `list_batch_jobs`, `cancel_batch_job`, and `resume_batch_job`.
-- Added analysis index actions:
-  `build_index`, `index_status`, and `query_index`.
-- Added npm package-content filtering and a GitHub Actions npm publish workflow
-  using OIDC/provenance.
-
-### Changed
-
-- Bumped version surfaces to `2.23.0`.
-- Updated the README quick start to `npx davinci-resolve-mcp setup`.
-- Tightened installer Python validation to require Python 3.10-3.12, matching
-  the documented Resolve scripting compatibility range.
-- Updated release validation to include npm CLI smoke tests and
-  `npm pack --dry-run`.
-- Made the npm publish workflow skip publishing when the package version already
-  exists, so a first manual npm registration can coexist with tag automation.
-
-### Validation
-
-- `venv/bin/python tests/test_import.py`
-- `venv/bin/python scripts/audit_api_parity.py`
-- `venv/bin/python -m unittest tests.test_media_analysis tests.test_update_check tests.test_media_pool_ingest_probe`
-- `npm run smoke`
-- `DAVINCI_RESOLVE_MCP_INSTALL_ROOT=/private/tmp/davinci-resolve-mcp-npm-smoke node bin/davinci-resolve-mcp.mjs setup --dry-run --no-venv --clients manual --update-policy never`
-- `node bin/davinci-resolve-mcp.mjs doctor --update-policy never`
-- `npm pack --dry-run`
-- `git diff --check`
-
-### Notes
-
-- The npm package is npm-only for v1; PyPI remains deferred because
-  `davinci-resolve-mcp` is already owned by another PyPI project.
-- Analysis job and index artifacts remain under the configured
-  `davinci-resolve-mcp-analysis` project root and do not store sampled image
-  bytes in SQLite.

package/mcps/davinci-resolve-mcp/release-notes/v2.23.1.md

@@ -1,35 +0,0 @@
-## v2.23.1
-
-v2.23.1 fixes local control panel navigation regressions introduced around the
-new Projects view and project context dropdown.
-
-### Fixed
-
-- Removed the standalone Projects button from the top navbar; the Projects view
-  is now reached from the project dropdown's `View All Projects` option.
-- Restored the project context dropdown to show only the open/current project
-  context plus `View All Projects`, instead of listing every loadable database
-  project.
-- Changed top-level dropdown triggers for Analysis, Diagnostics, Docs, and
-  Preferences so clicking them only opens the menu. The active view changes only
-  after selecting a dropdown item.
-
-### Changed
-
-- Bumped version surfaces to `2.23.1`.
-- Added regression coverage for the dashboard navigation and project dropdown
-  behavior.
-
-### Validation
-
-- `venv/bin/python tests/test_import.py`
-- `venv/bin/python scripts/audit_api_parity.py`
-- `venv/bin/python -m unittest tests.test_media_analysis.MediaAnalysisPlanningTests.test_dashboard_project_navigation_uses_context_dropdown tests.test_media_analysis.MediaAnalysisPlanningTests.test_dashboard_menu_buttons_open_without_navigation tests.test_media_analysis.MediaAnalysisPlanningTests.test_dashboard_context_switch_scopes_active_project_root_and_related_versions`
-- `node bin/davinci-resolve-mcp.mjs --help`
-- `node bin/davinci-resolve-mcp.mjs --version`
-- `npm pack --dry-run`
-- `git diff --check`
-- Local dashboard smoke check against `127.0.0.1:8765`
-
-No Resolve scripting behavior changed; live Resolve mutation validation was not
-required.

package/mcps/davinci-resolve-mcp/release-notes/v2.24.1.md

@@ -1,32 +0,0 @@
-## v2.24.1
-
-v2.24.1 fixes a CLI bug that caused `npx davinci-resolve-mcp` (with no
-subcommand) to print help text to stdout, which MCP clients then tried to parse
-as JSON-RPC. Reported in
-[#41](https://github.com/samuelgursky/davinci-resolve-mcp/issues/41).
-
-### Fixed
-
-- `bin/davinci-resolve-mcp.mjs` now defaults to the `server` subcommand when
-  invoked with no arguments. Previously the default was `--help`, which wrote
-  usage text to stdout and exited 0; MCP stdio clients (Hermes Agent, Claude
-  Desktop, Cursor, etc.) read that as malformed JSON-RPC, retried three times,
-  then dropped the connection. Existing configs that already pass `server`
-  explicitly are unaffected. Explicit `--help`, `-h`, `help`, `--version`, and
-  `-v` continue to print to stdout as before.
-
-### Changed
-
-- Bumped version surfaces to `2.24.1`.
-
-### Validation
-
-- `venv/bin/python tests/test_import.py`
-- `venv/bin/python scripts/audit_api_parity.py`
-- `node bin/davinci-resolve-mcp.mjs --help`
-- `node bin/davinci-resolve-mcp.mjs --version`
-- `npm pack --dry-run`
-- `git diff --check`
-
-No Resolve scripting behavior changed; live Resolve mutation validation was not
-required.

package/mcps/davinci-resolve-mcp/scripts/audit_api_parity.py

@@ -1,275 +0,0 @@
-#!/usr/bin/env python3
-"""API-docs-vs-source parity guard for davinci-resolve-mcp.
-
-Catches three regressions that have shipped in past releases:
-
-1. **Broken imports** — `from api.X import Y` patterns that crash on first call
-   (the bug class fixed in v2.3.2 by removing 25 broken granular tools).
-2. **Undocumented Resolve methods** — wrappers around methods that don't appear
-   in `docs/reference/resolve_scripting_api.txt` (the bug class fixed in v2.3.2/v2.3.3
-   by removing wrappers for ExportProjectToCloud, AddUserToCloudProject, etc.).
-3. **Documented methods missing from both layers** — Resolve API methods that
-   are documented but exposed neither in compound (`src/server.py`) nor
-   granular (`src/granular/*.py`).
-
-Exit codes: 0 if no issues, 1 if any check fails.
-
-Run: `python3 scripts/audit_api_parity.py`
-"""
-
-from __future__ import annotations
-
-import re
-import sys
-from pathlib import Path
-from typing import Dict, List, Set, Tuple
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-DOCS_PATH = REPO_ROOT / "docs" / "reference" / "resolve_scripting_api.txt"
-SERVER_PATH = REPO_ROOT / "src" / "server.py"
-GRANULAR_DIR = REPO_ROOT / "src" / "granular"
-
-# Class-prefixed methods like Resolve.OpenPage are split into class+method when
-# we extract; the class name comes from the section heading above the method.
-CLASS_HEADING_RE = re.compile(r"^([A-Z][A-Za-z]+)\s*$")
-METHOD_RE = re.compile(r"^\s+([A-Z][A-Za-z0-9_]+)\s*\(")
-
-# Methods to ignore in the "missing from both layers" check. These are either:
-# - intrinsic Python object methods we don't want to wrap
-# - methods that exist on multiple classes where one exposure is enough
-# - methods that are documented but optional on older Resolve builds
-IGNORE_METHODS: Set[str] = set()
-
-
-def parse_documented_methods(docs_path: Path) -> Dict[str, Set[str]]:
-    """Return {class_name: {method_name, ...}}. Skips:
-    - standalone sections like 'Cache Mode information' that aren't class headings
-    - everything after the 'Deprecated Resolve API Functions' marker
-    - everything after the 'Unsupported Resolve API Functions' marker
-    """
-    classes: Dict[str, Set[str]] = {}
-    current_class: str | None = None
-    text = docs_path.read_text()
-    # Truncate at the first deprecation marker
-    for marker in ("\nDeprecated Resolve API Functions",
-                   "\nUnsupported Resolve API Functions"):
-        idx = text.find(marker)
-        if idx != -1:
-            text = text[:idx]
-    for line in text.splitlines():
-        if not line.strip():
-            continue
-        if not line.startswith(" "):
-            m = CLASS_HEADING_RE.match(line)
-            if m:
-                # Heuristic: class headings are short single words, not section
-                # titles like "Looking up Render Settings"
-                candidate = m.group(1)
-                if len(candidate.split()) == 1:
-                    current_class = candidate
-                    classes.setdefault(current_class, set())
-                else:
-                    current_class = None
-            continue
-        if current_class is None:
-            continue
-        mm = METHOD_RE.match(line)
-        if mm:
-            classes[current_class].add(mm.group(1))
-    return classes
-
-
-def collect_source_text() -> str:
-    """Concatenate every Python file under src/ for substring searches."""
-    parts: List[str] = []
-    for py_path in (REPO_ROOT / "src").rglob("*.py"):
-        if "__pycache__" in py_path.parts:
-            continue
-        try:
-            parts.append(py_path.read_text())
-        except (OSError, UnicodeDecodeError):
-            continue
-    return "\n".join(parts)
-
-
-def find_broken_api_imports() -> List[Tuple[Path, int, str]]:
-    """Find any `from api.X import Y` lines (the v2.3.2 bug class)."""
-    hits: List[Tuple[Path, int, str]] = []
-    pattern = re.compile(r"^\s*from\s+api\.\w+\s+import\s+")
-    for py_path in (REPO_ROOT / "src").rglob("*.py"):
-        if "__pycache__" in py_path.parts:
-            continue
-        try:
-            for i, line in enumerate(py_path.read_text().splitlines(), 1):
-                if pattern.search(line):
-                    hits.append((py_path.relative_to(REPO_ROOT), i, line.strip()))
-        except (OSError, UnicodeDecodeError):
-            continue
-    return hits
-
-
-def find_methods_missing_from_source(
-    docs: Dict[str, Set[str]],
-    source_text: str,
-) -> Dict[str, Set[str]]:
-    """For each class.method documented in the API, return those whose
-    method name does not appear in any src/*.py file at all.
-
-    This is a coarse check (substring match) — it will not catch overload gaps
-    or incomplete dict-key forwarding. Those are checked separately at
-    development time, not in CI.
-    """
-    missing: Dict[str, Set[str]] = {}
-    for cls, methods in docs.items():
-        for method in methods:
-            if method in IGNORE_METHODS:
-                continue
-            # A simple but effective signal: look for ".MethodName(" anywhere
-            # in src/. Compound dispatchers and granular wrappers both call
-            # `obj.MethodName(...)` — so this catches both layers in one pass.
-            if f".{method}(" not in source_text:
-                missing.setdefault(cls, set()).add(method)
-    return missing
-
-
-# Methods that ARE real Resolve API surface but are documented elsewhere
-# (Fusion compositing API, UIManager, internal type-discrimination helpers).
-# These should NOT be flagged as suspicious even though they don't appear
-# in docs/reference/resolve_scripting_api.txt.
-ALLOWLIST_UNDOCUMENTED: Set[str] = {
-    # Fusion API (documented in Blackmagic's Fusion scripting docs, not in
-    # the Resolve scripting README that ships alongside Resolve)
-    "AddTool", "FindTool", "GetTool", "GetToolList", "Delete", "GetAttrs",
-    "SetAttrs", "GetCurrentComp", "GetInput", "GetInputList", "GetOutput",
-    "GetOutputList", "GetConnectedOutput", "SetInput", "GetKeyFrames",
-    "AddKeyframe", "DeleteKeyframe", "ModifyKeyframe", "RemoveKeyFrame",
-    "GetKeyframeAtIndex", "GetKeyframeCount", "GetPropertyAtKeyframeIndex",
-    "SetKeyframeInterpolation", "Render", "StartUndo",
-    # UIManager / Resolve app-control API (documented under UIManager, not
-    # the main Resolve scripting README)
-    "GetUIManager", "OpenPreferences", "SetHighPriority",
-    "OpenProjectSettings", "LoadUILayout", "SaveUILayout",
-    # Lua-table iteration helper used as a fallback in object_inspection.py
-    "GetKeyList",
-    # Project metadata accessor used defensively (hasattr-guarded)
-    "GetPath",
-    # GetRenderSettings: documented inverse of SetRenderSettings; the docs
-    # only show SetRenderSettings explicitly but Resolve exposes the getter.
-    "GetRenderSettings",
-    # Internal type-discrimination helpers used as guards inside tools
-    # (not exposed as user-facing wrappers themselves)
-    "GetType", "GetMediaType",
-}
-
-
-def find_undocumented_method_wrappers(
-    docs: Dict[str, Set[str]],
-    source_text: str,
-) -> List[Tuple[str, str, int]]:
-    """Find calls to .MethodName( in source where MethodName is NOT documented
-    in any class of the API docs and not in the allowlist. Likely candidates
-    for removal.
-
-    Skips: dunder methods, common Python builtins, snake_case methods (which
-    aren't Resolve API), and methods whose names overlap with stdlib/MCP.
-    """
-    documented: Set[str] = set()
-    for methods in docs.values():
-        documented.update(methods)
-    documented |= ALLOWLIST_UNDOCUMENTED
-
-    skip_prefixes = ("Get", "Set", "Is", "Has", "Add", "Delete", "Create", "Update",
-                     "Load", "Save", "Open", "Close", "Start", "Stop", "Import",
-                     "Export", "Append", "Remove", "Move", "Copy", "Insert",
-                     "Replace", "Find", "Reset", "Refresh", "Reveal", "Restore",
-                     "Convert", "Detect", "Apply", "Render", "Transcribe", "Clear",
-                     "Link", "Unlink", "Relink", "Sync", "Make", "Build", "Run",
-                     "Generate", "Cancel", "Pause", "Resume", "Process", "Execute",
-                     "Validate", "Initialize", "Quit", "Show", "Hide", "Mark",
-                     "Auto", "Switch", "Assign", "Monitor", "Disable", "Enable",
-                     "Modify", "Duplicate", "Merge", "Split", "Trim", "Slip",
-                     "Slide", "Scale", "Rotate", "Flip", "Crop")
-
-    # Find every .MethodName( call site
-    call_pattern = re.compile(r"\.([A-Z][A-Za-z0-9_]+)\(")
-    suspicious: List[Tuple[str, str, int]] = []
-    seen: Set[str] = set()
-
-    for py_path in (REPO_ROOT / "src").rglob("*.py"):
-        if "__pycache__" in py_path.parts:
-            continue
-        try:
-            for i, line in enumerate(py_path.read_text().splitlines(), 1):
-                for m in call_pattern.finditer(line):
-                    name = m.group(1)
-                    if name in documented or name in seen:
-                        continue
-                    if not any(name.startswith(p) for p in skip_prefixes):
-                        continue
-                    seen.add(name)
-                    suspicious.append((str(py_path.relative_to(REPO_ROOT)), name, i))
-        except (OSError, UnicodeDecodeError):
-            continue
-    return suspicious
-
-
-def main() -> int:
-    if not DOCS_PATH.exists():
-        print(f"FAIL: API docs not found at {DOCS_PATH}", file=sys.stderr)
-        return 1
-
-    docs = parse_documented_methods(DOCS_PATH)
-    source_text = collect_source_text()
-
-    failures = 0
-
-    print("=" * 70)
-    print("Check 1: broken `from api.X import` imports (v2.3.2 bug class)")
-    print("=" * 70)
-    broken = find_broken_api_imports()
-    if broken:
-        for path, line_no, snippet in broken:
-            print(f"  FAIL {path}:{line_no}  {snippet}")
-        failures += len(broken)
-    else:
-        print("  OK — no broken api.* imports")
-
-    print()
-    print("=" * 70)
-    print("Check 2: documented methods missing from source")
-    print("=" * 70)
-    missing = find_methods_missing_from_source(docs, source_text)
-    if missing:
-        for cls in sorted(missing):
-            for m in sorted(missing[cls]):
-                print(f"  MISSING {cls}.{m}")
-                failures += 1
-    else:
-        print("  OK — every documented method appears somewhere in src/")
-
-    print()
-    print("=" * 70)
-    print("Check 3: wrappers calling undocumented Resolve methods (advisory)")
-    print("=" * 70)
-    suspicious = find_undocumented_method_wrappers(docs, source_text)
-    if suspicious:
-        # Advisory only — these may legitimately be helper methods on non-Resolve
-        # objects (e.g., MCP framework, FastMCP). Print but do not count as failure.
-        for path, name, line in sorted(set(suspicious))[:30]:
-            print(f"  REVIEW {path}:{line}  .{name}(")
-        if len(suspicious) > 30:
-            print(f"  ... and {len(suspicious) - 30} more (advisory only)")
-    else:
-        print("  OK — no suspicious method calls")
-
-    print()
-    print("=" * 70)
-    if failures:
-        print(f"FAIL — {failures} parity issue(s) found")
-        return 1
-    print("PASS — all checks clean")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/mcps/davinci-resolve-mcp/scripts/audit_readwrite_symmetry.py

@@ -1,80 +0,0 @@
-#!/usr/bin/env python3
-"""Audit read/write symmetry across the compound server's action surface.
-
-For every mutating action (set_/add_/clear_/enable_/...) it checks whether a
-matching read action (get_/list_/...) exists on the same tool, and reports the
-asymmetries. The goal is to find write-without-read gaps before users have to —
-the repeatable feature-discovery method behind R5.
-
-Reads the `_unknown(action, [...])` lists in src/server.py, which enumerate every
-action a tool accepts. Prints a markdown report.
-"""
-import ast
-import os
-import re
-import sys
-
-ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-SERVER = os.path.join(ROOT, "src", "server.py")
-
-READ_PREFIXES = ("get_", "list_", "probe_", "is_", "has_", "find_")
-# `set_` is the high-signal class: a set with no get is a genuine readback gap.
-# create_/add_/insert_/import_ are inherently writes that usually have no paired
-# read of the same noun, so they're reported separately as low-signal.
-HIGH_SIGNAL = ("set_",)
-LOW_SIGNAL = ("add_", "create_", "insert_", "apply_", "import_")
-
-
-def _action_lists(src: str):
-    """Yield lists of action-name string literals from each _unknown(action, [...])."""
-    for m in re.finditer(r"_unknown\(action,\s*\[(.*?)\]\)", src, re.DOTALL):
-        names = re.findall(r'"([a-z][a-z0-9_]*)"', m.group(1))
-        if names:
-            yield names
-
-
-def _has_read(stem: str, aset: set) -> bool:
-    # Match get_<stem>, list_<stem>, and plural get_<stem>s (e.g. add_keyframe -> get_keyframes).
-    candidates = {rp + stem for rp in READ_PREFIXES}
-    candidates |= {rp + stem + "s" for rp in READ_PREFIXES}
-    candidates |= {rp + stem.rstrip("s") for rp in READ_PREFIXES}
-    return bool(candidates & aset)
-
-
-def audit(src: str):
-    high, low, covered, total = set(), set(), 0, 0
-    for actions in _action_lists(src):
-        aset = set(actions)
-        for a in actions:
-            for wp in HIGH_SIGNAL + LOW_SIGNAL:
-                if a.startswith(wp):
-                    total += 1
-                    stem = a[len(wp):]
-                    if _has_read(stem, aset):
-                        covered += 1
-                    elif wp in HIGH_SIGNAL:
-                        high.add(a)
-                    else:
-                        low.add(a)
-                    break
-    return total, covered, sorted(high), sorted(low)
-
-
-def main():
-    src = open(SERVER, encoding="utf-8").read()
-    total, covered, high, low = audit(src)
-    print("# Read/Write Symmetry Audit\n")
-    print(f"- write-style actions scanned: **{total}**")
-    print(f"- with a matching read: **{covered}**")
-    print(f"- `set_` actions with no `get_`/`list_` (real readback gaps): **{len(high)}**\n")
-    if high:
-        print("## High-signal gaps — `set_` with no read counterpart\n")
-        for a in high:
-            print(f"- `{a}`")
-    print(f"\n## Low-signal (create/add/insert/import — usually expected): {len(low)}\n")
-    print(", ".join(f"`{a}`" for a in low))
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())