Aislo/M02_MasterTemplete/M02_MasterTemplete_Store.py

"""M02 마스터 템플릿 — 층 저장소 · 기본 시스템 층(`resources/master_template/{종류}/<이름>.json`).

M01 `Store` 방식 — 판(파일 sha256 앞 16자) · 판이 다르면 409 · 원자 쓰기.
권한은 등록하는 쪽(`main.py`)이 붙임.
"""

from __future__ import annotations

import hashlib
import json
import re
import threading
from collections.abc import Iterator
from contextlib import contextmanager
from contextvars import ContextVar
from datetime import datetime
from pathlib import Path
from typing import Any

from common_util import common_util_spreadsheet as spreadsheet
from common_util.common_util_json import atomic_write_json
from M02_MasterTemplete import M02_Template_Layers as layers

FOLDER: Path = Path(__file__).resolve().parent.parent / "resources" / "master_template"
KINDS = layers.KINDS  # 시험은 FOLDER 를 사본으로 바꿈
# 지금 다루는 층 폴더 — 층 라우터가 `at(층 폴더)` 로 바꿈 · 안 바꾸면 시스템 층(`FOLDER`).
# 회사 · 개인 층도 시스템과 같은 모양(`table/구조물집계표.json` · 조합 장부 ·
# structure/area/material · 자재조합.json — PLAN 21-1)이라 아래 함수는 그대로 씀
_ROOT: ContextVar[Path | None] = ContextVar("m02_layer_root", default=None)


def root() -> Path:
    return _ROOT.get() or FOLDER


@contextmanager
def at(folder: str | Path) -> Iterator[Path]:
    """이 안에서 부르는 저장소 함수는 `folder` 층을 봄(요청 하나 · 스레드 하나 안에서만)."""
    token = _ROOT.set(Path(folder))
    try:
        yield Path(folder)
    finally:
        _ROOT.reset(token)


# 구조물집계표 구조물 열(꼴=수) 마다 세 파일(파일 이름 = 열 id) —
#   구조물 도면 `structure/` (도각 없는 전용 화면) · 면적산출 `area/` · 재료산출 `material/`
#   (둘 다 스프레드시트 통합문서)
# 번호 = 도번 SD · 면적번 SA · 재료번 SM + 8자리 [종류][분류1][분류2][분류3]
# (제목행 = 열 `머리` 네 층 · 없는 층 00) — 한 열의 세 번호는 같은 8자리 ·
# 한 번 준 번호는 파일에 남아 안 바뀜(PLAN 13장)
STRUCTURE_TABLE = "구조물집계표"
# 프로그램이 이름으로 부르는 양식 — 지우면 그 기능이 죽음(B07 이름은 `B07_DesignDetail_Engine_*`)
IN_USE = {
    ("table", STRUCTURE_TABLE): "구조물 도면 · 면적산출 · 재료산출 · 조합 장부가 씀",
    ("drawing", "00_template_A1"): "B07 도면 도각",
    ("drawing", "00_template_compass"): "B07 방위표",
    ("drawing", "00_template_cover"): "B07 표지",
}
# (종류, 문서 번호 칸, 머리 글자, 시트 이름) — 시트 이름이 None 이면 구조물 도면
PARTS = (
    ("structure", "도번", "SD", None),
    ("area", "면적번", "SA", "면적산출"),
    ("material", "재료번", "SM", "재료산출"),
)
_KEY = {kind: key for kind, key, _, _ in PARTS}
SHEETS = ("area", "material")  # 통합문서 종류 — [저장] 때 서버가 계산값을 새로 적음
_LEVELS = 4
_CODE = re.compile(r"^S[DAM](\d{8})$")
_OLD_CODE = re.compile(r"^S[DCA](\d{6})$")  # PLAN 12장 6자리 — 끝에 00 을 붙여 읽음
_BAD_NAME = re.compile(r'[\\/:*?"<>|\x00-\x1f]|\.\.')
# 도각 없는 빈 CAD 문서의 기본 도면층 — 없으면 B07 CAD 가 못 엶("Cannot read properties
# of undefined (reading 'length')") · CAD 쪽도 없으면 새로 채우지만(2026-09-27 sub1 고침)
# 뿌리도 처음부터 채움
_BLANK_LAYER = {"id": "기본", "name": "기본", "isVisible": True, "isLocked": False}
# ponytail: 저장은 한 번에 하나(프로세스 안 잠금) · 서버를 여럿 띄우면 파일 잠금으로
_LOCK = threading.Lock()


