@petercjl/taobao-ai-ops 0.1.0 → 0.1.2

package/skills/taobao-search-product-form/scripts/visual_form_pipeline.py

@@ -1,247 +0,0 @@
-#!/usr/bin/env python3
-"""Plan one-pass visual jobs and reduce open visual observations.
-
-Planning groups images for review; it never infers a product form. Reduction
-uses an explicit, versioned registry, so labels can change without rereading.
-"""
-
-import argparse
-import hashlib
-import json
-from collections import Counter, defaultdict
-from pathlib import Path
-
-from PIL import Image, ImageDraw, ImageOps
-
-
-def digest(path):
-    value = hashlib.sha256()
-    with path.open("rb") as stream:
-        for block in iter(lambda: stream.read(1024 * 1024), b""):
-            value.update(block)
-    return value.hexdigest()
-
-
-def dhash(path):
-    with Image.open(path) as source:
-        image = ImageOps.exif_transpose(source).convert("L").resize((9, 8))
-        pixels = list(image.tobytes())
-    value = 0
-    for row in range(8):
-        for col in range(8):
-            value = (value << 1) | int(pixels[row * 9 + col] > pixels[row * 9 + col + 1])
-    return value
-
-
-def read_json(path):
-    return json.loads(Path(path).read_text(encoding="utf-8"))
-
-
-def write_json(path, value):
-    with path.open("x", encoding="utf-8") as stream:
-        json.dump(value, stream, ensure_ascii=False, indent=2)
-        stream.write("\n")
-
-
-def plan(args):
-    manifest_path = Path(args.manifest).resolve()
-    manifest = read_json(manifest_path)
-    source_root = manifest_path.parent
-    if args.population != "natural":
-        raise ValueError("only the natural-position form population is currently implemented")
-    ids = manifest["selected_organic_ids"]
-    if args.limit:
-        ids = ids[:args.limit]
-    lookup = {str(p["product_id"]): p for p in manifest["products"]}
-    items = []
-    for pid in ids:
-        fetched = manifest["fetches"].get(pid, {})
-        if fetched.get("status") != "ok":
-            items.append({"product_id": pid, "status": "image_unavailable", "image_path": None,
-                          "unavailable_reason": fetched.get("status") or "missing_fetch_record"})
-            continue
-        path = (source_root / fetched["path"]).resolve()
-        if not path.is_file() or not path.is_relative_to(source_root):
-            raise ValueError(f"missing or escaping image path for product {pid}")
-        items.append({"product_id": pid, "status": "ready", "image_path": str(path),
-                      "source_image_url": lookup[pid].get("image_url"),
-                      "image_sha256": digest(path), "image_dhash": f"{dhash(path):016x}",
-                      "source_rank": lookup[pid]["organic_rank"]})
-    if len(ids) != len(set(ids)):
-        raise ValueError("duplicate selected natural-position product ID")
-    out = Path(args.output_dir).resolve()
-    if out.exists():
-        raise FileExistsError(out)
-    out.mkdir(parents=True)
-    ready = [item for item in items if item["status"] == "ready"]
-    # dHash is a cheap grouping hint only. It is never a classification label.
-    ready.sort(key=lambda item: (item["image_dhash"], item["product_id"]))
-    batches = []
-    for start in range(0, len(ready), args.batch_size):
-        members = ready[start:start + args.batch_size]
-        batch_id = f"B{len(batches) + 1:03d}"
-        for item in members:
-            item["batch_id"] = batch_id
-        batches.append({"batch_id": batch_id, "product_ids": [item["product_id"] for item in members]})
-        columns, cell_w, cell_h = 3, 350, 385
-        rows = (len(members) + columns - 1) // columns
-        sheet = Image.new("RGB", (columns * cell_w, rows * cell_h), "white")
-        draw = ImageDraw.Draw(sheet)
-        for n, item in enumerate(members):
-            with Image.open(item["image_path"]) as source:
-                image = ImageOps.exif_transpose(source).convert("RGB")
-                image.thumbnail((330, 345))
-                x, y = (n % columns) * cell_w, (n // columns) * cell_h
-                sheet.paste(image, (x + (cell_w - image.width) // 2, y + 4))
-            draw.text((x + 8, y + 354), f'{item["product_id"]}  N{item["source_rank"]}', fill="black")
-        sheet_name = f"{batch_id}.jpg"
-        sheet.save(out / sheet_name, "JPEG", quality=90)
-        batches[-1]["contact_sheet"] = str(out / sheet_name)
-    plan_doc = {"schema_version": 1, "strategy": "visual-form-open-v1",
-                "semantic_inspection_unit": "original_product_image",
-                "contact_sheet_role": "orientation_and_coverage_audit",
-                "source_manifest": str(manifest_path), "source_manifest_sha256": digest(manifest_path),
-                "population": "natural", "scope": {"selected": len(ids), "ready": len(ready),
-                "image_unavailable": len(ids) - len(ready), "manifest_natural_total": manifest["scope"]["organic_total"]},
-                "batch_size": args.batch_size, "items": items, "batches": batches}
-    write_json(out / "visual_batch_plan.json", plan_doc)
-    print(json.dumps({"plan": str(out / "visual_batch_plan.json"), "selected": len(ids),
-                      "ready": len(ready), "batches": len(batches)}, ensure_ascii=False))
-
-
-def bind(args):
-    plan_doc = read_json(args.plan)
-    draft = read_json(args.draft)
-    ready = {item["product_id"]: item for item in plan_doc["items"] if item["status"] == "ready"}
-    observations = draft["observations"]
-    ids = [str(row["product_id"]) for row in observations]
-    if len(ids) != len(set(ids)) or set(ids) != set(ready):
-        raise ValueError("draft must cover each ready product exactly once")
-    bound = []
-    for row in observations:
-        item = ready[str(row["product_id"])]
-        bound.append({**row, "batch_id": item["batch_id"], "image_sha256": item["image_sha256"]})
-    output = Path(args.output).resolve()
-    write_json(output, {"schema_version": 1, "plan_sha256": digest(Path(args.plan)),
-                        "observations": bound})
-    print(json.dumps({"observations": str(output), "count": len(bound)}, ensure_ascii=False))
-
-
-def reduce(args):
-    plan_doc = read_json(args.plan)
-    raw = read_json(args.observations)
-    registry = read_json(args.registry)
-    if raw.get("schema_version") != 1 or registry.get("schema_version") != 1:
-        raise ValueError("unsupported observations or registry schema")
-    if raw.get("plan_sha256") != digest(Path(args.plan)):
-        raise ValueError("observations were bound to a different plan")
-    expected = {item["product_id"]: item for item in plan_doc["items"] if item["status"] == "ready"}
-    records = raw["observations"]
-    ids = [str(record["product_id"]) for record in records]
-    if len(ids) != len(set(ids)):
-        raise ValueError("a product has more than one semantic observation")
-    if set(ids) != set(expected):
-        raise ValueError(f"observation coverage mismatch: missing={sorted(set(expected)-set(ids))}, extra={sorted(set(ids)-set(expected))}")
-    forms = registry.get("primary_forms", {})
-    alias_owner = {}
-    for canonical, entry in forms.items():
-        for alias in [canonical, *entry.get("aliases", [])]:
-            key = alias.strip().casefold()
-            if key in alias_owner and alias_owner[key] != canonical:
-                raise ValueError(f"alias collision: {alias}")
-            alias_owner[key] = canonical
-    result = []
-    unresolved = Counter()
-    uncertain_candidates = Counter()
-    candidates = Counter()
-    batches = defaultdict(Counter)
-    for record in records:
-        pid = str(record["product_id"])
-        item = expected[pid]
-        if record.get("image_sha256") != item["image_sha256"] or record.get("batch_id") != item["batch_id"]:
-            raise ValueError(f"image/batch provenance mismatch: {pid}")
-        status = record.get("status")
-        if status not in {"tagged", "uncertain"}:
-            raise ValueError(f"invalid observation status: {pid}")
-        evidence = str(record.get("visible_evidence", "")).strip()
-        if not evidence:
-            raise ValueError(f"missing visible evidence: {pid}")
-        candidate = str(record.get("primary_form_candidate", "")).strip()
-        if status == "tagged" and not candidate:
-            raise ValueError(f"missing form candidate: {pid}")
-        facets = record.get("facets", {})
-        if not isinstance(facets, dict):
-            raise ValueError(f"facets must be an object: {pid}")
-        canonical = alias_owner.get(candidate.casefold()) if candidate else None
-        if candidate:
-            candidates[candidate] += 1
-        if status == "tagged" and canonical is None:
-            unresolved[candidate] += 1
-        if status == "uncertain" and candidate and canonical is None:
-            uncertain_candidates[candidate] += 1
-        if canonical:
-            batches[item["batch_id"]][canonical] += 1
-        result.append({"product_id": pid, "batch_id": item["batch_id"],
-                       "image_sha256": item["image_sha256"], "status": status,
-                       "primary_form_candidate": candidate or None,
-                       "primary_form": canonical, "visible_evidence": evidence,
-                       "facets": facets})
-    out = Path(args.output_dir).resolve()
-    if out.exists():
-        raise FileExistsError(out)
-    out.mkdir(parents=True)
-    counts = Counter(row["primary_form"] for row in result if row["primary_form"])
-    report = {"schema_version": 1, "strategy": "visual-form-open-v1",
-              "plan_sha256": digest(Path(args.plan)), "observations_sha256": digest(Path(args.observations)),
-              "registry_sha256": digest(Path(args.registry)), "registry_version": registry.get("version"),
-              "scope": plan_doc["scope"], "observed": len(result),
-              "candidate_labels": dict(candidates), "candidate_label_count": len(candidates),
-              "canonical_forms": dict(counts), "canonical_form_count": len(counts),
-              "representative_product_ids": {form: [row["product_id"] for row in result
-                                                       if row["primary_form"] == form][:3]
-                                             for form in counts},
-              "singleton_forms": [form for form, count in counts.items() if count == 1],
-              "unresolved_candidates": dict(unresolved),
-              "uncertain_candidates": dict(uncertain_candidates),
-              "uncertain_count": sum(row["status"] == "uncertain" for row in result),
-              "batch_form_counts": {key: dict(value) for key, value in batches.items()},
-              "qa": {"one_record_per_ready_product": True, "image_hash_and_batch_match": True,
-                     "all_labels_resolved": not unresolved}}
-    write_json(out / "visual_form_assignments.json", {"schema_version": 1, "records": result})
-    write_json(out / "visual_form_summary.json", report)
-    print(json.dumps({"output_dir": str(out), "observed": len(result),
-                      "candidate_labels": len(candidates), "canonical_forms": len(counts),
-                      "unresolved": dict(unresolved)}, ensure_ascii=False))
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    commands = parser.add_subparsers(dest="command", required=True)
-    planning = commands.add_parser("plan")
-    planning.add_argument("--manifest", required=True)
-    planning.add_argument("--output-dir", required=True)
-    planning.add_argument("--population", default="natural")
-    planning.add_argument("--limit", type=int)
-    planning.add_argument("--batch-size", type=int, default=10)
-    binding = commands.add_parser("bind")
-    binding.add_argument("--plan", required=True)
-    binding.add_argument("--draft", required=True)
-    binding.add_argument("--output", required=True)
-    reducing = commands.add_parser("reduce")
-    reducing.add_argument("--plan", required=True)
-    reducing.add_argument("--observations", required=True)
-    reducing.add_argument("--registry", required=True)
-    reducing.add_argument("--output-dir", required=True)
-    args = parser.parse_args()
-    if args.command == "plan":
-        if args.batch_size < 1 or args.limit is not None and args.limit < 1:
-            parser.error("batch size and limit must be positive")
-        plan(args)
-    elif args.command == "bind":
-        bind(args)
-    else:
-        reduce(args)
-
-
-if __name__ == "__main__":
-    main()

package/skills/taobao-search-product-form/scripts/visual_observation_batches.py

@@ -1,117 +0,0 @@
-#!/usr/bin/env python3
-"""Checkpoint image-grounded observations one visual batch at a time.
-
-This tool validates membership and provenance. It never generates semantic labels.
-"""
-
-import argparse
-import hashlib
-import json
-from pathlib import Path
-
-
-def read(path):
-    return json.loads(Path(path).read_text(encoding="utf-8"))
-
-
-def digest(path):
-    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
-
-
-def ready_batches(plan):
-    items = {str(item["product_id"]): item for item in plan["items"] if item["status"] == "ready"}
-    batches = {batch["batch_id"]: batch for batch in plan["batches"]}
-    if len(items) != plan["scope"]["ready"]:
-        raise ValueError("ready-image count mismatch")
-    return items, batches
-
-
-def validate_batch(plan_path, batch_id, doc):
-    plan = read(plan_path)
-    items, batches = ready_batches(plan)
-    if batch_id not in batches:
-        raise ValueError(f"unknown batch: {batch_id}")
-    expected = set(batches[batch_id]["product_ids"])
-    rows = doc.get("observations")
-    if not isinstance(rows, list):
-        raise ValueError("observations must be an array")
-    ids = [str(row.get("product_id", "")) for row in rows]
-    if len(ids) != len(set(ids)) or set(ids) != expected:
-        raise ValueError(f"batch coverage mismatch: missing={sorted(expected-set(ids))}, extra={sorted(set(ids)-expected)}")
-    bound = []
-    for row in rows:
-        item = items[str(row["product_id"])]
-        if item["batch_id"] != batch_id:
-            raise ValueError(f"batch membership mismatch: {row['product_id']}")
-        if row.get("batch_id", batch_id) != batch_id or row.get("image_sha256", item["image_sha256"]) != item["image_sha256"]:
-            raise ValueError(f"image provenance mismatch: {row['product_id']}")
-        if row.get("status") not in ("tagged", "uncertain") or not str(row.get("visible_evidence", "")).strip():
-            raise ValueError(f"missing status or visible evidence: {row['product_id']}")
-        if any(not isinstance(row.get(axis), dict) for axis in ("form", "style", "audience")):
-            raise ValueError(f"three axes required: {row['product_id']}")
-        bound.append({**row, "product_id": str(row["product_id"]), "batch_id": batch_id,
-                      "image_sha256": item["image_sha256"]})
-    return {"schema_version": 2, "batch_id": batch_id, "plan_sha256": digest(plan_path),
-            "observations": bound}
-
-
-def checked_files(plan_path, batch_dir):
-    plan = read(plan_path)
-    _, batches = ready_batches(plan)
-    folder = Path(batch_dir)
-    found = {}
-    if folder.exists():
-        for path in sorted(folder.glob("B*.json")):
-            batch_id = path.stem
-            if batch_id not in batches:
-                raise ValueError(f"unexpected batch file: {path}")
-            doc = read(path)
-            if doc.get("plan_sha256") != digest(plan_path) or doc.get("batch_id") != batch_id:
-                raise ValueError(f"stale or mismatched batch file: {path}")
-            validated = validate_batch(plan_path, batch_id, doc)
-            found[batch_id] = validated["observations"]
-    return batches, found
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    commands = parser.add_subparsers(dest="command", required=True)
-    for name in ("commit", "status", "merge"):
-        command = commands.add_parser(name)
-        command.add_argument("--plan", required=True)
-        command.add_argument("--batch-dir", required=True)
-        if name == "commit":
-            command.add_argument("--batch-id", required=True)
-            command.add_argument("--draft", required=True)
-        if name == "merge":
-            command.add_argument("--output", required=True)
-    args = parser.parse_args()
-    plan_path = Path(args.plan).resolve()
-    batch_dir = Path(args.batch_dir).resolve()
-    batches, found = checked_files(plan_path, batch_dir)
-    if args.command == "commit":
-        if args.batch_id in found:
-            raise FileExistsError(batch_dir / f"{args.batch_id}.json")
-        validated = validate_batch(plan_path, args.batch_id, read(args.draft))
-        batch_dir.mkdir(parents=True, exist_ok=True)
-        path = batch_dir / f"{args.batch_id}.json"
-        with path.open("x", encoding="utf-8") as stream:
-            json.dump(validated, stream, ensure_ascii=False, indent=2)
-            stream.write("\n")
-        found[args.batch_id] = validated["observations"]
-    missing = [batch_id for batch_id in batches if batch_id not in found]
-    if args.command == "merge":
-        if missing:
-            raise ValueError(f"incomplete visual observations: {len(missing)} batches remain; next={missing[0]}")
-        rows = [row for batch_id in batches for row in found[batch_id]]
-        output = Path(args.output).resolve()
-        with output.open("x", encoding="utf-8") as stream:
-            json.dump({"schema_version": 2, "observations": rows}, stream, ensure_ascii=False, indent=2)
-            stream.write("\n")
-    print(json.dumps({"completed_batches": len(found), "total_batches": len(batches),
-                      "observed_products": sum(len(rows) for rows in found.values()),
-                      "next_batch": missing[0] if missing else None}, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    main()

package/skills/taobao-search-product-form/scripts/workflow_ledger.py

@@ -1,177 +0,0 @@
-#!/usr/bin/env python3
-"""Small, recoverable stage ledger for development and end-to-end runs."""
-
-import argparse
-import hashlib
-import json
-import os
-import shutil
-import tempfile
-import uuid
-from datetime import datetime, timezone
-from pathlib import Path
-
-
-STAGES = ("input", "clean", "classify", "compare", "decide", "report")
-STATUSES = ("not_started", "in_progress", "awaiting_review", "approved", "verified", "blocked", "skipped")
-DESIGN_STATES = ("open", "defined", "validated")
-
-
-def now():
-    return datetime.now(timezone.utc).isoformat(timespec="seconds")
-
-
-def sha256(path):
-    digest = hashlib.sha256()
-    with path.open("rb") as handle:
-        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
-            digest.update(chunk)
-    return digest.hexdigest()
-
-
-def stage_record():
-    return {"design_state": "open", "status": "not_started", "strategy": None,
-            "artifacts": [], "review": None, "note": None, "updated_at": None}
-
-
-def artifact_intact(item):
-    path = Path(item["path"])
-    return path.is_file() and path.stat().st_size == item["bytes"] and sha256(path) == item["sha256"]
-
-
-def command_init(args):
-    source = Path(args.input).expanduser().resolve()
-    if not source.is_file():
-        raise ValueError(f"input workbook not found: {source}")
-    run_dir = Path(args.run_dir).expanduser().resolve()
-    ledger = run_dir / "ledger.json"
-    if ledger.exists() or ledger.is_symlink():
-        raise FileExistsError(f"ledger already exists: {ledger}")
-    run_dir.mkdir(parents=True, exist_ok=True)
-    timestamp = now()
-    document = {
-        "schema_version": 1,
-        "mode": args.mode,
-        "created_at": timestamp,
-        "updated_at": timestamp,
-        "input": {"path": str(source), "sha256": sha256(source), "bytes": source.stat().st_size},
-        "stages": {name: stage_record() for name in STAGES},
-        "events": [{"at": timestamp, "action": "init", "note": "Run ledger initialized; stages await design or execution."}],
-    }
-    with ledger.open("x", encoding="utf-8") as handle:
-        json.dump(document, handle, ensure_ascii=False, indent=2)
-        handle.write("\n")
-    print(json.dumps({"ledger": str(ledger), "mode": args.mode, "stages": list(STAGES)}, ensure_ascii=False))
-
-
-def command_show(args):
-    ledger = Path(args.ledger).expanduser().resolve()
-    document = json.loads(ledger.read_text(encoding="utf-8"))
-    input_path = Path(document["input"]["path"])
-    input_intact = input_path.is_file() and sha256(input_path) == document["input"]["sha256"]
-    result = {"ledger": str(ledger), "mode": document["mode"], "input": document["input"],
-              "input_intact": input_intact,
-              "stages": {key: {"design_state": value["design_state"], "status": value["status"],
-                               "strategy": value["strategy"], "artifacts": value["artifacts"],
-                               "artifacts_intact": all(artifact_intact(item) for item in value["artifacts"]),
-                               "note": value["note"]} for key, value in document["stages"].items()}}
-    print(json.dumps(result, ensure_ascii=False, indent=2))
-
-
-def command_record(args):
-    ledger = Path(args.ledger).expanduser().resolve()
-    if ledger.is_symlink() or not ledger.is_file():
-        raise ValueError(f"ledger must be an existing regular file: {ledger}")
-    document = json.loads(ledger.read_text(encoding="utf-8"))
-    stage_id = args.stage
-    if stage_id not in document["stages"]:
-        if not stage_id.startswith("classify/") or len(stage_id) <= len("classify/"):
-            raise ValueError(f"unknown stage: {stage_id}; use classify/NAME for a module")
-        document["stages"][stage_id] = stage_record()
-    stage = document["stages"][stage_id]
-    if args.status == "approved" and (document["mode"] != "development" or not args.reviewer or not args.note):
-        raise ValueError("approved requires development mode, --reviewer and --note recording confirmation")
-    if args.status == "verified" and document["mode"] != "run":
-        raise ValueError("verified is reserved for run-mode automated QA")
-    if args.status == "awaiting_review" and document["mode"] != "development":
-        raise ValueError("awaiting_review is reserved for development mode")
-    if args.status == "blocked" and not args.note:
-        raise ValueError("blocked requires --note")
-    artifacts = []
-    for raw in args.artifact:
-        target = Path(raw).expanduser().resolve()
-        if not target.is_file():
-            raise ValueError(f"artifact does not exist as a file: {target}")
-        artifacts.append({"path": str(target), "sha256": sha256(target), "bytes": target.stat().st_size})
-    if args.status is not None:
-        stage["status"] = args.status
-    if args.design_state is not None:
-        stage["design_state"] = args.design_state
-    if args.strategy is not None:
-        stage["strategy"] = args.strategy
-    for artifact in artifacts:
-        stage["artifacts"] = [old for old in stage["artifacts"] if old["path"] != artifact["path"]]
-        stage["artifacts"].append(artifact)
-    if args.note is not None:
-        stage["note"] = args.note
-    if args.status == "approved":
-        stage["review"] = {"reviewer": args.reviewer, "at": now(), "note": args.note}
-    elif args.status in ("not_started", "in_progress", "awaiting_review", "blocked"):
-        stage["review"] = None
-    timestamp = now()
-    stage["updated_at"] = timestamp
-    document["updated_at"] = timestamp
-    document["events"].append({"at": timestamp, "action": "record", "stage": stage_id,
-                               "status": stage["status"], "design_state": stage["design_state"],
-                               "strategy": stage["strategy"], "artifacts_added": artifacts,
-                               "note": args.note, "reviewer": args.reviewer})
-    backup = ledger.with_name(ledger.name + ".bak-" + uuid.uuid4().hex[:12])
-    shutil.copy2(ledger, backup)
-    if not backup.is_file() or backup.stat().st_size == 0:
-        raise OSError("ledger backup verification failed")
-    fd, temporary = tempfile.mkstemp(prefix=".ledger-", suffix=".json", dir=ledger.parent)
-    try:
-        with os.fdopen(fd, "w", encoding="utf-8") as handle:
-            json.dump(document, handle, ensure_ascii=False, indent=2)
-            handle.write("\n")
-            handle.flush()
-            os.fsync(handle.fileno())
-        os.chmod(temporary, ledger.stat().st_mode & 0o777)
-        os.replace(temporary, ledger)
-    finally:
-        if os.path.exists(temporary):
-            os.unlink(temporary)
-    print(json.dumps({"ledger": str(ledger), "backup": str(backup), "stage": stage_id,
-                      "status": stage["status"], "artifacts": stage["artifacts"]}, ensure_ascii=False))
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    commands = parser.add_subparsers(dest="command", required=True)
-    init = commands.add_parser("init")
-    init.add_argument("--run-dir", required=True)
-    init.add_argument("--mode", choices=("development", "run"), required=True)
-    init.add_argument("--input", required=True)
-    init.set_defaults(func=command_init)
-    show = commands.add_parser("show")
-    show.add_argument("--ledger", required=True)
-    show.set_defaults(func=command_show)
-    record = commands.add_parser("record")
-    record.add_argument("--ledger", required=True)
-    record.add_argument("--stage", required=True)
-    record.add_argument("--status", choices=STATUSES)
-    record.add_argument("--design-state", choices=DESIGN_STATES)
-    record.add_argument("--strategy")
-    record.add_argument("--artifact", action="append", default=[])
-    record.add_argument("--note")
-    record.add_argument("--reviewer")
-    record.set_defaults(func=command_record)
-    args = parser.parse_args()
-    try:
-        args.func(args)
-    except (OSError, ValueError, KeyError, json.JSONDecodeError) as error:
-        parser.exit(2, f"{error}\n")
-
-
-if __name__ == "__main__":
-    main()