qubicl-cli 0.1.0-dev.0 → 0.1.0

package/dist/assets/computer/skills/core/powerpoint/scripts/pptx_render.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Render every slide of a .pptx to per-slide PNG images.
+
+Pipeline: LibreOffice (soffice --headless --convert-to pdf) turns the deck
+into a PDF, then poppler (pdftoppm, or pdftocairo as an alternate) splits
+the PDF into one PNG per slide.
+
+Output is JSON. When both tools are present:
+  {"rendered": true, "files": ["render/slide-1.png", ...]}
+When either tool is missing the script still exits 0 and reports:
+  {"rendered": false, "missing": ["soffice"], "guidance": "..."}
+so callers can degrade gracefully (fall back to pptx_read.py --outline).
+"""
+import argparse
+import glob
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+
+def find_tools():
+    """Return (soffice, splitter, missing) using shutil.which."""
+    soffice = shutil.which("soffice")
+    splitter = shutil.which("pdftoppm") or shutil.which("pdftocairo")
+    missing = []
+    if not soffice:
+        missing.append("soffice")
+    if not splitter:
+        missing.append("pdftoppm (or pdftocairo)")
+    return soffice, splitter, missing
+
+
+def render(pptx_path, out_dir, prefix, dpi):
+    soffice, splitter, missing = find_tools()
+    if missing:
+        return {
+            "rendered": False, "missing": missing,
+            "guidance": "Install LibreOffice (soffice) and poppler-utils "
+                        "(pdftoppm/pdftocairo) to render slides. Without "
+                        "them, verify decks with pptx_read.py --outline "
+                        "instead.",
+        }
+
+    os.makedirs(out_dir, exist_ok=True)
+    with tempfile.TemporaryDirectory() as tmp:
+        proc = subprocess.run(
+            [soffice, "--headless", "--convert-to", "pdf",
+             "--outdir", tmp, pptx_path],
+            capture_output=True, text=True, encoding="utf-8",
+            errors="replace", timeout=300)
+        pdfs = glob.glob(os.path.join(tmp, "*.pdf"))
+        if proc.returncode != 0 or not pdfs:
+            raise SystemExit(f"soffice PDF conversion failed: {proc.stderr}")
+        pdf = pdfs[0]
+        out_prefix = os.path.join(out_dir, prefix)
+        proc = subprocess.run(
+            [splitter, "-png", "-r", str(dpi), pdf, out_prefix],
+            capture_output=True, text=True, encoding="utf-8",
+            errors="replace", timeout=300)
+        if proc.returncode != 0:
+            raise SystemExit(f"{os.path.basename(splitter)} failed: "
+                             f"{proc.stderr}")
+
+    files = sorted(glob.glob(out_prefix + "*.png"))
+    return {"rendered": True, "files": files}
+
+
+def main(argv=None):
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    parser = argparse.ArgumentParser(
+        description="Render each slide of a .pptx to a PNG via "
+                    "soffice + pdftoppm/pdftocairo.",
+        epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("pptx", help="path to the .pptx file")
+    parser.add_argument("--outdir", default="render",
+                        help="directory for PNGs (default: ./render)")
+    parser.add_argument("--prefix", default="slide",
+                        help="PNG filename prefix (default: slide)")
+    parser.add_argument("--dpi", type=int, default=100,
+                        help="render resolution (default: 100)")
+    args = parser.parse_args(argv)
+
+    result = render(args.pptx, args.outdir, args.prefix, args.dpi)
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/dist/assets/computer/skills/core/xlsx/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nous Research
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/assets/computer/skills/core/xlsx/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: xlsx
+description: Create, inspect, edit, restructure, convert, and validate XLSX workbooks and CSV files using Qubicl's pinned local spreadsheet tools. Use for formulas, tables, charts, formatting, workbook structure, and CSV interoperability.
+---
+
+# Spreadsheet workflows
+
+Keep workbook artifacts under `/home/qubicl`. Obtain this skill's `resourceRoot` from `skill_view` and run its helpers with `/opt/qubicl/skills-venv/bin/python`. The computer and workstation presets contain the pinned spreadsheet libraries; do not install packages during a task.
+
+Useful helpers beneath `<resourceRoot>/scripts/`:
+
+- `xlsx_read.py FILE --sheets|--json|--csv|--formulas|--notes|--names`
+- `xlsx_create.py SPEC.json OUTPUT.xlsx`
+- `xlsx_edit.py FILE` for values, rows, sheets, tables, names, links, notes, and protection
+- `xlsx_restructure.py FILE` for reference-aware row or column changes
+- `csv_to_xlsx.py INPUT.csv OUTPUT.xlsx`
+- `xlsx_to_csv.py INPUT.xlsx OUTPUT.csv`
+- `xlsx_recalc.py FILE` when LibreOffice is available
+
+Read `references/restructuring.md` before inserting or deleting rows or columns in a formula-heavy workbook.
+
+Inspect workbook structure and formulas before editing. Preserve formulas unless replacement is intentional, use a new output for risky transformations, and read the result back afterward. LibreOffice recalculation is available only on workstation computers; explain that limitation rather than manufacturing cached formula values.

package/dist/assets/computer/skills/core/xlsx/references/restructuring.md

@@ -0,0 +1,71 @@
+# Reference-aware restructuring (xlsx_restructure.py)
+
+`scripts/xlsx_restructure.py` performs one row/column insert or delete
+and rewrites everything that references the moved cells. This document
+gives the exact rewrite rules and honest limits.
+
+## What gets rewritten
+
+| Artifact | Scope | Behavior |
+|---|---|---|
+| Formula references | ALL sheets | A1 refs into the edited sheet are shifted; refs into a fully deleted region become `#REF!` |
+| Merged-cell ranges | edited sheet | shifted; expanded when they span the insertion point; dropped (reported `to: null`) when fully deleted |
+| Autofilter ref | edited sheet | shifted/expanded like a range |
+| Freeze panes | edited sheet | anchor cell shifted (never below row/col of the pane's own minimum) |
+| Data validations | edited sheet | each range in the sqref shifted; deleted ranges removed |
+| Conditional formats | edited sheet | applied range (sqref) shifted |
+| Native tables | edited sheet | table `ref` shifted/expanded |
+| Defined names | workbook scope | `attr_text` refs into the edited sheet rewritten |
+| Row heights / column widths | edited sheet | dimension keys re-indexed |
+
+## Reference grammar handled
+
+- Relative and absolute coordinates in any mix: `B2`, `$B2`, `B$2`,
+  `$B$2` — the `$` flags are preserved through the shift.
+- Ranges `B2:D9`, including partial-absolute endpoints.
+- Cross-sheet refs: `Data!B2`, `'My Sheet'!$A$1:$C$9` (quoted names may
+  contain doubled quotes `''`). Only refs whose sheet qualifier matches
+  the edited sheet are touched; unqualified refs are interpreted
+  relative to the formula's own sheet.
+- String literals inside formulas (`"See B2"`) are never rewritten.
+- Function names that look like cells (`LOG10(...)`) are not touched
+  (a reference is never followed by `(`).
+- Whole-row/column refs (`B:B`, `2:2`) pass through unchanged — Excel
+  semantics keep them valid across inserts within the span.
+
+## Shift semantics
+
+Insert of N at index i: every coordinate >= i moves +N; range endpoints
+move independently, so a range spanning i grows by N.
+
+Delete of N at index i: coordinates before i are unchanged; coordinates
+past the deleted block move -N; a single cell inside the block becomes
+`#REF!`; a RANGE partially covering the block is clamped (Excel does the
+same); a range entirely inside the block becomes `#REF!` (formulas) or
+is removed (merges/validations).
+
+## What it CANNOT shift (honest limits)
+
+- **Chart anchors and plotted ranges** — openpyxl chart objects are not
+  reliably round-tripped; anchors stay where they were. Re-create
+  charts after restructuring if their data moved.
+- **Images / drawings** — same reason.
+- **Conditional-format RULE formulas** — the applied range (sqref) is
+  shifted, but formulas inside `cell_is`/`expression` rules (e.g.
+  `$B1>100`) are left as-is. Review them if they reference moved cells.
+- **Sheet-local defined names** and names using R1C1 or union/
+  intersection operators are rewritten only if they parse as plain A1
+  refs; anything else passes through untouched.
+- **Structured table references** in formulas (`Table1[Sales]`) don't
+  need shifting (they follow the table), and are left alone.
+
+Every run prints a JSON report listing exactly which formulas, merges,
+tables, names, and ranges were changed, plus a fixed `not_shifted` list
+of the above limits — inspect it after any structural edit.
+
+## One op per invocation
+
+The CLI takes exactly one of `--insert-rows/--delete-rows/
+--insert-cols/--delete-cols` (as `IDX[:N]`; columns accept letters).
+For multiple operations run it repeatedly — ordering compound shifts in
+one pass is where spreadsheet tools historically corrupt references.

package/dist/assets/computer/skills/core/xlsx/scripts/csv_to_xlsx.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Convert a CSV file to a styled .xlsx workbook with type inference.
+
+Type inference per cell (disable with --no-infer):
+  int, float, bool ("true"/"false", case-insensitive), ISO date
+  (YYYY-MM-DD) and ISO datetime; everything else stays a string.
+
+Styling applied by default (disable with --plain):
+  bold header row with a light fill, frozen top row, autofilter over the
+  data range, and column widths sized to the longest cell (capped at 60).
+
+Usage:
+  csv_to_xlsx.py data.csv out.xlsx
+  csv_to_xlsx.py data.csv out.xlsx --sheet-name Import --encoding cp1252
+  csv_to_xlsx.py data.csv out.xlsx --delimiter ';' --no-infer
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import sys
+from datetime import date, datetime
+
+from openpyxl import Workbook
+from openpyxl.styles import Font, PatternFill
+from openpyxl.utils import get_column_letter
+
+MAX_COL_WIDTH = 60
+COL_PADDING = 2
+DEFAULT_COL_WIDTH = 8
+
+
+def infer(text):
+    if text == "":
+        return None
+    low = text.lower()
+    if low in ("true", "false"):
+        return low == "true"
+    for caster in (int, float):
+        try:
+            return caster(text)
+        except ValueError:
+            pass
+    for parser in (date.fromisoformat, datetime.fromisoformat):
+        try:
+            return parser(text)
+        except ValueError:
+            pass
+    return text
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="CSV -> styled .xlsx converter.")
+    ap.add_argument("csv_file", help="input CSV path")
+    ap.add_argument("output", help="output .xlsx path")
+    ap.add_argument("--sheet-name", default="Sheet1")
+    ap.add_argument("--encoding", default="utf-8",
+                    help="CSV file encoding (default utf-8)")
+    ap.add_argument("--delimiter", default=",")
+    ap.add_argument("--no-infer", action="store_true",
+                    help="keep every cell as a string")
+    ap.add_argument("--plain", action="store_true",
+                    help="skip header styling / freeze / autofilter")
+    args = ap.parse_args(argv)
+
+    with open(args.csv_file, newline="", encoding=args.encoding) as fh:
+        rows = list(csv.reader(fh, delimiter=args.delimiter))
+
+    wb = Workbook()
+    ws = wb.active
+    ws.title = args.sheet_name
+    for i, row in enumerate(rows):
+        if args.no_infer or i == 0:
+            ws.append(row)
+        else:
+            ws.append([infer(cell) for cell in row])
+
+    if rows and not args.plain:
+        header_font = Font(bold=True)
+        header_fill = PatternFill("solid", fgColor="DDEBF7")
+        for cell in ws[1]:
+            cell.font = header_font
+            cell.fill = header_fill
+        ws.freeze_panes = "A2"
+        ws.auto_filter.ref = ws.dimensions
+        for col_idx in range(1, ws.max_column + 1):
+            longest = max((len(str(r[col_idx - 1])) for r in rows
+                           if len(r) >= col_idx), default=DEFAULT_COL_WIDTH)
+            ws.column_dimensions[get_column_letter(col_idx)].width = \
+                min(longest + COL_PADDING, MAX_COL_WIDTH)
+
+    wb.save(args.output)
+    print(json.dumps({"ok": True, "output": args.output,
+                      "rows": len(rows)}, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as exc:  # noqa: BLE001
+        print(json.dumps({"ok": False, "error": str(exc)}), file=sys.stderr)
+        sys.exit(1)

package/dist/assets/computer/skills/core/xlsx/scripts/xlsx_create.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""Create an .xlsx workbook from a JSON spec.
+
+Spec (JSON object):
+  {
+    "full_calc_on_load": true,          # force recalculation on open (optional)
+    "defined_names": {"Rates": "'Data'!$B$2:$B$4"},   # workbook scope
+    "sheets": [
+      {
+        "name": "Data",
+        "rows": [["Header", 1, true], ...],   # scalars or cell objects (see below)
+        "cells": {"A1": {"value": 5, "format": "0.00%"}},  # sparse overrides
+        "column_widths": {"A": 22, "B": 12},
+        "row_heights": {"1": 24},
+        "merges": ["A1:C1"],
+        "freeze_panes": "A2",
+        "autofilter": "A1:C10",
+        "conditional_formats": [
+          {"range": "B2:B9", "type": "cell_is", "operator": "greaterThan",
+           "formula": ["100"], "fill": "FFC7CE"},
+          {"range": "C2:C9", "type": "color_scale"}
+        ],
+        "charts": [
+          {"type": "bar", "title": "Sales", "anchor": "F2",
+           "data": "B1:B5", "categories": "A2:A5"}
+        ],
+        "validations": [
+          {"range": "D2:D9", "type": "list", "formula1": "\"Yes,No,Maybe\""}
+        ],
+        "tables": [
+          {"name": "Sales", "range": "A1:C4",
+           "style": "TableStyleMedium9"}        # native Excel table
+        ],
+        "protection": {"password": "your-password",   # NOT security --
+                       "unlock": ["B2:B9"]}           # see SKILL.md Pitfalls
+      }
+    ]
+  }
+
+Cell object keys (all optional except value/formula):
+  value          scalar; JSON true/false -> bool, numbers stay numeric
+  type           "date" or "datetime" -> value parsed from ISO string
+  formula        e.g. "=SUM(A2:A9)" (leading '=' optional)
+  hyperlink      URL; value becomes the display text
+  note           cell note text (or {"text": ..., "author": ...})
+  format         Excel number format, e.g. "$#,##0.00", "0.0%", "yyyy-mm-dd"
+  bold, italic   booleans
+  font_size      points
+  font_color     hex RGB like "FF0000"
+  fill           solid fill hex RGB like "DDEBF7"
+  border         "thin" | "medium" | "thick" (all four sides)
+  align          "left" | "center" | "right"
+  valign         "top" | "center" | "bottom"
+  wrap           boolean (wrap text)
+
+Usage:
+  xlsx_create.py spec.json out.xlsx
+  xlsx_create.py - out.xlsx   (spec on stdin)
+
+Prints a JSON summary to stdout; exits non-zero on failure.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import date, datetime
+
+from openpyxl import Workbook
+from openpyxl.chart import BarChart, LineChart, PieChart, Reference
+from openpyxl.comments import Comment
+from openpyxl.formatting.rule import CellIsRule, ColorScaleRule
+from openpyxl.styles import (Alignment, Border, Font, PatternFill,
+                             Protection, Side)
+from openpyxl.utils import column_index_from_string, range_boundaries
+from openpyxl.workbook.defined_name import DefinedName
+from openpyxl.worksheet.datavalidation import DataValidation
+from openpyxl.worksheet.table import Table, TableStyleInfo
+
+
+def parse_typed(value, type_hint=None):
+    if type_hint == "date" and isinstance(value, str):
+        return date.fromisoformat(value)
+    if type_hint == "datetime" and isinstance(value, str):
+        return datetime.fromisoformat(value)
+    return value
+
+
+def apply_cell(ws, coord, spec):
+    cell = ws[coord]
+    if isinstance(spec, dict):
+        if "formula" in spec:
+            f = spec["formula"]
+            cell.value = f if f.startswith("=") else "=" + f
+        elif "value" in spec:
+            cell.value = parse_typed(spec["value"], spec.get("type"))
+        if "hyperlink" in spec:
+            cell.hyperlink = spec["hyperlink"]
+            if cell.value is None:
+                cell.value = spec["hyperlink"]
+            cell.style = "Hyperlink"
+        if "note" in spec:
+            note = spec["note"]
+            if isinstance(note, dict):
+                cell.comment = Comment(note.get("text", ""),
+                                       note.get("author", "xlsx-skill"))
+            else:
+                cell.comment = Comment(str(note), "xlsx-skill")
+        if "format" in spec:
+            cell.number_format = spec["format"]
+        font_kw = {}
+        if spec.get("bold"):
+            font_kw["bold"] = True
+        if spec.get("italic"):
+            font_kw["italic"] = True
+        if "font_size" in spec:
+            font_kw["size"] = spec["font_size"]
+        if "font_color" in spec:
+            font_kw["color"] = spec["font_color"]
+        if font_kw:
+            cell.font = Font(**font_kw)
+        if "fill" in spec:
+            cell.fill = PatternFill("solid", fgColor=spec["fill"])
+        if "border" in spec:
+            side = Side(style=spec["border"])
+            cell.border = Border(left=side, right=side, top=side, bottom=side)
+        align_kw = {}
+        if "align" in spec:
+            align_kw["horizontal"] = spec["align"]
+        if "valign" in spec:
+            align_kw["vertical"] = spec["valign"]
+        if spec.get("wrap"):
+            align_kw["wrap_text"] = True
+        if align_kw:
+            cell.alignment = Alignment(**align_kw)
+    else:
+        cell.value = spec
+
+
+def ref_from_range(ws, rng):
+    min_col, min_row, max_col, max_row = range_boundaries(rng)
+    return Reference(ws, min_col=min_col, min_row=min_row,
+                     max_col=max_col, max_row=max_row)
+
+
+def add_chart(ws, spec):
+    kind = spec.get("type", "bar")
+    chart = {"bar": BarChart, "line": LineChart, "pie": PieChart}[kind]()
+    if "title" in spec:
+        chart.title = spec["title"]
+    data = ref_from_range(ws, spec["data"])
+    chart.add_data(data, titles_from_data=spec.get("titles_from_data", True))
+    if "categories" in spec:
+        chart.set_categories(ref_from_range(ws, spec["categories"]))
+    ws.add_chart(chart, spec.get("anchor", "H2"))
+
+
+def add_conditional(ws, spec):
+    rng = spec["range"]
+    kind = spec.get("type", "cell_is")
+    if kind == "color_scale":
+        rule = ColorScaleRule(
+            start_type="min", start_color=spec.get("start_color", "FFF8696B"),
+            end_type="max", end_color=spec.get("end_color", "FF63BE7B"))
+    else:
+        fill = PatternFill("solid", fgColor=spec.get("fill", "FFC7CE"))
+        rule = CellIsRule(operator=spec.get("operator", "greaterThan"),
+                          formula=spec.get("formula", ["0"]), fill=fill)
+    ws.conditional_formatting.add(rng, rule)
+
+
+def build_sheet(ws, spec):
+    for row in spec.get("rows", []):
+        values, styled = [], []
+        for item in row:
+            if isinstance(item, dict):
+                values.append(None)
+                styled.append(item)
+            else:
+                values.append(item)
+                styled.append(None)
+        ws.append(values)
+        r = ws.max_row
+        for idx, item in enumerate(styled, start=1):
+            if item is not None:
+                apply_cell(ws, ws.cell(row=r, column=idx).coordinate, item)
+    for coord, cell_spec in spec.get("cells", {}).items():
+        apply_cell(ws, coord, cell_spec)
+    for col, width in spec.get("column_widths", {}).items():
+        ws.column_dimensions[col].width = width
+    for row, height in spec.get("row_heights", {}).items():
+        ws.row_dimensions[int(row)].height = height
+    for rng in spec.get("merges", []):
+        ws.merge_cells(rng)
+    if spec.get("freeze_panes"):
+        ws.freeze_panes = spec["freeze_panes"]
+    if spec.get("autofilter"):
+        ws.auto_filter.ref = spec["autofilter"]
+    for cf in spec.get("conditional_formats", []):
+        add_conditional(ws, cf)
+    for ch in spec.get("charts", []):
+        add_chart(ws, ch)
+    for dv_spec in spec.get("validations", []):
+        dv = DataValidation(type=dv_spec.get("type", "list"),
+                            formula1=dv_spec["formula1"],
+                            allow_blank=dv_spec.get("allow_blank", True))
+        dv.add(dv_spec["range"])
+        ws.add_data_validation(dv)
+    for t_spec in spec.get("tables", []):
+        table = Table(displayName=t_spec["name"], ref=t_spec["range"])
+        table.tableStyleInfo = TableStyleInfo(
+            name=t_spec.get("style", "TableStyleMedium9"),
+            showRowStripes=t_spec.get("row_stripes", True),
+            showColumnStripes=t_spec.get("column_stripes", False))
+        ws.add_table(table)
+    prot = spec.get("protection")
+    if prot:
+        for rng in prot.get("unlock", []):
+            for row in ws[rng]:
+                for cell in row:
+                    cell.protection = Protection(locked=False)
+        if prot.get("password"):
+            ws.protection.password = prot["password"]
+        ws.protection.sheet = True
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="Create .xlsx from a JSON spec.")
+    ap.add_argument("spec", help="path to JSON spec, or '-' for stdin")
+    ap.add_argument("output", help="output .xlsx path")
+    args = ap.parse_args(argv)
+
+    if args.spec == "-":
+        spec = json.load(sys.stdin)
+    else:
+        with open(args.spec, encoding="utf-8") as fh:
+            spec = json.load(fh)
+
+    wb = Workbook()
+    wb.remove(wb.active)
+    for sheet_spec in spec.get("sheets", []):
+        ws = wb.create_sheet(sheet_spec.get("name", "Sheet1"))
+        build_sheet(ws, sheet_spec)
+    for name, ref in spec.get("defined_names", {}).items():
+        wb.defined_names[name] = DefinedName(name, attr_text=ref)
+    if spec.get("full_calc_on_load"):
+        wb.calculation.fullCalcOnLoad = True
+    wb.save(args.output)
+    print(json.dumps({"ok": True, "output": args.output,
+                      "sheets": wb.sheetnames}, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as exc:  # noqa: BLE001
+        print(json.dumps({"ok": False, "error": str(exc)}), file=sys.stderr)
+        sys.exit(1)