class StoreError(Exception):
    def __init__(self, status: int, detail):
        super().__init__(detail)
        self.status, self.detail = status, detail


def version_of(raw: bytes) -> str:
    return hashlib.sha256(raw).hexdigest()[:16]


def _path(kind: str, name: str) -> Path:
    if kind not in KINDS:
        raise StoreError(404, f"없는 종류 「{kind}」")
    if (
        not name
        or name != name.strip()
        or name.startswith((".", "_"))  # `_` 도 막음 — 새 프로젝트 복사(layers.check_name)가 거절함
        or len(name) > 80  # 파일 이름이 길면 OS 가 죽음(500) — 화면 규칙과 같은 80자
        or _BAD_NAME.search(name)
    ):
        raise StoreError(400, f"쓸 수 없는 글자가 있는 이름 「{name}」")
    return root() / kind / f"{name}.json"


def _info(kind: str, path: Path) -> dict[str, Any]:
    raw = path.read_bytes()
    stamp = datetime.fromtimestamp(path.stat().st_mtime).isoformat(timespec="seconds")
    row = {"종류": kind, "이름": path.stem, "판": version_of(raw), "수정일": stamp}
    if (kind, path.stem) in IN_USE:
        row["쓰는곳"] = IN_USE[(kind, path.stem)]  # 화면이 지우기 확인 창 전에 막음
    return row


def list_all() -> list[dict[str, Any]]:
    rows = [
        _info(kind, p)
        for kind in KINDS
        for p in sorted((root() / kind).glob("*.json"))
        if not p.name.startswith(".")
    ]
    return rows


def read(kind: str, name: str) -> dict[str, Any]:
    path = _path(kind, name)
    if not path.is_file():
        raise StoreError(404, f"없는 양식 「{name}」")
    raw = path.read_bytes()
    return {"종류": kind, "이름": name, "판": version_of(raw), "문서": json.loads(raw)}


def _check_skeleton(kind: str, doc: Any) -> None:
    """빈 문서·뼈대 없는 문서는 거절 — 층 저장과 같은 규칙(`layers.check_skeleton`)."""
    try:
        layers.check_skeleton(kind, doc)
    except ValueError as e:
        raise StoreError(400, str(e)) from e


def write(kind: str, name: str, version: str, doc: Any) -> dict[str, Any]:
    """`version` 이 빈 글이면 새로 만듦(이미 있으면 409) · 아니면 그 판일 때만 덮어씀.
    구조물집계표를 저장하면 — 새 구조물 열의 빈 구조물 도면 · 면적산출 · 재료산출을 번호와 같이
    만들고 지운 열(또는 구조물이 아니게 된 열)의 세 파일을 지움(잠금 밖에서 · 안에서 부르면 죽음).
    통합문서(area · material)는 서버가 같은 TS 엔진을 Node 로 돌려 `계산값` 을 새로 적음
    (브라우저 값 버림 · 5장 ②) · 알약 `연결` 은 문서와 같이 그대로 적힘.
    번호 칸(도번 · 면적번 · 재료번)은 서버 것 — 있던 파일 번호를 그대로 둠(화면 값을 안 받음).
    표 열의 `본뜬열`(분류 더하기로 복사한 새 열)은 적지 않음 — 집계표면 아직 파일이 없는 새 열이
    원본 열의 일위대가 · 자재조합 키와 세 파일 내용을 받음(새 번호 · 그 뒤로는 열마다 따로)."""
    path = _path(kind, name)
    _check_skeleton(kind, doc)
    origins = _take_origins(doc) if kind == "table" else {}
    if kind in SHEETS:
        doc = _server_values(doc)
    with _LOCK:
        have = version_of(path.read_bytes()) if path.is_file() else ""
        if have != (version or ""):
            raise StoreError(409, {"stale": [name], "판": have})
        if have and kind in _KEY:
            number = json.loads(path.read_bytes()).get(_KEY[kind])
            doc = {**doc, _KEY[kind]: number} if number else doc
        atomic_write_json(path, doc)
        info = _info(kind, path)
    if kind == "table" and name == STRUCTURE_TABLE:
        for column, source in origins.items():  # 빈 파일 채우기 앞 — 원본 내용으로 만듦
            for part in _KEY:
                _ensure(part, column, source)
        backfill_missing_structures()  # 지우기 앞 — 같은 저장의 새 열이 지운 번호를 안 받게
        prune_removed_structures()
        sync_combos()  # 번호가 다 선 뒤 — 조합 표 도번 · 면적번 · 재료번 칸
    return info


