#!/usr/bin/env python3 """Batch convert/read CAD drawings and generate a DXF inventory report.""" from __future__ import annotations import argparse import glob import fnmatch import json import os import re import shutil import subprocess import sys from collections import Counter from pathlib import Path CAD_SUFFIXES = {".dwg", ".dxf"} def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--input", required=True, help="Folder containing DWG/DXF files") parser.add_argument("--work", default="work/cad_showcase", help="Intermediate work folder") parser.add_argument("--output", default="outputs/cad_read_report", help="Output path stem or folder") parser.add_argument("--vendor-dir", default="work/vendor", help="Optional Python vendor dir containing ezdxf") parser.add_argument( "--no-convert", action="store_true", help="Skip DWG conversion and only read existing DXF files" ) parser.add_argument( "--converter", choices=("auto", "libredwg", "oda"), default="auto", help="auto=libredwg then ODA fallback; choose oda explicitly for 3DSOLID/ACIS drawings", ) parser.add_argument("--allow-partial", action="store_true", help="Write a partial report instead of failing") parser.add_argument("--partial-reason", help="Required justification when --allow-partial is used") return parser.parse_args() def import_ezdxf(vendor_dir: Path): if vendor_dir.exists(): sys.path.insert(0, str(vendor_dir.resolve())) try: import ezdxf # type: ignore from ezdxf import bbox, recover # type: ignore except ImportError as exc: raise SystemExit( f"Missing dependency: ezdxf. Install locally with:\n python3 -m pip install --target {vendor_dir} ezdxf" ) from exc return ezdxf, bbox, recover def safe_name(path: Path, used: set[str]) -> str: stem = path.stem candidate = f"{stem}.dxf" index = 2 while candidate in used: candidate = f"{stem}-{index}.dxf" index += 1 used.add(candidate) return candidate def find_cad_files(input_dir: Path) -> list[Path]: return sorted(path for path in input_dir.rglob("*") if path.is_file() and path.suffix.lower() in CAD_SUFFIXES) def run_dwg2dxf(source: Path, dest: Path) -> dict: exe = shutil.which("dwg2dxf") if not exe: return { "source": str(source), "dest": str(dest), "status": "missing_dwg2dxf", "message": "Install LibreDWG or use ODA/QCAD/FreeCAD to convert DWG to DXF.", } dest.parent.mkdir(parents=True, exist_ok=True) cmd = [exe, "-y", "-o", str(dest), str(source)] # libredwg echoes CJK layer/file names in the platform encoding (GBK on # Chinese drawings), so strict UTF-8 text mode crashes; decode leniently. proc = subprocess.run(cmd, capture_output=True) stdout = proc.stdout.decode("utf-8", errors="replace") stderr = proc.stderr.decode("utf-8", errors="replace") return { "source": str(source), "dest": str(dest), "status": "ok" if proc.returncode == 0 and dest.exists() else "failed", "returncode": proc.returncode, "stdout": stdout[-2000:], "stderr": stderr[-2000:], } def oda_converter() -> str | None: """ODA File Converter: env ODA_CONVERTER > PATH > macOS app-bundle default.""" override = os.environ.get("ODA_CONVERTER") if override: return override if Path(override).exists() else None found = shutil.which("ODAFileConverter") if found: return found if sys.platform == "win32": hits = sorted( glob.glob(r"C:/Program Files/ODA/*/ODAFileConverter.exe") + glob.glob(r"C:/Program Files (x86)/ODA/*/ODAFileConverter.exe") ) if hits: return hits[-1] default = Path("/Applications/ODAFileConverter.app/Contents/MacOS/ODAFileConverter") return str(default) if default.exists() else None def run_oda_batch(sources: list[Path], work_dir: Path) -> dict[Path, Path]: """Convert DWGs via ODA File Converter; returns {source: produced_dxf}. ODA converts whole directories with absolute paths and reports bad arguments via GUI dialogs (silent exit-0), so sources are staged under ASCII names in a scratch in-dir and results matched back by stem. """ exe = oda_converter() if not exe or not sources: return {} in_dir = work_dir / "oda_in" out_dir = work_dir / "oda_out" shutil.rmtree(in_dir, ignore_errors=True) shutil.rmtree(out_dir, ignore_errors=True) in_dir.mkdir(parents=True) out_dir.mkdir(parents=True) mapping: dict[str, Path] = {} for index, src in enumerate(sources): stem = f"oda{index:03d}" shutil.copy2(src, in_dir / f"{stem}.dwg") mapping[stem] = src try: subprocess.run( [exe, str(in_dir.resolve()), str(out_dir.resolve()), "ACAD2018", "DXF", "0", "1", "*.dwg"], capture_output=True, timeout=1800, ) except (subprocess.TimeoutExpired, OSError): return {} produced: dict[Path, Path] = {} for stem, src in mapping.items(): out = out_dir / f"{stem}.dxf" if out.exists() and out.stat().st_size > 0: produced[src] = out return produced def sanitize_dxf_comments(source: Path, dest: Path) -> int: """Remove DXF group code 999 comment pairs that can break brittle importers. Operates on BYTES: pre-2007 DXF from libredwg/TArch stores CJK text in the $DWGCODEPAGE encoding (ANSI_936/GBK). A UTF-8 round-trip with errors="ignore" silently drops those bytes, mangling every CJK layer/text ("一层平面图" -> "一平图") and breaking plan-title detection downstream, so the file content must pass through unchanged apart from the comment pairs. """ lines = source.read_bytes().splitlines(keepends=True) dest.parent.mkdir(parents=True, exist_ok=True) cleaned: list[bytes] = [] removed = 0 index = 0 # DXF is a strict alternation of group-code line / value line, so walk in # pairs: a bare "999" VALUE (e.g. an integer inside an ODA XRECORD) must # not be mistaken for a comment group code, or the pair removal shifts # every following tag and corrupts the file. while index + 1 < len(lines): if lines[index].strip() == b"999": removed += 1 index += 2 continue cleaned.append(lines[index]) cleaned.append(lines[index + 1]) index += 2 cleaned.extend(lines[index:]) dest.write_bytes(b"".join(cleaned)) return removed def bbox_tuple(box) -> dict | None: if not box or not box.has_data: return None extmin = box.extmin extmax = box.extmax return { "min": [round(extmin.x, 3), round(extmin.y, 3), round(extmin.z, 3)], "max": [round(extmax.x, 3), round(extmax.y, 3), round(extmax.z, 3)], "size": [ round(extmax.x - extmin.x, 3), round(extmax.y - extmin.y, 3), round(extmax.z - extmin.z, 3), ], } def guess_unit_scale(bbox_data: dict | None, insunits: int) -> dict: if insunits == 6: return {"source_units": "meters", "scale_to_meters": 1.0, "confidence": "header"} if insunits == 4: return {"source_units": "millimeters", "scale_to_meters": 0.001, "confidence": "header"} if not bbox_data: return {"source_units": "unknown", "scale_to_meters": 1.0, "confidence": "none"} sx, sy, _ = bbox_data.get("size", [0, 0, 0]) largest = max(abs(sx), abs(sy)) if largest > 1000: return {"source_units": "millimeters", "scale_to_meters": 0.001, "confidence": "bbox_heuristic"} return {"source_units": "meters_or_unknown", "scale_to_meters": 1.0, "confidence": "bbox_heuristic"} def read_doc(path: Path, ezdxf, recover): try: return ezdxf.readfile(path), [] except (ezdxf.DXFError, ValueError): # Strict reads can also raise plain ValueError on quirky-but- # recoverable files (e.g. an XRECORD holding "{ACAD_REACTORS" where a # handle is expected); recover skips those records. doc, auditor = recover.readfile(path) return doc, [str(error) for error in auditor.errors] # A floor-plan sheet whose real geometry lives in unbound XREFs exports as a # near-empty shell (a few dozen annotation entities). Modeling it silently # produces a missing floor, so it must be flagged before extraction. NEAR_EMPTY_ENTITY_THRESHOLD = 60 BLK_XREF_FLAGS = 4 | 8 # BLK_XREF | BLK_XREF_OVERLAY def xref_definitions(doc) -> list[dict]: xrefs = [] for block in doc.blocks: try: head = block.block flags = int(head.dxf.get("flags", 0)) is_xref = bool(flags & BLK_XREF_FLAGS) or bool(getattr(block.block_record, "is_xref", False)) if is_xref: xrefs.append( { "name": str(block.name), "path": str(head.dxf.get("xref_path", "") or ""), "overlay": bool(flags & 8), } ) except Exception: continue return xrefs PLAN_TITLE_RE = re.compile(r"平面图$") PLAN_TITLE_EXCLUDE_RE = re.compile(r"(示意|疏散|分区|索引|定位|总平面|放大|详图|布置|大样)") # AutoCAD MIF escapes (\M+5XXXX): CJK text in pre-Unicode DWGs survives # DXF conversion as literal escape sequences, so title matching must decode # them first. The digit selects the codepage; XXXX is the hex byte pair. MIF_RE = re.compile(r"\\M\+([1-5])([0-9A-Fa-f]{4})") MIF_CODEPAGES = {"1": "cp932", "2": "big5", "3": "cp949", "4": "johab", "5": "gbk"} def decode_mif(text: str) -> str: if "\\M+" not in text: return text def repl(match: "re.Match[str]") -> str: value = int(match.group(2), 16) raw = value.to_bytes(2, "big") if value > 0xFF else value.to_bytes(1, "big") try: return raw.decode(MIF_CODEPAGES.get(match.group(1), "gbk")) except (UnicodeDecodeError, LookupError): return match.group(0) return MIF_RE.sub(repl, text) def count_plan_titles(entities) -> int: """Distinct plan-frame titles in modelspace (multi-frame sheet detector).""" seen = set() for entity in entities: kind = entity.dxftype() if kind not in {"TEXT", "MTEXT"}: continue try: text = str(entity.dxf.text if kind == "TEXT" else entity.plain_text() or "").strip() except Exception: continue text = decode_mif(text) if not text or len(text) > 40: continue if PLAN_TITLE_RE.search(text) and not PLAN_TITLE_EXCLUDE_RE.search(text): try: pos = entity.dxf.insert seen.add((text, round(float(pos.x) / 5000), round(float(pos.y) / 5000))) except Exception: seen.add((text, 0, 0)) return len(seen) def insert_block_content(doc, entities) -> list[dict]: """Entity counts of blocks referenced by modelspace INSERTs. AutoCAD stores unbound-XREF content as CACHED block definitions inside the host DWG (13号: X-00-0011 held 5,306 entities while msp had 3 stubs), and both libredwg and ODA export that cache as ordinary blocks. A "near empty" msp made of INSERT stubs therefore often has ALL its geometry in-file — expand_blocks ≈ bind, no re-export needed. """ names = {str(e.dxf.name) for e in entities if e.dxftype() == "INSERT"} out = [] for name in names: try: block = doc.blocks[name] except Exception: continue count = sum(1 for _ in block) if count >= 100: out.append({"name": name, "entities": count}) return sorted(out, key=lambda b: -b["entities"])[:8] def file_warnings(item: dict) -> list[str]: warnings = [] entities = item.get("modelspace_entities") xrefs = item.get("xref_definitions", []) if entities is None: return warnings plan_titles = item.get("plan_title_count", 0) if plan_titles >= 2: warnings.append( f"multi_frame_sheet: {plan_titles} plan-frame titles (XX平面图) found in ONE modelspace. " "This file holds a whole sheet set — never model it as a single floor and never stack frames " "without per-floor offsets. Run scripts/detect_sheet_frames.py to generate clip/offset config." ) # Unfamiliar layer dialect: a plan file whose layers match NO known wall # naming (*WALL*/*墙*/QIANG) means a design institute convention this # pipeline has never seen — the layer mapping must be built consciously, # or extraction silently captures nothing (patterns age, invariants don't). wall_dialects = ("*WALL*", "*墙*", "*QIANG*") layer_names = [layer["name"] for layer in item.get("layers", []) if layer.get("entity_count", 0) > 0] if ( plan_titles >= 1 and (entities or 0) >= 400 and layer_names and not any(fnmatch.fnmatch(n.upper(), p.upper()) for n in layer_names for p in wall_dialects) ): tops = ", ".join(layer["name"] for layer in item.get("top_layers", [])[:8]) warnings.append( f"unknown_layer_dialect: {plan_titles} plan title(s) but no wall-like layer " f"(*WALL*/*墙*) among {len(layer_names)} populated layers — an unfamiliar design-institute " f"convention. Map layers consciously before modeling (top layers: {tops})." ) cached = item.get("insert_block_content") or [] cached_total = sum(b["entities"] for b in cached) if entities < NEAR_EMPTY_ENTITY_THRESHOLD and cached_total >= 200: names = ", ".join(f"{b['name']}({b['entities']})" for b in cached[:4]) warnings.append( f"cached_xref_content: modelspace is only {entities} entities (INSERT stubs) but " f"block definitions cached INSIDE this file hold {cached_total} entities ({names}). " "The referenced content is already in the file — expand blocks in detect/derive " "(expand_blocks ≈ bind); do NOT ask for a re-exported bound DWG." ) elif xrefs and entities < NEAR_EMPTY_ENTITY_THRESHOLD: names = ", ".join(x["name"] for x in xrefs[:4]) warnings.append( f"likely_xref_shell: only {entities} entities but {len(xrefs)} XREF definition(s) ({names}). " "Real geometry lives in the external reference. Bind/insert the XREFs in CAD and re-export this DXF " "before modeling, otherwise this sheet contributes an empty floor." ) elif entities < NEAR_EMPTY_ENTITY_THRESHOLD: warnings.append( f"near_empty: only {entities} entities (annotation shell?). " "Confirm with the user whether this sheet should contain geometry; if it is a plan, " "the source export is incomplete (unbound XREF or wrong layout)." ) elif xrefs: names = ", ".join(x["name"] for x in xrefs[:4]) warnings.append( f"has_xref_definitions: {len(xrefs)} XREF definition(s) ({names}). " "Entities inside unbound XREFs are NOT in modelspace; verify nothing essential is referenced externally." ) return warnings def inspect_file(path: Path, ezdxf, bbox, recover) -> dict: messages: list[str] = [] try: doc, recover_messages = read_doc(path, ezdxf, recover) messages.extend(recover_messages) msp = doc.modelspace() entities = list(msp) type_counts = Counter(entity.dxftype() for entity in entities) layer_counts = Counter(str(entity.dxf.layer) for entity in entities if entity.dxf.hasattr("layer")) try: geometry_bbox = bbox_tuple(bbox.extents(entities, fast=True)) except Exception as exc: # bbox can fail on unsupported proxy geometry. geometry_bbox = None messages.append(f"bbox failed: {exc}") layers = [] for layer in doc.layers: name = layer.dxf.name layers.append( { "name": name, "color": int(layer.dxf.color), "is_off": bool(layer.is_off()), "is_frozen": bool(layer.is_frozen()), "entity_count": layer_counts.get(name, 0), } ) header = doc.header insunits = int(header.get("$INSUNITS", 0) or 0) result = { "file": path.name, "path": str(path), "status": "ok", "acadver": str(header.get("$ACADVER", "")), "insunits": insunits, "measurement": int(header.get("$MEASUREMENT", 0) or 0), "unit_guess": guess_unit_scale(geometry_bbox, insunits), "modelspace_entities": len(entities), "plan_title_count": count_plan_titles(entities), "entity_types": dict(type_counts.most_common()), "top_layers": [{"name": name, "entity_count": count} for name, count in layer_counts.most_common(30)], "layer_count": len(layers), "layers": sorted(layers, key=lambda item: (-item["entity_count"], item["name"])), "bbox": geometry_bbox, "messages": messages, "xref_definitions": xref_definitions(doc), "insert_block_content": insert_block_content(doc, entities), } result["warnings"] = file_warnings(result) return result except Exception as exc: return {"file": path.name, "path": str(path), "status": "failed", "messages": [str(exc)]} def markdown_report(results: list[dict], conversions: list[dict], input_dir: Path) -> str: lines = [ "# CAD Read Report", "", f"Input: `{input_dir}`", "", ] all_warnings = [(item["file"], warning) for item in results for warning in item.get("warnings", [])] if all_warnings: lines.extend(["## Warnings (resolve before modeling)", ""]) for file_name, warning in all_warnings: lines.append(f"- `{file_name}`: {warning}") lines.append("") lines.extend( [ "## Files", "", "| File | Status | Entities | Layers | Size X | Size Y | Unit Guess | Main Types |", "| --- | --- | ---: | ---: | ---: | ---: | --- | --- |", ] ) for item in results: bbox_data = item.get("bbox") or {} size = bbox_data.get("size", ["", "", ""]) unit = item.get("unit_guess", {}) unit_text = f"{unit.get('source_units', '')} x{unit.get('scale_to_meters', '')}" types = ", ".join(f"{k}:{v}" for k, v in list(item.get("entity_types", {}).items())[:5]) lines.append( f"| {item['file']} | {item.get('status', '')} | {item.get('modelspace_entities', '')} | " f"{item.get('layer_count', '')} | {size[0]} | {size[1]} | {unit_text} | {types} |" ) if conversions: lines.extend(["", "## DWG Conversion", ""]) for conv in conversions: lines.append(f"- `{Path(conv['source']).name}` -> `{Path(conv['dest']).name}`: {conv['status']}") lines.extend(["", "## Top Layers", ""]) for item in results: lines.append(f"### {item['file']}") for layer in item.get("top_layers", [])[:12]: lines.append(f"- `{layer['name']}`: {layer['entity_count']}") for message in item.get("messages", [])[:8]: lines.append(f"- message: `{message}`") lines.append("") return "\n".join(lines) def output_paths(output: Path) -> tuple[Path, Path]: if output.suffix: return output.with_suffix(".json"), output.with_suffix(".md") output.mkdir(parents=True, exist_ok=True) return output / "cad_read_report.json", output / "cad_read_report.md" def scrub_surrogates(value): """Make report data JSON-writable when ezdxf's recover mode leaks surrogate-escaped bytes (broken files read with errors="surrogateescape"). CJK bytes are recovered via GBK where possible; the batch never dies on one corrupt drawing.""" if isinstance(value, str): try: value.encode("utf-8") return value except UnicodeEncodeError: raw = value.encode("utf-8", errors="surrogateescape") try: return raw.decode("gbk") except UnicodeDecodeError: return raw.decode("utf-8", errors="replace") if isinstance(value, dict): return {scrub_surrogates(k): scrub_surrogates(v) for k, v in value.items()} if isinstance(value, list): return [scrub_surrogates(item) for item in value] return value def main() -> int: args = parse_args() input_dir = Path(args.input) work_dir = Path(args.work) raw_dir = work_dir / "dxf_raw" clean_dir = work_dir / "dxf_sanitized" vendor_dir = Path(args.vendor_dir) ezdxf, bbox, recover = import_ezdxf(vendor_dir) if not input_dir.exists(): raise SystemExit(f"Input folder not found: {input_dir}") if args.allow_partial and not (args.partial_reason or "").strip(): raise SystemExit("--allow-partial requires --partial-reason") # These folders are generated intermediates. Recreate them so a source # removed between runs cannot survive as a stale DXF and enter modeling. shutil.rmtree(raw_dir, ignore_errors=True) shutil.rmtree(clean_dir, ignore_errors=True) raw_dir.mkdir(parents=True, exist_ok=True) clean_dir.mkdir(parents=True, exist_ok=True) cad_files = find_cad_files(input_dir) used_names: set[str] = set() conversions: list[dict] = [] raw_dxfs: list[Path] = [] assigned = [(source, raw_dir / safe_name(source, used_names)) for source in cad_files] oda_outputs: dict[Path, Path] = {} if args.converter == "oda" and not args.no_convert: oda_outputs = run_oda_batch( [source for source, _dest in assigned if source.suffix.lower() == ".dwg"], work_dir, ) for source, dest in assigned: if source.suffix.lower() == ".dwg": if args.no_convert: continue if args.converter == "oda": produced = oda_outputs.get(source) if produced: dest.parent.mkdir(parents=True, exist_ok=True) shutil.copy2(produced, dest) conversion = {"source": str(source), "dest": str(dest), "status": "oda_ok"} else: conversion = {"source": str(source), "dest": str(dest), "status": "oda_failed"} else: conversion = run_dwg2dxf(source, dest) conversions.append(conversion) if conversion["status"] in {"ok", "oda_ok"}: raw_dxfs.append(dest) else: if source.resolve() != dest.resolve(): shutil.copy2(source, dest) raw_dxfs.append(dest) sanitized: list[Path] = [] for raw in raw_dxfs: dest = clean_dir / raw.name removed = sanitize_dxf_comments(raw, dest) sanitized.append(dest) if removed: conversions.append({"source": str(raw), "dest": str(dest), "status": f"sanitized_{removed}_comments"}) results = [inspect_file(path, ezdxf, bbox, recover) for path in sorted(sanitized)] # ODA auto-fallback: libredwg chokes on some TArch DWGs (duplicate handles, # missing ENDBLK/EOF) or yields an empty modelspace even when the drawing # is full — the 黄桥 plans sheet read 0 entities via dwg2dxf but 21k via # ODA. Reconvert those sources through ODA when it is available. dwg_dest_to_source = { Path(c["dest"]).name: Path(c["source"]) for c in conversions if str(c.get("source", "")).lower().endswith(".dwg") and c.get("dest") } retry: dict[str, Path] = {} for item in results: src = dwg_dest_to_source.get(item.get("file", "")) if src and (item.get("status") == "failed" or item.get("modelspace_entities") == 0): retry[item["file"]] = src for c in list(conversions): if c.get("status") in {"failed", "missing_dwg2dxf"} and str(c.get("source", "")).lower().endswith(".dwg"): name = Path(c["dest"]).name if c.get("dest") else Path(c["source"]).with_suffix(".dxf").name retry.setdefault(name, Path(c["source"])) if retry and args.converter == "auto": produced = run_oda_batch(list(retry.values()), work_dir) for name, src in retry.items(): out = produced.get(src) if not out: conversions.append({"source": str(src), "dest": "", "status": "oda_fallback_failed"}) continue raw_dest = raw_dir / name shutil.copy2(out, raw_dest) clean_dest = clean_dir / name sanitize_dxf_comments(raw_dest, clean_dest) item = inspect_file(clean_dest, ezdxf, bbox, recover) replaced = False for i, existing in enumerate(results): if existing.get("file") == name: results[i] = item replaced = True break if not replaced: results.append(item) conversions.append({"source": str(src), "dest": str(raw_dest), "status": "oda_fallback_ok"}) results.sort(key=lambda r: r.get("file", "")) json_path, md_path = output_paths(Path(args.output)) json_path.parent.mkdir(parents=True, exist_ok=True) md_path.parent.mkdir(parents=True, exist_ok=True) payload = { "report_version": 1, "input": str(input_dir.resolve()), "work": str(work_dir.resolve()), "dxf_sanitized": str(clean_dir.resolve()), "conversions": conversions, "files": results, } # --no-convert is a diagnostic convenience, not permission to silently # exclude DWGs from the source ledger. A mixed folder therefore fails the # hard gate until every DWG is converted or the run is explicitly partial. dwg_sources = {str(path) for path in cad_files if path.suffix.lower() == ".dwg"} successful_dwg_sources = { str(item.get("source")) for item in conversions if item.get("status") in {"ok", "oda_ok", "oda_fallback_ok"} } unresolved_dwgs = sorted(dwg_sources - successful_dwg_sources) failed_files = [item.get("file", "?") for item in results if item.get("status") != "ok"] empty_files = [ item.get("file", "?") for item in results if item.get("status") == "ok" and item.get("modelspace_entities") == 0 ] issues = [] if not cad_files: issues.append("input contains no DWG/DXF files") if unresolved_dwgs: issues.append("unconverted DWG files: " + ", ".join(Path(path).name for path in unresolved_dwgs)) if failed_files: issues.append("unreadable DXF files: " + ", ".join(failed_files)) if empty_files: issues.append("zero-entity DXF files: " + ", ".join(empty_files)) if not results: issues.append("no readable DXF files were produced") payload["gate"] = { "name": "all_sources_converted_and_readable", "status": "WARN" if issues and args.allow_partial else ("FAIL" if issues else "PASS"), "detail": "; ".join(issues) if issues else f"{len(results)} DXF file(s) readable", "partial_reason": args.partial_reason if issues and args.allow_partial else None, } payload = scrub_surrogates(payload) results = payload["files"] json_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8") gate = payload["gate"] gate_md = ( "## Source Gate\n\n" f"- **{gate['status']}** `{gate['name']}`: {gate['detail']}" + (f"\n- Partial reason: {gate['partial_reason']}" if gate.get("partial_reason") else "") + "\n\n" ) md_path.write_text(gate_md + markdown_report(results, conversions, input_dir), encoding="utf-8") print(json.dumps({"json": str(json_path), "markdown": str(md_path), "files": len(results)}, ensure_ascii=False)) if issues and not args.allow_partial: for issue in issues: print(f"GATE FAIL [all_sources_converted_and_readable]: {issue}", file=sys.stderr) return 3 return 0 if __name__ == "__main__": raise SystemExit(main())