def delete(kind: str, name: str, version: str | None = None) -> None:
    path = _path(kind, name)
    if (kind, name) in IN_USE:
        raise StoreError(409, f"쓰는 양식이라 못 지움 「{name}」 — {IN_USE[(kind, name)]}")
    with _LOCK:
        if not path.is_file():
            raise StoreError(404, f"없는 양식 「{name}」")
        if version is not None and version_of(path.read_bytes()) != version:
            raise StoreError(409, {"stale": [name], "판": version_of(path.read_bytes())})
        path.unlink()


# ── 구조물 도면 · 면적산출 · 재료산출 ─────────────────────


def _docs(kind: str) -> list[tuple[str, Any]]:
    folder = root() / kind
    return [(p.stem, json.loads(p.read_bytes())) for p in sorted(folder.glob("[!.]*.json"))]


def _code(doc: Any, key: str) -> str | None:
    """문서의 번호 8자리 — 12장 6자리는 끝에 00 · 옛 `구-01` · `표-01` · 없음은 None."""
    text = str(doc.get(key) or "") if isinstance(doc, dict) else ""
    if found := _CODE.match(text):
        return found.group(1)
    found = _OLD_CODE.match(text)
    return found.group(1) + "00" if found else None


def _codes() -> dict[str, str]:
    """`{열 id: 8자리}` — 구조물 도면 도번 먼저 · 없으면 면적번 · 재료번."""
    codes: dict[str, str] = {}
    for kind, key, _, _ in reversed(PARTS):
        codes.update({name: c for name, doc in _docs(kind) if (c := _code(doc, key))})
    return codes


def structure_numbers() -> dict[str, dict[str, str]]:
    """`{열 id: {도번, 면적번, 재료번}}` — 집계표 줄 · 좌측 줄이 한 번에 받음(없는 쪽은 빈 글)."""
    out: dict[str, dict[str, str]] = {}
    for kind, key, _, _ in PARTS:
        for name, doc in _docs(kind):
            row = out.setdefault(name, {k: "" for _, k, _, _ in PARTS})
            row[key] = str(doc.get(key) or "")
    return out


def _heads(col: dict[str, Any]) -> tuple[str | None, ...]:
    """제목행 네 층(종류 · 분류1 · 분류2 · 분류3) — 빈 층은 None."""
    parts = [*(col.get("머리") or []), *[None] * _LEVELS][:_LEVELS]
    return tuple((str(p).strip() if p is not None else "") or None for p in parts)


def _structure_columns() -> list[dict[str, Any]]:
    """번호 · 파일을 받는 열 — 꼴=수(NO · 측점 · 비고 같은 글 열은 구조물 아님)."""
    table = read("table", STRUCTURE_TABLE)["문서"]
    return [
        col
        for col in table.get("열", [])
        if isinstance(col, dict) and col.get("id") and col.get("꼴") == "수"
    ]


def _column_ids() -> list[str]:
    return [col["id"] for col in _structure_columns()]


def _pick_code(
    col: dict[str, Any],
    taken: dict[str, str],
    heads: dict[str, tuple],
    retired: list[str] | None = None,
) -> str:
    """새 열 번호 — 층마다 같은 무리(그 층까지 제목행이 같은 열)가 이미 번호를 가졌으면 그 두 자리를
    이어 받고 · 없으면 그 층 가장 큰 번호 + 1 · 빈 층(종류 밖)은 00 · 맨 아래 층(분류3)은 늘 다음
    번호. 같은 8자리가 이미 있으면(같은 제목행 · 빈 분류3 겹침) 맨 아래 층을 그 무리 다음 번호로.
    `taken` = 이미 번호 있는 열 `{열 id: 8자리}` · `heads` = 열 id → 제목행 ·
    `retired` = 지운 열의 번호(다시 안 줌 — 「가장 큰 번호」 · 겹침 셈에만 듦)."""
    parts = _heads(col)
    codes = [*taken.values(), *(retired or [])]
    mates = [(heads[cid], code) for cid, code in taken.items() if cid in heads]

    def next_of(prefix: str) -> str:
        at = slice(len(prefix), len(prefix) + 2)
        found = [int(c[at]) for c in codes if c.startswith(prefix)]
        return f"{max(found, default=0) + 1:02d}"

    code = ""
    for depth, head in enumerate(parts):
        if depth and head is None:
            code += "00"
            continue
        at = slice(2 * depth, 2 * depth + 2)
        group = parts[: depth + 1]
        same = (c[at] for h, c in mates if h[: depth + 1] == group and c.startswith(code))
        leaf = depth == _LEVELS - 1
        code += (None if leaf else next(same, None)) or next_of(code)
    if code in codes:
        code = code[:-2] + next_of(code[:-2])
    return code


def _new_code(column: str) -> str:
    """이 열이 쓸 8자리 — 짝 파일에 이미 있으면 그것 · 없으면 새로(잠금 안에서 부름)."""
    taken = _codes()
    if column in taken:
        return taken[column]
    cols = _structure_columns()
    col = next((c for c in cols if c["id"] == column), {"id": column})
    return _pick_code(col, taken, {c["id"]: _heads(c) for c in cols}, _retired())


def _retired() -> list[str]:
    """지운 열의 8자리 — 조합 장부 `지운번호`(한 번 준 번호는 다시 안 줌)."""
    path = root() / COMBO_FILE
    return json.loads(path.read_bytes()).get("지운번호", []) if path.is_file() else []


def _blank(kind: str, column: str) -> dict[str, Any]:
    """빈 문서(번호는 부르는 쪽이 붙임) — 구조물 도면 = 도각 없음 · 기본 도면층 하나 /
    면적산출 · 재료산출 = 진짜 빈 시트 하나(식 없어 `계산값` 없음 · 첫 [저장] 때 서버가 적음)."""
    if kind == "structure":
        return {
            "양식": "구조물도면",
            "종류": "structure",
            "판": 1,
            "열": column,
            "도면": {"format": 6, "entities": [], "layers": [dict(_BLANK_LAYER)]},
        }
    sheet = next(name for k, _, _, name in PARTS if k == kind)
    return {
        "종류": "통합문서",
        "판": 1,
        "열": column,
        "서식": [{}],
        "시트": [{"id": "s1", "이름": sheet, "칸": {}}],
        "활성": "s1",
    }


def _ensure(kind: str, column: str, source: str | None = None) -> bool:
    """그 열의 파일이 없으면 빈 문서를 번호(세 파일이 같은 8자리)와 같이 만듦 · 있으면 그대로.
    `source` 열 파일이 있으면 빈 문서 대신 그 내용(알약 `연결` 포함 · 계산값은 서버가 다시 풂)."""
    path = _path(kind, column)
    if path.is_file():
        return False
    head = next(h for k, _, h, _ in PARTS if k == kind)
    base = _blank(kind, column)
    if source and _path(kind, source).is_file():
        got = json.loads(_path(kind, source).read_bytes())
        base = {**{k: v for k, v in got.items() if k != "계산값"}, "열": column}
        if kind in SHEETS:
            base = _server_values(base)
    with _LOCK:
        if path.is_file():
            return False
        atomic_write_json(path, {**base, _KEY[kind]: head + _new_code(column)})
    return True


def _take_origins(doc: Any) -> dict[str, str]:
    """표 열의 `본뜬열` 을 떼어 냄 → `{새 열: 원본 열}` (구조물 파일이 아직 없는 열만) ·
    그 열에 일위대가 · 자재조합 키가 비었으면 원본 열 것을 받음."""
    cols = (
        [c for c in (doc.get("열") or []) if isinstance(c, dict)] if isinstance(doc, dict) else []
    )
    by_id = {c.get("id"): c for c in cols}
    out: dict[str, str] = {}
    for col in cols:
        source = col.pop("본뜬열", None)
        if not source or source not in by_id or not col.get("id"):
            continue
        if (root() / "structure" / f"{col['id']}.json").is_file():
            continue
        out[col["id"]] = source
        for field in ("일위대가", "자재조합"):
            col[field] = col.get(field) or by_id[source].get(field)
    return out


def create_structure(column: str) -> dict[str, Any]:
    """구조물 열 하나의 구조물 도면 새로 — 도번 SD + 8자리 · 이미 있으면 409.
    면적산출 · 재료산출 파일이 없으면 빈 통합문서도 같이 만듦(같은 8자리)."""
    if column not in _column_ids():
        raise StoreError(404, f"{STRUCTURE_TABLE}에 없는 구조물 열 「{column}」")
    if not _ensure("structure", column):
        raise StoreError(409, f"이미 있는 구조물 도면 「{column}」")
    for kind in SHEETS:
        _ensure(kind, column)
    return read("structure", column)


def copy_from(kind: str, column: str, source: str) -> dict[str, Any]:
    """다른 열(`source`) 내용을 받는 열(`column`)로 가져옴 — 번호 · 열은 받는 쪽 그대로(두 열은
    따로 움직임) · 통합문서는 알약 `연결` 도 같이 오고 계산값은 서버가 다시 풂."""
    if kind not in _KEY:
        raise StoreError(404, f"없는 종류 「{kind}」")
    target = read(kind, column)["문서"]
    doc = {**read(kind, source)["문서"], **{k: target.get(k) for k in ("열", _KEY[kind])}}
    if kind in SHEETS:
        doc = _server_values({k: v for k, v in doc.items() if k != "계산값"})
    with _LOCK:
        atomic_write_json(_path(kind, column), doc)
        return _info(kind, _path(kind, column))


def prune_removed_structures() -> list[str]:
    """집계표에서 지운 열(또는 구조물이 아니게 된 열)의 세 파일을 같이 지움 —
    번호는 비워 둠(다른 열 번호를 안 당김)."""
    keep = set(_column_ids())
    gone: list[str] = []
    codes: set[str] = set()
    with _LOCK:
        for kind, key, _, _ in PARTS:
            for path in sorted((root() / kind).glob("[!.]*.json")):
                if path.stem not in keep:
                    code = _code(json.loads(path.read_bytes()), key)
                    codes.update([code] if code else [])
                    path.unlink()
                    gone.append(f"{kind}/{path.stem}")
        if codes:  # 지운 번호는 장부에 남겨 새 열이 다시 안 받게
            book = root() / COMBO_FILE
            doc = json.loads(book.read_bytes()) if book.is_file() else {}
            doc["지운번호"] = sorted(codes | set(doc.get("지운번호", [])))
            atomic_write_json(book, doc)
    return gone


def _move_basis() -> list[str]:
    """12장 산출근거 `basis/` → 면적산출 `area/` (내용 · 알약 연결 그대로 · 표번 칸 → 면적번 ·
    시트 이름 산출근거 → 면적산출) · 옮긴 뒤 빈 `basis/` 폴더를 지움."""
    old = root() / "basis"
    if not old.is_dir():
        return []
    moved: list[str] = []
    with _LOCK:
        for path in sorted(old.glob("[!.]*.json")):
            doc = json.loads(path.read_bytes())
            doc["면적번"] = doc.pop("표번", None)  # 번호는 renumber 가 SA 8자리로
            for sheet in doc.get("시트") or []:
                if isinstance(sheet, dict) and sheet.get("이름") == "산출근거":
                    sheet["이름"] = "면적산출"
            target = _path("area", path.stem)
            if not target.is_file():
                atomic_write_json(target, doc)
            path.unlink()
            moved.append(path.stem)
        if not any(old.iterdir()):
            old.rmdir()
    return moved


def renumber() -> dict[str, list[str]]:
    """한 번 — 옛 산출근거를 면적산출로 옮김 · 옛 번호(6자리 · 구-NN · 표-NN · 없음)를 8자리로
    (6자리는 끝에 00 · 없는 열 차례 = 종류 · 분류1 · 분류2 · 분류3 차례) ·
    구조물 아닌 열 파일 지움 · 빠진 파일(재료산출 등) 만듦. 내용은 그대로 · 두 번 돌려도 같음."""
    moved = _move_basis()
    gone = prune_removed_structures()
    changed: list[str] = []
    made: list[str] = []
    with _LOCK:
        cols = _structure_columns()
        heads = {c["id"]: _heads(c) for c in cols}
        taken = _codes()
        retired = _retired()
        for col in cols:
            if col["id"] not in taken:
                taken[col["id"]] = _pick_code(col, taken, heads, retired)
        docs = {kind: dict(_docs(kind)) for kind in _KEY}
        for col in cols:
            cid = col["id"]
            for kind, key, head, _ in PARTS:
                number = f"{head}{taken[cid]}"
                doc = docs[kind].get(cid)
                if doc is None:
                    atomic_write_json(_path(kind, cid), {**_blank(kind, cid), key: number})
                    made.append(f"{kind}/{cid}")
                elif doc.get(key) != number:
                    doc[key] = number
                    atomic_write_json(_path(kind, cid), doc)
                    changed.append(f"{kind}/{cid}")
    return {"옮김": moved, "지움": gone, "바꿈": changed, "새로": made}


def _server_values(doc: Any) -> dict[str, Any]:
    try:
        return spreadsheet.with_server_values(doc)
    except spreadsheet.RecalcError as e:
        raise StoreError(503, str(e)) from e


def backfill_missing_structures() -> list[str]:
    """구조물 열마다 세 파일이 있게 — 없는 것만 열 차례로 새로 만듦(그 무리 다음 번호).
    그 사이 남이 만들었으면 그대로 둠."""
    made: list[str] = []
    for cid in _column_ids():
        made += [f"{kind}/{cid}" for kind in _KEY if _ensure(kind, cid)]
    return made


# ── 구조물집계표조합 ─────────────────────
# 구조물 열마다 줄 하나(제어용 장부 · 관리자는 집계표 화면으로 고침 · 서버가 집계표로 맞춤) ·
# 키 = SS + 6자리 · 한 번 준 키는 그 열에 남음 · 지운 열의 키는 다시 안 씀(`다음` 이 기억)
COMBO_FILE = layers.COMBO_FILE
_COMBO_HEAD = "SS"
_COMBO_NOTE = (
    "구조물집계표 구조물 열(꼴=수)마다 한 줄 · 서버가 집계표 [저장] 때 맞춤(손으로 고치지 않음) · "
    "키 SS 는 한 번 주면 안 바뀌고 지운 열의 키는 다시 안 씀"
)


def _combo_row(key: str, col: dict[str, Any], numbers: dict[str, str]) -> dict[str, Any]:
    kind, level1, level2, level3 = _heads(col)
    return {
        "키": key,
        "열": col["id"],
        "종류": kind,
        "분류1": level1,
        "분류2": level2,
        "분류3": level3,
        "단위": col.get("단위"),
        "일위대가": col.get("일위대가"),
        "자재조합": col.get("자재조합"),
        **{field: numbers.get(field, "") for _, field, _, _ in PARTS},
        "바인딩": col.get("바인딩"),
        "펼침": col.get("펼침"),
    }


def sync_combos() -> dict[str, Any]:
    """조합 표를 집계표에 맞춤 — 새 열 = 새 SS 키 · 지운 열 = 줄 지움 · 고친 열 = 칸 갱신 ·
    줄 차례 = 집계표 열 차례. 바뀐 것이 없으면 파일을 안 씀."""
    path = root() / COMBO_FILE
    with _LOCK:
        old = json.loads(path.read_bytes()) if path.is_file() else {}
        keys = {row["열"]: row["키"] for row in old.get("줄", [])}
        taken = [int(k[len(_COMBO_HEAD) :]) for k in keys.values()]
        after = max(old.get("다음", 1), max(taken, default=0) + 1)
        numbers = structure_numbers()
        rows = []
        for col in _structure_columns():
            if col["id"] not in keys:
                keys[col["id"]] = f"{_COMBO_HEAD}{after:06d}"
                after += 1
            rows.append(_combo_row(keys[col["id"]], col, numbers.get(col["id"], {})))
        doc = {"그룹": "구조물집계표조합", "판": 1, "비고": _COMBO_NOTE, "다음": after}
        if old.get("지운번호"):
            doc["지운번호"] = old["지운번호"]  # 지운 열의 도번 8자리 — 다시 안 줌
        doc["줄"] = rows
        if doc != old:
            atomic_write_json(path, doc)
    return doc


def read_combos() -> dict[str, Any]:
    """조합 표 — 파일이 아직 없으면 지금 열 전부로 처음 한 번 만듦."""
    path = root() / COMBO_FILE
    return json.loads(path.read_bytes()) if path.is_file() else sync_combos()