diff --git a/A00_Common/line_stack_screen.ts b/A00_Common/line_stack_screen.ts index 3f686bf8d..0fb1bbb6b 100644 --- a/A00_Common/line_stack_screen.ts +++ b/A00_Common/line_stack_screen.ts @@ -533,7 +533,10 @@ export function createStackScreen(opt: StackScreenOptions) { const save = async (job?: Record, done = ft("Saved")): Promise => { await loading; // 새 로직 저장 뒤 여는 중이면 다 읽고(캐시 이어 받음) if (!doc || (!job && !dirty())) return true; - const send = job ?? (cp ? { 문서: doc, 끊음: cut, 판: version, ...pending() } : { 문서: doc }); + // M01 = 읽을 때 받은 판도(그 사이 다른 곳에서 바뀌면 409 · 덮지 않음) + const send = + job ?? + (cp ? { 문서: doc, 끊음: cut, 판: version, ...pending() } : { 문서: doc, 판: version }); const was = saved; showLoadingOverlay(); try { diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index e273dd7af..767827b1f 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -16,6 +16,8 @@ from __future__ import annotations import json +import os +import threading from decimal import Decimal from pathlib import Path @@ -30,12 +32,33 @@ import master_equation_link as link # noqa: E402 OWN_FILE = "수식_자체.json" _memo: dict = {} +# 수식 문서 쓰기 한 번에 하나 — 저장 · 지움 · 기계 고르기 목록 등록(`Machine._register_docs`) +# ponytail: 프로세스 안 잠금(`Store._LOCK` 과 같은 한계) · 서버를 여럿 띄우면 파일 잠금으로 +_LOCK = threading.Lock() +_HOME = Path(ml.__file__).resolve().parents[1] # 저장소 정본 마스터 폴더 +STALE = "그 사이 파일이 바뀜 — 고친 것을 버리고 다시 여세요: {v}" # 화면 `Save_Stale` 과 같은 글 def folder() -> Path: return ml.FOLDER +def version_of(doc: dict | None) -> str: + """문서 한 장의 판(저장 글 기준) — 저장본 없음 = 빈 글.""" + return "" if doc is None else store.version_of(ml.dump(doc).encode("utf-8")) + + +def put(path: Path, data: dict) -> None: + """수식 문서 파일 한 벌 — 임시 파일 → 교체(원자적) · `_LOCK` 안에서 부름. + 마스터만 사본으로 바꾼 시험(`Store.FOLDER` ≠ 정본)이 정본 수식 문서를 쓰지 않게 건너뜀.""" + if path.resolve().parent.parent == _HOME and Path(store.FOLDER).resolve() != _HOME: + return + tmp = path.with_name(f".{path.name}.tmp") + tmp.write_text(ml.dump(data), encoding="utf-8", newline="\n") + os.replace(tmp, path) + _memo.clear() + + def _stamp() -> tuple: return tuple((p.name, p.stat().st_mtime_ns) for p in sorted(folder().glob("수식_*.json"))) @@ -95,7 +118,8 @@ def read(key: str) -> dict: out = _run(found) up = None if fresh else built(key) more = {"층바탕": {"위": up}} if up is not None else {} - return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, **more} + 판 = version_of(None if fresh else found) # 저장 때 대조(다른 곳에서 바뀌면 409) + return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, "판": 판, **more} def preview(doc: dict, given: dict | None = None) -> dict: @@ -130,6 +154,48 @@ def built(key: str) -> dict | None: return None +def make(key: str) -> bool: + """[로직 복사/생성](`Store_Make.logic_new`) 뒤 수식 문서를 지어 씀 — 빌더(`build_수식문서_802_2`)와 + 같은 변환 · 같은 대조(옛 엔진 = 새 계산기 · 기본 + 옵션 표본 · 부르는 단가산출이 저장본)를 지난 것만 + (빌더도 그것만 넣음 · 못 지나면 안 씀 = 열면 빈 문서) · 이미 있으면 그대로 · 썼거나 있음 = True.""" + import importlib + + builder = importlib.import_module("build_수식문서_802_2") + files, whole = store.loaded() + row = next( + ( + r + for data in files.values() + if data.get("그룹") == "로직" + for r in data.get("줄") or [] + if str(r.get("키")) == key + ), + None, + ) + doc = built(key) if row is not None else None + if doc is None: + return False + with _LOCK: + have = docs() + if key in have: + return True + links = ml.Links(whole, {**have, key: doc}) + if not builder._calls(doc) <= set(have) or not all( + builder.agree( + builder.old_answer(whole, row, given), builder.new_answer(links, doc, one) + ) + for _, given, one in builder.cases_of(whole, row) + ): + return False + path = folder() / _file_for(key) + data = ( + ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []} + ) + data.setdefault("줄", []).append(doc) + put(path, data) + return True + + def layered(doc: dict, key: str) -> dict: """848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 · 다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로.""" @@ -150,22 +216,27 @@ def layered(doc: dict, key: str) -> dict: return out -def save(doc: dict) -> dict: +def save(doc: dict, 판: str | None = None) -> dict: + """`판` = 읽을 때 받은 판(없음 = 대조 안 함 · 빈 글 = 저장본 없던 문서) · 다르면 409.""" doc = _check(doc) key = str(doc["키"]).strip() - doc = layered(doc, key) - name = _file_for(key) - path = folder() / name - data = ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []} - rows = data.setdefault("줄", []) - at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None) - if at is None: - rows.append(doc) - else: - rows[at] = doc - path.write_text(ml.dump(data), encoding="utf-8", newline="\n") - _memo.clear() - return {"문서": doc, **_run(doc), "파일": name} + with _LOCK: + doc = layered(doc, key) + name = _file_for(key) + path = folder() / name + data = ( + ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []} + ) + rows = data.setdefault("줄", []) + at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None) + if 판 is not None and version_of(None if at is None else rows[at]) != 판: + raise store.StoreError(409, STALE.format(v=f"{name} {key}")) + if at is None: + rows.append(doc) + else: + rows[at] = doc + put(path, data) + return {"문서": doc, **_run(doc), "파일": name, "판": version_of(doc)} def candidates(ask: dict) -> dict: @@ -222,14 +293,14 @@ def users(key: str) -> list[str]: def drop(key: str) -> None: """수식 문서 줄 하나 지움(없으면 그냥).""" - name = _where(key) - if not name: - return - path = folder() / name - data = ml.load_file(path) - data["줄"] = [d for d in data.get("줄") or [] if str(d.get("키")) != key] - path.write_text(ml.dump(data), encoding="utf-8", newline="\n") - _memo.clear() + with _LOCK: + name = _where(key) + if not name: + return + path = folder() / name + data = ml.load_file(path) + data["줄"] = [d for d in data.get("줄") or [] if str(d.get("키")) != key] + put(path, data) def remove(key: str, file: str, version: str, confirmed: bool) -> dict: diff --git a/M01_MasterData/M01_MasterData_Equation.py b/M01_MasterData/M01_MasterData_Equation.py index 53906fd4a..2e67c9895 100644 --- a/M01_MasterData/M01_MasterData_Equation.py +++ b/M01_MasterData/M01_MasterData_Equation.py @@ -3,7 +3,7 @@ 모델 = `scripts/master_equation.py`(나무 · 변수 표) · `master_equation_edit.py`(고침 · 검사) · 키보드 글 번역 · 상한 = M02 단가산출 식 칸과 한 벌(`M02_Sangeun_Formula` 불러 씀 · 고치지 않음) · 셈 = 엔진 한 벌(③ 서버 단독 · 브라우저 값 받아 적지 않음) · 저장 = 기존 M01 `/save`(개정확인) · -M02 사본(795-1)은 `export_row` · `edit_row` 를 사본 줄로 부름 · 시험 `test_796_1_formula_model.py`. +M02 사본(795-1)은 `edit_row` 를 사본 줄로 부름 · `export_row` 는 시험(796-1 · 800-2)의 수식 모델 바탕(옛 엔진 은퇴 때 같이). """ from __future__ import annotations @@ -15,7 +15,6 @@ from M01_MasterData import M01_MasterData_Store as store _ERR = (store.cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) import master_equation as meq # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤 -import master_equation_link as link # noqa: E402 import master_equation_edit as me # noqa: E402 @@ -56,8 +55,3 @@ def edit_row(whole, row: dict, edits: list) -> tuple[dict, list[str]]: """고침 → (새 줄, 까닭) — 까닭 있으면 저장 안 됨(M01 · M02 사본 같은 함수).""" new, why, _ = me.apply(whole, row, edits, words) return new, why - - -def links(ask: dict) -> dict: - """새 기호 연결 후보(800-3) — {갈래: 표 | 요소 | 로직, 검색, 분류?} → {후보, 더있음} · 읽기만.""" - return link.candidates(store.loaded()[1], ask) diff --git a/M01_MasterData/M01_MasterData_Machine.py b/M01_MasterData/M01_MasterData_Machine.py index 769fa2b7f..dd37efe64 100644 --- a/M01_MasterData/M01_MasterData_Machine.py +++ b/M01_MasterData/M01_MasterData_Machine.py @@ -182,22 +182,26 @@ def register(batch: list[dict]) -> Callable[[], None]: def _register_docs(add: dict[str, list[str]], drop: set[str]) -> None: - """수식 문서의 「기계」 고르기 목록에 로직 목록과 같은 더함 · 뺌 — 바뀐 파일만 다시 씀.""" + """수식 문서의 「기계」 고르기 목록에 로직 목록과 같은 더함 · 뺌 — 바뀐 파일만 다시 씀 + (수식 문서 쓰기 길 `Doc.put` · 잠금 안 — 화면 저장과 겹쳐도 한쪽이 덮지 않음).""" import master_doc_link as ml # noqa: E402 - for path in sorted(ml.FOLDER.glob("수식_*.json")): - data, hit = ml.load_file(path), False - for doc in data.get("줄") or []: - for v in doc.get("변수") or []: - link = v.get("연결") or {} - if link.get("갈래") != "선택" or v.get("이름") != "기계": - continue - codes = [c for c in link.get("목록") or [] if str(c) not in drop] - codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes] - if codes != link.get("목록"): - link["목록"], hit = codes, True - if hit: - path.write_text(ml.dump(data), encoding="utf-8", newline="\n") + from M01_MasterData import M01_MasterData_Doc as docs + + with docs._LOCK: + for path in sorted(docs.folder().glob("수식_*.json")): + data, hit = ml.load_file(path), False + for doc in data.get("줄") or []: + for v in doc.get("변수") or []: + link = v.get("연결") or {} + if link.get("갈래") != "선택" or v.get("이름") != "기계": + continue + codes = [c for c in link.get("목록") or [] if str(c) not in drop] + codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes] + if codes != link.get("목록"): + link["목록"], hit = codes, True + if hit: + docs.put(path, data) # ── 쓰는 곳 = `M01_MasterData_Machine_Uses`(수식 문서 기준 · 848-5) ────────────── diff --git a/M01_MasterData/M01_MasterData_Parts.py b/M01_MasterData/M01_MasterData_Parts.py index d3267715c..451fba9c8 100644 --- a/M01_MasterData/M01_MasterData_Parts.py +++ b/M01_MasterData/M01_MasterData_Parts.py @@ -5,7 +5,6 @@ 틀 = `_수식문서_틀.md` 9 장. - 단가산출 기초 목록 · 찾아 넣기 「다른 단가산출」 목록에서 뺌(`strip`) — 키로 열기 · 셈 · 부르기는 그대로 - 기종 → 그 기종 기계가 쓰는 기계경비식 · 작업량 틀(`of_kind` · M01 「기계」 화면) -- 기계 원문번호 → 그 기종 작업량 틀 문서(`of_machine` · 줄 쌓기 기계 넣기) 쓰기 없음 · 로그인 사용자 모두(마스터 읽기). """ @@ -75,15 +74,3 @@ def of_kind(group: str, detail: str = "") -> dict[str, list]: used[str(got["키"])] = used.get(str(got["키"]), 0) + 1 rule = [{**_brief(k, docs[k]), "기계수": n} for k, n in used.items() if k in docs] return {"기계경비식": rule, "작업량 틀": [_brief(k, d) for k, d in _templates(detail)]} - - -def of_machine(no: str) -> dict[str, Any]: - """줄 쌓기 기계 넣기 — 기계 원문번호 → {기계 {이름 · 규격 · 상세구분}, 틀 [{… 문서}]}.""" - row = next((m for m in _machines() if str(m.get("원문번호")) == str(no)), None) - if not row: - raise store.StoreError(404, f"없는 기계 「{no}」") - kind = str(row.get("상세구분") or "") - return { - "기계": {"이름": row.get("이름"), "규격": row.get("규격") or "", "상세구분": kind}, - "틀": [{**_brief(k, d), "문서": d} for k, d in _templates(kind)], - } diff --git a/M01_MasterData/M01_MasterData_Router.py b/M01_MasterData/M01_MasterData_Router.py index bc9d0f1d2..b56a2cf07 100644 --- a/M01_MasterData/M01_MasterData_Router.py +++ b/M01_MasterData/M01_MasterData_Router.py @@ -318,6 +318,7 @@ def post_logic_formula_preview(body: FormulaPreview) -> dict: class DocBody(BaseModel): 문서: dict[str, Any] 입력: dict[str, Any] = {} + 판: str | None = None # 저장 — 읽을 때 받은 판(다르면 409 · 없으면 대조 안 함) @router.get("/logic/doc") @@ -335,7 +336,7 @@ def post_logic_doc_preview(body: DocBody) -> dict: @router.post("/logic/doc/save") def post_logic_doc_save(body: DocBody) -> dict: """저장 — 서버가 정본으로 다시 셈 · 문서 파일에 씀 → {문서, 셈, 연결, 파일}.""" - return _call(doc_screen.save, body.문서) + return _call(doc_screen.save, body.문서, body.판) class RemoveBody(BaseModel): diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py index 40c84f4b9..e60e3f328 100644 --- a/M01_MasterData/M01_MasterData_Store_Make.py +++ b/M01_MasterData/M01_MasterData_Store_Make.py @@ -257,12 +257,26 @@ def save(batch: list[dict], confirmed: bool = False) -> dict: _own_path().unlink(missing_ok=True) raise docs_too() # 수식 문서 기계 고르기 목록도 같게(848-5) + _drop_docs(batch) added = [ {"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old ] return {"files": files, "added": added, "warnings": []} +def _drop_docs(batch: list[dict]) -> None: + """지운 로직 줄의 수식 문서도 지움(문서만 남지 않게 · `/logic/remove` 와 같은 끝).""" + from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게 + + files = store.loaded()[0] + for part in batch: + if (files.get(str(part.get("file"))) or {}).get("그룹") != "로직": + continue + for ch in part.get("changes") or []: + if ch.get("op") == "delete" and ch.get("key"): + doc_store.drop(str(ch["key"])) + + def _keep_same(part: dict) -> None: """고친 줄의 값이 같은 칸 = 파일 값 그대로(화면 왕복 「9.0」 → 「9」 막음 · 그 칸만 바뀜).""" data = store.loaded()[0].get(str(part.get("file") or "")) # 읽기만 — 기억(826-2) @@ -340,11 +354,14 @@ def _keys() -> list[str]: def logic_new(logic: dict, owner: str = OWNERS[0]) -> dict: - """새 자체 로직 — 키는 서버가 `GX` 다음 번호로 줌.""" + """새 자체 로직 — 키 = 서버가 `GX` 다음 번호 · 수식 문서도 같이(`Doc.make` · 요구 896).""" + from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게 + before = set(_keys()) done = _write([{"op": "add", "row": _clean(logic, owner)}]) key = next((k for k in reversed(_keys()) if k not in before), "") - return {**done, "key": key, "logic": store.logic(key)["logic"] if key else {}} + made = doc_store.make(key) if key else False + return {**done, "key": key, "logic": store.logic(key)["logic"] if key else {}, "수식문서": made} def logic_copy(key: str, 이름: str = "", owner: str = OWNERS[0]) -> dict: diff --git a/M01_MasterData/M01_MasterData_Store_Save.py b/M01_MasterData/M01_MasterData_Store_Save.py index 9adb408a7..877a96b9d 100644 --- a/M01_MasterData/M01_MasterData_Store_Save.py +++ b/M01_MasterData/M01_MasterData_Store_Save.py @@ -116,16 +116,50 @@ def save(batch: list[dict]) -> list[dict]: new = [x for x in new + cache.labor_errors(fresh, gone) if x not in old] if new: raise store.StoreError(422, {"errors": new}) - if book["다음"] != issued: - mk.save_book(book, book_path) - out = [{"file": name, "version": _write(name, before[name], after[name])} for name in names] + # 대장(원자적) → 파일 · 중간에 끊기면 쓴 것 모두 저장 전으로(대장만 · 파일만 앞서가지 않게) + raw = {n: (store.FOLDER / n).read_bytes() for n in names if not _machine(n)} + book_raw = book_path.read_bytes() if book["다음"] != issued else None + tried: list[str] = [] + try: + if book_raw is not None: + mk.save_book(book, book_path) + out = [] + for name in names: + tried.append(name) + out.append({"file": name, "version": _write(name, before[name], after[name])}) + except BaseException: + _undo(tried, before, after, raw, book_path, book_raw) + raise # 저장 뒤 — 쓴 파일만 기억에 갈아 끼우고 흔들린 자리를 알려 줘 그 줄만 다시 세게 cache.adopt(store.FOLDER, after, fresh, names, narrowed[2]) return out +def _machine(name: str) -> bool: + return name == mmf.NAME and mmf.here(store.FOLDER) # 기계 = 폴더(826-2) + + +def _put(path, raw: bytes) -> None: + tmp = path.with_name(f".{path.name}.tmp") + tmp.write_bytes(raw) + os.replace(tmp, path) + + +def _undo(names, before, after, raw, book_path, book_raw) -> None: + """쓰기 중간 실패 — 쓴(쓰려던) 파일 · 대장을 저장 전 글로 되돌림.""" + for name in names: + if _machine(name): + mmf.write( + store.FOLDER, before[name], after[name] + ) # 바뀐 · 더한 · 지운 대를 저장 전으로 + else: + _put(store.FOLDER / name, raw[name]) + if book_raw is not None: + _put(book_path, book_raw) + + def _write(name: str, before: dict, after: dict) -> str: - if name == mmf.NAME and mmf.here(store.FOLDER): # 기계 = 바뀐 대 파일만(826-2) + if _machine(name): # 기계 = 바뀐 대 파일만(826-2) mmf.write(store.FOLDER, after, before) return store.version(name) path = store.FOLDER / name diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Money.ts b/M01_MasterData/M01_MasterData_UI_Logic_Money.ts deleted file mode 100644 index a5e53dc8f..000000000 --- a/M01_MasterData/M01_MasterData_UI_Logic_Money.ts +++ /dev/null @@ -1,11 +0,0 @@ -/* ============================================================================= - * M01_MasterData_UI_Logic_Money.ts - * 돈 모양 — 공용 꼴 한 벌(`common_util/common_util_money.ts`)을 다시 내보냄. 부르는 쪽은 그대로. - * ========================================================================== */ - -export { - formatLineMoney, - formatMoney, - formatNumber, - formatPrice, -} from "../common_util/common_util_money"; diff --git a/M02_MasterTemplete/M02_Labor_Ref.py b/M02_MasterTemplete/M02_Labor_Ref.py index 1afa5198c..2306ad99f 100644 --- a/M02_MasterTemplete/M02_Labor_Ref.py +++ b/M02_MasterTemplete/M02_Labor_Ref.py @@ -352,11 +352,34 @@ def _no_loop(ref: Ref, trail: list[Ref]) -> None: _no_loop(child, [*trail, child]) +#: 층 뿌리 번호 장부 {종류: 발급한 가장 큰 번호} — 지운 끝 번호를 다시 안 씀(854-1 · M01 키대장 규칙과 같은 뜻) +ISSUED = "_번호.json" + + +def _issued() -> dict[str, Any]: + try: + got = json.loads((store.root() / ISSUED).read_bytes()) + except (OSError, ValueError): + return {} + return got if isinstance(got, dict) else {} + + def next_key(kind: str) -> str: - """지금 층 그 종류의 다음 키(가장 큰 번호 + 1).""" + """지금 층 그 종류의 다음 키(파일 · 장부 가운데 가장 큰 번호 + 1).""" folder = store.root() / kind have = [int(m.group(2)) for p in folder.glob("*.json") if (m := _KEY.match(p.stem))] - return f"{PREFIX[kind]}-{max(have, default=0) + 1:06d}" + return f"{PREFIX[kind]}-{max(*have, int(_issued().get(kind) or 0), 0) + 1:06d}" + + +def _keep_issued(kind: str, key: str) -> None: + """장부에 발급한 번호(더 클 때만).""" + from common_util.common_util_json import atomic_write_json + + n = int(_KEY.match(key).group(2)) + with store._LOCK: + got = _issued() + if int(got.get(kind) or 0) < n: + atomic_write_json(store.root() / ISSUED, {**got, kind: n}) def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]: @@ -364,10 +387,13 @@ def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]: for _ in range(5): key = next_key(kind) try: - return store.write(kind, key, "", {**doc, "키": key}) + got = store.write(kind, key, "", {**doc, "키": key}) except store.StoreError as e: if e.status != 409 or not isinstance(e.detail, dict): raise + else: + _keep_issued(kind, key) + return got raise _bad("새 키를 못 잡음 — 다시 누름", 409) diff --git a/M02_MasterTemplete/M02_Logic_Standard.py b/M02_MasterTemplete/M02_Logic_Standard.py index 71f78dc4a..953cd8ba7 100644 --- a/M02_MasterTemplete/M02_Logic_Standard.py +++ b/M02_MasterTemplete/M02_Logic_Standard.py @@ -1,17 +1,20 @@ -"""M02 기준 목록 · 계산서 보기(PLAN 704-1 · 704-2 · 요구서 4장 8) — 로직 고르기 창이 읽음. +"""M02 기준 목록 · 계산서 보기(PLAN 704-1 · 704-2 · 855-C 2-C4 · 요구서 4장 8) — 로직 고르기 창. -기준 목록 = 단가산출 로직 하나를 대표 규격으로 펼친 줄(품명 · 규격 · 단위 · 금액 · 출처 · 공종). -대표 규격 = 고르기 입력 값 전부 · 표 찾기 조건으로 쓰이는 수 입력은 그 표 줄마다 값 하나(범위 줄은 -위 끝) · 그 밖 연속 값 입력은 견본 자동값(`master_auto.values`) 한 줄 · 지역 = 자동값(전국평균). -펼침 = 바탕(자동값 · 규격 축은 첫 대표 값) 한 줄 + 규격 축마다 값 하나씩 바꾼 줄(곱하지 않음 · +기준 목록 = 단가산출 기초 하나를 대표 규격으로 펼친 줄(품명 · 규격 · 단위 · 금액 · 출처 · 공종). +대표 규격 = 수식 문서 선택 변수(`선택 목록`) 값 전부 · 표 조건으로 바로 쓰이는 입력 변수는 +그 표 줄마다 값 하나(범위 줄은 위 끝) · 지역 = 문서 기본값(전국평균) 한 벌 · +바탕 = 문서 변수 기본값(`연결.값`). +펼침 = 바탕(규격 축은 첫 대표 값) 한 줄 + 규격 축마다 값 하나씩 바꾼 줄(곱하지 않음 · 바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌). -금액 = M01 엔진 식 + B09 산근 끝수(줄마다 버림 · `M02_Logic_Settle` · 근거 지식DB -`technical_info/01_임도/05_원가정보/단수처리_규칙.md`) · 최신 판 노임(마스터 판). -목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개 · 수 분) → 프로세스 메모리 + 파생 저장본 -(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 내용 지문 + `SHAPE` · 같으면 안 셈 · +금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) · +계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판). +(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.) +목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본 +(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` · +같으면 안 셈 · 셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸). 실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음. -계산서 = `master_text.lines`(줄 「석공 | 268,908 * 0.1 = 26,891」 · 비목 소계 · 계) + 같은 끝수 값. +이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫). M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인). """ @@ -26,15 +29,18 @@ from decimal import Decimal from typing import Any from common_util.common_util_derived_store import derived_key, read_derived, write_derived +from M01_MasterData import M01_MasterData_Doc as m01_doc from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs -from M02_MasterTemplete import M02_Logic_Settle as settle from M02_MasterTemplete import M02_Template_Layers as layers mf = m01.cm.mf -import master_sheet_line as msl # noqa: E402 — 계산서 줄 덧칸(714-1) · scripts 길은 `m01` 이 둠 +import master_doc as md # noqa: E402 — scripts 길은 `m01` 이 둠 +import master_doc_calc as mc # noqa: E402 +import master_doc_link as ml # noqa: E402 +import master_doc_text as mdt # noqa: E402 — 계산서 줄 글(줄 쌓기 산출근거와 같은 규칙) -SHAPE = 3 # 줄 꼴이 바뀌면 올림 — 옛 저장본을 안 씀 +SHAPE = 4 # 줄 꼴 · 셈이 바뀌면 올림 — 옛 저장본을 안 씀(4 = 855-C 문서 셈) KIND = "m02_logic_standard" REGION = "지역" # 지역 = 자동값 한 벌(정함 8) QUIET = ("해당 없음", "없음") # 규격 글에서 뺄 값 @@ -95,7 +101,7 @@ def words_of(row: dict) -> list[str]: def _range_label(table: dict, low: Any, high: Any, unit: str) -> str: - f = m01.mtx.fmt + f = mdt.eq_text if low is None: return f"{f(high)}{unit} 이하" if high is None: @@ -118,29 +124,52 @@ def _table_reps(whole: Any, ref: str, cond: str, unit: str) -> list[tuple[Any, s continue if not ranged: if isinstance(have, Decimal): - out.setdefault(have, f"{m01.mtx.fmt(have)}{unit}") + out.setdefault(have, f"{mdt.eq_text(have)}{unit}") continue low, high = have tries = [v for v in (high, low, (low or 0) + 1) if isinstance(v, Decimal)] - got = next((v for v in tries if m01.cm.mf._match(table, r, cond, v)), None) + got = next((v for v in tries if ml._match(table, r, cond, v)), None) if got is not None: out.setdefault(got, _range_label(table, low, high, unit)) return sorted(out.items()) -def axes(whole: Any, logic: dict) -> tuple[dict, list[tuple[str, list[tuple[Any, str]]]]]: - """(바탕 입력, [(입력 이름, [(값, 글) …]) …]) — 규격 축 = 지역 뺀 고르기 · 표 찾기 수 입력.""" - base = m01.mau.values(whole, logic) - finds, _ = m01.mau._uses(logic) +def _default(var: dict) -> Any: + """문서 변수 기본값(`연결.값`) — 수 글은 수로.""" + value = (var.get("연결") or {}).get("값") + if isinstance(value, str) and value.strip(): + num = mdt._dec(value) + return value if num is None else num + return value + + +def axes(whole: Any, doc: dict) -> tuple[dict, list[tuple[str, list[tuple[Any, str]]]]]: + """(바탕 입력, [(변수 열쇠, [(값, 글) …]) …]) — 규격 축 = 지역 뺀 선택 변수(`선택 목록`) · + 표 조건으로 바로 쓰이는 입력 변수(그 표 줄마다 값 하나) · 바탕 = 문서 기본값.""" + found = [ + v for v in doc.get("변수") or [] if (v.get("연결") or {}).get("갈래") in ("선택", "입력") + ] + base = {str(v["열쇠"]): _default(v) for v in found} + ids = {md.var_id(v): str(v["열쇠"]) for v in found} + finds: dict[str, list[tuple[str, str]]] = {} + for v in doc.get("변수") or []: + link = v.get("연결") or {} + if link.get("갈래") != "표": + continue + for cond, expr in (link.get("조건") or {}).items(): + node = mdt.node_of(expr) + if node and node[0] == "var" and node[1] in ids: + finds.setdefault(ids[node[1]], []).append((str(link.get("표")), cond)) out = [] - for spec in logic.get("입력") or []: - name = spec["이름"] + for var in found: + name, link = str(var["열쇠"]), var["연결"] if name == REGION: continue - unit = str(spec.get("단위") or "") - if spec.get("고르기"): + unit = str(var.get("단위") or "") + if link["갈래"] == "선택": + spec = {"이름": name, "고르기": link.get("목록") or []} labels = labor_inputs._labels(whole, spec) - reps = [(v, str(labels.get(v, m01.mtx.fmt(v) if isinstance(v, Decimal) else v))) + reps = [(v, str(labels.get(v, mdt.eq_text(v) if isinstance(v, Decimal) else v))) for v in spec["고르기"]] # fmt: skip elif name in finds: seen: dict[Any, str] = {} @@ -172,18 +201,34 @@ def _unit(logic: dict) -> str: return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit) -def _money(whole: Any, logic: dict, given: dict) -> Decimal | None: - if not str(logic.get("결과단위") or "").startswith("원"): - return None +def _links(whole: Any) -> Any: + return ml.Links(whole, m01_doc.docs()) + + +def _calc(doc: dict, links: Any, given: dict) -> dict | None: try: - got = settle.settle(whole, str(logic["키"]), m01.cm.mf.fill_empty(logic, given)) - except (m01.cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): + got = mc.calc(doc, links, given) + except Exception: # noqa: BLE001 — 계산기는 예외 없음이 원칙 · 혹시 = 못 셈 return None - return got.get("계", got.get("결과")) + return got if got.get("셈됨") else None -def _rows_of(whole: Any, logic: dict, blocked: bool) -> list[dict]: - base, ax = axes(whole, logic) +def _money(doc: dict, links: Any, given: dict) -> Decimal | None: + """돈 기초(결과단위 「원…」)의 계(돈 아닌 결과 문서 = 결과) — 못 셈 = None.""" + if not str(doc.get("결과단위") or "").startswith("원"): + return None + got = _calc(doc, links, given) + if got is None: + return None + return got.get("계") if got.get("계") is not None else got.get("결과") + + +def _rows_of(whole: Any, logic: dict, blocked: bool, links: Any = None) -> list[dict]: + doc = m01_doc.docs().get(str(logic.get("키"))) + if doc is None: + return [] + links = links or _links(whole) + base, ax = axes(whole, doc) changes: list[dict] = [{}] for name, reps in ax: changes += [{name: v} for v, _ in reps if v != base.get(name)] @@ -201,7 +246,7 @@ def _rows_of(whole: Any, logic: dict, blocked: bool) -> list[dict]: out = [] for change in changes: given = {**base, **change} - money = _money(whole, logic, given) + money = _money(doc, links, given) if change and money == 0: # 표에 없는 규격 조합(견치돌 · 뒷길이 25 따위) — 0 원 줄은 뺌 continue out.append( @@ -231,15 +276,19 @@ def _stamp() -> str: if not name.startswith("_"): sha.update(name.encode()) sha.update(hashlib.sha1(m01.cm.mmf.raw(m01.FOLDER, name)).digest()) + for path in sorted(m01_doc.folder().glob("수식_*.json")): # 수식 문서(855-C · 셈 정본) + sha.update(path.name.encode()) + sha.update(hashlib.sha1(path.read_bytes()).digest()) return sha.hexdigest() def _chunk(keys: list[str], blocked: set[str]) -> list[dict]: """일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음).""" whole = m01.loaded()[1] + links = _links(whole) out = [] for key in keys: - out += _rows_of(whole, whole.logic(key), key in blocked) + out += _rows_of(whole, whole.logic(key), key in blocked, links) return out @@ -268,23 +317,25 @@ def _make(files: dict, whole: Any, key: str) -> None: value = build(files, WORKERS) write_derived(layers.storage_root(), KIND, key, value) with _LOCK: - if _MEMO.get("whole") is whole: + if _MEMO.get("key") == key: _MEMO.update(value=value) except Exception as e: # noqa: BLE001 — 다음 요청이 다시 셈 print(f"[M02 기준 목록] 셈 실패: {e}", file=sys.stderr) finally: with _LOCK: - if _MEMO.get("whole") is whole: + if _MEMO.get("key") == key: _MEMO["job"] = None def listing() -> dict: """기준 목록 `{판, 공종, 줄, 준비}` — 메모리 → 파생 저장본 → 뒤에서 셈(그동안 빈 줄).""" files, whole = m01.loaded() + docs = m01_doc.docs() # 수식 문서를 고치면 새 묶음(같은 내용이면 같은 묶음) with _LOCK: - if _MEMO.get("whole") is not whole: + if _MEMO.get("whole") is not whole or _MEMO.get("docs") is not docs: _MEMO.clear() - _MEMO.update(whole=whole, key=derived_key(KIND, SHAPE, _stamp()), value=None, job=None) + key = derived_key(KIND, SHAPE, _stamp()) + _MEMO.update(whole=whole, docs=docs, key=key, value=None, job=None) if _MEMO["value"] is None and _MEMO["job"] is None: got = read_derived(layers.storage_root(), KIND, _MEMO["key"]) if got: @@ -312,8 +363,8 @@ def _quiet(fn) -> None: print(f"[M02 기준 목록] 데움 실패: {e}", file=sys.stderr) -def _given(whole: Any, logic: dict, change: dict) -> tuple[dict, list]: - base, ax = axes(whole, logic) +def _given(whole: Any, doc: dict, change: dict) -> tuple[dict, list]: + base, ax = axes(whole, doc) known = {name: dict(reps) for name, reps in ax} for name, value in (change or {}).items(): if name not in known: @@ -326,28 +377,19 @@ def _given(whole: Any, logic: dict, change: dict) -> tuple[dict, list]: def sheet(key: str, change: dict) -> dict: - """계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(엔진 값).""" + """계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(문서 셈).""" files, whole = m01.loaded() + doc = m01_doc.docs().get(key) try: logic = whole.logic(key) except m01.cm.mf.FormulaError as e: raise m01.StoreError(404, str(e)) from e - given, ax = _given(whole, logic, change) - filled = m01.cm.mf.fill_empty(logic, given) - got = msl.annotate(files, key, filled, m01.mtx.lines(files, key, filled)) # 줄 덧칸(714-1) - done = settle.settle(whole, key, filled) - if "결과" not in done: # 돈 로직 — 줄마다 버림(B09 산근 규칙) - settle.apply(got.get("groups") or [], m01.cm.mf.run(whole, key, filled), done) - got["계"] = done["계"] - groups = [ - { - "비목": g["비목"], - "소계": g.get("소계"), - "끝수": g.get("끝수") or "", - "줄": [{k: line.get(k) for k in ("이름", "글", "금액", *msl.KEYS)} for line in g["줄"]], - } - for g in got.get("groups") or [] - ] + if doc is None: + raise m01.StoreError(404, f"수식 문서 없음 「{key}」") + given, ax = _given(whole, doc, change) + links = _links(whole) + got = _calc(doc, links, given) or {} + money = str(doc.get("결과단위") or "").startswith("원") and "결과" not in doc return labor_inputs._num( { "키": key, @@ -357,8 +399,8 @@ def sheet(key: str, change: dict) -> dict: "출처": labor_inputs.sources(logic) or "", "판": edition(files), "입력": given, - "묶음": groups, - "계": got.get("계"), - "기준단위": got.get("기준단위"), + "묶음": mdt.sheet_groups(doc, got, links) if got and money else [], + "계": got.get("계") if money else got.get("결과"), + "기준단위": _unit(logic) or None, } ) diff --git a/M02_MasterTemplete/M02_Machine_Hourly.py b/M02_MasterTemplete/M02_Machine_Hourly.py index c263059c6..fb43f70dc 100644 --- a/M02_MasterTemplete/M02_Machine_Hourly.py +++ b/M02_MasterTemplete/M02_Machine_Hourly.py @@ -8,7 +8,7 @@ 기계표 = M01 + 지금 층 내 기계(821-1 · `M02_MyMachine` — 식은 채운 칸으로 고른 같은 GC 식 · 직접 = 그 값) · 층을 모르는 길(`/api/m02/logic-lib/machine-hourly`)은 M01 만. 셈 한 길(842-3) = 식 문서 계산기(`master_doc_calc` · 기계 줄 인력 · 잡품 목록을 바탕 덮음으로 얹음 — -`master_doc_cover.row_entry`) · 식 문서 없는 식만 옛 로직 엔진 · 조종원 유무 = 인력 줄(`master_machine_crew.view`). +`master_doc_cover.row_entry`) · 식 문서 없는 식 = 못 셈 + 까닭(855 2-B2 · 옛 엔진 폴백 걷음) · 조종원 유무 = 인력 줄(`master_machine_crew.view`). 식 고름 한 곳(822-2 · `pick`) = ㉠ 원문번호가 식 「기계」 목록에 있으면 그 식(짝 차례) ㉡ 그 기계만의 식 (`_own`) ㉢ 없으면 꼴(채운 칸 · `M02_MyMachine.logic_key`) — M01 [새 기계] · 불러오기 · 데이터 흐름 · 줄 쌓기 · 단가산출 기초가 다 이것을 씀 · 못 고름 · 값 모자람 = 까닭 글(`why`). @@ -183,39 +183,22 @@ def hourly(key: str) -> dict[str, Any]: logic = pick(row) if lack := why(row, logic): return {"ok": False, "reason": lack, **({"로직": logic["키"]} if logic else {})} - args = "".join( # 빈칸 든 입력 이름(「전력 계약종별」 · 820-1 파워트로웰)은 따옴표로 - f", {n if (n := i['이름']).isidentifier() else repr(n)}='{(i.get('고르기') or [''])[0]}'" - for i in logic.get("입력") or [] - if i.get("이름") != "기계" - ) - if (got := doc_sums(row, logic, whole)) is not None: - return got if not got["ok"] else {"ok": True, "이름": row.get("이름"), "규격": row.get("규격"), - "로직": logic["키"], "원문번호": code, **got["합"]} # fmt: skip - mine = f", 기계='{code}'" if takes_machine(logic) else "" - call = f"로직({logic['키']}{mine}{args})" - line = {"종류": "로직", "요소": call, "이름": "기계", "단위": "시간", "수량": "1"} - holder = { - "키": "", "원문번호": "", "이름": "기계 시간", "결과단위": "원/식", "출처": "자체", - "입력": [], "중간": [], "호표": [line], "덧줄": [], "끝수": None, - } # fmt: skip - got = store.calc("", {}, holder, None) - if not got.get("ok") or "sums" not in got: - return {"ok": False, "reason": got.get("reason") or "셈 못 함"} - sums = {k: float(got["sums"][k]) for k in (*cm.mf.COST_ITEMS, "계")} - # 804-3 줄 쌓기 기계 줄 = 이 로직 + 기계='원문번호' - return { - "ok": True, - "이름": row.get("이름"), - "규격": row.get("규격"), - "로직": logic["키"], - "원문번호": code, - **sums, - } + got = hour(row, logic, whole) # 804-3 줄 쌓기 기계 줄 = 이 로직 + 기계='원문번호' + if not got["ok"]: + return got + return {"ok": True, "이름": row.get("이름"), "규격": row.get("규격"), "원문번호": code, **got} + + +def hour(row: dict, logic: dict, index: Any) -> dict[str, Any]: + """시간당 한 몸(`hourly` · `brief` · `M02_MyMachine.hourly`) — {ok, 로직, 노무비 · 재료비 · 경비 · 계} | + {ok False, reason, 로직}.""" + got = doc_sums(row, logic, index) + return {"ok": True, "로직": logic["키"], **got["합"]} if got["ok"] else got def doc_sums(row: dict, logic: dict, index: Any) -> dict | None: """셈 한 길(842-3) — 식 문서 계산기 + 기계 줄 목록(바탕 덮음) · 입력 = 식 기본값 · - {ok, 합 {노무비 · 재료비 · 경비 · 계}} | {ok False, reason} · 식 문서 없음 = None(옛 로직 엔진).""" + {ok, 합 {노무비 · 재료비 · 경비 · 계}} | {ok False, reason, 로직} · 식 문서 없음 = 못 셈(855 2-B2).""" import master_doc_calc as mc import master_doc_cover as mcv import master_doc_link as ml @@ -224,8 +207,12 @@ def doc_sums(row: dict, logic: dict, index: Any) -> dict | None: docs = m01doc.docs() doc = docs.get(str(logic.get("키"))) - if doc is None: - return None + if doc is None: # 854-2 이후 수식 문서 없는 로직 0 — 옛 엔진 폴백 없음 + return { + "ok": False, + "reason": f"식 문서 없음 — 「{logic.get('키')}」", + "로직": logic.get("키"), + } given = {"기계": str(row.get("원문번호"))} if takes_machine(logic) else {} shaped = mcv.cover_doc(doc, given, None, mcv.row_entry(doc, row.get("값"))) got = mc.calc(shaped, ml.Links(index, docs), given) @@ -235,22 +222,26 @@ def doc_sums(row: dict, logic: dict, index: Any) -> dict | None: return {"ok": True, "합": {k: float(got[k]) for k in (*cm.mf.COST_ITEMS, "계")}} -_BRIEF: dict[tuple, dict] = {} +#: {키: (색인, 줄)} — 색인이 바뀌면 비움 · 꺼낼 때 `is` 확인(옛 색인 주소 재사용 · 옛 값 막음 · 854-1) +_BRIEF: dict[str, tuple[Any, dict]] = {} +_BRIEF_OF: list[Any] = [None] def brief(keys: list[str]) -> list[dict[str, Any]]: """기계 창 목록 · 양식(827-1) — M01 기계 줄 값 + 시간당(`hourly` 와 같은 식 · 입력 기본값 · 마스터를 다시 읽지 않고 색인 위에서 셈 · 색인마다 메모) · 키 · 원문번호로 찾음 · 없는 키 = 뺌.""" - import master_cut as mcut - from M02_MasterTemplete.M02_Item_Prices import to_json index, mf = store.loaded()[1], cm.mf - if len(_BRIEF) > 2000: # ponytail: 통째 비움 · 기계 수(655)의 세 배 + # ponytail: 통째 비움 · 기계 수(655)의 세 배 + if _BRIEF_OF[0] is not index or len(_BRIEF) > 2000: _BRIEF.clear() + _BRIEF_OF[0] = index out = [] for key in keys[:60]: - if (got := _BRIEF.get((id(index), key))) is None: + hit = _BRIEF.get(key) + got = hit[1] if hit and hit[0] is index else None + if got is None: try: row = (index.numbers.get("EQ") or {}).get(key) or index.get(key) except mf.FormulaError: @@ -259,20 +250,10 @@ def brief(keys: list[str]) -> list[dict[str, Any]]: continue logic = pick(row) head = {k: row.get(k) for k in ("키", "원문번호", "이름", "규격")} - if lack := why(row, logic): - hour = {"ok": False, "reason": lack} - elif (by_doc := doc_sums(row, logic, index)) is not None: - hour = {"ok": True, "로직": logic["키"], **by_doc["합"]} if by_doc["ok"] else by_doc - else: - given = {i["이름"]: (i.get("고르기") or [""])[0] for i in logic.get("입력") or []} - if takes_machine(logic): - given["기계"] = str(row.get("원문번호")) - sums = mcut.engine( - index, logic["키"], mf.run(index, logic["키"], mf.fill_empty(logic, given)) - ) - hour = {"ok": True, "로직": logic["키"]} - hour |= {k: float(sums[k]) for k in (*cm.mf.COST_ITEMS, "계")} - got = _BRIEF[(id(index), key)] = {**head, "값": to_json(row.get("값")), "시간당": hour} + lack = why(row, logic) + hours = {"ok": False, "reason": lack} if lack else hour(row, logic, index) + got = {**head, "값": to_json(row.get("값")), "시간당": hours} + _BRIEF[key] = (index, got) out.append(got) return out diff --git a/M02_MasterTemplete/M02_MasterTemplete_Hopyo.css b/M02_MasterTemplete/M02_MasterTemplete_Hopyo.css index 9c8d4102b..7794c475c 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Hopyo.css +++ b/M02_MasterTemplete/M02_MasterTemplete_Hopyo.css @@ -24,57 +24,6 @@ white-space: pre-wrap; } -.m02-hopyo__search { - max-width: 320px; -} - -/* 실무자료 표 — 한글은 낱말 단위로만 줄바꿈(두세 글자마다 안 갈라짐) · 너무 긴 낱말만 쪼갬 */ -.m02-hopyo__table :is(th, td) { - word-break: keep-all; - overflow-wrap: break-word; -} - -/* 우리 로직 칸 — 대상 여럿 = 칸 안 여러 줄(이름 · 키 · 몫 · 배 칸 · [옵션]) */ -.m02-hopyo__parts { - min-width: 11em; -} - -.m02-hopyo__part { - display: flex; - flex-wrap: wrap; - align-items: center; - gap: var(--spacing-4); -} - -.m02-hopyo__part + .m02-hopyo__part { - margin-top: var(--spacing-4); -} - -.m02-hopyo__times { - width: 6em; -} - -.m02-hopyo__unit { - display: inline-flex; - align-items: center; - gap: var(--spacing-4); -} - -/* 단위 환산 칸 앞뒤 글 — 「엑셀 1 ㎡ = 우리 [ ] 본」 */ -.m02-hopyo__unit-text { - color: var(--color-text-secondary); - font-size: var(--text-sm); - white-space: nowrap; -} - -.m02-hopyo__acts { - white-space: nowrap; -} - -.m02-hopyo__acts > button + button { - margin-left: var(--spacing-4); -} - /* 엑셀 보기(329) — 왼쪽 읽기 전용 시트 · 오른쪽 호표 목록 */ .m02-hopyo-sheet { display: grid; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_SheetNav.ts b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_SheetNav.ts index ae1217795..9b2d00b64 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_SheetNav.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_SheetNav.ts @@ -65,7 +65,6 @@ export function gridOf(id: string, scope: HopyoScope, key: string): Promise kept?.got === got && (kept = null)); return got; } -export const dropGrid = (): void => void (kept = null); /** 역할 시트 탭 글 통일 — 역할 → 시트 id */ export function nameTabs(book: Workbook, grid: HopyoGrid): Partial> { diff --git a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts index 563c14f1d..a09f36311 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts @@ -48,7 +48,6 @@ export function buildHopyoSection(opt: HopyoSectionOptions): HopyoSection { start.classList.add("m02-layers__btn"); start.title = "파일 하나 — 경쟁사 엑셀(.xls · .xlsx) 또는 경쟁사 파일(.estx · .STC) → 우리 정보로 다시 만듦(한시 · 끝내거나 떠나면 올린 파일 지움)"; - start.dataset.hopyoWizardOpen = ""; const jobs = el("div", { className: "m02-hopyo-side", attrs: { "data-hopyo-jobs": "" } }); const body = el("div", { className: "m02-hopyo-side", diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Diagram.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Diagram.ts index d0eedf3a9..0e508bc0c 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Diagram.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Diagram.ts @@ -10,7 +10,7 @@ import { currentLanguageIndex } from "@ui/ui_template_locale"; import { wheelZoomsIn } from "../A00_Common/touch_bridge"; import { guardMenuAfterDrag, isAuxPanButton } from "../A00_Common/input_prefs"; import { createButton, el } from "@ui/ui_template_elements"; -import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money"; +import { formatMoney } from "../common_util/common_util_money"; import "./M02_MasterTemplete_Labor_Diagram.css"; import { createEmpty } from "@ui/ui_template_empty"; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts index 4c9548b3e..4b9d04872 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts @@ -9,7 +9,7 @@ * ========================================================================== */ import { createButton, el } from "@ui/ui_template_elements"; -import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money"; +import { formatMoney } from "../common_util/common_util_money"; import { openPickTable } from "../M01_MasterData/M01_MasterData_UI_Logic_PickTable"; import { headWord } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Modal"; import type { LaborCalc, LaborRow, MatMarkKey } from "./M02_MasterTemplete_Labor_Api"; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts index 7c6be0e7d..73bd86f45 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts @@ -6,7 +6,7 @@ * ========================================================================== */ import { createButton, el } from "@ui/ui_template_elements"; -import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money"; +import { formatMoney } from "../common_util/common_util_money"; import type { LaborCalc, LaborCalcLine, diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts index 2865c41dd..293af59e2 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts @@ -15,7 +15,7 @@ import { createButton, createSelectField, el } from "@ui/ui_template_elements"; import { HOPYO_TAG } from "@ui/ui_template_hopyo_grid"; import { pctView } from "../M01_MasterData/M01_MasterData_UI_Logic_Api"; -import { formatLineMoney, formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money"; +import { formatLineMoney, formatMoney } from "../common_util/common_util_money"; import type { ItemLogic } from "./M02_MasterTemplete_Api_Fetch"; import type { LaborCalc, diff --git a/M02_MasterTemplete/M02_Material_Own.py b/M02_MasterTemplete/M02_Material_Own.py index b5885a4cb..789962c58 100644 --- a/M02_MasterTemplete/M02_Material_Own.py +++ b/M02_MasterTemplete/M02_Material_Own.py @@ -49,14 +49,14 @@ def rows(folder: str | Path) -> list[dict[str, Any]]: def _last() -> int: - """모든 개인 층 파일의 가장 큰 PM 번호 — 사람 사이 번호 안 겹침.""" - found = [ - int(m.group(1)) - for path in layers.storage_root().glob(f"*/*/{layers.TEMPLATES_DIRNAME}/{FILE}") - for row in read(path.parent)["줄"] - if (m := KEY.match(str(row.get("키") or ""))) - ] - return max(found, default=0) + """모든 개인 층 파일의 가장 큰 PM 번호 — 사람 사이 번호 안 겹침 · 파일마다 `마지막`(발급한 가장 큰 번호)도 + 셈(지운 끝 번호를 다시 안 씀 · 854-1).""" + found = [0] + for path in layers.storage_root().glob(f"*/*/{layers.TEMPLATES_DIRNAME}/{FILE}"): + doc = read(path.parent) + found.append(int(doc.get("마지막") or 0)) + found += [int(m.group(1)) for r in doc["줄"] if (m := KEY.match(str(r.get("키") or "")))] + return max(found) def _text(v: Any) -> str: @@ -114,8 +114,10 @@ def add(folder: str | Path, body: dict[str, Any]) -> dict[str, Any]: with store._LOCK: doc = read(folder) row = _checked(body, doc["줄"]) - got = {"키": f"{PREFIX}{_last() + 1:06d}", **row} + n = _last() + 1 + got = {"키": f"{PREFIX}{n:06d}", **row} doc["줄"].append(got) + doc["마지막"] = n atomic_write_json(Path(folder) / FILE, doc) return got diff --git a/M02_MasterTemplete/M02_MyMachine.py b/M02_MasterTemplete/M02_MyMachine.py index bb5e0ef15..33859078c 100644 --- a/M02_MasterTemplete/M02_MyMachine.py +++ b/M02_MasterTemplete/M02_MyMachine.py @@ -23,6 +23,8 @@ from __future__ import annotations import json import os import re +import threading +from collections.abc import Callable from contextvars import ContextVar from datetime import datetime from decimal import Decimal @@ -53,6 +55,11 @@ POWER, POWER_CREW, DIRECT_KEY = "GC001196", "GC001197", "GC001199" FUEL_POWER, FUEL_POWER_CREW = "GC001200", "GC001201" # 연료 + 전력(+ 조종원) — 경쟁사 구성(822-2b) +#: 번호 발급 · 고치기 · 지우기 한 번에 하나(854-1) — 자기 잠금(`store._LOCK` 안에서 불려도 교착 없게) +# ponytail: 프로세스 안 잠금 · 서버를 여럿 띄우면 파일 잠금으로 +_LOCK = threading.RLock() + + #: 단가산출 기계 창 초안(827-1 · `M02_MyMachine_Draft`) — 셈 꼴 줄 · 미리 셈 · 저장 한 요청 안만 `whole()` 위에 얹음 DRAFT: ContextVar[tuple] = ContextVar("내기계초안", default=()) @@ -106,6 +113,26 @@ def _put(row: dict) -> None: atomic_write_json(_dir() / f"{row['키']}.json", row) +def version(key: str) -> str: + """내 기계 한 대 판(파일 바이트 지문 · 없으면 빈 글).""" + path = _dir() / f"{key}.json" + return store.version_of(path.read_bytes()) if path.is_file() else "" + + +def add(build: Callable[[str], dict]) -> dict: + """새 번호 발급 + 쓰기를 한 잠금 안에서(854-1) — `_다음` 번호 · 이미 있는 파일 번호는 건너뜀(덮어쓰기 없음) · + `build(키)` = 저장 줄.""" + with _LOCK: + _move() + user, n = _user(), int(_load(_dir() / NEXT).get("다음") or 1) + while (_dir() / f"{PREFIX}{user}-{n:04d}.json").exists(): + n += 1 + row = build(f"{PREFIX}{user}-{n:04d}") + atomic_write_json(_dir() / NEXT, {"다음": n + 1}) # 번호 먼저 — 겹쳐 쓰지 않게 + _put(row) + return row + + def _read(folder: Path | None = None) -> dict[str, Any]: _move(folder) base = _dir(folder) @@ -227,28 +254,14 @@ def hourly(row: dict, index: Any) -> dict[str, Any]: **sums, "계": sum(sums.values()), } - import master_cut as mcut - - mf = m01.cm.mf key = logic_key(row) if key is None: return {"ok": False, **head, "reason": "식 없음 — 조종원직종 없음"} logic = index.logic(key) - from M02_MasterTemplete import M02_Machine_Hourly as mh # 셈 한 길(842-3) + from M02_MasterTemplete import M02_Machine_Hourly as mh # 셈 한 길(842-3 · 855 2-B2) - if (by_doc := mh.doc_sums(row, logic, index)) is not None: - got = by_doc.get("합") or {"reason": by_doc.get("reason")} - return {"ok": by_doc["ok"], **head, "로직": logic["키"], **got} - given = {i["이름"]: (i.get("고르기") or [""])[0] for i in logic.get("입력") or []} - given["기계"] = str(row.get("원문번호")) - try: - got = mcut.engine( - index, logic["키"], mf.run(index, logic["키"], mf.fill_empty(logic, given)) - ) - except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e: - return {"ok": False, "reason": str(e) or type(e).__name__} - sums = {k: float(got[k]) for k in (*COSTS, "계")} - return {"ok": True, **head, "로직": logic["키"], **sums} + got = mh.hour(row, logic, index) + return {"ok": got["ok"], **head, **got} # ── 검사 ────────────────────────────────────────────────────────────── @@ -420,9 +433,9 @@ def create_own(raw: Any = None, base: str | None = None) -> dict[str, Any]: return create(raw, base) -def update_own(key: str, raw: Any) -> dict[str, Any]: +def update_own(key: str, raw: Any, ver: str | None = None) -> dict[str, Any]: not_m01(raw, key) - return update(key, raw) + return update(key, raw, ver) def create(raw: Any = None, base: str | None = None) -> dict[str, Any]: @@ -430,37 +443,44 @@ def create(raw: Any = None, base: str | None = None) -> dict[str, Any]: seed = _seed(base) if base else {} raw = raw if isinstance(raw, dict) else {} body = clean({**seed, **raw, "값": {**seed.get("값", {}), **(raw.get("값") or {})}}) - data = _read() - key = f"{PREFIX}{_user()}-{data['다음']:04d}" when = _now() - row = {"키": key, "원문번호": f"{NO}{key}", "원문": "개인", "구분": "개인", "상세구분": body["이름"], - **body, "넣은날": when, "고친날": when, **({"본뜬": base} if base else {})} # fmt: skip - atomic_write_json(_dir() / NEXT, {"다음": data["다음"] + 1}) # 번호 먼저 — 겹쳐 쓰지 않게 - _put(row) + row = add(lambda key: {"키": key, "원문번호": f"{NO}{key}", "원문": "개인", "구분": "개인", + "상세구분": body["이름"], **body, "넣은날": when, "고친날": when, + **({"본뜬": base} if base else {})}) # fmt: skip return answer(row) -def update(key: str, raw: Any) -> dict[str, Any]: - _user() - data = _read() - old = next((r for r in data["줄"] if r["키"] == key), None) +def _old(key: str) -> dict: + old = next((r for r in rows() if r["키"] == key), None) if old is None: raise _bad(f"없는 내 기계 「{key}」", 404) + return old + + +def update(key: str, raw: Any, ver: str | None = None) -> dict[str, Any]: + """고침 — `ver`(화면이 연 판)가 지금 판과 다르면 409 {stale, 판} · None = 대조 없음(초안 저장 등 서버 길).""" + _user() + _old(key) body = clean(raw) - keep = {k: old[k] for k in ("키", "원문번호", "원문", "구분", "넣은날", "본뜬") if k in old} - row = {**keep, "상세구분": body["이름"], **body, "고친날": _now()} - _put(row) - return answer(row) + with _LOCK: + old = _old(key) + if ver is not None and (have := version(key)) != ver: + raise store.StoreError(409, {"stale": [key], "판": have}) + keep = {k: old[k] for k in ("키", "원문번호", "원문", "구분", "넣은날", "본뜬") if k in old} + row = {**keep, "상세구분": body["이름"], **body, "고친날": _now()} + _put(row) + now = version(key) # 잠금 안 판 — 뒤 고침이 끼어도 화면이 그 고침을 덮지 않게 + return {**answer(row), "판": now} def delete(key: str) -> dict[str, Any]: """지움 — 이미 만든 단가산출은 사본의 마지막 값 그대로(「지운키」).""" _user() - data = _read() - if not any(r["키"] == key for r in data["줄"]): - raise _bad(f"없는 내 기계 「{key}」", 404) + _old(key) used = uses().get(key, []) - (_dir() / f"{key}.json").unlink(missing_ok=True) + with _LOCK: + _old(key) + (_dir() / f"{key}.json").unlink(missing_ok=True) return {"지움": key, "쓰는곳": used} @@ -509,6 +529,7 @@ def same(name: Any, spec: Any, skip: str = "") -> list[dict]: def answer(row: dict, used: list | None = None) -> dict[str, Any]: out = { "줄": row, + "판": version(row["키"]), "시간당": hourly(engine(row), whole()), "같은이름": same(row["이름"], row["규격"], row["키"]), } diff --git a/M02_MasterTemplete/M02_MyMachine_Api.ts b/M02_MasterTemplete/M02_MyMachine_Api.ts index bd686defe..a7f10a983 100644 --- a/M02_MasterTemplete/M02_MyMachine_Api.ts +++ b/M02_MasterTemplete/M02_MyMachine_Api.ts @@ -48,6 +48,8 @@ export interface Use { export interface MyMachineOne { 줄: MyMachine; + /** 연 판(854-1) — 고치기 때 보냄 · 다르면 409(`StaleError`) */ + 판?: string; 시간당: MyHourly; 같은이름: { 키: string; 이름: string; 규격: string; 출처: string }[]; 쓰는곳?: Use[]; @@ -116,8 +118,9 @@ export const updateMyMachine = ( owner: string | null, k: string, body: MyMachineBody, + ver?: string, ): Promise => - call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body }) }); + call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body, 판: ver ?? null }) }); /** 저장 전 영향(848-5) — 바뀐 칸 · 이 층 쓰는 단가산출(그 칸을 따로 고쳐 둠?) · 쓰기 없음 */ export interface MyMachineImpact { diff --git a/M02_MasterTemplete/M02_MyMachine_Draft.py b/M02_MasterTemplete/M02_MyMachine_Draft.py index cfb51347b..f289820e1 100644 --- a/M02_MasterTemplete/M02_MyMachine_Draft.py +++ b/M02_MasterTemplete/M02_MyMachine_Draft.py @@ -140,15 +140,19 @@ def renew(copy: Any) -> Any: def _new(row: dict) -> str: """새 내 기계 파일(`mym.create` 와 같은 꼴 · 값은 초안 그대로 — 본뜬 값을 다시 섞지 않음).""" - data = mym._read() - key = f"{mym.PREFIX}{mym._user()}-{data['다음']:04d}" when = mym._now() - head = {"키": key, "원문번호": f"{mym.NO}{key}", "원문": "개인", "구분": "개인"} body = {k: row[k] for k in ("상세구분", *BODY, "단위", "출처") if k in row} tail = {"넣은날": when, "고친날": when, **({"본뜬": row["본뜬"]} if row.get("본뜬") else {})} - mym.atomic_write_json(mym._dir() / mym.NEXT, {"다음": data["다음"] + 1}) # 번호 먼저 - mym._put({**head, **body, **tail}) - return key + return mym.add( # 번호 발급 + 쓰기 한 잠금(854-1) + lambda key: { + "키": key, + "원문번호": f"{mym.NO}{key}", + "원문": "개인", + "구분": "개인", + **body, + **tail, + } # fmt: skip + )["키"] def saving(body: dict, inner: Callable[[dict], Any]) -> Any: diff --git a/M02_MasterTemplete/M02_MyMachine_Form.ts b/M02_MasterTemplete/M02_MyMachine_Form.ts index ac7b6d766..bdb9f5941 100644 --- a/M02_MasterTemplete/M02_MyMachine_Form.ts +++ b/M02_MasterTemplete/M02_MyMachine_Form.ts @@ -33,6 +33,7 @@ import { type MyMachineOne, type SimilarRow, } from "./M02_MyMachine_Api"; +import { StaleError } from "./M02_MasterTemplete_Api_Fetch"; import { confirmMyMachineImpact } from "./M02_MyMachine_Impact"; import { mt } from "./M02_MyMachine_Text"; import "./M02_MyMachine.css"; @@ -97,6 +98,7 @@ export async function mountMyMachineForm( opt.key ? readMyMachine(opt.owner, opt.key) : Promise.resolve(null), ]); const row = one?.줄; + let ver = one?.판; // 연 판(854-1) — 고치기 때 보냄 · 저장마다 새 판 let base: string | undefined; // 서버 `본뜬` const notice = el("div", { className: "m02-mymach__notice" }); const server = el("div", { className: "m02-mymach__server" }); @@ -173,16 +175,16 @@ export async function mountMyMachineForm( // 정본 고침 = 영향 보고 저장(848-5) if (opt.key && !(await confirmMyMachineImpact(opt.owner, opt.key, body))) return; const got = opt.key - ? await updateMyMachine(opt.owner, opt.key, body) + ? await updateMyMachine(opt.owner, opt.key, body, ver) : await createMyMachine(opt.owner, body, base); + ver = got.판; saved = true; opt.onDirty?.(false); showToast(mt("Saved"), "success"); opt.onSaved(got); } catch (error) { - notice.replaceChildren( - createText(error instanceof Error ? error.message : mt("Failed"), "error"), - ); + const why = error instanceof StaleError ? mt("Stale") : error instanceof Error ? error.message : mt("Failed"); // prettier-ignore + notice.replaceChildren(createText(why, "error")); } finally { saveBtn.disabled = m01Same; } diff --git a/M02_MasterTemplete/M02_MyMachine_Router.py b/M02_MasterTemplete/M02_MyMachine_Router.py index 31ee23219..2637bf04b 100644 --- a/M02_MasterTemplete/M02_MyMachine_Router.py +++ b/M02_MasterTemplete/M02_MyMachine_Router.py @@ -2,8 +2,9 @@ GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) · POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) · -PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · -POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}. +PUT `/{키}` 몸 {줄, 판?}(판 = 연 판 · 다르면 409 {stale, 판} · 854-1) · +POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · +옛 POST `/draft`(기계 창 [확인] · 화면 0)은 853-3 에서 지움 — 확인 셈 `M02_MyMachine_Draft.check` 는 시험 827-1 기준값으로 남김. 권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404). ⚠ 등록은 `main.py`(로그인만). """ @@ -17,7 +18,6 @@ from pydantic import BaseModel from common_util.common_util_auth import verify_session from M02_MasterTemplete import M02_MyMachine as mym -from M02_MasterTemplete import M02_MyMachine_Draft as draft from M02_MasterTemplete import M02_MyMachine_Impact as impact from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Session, _call, _root @@ -28,8 +28,7 @@ PATH = "/layers/{layer}/my-machines" class MachineBody(BaseModel): 줄: dict[str, Any] | None = None 본뜬: str | None = None - 키: str | None = None # 초안 확인(827-1) — 고칠 내 기계 - 표지: str | None = None # 초안 확인(827-1) — 화면이 정한 표지(셈 기록 열쇠) + 판: str | None = None # 고치기 — 화면이 연 판(854-1 · 다르면 409) def _folder(session: Session, layer: str, owner: str | None, write: bool = False): @@ -43,16 +42,6 @@ def my_machines(layer: str, owner: str | None = None, session: Session = Depends return _call(_folder(session, layer, owner), mym.listing) -@router.post(PATH + "/draft") -def my_machine_draft( - layer: str, - body: MachineBody, - owner: str | None = None, - session: Session = Depends(verify_session), -): - return _call(_folder(session, layer, owner, True), draft.check, body.model_dump()) - - @router.get(PATH + "/{key}") def my_machine( layer: str, key: str, owner: str | None = None, session: Session = Depends(verify_session) @@ -78,7 +67,7 @@ def my_machine_update( owner: str | None = None, session: Session = Depends(verify_session), ): - return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄) + return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄, body.판) @router.post(PATH + "/{key}/impact") diff --git a/M02_MasterTemplete/M02_MyMachine_Text.ts b/M02_MasterTemplete/M02_MyMachine_Text.ts index df7e114e1..d79a93497 100644 --- a/M02_MasterTemplete/M02_MyMachine_Text.ts +++ b/M02_MasterTemplete/M02_MyMachine_Text.ts @@ -28,6 +28,7 @@ const TEXT = { Back: "목록", Close: "닫기", Failed: "못 함", + Stale: "그 사이 다른 곳에서 바뀜 — 목록에서 다시 열어 고침", Name_Needed: "이름 · 비어 있음", Same: "같은 이름 · 규격 있음 — {value}", Copied: "「{value}」 값을 복사 — 고친 뒤 [저장]", diff --git a/M02_MasterTemplete/M02_San_Book.py b/M02_MasterTemplete/M02_San_Book.py index e11fe2f4c..027b518d5 100644 --- a/M02_MasterTemplete/M02_San_Book.py +++ b/M02_MasterTemplete/M02_San_Book.py @@ -152,14 +152,6 @@ def flat(s: Any) -> str: return re.sub(r"\s+", "", str(s or "")) -def _hcol(rows: list[list[Any]], word: str, start: int = 2) -> int | None: - for r in rows[start : start + 2]: - for j, v in enumerate(r): - if flat(v) == word: - return j - return None - - def _n(v: Any) -> float | None: if isinstance(v, (int, float)): return float(v) @@ -192,51 +184,3 @@ def applied_how(r: list[Any]) -> tuple[dict[str, float], str | None]: return got, None # 쓸 값이 없음 — 표지할 것 없음 why = "적용 칸 합이 안 맞음" if a["T"] else "적용 칸 비어 있음" return got, f"당초 칸 사용 — {why}" + (f" ({gap})" if gap else "") - - -def applied(r: list[Any]) -> dict[str, float]: - return applied_how(r)[0] - - -def est_prices(book: dict[str, list]) -> tuple[list[dict[str, Any]], dict[int, dict[str, Any]]]: - """→ (단가 목록 [{종류, 이름, 규격, 비목, 값}], 산근 총괄 {번: {T, L, M, S, 이름, 규격}}).""" - out: list[dict[str, Any]] = [] - lab = book.get("노임단가", []) - c = _hcol(lab, "적용단가") - for r in lab[3:]: - if c is not None and len(r) > c and r[2] and isinstance(r[c], (int, float)): - out.append( - {"종류": "노임", "이름": flat(r[2]), "규격": "", "비목": "L", "값": float(r[c])} - ) - mat = book.get("자재단가", []) - c = _hcol(mat, "적용단가") - for r in mat[4:]: - if c is not None and len(r) > c and r[2] and isinstance(r[c], (int, float)): - out.append( - { - "종류": "자재", - "이름": flat(r[2]), - "규격": flat(r[3]), - "비목": "M", - "값": float(r[c]), - } - ) - for sheet, kind in (("기계경비총괄표", "기계"), ("견적단가", "견적")): - for r in book.get(sheet, [])[3:]: - if len(r) > 28 and r[2]: - for k, v in applied(r).items(): - if isinstance(v, (int, float)) and (v or k != "T"): - one = {"종류": kind, "이름": flat(r[2]), "규격": flat(r[3])} - out.append({**one, "비목": k, "값": float(v or 0)}) - san: dict[int, dict[str, Any]] = {} - for r in book.get("단가산출총괄표", [])[3:]: - if len(r) > 28 and str(r[1]).strip().isdigit(): - n = int(str(r[1]).strip()) - got, note = applied_how(r) - san[n] = {k: float(v or 0) for k, v in got.items()} - san[n] |= {"이름": flat(r[2]), "규격": flat(r[3]), "칸": note} - for k in "TLMS": - if san[n][k] or k != "T": - one = {"종류": "산근", "이름": f"단산{n}", "규격": ""} - out.append({**one, "비목": k, "값": san[n][k]}) - return out, san diff --git a/M02_MasterTemplete/M02_San_MatPick.py b/M02_MasterTemplete/M02_San_MatPick.py index 2b03c7dbc..e5ec2794a 100644 --- a/M02_MasterTemplete/M02_San_MatPick.py +++ b/M02_MasterTemplete/M02_San_MatPick.py @@ -139,12 +139,6 @@ def chosen(item: dict) -> dict | None: return got if got and not _apart(res) else None -def item_key(res: dict) -> str | None: - """줄 품목 키 — 고름 › 엔진 이음.""" - found = res.get("재료찾기") or {} - return (found.get("고름") or {}).get("키") or found.get("키") - - def apart_note(found: dict) -> str: """별도계상 줄 설명 — 품목이 있으면 「별도계상 · 품목: 이름 규격」.""" from M02_MasterTemplete import M02_San_Link as link diff --git a/M02_MasterTemplete/M02_San_Stmate.py b/M02_MasterTemplete/M02_San_Stmate.py index 89cde2e67..b8f8c8086 100644 --- a/M02_MasterTemplete/M02_San_Stmate.py +++ b/M02_MasterTemplete/M02_San_Stmate.py @@ -182,10 +182,3 @@ def parse_line(g: str | None) -> dict[str, Any]: if refs: return {**head, **_ref_line(st, refs[0])} return {**head, **_assign_line(st)} - - -def parse_block(lines: list[dict[str, Any]]) -> list[dict[str, Any]]: - """[{행, G}] → 줄 나무 목록(행 · 원문 붙임).""" - return [ - {"행": ln.get("행"), "글": ln.get("G") or "", **parse_line(ln.get("G"))} for ln in lines - ] diff --git a/M02_MasterTemplete/M02_San_Xlsx.py b/M02_MasterTemplete/M02_San_Xlsx.py index abb69a007..56d77e2cc 100644 --- a/M02_MasterTemplete/M02_San_Xlsx.py +++ b/M02_MasterTemplete/M02_San_Xlsx.py @@ -122,7 +122,7 @@ def _table(rows: list[list[Any]], price: tuple[str, ...]) -> list[dict[str, Any] def resources(sheets: dict[str, list]) -> dict[str, list[dict[str, Any]]]: """같은 책 단가표 → {종류: [{번 · 이름 · 규격 · 단위 · 표 · 값 {T L M S}}]}(노임 · 자재 = 적용단가 · - 기계 · 견적 · 산근 = 적용 칸(합이 안 맞으면 당초 · `M02_San_Book.applied`)).""" + 기계 · 견적 · 산근 = 적용 칸(합이 안 맞으면 당초 · `M02_San_Book.applied_how`)).""" out: dict[str, list[dict[str, Any]]] = {} for kind, sheet, comp in (("노임", "노임단가", "L"), ("자재", "자재단가", "M")): rows = sheets.get(sheet) or [] diff --git a/M02_MasterTemplete/M02_Sangeun_Imported.py b/M02_MasterTemplete/M02_Sangeun_Imported.py index 61ee815a2..951f94479 100644 --- a/M02_MasterTemplete/M02_Sangeun_Imported.py +++ b/M02_MasterTemplete/M02_Sangeun_Imported.py @@ -561,7 +561,8 @@ def create( new: bool = False, use: str | None = None, ) -> dict[str, Any]: # fmt: skip """엔진 로직 줄 + 원본 → 지금 층 새 가져온 식 SK — 서버가 다시 셈해 엑셀과 맞댐(검산 · - 다르면 `같음` False 로 표지 · 막지 않음) · 같은 층 같은 내용 = 409(`ask` · 733-2).""" + 다르면 `같음` False 로 표지 · 막지 않음) · 같은 층 같은 내용 = 409(`ask` · 733-2) · + 서버 길(POST sangeun/imported)은 853-3 에서 걷음 — 시험이 가져온 식 SK 바탕으로 씀.""" return keep(new_doc(logic, source, name, unit, head), new, use) diff --git a/M02_MasterTemplete/M02_Sangeun_Router.py b/M02_MasterTemplete/M02_Sangeun_Router.py index d030ffa44..7040427e0 100644 --- a/M02_MasterTemplete/M02_Sangeun_Router.py +++ b/M02_MasterTemplete/M02_Sangeun_Router.py @@ -1,6 +1,6 @@ """M02 단가산출(SK) 셈 길(PLAN 715-1b) — `POST /api/m02/layers/{층}/sangeun/calc` · 일위대가 [+ 줄] M01 기초 = 그 층 SK 사본(811-1 · `M02_Labor_SkRow`) `…/sangeun/from-logic`(층 쓰기) · -가져온 식(793-2 · `M02_Sangeun_Imported`) `…/sangeun/imported`(만들기 · 층 쓰기) · `/price` · +가져온 식(793-2 · `M02_Sangeun_Imported`) `…/sangeun/imported/price` · `/link`(화면 캐시 문서 고침 · 저장 없음 · 층 읽기 · 기초로 바꾸기 없음 · 809-1) · 불러오기 단산 블록 → 가져온 식(793-3b · `M02_Sangeun_FromHopyo`) `…/sangeun/from-hopyo` (늘 개인 층 쓰기 · 몸 `문서` = 미리 보기에서 고친 문서) · 미리 보기 `…/from-hopyo/preview`(층 읽기 · 안 씀 · 835-1). @@ -81,31 +81,6 @@ def calc_sangeun( return _call(_root(session, layer, owner), _calc, body) -class ImportedBody(BaseModel): - 로직: dict[str, Any] - 원본: dict[str, Any] | None = None - 이름: str = "" - 단위: str = "" - 구분: str = "" - 상세구분: str = "" - 새로: bool = False - 씀: str | None = None - - -@router.post("/layers/{layer}/sangeun/imported") -def sangeun_imported( - layer: Layer, - body: ImportedBody, - owner: str | None = None, - session: Session = Depends(verify_session), -) -> dict: - """가져온 식 단가산출 만들기(793-2) — 답 = {이름, 검산, 단가기준} · 같은 내용 409.""" - folder = _root(session, layer, owner, write=True) - head = {"구분": body.구분, "상세구분": body.상세구분} - args = (body.로직, body.원본, body.이름, body.단위, head, body.새로, body.씀) - return _call(folder, _sd(imp.create), *args) - - class FromHopyoBody(BaseModel): 층: Layer 주인: str | None = None diff --git a/M02_MasterTemplete/logic/M02_MasterTemplete_Hopyo_Unit.ts b/M02_MasterTemplete/logic/M02_MasterTemplete_Hopyo_Unit.ts deleted file mode 100644 index 2284bd34e..000000000 --- a/M02_MasterTemplete/logic/M02_MasterTemplete_Hopyo_Unit.ts +++ /dev/null @@ -1,61 +0,0 @@ -/* ============================================================================= - * M02_MasterTemplete_Hopyo_Unit.ts — 확인 창 대상 이름 옆 「단위 환산」 칸의 보이기 판정(PLAN 784-2 · 요구 635-2). - * 순수 계산(화면 · fetch 없음) — 숨김 조건 · 두 단위 글 재료 · 추정 두께. - * · same = 배 1 · 단위 같음(서버 갈래 같음 · 두 단위 · 단위표 1) → 칸 숨김 · 「단위 같음 ×1」 - * · quota = 배가 몫(0.1)과 같음 → 칸 숨김 · 「몫 0.1」 만 - * · input = 빈칸 · 추정 · 그 밖 → 입력 칸 「엑셀 1 ㎡ = 우리 [ ] 본」 - * 값 자체(배)는 안 바꿈 — 서버 `Match.factor` 가 낸 배 · 갈래를 보이기만 다르게. - * ========================================================================== */ - -export interface UnitPart { - 배: number | null; - 몫?: number | null; - 환산?: { 배: number | null; 갈래: string } | null; - 단위?: string | null; -} - -export type UnitMode = "same" | "quota" | "input"; - -export interface UnitView { - mode: UnitMode; - /** 엑셀 단위 · 우리 단위(빈 글 = 모름) */ - from: string; - to: string; - /** 추정 갈래 — 두께 m(㎡ → ㎥ 일 때만 · 아니면 null) */ - thick: number | null; - estimated: boolean; -} - -const plain = (u: string | null | undefined): string => - String(u ?? "") - .replace(/\s+/g, "") - .replace("㎡", "m2") - .replace("㎥", "m3") - .toLowerCase(); -const close = (a: number, b: number): boolean => Math.abs(a - b) < 1e-9; - -export function unitView( - p: UnitPart, - from: string | null | undefined, - to?: string | null, -): UnitView { - const f = String(from ?? "").trim(); - const t = String(to ?? p.단위 ?? "").trim(); - const quota = p.몫 != null && p.몫 !== 1; // 몫 1 = 몫 없음과 같음 - const kind = p.환산?.갈래; - const unitSame = kind - ? kind === "같음" || kind === "두 단위" || (kind === "단위표" && p.환산?.배 === 1) - : plain(f) !== "" && plain(f) === plain(t); - const at = quota ? (p.몫 as number) : 1; - const hidden = p.배 !== null && close(p.배, at) && unitSame; - const estimated = kind === "추정"; - const thick = - estimated && plain(f) === "m2" && plain(t) === "m3" && p.환산?.배 != null ? p.환산.배 : null; - return { - mode: hidden ? (quota ? "quota" : "same") : "input", - from: f, - to: t, - thick, - estimated, - }; -} diff --git a/docs/raw/요구_1104/사용자요구_1104.md b/docs/raw/요구_1104/사용자요구_1104.md index 24510cfb3..312fd38fb 100644 --- a/docs/raw/요구_1104/사용자요구_1104.md +++ b/docs/raw/요구_1104/사용자요구_1104.md @@ -1583,3 +1583,24 @@ b09원가에서는 확인할필요 없음. 어차피 m02의정보를 가져가 ## 요구 896 (11-17 · 사용자 · 분석 894 보고 답 — 정할 것 5 번(옛 자료 · 한 번용 스크립트)은 tmp 폴더에 보관 · 나머지 항목 전체 동의 · 천천히 단계적으로 오류 없게 진행) 5번 tmp폴더에 보관. 나머지 항목은 전체 동의. 천천히 단계적으로 오류 없게 진행할것. + +## 요구 897 (11-17 · 사용자 · 예상 종료 시간 물음 · 워크트리를 늘리면 빨라지는지 · 창 여덟까지 늘려도 됨 · 왜 오래 걸리는지 물음) + +예상종료시간? + +워크트리를 더 늘려서 진행하면 빨라질까? + +8개 창까지는 늫려도 됨. + +그런데 궁금한게 왜 이렇게 오래걸리는거야? + +## 요구 898 (11-17 · 사용자 · 걸음 2 설계 「브레인이 정한 것」 넷에 답 — B08 · B09 는 M02 것을 복사해 가져가 비목별 합산만 · 직접 계산 없음 / 옛 로직 파일은 tmp 로 이동(한 번에 삭제 예정) / 막힘 기준 일단 유지 / 화면 단가는 품셈 원문 자릿수로 보이고 계산은 정밀하게) + +1. B08/B09는 M02에서 만들어진 단가산출, 일위대가, 구조물조합을 통해 복사하여 프로젝트 내부로 들어감. 계산은 인건비, 재료비, 경비를 구분하여 합산 정도만 함. 계산을 직접할 일은 없음. +2. 옛로직 파일은 tmp 폴더로 이동(한번에 삭제예정) +3. 일단유지 +4. 화면의 단가는 끝수는 사용자에게 보여질때는 품셈의 원문의 단위당 소수점 자리수를 따르게 되어있으며 계산은 정밀도 있게 계산해달라고 요청했었음. 반영되어있을걸로 보임. + +## 요구 899 (11-17 · 사용자 · 지금 M02 의 개인 · 회사 · 마스터 데이터는 개발 중 테스트 결과 — 삭제해도 됨) + +추가로 현재 M02의 개인/회사/마스터 데이터는 프로그램 개발과정에서 테스트한 결과임. 삭제 해도됨. diff --git a/docs/raw/요구_1104/설계_855_보충_B09_로직JSON_호환.md b/docs/raw/요구_1104/설계_855_보충_B09_로직JSON_호환.md new file mode 100644 index 000000000..276867106 --- /dev/null +++ b/docs/raw/요구_1104/설계_855_보충_B09_로직JSON_호환.md @@ -0,0 +1,286 @@ +# 설계 855 보충 — 사용자 확정 넷 반영 (PLAN 855-F) + +요구 898 · 899 · sub7 · 2026-11-17 · 읽기 · 세기만(코드 · 자료 · 시험 고침 0). 바탕 = `docs/raw/요구_1104/설계_855_정본하나_계산기하나.md`(아래 「본 설계」). +세는 도구 · 결과 = `tmp/s894/m855b/`(sub6 도구 셋 복사 + 새 도구 넷 · 결과 파일은 4 절 끝 표). + +## 0. 한눈 요약 + +- **B08 · B09 는 지금 「M02 셈 답을 받는」 게 아니라 「M02 를 복사한 옛 로직 줄을 옛 엔진으로 다시 푸는」 꼴** — 프로젝트 사본 `단가.json` 에 M01 로직 줄 · 굳힌 SK 로직 줄(`로직_단가산출.json` `GX9…`)을 싣고, B09 가 그 줄을 `run_line` · `mf.evaluate` 로 다시 풀어 수량 · 자원 키 · 하위 산근 · 풀이 글을 얻음. 셈 몸은 이미 M02 엔진 값(841-1) — B09 고유 셈은 비목 합 · 끝수 · 관급 0 원 · % 밑수뿐. +- 사본에 이미 `수식.json`(수식 문서 닫힌 묶음 · 802-4a)이 같이 실림 — **쓰는 곳 0**(만들기만). +- 권함 = **안 B「프로젝트는 M02 계산기(문서 셈) 한 벌을 불러 사본을 셈 · B09 는 답을 갈라 합산만」** + 입력 지문이 같으면 다시 안 셈(파생 저장본). 안 A(복사 때 셈 답만 굳힘)는 프로젝트 입력값(구조물마다 · 운반 거리) · [단가 갱신] 이 다시 셈을 요구해 못 씀. +- **B09 손 줄이 M01 기초를 직접 고름**(설계내역서 [단가 연결] · 운반 단가 모달 · `ref.tab = logic`) — 저장된 프로젝트 1 곳에 **6 줄 살아 있음**. M02 를 거치지 않는 유일한 길 → 판단 거리 1. +- 로직 JSON 칸 19 가운데 문서에 같은 값으로 이미 있는 것 4(`이름 결과단위 출처 부품`) · 문서로 옮길 이름표 6(`원문번호 구분 상세구분 소유 비고 개정`) + `별칭`(지금 값 0) + 파일 머리 3(`원문 부문 차례`) · 셈 칸 8 은 문서 셈 칸이 대신(버림) · **문서에 없는 정보 = 이름표뿐**. +- 로직 줄을 직접 읽는 파이썬 자리 = `.logic(` 류 **102 곳 · 49 파일**(M01 7 파일 19 · M02 23 파일 48 · B09 7 파일 16 · scripts 12 파일 19) + 층 서고 SK `수식.로직` · `사본.로직`(로직 줄 값 사본 28 줄) — 모두 문서 읽기로 옮긴 뒤 로직 JSON 을 뺌. +- **지금 진행 중인 기초 고침(851-1 등)이 로직 JSON → 빌더 길을 씀** — 로직 JSON 을 빼기 전에 「기초 내용 고침 = 수식 문서를 바로 고치는 스크립트 · M01 [저장]」 으로 길을 바꿔야 함(차례 조건). +- 호환을 안 만들면 빠지는 것: 2-D 올림 규칙 · 사본 없는 SK 옛 길 · 옛 SK 상세 시험 8 군 고쳐 쓰기 · 프로젝트 옛 사본 꼴 읽기(`items/` · `complete_old`) · SK `사본` · `수식.로직` 이행 — **어림 −1,200 줄 · 걸음 하나(2-D) 크기 절반**. +- 저장본을 비울 때 = **2-C1(SK 셈 한 길) 바로 앞**(옛 칸을 읽는 셈이 꺼지기 전에 자료가 0 이면 2-C1 · 2-D 가 옛 꼴을 볼 필요 없음). +- 「가져온 식」(`가져온.로직` = 옛 로직 줄 꼴)은 저장본을 비워도 불러올 때마다 새로 생김 → 옛 식 **파서만** 불러오기 몫으로 남김(엔진 몸은 지움) · 857 이 문서를 바로 내면 그때 걷음. + +--- + +## 1. ㉮ B08 · B09 — 옛 엔진 부름 걷기 + +### 1-1 옛 엔진을 부르는 자리 하나하나 + +길 = 화면 → 서버 길 → 함수. 「살아 있음」 = 화면 단추 · 페이지 열기가 실제로 탐 · 「자료 0」 = 길은 살았으나 지금 저장소에 그 자료가 없어 실제로는 안 돎(프로젝트 사본 0 · 구조물 조합 줄 0). + +| 자리 | 부름 | 무엇을 얻으려고 | 타는 길 | 판정 | +| --- | --- | --- | --- | --- | +| `B08_Quantity_Router_Material.py:79` `_ref_mats.run` | `labor.run_line` | 참조 일위대가 안 **옛 로직 줄**의 재료 줄(이름 · 단위 · 품목 키 · 수량) → 단위수량 | B08 자재 집계표 열기 `GET …/quantity/materials`(:275) → `snapshot_units` → `_folder_units`(:117) | 살아 있음 · 자료 0(SC 옛 로직 줄 0) | +| 같은 파일 `_folder_units` | `copies.calc`(`M02_Item_Copy.py:338` → `Item_Prices.calc` → `Labor_Doc.calc` → `run_line`) | 사본 일위대가 줄 재료 · 자재 수량 | 같음 | 살아 있음 · 자료 0(사본 0) | +| `B09_Estimation_Sangeun.py:346` `Solver._solve:333` | `labor_doc.run_line(raw=True)` | 산근 줄마다 **엔진 금액 ÷ 수량 = 단가**(841-1) | B09 열기 · [저장] · 셈 `GET/PUT …/estimation` · `POST …/estimation/calc`(:430) → `calc_user` → `Sangeun.build`(:667) → `collect`(:626) | 살아 있음 · 손 줄 6 이 탐 | +| 같은 파일 `_env:200` | `mau.values` · `mf._inputs` · `mf.evaluate(중간)` | **입력 기본값** · 중간 값(작업량 Q 표시 자리) | 위 `_solve` 안 | 살아 있음 | +| `_line:445` · `_logic_line:488` | `mf.evaluate(수량)` · `mf.fill(요소)` · `mf.mp.priced` | 줄 **수량 · 자원 키**(노임 · 자재 · 기계) · 고른 품목 | 같음 | 살아 있음 | +| `call_of:223` · `line_calls:242` · `_captured:261` | `mf.parse` · `mf.evaluate` · `whole.get` 가로채기 | **하위 산근**(부른 로직 키 + 넘긴 입력) · 기계경비 줄의 **기계 키** | 같음 + `rows_of`(일위대가화 줄 펼침) + `Labor_Source` | 살아 있음 | +| `_extras:513` | `mf.evaluate(덧줄 식)` · `labor_doc.pct_extras` | **율 줄**(% · 밑수 = B09 비목 합) | 같음 | 살아 있음 | +| `hand_resource_keys:602` | `run_line`(+ `whole.get` 가로채기) | 손 줄이 부르는 **자원 키**(자재 단가 책 수요) | B09 열기 `payload` → `Router.py:238` | 살아 있음 | +| `B09_Estimation_Sangeun_Text.py` 13 함수 31 곳(`render_sangeun_text:347`) | `mf.*` · `master_text`(`mtx.fmt` · `render` · `_names`) | **산출근거 글**(머리 · 줄 · 계) | `_solve` → `_text` · `POST …/estimation/logic-preview`(:444 · 운반 단가 모달 ③) | 살아 있음 | +| `B09_Estimation_Sangeun_Sum.py:36 · 87` | `mcut._line` · `mcut.settle` | **끝수**(줄 자리 · 끝전 · 조정 · 792-3) | `_solve` 안 | 살아 있음 | +| `B09_Estimation_Labor_Rule.py:90 · 115` | `mf.parse`(덧줄 식 꼴 읽기) | 대가 블록 **율 줄 밑수 · 합밖 · 번지 표지**(792-4) | `Labor_Source._poomsem` | 살아 있음 · 자료 0 | +| `B09_Estimation_Labor_Source.py:140` `_poomsem` | `run_line(raw=True)` + `sg.line_calls` | 대가(품셈) 블록 **줄 꼴 · 수량 · 비목 · 하위 산근** | B09 열기 `payload` → `daega_inputs`(:656) | 살아 있음 · 자료 0 | +| 같은 파일 `sangeun:181` → `Supply.sk_money:79` | `Sangeun_Calc.unit`(옛 엔진 + 문서 합계 덮음) | 굳힌 SK 블록 **합(노 · 재 · 경)** | 같음 | 살아 있음 · 자료 0 | +| `B09_Estimation_Linked.py:64` `used_keys` | `run_line`(+ `get` 가로채기) | 사본이 부르는 **자원 키**(단가 책 수요) | `payload` → `linked_resource_keys`(`Router.py:237`) | 살아 있음 · 자료 0 | +| `M02_Item_Sangeun.py:45` `freeze` | `Sangeun_Calc.resolve` | 사본 만들 때 SK 를 **옛 로직 줄 하나(GX9)로 굳힘** | 구조물 [저장] → `Item_Snapshot.build_snapshot:126` · B09 서고 [가져오기] `POST …/estimation/library` → `Bill_Library.import_copy:272` · [재생성] `Refresh` | 살아 있음 · 자료 0 | +| `M02_Item_Prices.py:234` `collect` · `:346` `calc` | `_texts`(옛 식 글 훑기) · `mf._expand` 류 · `Labor_Doc.calc` | 사본 **닫힌 묶음**(로직 줄 · 요소 · 표) 모으기 · 사본 셈 | 사본 만들기 · B08 · B09 전부 | 살아 있음 | + +죽은 길 = 없음(모두 화면에서 닿음). 지금 실제로 도는 것은 **손 줄 로직 6 줄**(B09 프로젝트 1 곳)뿐 — 나머지는 자료 0. + +### 1-2 사본에 지금 실어 오는 것 대 실어 와야 할 것 + +| 파일(구조물 사본 `templates/structures/{id}/` · B09 서고 `library/`) | 지금 내용 | 쓰는 곳 | 끝 모습(안 B) | +| --- | --- | --- | --- | +| `일위대가.json` | 일위대가 문서 + **M01 로직 줄 사본**(`로직`) · 알약 · `참조사본`(SC · 굳힌 SK 문서 = `굳힌줄` · `원본` · `정체`) (`Item_Source.py:93 · 105`) | B08 · B09 전부 | 일위대가 문서 + 참조사본(SC 그대로 · **SK = 수식 문서 사본**) · 로직 줄 사본 없음 | +| `단가.json` | 닫힌 묶음 = **M01 로직 줄** + 요소 · 표 줄 + 자원 단가 줄 + `로직_단가산출.json`(GX9 굳힌 SK 줄) (`Item_Source.py:162`) | 옛 엔진 색인(`load_prices`) | **자원 단가 줄 · 표 줄만**(로직 줄 · GX9 없음) — [단가 갱신] 이 바꾸는 자리 | +| `수식.json` | 수식 문서 닫힌 묶음(`Doc_B09.build:33` · 802-4a) | **없음**(만들기만) | **셈 정본** — 프로젝트 셈이 읽는 유일한 식 | +| `입력값.json` · `고른자재.json` · `면적.json` | 구조물마다 입력 · 고른 재료 · 알약 칸 값 | 사본 셈 | 그대로(키 = 문서 키 · 입력 이름 → 변수 열쇠 맞춤 필요) | +| B09 견적 `user_values.json` 손 줄 `ref{tab: logic, code, given, rate, picks}` | M01 로직 키 + 입력 | `hand_whole`(지금 M01 묶음 즉석 모음) | 안 바뀜 — 키가 같은 수식 문서로 셈(판단 거리 1) | + +### 1-3 「프로젝트는 직접 계산하지 않음」 을 지키는 두 안 + +B09 가 셈 답에서 먹는 것 = 줄마다 **이름 · 종류(인력 · 자재 · 기계 · 하위 산근 · 율) · 자원 키 · 수량(1 단위) · 비목 금액 · 하위 부름(키 + 입력) · 율 밑 · 끝수 표지** + **풀이 글**. 새 계산기 답(`master_doc_calc.calc:545` → 줄 `{이름 비목 수량 단가 금액 까닭 합밖 묶음 작업량}`)에 **자원 키 · 하위 부름이 없음** → 어느 안이든 「줄마다 무엇을 불렀나」 기록이 새로 필요(셈은 안 바꿈 · 연결 풀이 `master_doc_link.Links` 를 감싸 부른 것을 적음 · 서버 단독 · TS 짝 안 건드림). + +| 경우 | 안 A — 복사 때 셈 답을 굳혀 실어 옴 | 안 B — 프로젝트가 M02 문서 계산 함수를 불러 사본을 셈(권함) | +| --- | --- | --- | +| 실어 오는 것 | 셈 답(줄 · 비목 · 자원 키 · 하위 부름 · 풀이 글) | 수식 사본 + 자원 단가 줄(지금 `수식.json` + 줄인 `단가.json`) | +| 프로젝트 안 [단가 갱신] | 자원 단가가 바뀌면 줄 금액이 달라짐 → 굳힌 답 못 씀 → M02 에서 다시 복사([재생성]) 해야 함 = 지금 뜻(사본 로직 그대로 · 단가만 새로)과 다름 | 자원 줄만 바꾸고 다시 셈 — 지금 뜻 그대로 | +| 수량 · 입력 바뀜(구조물마다 입력값 · 운반 거리 이정표 `haul_dist` · 면적 알약) | 입력이 바뀌면 굳힌 답 무효 → 못 함 | 같은 계산기로 다시 셈 | +| 산출근거 보기 | 굳힌 글(단가 갱신 · 입력 바뀜 뒤엔 틀림) | 셈 답 → 서버 풀이 글(본 설계 ② `master_doc_text` · 2-C4) + B09 단가 | +| 내역서 합산 | 같음(비목 합) | 같음(비목 합) — B09 고유 셈 = 비목 합 · 끝수 · 관급 0 원 · % 밑수만 | +| 손 줄 M01 로직(6 줄) | 고를 때 M02 에서 셈해 굳힘 — 입력 바꾸면 다시 | 그대로 문서 셈 | +| 속도 | 빠름 | 입력 지문이 같으면 저장본(CLAUDE.md 5 장 「파생 저장본」) → 안 A 와 같은 속도 | +| 고칠 크기 | 사본 꼴 + B09 5 파일 + [단가 갱신] · 입력 바꿈 길 새로 | 사본 꼴 + B09 5 파일(읽는 답만 바뀜) | + +→ **안 B 권함.** 「계산을 직접 할 일 없음」 = B09 에 식 엔진이 없음(계산기는 M01 · M02 와 같은 한 벌) · B09 는 답을 갈라 합산만 — 로 읽음(판단 거리 2 에서 확인). + +### 1-4 걸음(두 박자 · 한 걸음 = 한 커밋 묶음) + +| 걸음 | 무엇 | 파일(어림 줄) | 지킴 | 앞 조건 | +| --- | --- | --- | --- | --- | +| **B9-0 견본 · 골든** | 지금 사본 0 · 조합 줄 0 → **임시 storage 견본 프로젝트**를 시험이 지음: 층 견본(SK 가져온 식 · 따로 · 율 더한줄 · 형제 SK · 기계 · 관급 재료 / SC 참조 · 고정 · 자재 / 구조물 조합 일위대가 열) → 구조물 지정 → 사본 만들기(지금 길) → B09 `calc_user` · `daega_inputs` · `payload` 수요 키 · B08 `snapshot_units` · `logic_preview` 답을 지문으로 `855_b09_golden.json` · 손 줄 견본(운반공 · 율 · 고른 재료) 포함 · 실제 B09 프로젝트 1 곳(손 줄 6)은 자기 포트에서 `GET …/estimation` 답 읽기만 전후 대조(tmp) | 새 `resources/tester/test_855_b09_golden.py`(+ 250) · 견본 짓기는 기존 `test_143_*` · `145_*` · `792_3` · `802_4a` 견본을 모아 씀 | 지금 수치 그대로 통과 | 2-A(855-A) | +| B9-1 셈 기록 | 문서 셈 줄마다 부른 자원 키 · 하위 문서(키 + 입력) · 고른 품목을 적는 연결 감쌈 | 새 `scripts/master_doc_trace.py`(+ 120) · 시험 | 1,521 기초 기본 옵션 — 기록한 자원 키 = 옛 `whole.get` 가로채기 키(같음) | B9-0 | +| B9-2 사본 셈 한 길 | `Item_Copy.calc` · `Item_Prices.calc` = `수식.json` 문서 셈 · B08 `_folder_units` · `_ref_mats` = 문서 셈 답 재료 줄 | `M02_Item_Prices.py`(± 120) · `M02_Item_Copy.py`(± 20) · `B08_Quantity_Router_Material.py`(± 60) | 골든(B08 단위수량 · 사본 셈 금액) 같음 · `test_143_*` · `145_3_b08` | B9-1 · 2-C1(SK 문서 셈) | +| B9-3 B09 산근 · 대가 | `Sangeun._solve · _env · _line · call_of · line_calls · _captured · rows_of · _extras · hand_resource_keys` · `Labor_Source._poomsem` · `Linked.used_keys` · `Supply.sk_money` · `Sangeun_Sum` · `Labor_Rule` → 문서 셈 답 + 기록(끝수 = 답 `끝수` · 율 = 금액 줄 `합밖 · 자리 · 단계` 칸) | `B09_Estimation_Sangeun.py`(± 250) · `_Labor_Source.py`(± 120) · `_Linked.py`(± 40) · `_Supply.py`(± 20) · `_Sangeun_Sum.py`(− 40) · `_Labor_Rule.py`(± 60) | 골든 B09 산근 합 · 줄 비목 · 대가 줄 · 내역서 합계 같음 · `test_145_*` · `792_3`(다섯 길) | B9-1 · 2-C1 | +| B9-4 산출근거 글 | `Sangeun_Text` 31 곳 → 서버 풀이 글(본 설계 ②) + B09 단가 끼움 | `B09_Estimation_Sangeun_Text.py`(± 250 · 줄어듦) | 글 = 골든 글(줄 수 · 금액 숫자) · 화면 산근 탭 · 운반 모달 ③ 확인 | 2-C4(`master_doc_text`) · B9-3 | +| B9-5 사본 꼴 | 새 사본 = `수식.json`(셈 정본) + 자원 줄만 `단가.json` · SK 굳힘(`Item_Sangeun.freeze` → GX9 줄) 대신 SK 수식 문서 사본(따로 · 덮음 반영) · [재생성] · [단가 갱신] 같은 꼴로 | `M02_Item_Source.py`(± 80) · `M02_Item_Sangeun.py`(− 150) · `M02_Doc_B09.py`(± 20) · `B09_Estimation_Bill_Library.py`(± 30) · `_Refresh.py` · `_Copy_Prices.py`(± 40) | 골든 같음 · 사본 파일 칸 전수(`census_copies`) · 옛 꼴 사본 읽기 없음(지금 0 · 1-2) | B9-3 | +| B9-6 옛 길 지움 | B08 · B09 의 `run_line` · `mf` · `mau` · `mtx` · `mcut` 부름 · `Item_Prices` 옛 묶음 모음(`_texts` · `collect` 로직 줄) · `Labor_Doc.run_line` 의 B 쪽 | 위 파일들 · 옛 사본 시험 줄(`test_143_4` · `145_1` · `145_2` 등 옛 꼴 견본 부분) | 골든 · 관련 시험 전부 · `/openapi.json` 같음 | B9-5 | + +### 1-5 2-E4(엔진 모듈 지움) 앞 조건 — 새 차례 + +1. 본 설계 2-C1(SK 셈 한 길) · 2-C4(서버 풀이 글) 끝. +2. B9-0 → B9-6 끝 = B08 · B09 가 옛 엔진 · `master_text` · `master_cut.engine` · `master_auto` 를 부르는 곳 0(`census_calls.py` 에서 B08 · B09 줄 0). +3. 불러오기 옛 식 **파서**(`mf.parse` 류 · `Doc_Import` · `San_Basis_Index` · `Sangeun_QtyLinks`)는 엔진 몸과 떼어 「바탕 기반」 새 모듈로(3-3). +4. 그 뒤 2-E4 = 엔진 몸 · 셈 · 글 · `master_auto` · `master_combo.run` 지움 · `test_791_1` 은퇴. + +--- + +## 2. ㉯ 로직 JSON 없애기 — 수식 문서에 합침 + +### 2-1 칸 전수와 갈 곳(`census_logic_fields.py` · 1,521 줄 · 59 파일) + +| 칸 | 줄 수(값 있음) | 문서에 지금 | 갈 곳 | +| --- | --- | --- | --- | +| 파일 머리 `그룹` · `판` | 59 | 문서 파일 머리 `그룹` · 줄 `판` | 그대로(문서 파일 `그룹 = 수식문서`) | +| 파일 머리 `원문` · `부문` · `차례` | 59 · 45 · 58 | 없음(문서 파일 머리 = `로직파일` 이름만) | **문서 파일 머리로** — M01 분류(원문 · 장 차례 · 부문) 정본 | +| `키` | 1,521 | 같음 | 그대로 | +| `이름` · `결과단위` · `출처` · `부품` | 1,521 · 1,521 · 1,521 · 81 | **같은 값**(다름 0) | 이미 문서 — 로직 쪽 버림 | +| `원문번호` · `구분` · `상세구분` · `소유` | 1,521 | 없음 | **문서 줄 머리로**(이름표) | +| `비고` · `개정` | 1,452 · 1,257 | 없음 | **문서 줄 머리로** | +| `별칭` | 0(지금 값 없음 · 칸은 화면 · 저장 길에 있음) | 없음 | **문서 줄 머리로** | +| `입력` · `중간` · `호표` · `덧줄` · `끝수` · `결과` | 1,245 · 1,227 · 1,452 · 570 · 70 · 65 | 문서 `변수` · `식` · `금액` · `끝수` · `결과`(꼴 다름 · 빌더가 변환) | 버림(문서가 셈 정본 · 금액 다름 0 = 본 설계 3 절) | +| `입력[].고르기`(기계 목록 2,757) | — | 문서 변수 `선택 목록` | 버림(기계 등록이 문서만 고침) | +| `변수표` | 1,423 | 문서 `변수`(이름 · 기호 · 단위 · 빌더 `master_equation` 길) | 버림 | +| `시험입력` | 234 | 없음 | **버림** — 읽는 곳 = 옛 틀 검사(`check_master`) · 옛 수식 탭(`master_equation*`) · 한 번용 스크립트뿐(작은 결정) | + +→ 문서에 없는 정보 = 이름표 칸 여섯 + 별칭 + 파일 머리 셋. 셈 칸은 전부 문서가 대신함. + +### 2-2 로직 줄을 읽는 자리 전수(`census_logic_readers.py` · `.logic(` 류 102 곳 49 파일 · 결과 `out_logic_readers.tsv`) + +| 갈래 | 자리(대표 `파일:줄`) | 무엇을 읽나 | 문서 읽기로 바꾸는 법 | +| --- | --- | --- | --- | +| **M01 관문** | `M01_MasterData_Store.py:337 _logic_files` · `:21-26`(scripts 길 · `check_master.load` → `mf.Master` 로직 그룹) | 로직 파일 전부 | 문서 색인(`master_doc_link.load_all` · 이미 있음)을 관문 하나로 · `mf.GROUPS` 에서 「로직」 뺌 | +| 목록 · 찾기 · 분류 | `Store.logics:343` · `files_of('로직'):113` · `subs` · `Store_List.attach` · `Store_Find`(↔ `ui_template_logic_find.ts` 짝) · 화면 `UI_Side.ts:48` · `Logic_List` | `키 원문번호 구분 상세구분 이름 결과단위 출처 소유 별칭` · 파일 머리 차례 | 같은 칸을 문서 머리에서 · 답 꼴 그대로(화면 안 바뀜) | +| 상세 · 기본정보 | `Store.logic:384`(+ `blocked` · `prices`) · `LogicLab_Detail` · `_Basic` | 줄 통째 · 막힘 · 단가 미리보기 | 이름표 = 문서 머리 · 막힘 = 2-B3 문서 막힘 · 단가 미리보기 = 문서 셈 | +| 별칭 | `M01_MasterData_Alias.py`(`/alias/save` → `Make.save` 별칭 칸) · 로직 목록 `onAlias` | `별칭` 칸 | 문서 머리 `별칭` 쓰기(문서 저장 길 · 잠금 = 걸음 1 의 문서 저장 잠금) | +| 개정 · 개정 확인 | `Store_Revise`(정본 줄 지문 · 409) · `UI_Logic_Text.ts` · `build_로직_개정.py` | `개정` · 줄 지문 | 문서 지문(`dc.doc_fp` 꼴) · 개정 칸 = 문서 머리 | +| 키 대장 | `master_keys`(`_키대장.json`) · `Store_Save._errors`(키 겹침 · 대장 대조) | 로직 키 발급 · 대조 | 대장 그대로 · 대조 대상 = 문서 키 | +| 기계 등록 | `Machine.register`(`M01_MasterData_Machine.py:131-201`) | 로직 `입력[기계].고르기` + 문서 `선택 목록` 두 벌 | 문서만 | +| [신규 로직] · [복사/생성] · [삭제] | `Store_Make`(3 곳) · `/logic/copy` · `/logic/formula*` · `/logic/remove` · `/logic/users` | 로직 줄 만들기 · 지우기 · 쓰는 곳 | 문서만 만들고 지움(854-2 가 문서 같이 만들기 하는 중 → 그 뒤 로직 쪽 걷음) | +| 저장 검사 | `check_master`(로직 틀 · `시험입력`) · `Store_Save._errors` · `Store_Cache._check · check_saved` | 로직 줄 틀 | 문서 검사(`master_doc.check` + 2-B3 막힘) | +| 손고침 판정 | `M01_MasterData_Doc.py`(`built()` = `master_doc_convert.convert(로직 줄)`) | 로직 줄 → 빌더 문서 | 빌더 은퇴와 함께 `손고침` 칸 뜻 없어짐 → 걷음 | +| 계산서 덧칸 | `Store_Sheet` · `master_sheet_line`(B09 `_annotate` 도) | 로직 줄 식 | 문서 셈 기록(B9-1) | +| 일위대가 조합 알약 · 입력 | `M01_MasterData_Store_Combo.combo_pills` · `M02_Labor_Inputs.py:36-94`(`/logic-lib/inputs` ← M02 일위대가 · B09 손 줄 · 운반 모달 `fetchLogicInputs`) · `Combo_Store` · `Router_Combos` | `입력`(이름 · 설명 · 단위 · 고르기 · 범위) · `결과단위` | 문서 `변수`(입력 갈래 · `선택 목록` · `연결.값` 기본값 = 본 설계 ③) | +| M02 기초 고르기 · 찾아 넣기 | `/logic-lib/logics · subs · logic · source`(`M02_MasterTemplete_Router_Combos.py:42-93` → M01 함수) · `Logic_Standard`(2-C4) | 목록 · 이름표 · 출처 | M01 목록 갈래를 따라 바뀜 | +| M02 SK · SC 사본 | `Sangeun_Copy`(`사본.로직` · `수식.로직` = **로직 줄 값 사본**) · `Copy_Slim` · `Doc_Gap` · `Item_Prices.collect`(로직 식 글 훑어 닫힌 묶음) | 로직 줄 · 표 · 요소 줄 | 로직 줄 값 사본 없앰 → `수식.부름`(문서 사본)이 대신 · 닫힌 묶음 = `Doc_Copy.closure`(문서로 · 이미 있음) · 표 · 요소 줄은 남음 | +| M02 그 밖 이름 · 단위 읽기 | `Layer_Index` · `Library_Flat`(5) · `Doc_Copy` · `Doc_Sk` · `Doc_Take` · `Labor_SkRow` · `Sangeun_Doc` · `Sangeun_Block` · `Machine_Find` · `MyMachine*` · `Material_Own` · `Elem_Alias` | `이름` · `결과단위` · `입력` | 문서 머리 · 변수 | +| 불러오기 이음 | `Hopyo_Elem`(5) · `Hopyo_Match`(3) · `Hopyo_Clause` · `Hopyo_Relink` · `Hopyo_Row` · `Hopyo_Units` · `Hopyo_Build` · `Doc_Import` · `San_*` | 엑셀 호표 ↔ M01 기초 맞춤(이름 · 원문번호 · 단위 · 입력) | 문서 머리(원문번호 · 이름 · 단위) · 변수 — **857 과 겹침**(아래 2-3 묶음 ⓒ) | +| B08 · B09 | `Item_Source.logic_rows:105`(사본에 로직 줄 실음) · B09 `Sangeun` 6 · `Sangeun_Text` 4 · `Labor_Source` 2 · `Supply` · `Bill_Hopyo` · `Bill_Library` · `Daega_Personal` | 사본 · 지금 M01 로직 줄 | ㉮ 끝(B9-6)이면 0 | +| 옛 엔진 · 옛 수식 탭 | `master_formula` · `_check` · `_sum` · `master_cut` · `master_text` · `master_combo` · `master_equation*` · `M01_MasterData_Equation` · `M02_Sangeun_Equation` · `M02_Sangeun_Formula` | 로직 줄 셈 칸 | 2-E2 · 2-E4 로 지움 | +| 갱신 스크립트 | `build_로직_직접칸_851_1.py` · `build_로직_개정.py` · `build_용도.py` · `build_재료_검색어.py`(쓰기) · `build_변수표_796_3` · `build_변수기호_800_1` · `build_단위표기_801_5` · `build_기계_작업량_846_1` · `compare_estx` · `master_bundle` · `master_doc_unit` | 로직 JSON 읽고 씀 | 2-4 | +| 시험 | 로직 파일 이름 45 · `.logic(` 42 · `run_line` 27 · `master_formula` 23 · `master_doc_convert` 7 · 빌더 4(1,401 시험 파일 중) | 로직 줄 견본 · 대조 | 걸음마다 그 자리 시험만 문서 견본으로 · 대조 시험은 은퇴 | + +### 2-3 차례 · 병행 · 지킴 + +| 걸음 | 무엇 | 지킴 | 앞 조건 | +| --- | --- | --- | --- | +| L1 이름표 싣기(첫 박자) | 빌더가 이름표 칸 일곱 · 파일 머리 셋을 문서에 실음(`--check` 새 기준) · M01 [저장](비고 · 별칭 · 자체 이름 · 개정)이 두 곳에 씀 | 1,521 문서 이름표 = 로직 줄 이름표(다름 0) · 금액 골든 같음 | 2-B3 · 854-2 끝 · **로직 JSON 을 고치는 일감 0**(851 류 끝) | +| L2 읽는 쪽 바꿈(묶음 셋 병행) | ⓐ M01 목록 · 찾기 · 분류 · 상세 · 별칭 · 개정 · 키 대장 · 저장 검사 · 기계 등록 · 신규 · 복사 · 삭제 ⓑ M02 입력 목록 · 알약 · 이름 읽기 · SK 사본 `로직` 값 사본 없앰(`수식.부름` 으로) · 닫힌 묶음 = 문서 ⓒ 불러오기 이음(Hopyo · San — 857 과 같이 하거나 857 앞에 이름표 읽기만 바꿈) | 화면 답 전후 같음(`/logics` 전 갈래 · `/subs` · `/groups/로직/files` · `/logic` · `/alias` · `/logic-lib/inputs` 답 JSON 대조) · 금액 골든 · 불러오기 골든(`test_812_1`) | L1 · ⓑ 는 2-C1 · 2-D 뒤 · ⓒ 는 2-C2 뒤 | +| L3 로직 JSON 뺌(둘째 박자) | 읽는 곳 0 확인(`census_logic_readers` 관문 · 이름표 0) → `로직_*.json` 59 `git rm`(브레인이 tmp 보관) · `mf.GROUPS` 「로직」 뺌 · 키 대장은 그대로 | 금액 골든 · 화면 답 대조 · 핵심 시험 · 서버 뜸 | L2 · ㉮ B9-6 · 2-E1 · 2-E2 | +| L4 은퇴 | 2-4 표 | `test_855_golden` + `test_802_1`(거울)이 관문 | L3 | + +### 2-4 은퇴 목록 + +| 대상 | 은퇴 때 | 대신 | +| --- | --- | --- | +| 빌더 `build_수식문서_802_2.py` · `master_doc_convert` · `_목록_802-2_변환대조.xlsx` | L3 | 문서가 정본 · 고침 = M01 [저장] · 문서 고침 스크립트 | +| `test_802_2_convert`(싱크 관문) | L3 | `test_855_golden`(지문) + `test_802_1`(파이썬 ↔ TS 거울) 관문 | +| `master_equation*` 6 · `M01_MasterData_Equation` · `M02_Sangeun_Equation` · `master_symbol` | 2-E2(SK 옛 식 덮개 걷음) 뒤 · L3 | 문서 변수(이름 · 기호 · 단위) | +| `M01_MasterData_Doc` 의 `built()` · `손고침` 판정 | L3 | 없음(빌더가 없으니 갈림도 없음) | +| 「로직 줄을 더한 뒤 채우기」 넷(`build_변수표_796_3` · `build_변수기호_800_1` · `build_단위표기_801_5` · `build_재료_검색어`) | L3 | 문서에서 같은 채우기가 필요하면 문서 대상 스크립트로 다시 씀(지금은 새 로직이 늘 때만 돎) | +| `build_로직_개정.py` | L1 에서 문서 머리 `개정` 을 쓰도록 바꿈 | 같은 스크립트 · 대상만 문서 | +| 한 번용 `build_로직_*`(851-1 등) | 다 돈 것 → 걸음 0 보관 갈래 | 앞으로 기초 고침 = 문서 고침 스크립트 | +| `_갱신절차.md` 로직 절 · 수식 문서 절 | L3 | 수식 문서 절 하나(빌더 없음 · 고치는 길 = 화면 · 문서 스크립트) — 갱신절차 고침은 이 일감 범위 밖 · 그때 같이 | + +### 2-5 수식 문서 파일 나눔 + +지금 = 옛 로직 파일마다 한 벌(59 파일 · 원문 · 장 단위 · 파일 머리 `로직파일`). **그대로 둠(권함)** — 분류 화면(원문 · 장 차례)과 파일이 1:1 · 저장 한 번에 작은 파일 하나만 씀 · git 다름이 장 단위로 읽힘. 바꾸는 것 = 파일 머리 `로직파일` → `원문 · 부문 · 차례`(L1) · 파일 이름은 그대로(`수식_<원문>_장_….json`). + +--- + +## 3. ㉰ 호환을 안 만드는 쪽으로 줄이기 + +### 3-1 빼거나 줄이는 걸음(저장본을 비우는 전제) + +| 본 설계 자리 | 원래 할 일 | 비우면 | 어림 줄 | 차례 | +| --- | --- | --- | --- | --- | +| 2-C1 「사본 없는 SK 는 옛 `run_line`」 | 옛 길을 남겨 둠 | **뺌** — SK 는 늘 `수식` 사본으로 만들어짐 · 없는 SK = 「못 셈 · 까닭」 | −150(2-C1 안 옛 갈래 · 2-E2 가 나중에 지울 몫이 미리 없음) | 2-C1 과 2-E2 일부가 한 걸음 | +| 2-C1 「옛 칸 값 있는 SK 는 옛 길 그대로(2-D 에서 올림)」 | 옛 7 칸 셈 유지 | **뺌** | −100 | 같음 | +| 2-D 「읽을 때 올림」(옛 7 칸 → `따로` 굳힘 · `사본` → `수식` · `바탕판` 버림) | 올림 규칙 새로 + 시험 | **뺌** — 칸만 걷고 읽지 않음 | −250(+ 시험 −150) | 2-D 가 2-C1 바로 뒤에 붙음 · 옛 엔진 살아 있을 때 할 일 없음 | +| 5-1 SC 「옛 로직 줄 → SK 참조」(`Labor_SkRow.migrate` 꼴) | 규칙 유지 | **뺌**(이미 걷음 · 자료 0) | 0 | — | +| SK `사본` 칸(= `수식` 여섯 칸) · `수식.로직`(로직 줄 값 사본) | 2-D 에서 이행 | 그냥 안 씀 · 안 읽음 · `Copy_Slim` · `Doc_Gap` 의 `사본` 갈래 걷음 | −120 | 2-D | +| 옛 SK 상세 길 시험 8 군(`715_*` 4 · `717_4` · `725_1` · `742_1` · `744_1` · `806_1`) | 견본을 문서 꼴로 고쳐 씀 | **지움**(옛 칸 견본만 붙듦) · 살아 있는 결과는 `test_855_sk_layers` 가 봄 | −(시험) | 2-C1 과 같은 커밋 묶음 | +| 옛 식 문법 도구 — SK 옛 식 덮개(`Sangeun_Formula` `변수줄 · 식덮개 · 더한줄 수량식`) | 옛 칸 있는 동안 유지 | 저장본에 이 칸 값 0 → **2-C1 과 같이 걷음**(2-E2 몫이 앞당겨짐) | −530 | 2-C1 뒤 | +| 프로젝트 옛 사본 꼴 — `Item_Snapshot.migrate_items:198`(25-2b `items/`) · `complete_old:384` · `Item_Copy._migrated:71` | 남김 | 프로젝트 사본 0 · `items/` 0 → **뺌**(판단 거리 3 — 프로젝트는 사용자 확정 범위 밖) | −120 | B9-5 | +| `M02_Sk_AutoRenew` 의 옛 사본 갈래 · `MasterTemplete_Tree.old_fields:58` · `MyMachine._old:467` | 남김 | 각 갈래가 옛 저장 꼴을 읽는지 그 걸음에서 확인 뒤 뺌(지금 확인 안 함) | −(미확인) | 2-D · 858 | +| B09 사본 안 굳힌 로직(`로직_단가산출.json` · `굳힌줄` · `GX9`) | 판단 5 · B09 와 같이 꼴 바꿈 | 사본 0 → 이행 없이 새 꼴(B9-5) | 0(이행) | B9-5 | + +합 어림 = 코드 **−1,200 줄 안팎** + 이행 시험 0 · 2-D 크기 절반 · 2-E2 일부가 2-C1 로 당겨짐. + +### 3-2 저장본을 비울 때 · 범위(비우는 일은 하지 않음 · 브레인이 사용자 확인 뒤) + +**때 = 2-C1 바로 앞**(855-B 끝 · 855-C 첫 걸음 전). 까닭: 2-C1 이 옛 칸 · 사본 없는 SK 를 보지 않으려면 그때 자료가 새 꼴뿐이어야 함 · 2-A 골든은 저장본이 아니라 임시 storage 견본이라 영향 없음 · 비운 뒤 사용자가 새로 만든 SK 는 이미 새 꼴(`수식` 있음). + +| 후보 | 자리 | 지금 수(`census_storage` · `census_copy_fields`) | 권함 | +| --- | --- | --- | --- | +| 단가산출 SK | 개인 `templates/sangeun/SK-*.json` · `sangeun_폴더.json` | 14 ~ 15(세는 동안 늘어남 = 사용자가 지금 만드는 중) · 가져온 식 12 ~ 13 | 비움 — 단 **사용자가 지금 개인 층에서 단가산출을 만들어 쓰는 중**(공통 지시) → 판단 거리 4 | +| 일위대가 SC | 개인 `precombo/SC-*.json` · `precombo_폴더.json` | 6 | 비움(같은 판단) | +| 지운 문서 보관 | 개인 `_합친것/` | SK 12 · SC 3 | 비움 | +| 구조물 조합 | 회사 · 개인 `구조물집계표조합.json` · `table/구조물집계표.json` | 줄 0(파일 6 · 표 6) | 그대로(빈 틀 · 새 꼴 상관없음) | +| 불러온 자료 | 개인 `실무자료/`(불러옴 4 · HP 3) | 7 | 비움 — 다시 불러오면 새로 생김 | +| 내 기계 · 내 재료 | 개인 `내기계/_다음.json` · `개인자재.json` | 1 · 1 | 858(서고 한 벌) 앞에 같이 · 855 엔 상관없음 | +| 번호 · 겉 | `_번호.json` · `manifest.json` | 1 · 1 | 비우면 번호도 처음부터(번호 겹침 위험 없음 — 문서 0) | +| **따로 둠** | 마스터 층 `resources/master_template/`(구조물 표 · 도면 틀 · 구조물정의) · 회사 `drawing/` · 프로젝트 `_initial/` · `drawing/` · `table/`(14 프로젝트) | — | 비우지 않음 — 다른 페이지(B05 · B08 · 도면)가 씀 | +| **따로 둠** | B09 견적 저장 `B09_Estimation/v1/`(1 프로젝트 · 손 줄 로직 6) | — | 프로젝트 자료 — 확정 범위 밖 · 키가 같아 새 계산기로 그대로 셈 | + +### 3-3 가져온 식(`가져온.로직` = 옛 로직 줄 꼴)은 따로 + +- 지금 SK 12 의 `가져온.로직` 칸 = `호표 · 중간 · 덧줄 · 단계 · 끝전 · 이름 · 결과단위`(옛 로직 줄 꼴) — 불러오기 읽기기(`Hopyo_*` · `San_*`)가 **불러올 때마다 이 꼴을 새로 냄** → 저장본을 비워도 다시 생김. +- 이것을 문서로 바꾸는 `Doc_Import`(`mf.parse` · `_OPS` · `_plain`) · 가져온 식 기호 `San_Basis_Index` · `Sangeun_QtyLinks` 는 **옛 식 파서**만 씀(엔진 셈 · 글 · 끝수는 안 씀 · 2-C2 · 2-C3 뒤). +- 가름: 2-E4 때 파서(`parse` · 연산 표)는 「바탕 기반」 새 모듈(`mf.Master` · `FormulaError` · `COST_ITEMS` 등과 같이)로 떼어 남김 → 857(불러오기 한 번 읽기)이 읽기기에서 문서를 바로 내면 그때 파서도 걷음. +- 저장본 비우기와 무관 · 호환 아님(살아 있는 입력 꼴). + +--- + +## 4. ㉱ 바뀐 전체 걸음 표 · 병행 묶음 + +### 4-1 걸음 표(본 설계 4-1 을 고친 것 · ★ = 새 · ✂ = 줄임) + +| 걸음 | 무엇 | 바뀐 점 | +| --- | --- | --- | +| 2-A 지킴 올림 | 855 시험 넷 · 골든 | 끝(855-A) | +| ★ B9-0 B09 견본 · 골든 | 1-4 | 새 | +| 2-B1 | 854-2 확인만 | 그대로 | +| 2-B2 · 2-B3 · 2-B4 | 기계 폴백 · 문서 막힘(기준 지금 그대로 · 확정 3) · M01 시험 계산 | 그대로 | +| ★ B9-1 셈 기록 | 1-4 | 새 · 2-B 와 병행 | +| ★ 저장본 비움(사용자 확인 · 브레인) | 3-2 | 새 · 2-C1 바로 앞 | +| 2-C1 ✂ SK 셈 한 길 | 수식 사본 셈만 · 옛 길 갈래 없음 · `Sangeun_Formula` 옛 식 칸 · 옛 상세 시험 8 군 같이 걷음 | 옛 칸 · 사본 없는 SK 갈래 뺌 | +| 2-C2 · 2-C3 | 가져온 식 열기 · 검산 | 그대로 | +| 2-C4 | 기준 목록 · 서버 풀이 글 ② | 그대로 · B9-4 의 앞 조건 | +| 2-C5 | 나머지 셈 자리 | 그대로 | +| ★ B9-2 · B9-3 | 사본 셈 · B08 / B09 산근 · 대가 | 2-C1 뒤 | +| ★ B9-4 · B9-5 | 산출근거 글 · 사본 꼴 | 2-C4 · B9-3 뒤 | +| 2-D ✂ 파일 칸 정리 | 칸 걷음만(올림 규칙 · 이행 없음) · `사본` · `수식.로직` 안 씀 | 크기 절반 | +| ★ L1 이름표 싣기 | 2-3 | 새 · 2-D 와 병행 가능(파일 다름) | +| 2-E1 · 2-E2 | M01 · M02 옛 길 지움 | 2-E2 일부(옛 식 칸)는 2-C1 로 당겨짐 | +| ★ B9-6 B08 · B09 옛 길 지움 | 1-4 | 새 | +| ★ L2 읽는 쪽 바꿈 ⓐ ⓑ ⓒ | 2-3 | 새(본 설계 2-E3 의 앞 절반) | +| 2-E3 → L3 · L4 | 로직 JSON 뺌 · 빌더 은퇴 | 「이름표만 남김」 → 「없앰」 | +| 2-E4 엔진 모듈 지움 | 1-5 차례 · 파서는 바탕 기반으로 | 보류 풂 | + +### 4-2 병행 묶음(창 여덟까지 · 파일 안 겹침) + +| 묶음 | 같이 도는 걸음(창) | 겹침 확인 | 앞 조건 | +| --- | --- | --- | --- | +| ① | 2-B2 · 2-B3 · 2-B4 · 2-C2 · 2-C4 · **B9-0** · **B9-1**(일곱) | 본 설계 ② + 새 시험 파일 · 새 `master_doc_trace.py` — 서로 다름 | 2-A · 2-B2 는 854-1 뒤 | +| ② | 저장본 비움(브레인 · 사용자 확인) | — | ① 의 2-B3 | +| ③ | 2-C1(중심) · 2-C3 · **B9-2**(B08 · `Item_Prices` · `Item_Copy`)(셋) | Sangeun_Calc · Doc_Sk ↔ Sangeun_Imported ↔ Item_* · B08 — 다름 | ② · 2-C2 · B9-1 | +| ④ | 2-C5 · **B9-3**(B09 Sangeun · Labor_Source · Linked · Supply · Sum · Rule) · 856 화면 하나 · **L1**(빌더 · M01 저장 두 곳)(넷) | Labor_Expand · Hopyo_Build ↔ B09 5 파일 ↔ 화면 TS ↔ 빌더 · M01 Store_Save — 다름 | 2-C1 · B9-2 | +| ⑤ | 2-D · **B9-4** · **B9-5** · **L2 ⓐ**(M01 쪽)(넷) | Sangeun_Doc · Copy_Slim 무리 ↔ B09 Sangeun_Text ↔ Item_Source · Item_Sangeun · Bill_Library ↔ M01 Store 무리 — 다름(B9-4 · B9-5 는 B09 안 파일이 다름) | ④ · 2-C4 | +| ⑥ | 2-E1 · 2-E2 · **B9-6** · **L2 ⓑ**(M02 이름 읽기 · SK 값 사본)(넷) | M01 ↔ M02 Sangeun 무리 ↔ B08 · B09 ↔ M02 Labor_Inputs · Layer_Index 무리 — 2-E2 와 L2 ⓑ 가 `Sangeun_Copy` 를 같이 만질 수 있음 → 그 파일은 2-E2 한 창 몫 | ⑤ · 856 | +| ⑦ | **L2 ⓒ**(불러오기 이음 — 857 과 합침 권함) | Hopyo · San | ⑥ · 857 | +| ⑧ | L3 → L4 → 2-E4(차례 · 한 창) | scripts · 자료 | ⑥ · ⑦ | + +꼭 차례인 까닭(본 설계에 더함): +- 저장본 비움은 2-C1 앞 — 2-C1 이 옛 꼴 갈래를 안 가지려면. +- B9-2 · B9-3 은 2-C1 뒤 — 사본 안 SK 셈이 문서 한 길이어야 B09 가 같은 답을 받음. +- B9-4 는 2-C4 뒤 — 서버 풀이 글이 먼저 있어야 함. +- L1 은 로직 JSON 을 고치는 일감이 0 일 때 — 빌더 기준이 두 번 바뀌지 않게. +- L3 은 B9-6 · 2-E1 · 2-E2 · L2 뒤 — 로직 줄을 읽는 곳 0. +- 2-E4 는 L3 뒤 — `mf.Master` 의 로직 그룹이 빠져야 엔진 몸이 지울 수 있는 꼴. + +### 4-3 세기 결과 파일(`tmp/s894/m855b/`) + +| 도구 | 결과 | 핵심 수 | +| --- | --- | --- | +| `census_calls.py`(sub6 · 내 폴더에서 다시) | `out_calls.tsv` | 185 자리 · 39 파일 · B08 1 · B09 5 파일 51 자리 | +| `census_copies.py` · `census_storage.py`(sub6) | `out_copies.json` · `out_storage.json` | 프로젝트 사본 0 · SK 15 · SC 6 · `_합친것` 15 | +| `census_logic_fields.py`(새) | `out_logic_fields.json` | 로직 칸 19 · 문서와 같은 값 4 · 문서 없는 이름표 6 + 별칭 + 파일 머리 3 | +| `census_logic_readers.py`(새) | `out_logic_readers.tsv` | 파일 · 갈래(관문 · 파일 이름 · 셈 칸 · 이름표 칸)별 자리 | +| `census_copy_fields.py`(새) | `out_copy_fields.json` | SK `수식.로직` 16 줄 · `사본.로직` 12 줄 · `가져온.로직` 12 · B09 손 줄 `ref.tab = logic` 6 | + +--- + +## 5. 사용자 판단 거리 + +1. **B09 손 줄이 M01 기초를 바로 고르는 기능** — B09 설계내역서 [단가 연결] · 운반 단가 모달에서 M01 단가산출 기초를 직접 골라 셈(지금 프로젝트 1 곳에 6 줄). 확정 1(「M02 것을 복사해 가져감」)과 어긋남. ㉠ 그대로 둠 — 같은 새 계산기로 셈 · 지금 6 줄 그대로 이어짐(권함) ㉡ M02 단가산출만 고르게 바꿈 — 6 줄을 다시 이어야 함. +2. **「계산을 직접 할 일 없음」 의 뜻** — 프로젝트에서 구조물 입력값 · 운반 거리를 바꾸거나 [단가 갱신] 을 누르면 금액이 다시 나와야 함. 이때 M02 와 **같은 계산기 한 벌**을 불러 다시 셈(B09 엔 식 엔진 없음 · 갈라 합산만)으로 이해(권함 · 1-3 안 B). 「복사 때 굳힌 금액만 쓰고 프로젝트에선 절대 다시 셈 안 함」 이 뜻이면 입력 바꿈 · [단가 갱신] 을 M02 [재생성]으로만 하게 바뀜. +3. **프로젝트 쪽 옛 꼴** — 확정 5 는 M02 층 자료. 프로젝트 사본은 지금 0 개라 옛 사본 꼴 읽기(25-2b `items/` 옮겨 받기 등)도 같이 걷어도 되는지(권함 = 걷음 · 지금 옮길 것 0). +4. **저장본 비우는 때** — 지금 개인 층 단가산출이 계속 늘어나는 중(세는 동안 14 → 15). 2-C1 앞에 비우면 그 사이 만든 것도 지워짐 → 비우기 전날 알림 · 남길 것만 다시 만들 길(가져온 식은 다시 불러오면 됨)을 같이 알림. + +## 6. 못 본 것 + +- 서버 · 화면을 돌리지 않음(코드 따라가기 + 자료 세기). 「살아 있음」 = 화면 TS 에서 서버 길까지 이름으로 이은 것 · 단추를 눌러 보지 않음. +- B09 프로젝트 1 곳의 손 줄 6 은 칸 이름만 셈(로직 키 · 값 안 봄). +- `M02_Sk_AutoRenew` · `MasterTemplete_Tree.old_fields` · `MyMachine._old` 가 옛 저장 꼴만 읽는지는 확인 안 함(3-1 「미확인」). +- `.logic(` 류 자리 수(102)는 글자 찾기 — `whole.logic` 처럼 이름을 바꿔 부르는 곳 · 문자열로 조립한 부름은 빠졌을 수 있음(L3 앞 전수는 다시 셈). +- 855-A 시험(sub6 커밋 327fdc5d9)은 이 폴더 받은 판에 아직 없음 — 이름만 PLAN 에서 봄. +- 줄 수 어림은 함수 크기로 짐작한 값. diff --git a/docs/raw/요구_1104/설계_855_정본하나_계산기하나.md b/docs/raw/요구_1104/설계_855_정본하나_계산기하나.md new file mode 100644 index 000000000..c3bbb62fb --- /dev/null +++ b/docs/raw/요구_1104/설계_855_정본하나_계산기하나.md @@ -0,0 +1,311 @@ +# 설계 855 — 걸음 2 「정본 하나 · 계산기 하나」 (PLAN 855-0) + +요구 894 · 896 · sub6 · 2026-11-17 · 읽기 · 측정만(코드 · 자료 · 시험 고침 0). 측정 도구 · 결과 = `tmp/s894/m855/`. + +## 0. 한눈 요약 + +- **지금 두 엔진의 금액은 같음** — 불러오기 3,241 블록 합계 다름 **0** · 로직 1,521 기본 옵션 합계 · 줄 비목 금액 다름 **0** · 옵션 표본 18,926 까지 넣으면 합계 다름 3(이미 채택된 714-3) · 줄 비목 다름 13(같은 채택 계열) · 그 밖 다름은 전부 **보이는 단가 · 풀이 값 차이(금액 같음)**. +- **수식 문서 없는 로직 0 / 1,521** · 손고침 0 · 기계덮음 0 · 옛 막힘 0. +- 저장소: 층 서고 SK 14(전부 개인 층 · 가져온 식 12 · **「따로」 1** · 옛 칸 값 0) · SC 6(옛 로직 줄 0) · **프로젝트 사본 0**(구조물 사본 · B09 서고 사본 · 굳힌 로직 파일 모두 0). → 옮길 자료가 거의 없음. +- 옛 엔진을 부르는 자리 = 서버 **39 파일 185 곳**(M01 7 · M02 26 · **B08 1 · B09 5**). 화면 TS 쪽 옛 길 = 6 갈래. +- **새로 만들어야 하는 것 넷**: ① 문서 막힘 검사 한 함수 ② 서버 풀이 글(문서 셈 답 → 산출근거 글) ③ 문서 기본값 읽기(옛 `master_auto` 대신) ④ 가져온 식 검산(문서 줄 ↔ 엑셀 글줄 맞댐). +- **막는 것 하나**: B08 · B09 가 옛 엔진(`run_line` · `mf.evaluate` · `master_text`)을 직접 부름 → 옛 엔진 **모듈 지움**은 그 페이지가 옮긴 뒤. 855 범위 = M01 · M02 가 옛 엔진을 안 부르게 하는 데까지(7 절 판단 1). + +--- + +## 1. 옛 엔진을 부르는 자리 전수 + +전수 표 = `m855/out_calls.tsv`(파일 · 줄 · 감싼 함수 · 부름 — 185 줄). 아래는 목적별로 묶은 것. + +### 1-1 서버 — 금액 셈(엔진 몸 직접) + +| 자리 | 무엇을 얻나 | 새 계산기로 바꿀 것 | 새로 만들 것 | +| --- | --- | --- | --- | +| `M02_Labor_Doc.py:541 run_line` — **옛 엔진 관문**(`mf.run` + `mcut.engine` + `mau.values`) | 로직 줄 금액 · 줄 · 중간 · 재료 | 문서 셈 `master_doc_calc.calc`(문서 = 로직 키의 수식 문서 + 입력값 · 고름) | 「로직 줄 → 문서 입력」 맞춤(입력값 이름 = 변수 열쇠 · 고름 = 재료 연결) | +| `M02_Sangeun_Calc.py:383 · 387 run` · `:268 sub_run` | SK 줄 금액 · 글 · 중간(옛) → 끝에서 `M02_Doc_Sk.py:223 on_run` 이 기준 · 1단위만 문서 값으로 덮음 | 수식 사본 셈(`Doc_Sk.run`)을 **처음부터** 씀 · 줄도 문서 답 | 셈 답 꼴 맞춤(줄 `cid` · 덮개 표지 · 빠진줄 · 정체 · 배 · 꼬리표) — 화면 · 일위대가가 먹는 칸 | +| `Sangeun_Calc.run` 을 거쳐 부르는 곳: `M02_Doc_Sk.py:294 settle`(저장) · `M02_Doc_Sk_Path.py:76 current`(수식 읽기) · `M02_Doc_Take.py:97 _sk`(복사 펼침 배) · `M02_Labor_Patch.py:103 run`(줄 덮개) · `M02_Sangeun_Const.py:365 sheet` · `M02_Sangeun_Imported.py:349 _run`(검산) · `M02_Doc_Import.py:83 _ctx`(가져온 식 문서 짓기 전 색인) | 금액 · 색인(ctx) | 위 한 길로 따라 바뀜 · `_ctx` 는 문서 짓기에 옛 엔진 색인 대신 가져온 로직 줄을 바로 변환 | `Doc_Sk.derive`(:118)가 옛 엔진 ctx 없이 문서를 짓는 길 | +| `M02_Labor_Copy.py:141 line` | 일위대가 로직 줄 금액(옛 먼저 · 사본 있으면 기준만 문서) | 사본 있으면 문서만 | — (저장소 옛 로직 줄 0) | +| `M02_Labor_Expand.py:91 _promote` · `:121 _logic` | 옛 단가승격 · 로직 줄 펼침 | 문서 셈 | — | +| `M02_Hopyo_Build.py:333 _inside` | 호표 → SC 만들 때 안쪽 로직 금액 | 문서 셈 | — | +| `M02_Machine_Hourly.py:201 hourly`(`store.calc`) · `:270 brief` · `M02_MyMachine.py:245 hourly` | 기계 시간당 — **문서 없을 때만 폴백** | 폴백 걷음(문서 없는 로직 0 · 복사/생성이 문서를 만들면 영영 0) | 「문서 없음」 까닭 글 하나 | +| `M02_Sangeun_Imported.py:419 _inner` | 가져온 식 안쪽 산근 금액 | 형제 SK 문서 셈(`dim.run`) | — | +| `M02_Logic_Standard.py:336 sheet` · `:133 axes` | M02 [로직 더하기] · 찾아 넣기 **기준 목록 · 계산서 보기**(살아 있는 화면) | 문서 셈 + 옵션 축 = 문서 변수 `선택 목록` | 서버 풀이 글(1-2) | +| `M02_Logic_Settle.py:41 settle` | 기준 목록 금액 · B09 산근 끝수 규칙 짝(`test_704_settle`) | 문서 끝수 기본(줄 버림 1 · 비목 버림 0)과 같은 규칙 → 문서 셈 | — · B09 짝이 남는 동안 이 파일은 B09 몫으로 둠 | +| `M02_Sangeun_Const.py:335 _mids` · `M02_Sangeun_Views.py:29 text_of` | 옛 「상세 몸」 시트 답 · 풀이 글(`detail=True` 화면 셈 길만) | 856(화면 하나)에서 상세 몸과 같이 걷음 | — | +| M01 `M01_MasterData_Store.py:553 calc` · `:582 text`(`/m01/calc` `:259` · `/text` `:281` · M02 감쌈 `M02_Logic_Lib_Read.py:61 · 67`) | M01 [로직 복사/생성] 시험 계산 · 상세 몸 풀이 글 | 시험 계산 = `/logic/doc/preview`(`Router.py:329` · 이미 있음) | — | + +### 1-2 서버 — 풀이 글 · 기본값 · 끝수 · 검사 · 식 도구 + +| 갈래 | 자리 | 새 쪽 | 새로 만들 것 | +| --- | --- | --- | --- | +| **풀이 글** `master_text` | `Store.text`(:589) · `Sangeun_Views.text_of` · `Logic_Standard.sheet`(`mtx.lines`) · `_range_label` · `_table_reps` · B09 `Sangeun_Text`(31 곳) | 서버 글 **없음** — 화면 줄 쌓기 오른쪽(`line_stack_out.ts`)이 브라우저 계산기 답으로 그림 | **② 서버 풀이 글**(문서 셈 답 → 줄 글 · 조각) — 기준 목록 · 계산서 · (뒤에) B09 산출근거가 씀. 파이썬 ↔ TS 짝으로 `line_stack_out` 의 글 규칙을 옮김 | +| **입력 기본값** `master_auto.values` | `Store.auto`(:577 · `/logic/auto` `:188`) · `M02_Doc_Copy.py:270 given_of` · `M02_Labor_Inputs.py:94` · `Sangeun_Calc.py:206 _defaults` · `run_line` · `Logic_Standard.axes` · B09 `Sangeun._env` | 문서 변수 `연결.값`(빌더가 `master_equation.given_of` 로 채워 둠) | **③ 문서 기본값 읽기** 한 함수(변수 열쇠 → 값) | +| **끝수** `master_cut` | `Labor_Doc.settle`(:450) · `reflect`(:403) · `drop_apart`(:270) · `Labor_Expand._combo`(:173) · `Labor_Fixed.ratio_row`(:202) · B09 `Sangeun_Sum` | 일위대가 합산(③ 갈래 · TS 짝 `Labor_Calc.ts`)이 쓰는 줄 · 합 끝수 — **옛 엔진과 따로 살아 있는 규칙** | 없음 — `row` `sums` `down` `plain` `kept` 는 남겨 「일위대가 끝수」 로 옮김 · `engine` `_sub` 만 은퇴 | +| **막힘 · 저장 검사** | `Store.logic`(:390 · `/logic` 의 `blocked` `reasons`) · `Store_Cache._check`(:99 · 목록 막힘) — `mf.check_logic` / `Store_Cache.check_saved`(:276) · `Store_Save._errors`(:74) — `mcb.check_all` / `Store_Combo` · `Combo_Store` — `mcb.check_row`(일위대가 조합 입력 이름 검사) | 문서 검사 `master_doc.check`(표지) · 계산기 표지 | **① 문서 막힘 검사** 한 함수(`check` 표지 + 부름 닫힘 · 순환) · 조합 검사는 입력 이름을 변수 열쇠로 | +| **엔진 속살(식 문법 도구)** | `Sangeun_Formula`(`_Parser` `_check_node` `walk` — SK 옛 식 덮개 칸) · `Doc_Import`(`parse` `_OPS` `_plain` — 가져온 로직 줄 → 문서) · `San_Basis_Index` · `Sangeun_QtyLinks`(`parse` `_OPS`) · `Item_Prices`(`_expand` `_HOLE` `fill` `static` `walk` — 프로젝트 사본 단가 묶음 닫힘) · `Labor_Doc.pct_extras · _pct_base · _specs` · B09 `Labor_Rule` | 문서 식 파서 `master_doc.parse` | 옛 식 문법을 읽는 곳은 「옛 꼴 자료(가져온 로직 줄 · 굳힌 로직)」 가 남는 동안 필요 — 그 자료가 문서 꼴로 바뀌면 함께 걷음 | +| **바탕 기반(남김)** | `mf.Master`(요소 · 표 색인) · `mf.FormulaError` · `find` · `master_material` · `master_pick`(`mf.mp`) · `COST_ITEMS` `BUNDLE` `GROUPS` — 새 계산기(`master_doc_link.py:120`)도 씀 · Hopyo_* · Material_Own 도 씀 | — | 은퇴 때 `master_formula` 에서 이것만 떼어 새 이름 모듈로(엔진 몸 · 파서 · 셈 · 글은 지움) | +| 옛 수식 탭 `master_equation*` | `M01_MasterData_Equation.py:51 export_row`(M02 `Sangeun_Formula` 가 부름) · 빌더 · `master_doc_convert`(기본값 `given_of` · 기호) | — | 빌더 은퇴와 함께 | + +### 1-3 B08 · B09 가 옛 엔진을 부르는 자리(이름만 · 그 페이지 코드는 범위 밖) + +| 파일 | 함수 | 부름 | +| --- | --- | --- | +| `B08_Quantity_Router_Material.py:79` | `run` | `labor.run_line` | +| `B09_Estimation_Sangeun.py` | `_solve:346` · `hand_resource_keys:622` · `_env:202` · `_line:447` · `call_of:227` · `_extras:540` · `_captured:275` | `run_line` · `mf.evaluate` `parse` `fill` `_inputs` · `mau.values` | +| `B09_Estimation_Sangeun_Text.py` | 13 함수 · 31 곳 | `mf.*` · `master_text`(산출근거 글) | +| `B09_Estimation_Labor_Source.py:140` · `B09_Estimation_Linked.py:64` | `_poomsem` · `used_keys` | `run_line` | +| `B09_Estimation_Sangeun_Sum.py:36 · 87` · `B09_Estimation_Labor_Rule.py:90 · 115` | 끝수 · 율 식 | `mcut._line` `settle` · `mf.parse` | + +→ 프로젝트 쪽은 **사본(굳힌 로직 `GX9…` · `로직_단가산출.json`)을 옛 엔진으로 셈**(`M02_Item_Sangeun.py:27`). 지금 저장소 사본은 0 이지만 길은 살아 있음. + +### 1-4 화면 TS 쪽 + +| 화면 | 부르는 길 | 지금 엔진 | 걸음 2 뒤 | +| --- | --- | --- | --- | +| M01 · M02 줄 쌓기(단가산출 · 기계 보기 · 가져온 식) | 브라우저 `common_util_formula_doc_calc.ts calcDoc`(↔ `master_doc_calc` 짝) | 새 | 그대로 | +| M02 단가산출 상세 몸 · 머리 띠(까닭 · 빠진 줄 · 짝 잃음 · M01 개정) | `M02_MasterTemplete_Sangeun_Cover.ts:25 calcSangeun` → `/layers/{층}/sangeun/calc` ← `Sangeun_Detail.ts:216-217`(두 번) · `Labor_RowSk.ts:53`(정체만) · 풀이 `logic/M02_Sangeun_Cover_Model.ts hoView` | 옛 줄 + 새 합계 | 서버 답이 새 한 길 · 답 꼴 그대로 → 화면 안 바뀜 · 856 에서 상세 몸 걷음 | +| 일위대가표 · 프로젝트 모달 카드 | `M02_MasterTemplete_Labor_Api.ts:265 calcLabor` ← `Labor_Table.ts:245` · `Labor_View.ts:132` · `ui_template_item_picker_detail.ts:206` | SK 줄 = 위 SK 셈 · 로직 줄 = 옛 | 같은 답 꼴 | +| M01 [로직 복사/생성] 시험 계산 | `M01_MasterData_UI_Logic_Drive.ts:61-62 runCalc · runText`(`/calc` `/text`) ← `Logic_Calc.ts:143` · `LogicLab_Copy.ts:275 previewLogicFormula` | 옛만 | `/logic/doc/preview` 로 | +| M02 찾아 넣기 · [로직 더하기] 기준 목록 · 계산서 | `M02_MasterTemplete_Find_Pick.ts:371`(`/logic-lib/standard`) · 계산서 `calc_sheet` | 옛 | 서버 문서 셈 + 풀이 글 ② | +| 기계 고를 때 시간당 | `Find_Pick.ts:257`(`/logic-lib/machine-hourly`) | 문서 먼저 · 폴백 옛 | 문서만 | + +--- + +## 2. 자료 실태(세기 · 칸 이름 · 개수만) + +도구 = `m855/census_storage.py` · `census_copies.py` · 결과 `out_storage.json` · `out_copies.json` · 못 연 자리 0(권한 막힘 없음). + +### 2-1 M01 기초 + +| 항목 | 수 | +| --- | --- | +| 로직 줄(GC 1,191 · GF 329 · GX 1) | 1,521 | +| 수식 문서 · 로직 없는 문서 · **문서 없는 로직** | 1,521 · 0 · **0** | +| 부품 문서 · 돈 아닌 문서(결과) | 81 · 65 | +| 손고침 · 기계덮음 | 0 · 0 | + +### 2-2 층 서고 저장본 + +| 층 | SK | SC | 칸 · 판정 | +| --- | --- | --- | --- | +| 마스터(`resources/master_template`) | 0 | 0 | 단가산출 · 일위대가 폴더 없음 | +| 회사 | 0 | 0 | `table` · `drawing` · 조합만 | +| 개인 | **14** | 6 | SK 칸 = 옛 칸 열넷(전부 있음) + `바탕판 M01판 수식`(14) · `사본`(13) · `가져온`(12) | +| 개인 `_합친것` | 11(지움 꼴 `{키 종류 지움 고친곳 때 누가}`) | 3 | 지운 문서 보관 | + +SK 14 판정: 옛 7 칸 값 든 것 **0** · 옛 0/5 칸 6 **0** · `사본` 없음 1 · `사본 ≡ 수식`(여섯 칸) 13 / 13 · **「따로」 1**(분석 때 0 → 그 뒤 생김) · 바탕 = 로직 1 · 없음 13 · 가져온 식 12 · 굳힌줄 0. +SC 6 의 줄 28 = 참조 13 · 고정 15 · **옛 로직 줄 0**. + +### 2-3 프로젝트 폴더 안 사본 + +| 항목 | 수 | +| --- | --- | +| 프로젝트 폴더 | 14 | +| 구조물 사본 `templates/structures/{id}/`(`단가.json` · `일위대가.json` · `로직_단가산출.json` · `수식.json`) | **0** | +| B09 서고 사본(`library/`) | **0** | +| 프로젝트 층 `templates/sangeun` · `precombo` | 0 | +| B09 견적 저장 | 1 프로젝트(`B09_Estimation/v1/price_book.json` · `user_values.json`) | +| 프로젝트 층 저장 꼴 | `_initial/` + 작업본(`drawing` 4 · `table/구조물집계표` · `구조물집계표조합` · `manifest`) — 14 / 14 같은 꼴 | + +→ **옮길 프로젝트 사본 0**(이 저장소 기준 · 데스크탑 임시 배포 storage 는 Synology 동기화로 같은 것으로 봄 · 7 절). + +### 2-4 B08 · B09 가 읽는 단가산출 · 일위대가 칸(이름만) + +| 칸 | 읽는 파일 | +| --- | --- | +| `사본` | B09 `Past` · `Refresh` · `Router_Import` | +| `바탕` | B09 `Daega_Personal` · `Labor_Source` · `Linked` · `Sangeun` · `Supply` | +| `덮개` · `더한줄` · `뺀줄` · `열린입력` · `자재표시` | B09 `Daega_Personal` · `Labor_Source`(+ `Past` · `Router` 덮개) | +| `입력값` · `고름` · `켜쌓기율` · `담은로직` | B08 `Router_Material` · B09 `Daega_Personal` · `Linked` · `Labor_Source` · `Sangeun` · `Bill_Library` · `Bill_Hopyo` | +| `굳힌줄` | B09 `Linked` · `Sangeun` | +| `수식` · `가져온` · `바탕판` · `M01판` | 없음 | + +→ 걸음 2-D 에서 SK 옛 칸을 걷어도 B09 는 **사본 쪽 옛 칸**(굳힌 SK)을 읽음 — 프로젝트 사본 꼴은 B09 와 같이 바꿔야 함(7 절 판단 1 · 5). + +--- + +## 3. 두 엔진의 지금 차이 — 전수 측정(지킴 수치) + +### 3-1 도구 + +| 도구 | 무엇 | 시간 | 결과 | +| --- | --- | --- | --- | +| `m855_logic.py --no-options` | 로직 1,521 × 기본 입력 · 옛(`mf.run`+`mcut.engine`) 대 새(저장된 수식 문서 · `mc.calc`) · 층 L0 ~ L4 | **16 초** | `out_logic.json` | +| `m855_logic.py` | + 옵션 표본 18,926(고르기 입력 갈래마다 하나 · 빌더 대조와 같은 표본) = 20,447 셈 | 196 초 | 〃 | +| `m855_sk.py` | 층 서고 SK 전부(임시 복사본 위) · `Sangeun_Calc.run` 옛 답(문서 덮음 끔) 대 새 답 · 옛 줄 비목 합 = 새 기준 | 6 초 | `out_sk.json` | +| `m855_block.py` | 막힘 판정 옛 `check_logic` 대 새(문서 표지 · 기본 셈 셈됨) | 22 초 | `out_block.json` | +| `m855_import.py [--quick]` | 불러오기 블록 전수(원파일 EST 6 · STC 7 · 실무 엑셀 11) · 가져온 식 SK 옛 엔진 셈 대 문서 계산기 셈 | 빠른 표본 3 파일 221 블록 128 초 · 전수 3,241 블록 **26 분**(관문 아님 · 전수는 손으로) | `out_import.json` | +| `census_calls.py` · `census_storage.py` · `census_copies.py` | 1 · 2 절 세기 | 수 초 | `out_calls.tsv` · `out_storage.json` · `out_copies.json` | + +층(앞 층이 다르면 뒤 층은 안 봄): **L0 합계**(노 · 재 · 경 · 계 · 돈 아닌 = 결과) · **L1 줄 비목**(줄 이름마다 비목 금액 합 · 기계 한 대 = 줄 나눔 묶음) · **L2 줄 꼴**(차례 · 이름 · 금액 · 비목) · **L3 수량 · 단가** · **L4 풀이 값**(옛 `중간` 수가 새 기호 값 · 줄 값에 있는가). + +### 3-2 결과 — 로직 1,521 + +| 층 | 기본 1,521 | + 옵션(20,447) | 까닭 | 판정 | +| --- | --- | --- | --- | --- | +| L0 합계 | **0** | 3 | GC000091 지역=울산 · GC000093 지역=경북 · GC000100 지역=전북 — 식 속 단가산출 부름 = 끝수 뒤 값(새) · 끝수 전(옛) | **채택(요구 714-3)** · 빌더 `ADOPTED` 와 같음 | +| L1 줄 비목 | **0** | 13 | GC000091 · 092 · 093 · 094 · 100 의 지역 옵션 — 같은 까닭이 줄 하나(소모자재 0.1 원)에만 닿고 합계 원 단위는 같음 | 채택 계열 | +| L2 줄 꼴 | 0 | 0 | — | 같음 | +| L3 수량 | 0 | 0 | — | 같음 | +| L3 단가 표시 | 499 | 7,531 | 옛 = 줄 끝수 자리로 자른 단가(284.4) · 새 = 날 값(284.42142…) · 금액 같음 | 보임만 | +| L3 묶음 단가 | (위에 포함) | | 기계 줄 단가 = 옛 수(계) · 새 묶음 `{노 재 경 계}` — 계로 맞대 같음 | 꼴만 | +| L3 수량 0 줄 | 17 | 177 | 옛 단가 0 · 새 단가 빈 값(수량 0 = 금액 0 규칙) | 보임만 | +| L3 값 없음 줄 | 0 | 303 | 수량이 빈 값인 줄 — 옛 단가 빈 값 · 새 단가 채움(금액 둘 다 빈 값) | 보임만 | +| L4 풀이 값 | 10 | 198 | GC000087 · 090 ~ 096 · 098 · 100 — 옛 중간 「드릴경비 · 브레이커경비」 단계 값이 새 문서엔 기호로 없음(기계 한 대 = 줄 나눔으로 사라진 옛 중간) | 금액 같음 · 풀이 글 차이 | +| 둘 다 못 셈 | 3 | 175 | 기본 옵션으로 셈이 안 되는 로직 3 + 옵션 갈래 | 같음 | + +막힘(`m855_block`): 옛 막힘 **0** · 새 표지 **0** · 새 기본 셈 못 함 3(= 둘 다 못 셈 3). + +### 3-3 결과 — 층 서고 SK 14 + +| 항목 | 수 | +| --- | --- | +| 새 답 = 문서 계산기(수식 사본 있음) | 14 / 14 | +| 옛 기준 = 새 기준 | 13 / 14 | +| 다름 1 | **「따로」 SK** — 문서가 정본인데 옛 엔진은 빈 옛 칸 · 바탕으로 셈 → 옛 답 줄 0 · 기준 다름. 화면 머리 띠 · 상세 몸 · 일위대가 줄 금액이 이 옛 답을 먹음 = **「줄 금액 = 옛 · 합계 = 새」 가 실제로 갈린 첫 사례** | +| 옛 줄 비목 합(원 버림) ≠ 새 기준 | 3(따로 1 + 가져온 식 2 — 기준은 같음 · 줄 합과 합계 끝수 차이 유력: 가져온 식 끝수 규칙(끝전 · 조정) · 미확인) | + +### 3-4 결과 — 불러오기 블록 + +| 원천 | 블록 | 옛 합계 = 새 합계 | 한쪽만 못 셈 | +| --- | --- | --- | --- | +| 원파일 EST 6 | 1,849 | 1,849 | 0 | +| 원파일 STC 7 | 371 | 371 | 0 | +| 실무 엑셀 11 | 1,021 | 1,021 | 0 | +| **합** | **3,241** | **3,241(다름 0)** | 0 | + +- 옛 = 가져온 식 검산 길(`Sangeun_Imported._run` · 옛 엔진) · 새 = `Doc_Import.derive` + 문서 계산기(지금 화면 · 저장 길). +- 「옛 줄 비목 합 = 옛 합계」 판정(1,499 같음 · 1,742 다름)은 **도구 한계로 판정에 안 씀** — 가져온 식 줄에는 소계 · 단계 · 합밖 · 형제 산근 줄이 섞여 단순 합이 합계가 아님. 줄 단위 대조는 2-C3(검산 새로) 때 줄 맞댐 열쇠를 정한 뒤 다시 잼. + +### 3-5 일위대가 줄 + +- 저장소 SC 줄 28 = 참조 13(SK 셈 = 3-3 과 같은 길) · 고정 15(엑셀 숫자 · 셈 아님) · 옛 로직 줄 0 → **`Labor_Copy.line` 의 옛 길을 실제 자료로 잴 수 없음**. 시험 견본(`715` 군 · `742_1` 등)만 그 길을 탐. + +### 3-6 `resources/tester` 지킴 시험으로 올릴 꼴(제안) + +| 시험 | 내용 | 시간 | 관문 | +| --- | --- | --- | --- | +| `test_855_engine_parity.py` | 기본 1,521 L0 ~ L3(단가 표시 갈래는 허용 갈래로 셈) 다름 = 채택 목록과 같음 · 옵션 전수는 환경 `S855_ALL=1` | 16 초(전수 3.3 분) | 걸음 2 동안 싱크 관문에 더함 | +| `test_855_golden.py` | 새 계산기 답 지문 — 로직마다 (기본 + 옵션 표본) 답(노 재 경 계 · 줄 금액 · 비목)을 한 해시로 · `resources/tester/data/855_golden.json`(약 1,521 줄 · 수십 KB) | 16 초 ~ | **옛 엔진을 지운 뒤** 옛 → 새 대조를 이것이 대신 | +| `test_855_sk_layers.py` | 임시 storage 견본 SK(옛 칸 · 따로 · 가져온 식 · 율 더한줄 · 형제 SK) 셈 답 줄 합 = 합계 · 옛 대 새 같음 | 수 초 | 걸음 2-C 동안 | +| `test_855_block.py` | 막힘 판정 옛 = 새(2-B3 뒤에는 새만 · 표지 0 지킴) | 22 초 | — | +| 불러오기 | 기존 `test_812_1_xlsx_golden`(문서 계산기 = 엑셀 100 %)에 「옛 검산 = 새 검산」 한 단언 더함 · 전수는 `S8121_ALL=1` | 표본 2 분 | 지금 관문 | + +결과 판정은 금액 · 동작만(소스 글자 안 봄). 측정 도구 원본은 `tmp/s894/m855/` — 올릴 때 시험 꼴로 다시 씀. + +--- + +## 4. 차례 설계 + +원칙: 한 걸음 = 한 길만 · **두 박자**(새 길로 바꿈 → 전수 다름 0 → 다음 묶음에서 옛 길 지움) · 걸음마다 한 커밋 묶음(되돌리기 = 그 커밋만) · 화면은 걸음마다 그대로 돎(서버 답 꼴 유지). + +### 4-1 걸음 표 + +| 걸음 | 무엇을 바꾸나 | 고칠 파일(어림 줄) | 지킴 | 위험 · 막는 법 | 화면 확인 | +| --- | --- | --- | --- | --- | --- | +| **2-A 지킴 올림** | 3-6 시험 넷 · 골든 지문 · 관문 목록 | `resources/tester/test_855_*` 넷(+ 300) · `tools/sync_core_tests.txt`(1) | 지금 수치 그대로 통과 | 시험 시간 — 기본만 관문 · 전수는 환경 변수 | — | +| 2-B1 [로직 복사/생성] 수식 문서 같이 만듦 | **854-2 가 하는 중** → 855 에서 빼고 확인만 | — | `m855_block` · 문서 없는 로직 0 | — | 복사/생성 → 수식 탭이 채워짐 | +| 2-B2 기계 시간당 폴백 걷음 | 「문서 없음 = 못 셈 · 까닭」 | `M02_Machine_Hourly.py`(− 60) · `M02_MyMachine.py`(− 35) | `test_842_3`(655 대) · `test_822_2` | 854-1 이 `M02_MyMachine.py` 를 고치는 중 → **854-1 뒤** | 기계 고르기 시간당 · 내 기계 보기 | +| 2-B3 막힘 · 저장 검사를 문서 기준으로 | ① 문서 막힘 검사 새 함수 → `/logic` `blocked` · 목록 막힘 · 일위대가 조합 검사(입력 이름 → 변수 열쇠) | 새 `scripts/master_doc_block.py`(+ 120) · `M01_MasterData_Store.py`(± 10) · `_Store_Cache.py`(± 15) · `_Store_Save.py` · `_Store_Combo.py` · `M02_MasterTemplete_Combo_Store.py`(± 20) | `test_855_block`(옛 = 새 · 막힘 0) · `test_masterdata_check` | 막힘 기준 갈림(기본 셈 못 함 3) — 표지만 막힘으로(7 절 판단 3) | M01 로직 목록 막힘 표시 · 조합 알약 | +| 2-B4 M01 시험 계산을 문서 셈으로 | 복사/생성 [시험 계산] = `/logic/doc/preview` | `M01_MasterData_UI_LogicLab_Copy.ts` · `_Logic_Calc.ts` · `_Logic_Drive.ts`(± 60) | `npm run typecheck` · 시험 계산 금액 = 수식 탭 금액 | 상세 몸 `/text` 조각은 856 까지 남음 | M01 복사/생성 시험 계산 | +| 2-C1 **SK 셈 한 길**(줄 금액까지) | `Sangeun_Calc.run` = 수식 사본 셈 먼저 · 옛 `run_line` 은 사본 없는 SK(지금 0)만 · 답 꼴 맞춤 · `derive` 가 옛 ctx 없이 지음 | `M02_Sangeun_Calc.py`(± 120) · `M02_Doc_Sk.py`(± 80) · `M02_Doc_Sk_Path.py`(± 20) · `M02_Labor_Copy.py`(± 20) | `test_855_sk_layers` · `m855_sk`(14 / 14 · 줄 합 = 기준 · 「따로」 줄 수 > 0) · `test_802_4a` · `836_2` · `848_*` · 거울 `802_1` | 옛 SK 상세 길 시험 8 군(옛 칸 값 견본) — 옛 칸 값 있는 SK 는 이 걸음에선 옛 길 그대로(2-D 에서 올림) | 단가산출 머리 띠 · 일위대가 줄 금액 · 「따로」 SK 줄 | +| 2-C2 불러온 식 열기 | `Doc_Import._ctx` 옛 엔진 색인 → 가져온 로직 줄 직접 변환 | `M02_Doc_Import.py`(± 80) | `m855_import` 전수 · `test_812_1` · `test_810_2` · `test_802_4b1` | 가져온 값 층(`Doc_Import_Carry`)이 색인에 기댐 — 같이 확인 | 불러오기 [가져온 식으로 열기] | +| 2-C3 가져온 식 검산 | ④ 문서 줄 ↔ 엑셀 글줄 맞댐 새로 · `check` = 문서 계산기 | `M02_Sangeun_Imported.py`(± 100) | 검산 판정 옛 = 새(3,241 블록 · 줄마다) | 줄 맞댐 열쇠(정체 · 행) — 2-C2 뒤 | 불러오기 줄 칠 · 검산 표 | +| 2-C4 기준 목록 · 계산서 | 문서 셈 + ② 서버 풀이 글 | 새 `scripts/master_doc_text.py`(+ 250 · TS `line_stack_out` 글 규칙과 짝 · 거울 시험) · `M02_Logic_Standard.py`(± 80) | 기준 목록 금액 전수 = 옛(로직 × 대표 규격) · 거울 시험 | `Logic_Settle` 은 B09 짝이라 남김 | M02 찾아 넣기 · 계산서 보기 | +| 2-C5 나머지 엔진 셈 자리 | `Labor_Expand._promote · _logic` · `Hopyo_Build._inside` · `Sangeun_Imported._inner` · `Labor_Patch.run` · `Doc_Take._sk` → 문서 셈 | 5 파일(± 100) | `test_m02_labor_*` · `test_621` · 불러오기 표본 | 옛 단가승격 줄(자료 0) | 일위대가 펼침 | +| 2-D **파일 칸 정리**(855-3) | SK 저장 꼴 줄임 · 읽을 때 올림 규칙 · `_합친것` 그대로 | `M02_Sangeun_Doc.py` · `M02_Copy_Slim.py` · `M02_Doc_Sk.py`(OLD_FIELDS) · `M02_Library_Flat.py` · `M02_Sangeun_Copy.py` · `M02_Sk_AutoRenew.py` · `M02_Doc_Gap.py`(± 300) | SK 14 셈 답 전후 같음 · 저장 → 다시 읽기 왕복 · 칸 전수(`census_storage`) | `사본` 을 읽는 py 19 파일 중 **B09 3** — 올림 규칙(사본 없으면 수식에서)으로 B09 가 그대로 읽게 | 단가산출 저장 · 다시 열기 | +| 2-E1 M01 옛 길 지움 | `/calc` `/text`(M01 · M02 감쌈) · `Store.calc · text · auto` · `check_logic` 부름 | M01 4 파일 · `M02_Logic_Lib_Read.py`(− 150) | `/openapi.json` 길 전후(뜻한 길만 빠짐) | 856 이 상세 몸 `/text` 를 걷은 뒤 | — | +| 2-E2 M02 옛 길 지움 | `run_line` 의 M02 부름 · `Sangeun_Const._mids · sheet` · `Sangeun_Views.text_of` · `Sangeun_Formula` 옛 식 덮개 | M02 6 파일(− 1,000 안팎) · 옛 상세 길 시험 8 군 | 2-A 시험 넷 · 관련 시험 전부 | 856 뒤(상세 몸이 먹는 답) | — | +| 2-E3 **로직 JSON 끝 모습 · 빌더 은퇴**(855-4) | 5 절 ㉮ · 빌더 · `master_doc_convert` · `master_equation*` · `test_802_2` 은퇴 · 관문 = `test_855_golden` | 로직 JSON 59 파일 · scripts 8 파일 · 시험 | `test_855_golden` 같음 · M01 화면 목록 · 별칭 · 개정 | 로직 JSON 칸을 읽는 M01 화면 · 검사 | M01 로직 목록 · 별칭 · 복사/생성 | +| 2-E4 옛 엔진 모듈 지움 | `master_formula` 엔진 몸 · `master_cut.engine` · `master_text*` · `master_auto` · `master_combo.run` · 바탕 기반은 새 모듈로 | scripts 6 파일(− 2,500) · `test_791_1` 은퇴 | `test_855_golden` · 전 관련 시험 | **B08 · B09 가 부르는 동안 못 함**(7 절 판단 1) | — | + +### 4-2 병행 묶음(창 여덟까지 · 파일 안 겹침) + +| 묶음 | 같이 도는 걸음 | 겹침 확인 | 앞 조건 | +| --- | --- | --- | --- | +| ① | 2-A(한 창) | 시험 파일 새로만 | 854 끝 | +| ② | 2-B2 · 2-B3 · 2-B4 · 2-C2 · 2-C4(다섯 창) | M02 Machine/MyMachine · M01 Store 무리 · M01 화면 TS · M02 Doc_Import · M02 Logic_Standard + 새 scripts 파일 — 서로 다름 | ① · 2-B2 는 854-1 뒤 | +| ③ | 2-C1(한 창 · 중심) · 2-C3(한 창 · 2-C2 뒤) | Sangeun_Calc · Doc_Sk 무리 ↔ Sangeun_Imported — 다름 | ② 의 2-C2 | +| ④ | 2-C5(한 창) · 856 화면 하나(한 창 · 별도 PLAN) | Labor_Expand · Hopyo_Build ↔ 화면 TS · Sangeun_Detail — 다름 | 2-C1 | +| ⑤ | 2-D(한 창) | Sangeun_Doc · Copy_Slim · Library_Flat 무리 | ③ · ④ | +| ⑥ | 2-E1 · 2-E2(두 창) | M01 ↔ M02 | ⑤ · 856 | +| ⑦ | 2-E3 → 2-E4(차례) | scripts · 자료 | ⑥ · 판단 1 · 2 | + +꼭 차례인 까닭: +- 2-A 먼저 — 모든 걸음의 「다름 0」 판정 자. +- 2-C1 은 2-D 앞 — 옛 칸을 걷으려면 그 칸을 읽는 옛 셈이 먼저 꺼져야 함. +- 2-C3(검산)은 2-C2 뒤 — 검산 줄 맞댐 열쇠가 새 문서 짓기 꼴에 기댐. +- 2-E 는 856 뒤 — 상세 몸이 옛 답 덧칸(풀이 글 · 시트)을 먹음. +- 2-E3 은 2-E1 · 2 뒤 — 빌더가 지금 옛 로직 JSON 의 셈 칸에서 문서를 지음(고침이 있으면 문서로 옮겨야 함). +- 2-E4 는 맨 끝 — 엔진 모듈을 B09 가 import. + +--- + +## 5. 끝 모습 + +### 5-1 저장 파일 꼴 + +| 파일 | 남는 칸 | 걷는 칸 | 옛 파일을 읽을 때 올림 | +| --- | --- | --- | --- | +| 단가산출 SK | `종류 키 이름 단위 구분 상세구분 본뜬` · `바탕 {로직 \| 참조} \| null` · `수식 {판 시점 로직 단가판 단가시점 단가 부름 문서 따로 위덮음 …}` · `M01판` · `가져온 {원본 로직 단가기준}` | 옛 7 칸(`입력값 열린입력 고름 자재표시 덮개 더한줄 뺀줄` — 값 0 / 14) · 옛 6 칸(0 / 14) · `사본`(= `수식` 여섯 칸 복제) · `바탕판`(= M01판 겹침 · 유력) · `수식.문서.가져온`(= `가져온.원본` 복제) | 옛 7 칸에 값이 있으면 **2-D 때(옛 엔진이 살아 있을 때)** 한 번 문서로 굳혀 `따로` 로 · `사본` 만 있으면 `수식` 으로 옮김 · `바탕판` 은 버림 | +| 일위대가 SC | `종류 키 이름 단위 구분 상세구분 본뜬` · `담은로직 [{참조 \| 고정, 별칭 메모 수량}]` · `자재` | `사본`(SC 엔 `수식` 이 같은 값) · 옛 로직 줄 꼴(`{로직 입력값 고름 …}` — 0 / 28) | 옛 로직 줄 → SK 참조 줄(`Labor_SkRow.migrate` 와 같은 규칙 · 지금 0) | +| 가져온 식 SK | 위 SK + `가져온.원본`(엑셀 글줄 · 금액 · 표지) · `가져온.로직`(엑셀 블록 정본) | `수식.문서.가져온` | 열 때 `가져온.원본` 에서 다시 붙임 | +| 프로젝트 사본(구조물 · B09 서고) | 수식 문서 사본(`수식.json` · `M02_Doc_B09.py` 꼴 · 802-4a) | 굳힌 로직(`로직_단가산출.json` · `굳힌줄` · `GX9…`) | **지금 사본 0** → 이행 대상 0 · 다만 B09 가 굳힌 로직을 옛 엔진으로 셈하므로 꼴 바꿈은 B09 와 같이(판단 5) | + +### 5-2 로직 JSON 끝 모습 — ㉮ 대 ㉯ + +| | ㉮ 이름표만 남김 | ㉯ 수식 문서에 합쳐 없앰 | +| --- | --- | --- | +| 남는 것 | 로직 JSON = `키 구분 상세구분 소유 원문번호 개정 비고 별칭`(셈 칸 `입력 중간 호표 덧줄 끝수 변수표 시험입력` 걷음) · 수식 문서 = 셈 정본 + `이름 결과단위 출처`(셈 답에 찍히는 칸) | 수식 문서 하나(위 이름표 칸을 문서 머리에 더함) · 로직 JSON 59 파일 없앰 | +| 좋은 점 | M01 목록 · 별칭 · 개정 · 분류 화면과 검사가 지금 읽는 파일 그대로 · 걸음이 작음 · 되돌리기 쉬움 | 파일 한 벌 · 복제 0 · 기계 등록 한 곳 | +| 나쁜 점 | 파일 두 벌(복제는 0 이 되도록 칸을 나눠도 키 대장 둘) | M01 관문 `Store`(89 파일이 부름) · 목록 · 별칭 · 검사 · 개정 화면을 모두 문서로 옮김 — 크고 위험 | +| 권함 | **㉮ 먼저**(855-4) · ㉯ 는 걸음 5 뒤에 다시 판단 | | + +### 5-3 빌더 · 대조 시험 · 지문 시험 + +| 대상 | 은퇴 조건 | 대신할 지킴 | +| --- | --- | --- | +| 빌더 `build_수식문서_802_2.py` · `master_doc_convert` · 목록 xlsx | 로직 JSON 셈 칸 걷음(2-E3) — 그 뒤엔 지을 근원이 없음 | 수식 문서가 정본 · M01 [저장] 길만 씀 | +| `test_802_2_convert`(관문 · 옛 → 새 대조) | 2-E3 | `test_855_golden`(새 계산기 = 고정 지문) + `test_802_1`(파이썬 ↔ TS 거울)을 관문으로 | +| `test_791_1`(옛 엔진 지문) | 2-E4 | 같음 | +| 옛 SK 상세 길 시험 8 군(`715_*` · `725_1` · `742_1` · `744_1` · `717_4` · `806_1`) | 2-E2 | `test_855_sk_layers`(같은 견본을 문서 꼴로) | + +### 5-4 화면이 읽게 될 정본 + +| 화면 | 끝 모습 | +| --- | --- | +| M01 [로직 복사/생성] | 수식 문서를 복사해 새 키 문서 + 이름표 줄(854-2 가 문서 같이 만듦 → 2-E3 뒤엔 문서 복사만) · 시험 계산 = 문서 셈 | +| M01 로직 목록 막힘 | 문서 막힘 검사(표지) | +| 별칭 | 이름표(㉮) 칸 그대로 · 별칭 장부 화면 그대로 | +| M02 단가산출 · 일위대가 · 불러오기 | 서버 = 문서 계산기 한 길 · 브라우저 = 짝 계산기 | + +--- + +## 6. 걸음 3 · 4 · 5 와 맞물리는 자리 + +| 걸음 | 2 에서 미리 해 두면 쉬운 것 | 2 에서 건드리지 말 것 | +| --- | --- | --- | +| 3 화면 하나(856) | 2-C1 에서 `/sangeun/calc` 답 꼴 유지 + 머리 띠 칸(까닭 · 빠진 줄 · 짝 잃음 · M01 개정)을 문서 답에서 채움 → 856 은 화면만 바꿈 | 상세 몸 TS(`LogicLab_Ho` · `Cover_Model` · `Sangeun_Detail`) · `Sangeun_Views` 글 덧칸 — 856 몫 | +| 4 불러오기(857) | 2-C2 · 2-C3 으로 가져온 식이 옛 엔진 없이 열리고 검산되면 857 은 읽기기 합침만 남음 | `Hopyo_*` 읽기기 · 재료 이음 규칙 · `San_*` — 857 몫 | +| 5 서고(858) | — | 내 기계 저장(`MyMachine` 의 저장 · 번호 · 폴더) · `Library_*` 쓰는 곳 찾기 — 2-B2 는 `MyMachine.hourly` 만 · 2-D 는 SK 칸만 | + +--- + +## 7. 사용자 판단 거리 · 못 본 것 + +### 7-1 판단 거리 + +1. **B08 · B09 가 옛 엔진을 직접 부름**(6 파일 · 1-3) — 걸음 2 를 ㉠ M01 · M02 가 옛 엔진을 안 부르게 하는 데까지로 하고 옛 엔진 모듈은 그 페이지가 옮길 때까지 남김(권함 · 2-E4 보류) ㉡ 같은 때 B09 도 옮김(따로 큰 일감). +2. **로직 JSON 끝 모습** — ㉮ 이름표만 남김(권함) · ㉯ 수식 문서에 합침. +3. **막힘 기준** — 기본 옵션으로 셈이 안 되는 로직 3 개를 막힘으로 보일지(새 기준) · 지금처럼 열림(권함 · 표지만 막힘). +4. **화면에 보이는 단가** — 옛 = 끝수 자리로 자른 단가 · 새 = 날 값(금액 같음 · 7,531 셈). 보일 때 줄 끝수 자리로 잘라 보이는 것을 기본으로 정함(물음 아님 · 다르면 말씀). +5. **프로젝트 사본 꼴** — 굳힌 로직(옛 엔진으로 셈) → 수식 문서 사본으로 바꾸는 일은 B09 와 같이(지금 사본 0 개 · 1 번과 같이 정함). + +### 7-2 못 본 것 + +- 서버를 띄우지 않고 파이썬으로 직접 셈 · 화면 조작 없음(「화면 확인」 칸은 걸음마다 할 것). +- 데스크탑 임시 배포 storage 는 Synology 로 같은 것이라 보고 따로 안 셈 · DB 에는 M01 · M02 표 없음(분석 E). +- 풀이 글 비교는 「옛 중간 값이 새 값에 있는가」 수준 — 글 꼴 · 문장 비교 아님. +- SK 표본 14(개인 층 · 다른 사용자 것 포함 · 칸 · 판정만 셈 · 값 안 봄) · 가져온 식 2 의 줄 합 ≠ 기준 까닭 미확인(유력 = 엑셀 끝수 규칙). +- 일위대가 옛 로직 줄 · 옛 칸 값 SK · 프로젝트 사본이 자료에 0 이라 그 길은 시험 견본으로만 잴 수 있음. +- B08 · B09 코드는 이름만 봄(무엇을 부르는지) · 그 페이지 동작은 안 봄. diff --git a/docs/raw/요구_1104/설계_858_서고한벌.md b/docs/raw/요구_1104/설계_858_서고한벌.md new file mode 100644 index 000000000..87d802543 --- /dev/null +++ b/docs/raw/요구_1104/설계_858_서고한벌.md @@ -0,0 +1,221 @@ +# 설계 858 — 걸음 5 「서고 한 벌」 + +요구 896 · 898 · 899 · 2026-11-17 · sub4 · 읽기만(코드 · 자료 · 시험 안 고침). 근거 = `파일:줄`(sub_laptop_4 · 커밋 962476e69). 세기 도구 · 결과 = `tmp/s894/m858/`(끝 절). + +## 0. 한눈 요약 + +- 층 서고 종류 아홉 가운데 **단가산출 · 일위대가 둘만 한 틀**(`Store.write` + `Library_*` + `Precombo_Folders`). 구조물 조합 · 표 · 도면은 같은 `Store.write` 를 쓰나 목록 · 나무 · 번호가 따로. 내 기계 · 내 재료 · 실무자료 · 재료 고름 · 공유 요청은 저장 · 번호 · 목록 · 쓰는 곳 찾기를 **각자** 가짐. +- 같은 일 여러 벌(지금 자리 확인): 층 폴더 찾기 **5**(진짜 몸 2) · 폴더 → 층 판정 **4** · 쓰는 곳 찾기 **10**(서고 참조 4 + 자원 키 6) · 쓰기 권한 판단 **3**(+ TS 짝 1) · 파일 판 `version_of` **M02 3**(+ M01 2) · 쓰기 잠금 **4 벌** + **잠금 없는 여러 파일 쓰기 5 곳** · 번호 체계 **7 갈래** · 목록 **8**. +- 제안 = **새 틀을 만들지 않고 가장 잘 된 것을 넓힘**: 종류 표 하나(`Template_Layers` 안 · 옵션 칸) + 부품 일곱(층 폴더 · 권한 · 판 · 여러 파일 쓰기 · 번호 장부 · 쓰는 곳 색인 · 저장). 새 파일 = 지킴 시험 1 · 쓰는 곳 색인 1(`Labor_Ref` 700 줄 경계 때문에 떼어 냄) 뿐. +- 걸음 = 5-0 지킴 → 5-1 · 5-2 · 5-3(셋 병행) → 5-4 → 5-5 → 5-6 → 5-7(공유 · 판단 뒤) → 5-8 옛 코드 지움. 어림 **서버 +250 / −450 줄**. +- **지금 바로 시작해도 되는 조각** = 5-0 · 5-1 · 5-3(855 남은 걸음 · 856 · 857 과 파일 안 겹침). 실무자료 · 재료 고름은 **857 과 같이**. + +## 1. 지금 모습 + +### 1-1 종류 · 자리 · 서버 길 + +| 종류 | 저장 자리(층 폴더 안) | 층 | 서버 길(묶음) | +| --- | --- | --- | --- | +| 단가산출 SK | `sangeun/SK-######.json` + 뿌리 `sangeun_폴더.json` · `_번호.json` | 마스터 · 회사 · 개인 · 프로젝트(굳힘) | `/layers/{층}/library/{kind}` · `{kind}-tree(/paste)` · `{kind}-same(/merge /undo)` · `-tree/delete-check` · `-flat` · `-reset` · `templates/sangeun/{키}` · `sangeun/{키}/doc/*` | +| 일위대가 SC | `precombo/SC-######.json` + `precombo_폴더.json` | 같음 | 같음(종류 인자) | +| 구조물 조합(항목 · 열) | `table/구조물집계표.json`(열 · 경로 = 나무) + 뿌리 `구조물집계표조합.json`(장부) + `structure/ area/ labor/<열id>.json` | 같음 | `/items` · `/layers/{층}/tree` · `items/paste` · `personal/items/copy` · `structures/*` · `area/*` · `{kind}/{column}/clear·copy` | +| 구조물 표 · 도면 틀(양식) | `table/*.json` · `drawing/*.json` | 같음 + 프로젝트 `_initial/` | `/layers/{층}/templates(/{kind}/{name})` GET · PUT · DELETE | +| 내 기계 | `내기계/EQP{사용자}-####.json` + `내기계/_다음.json` | 개인만 | `/layers/personal/my-machines(/{키})` · `/{키}/impact` · `my-machine-lists · -find` · `machine-sheet` | +| 내 재료 | 뿌리 `개인자재.json`(한 파일 묶음 `{그룹, 원문, 줄, 마지막}`) | 개인만 | `/layers/{층}/materials(/{키})`(**`Labor_Router` 안** · 이름 안 맞음) | +| 실무자료(불러온 것) | `실무자료/HP-######.json` · `격자/` · `산근/` · `불러옴.json{번}` | 개인만 · 하루 지나면 숨김 | `/layers/{층}/hopyo*`(층 글 무시 · 늘 개인) | +| 재료 고름 | `실무자료/재료고름/<파일 지문>.json` | 개인만 | `/layers/{층}/material-picks/{fp}` | +| 공유 요청 | 회사 층 뿌리 `올리기요청.json{줄}` | 회사 | `/share-requests(/{id}/approve·reject · /seen)` | + +서버 길 수(자기 포트 `openapi.json` 읽기 · `routes.tsv`): M02 108 가운데 단가산출 · 일위대가 28 · 구조물 조합 · 표 · 도면 12 · 내 기계 9 · 내 재료 5 · 불러오기 15 · 공유 5. + +### 1-2 일마다 하는 자리 — 저장 쪽 + +| 종류 | 층 폴더 찾기 | 목록 | 폴더(나무) | 만들기 · 번호 | 저장(잠금 · 판 · 원자) | +| --- | --- | --- | --- | --- | --- | +| SK · SC | `Router_Items._root:145`(서고 길) · `Router_Layers._layer_dir:140`(templates 길) | `Router_Layers.list_layer:229` → `Layer_Index.list_rows:90` · `summaries:152` | `Precombo_Folders.view:67` · `edit:180`(**판 대조 · 잠금 없음**) | `Labor_Ref.create:385` · `next_key:367` + `_번호.json`(854-1) | `Store.write:142`(잠금 `_LOCK:80` · 판 409 · 원자) · 프로젝트 = `layers.write_template:251`(판 · **잠금 없음**) | +| 구조물 조합 | `Router_Items._root:145` | `Items.items:62` · `get_tree:219` | 표 안 경로 `Tree.apply:233` → `Store.write`(표) | `Item_Personal.create_item:44` · `Items.copy_item:140` · 장부 키 `Book.key_head:36`(`SC{회사}-` · `SP{사용자}-` · `다음`) · 도번 `Store._serial:326`(지운 번호 `_retired:339` 셈) | `Store.write`(표 · 세 파일 · `sync_combos:629`) | +| 표 · 도면 틀 | `Router_Layers._layer_dir:140` | `Layer_Index.list_rows` · `Template_Layers.list_templates:150` | 없음 | 이름 = 파일 이름(번호 없음) | `Store.write` · 프로젝트 `write_template` | +| 내 기계 | `MyMachine_Router._folder:34`(개인 고정 감쌈) + `MyMachine._user:410`(경로로 층 판정) | `MyMachine.listing` | 없음 | `MyMachine.add`(자기 `_LOCK:60` · `_다음.json`) | `update`(자기 잠금 · 판 · 원자 — 854-1) | +| 내 재료 | `Router_Items._root` + `Material_Own._personal:236` | `Material_Own.rows` | 없음 | `add`(`store._LOCK` · **모든 개인 층 최대 + 1** `_last` + 파일 `마지막`) | `update`(`store._LOCK` · **판 없음** · 원자) | +| 실무자료 | `Hopyo_Router._root:42`(개인 고정 감쌈) | `Hopyo_Store.rows:87`(하루 지난 것 숨김) | 없음 | `Hopyo_Store.save:119`(자기 `_LOCK:37` · `불러옴.json.번`) | `save`(새 키만 · 고침 없음) | +| 재료 고름 | `Hopyo_Router._root` | 없음 | 없음 | 파일 지문이 키 | `San_MatPick.write:97`(**잠금 · 판 없음** · 원자) | +| 공유 요청 | `Share_Request._company:66` + `Router_Items._root` | `listing:145` | 없음 | `uuid` | 자기 `_LOCK:47` · 원자 · 상태 409 | + +### 1-3 일마다 하는 자리 — 고침 · 둘러싼 쪽 + +| 종류 | 지우기 | 복사 · 붙여넣기 | 쓰는 곳 찾기 | 권한 | 지문 · 캐시 | 공유 | +| --- | --- | --- | --- | --- | --- | --- | +| SK · SC | 나무 `edit` → `Library_Delete.remove:166`(쓰는 줄 지움 · `_합친것` 기록 · **잠금 없음 · 앞판 되돌림** `:189`) · `Store.delete:207` | `Precombo_Folders.paste:203` → `Labor_Ref.carry:533`(못 읽는 참조 같이) · 합치기 `Library_Same_Router.merge:206`(**잠금 없음** `:261`) | `Labor_Ref.users:459`(+ `use_files:452` · 기억 `_ids_of:473`) · `Library_Delete.users:76` · `Library_Same_Router._user_index:93` · `Layer_Index._uses:185` | `Layer_Access.require:83` + `Library_Delete.can_write:40` + `Library_Same_Router._can_write:108` · 참조 위 층 규칙 `Labor_Ref.readable:146` | 판 `Store.version_of:89` · 내용 `Library_Same.finger:208` · 캐시 `Layer_Index._MEM:34` · `Labor_Ref._IDS:470` | SC 만 요청 길 · SK 는 승인 `carry` 로 딸려 감 | +| 구조물 조합 | 나무 지움 → `Store.prune_removed_structures:489` | `Item_Paste.paste:44`(층 사이) · `Items.copy_item:140` · 열끼리 `Store.copy_from:442` · `copy_pair:471` | SK 쪽에서 열 이름 `Library_Delete._columns:64` | `Router_Items._root` | `Store.version_of` | 요청 길 있음(`item`) | +| 표 · 도면 틀 | `Router_Layers.delete_layer_template:366` → `Store.delete` · `layers.delete_template:272` | 프로젝트로 `copy_templates:345` · `seed_project:390` · `reset_project:425` | 고정 표 `Store.IN_USE:58`(네 양식) | `_layer_dir` | `Template_Layers.version_of:139` | 없음 | +| 내 기계 | `MyMachine.delete`(잠금) | 없음(층 사이 안 옮김) | `MyMachine.uses:487`(SK 글 훑기) · 영향 `MyMachine_Impact` · M01 `Machine_Uses.uses:265` | `_folder` | 판 `MyMachine.version:116` · 캐시 `_MEMO:169` | 없음 | +| 내 재료 | `Material_Own.remove`(쓰는 곳 409) | 층 사이 같은 키 `carry` · `adopt` | `Material_Own.usage:143`(층 폴더 통째 글 훑기) | `_root` + `_personal` | 캐시 `_MEMO:184` | 없음 | +| 실무자료 | `Hopyo_Store.delete:167` · `Hopyo_Forget.finish:128` · 하루 지남 `sweep:148` | 없음 | 본뜬 키로 사본 걷음 `Hopyo_Forget.forget:102` | `Hopyo_Router._root` | 올린 엑셀 `Hopyo_Store.fingerprint:71` | 없음 | +| 재료 고름 | HP 지울 때 판만 | 없음 | `San_MatPick.made:248` · `uses:333` · `tally:348` | `Hopyo_Router._root` | — | 없음 | +| 공유 요청 | 없음(상태만) | 승인 = 위 두 길 | — | `_company` | — | — | + +### 1-4 같은 일 몇 벌(분석 수 → 지금 자리) + +| 일 | 분석 | 지금 | 자리 | +| --- | --- | --- | --- | +| 층 폴더 찾기(세션 → 폴더) | 4 | **5**(몸 2 + 감쌈 2 + 프로젝트 1) | `Router_Items._root:145` · `Router_Layers._layer_dir:140` · 감쌈 `Hopyo_Router._root:42` · `MyMachine_Router._folder:34` · 프로젝트 `Project_Items_Router._root:87` | +| 폴더 → 층 판정 | — | **4** | `Labor_Ref.where:77`(몸) · `MyMachine._user:410`(경로 부모 이름) · `Material_Own._personal:236`(→ `where`) · 키 → 층 `Combo_Store.where:86` | +| 쓰는 곳 찾기 | 6 | **10** | 서고 참조 4: `Labor_Ref.users:459` · `Library_Delete.users:76` · `Library_Same_Router._user_index:93` · `Layer_Index._uses:185` / 자원 키 6: `MyMachine.uses:487` · `Material_Own.usage:143` · `Labor_Spec.users:143`(규격 열) · `San_MatPick.made:248 · uses:333` · M01 `Machine_Uses.uses:265` · M01 `Doc.users:268` | +| 쓰기 권한 판단 | 여러 곳 | **3 + TS 1** | `Layer_Access.grant:61 · require:83`(몸) · `Library_Delete.can_write:40` · `Library_Same_Router._can_write:108` · TS `M02_MasterTemplete_Layer.ts:107 accessFor`(거울 시험 없음) | +| 파일 판 `version_of` | 3 | **M02 3 + M01 2** | `Store.version_of:89`(바이트) · `Template_Layers.version_of:139`(경로 · 같은 sha256[:16]) · `Item_Source.version_of:79`(JSON 정렬 — 실은 내용 지문) · M01 `Store.version_of:56` · `Doc.version_of:46` | +| 내용 지문 | 7 | 7(855 몫) + 서고 2 | 서고 쪽 `Library_Same.finger:208` · `Hopyo_Store.fingerprint:71` | +| 쓰기 잠금 | — | **4 벌** | `Store._LOCK:80`(서고 · 표 · 재료 공용 · `Lock` = 안에서 다시 잡으면 교착) · `MyMachine._LOCK:60`(RLock) · `Hopyo_Store._LOCK:37` · `Share_Request._LOCK:47` | +| 잠금 없는 쓰기 | B 5-4 · 5-5 | **5 곳** | `Precombo_Folders.edit:180`(판 대조와 쓰기 사이 열림) · `Library_Delete.remove:166` · `Library_Same_Router.merge:206 · undo:285` · `Template_Layers.write_template:251` · `San_MatPick.write:97` | +| 번호 체계 | 9 갈래(E 4-1) | 서고 **7** | SK · SC `next_key` + `_번호.json` · 장부 `Book`(`다음`) · 도번 `Store._serial`(지운 번호) · HP `불러옴.json.번` · PM 전 층 최대 + `마지막` · EQP `_다음.json` · 요청 `uuid` | +| 목록 | — | **8** | `Layer_Index.list_rows` · `Precombo_Folders.view` · `Items.items` · `MyMachine.listing` · `Material_Own.rows` · `Hopyo_Store.rows` · `Share_Request.listing` · `Combo_Store.listing:159` | + +### 1-5 storage 실측(꼴 · 개수만 · `census_storage.tsv`) + +| 층 | 수 | 폴더별 json(층 합) | 뿌리 파일 | +| --- | --- | --- | --- | +| 마스터 | 1 | drawing 5 · table 1 · report 1 · stability 2 · 구조물정의_이력 22 | `구조물정의.json` · `구조물집계표조합.json` · `calc_sites.json` | +| 회사 | 2 | table 2 · drawing 1 · 나머지 0 | `구조물집계표조합.json` 2 · `00_template_A1.json` 1(종류 폴더 밖에 놓인 양식 — 확인 거리) | +| 개인 | 6 | sangeun 15 · precombo 6 · `_합친것` 16 · table 4 · 내기계 1(`_다음` 만) · 실무자료 7 · 빈 폴더 `area drawing inputs labor material promote structure` | `구조물집계표조합.json` 4 · `sangeun_폴더` 2 · `precombo_폴더` 2 · `개인자재.json` 1 · `manifest.json` 1 · `_번호.json` 1 | + +## 2. 한 벌 틀 제안 + +### 2-1 바탕 — 이미 잘 된 것 + +- **저장** `Store.write:142` — 잠금 · 판 409 · 원자 쓰기 · 서버 정본 다시 셈(`_server:566`) · 서고 키 = 파일 이름. 한 파일 한 문서 꼴의 정본 길. +- **나무** `Precombo_Folders` — `{종류}_폴더.json{폴더, 자리}` · 종류 인자 한 벌. +- **지우기 · 합치기 · 되돌림** `Library_Delete` · `Library_Same(_Router)` — 쓰는 줄 정리 · `_합친것` 기록 · 되돌림. +- **권한** `Layer_Access` 한 벌 · **층 폴더** `Router_Items._root` 한 벌(대부분 가져다 씀). + +### 2-2 종류 표 하나(새 파일 없음 · `Template_Layers` 안 · 어림 +40) + +지금 `KINDS · LIBRARY_KINDS`(`Template_Layers:34-35`) · `Labor_Ref.PREFIX · TITLE` · `Share_Request` `Literal`(종류 글) · TS `Api_Fetch.Kind` 로 흩어진 종류 정의를 한 표로. + +| 칸(옵션) | 뜻 | SK | SC | 내 기계 | 내 재료 | 실무자료(857) | +| --- | --- | --- | --- | --- | --- | --- | +| `폴더` | 층 안 자리 | `sangeun` | `precombo` | `내기계` | 판단 1 | `실무자료` | +| `키꼴` · `머리` | 번호 꼴 | `SK-######` | `SC-######` | `EQP{사용자}-####` | `PM######`(전 층) | `HP-######` | +| `층` | 놓일 층 | 넷 | 넷 | 개인만 | 개인만 | 개인만 | +| `번호` | 장부 자리 | 층 `_번호.json` | 같음 | 같음(`_다음.json` 걷음) | 전 층 최대 + `마지막` 그대로 | `불러옴.json.번` 그대로(857) | +| `나무` | 폴더 장부 | 있음 | 있음 | 없음 | 없음 | 없음 | +| `숨김` | 하루 지나면 | — | — | — | — | 1 일 | +| `쓰는곳` | 쓰는 곳의 뜻 | 참조 `{층 주인 키}` | 같음 | 자원 키 글(`개인 EQP…`) | 자원 키 글(`PM…`) | 본뜬 키 | +| `공유` | 회사에 올리기 | 판단 2 | 있음 | 판단 2 | 판단 2 | 없음 | +| `셈` | 저장 때 서버 정본 | `Store._server` | 같음 | 시간당(`Machine_Hourly.hour`) | 없음 | 없음 | + +구조물 조합 · 표 · 도면 틀은 이미 `Store.write` 를 쓰고 번호가 표 장부와 같이 움직임 → 표에 「양식 종류」 로만 올리고 번호 · 나무는 지금 것 그대로. + +### 2-3 부품 일곱(지금 것을 넓힘) + +| 부품 | 한 벌로 삼을 것 | 걷을 것 | 어림 | +| --- | --- | --- | --- | +| ① 층 폴더 | `Router_Items._root` + 옵션 `개인만` | `Hopyo_Router._root:42` · `MyMachine_Router._folder:34` 감쌈 · `Router_Layers._layer_dir` 는 프로젝트 · 비동기 때문에 남기되 안쪽이 `access.folder` 를 같이 씀 | −10 | +| ② 층 판정 | `Labor_Ref.where:77` | `MyMachine._user:410` 의 경로 부모 이름 판정 → `where` | −10 | +| ③ 권한 | `Layer_Access` 에 `can_write(session, here)` 하나 | `Library_Delete.can_write:40` · `Library_Same_Router._can_write:108` · TS `accessFor` 는 거울 시험 붙임 | +15 / −15 | +| ④ 판 | `Store.version_of` | `Template_Layers.version_of:139` → 그것을 부름 · `Item_Source.version_of` 는 이름만 「내용 지문」 으로(855 B9-5 때) | −5 | +| ⑤ 여러 파일 쓰기 | `Store` 에 `batch()`(잠금 하나 + 앞판 되돌림 · `Library_Delete.remove:189` 의 되돌림 꼴을 옮김) · `_LOCK` → `RLock` | `Library_Delete` 되돌림 몸 · `Library_Same_Router.merge` · `undo` · `Precombo_Folders.edit` 가 `batch` 안에서 | +40 / −40 | +| ⑥ 번호 장부 | 층 `_번호.json`(854-1 · `Labor_Ref.next_key` 꼴) 을 종류 표 `번호` 칸으로 | `MyMachine._다음.json` · `MyMachine.add` 의 번호 몸 | +10 / −20 | +| ⑦ 쓰는 곳 색인 | `Labor_Ref.use_files · users · _ids_of`(파일 판 기억) 를 새 `M02_Library_Uses.py` 로 떼어 넓힘(참조 + 자원 키 두 찾기) | `Library_Delete.users` 훑기 몸 · `_user_index` · `Layer_Index._uses` · `MyMachine.uses` · `Material_Own.usage` | +120 / −150 | + +### 2-4 새로 만드는 것(가장 적게) + +- 새 파일 2 = `M02_Library_Uses.py`(⑦ · `Labor_Ref` 675 줄이라 더 못 넣음) · 지킴 시험 `test_858_shelf_golden.py`. +- 새 저장 파일 0(층 `_번호.json` 은 이미 있음). +- 새 서버 길 0 — 내 재료 길을 `Labor_Router` 에서 내 기계와 같은 라우터 묶음으로 옮김(길 글자는 그대로). + +## 3. 걸음(두 박자 — 새 틀로 옮김 → 답 전후 같음 → 다음 묶음에서 옛 코드 지움) + +| 걸음 | 무엇 | 파일(어림 줄) | 지킴 | 위험 · 막는 법 | 화면 확인 | +| --- | --- | --- | --- | --- | --- | +| **5-0 지킴 올림** | 임시 storage 견본 층(SK · SC · 항목 · 내 기계 · 내 재료 · 공유 요청)에서 길 답 지문 — 목록 · 나무 · 만들기 · 고치기 · 지우기 · 복사 · 붙여넣기 · 합치기 · 되돌림 · 쓰는 곳 · 권한 403/404 → `858_shelf_golden.json` · 동시 쓰기 시험(854-1 꼴)을 나무 · 지우기 · 합치기로 넓힘 | 새 `resources/tester/test_858_shelf_golden.py`(+ 300) | 지금 수치 그대로 통과 | 견본 짓기가 남의 시험 견본과 겹침 → 기존 `world` 픽스처(`test_m02_labor_ref`) 재사용 | — | +| **5-1 권한 한 벌** | ③ | `M02_Layer_Access.py`(+ 15) · `M02_Library_Delete.py`(− 8) · `M02_Library_Same_Router.py`(− 5) · 거울 시험(TS `accessFor` ↔ 서버) 새 1(+ 60) | 5-0 · `test_m02_layer_access` · `test_735_1` · `test_733_3_*` | 회사 관리자 · 남의 층 경우 — 5-0 의 403 지문 | 개인 · 회사 층 나무 지우기 · 중복 합치기 단추 보임 | +| **5-2 층 폴더 · 층 판정 한 벌** | ① ② | `M02_MasterTemplete_Router_Items.py`(+ 5) · `M02_MyMachine_Router.py`(− 5) · `M02_MyMachine.py`(± 10) · `M02_Material_Own.py`(± 5) | 5-0 · `test_821_*` · `test_840_4` · `test_m02_material_own` | `Hopyo_Router._root` 는 **857 몫 파일** → 여기선 안 고침 · 857 이 같은 옵션을 씀 | 개인관리 › 기계 · 자재 열기 | +| **5-3 판 한 벌 · 프로젝트 저장 잠금** | ④ + `write_template` 을 `Store._LOCK` 안에서 | `M02_Template_Layers.py`(± 10) · `M02_MasterTemplete_Store.py`(± 3) | 5-0 · `test_826_1` · `test_204_2` · `test_572` | 프로젝트 층 저장(B05 · B07 양식) — 판 값은 같은 sha256[:16] 이라 안 바뀜 | 프로젝트 양식 저장 한 번 | +| **5-4 여러 파일 쓰기 한 꼴** | ⑤ | `M02_MasterTemplete_Store.py`(+ 40) · `M02_Library_Delete.py`(− 30) · `M02_Library_Same_Router.py`(± 20) · `M02_Precombo_Folders.py`(± 5) | 5-0 동시 시험(같은 층 지우기 · 합치기 겹침 → 하나만 이김 · 파일 앞판 그대로) · `test_735_1` · `test_733_3_*` · `test_m02_precombo_folders` | `RLock` 으로 바꿈 — `Store.write` 를 잠금 안에서 부르는 길(합치기 `_rewrite:125`)이 생김 · 늦은 쓰기(`_refresh_labor`)는 잠금 밖 그대로 | 나무 지우기 · 되돌림 · 합치기 | +| **5-5 쓰는 곳 색인 한 벌** | ⑦ | 새 `M02_Library_Uses.py`(+ 120) · `M02_Labor_Ref.py`(− 60) · `M02_Library_Delete.py`(− 30) · `M02_Library_Same_Router.py`(− 20) · `M02_Layer_Index.py`(− 15) · `M02_MyMachine.py`(− 25) · `M02_Material_Own.py`(− 20) | 5-0 쓰는 곳 지문 · `test_826_1`(목록 쓰는 곳 수) · `test_840_4` · `test_848_5` | **855 L2 ⓑ 가 `Layer_Index` 를 만짐** → L2 ⓑ 뒤 또는 `Layer_Index` 몫만 L2 ⓑ 창에 | 지우기 미리 보기 쓰는 곳 · 목록 쓰는곳수 · 내 기계 쓰는 단가산출 | +| **5-6 내 기계 · 내 재료를 서고 틀로** | 종류 표(2-2) · 내 기계 번호 = 층 `_번호.json` · 옛 `내기계.json` 옮김(`MyMachine._move:97`) 걷음 · 내 재료 판 대조(+ 판단 1) · 내 재료 길을 내 기계 라우터 묶음으로 | `M02_Template_Layers.py`(+ 40) · `M02_MyMachine.py`(− 60) · `M02_MyMachine_Router.py`(+ 40) · `M02_Material_Own.py`(± 40) · `M02_Labor_Router.py`(− 50) · TS `M02_MyMachine_Api.ts` · 내 재료 화면 Api(판 칸 · ± 20) | 5-0 · `test_854_1` · `test_821_*` · `test_840_4` · `test_m02_material_own` · `test_826_2` | **`San_MyMachine.attach` 가 `MyMachine.create` 를 부름(857 몫)** → `create` 인자 · 답 꼴 그대로 | 내 기계 만들기 · 고침 · 옛 판 막힘 · 내 재료 같은 것 | +| 5-7 공유 범위(판단 2 뒤) | `Share_Request` `Literal` → 종류 표 `공유` 칸 | `M02_Share_Request.py`(± 20) · TS `ShareRequest`(± 20) | `test_706_1` | — | [회사에 올리기] | +| **5-8 옛 코드 지움** | 감쌈 · 중복 몸 · 옛 꼴 옮김 · 잠금 없는 되돌림 몸 · 화면 0 이 된 것 · 그것만 붙드는 시험 | 위 파일들(− 150 안팎) | `/openapi.json` 길 전후(뜻한 길만) · 관련 시험 전부 | — | 한 바퀴 | + +### 3-1 같이 돌릴 수 있는 묶음(파일 안 겹침) + +| 묶음 | 걸음(창) | 겹침 확인 | 앞 조건 | +| --- | --- | --- | --- | +| ㉠ | 5-0(하나) | 새 시험 파일만 | 없음 — **지금** | +| ㉡ | 5-1 · 5-2 · 5-3(셋) | Layer_Access · Library_Delete · Library_Same_Router ↔ Router_Items · MyMachine* · Material_Own ↔ Template_Layers · Store — 다름 | ㉠ | +| ㉢ | 5-4(하나) | Store · Library_* · Precombo_Folders | ㉡(5-1 의 Library_* · 5-3 의 Store) | +| ㉣ | 5-5(하나) | Labor_Ref · Library_* · Layer_Index · MyMachine · Material_Own | ㉢ · 855 L2 ⓑ | +| ㉤ | 5-6 · 5-7(둘) | MyMachine* · Material_Own · Labor_Router · Template_Layers ↔ Share_Request — 다름 | ㉣ · 판단 1 · 2 | +| ㉥ | 5-8(하나) | 전부 | ㉤ | + +꼭 차례인 까닭: +- `Library_Delete` · `Library_Same_Router` 를 5-1 · 5-4 · 5-5 셋이 만짐 → 한 걸음씩. +- `MyMachine` · `Material_Own` 을 5-2 · 5-5 · 5-6 이 만짐 → 5-2 는 판정 몸만 · 5-6 은 마지막. +- 5-4(잠금 하나)가 5-5 앞 — 쓰는 곳 색인을 지우기 · 합치기 잠금 안에서 쓰게 되므로. + +## 4. 「다시 셈 · 새로 고침」 길 열두 가지 + +| 번호 | 길(B 4-1) | 걸음 2 뒤 | 하나로 모을 수 있나 · 정리안 | +| --- | --- | --- | --- | +| ① | 자동 따라옴 `Sk_AutoRenew`(프로젝트 층 밖) | 남음(2-D 가 옛 사본 갈래만 걷음) | ②와 「값을 새로 받기」 한 뜻 — 층 따라 자동 / 손 | +| ② | [단가 갱신] `Sangeun_Copy.PRICE:40` | 남음(프로젝트 층) | 판단 3 — 이름 가름 | +| ③ | [재생성] `REGEN` | 남음 | 그대로(고친 것 버림 · 뜻 다름) | +| ④ | 알림 [확인] `Sk_AutoRenew.CONFIRM:47` | 남음 | ① 의 짝 — ① 과 같이 | +| ⑤ | 저장 때 재계산 `Store._server:566` → … `Doc_Sk.settle` | 남음(서버 정본 원칙) · 2-D 뒤 `사본` 줄임 갈래 빠짐 | 그대로 — 모든 저장이 이미 이 한 길 | +| ⑥ | 펼침 `Library_Flat.flat_doc`(읽기 · 저장 · 복사) · 초기화 `reset_doc` | 남음 · 읽기 길 펼침(`Router_Layers:275-276` `unpromote` · `flat_doc`) = 「열 때 본 문서 ≠ 파일」 | 옛 로직 줄 꼴 올림 몫이 크면 저장본 비운 뒤 읽기 길 펼침 걷음(855 2-D 와 같이 확인) | +| ⑦ | 일위대가 계산값 다시 적기 `Labor_Doc.server` · `Store._refresh_labor:596` | 남음 | ⑦ ⑧ = 「저장 뒤 딸림 갱신」 한 목록으로(`Store.write` 끝 · 5-4 의 `batch` 안) | +| ⑧ | 도면 연결표 글 `Store._refresh_drawing:588` | 남음 | 위와 같음 | +| ⑨ | 저장 전 영향 `MyMachine_Impact` | 남음 | 내 재료에도 같은 꼴(5-6 · 판단 1 과 같이) | +| ⑩ | 파생 색인 `Layer_Index` · `Logic_Standard` · 프로젝트 [재적용] · `Item_Prices.refresh` · B09 | 색인 둘 남음 · 프로젝트 쪽은 B9 걸음 몫 | 색인 무효 규칙 = 「파일 자국」 한 꼴(`Layer_Index._stamps:49` · `Logic_Standard._stamp:227` 이 각자) — 858 범위 밖 · 메모만 | +| ⑪ | `Hopyo_Relink` | 857 몫 | — | +| ⑫ | 한 번용 `*_Migrate*` | **이미 없음**(853-2 · 지금 파일 0) | — | + +같은 단추 이름이 층 따라 다른 뜻인 자리 — **[단가 갱신]**: 프로젝트 층 = 굳힌 사본을 지금 M01 값으로 다시 씀(손) · 층 서고 = 자동 따라옴이라 단추 대신 알림 [확인]. 서버가 `Sk_AutoRenew.on:55` 로 가름 · 화면 글 `formula_doc_text.ts:54` 한 벌. 정리안 = 판단 3. + +## 5. 화면 쪽 + +| 거리 | 지금 | 제안 | +| --- | --- | --- | +| 고치는 중 값 보관 | 단가산출만 sessionStorage(`line_stack_screen.ts:185 · 197` · 열쇠 `m02_sk_doc_drafts` `Sangeun_Tabs.ts:56`) · 나머지는 메모리 + 떠날 때 `confirmLeave`(11 파일) | **858 범위 밖** 권함 — 856 이 일위대가 줄 창을 줄 쌓기로 바꾸면 SC 도 같은 보관을 얻음 · 내 기계 · 내 재료는 짧은 양식이라 메모리 그대로 · 판단 5 | +| 층 전역 `setActiveLayer` | `Api_Fetch.ts:74-92` 모든 M02 부름이 `/layers/${activeLayer}` · `UI_Page.ts:162 · 345` 가 바꿈 · 되돌림 · 섞임은 `turn` 이 막음 | **858 범위 밖** 권함(화면 부름 전부가 걸림 · 효과 작음) · 5-6 에서 내 기계 · 내 재료 Api 만 「종류 + 층」 을 인자로 받는 한 함수로 | +| 권한 짝 | TS `accessFor` ↔ 서버 `Layer_Access` 거울 시험 없음 | 5-1 에서 붙임 | + +## 6. 걸음 2 · 3 · 4 와 겹침 · 차례 조건 + +| 상대 | 겹치는 파일 | 조건 | +| --- | --- | --- | +| 855 2-C1 · 2-C5 · 2-D | `Doc_Sk` · `Sangeun_Calc` · `Labor_Copy` · `Labor_Expand` · `Copy_Slim` · `Library_Flat` · `Sangeun_Copy` · `Sk_AutoRenew` | 858 은 이 파일들을 **안 고침**(⑥ 펼침 정리는 2-D 뒤 메모만) | +| 855 L2 ⓑ | `Layer_Index` · `Labor_Inputs` | 5-5 의 `Layer_Index` 몫은 L2 ⓑ 뒤 | +| 855 B9-5 | `Item_Source.version_of` | 이름 바꿈은 B9-5 몫 · 858 은 안 고침 | +| 856 화면 하나 | `Sangeun_Detail` · `LogicLab_Ho` · `line_stack_*` · 일위대가 줄 창 TS | 겹침 없음 · 고치는 중 값 보관은 856 에 맡김 | +| 857 불러오기 | `Hopyo_Router` · `Hopyo_Store` · `Hopyo_Forget` · `San_MatPick` · `San_MyMachine`(→ `MyMachine.create`) | 실무자료 · 재료 고름의 틀 옮김은 **857 안에서**(종류 표 `숨김` 칸을 씀) · 5-6 은 `create` 꼴 그대로 | +| 854 · 855 이미 끝난 것 | `MyMachine`(854-1 잠금 · 판 · 2-B2) · `Labor_Ref.next_key`(854-1) · `Machine_Hourly` | 바탕으로 씀 | + +지금 바로 시작해도 되는 조각 = **㉠ 5-0 · ㉡ 5-1 · 5-3**(855 남은 걸음 · 856 · 857 과 파일 안 겹침). 5-2 는 `MyMachine` 을 만지는 다른 일감이 없으면 같이. + +## 7. 사용자 판단 거리 · 못 본 것 + +### 7-1 판단 거리(쉬운 말) + +1. **내 재료 저장 꼴** — 지금 한 파일에 모든 줄 · 고칠 때 판 대조 없음. ㉮ 내 기계처럼 한 줄 한 파일 + 판(서고 틀과 같음 · 지금 저장본 1 개라 옛 꼴 호환 없이 바꿈) ㉯ 한 파일 그대로 + 판만 붙임(권함 — 줄이 적고 번호가 전 층에 걸쳐 있어 파일을 나눌 득이 작음). +2. **공유 범위** — 지금 [회사에 올리기] 요청은 구조물 조합 항목 · 일위대가만. 단가산출 · 내 기계 · 내 재료도 요청 길을 둘지(지금 단가산출은 일위대가 승인 때 딸려 갈 때만 올라감). +3. **[단가 갱신] 이름** — 프로젝트 층에선 손으로 새 값 받기, 층 서고에선 저절로 따라오고 알림 [확인]만 있음. ㉮ 이름을 가름(프로젝트 = 「단가 갱신」 · 층 서고 = 「새 값 확인」 · 권함) ㉯ 그대로. +4. **내 기계 · 내 재료 저장본** — 지금 내 기계 0 대(번호 파일만) · 내 재료 1 파일. 비우고 시작해도 되는지(옛 `내기계.json` 옮김 코드도 같이 걷음). +5. **고치는 중 값 보관** — 새로고침 뒤에도 고친 값이 남아야 하는 화면(지금 단가산출만) — 858 에선 안 다루고 856 에 맡겨도 되는지. +6. **실무자료 · 재료 고름** — 857(불러오기 합침) 안에서 같은 틀로 옮김(권함). + +### 7-2 못 본 것 + +- 화면 · 서버를 조작하지 않음(코드 따라가기 · 길 목록만 읽음) — 「공유 요청 승인」 · 「합치기 되돌림」 실제 동작. +- 프로젝트 층 서고(굳힌 사본)의 목록 · 쓰는 곳 — B9 걸음 몫이라 깊게 안 봄. +- M01 `Machine_Uses` · `Doc.users` 속(M01 범위). +- 회사 층 뿌리 `00_template_A1.json`(종류 폴더 밖) 이 어느 코드가 놓은 것인지. +- `Router_Layers._layer_dir` 의 프로젝트 · 직접 SQL(B 1-4) 정리 — 858 에 넣지 않음(마스터 층 ↔ 프로젝트 경계 · B 6(다) 다른 후보). + +## 세기 도구 · 결과(`tmp/s894/m858/`) + +| 파일 | 내용 | +| --- | --- | +| `defs.py` → `defs.tsv` | 서고 관련 36 파일 함수 555 개(이름 · 줄 · 길이 · 서버 길 · 독스트링 첫 줄) | +| `count.py` → `count.tsv` · `count_summary.tsv` | 일 16 갈래 정규식 자리(`파일:줄`) — 표 1-4 는 이것을 손으로 걸러 셈(이름이 같은 다른 일 뺌 — 예 `Hopyo_Excel._columns`) | +| `census_storage.py` → `census_storage.tsv` | 층 폴더 꼴 · 폴더별 json 수 · 뿌리 파일(키 이름은 `<키>` 로 가림 · 값 안 봄) | +| `openapi.json` → `routes.tsv` | 자기 포트 8006 길 목록(읽기만) · M02 108 길 묶음 | diff --git a/resources/master_data/_수식문서_틀.md b/resources/master_data/_수식문서_틀.md index 4171ac42f..b96b58a6f 100644 --- a/resources/master_data/_수식문서_틀.md +++ b/resources/master_data/_수식문서_틀.md @@ -5,6 +5,7 @@ - 셈 = `scripts/master_doc_calc.py` ↔ `common_util/common_util_formula_doc_calc.ts`(짝) - 풀이 · 글 · 검사 = `scripts/master_doc.py` ↔ `common_util/common_util_formula_doc.ts`(짝) - 표 찾기 · M01 연결 풀이 = `scripts/master_doc_link.py` ↔ `common_util/common_util_formula_doc_table.ts`(표 찾기 짝) +- 셈 기록(줄마다 부른 자원 · 하위 문서 · 고른 품목 · 서버 단독) = `scripts/master_doc_trace.py`(B08 · B09 가 답을 갈라 합산) - 옛 로직 변환 = `scripts/master_doc_convert.py` · 빌더 `scripts/build_수식문서_802_2.py`(`--check`) - 거울 · 꼴 시험 = `resources/tester/test_802_1_formula_doc.py` · 변환 대조 = `test_802_2_convert.py` diff --git a/resources/master_data/scripts/build_수식문서_802_2.py b/resources/master_data/scripts/build_수식문서_802_2.py index 2eaa2fa84..bbe15a9ff 100644 --- a/resources/master_data/scripts/build_수식문서_802_2.py +++ b/resources/master_data/scripts/build_수식문서_802_2.py @@ -81,6 +81,23 @@ def new_answer(links, doc: dict, given: dict | None = None): return {"결과": got["결과"]} if doc.get("결과") else {k: got.get(k) for k in KEYS} +def cases_of(whole, row: dict) -> list[tuple]: + """(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력) — 기본 + 고르기 입력의 다른 갈래 하나씩.""" + base = meq.given_of(whole, row) + cases = [("", base, None)] + for spec in row.get("입력") or []: + for opt in spec.get("고르기") or []: + if str(opt) != str(base.get(spec["이름"])): + one = {spec["이름"]: opt} + cases.append((f"{spec['이름']}={opt}", {**base, **one}, one)) + return cases + + +def agree(old, new) -> bool: + """대조 같음 — 같은 값 · 둘 다 못 셈.""" + return old == new or (isinstance(old, str) and isinstance(new, str)) + + def _text(v) -> str: if isinstance(v, str): return v @@ -137,17 +154,11 @@ def build(log=print) -> dict: links = ml.Links(whole, docs) runs, both_out = [], 0 for _, row in items: - key, base = str(row["키"]), meq.given_of(whole, row) - cases = [("", base, None)] # (옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력) - for spec in row.get("입력") or []: - for opt in spec.get("고르기") or []: - if str(opt) != str(base.get(spec["이름"])): - one = {spec["이름"]: opt} - cases.append((f"{spec['이름']}={opt}", {**base, **one}, one)) - for label, given, changed in cases: + key = str(row["키"]) + for label, given, changed in cases_of(whole, row): old = old_answer(whole, row, given) new = new_answer(links, docs[key], changed) - same = old == new or (isinstance(old, str) and isinstance(new, str)) + same = agree(old, new) both_out += isinstance(old, str) and isinstance(new, str) runs.append( { diff --git a/resources/master_data/scripts/master_doc_calc.py b/resources/master_data/scripts/master_doc_calc.py index 0f6f5be68..07de3aee1 100644 --- a/resources/master_data/scripts/master_doc_calc.py +++ b/resources/master_data/scripts/master_doc_calc.py @@ -275,6 +275,8 @@ class _Run: for k in ("칸", "단위"): if link.get(k): payload[k] = link[k] + if hasattr(self.links, "at"): # 855-F 셈 기록(`master_doc_trace`) — 기록 안 켬 = 안 탐 + self.links.at(self.stack, name, kind, payload) try: if kind == "요소": return number(self.links.element(payload)) @@ -407,6 +409,8 @@ def _money(run: _Run, doc: dict, rules: dict): for i, line in enumerate(lines): scope = _scope(doc, outs, dict(running), cover, syms) where = str(line.get("이름") or f"금액 {i + 1}") + if hasattr(run.links, "at"): # 855-F 셈 기록 — 이 줄 읽음(시간당 작업량) + run.links.at(run.stack, i, "금액", {}) swapped, more, work = mw.line_work(run, line, scope) # 846-1 시간당 작업량 text = line.get("수량") if swapped is None else swapped qty = ( diff --git a/resources/master_data/scripts/master_doc_link.py b/resources/master_data/scripts/master_doc_link.py index 349635ea0..64d3d9b38 100644 --- a/resources/master_data/scripts/master_doc_link.py +++ b/resources/master_data/scripts/master_doc_link.py @@ -14,6 +14,7 @@ from __future__ import annotations import json +import os from decimal import Decimal from pathlib import Path @@ -24,7 +25,9 @@ import master_machine_crew as mcrew import master_material as mm import master_pick as mp -FOLDER = Path(__file__).resolve().parents[1] / "수식문서" +# 화면 저장 시험 사본(`AISLO_MASTER_DIR` — `M01_MasterData_Store.FOLDER` 와 같이) · 없으면 정본 +_HOME = os.environ.get("AISLO_MASTER_DIR") or Path(__file__).resolve().parents[1] +FOLDER = Path(_HOME).resolve() / "수식문서" _ARITH_OK = ("num", "bin", "neg") diff --git a/resources/master_data/scripts/master_doc_text.py b/resources/master_data/scripts/master_doc_text.py new file mode 100644 index 000000000..9e1696287 --- /dev/null +++ b/resources/master_data/scripts/master_doc_text.py @@ -0,0 +1,327 @@ +# -*- coding: utf-8 -*- +"""단가산출 수식 문서 셈 답 → 산출근거 글(PLAN 855-C 2-C4 · 서버 풀이 글) — 셈 안 함(답만 읽음). + +쓰는 곳 = M02 기준 목록 계산서(`M02_Logic_Standard.sheet`) · (뒤에) B09 산출근거(855 보충 B9-4). +⚠ 짝(글 규칙) — 한쪽을 고치면 다른 쪽도 · 거울 시험 `resources/tester/test_855_c4_doc_text.py`: + `A00_Common/line_stack_out.ts`(금액 줄 · 계 줄 꼴 · 수 꼴 `one` · `won` · 비목 이름) · + `ui_template/ui_template_equation.ts`(`eqText`) · + `common_util/common_util_line_stack_unit.ts`(`unitText` · `isAtom` · `moneyUnits`) · + `common_util/common_util_formula_doc_view.ts`(`offLine` — 선택으로 꺼진 줄). +금액 줄 = 「이름 : 단가 원/단위 × 수량 단위 = 금액 원」 · 묶음 줄 = 비목마다 「노무비 : …」 · + 계 = 「노무비 : 줄 + 줄 = 금액 원」 · 「합계 : 금액 원」. +수 꼴 = 화면과 같음 — 단가 · 수량 = `eqText`(소수 여섯 자리까지 · 셈 값 그대로) · + 줄 금액 = 소수 한 자리 · 비목 · 합계 = 원(셈 답의 끝수 그대로 · 여기서 자르지 않음). +옮기지 않은 것(화면만) — 식 조판(KaTeX · 수량 식은 값 하나로) · 공식 줄 · 펼침 · + 작업량 줄(846-2) · 굳은 기계 이름(847-1) · 비목곱 인수 글(848-7 · 금액은 답 그대로) · + 계 덧셈 항 = 줄 금액(화면은 묶음 줄 있는 항목 · 항이 넷 넘으면 항목 소계 — 여기는 금액만). +""" + +from __future__ import annotations + +import re +from decimal import ROUND_FLOOR, ROUND_HALF_UP, Decimal, InvalidOperation + +import master_doc as md +import master_doc_calc as mc + +COSTS = md.COSTS # 노무비 · 재료비 · 경비 +COST_SHOW = {"노무비": "노무비", "재료비": "재료비", "경비": "경 비"} +AMOUNT_UNIT = "원" +LONG_SUM = 4 +_HIDE = ("반올림", "올림", "버림") +_SAME = (("일", "인"), ("㎏", "kg"), ("ℓ", "L")) + + +# ── 수 꼴 ───────────────────────────────────────────────────────────── +def _dec(v) -> Decimal | None: + if isinstance(v, bool) or v is None: + return None + try: + d = Decimal(str(v)) if not isinstance(v, Decimal) else v + except InvalidOperation: + return None + return d if d.is_finite() else None + + +def _group(d: Decimal, places: int, keep: bool) -> str: + q = d.quantize(Decimal(1).scaleb(-places), ROUND_HALF_UP) + sign = "-" if q.is_signed() else "" # Intl 과 같음 — 0 으로 반올림된 음수 = 「-0」 + whole, _, frac = f"{abs(q):f}".partition(".") + frac = frac if keep else frac.rstrip("0") + head = f"{int(whole):,}" + return f"{sign}{head}.{frac}" if frac else f"{sign}{head}" + + +def eq_text(v) -> str: + """`eqText` — 수 = 천 단위 쉼표 · 소수 여섯 자리까지(반올림 · 끝 0 뗌) · 그 밖 = 글 그대로.""" + if v is None or v == "": + return "" + if isinstance(v, bool): + return "true" if v else "false" + d = _dec(v) + if d is None or (isinstance(v, str) and not v.strip()): + return str(v) + return _group(d, 6, False) + + +def one(v) -> str: + """줄 금액 — 소수 한 자리 꼭(「26,890.8」 · 「0.0」).""" + return _group(_dec(v) or Decimal(0), 1, True) + + +def won(v) -> str: + """비목 · 합계 — 원(JS `Math.round` = 0.5 올림).""" + d = _dec(v) or Decimal(0) + r = (d + Decimal("0.5")).to_integral_value(ROUND_FLOOR) + return eq_text(Decimal("-0") if r == 0 and d.is_signed() else r) # JS Math.round(-0.4) = -0 + + +# ── 단위 ───────────────────────────────────────────────────────────── +def unit_text(u) -> str: + """자료 단위 글 → 화면 단위(메타 단위 = 빈 글).""" + s = str(u if u is not None else "").strip() + if not s or re.search(r"따름|원문 단위 없음", s) or re.match(r"^수(\(| 또는|$)", s): + return "" + s = re.sub(r"^%\(.*\)$", "%", s) + return s.replace("10^-7", "10⁻⁷").replace("kWh", "㎾h") + + +def _same(a: str, b: str) -> bool: + return a == b or any((a == x and b == y) or (a == y and b == x) for x, y in _SAME) + + +def is_atom(n) -> bool: + """한 덩이(기호 · 수 · 칸 · 글 — 반올림 · 올림 · 버림 감싸개 안 한 덩이 포함).""" + if not n: + return False + if n[0] == "call" and n[1] in _HIDE and 1 <= len(n[2]) <= 2: + return is_atom(n[2][0]) + return n[0] in ("var", "num", "field", "str") + + +def node_of(text): + if text is None or str(text).strip() == "": + return None + try: + return md.parse(text) + except md.DocError: + return None + + +def money_units( + line: dict, price, qty, price_var: dict | None = None, sub: dict | None = None +) -> dict: + """금액 줄 단위 자리 `{price, qty, wrap}` — 수량이 식이면 괄호 · + 단가 분모가 수량 단위와 같은 뜻이면 수량 단위 글.""" + has = line.get("수량") not in (None, "") + q = unit_text(line.get("단위")) if has else "" + wrap = bool(q) and bool(qty) and not is_atom(qty) + own = next( + ( + u + for u in ( + unit_text((sub or {}).get("결과단위")), + unit_text((price_var or {}).get("단위")), + ) + if u.startswith("원") + ), # fmt: skip + None, + ) + mine = f"{AMOUNT_UNIT}/{q}" if own and q and _same(own[2:], q) else own + fallback = f"{AMOUNT_UNIT}/{q}" if q else "" + price_unit = (mine if mine is not None else fallback) if has and is_atom(price) else "" + return {"price": price_unit, "qty": q, "wrap": wrap} + + +def price_sym(line: dict) -> str | None: + n = node_of(line.get("단가")) + if not n: + return None + if n[0] == "var": + return n[1] + if n[0] == "field" and n[1][0] == "var": + return n[1][1] + return None + + +def line_name(line: dict) -> str: + """이름에 규격이 들면 한 번만(814-1).""" + name, spec = str(line.get("이름") or ""), line.get("규격") + return f"{name} {spec}".strip() if spec and spec not in name else name + + +# ── 선택으로 꺼진 줄(`offLine`) ─────────────────────────────────────── +class _Look: + """셈 답 값으로 조건만 읽음 — 계산기 한 벌(`master_doc_calc._Run.ev`) · 값은 답에서 채움.""" + + def __init__(self, doc: dict, answer: dict, links): + self.run = mc._Run(doc, links, None, (), {}) + got = answer.get("값") or {} + names = {md.var_id(v) for v in doc.get("변수") or []} + names |= {str(x.get("기호") or "") for x in doc.get("식") or []} + for name in names: # 답에 없는 값 = 모름(다시 셈하지 않음 · 화면 `evalNode` 와 같음) + have = got.get(name) + self.run.values[name] = mc.Blank("모름") if have is None else have + self.lines = {str(x.get("기호") or ""): x.get("식") for x in doc.get("식") or []} + + def value(self, n): + try: + v = self.run.ev(n, None, "") + except Exception: # noqa: BLE001 — 그림용 값 · 모르면 없음 + return None + return None if isinstance(v, (mc.Blank, mc.Stop)) else v + + def taken(self, n) -> int: + if not (n and n[0] == "call" and n[1] == "만약" and len(n[2]) == 3): + return 0 + t = self.value(n[2][0]) + return 0 if t is None else (1 if t else 2) + + def off_zero(self, n, path: frozenset = frozenset()) -> bool: + if not n: + return False + at, hop = n, 0 + while pick := self.taken(at): + at, hop = at[2][pick], hop + 1 + if hop and at[0] == "num": + return at[1] == 0 + kind = at[0] + if kind == "var": + name = at[1] + if name not in self.lines or name in path: + return False + return self.off_zero(node_of(self.lines[name]), path | {name}) + if kind in ("neg", "pct"): + return self.off_zero(at[1], path) + if kind == "bin": + if at[1] == "*": + return self.off_zero(at[2], path) or self.off_zero(at[3], path) + if at[1] == "/": + return self.off_zero(at[2], path) + if at[1] in ("+", "-"): + return self.off_zero(at[2], path) and self.off_zero(at[3], path) + return False + + def off_line(self, line: dict) -> bool: + return any(self.off_zero(node_of(line.get(k))) for k in ("수량", "단가")) + + +# ── 줄 글 ──────────────────────────────────────────────────────────── +def _num(v) -> Decimal | None: + return _dec(v) + + +def _u(text: str, unit: str) -> str: + return f"{text} {unit}" if unit else text + + +def money_lines(doc: dict, answer: dict, links) -> list[dict]: + """금액 줄마다 산출근거 조각 `{i, 이름, 비목, 단가, 수량, 금액, 단위, 글, 꺼짐, 합밖, 까닭?}` · + 묶음 줄 = 비목마다 한 조각(`비목` = 노무비 · 재료비 · 경비 · `묶음줄` 참).""" + look = _Look(doc, answer, links) + vars_ = {md.var_id(v): v for v in doc.get("변수") or []} + rows = answer.get("줄") or [] + out: list[dict] = [] + for i, line in enumerate(doc.get("금액") or []): + got = rows[i] if i < len(rows) else {} + name = line_name(line) + ps = price_sym(line) + pv = vars_.get(ps) if ps else None + link = (pv or {}).get("연결") or {} + sub = None + if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]): + try: + sub = links.doc(str(link["키"])) + except Exception: # noqa: BLE001 — 못 읽는 부름 = 단위 없이 + sub = None + mu = money_units(line, node_of(line.get("단가")), node_of(line.get("수량")), pv, sub) + qty = got.get("수량") + base = { + "i": i, + "이름": name, + "수량": _num(qty), + "단위": mu, + "꺼짐": look.off_line(line), + "합밖": bool(got.get("합밖")), + "묶음": line.get("묶음") or "", + } + tail = "" if qty is None else " × " + _u(eq_text(qty), mu["qty"]) + if got.get("까닭") and got.get("금액") is None: + why = got["까닭"] + out.append({**base, "비목": line.get("비목"), "단가": None, "금액": None, "까닭": why, + "글": f"{name} : — {why}"}) # fmt: skip + continue + if line.get("비목") == "묶음": + bundle = got.get("단가") if isinstance(got.get("단가"), dict) else {} + for c in COSTS: + part = (got.get("비목") or {}).get(c) + if _dec(part) is None or (not part and not bundle.get(c)): + continue + price = _u(eq_text(bundle.get(c)), mu["price"]) + text = f"{COST_SHOW[c]} : {price}{tail} = {one(part)} {AMOUNT_UNIT}" + out.append({**base, "비목": c, "묶음줄": True, "단가": _num(bundle.get(c)), + "금액": _num(part), "글": text}) # fmt: skip + continue + amt, price = got.get("금액"), got.get("단가") + text = f"{name} : {_u(eq_text(price), mu['price'])}{tail} = {one(amt or 0)} {AMOUNT_UNIT}" + out.append({**base, "비목": line.get("비목"), "단가": _num(price), "금액": _num(amt), + "글": text}) # fmt: skip + return out + + +def total_lines(answer: dict, lines: list[dict]) -> list[str]: + """계 줄 — 비목마다 「노무비 : 줄 + 줄 = 금액 원」(항이 넷 넘으면 금액만) · + 「합계 : 금액 원」.""" + out = [] + for c in COSTS: + terms = [ + x["금액"] + for x in lines + if x.get("비목") == c and not x["합밖"] and not x["꺼짐"] and x.get("금액") + ] + v = answer.get(c) + if _dec(v) is None: + body = "—" + elif 1 < len(terms) <= LONG_SUM: + body = f"{' + '.join(one(t) for t in terms)} = {won(v)}" + else: + body = won(v) if terms or v else "" + unit = f" {AMOUNT_UNIT}" if _dec(v) is not None and body else "" + out.append(f"{COST_SHOW[c]} : {body}{unit}") + total = answer.get("계") + out.append(f"합계 : {_u(won(total), AMOUNT_UNIT) if _dec(total) is not None else '—'}") + return out + + +def sheet_groups(doc: dict, answer: dict, links) -> list[dict]: + """공용 계산서(`A00_Common/calc_sheet.ts`) 묶음 — 비목마다 줄 + `{이름, 글 「단가 * 수량 = 금액」, 금액, 묶음, 장비, 옵션꺼짐}` · + 소계 = 셈 답 비목 값(끝수 뒤) · + 합 밖 줄 · 비목 없는 줄 = 뺌.""" + groups: dict[str, list] = {c: [] for c in COSTS} + for x in money_lines(doc, answer, links): + c = x.get("비목") + if c not in groups or x["합밖"]: + continue + mu = x["단위"] + if x.get("까닭"): + text = f"— {x['까닭']}" + else: + price = "—" if x["단가"] is None else _u(eq_text(x["단가"]), mu["price"]) + qty = "" if x["수량"] is None else " * " + _u(eq_text(x["수량"]), mu["qty"]) + text = f"{price}{qty} = {one(x['금액'] or 0)}" + groups[c].append( + { + "이름": x["이름"], + "글": text, + "금액": x["금액"], + "묶음": x["묶음"] or None, + "장비": bool(x.get("묶음줄")) or None, + "옵션꺼짐": x["꺼짐"] or None, + } + ) + return [ + {"비목": c, "소계": _num(answer.get(c)), "끝수": "", "줄": groups[c]} + for c in COSTS + if groups[c] or _dec(answer.get(c)) + ] diff --git a/resources/master_data/scripts/master_doc_trace.py b/resources/master_data/scripts/master_doc_trace.py new file mode 100644 index 000000000..07e0278b1 --- /dev/null +++ b/resources/master_data/scripts/master_doc_trace.py @@ -0,0 +1,175 @@ +# -*- coding: utf-8 -*- +"""수식 문서 셈 기록 — 줄마다 부른 것(PLAN 855-F B9-1 · 설계 855 보충 1-3). + +서버 단독(TS 짝 없음) — B08 · B09 가 문서 셈 답을 갈라 합산할 때 「이 줄이 어느 노임 · 자재 · +기계 · 표 · 하위 단가산출을 불렀나」 를 읽음. 셈은 그대로: `Trace` = `master_doc_link.Links` + +기록 · `master_doc_calc` 의 훅(`links.at`)이 연결마다 알림 — `Links` 에는 `at` 이 없어 기록을 안 +켜면 지금 길 그대로. + +`calc(doc, Trace(master, docs), given)` → 셈 답 + +- `부름` = 연결 부른 차례 [{문서, 깊이, 이름, 갈래(요소 · 표 · 단가산출), 부름(넘긴 꼴 — 키 · 표 · + 조건 · 입력 · 재료 …), 자원[{키, 갈래(인력 · 재료 · 기계 · 표)}], 품목?(고른 재료 키) · + 기계?(기계경비 부름 = 결과단위 원/시간 돈 문서의 기계 키)}] — + 하위 문서 안 부름도 깊이를 달고 같이(같은 하위 · 같은 입력 두 번째는 셈 답을 다시 씀 = 안 적음) +- `줄[i].부름` = 그 금액 줄 식(수량 · 단가 · 비목곱)이 닿는 이름의 맨 위 부름 차례 번호 + 그 줄 + 셈 중 읽음(갈래 「금액」 · 이름 = 줄 차례 · 시간당 작업량 기계 칸) +- `자원` = 문서 전체(하위 포함) 자원 키 차례 · 겹침 없음(표 빼고 · 단가 책 수요) +""" + +from __future__ import annotations + +import inspect +import re +import types +from itertools import takewhile + +import master_doc as md +import master_doc_calc as mc +import master_doc_link as ml + +CAT = {"LB": "인력", "MT": "재료", "MO": "재료", "EQ": "기계"} # `master_equation_view.CAT` 같은 말 +_SLOTS = ("키", "표", "칸", "단위", "재료", "조건", "입력", "지역", "계약종별") + + +class _Seen: + """마스터 감쌈 — `get` 이 돌려준 줄을 알림 · + 마스터 메서드도 이 감쌈에 묶어 안쪽 `self.get` 까지 잡음.""" + + def __init__(self, master, note): + self._m, self._note = master, note + + def get(self, ref): + row = self._m.get(ref) + self._note(row) + return row + + def __setattr__(self, name, value): # 마스터 칸(찾기 색인 `_found` 등)은 마스터에 + if name in ("_m", "_note"): + object.__setattr__(self, name, value) + else: + setattr(self._m, name, value) + + def __getattr__(self, name): + raw = inspect.getattr_static(self._m, name) + if isinstance(raw, types.FunctionType): + return raw.__get__(self) + return getattr(self._m, name) + + +class Trace(ml.Links): + """기록 켠 연결 — `calls` 에 부른 차례대로 쌓임(여러 문서 셈에 다시 써도 됨).""" + + def __init__(self, master, docs: dict[str, dict] | None = None): + super().__init__(_Seen(master, self._note), docs) + self.calls: list[dict] = [] + self._now: dict | None = None + self._last: str | None = None + + def at( + self, stack: tuple, name, kind: str, payload: dict + ) -> None: # 셈 훅(이름 | 금액 줄 차례) + self._now = { + "문서": stack[-1] if stack else "", + "깊이": len(stack), + "이름": name, + "갈래": kind, + "부름": {k: payload[k] for k in _SLOTS if k in payload}, + "자원": [], + } + self.calls.append(self._now) + + def _note(self, row: dict) -> None: + key = self._last = str(row.get("키") or "") + kind = CAT.get(key[:2]) or ("표" if "줄" in row and "조건" in row else None) + if not kind: + return + if self._now is None: # 연결 밖 부름(이름 없는 기계 줄 읽기) — 이름 빈 기록 + self.at((), "", "", {}) + got = self._now["자원"] + if not any(x["키"] == key for x in got): + got.append({"키": key, "갈래": kind}) + + def element(self, p: dict): + if p.get("재료") is None or self._now is None: + return super().element(p) + got, before, self._last = self._now["자원"], len(self._now["자원"]), None + try: + return super().element(p) + finally: # 재료 찾기 = 고른 품목 하나 — 찾을 때 훑은 후보 · 색인 짓기 읽음은 뺌 + del got[before:] + if self._last and CAT.get(self._last[:2]) == "재료": # 마지막 읽음 = 고른 품목 + self._now["품목"] = self._last # (`mp.priced` 출처 · 값 없음 = 그 이름 글 읽음) + if not any(x["키"] == self._last for x in got): + got.append({"키": self._last, "갈래": "재료"}) + + +def _names(text) -> list[str]: + if text in (None, ""): + return [] + try: + return md.names(md.parse(str(text))) + except md.DocError: + return [] + + +def reach(doc: dict, texts: list) -> set[str]: + """식 글들이 닿는 이름 전부 — 식 줄 · 연결 구멍(`{이름}`) · 조건 · 입력 식 · 지역 칸을 + 따라감.""" + vars_ = {md.var_id(v): v for v in doc.get("변수") or []} + lines = {str(x.get("기호") or ""): x for x in doc.get("식") or []} + todo = [n for t in texts for n in _names(t)] + seen: set[str] = set() + while todo: + name = todo.pop() + if name in seen: + continue + seen.add(name) + if name in lines: + todo += _names(lines[name].get("식")) + link = (vars_.get(name) or {}).get("연결") or {} + for k in ("키", "표"): + todo += md.HOLE.findall(str(link.get(k) or "")) + for v in (link.get("재료") or {}).values() if isinstance(link.get("재료"), dict) else (): + todo += md.HOLE.findall(str(v)) + for k in ("조건", "입력"): + for v in (link.get(k) or {}).values() if isinstance(link.get(k), dict) else (): + todo += _names(v) + todo += [str(link[k]) for k in ("지역", "계약종별") if link.get(k)] + return seen + + +def _machines(trace: Trace, calls: list[dict]) -> None: + """기계경비 부름(결과단위 원/시간 돈 문서 · `master_bundle.is_machine` 같은 판별)에 「기계」 = + 그 부름 안에서 처음 읽은 기계 키(옛 `B09 call_of` 의 machine) · 같은 부름 두 번째 = 앞 답.""" + seen: dict[str, str | None] = {} + for i, c in enumerate(calls): + doc = trace.doc(str(c["부름"].get("키"))) if c["갈래"] == "단가산출" else None + unit = re.sub(r"\s", "", str((doc or {}).get("결과단위") or "")) + if not doc or doc.get("결과") or unit != "원/시간": + continue + tag = repr((c["부름"].get("키"), sorted((c["부름"].get("입력") or {}).items()))) + inner = [c, *takewhile(lambda x: x["깊이"] > c["깊이"], calls[i + 1 :])] + got = [x["키"] for one in inner for x in one["자원"] if x["갈래"] == "기계"] + c["기계"] = seen[tag] = got[0] if got else seen.get(tag) + + +def calc(doc: dict, trace: Trace, given: dict | None = None, cover: dict | None = None) -> dict: + """문서 셈(`master_doc_calc.calc` 그대로) + 기록 — 모듈 머리 꼴.""" + start = len(trace.calls) + trace._now = None + got = mc.calc(doc, trace, given, cover=cover) + calls = [c for c in trace.calls[start:] if c["갈래"] != "금액" or c["자원"]] # 빈 줄 읽음 뺌 + top = 1 if doc.get("키") else 0 + for i, (line, out) in enumerate(zip(doc.get("금액") or [], got.get("줄") or [])): + texts = [line.get("수량"), line.get("단가"), *(line.get(mc.TIMES) or {}).values()] + names = reach(doc, texts) | {i} # 이 줄 읽음(갈래 「금액」 · 이름 = 줄 차례) + out["부름"] = [ + j + for j, c in enumerate(calls) + if c["깊이"] == top and c["이름"] in names and (c["갈래"] == "금액") == (c["이름"] == i) + ] + _machines(trace, calls) + keys: list[str] = [] + for c in calls: + keys += [x["키"] for x in c["자원"] if x["갈래"] != "표" and x["키"] not in keys] + return {**got, "부름": calls, "자원": keys} diff --git a/resources/master_data/scripts/master_keys.py b/resources/master_data/scripts/master_keys.py index f8511f70b..e0c205ee6 100644 --- a/resources/master_data/scripts/master_keys.py +++ b/resources/master_data/scripts/master_keys.py @@ -7,6 +7,7 @@ from __future__ import annotations import json +import os import re from decimal import Decimal from pathlib import Path @@ -77,7 +78,9 @@ def save_book(book: dict, path: Path = BOOK) -> None: comma = "," if i < len(items) - 1 else "" lines.append(f" {json.dumps(key)}: {json.dumps(v, ensure_ascii=False)}{comma}") lines += [" }", "}"] - path.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n") + tmp = path.with_name(f".{path.name}.tmp") # 임시 파일 → 교체(원자적 · 끊겨도 반쪽 대장 없음) + tmp.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n") + os.replace(tmp, path) def lookup(book: dict) -> dict: diff --git a/resources/tester/golden_855_b09.json b/resources/tester/golden_855_b09.json new file mode 100644 index 000000000..b811ea2e8 --- /dev/null +++ b/resources/tester/golden_855_b09.json @@ -0,0 +1,20 @@ +{ + "판": 1, + "지문": { + "키": "e68369418202e5ee", + "calc_user": "6d74551273d6735f", + "daega_inputs": "0ef81c80bc45ae0b", + "수요": "f793204cf95c45c4", + "산근 값": "c486d041a3246ffb", + "산근 글": "a21b34ec13661f0c", + "산근 관급 값": "c5c3daf85d9bd01b", + "산근 관급 글": "a65b945fc8582ca3", + "미리보기 hand:rate 값": "091690571b7dc54b", + "미리보기 hand:rate 글": "c49b1bc692d59fe5", + "미리보기 hand:pick 값": "6c7f426d37e31998", + "미리보기 hand:pick 글": "96a9de9a02e3d124", + "미리보기 hand:net 값": "b1c2c650567a14ae", + "미리보기 hand:net 글": "be7884bdbeb29ed3", + "B08 단위수량": "896710398b04b4fd" + } +} diff --git a/resources/tester/golden_855_engine.json b/resources/tester/golden_855_engine.json new file mode 100644 index 000000000..eda1f7eb3 --- /dev/null +++ b/resources/tester/golden_855_engine.json @@ -0,0 +1,1526 @@ +{ + "판": 1, + "지문": { + "GC000001": "7668cb27f4257ba3", + "GC000002": "2bff277c6b2c6b75", + "GC000003": "be53e60464a18a08", + "GC000004": "30ad72a73f9ed7c8", + "GC000005": "f64f19781ecefdbe", + "GC000006": "58dd823ed0b4ac26", + "GC000007": "b5a8656070d7c489", + "GC000008": "1ce9d4760cd2222a", + "GC000009": "54fe5b1297aba396", + "GC000010": "218d082ef7a022b3", + "GC000011": "e8656df79b0a42eb", + "GC000012": "c77f6b59a0f01107", + "GC000013": "19d3b025337a026b", + "GC000014": "e00f0261036c07ab", + "GC000015": "dc32b92a53c959bd", + "GC000016": "8f7356e1316fac5e", + "GC000017": "56e83c37b775e7f9", + "GC000018": "8f7356e1316fac5e", + "GC000019": "5f10a82dedfc0753", + "GC000020": "af7ac3471af99254", + "GC000021": "02580e786f381fec", + "GC000022": "057f5fb799b23617", + "GC000023": "3e870c1a3a860774", + "GC000024": "e749b257555c0858", + "GC000025": "56e327bf3883ee69", + "GC000026": "4a0c18fd0b060511", + "GC000027": "ce7c628e4985ce54", + "GC000028": "ddaaf4e98e48fe89", + "GC000029": "0bcf8fc56ff72e17", + "GC000030": "fe53d3c5be000fea", + "GC000031": "eec307d81fc0e579", + "GC000032": "4ab2717a823a503e", + "GC000033": "869e3dcef49d00a4", + "GC000034": "d00217cbe34cbe48", + "GC000035": "ff1559143bc476e9", + "GC000036": "35fdfd61d1fe1779", + "GC000037": "2bebb481e471b97f", + "GC000038": "cf17119754a873c2", + "GC000039": "042608faaabdebab", + "GC000040": "9fdcbe64635af6a8", + "GC000041": "0b0af50d25347c24", + "GC000042": "af2a53c68a941986", + "GC000043": "333bdf09111669eb", + "GC000044": "a7a9a4c0d23e84ce", + "GC000045": "ec21c62469444f09", + "GC000046": "350d8def18179512", + "GC000047": "db5cc08edb175403", + "GC000048": "a231ca530d2e9eb1", + "GC000049": "1f99b7be4163ebef", + "GC000050": "3e6890bd47c5beee", + "GC000051": "479c00f67a5954c5", + "GC000052": "b6214336896cd50e", + "GC000053": "32d45ba23298e8e6", + "GC000054": "2e433953161b6247", + "GC000055": "d34e5c4ad37d175e", + "GC000056": "7c3bc2fd6f7db503", + "GC000057": "4e75f7d977d4b4af", + "GC000058": "681abfd1e3b906b3", + "GC000059": "681abfd1e3b906b3", + "GC000060": "7b092e8c949a572d", + "GC000061": "42951d83847f526a", + "GC000062": "8bf4d85f5f2bfb63", + "GC000063": "2c3ceb16fd842b72", + "GC000064": "8dd29715a12bbb7b", + "GC000065": "1c8619ba861b2164", + "GC000066": "c7a3fb47c26bb511", + "GC000067": "3930b3028464f516", + "GC000068": "1df1237c49f4cae8", + "GC000069": "36702e85d90e348d", + "GC000070": "22d5488bf0596041", + "GC000071": "c5461ad4791782da", + "GC000072": "0b0d08e79baa4da0", + "GC000073": "305b9f98815418ef", + "GC000074": "a171f068787c1c46", + "GC000075": "216eece7cb9e26b0", + "GC000076": "e33adfc8e1536b6d", + "GC000077": "9f4c46ba26264450", + "GC000078": "88b7fbe77d736d85", + "GC000079": "83d2941ddb03c59b", + "GC000080": "0b5adc6b35ba4c41", + "GC000081": "460f16a1a50f3e2a", + "GC000082": "9b91e97a106fc812", + "GC000083": "2cf319ce34009bcf", + "GC000084": "6719f35187514ea4", + "GC000085": "62da652b38d45159", + "GC000086": "a396521f34d0b23c", + "GC000087": "376481e663e0fe00", + "GC000088": "1ce6dbd35ee35279", + "GC000089": "9252ac2ca6a93a35", + "GC000090": "79d02d499e326d7a", + "GC000091": "a8430e047906f7e7", + "GC000092": "7d301e65ebafd412", + "GC000093": "da27a5ea6dfc764c", + "GC000094": "1108003107407565", + "GC000095": "0303ba6474cbde2c", + "GC000096": "dd32d308461003e0", + "GC000097": "3ffaeebf07de2362", + "GC000098": "8e9a11f572fd0c12", + "GC000099": "6c378d03508de7e9", + "GC000100": "3b450e029042486f", + "GC000101": "329a929667ba4694", + "GC000102": "f1519d0faa60ba72", + "GC000103": "a68cf9a73ba4b7b4", + "GC000104": "c63972dc1c0c4197", + "GC000105": "3fb80a854526097e", + "GC000106": "43f24fc293ab7902", + "GC000107": "22323ca3c5dbc3d1", + "GC000108": "7a9464b480365204", + "GC000109": "3b932460d4dd6857", + "GC000110": "6b13163c22436e36", + "GC000111": "a971125f812af0e6", + "GC000112": "9aa7ed694ba48890", + "GC000113": "d0ddf0a097062217", + "GC000114": "b39bda73d65845ba", + "GC000115": "7fc1b9c0c50a9ef2", + "GC000116": "c9239dd689e1b89c", + "GC000117": "817643177c70bb6a", + "GC000118": "e9f1253d0778fdf9", + "GC000119": "907b1a2a55ae1adb", + "GC000120": "073e203371de6b04", + "GC000121": "0538edccdb5d5647", + "GC000122": "1e7f348c09379ea3", + "GC000123": "b29906faf5836dbb", + "GC000124": "bcad2e02a0c4211f", + "GC000125": "8b9a9ea8d71bf981", + "GC000126": "77a6f587474cd1a5", + "GC000127": "e9b59685ca45e8a5", + "GC000128": "35500110a7430c80", + "GC000129": "0160a8e5778a2202", + "GC000130": "08785faeef912d27", + "GC000131": "2523bd73ff7b9288", + "GC000132": "e8518c2dfe049da5", + "GC000133": "2a283747e8f215de", + "GC000134": "e8518c2dfe049da5", + "GC000135": "2a283747e8f215de", + "GC000136": "b945dcece3d256d7", + "GC000137": "739ab15d4b6f11de", + "GC000138": "3f7fe7307747d642", + "GC000139": "8d55f05fec5a3aad", + "GC000140": "cde560f441d66406", + "GC000141": "de59966724f80967", + "GC000142": "9441d6e425b21ab0", + "GC000143": "152b7b126dcb320c", + "GC000144": "fc6c01e54bdf391b", + "GC000145": "cb4bb2aeb99b5999", + "GC000146": "016db242ebeb794f", + "GC000147": "239dd28801f2c19e", + "GC000148": "83789266edce600b", + "GC000149": "00a57a75f18bac9c", + "GC000150": "814c6888158d97e4", + "GC000151": "b5cd3aa3c6af28f2", + "GC000152": "5395d3e0fc3413c7", + "GC000153": "2a2267631875210b", + "GC000154": "5ab4f0b8d95febf4", + "GC000155": "31fafab1c84022f6", + "GC000156": "b7d0e483506acc00", + "GC000157": "a326e41ffbadea7b", + "GC000158": "d71d0fa56940d7ae", + "GC000159": "834540736e58e57e", + "GC000160": "816e0786d8d30010", + "GC000161": "1207209a86e047e7", + "GC000162": "171434c2317c9b54", + "GC000163": "1da6fb579048eac0", + "GC000164": "0779c30ca1aeab34", + "GC000165": "565f33f5b0d9ebb3", + "GC000166": "5d6ccc68fcb8932f", + "GC000167": "e8c67d2492db4550", + "GC000168": "dfe0b8b87b641ca6", + "GC000169": "6a207e509583b3aa", + "GC000170": "7768bcb205adb881", + "GC000171": "af7a71cd77223374", + "GC000172": "0c2dd9b71835ec9e", + "GC000173": "f35e04c448155165", + "GC000174": "5a6b4168788e8850", + "GC000175": "9bf920be12b6b4e8", + "GC000176": "dfb964e984b4e8cc", + "GC000177": "47336872e12123c3", + "GC000178": "991ea0b03c2c05db", + "GC000179": "176eadfde9bd44cc", + "GC000180": "52469e8a06d27b1f", + "GC000181": "13e52b9848be7000", + "GC000182": "97fd6a96e729e38d", + "GC000183": "a2591f98def54985", + "GC000184": "dab3c3960298a5d0", + "GC000185": "c68a748764d2fb4f", + "GC000186": "614afc8823290476", + "GC000187": "6fdbc3f02d88de59", + "GC000188": "4c732de52a987455", + "GC000189": "ef44b267e0043bfa", + "GC000190": "e2b223fea9134a34", + "GC000191": "f83b96fccc8bc2bf", + "GC000192": "ab43dbfdb004f378", + "GC000193": "0c81b9be9d3c1e49", + "GC000194": "614afc8823290476", + "GC000195": "e8c7f9e52d6926d5", + "GC000196": "dd55a05c33c81378", + "GC000197": "106c999ac312407b", + "GC000198": "a616aa21e678f4f9", + "GC000199": "490fc27fb87f3654", + "GC000200": "8a6aa53c4f183242", + "GC000201": "915ae6f25a8931d1", + "GC000202": "08794e48f6016fc6", + "GC000203": "035db34fa954b63b", + "GC000204": "a976f0f6ec0d6e7d", + "GC000205": "040c8154fbe2c187", + "GC000206": "af634c08f29dc85c", + "GC000207": "ce15954d6bce38c9", + "GC000208": "e63e48c689669d5e", + "GC000209": "ad9af83d08c7a473", + "GC000210": "eca549e43315549f", + "GC000211": "5633ab2e79e1355b", + "GC000212": "68a09199609ab821", + "GC000213": "5d2008d98597bd01", + "GC000214": "0a2b07adbbdc35fb", + "GC000215": "2c450520f9964c30", + "GC000216": "562a3f3ddd830a0c", + "GC000217": "c18e1801c149f842", + "GC000218": "1054a09b4b1d71a3", + "GC000219": "45409808a95e5fac", + "GC000220": "a316f0b8358cf6e1", + "GC000221": "68d5d0b1c83eacc0", + "GC000222": "a50cf7c788357e15", + "GC000223": "b012b58e2a7b3329", + "GC000224": "b1711b74eed80dd4", + "GC000225": "a3e01906ae3a8300", + "GC000226": "143f8769167172b2", + "GC000227": "63f924067c3d294f", + "GC000228": "449e56b67f91b1b0", + "GC000229": "4f7a5f792b2fd61b", + "GC000230": "bf3b5e968de87225", + "GC000231": "f22faeed576d66a7", + "GC000232": "5d8d107580c014fd", + "GC000233": "0b8a4cdbf7032b54", + "GC000234": "c268e58c7908829c", + "GC000235": "3913427c4649ab86", + "GC000236": "62edaa9ac74dea3f", + "GC000237": "26df410acfad5098", + "GC000238": "44e23b400b981faf", + "GC000239": "7a289d0b85b4436b", + "GC000240": "ff62f41c2ca3115e", + "GC000241": "99d4aaf455fd0b30", + "GC000242": "70f5c24c3d71b3ec", + "GC000243": "001cd10a8fe7d2b9", + "GC000244": "6f93231855805fe3", + "GC000245": "ef08c6289eea08e1", + "GC000246": "bc072da57f7ebaf6", + "GC000247": "d4228244b4603330", + "GC000248": "af629268dff54800", + "GC000249": "503ec3adf0425cee", + "GC000250": "b93c87ed39f4d0df", + "GC000251": "85a8254ef8c6e521", + "GC000252": "1330ed61a826bd5b", + "GC000253": "b447d91e4dfacf35", + "GC000254": "3b145710a3d99aa6", + "GC000255": "a3e65a65634e1a77", + "GC000256": "02c2b03e68e6fb7a", + "GC000257": "cf84beb76e7f1d41", + "GC000258": "7a890fd5cb2d182b", + "GC000259": "c146cb0d30fc6d8c", + "GC000260": "ae7e5fe10bcf0c21", + "GC000261": "6775b2d2f9a3cc77", + "GC000262": "026a09f3cbc1a96f", + "GC000263": "4d13d387fa99eeed", + "GC000264": "578ab88e198a355b", + "GC000265": "f5c9235b25924220", + "GC000266": "dc6d2a3def556d9a", + "GC000267": "a8aa14b8ca482bcc", + "GC000268": "39563737c19979fc", + "GC000269": "22f8b5ad1ee1dcd5", + "GC000270": "92ccaea47eb1b818", + "GC000271": "a9db0bb065003807", + "GC000272": "26c90a1b51574bbb", + "GC000273": "91c3f2c432712166", + "GC000274": "7b91cb515ef3ee59", + "GC000275": "c67d366803dfe2d0", + "GC000276": "ddd6f5ab3fde81c4", + "GC000277": "592a375749b7cb08", + "GC000278": "30c313f2568afc34", + "GC000279": "b717aab63021472d", + "GC000280": "45a77c999c7e9ff0", + "GC000281": "397bc2a910fd05c4", + "GC000282": "4d18153218ddf574", + "GC000283": "ffaaef2dab66c592", + "GC000284": "d87edb7fe04219a1", + "GC000285": "cbaf846d290e3d84", + "GC000286": "9cd5381018d68d6a", + "GC000287": "a0c1e4e5bc09c0ac", + "GC000288": "c380bb0281ba9068", + "GC000289": "b1e0c2dbc9b2b057", + "GC000290": "a49e72e7a9efabe7", + "GC000291": "dc1d4d5c49cad894", + "GC000292": "5ac93e860722245e", + "GC000293": "493696569faadfc2", + "GC000294": "f6e74be0fedb7f67", + "GC000295": "32414e3934e3c6a7", + "GC000296": "95d80c31acac68d2", + "GC000297": "3974fa2179b08526", + "GC000298": "fc4a4ff72cfe6ee5", + "GC000299": "257b9af8cfa0d994", + "GC000300": "1167554684a053c3", + "GC000301": "3b91dc274383f232", + "GC000302": "0db1610e26a19d8a", + "GC000303": "de01bdc3a46e7cd9", + "GC000304": "ff8498b88b5acf94", + "GC000305": "d4db816aa7e51081", + "GC000306": "d09ba071f51ec522", + "GC000307": "f61e947a96dfdac8", + "GC000308": "1af9a5dd86f0cb75", + "GC000309": "cd9f2016a51b3fe2", + "GC000310": "033a61acc64a03b5", + "GC000311": "b8ed109508f8ec01", + "GC000312": "736f2aeca1cd6878", + "GC000313": "4075f84cbd7b3999", + "GC000314": "b739d9890041b9cf", + "GC000315": "6138c880c3737964", + "GC000316": "7d673f2666593a2f", + "GC000317": "3902f1769546a395", + "GC000318": "149a60e5310675d8", + "GC000319": "4727529e3a6ada3e", + "GC000320": "3fe9ab6a14852bbb", + "GC000321": "c953ef3d1c61951c", + "GC000322": "804f2ea385ddfb24", + "GC000323": "3d5d0ad3465bed45", + "GC000324": "af6e587bdd8865a2", + "GC000325": "83e28e076d2f6cc3", + "GC000326": "ffb1ec900144636f", + "GC000327": "4437c1eadca442f2", + "GC000328": "0d7256783a3a54a8", + "GC000329": "56de8e34f4641146", + "GC000330": "f9e6bedfe39ea62f", + "GC000331": "499467ad1d669a47", + "GC000332": "e1d95871eb7ef9ae", + "GC000333": "6e91eb6587f221b1", + "GC000334": "5dbfa2ad4b52978f", + "GC000335": "a081c99a18cf8219", + "GC000336": "65fb30065cac36f4", + "GC000337": "c1e1a3c52d3fc415", + "GC000338": "786abe47f875ea74", + "GC000339": "7a3888ff8b254d91", + "GC000340": "f31a667901f64d50", + "GC000341": "4623d7786e56f523", + "GC000342": "1ab6d205d6dda513", + "GC000343": "b872c6b0ad15a3f4", + "GC000344": "5ca0d6fcd7714b3e", + "GC000345": "083813776c5a2547", + "GC000346": "8315dab034d0f80e", + "GC000347": "4e813d9d19285eb9", + "GC000348": "e20600a0db20ea90", + "GC000349": "cf092c24b3956bbb", + "GC000350": "187fd2fed776ddae", + "GC000351": "cad4a76874a9e486", + "GC000352": "0ba4501895f9aba5", + "GC000353": "900f604913fba5dd", + "GC000354": "e4edd96b86f392f2", + "GC000355": "b095779b2ef6d3a9", + "GC000356": "8cf509599cbc58f9", + "GC000357": "ab73b383dd25c984", + "GC000358": "8630b431b573a740", + "GC000359": "228460c982846c0c", + "GC000360": "86824b360e9becf9", + "GC000361": "6a764753ec7260b6", + "GC000362": "41d8c89c557a9e93", + "GC000363": "30062847c4a820a0", + "GC000364": "901d66e174667c73", + "GC000365": "c26e723b54ff9909", + "GC000366": "ceecc7da2ff787c5", + "GC000367": "b59845e60ad2d8e7", + "GC000368": "13712ef75ca4d128", + "GC000369": "463b7a2882a024b1", + "GC000370": "dbfb60f5c69645e9", + "GC000371": "1b2940f63fad92e9", + "GC000372": "49c1f5d1134a41a2", + "GC000373": "bc4f053f20a10a00", + "GC000374": "e1259acefc57dda7", + "GC000375": "69cdba1dcf3377b6", + "GC000376": "1ffd152fdefbfec9", + "GC000377": "6934acf35ddf9d09", + "GC000378": "2481cb3c7490dced", + "GC000379": "da9aa356f6b224ba", + "GC000380": "cd4e9434459452ee", + "GC000381": "4a30630384eddaee", + "GC000382": "2207fccd5e8f1522", + "GC000383": "89c3ee89ed9559b3", + "GC000384": "93427389914e85d7", + "GC000385": "5c4a041193010421", + "GC000386": "665a9b7fac395ae7", + "GC000387": "91cb9e1cf133641f", + "GC000388": "3d5aa3d12d1cd75a", + "GC000389": "183e503eeda6fe47", + "GC000390": "c16ff2e6d11421d1", + "GC000391": "2010d3a4a7ed2f42", + "GC000392": "ed1581f0c182b0ce", + "GC000393": "95036c2e8f1a7f9c", + "GC000394": "f04f7016d70e3a85", + "GC000395": "ef5f9661b9fcfce9", + "GC000396": "551b1b0f8c9225c9", + "GC000397": "29ccbc912d5b6771", + "GC000398": "7514a3158bd75e6a", + "GC000399": "8bee310cca76013a", + "GC000400": "16f4dccf83b5fae1", + "GC000401": "2d034e165fad1f59", + "GC000402": "9ddb366af08cef76", + "GC000403": "226d41db226820ac", + "GC000404": "34fda658b8f0030b", + "GC000405": "6c7cfcc2783de11e", + "GC000406": "dfd21abf6e15d8f2", + "GC000407": "60c543272d861afb", + "GC000408": "5c5110ae15ebb002", + "GC000409": "423b499dc751216a", + "GC000410": "8bd19c4ac86dfe0a", + "GC000411": "1157ae18cd887621", + "GC000412": "8b46b41b8662875a", + "GC000413": "e8200881d1d35ceb", + "GC000414": "ef7f6447a61d395c", + "GC000415": "419f4530a41252cf", + "GC000416": "ea518c48b1305da9", + "GC000417": "878bdb151d35ae47", + "GC000418": "14fd35e8da998c28", + "GC000419": "23af86832b67c851", + "GC000420": "f5d433d70202edba", + "GC000421": "e4e5b51893ef8866", + "GC000422": "41e3b84f8a51ea0c", + "GC000423": "6988956b87763917", + "GC000424": "6988956b87763917", + "GC000425": "d7032392d2acfebd", + "GC000426": "68d55e6906572ea2", + "GC000427": "a5b2278f719faddd", + "GC000428": "cf7fd73485df1dfc", + "GC000429": "804ea4f065a52922", + "GC000430": "32baa1c46876e010", + "GC000431": "5dc61455969acaac", + "GC000432": "d00a8b19e9203cb4", + "GC000433": "42aaf7e2b4836106", + "GC000434": "bd9ddb71e0d7e4bc", + "GC000435": "5835b7b18ba096bd", + "GC000436": "a79ef27342919e2b", + "GC000437": "d3e6c94ef760a1ed", + "GC000438": "c76fa39e6c005b5d", + "GC000439": "11d5cfacbfa50aab", + "GC000440": "799d053490d8da3a", + "GC000441": "9669bebf40299aeb", + "GC000442": "f1ead0b1ccd1ef3a", + "GC000443": "aaba0d7d434f46ad", + "GC000444": "fc7e3cf093ed80b8", + "GC000445": "c198c813815e578a", + "GC000446": "53294304ede0f7b2", + "GC000447": "0fb9979008c202a1", + "GC000448": "f9243ff390ae90e9", + "GC000449": "48da069b4650f45d", + "GC000450": "7f89b0ca48852cdd", + "GC000451": "6cae33da8d2416a0", + "GC000452": "ca0a827b8d4ec0b9", + "GC000453": "aae0fc97a5b5dfa9", + "GC000454": "5c62953be469dba1", + "GC000455": "4e52bf8164df1ec5", + "GC000456": "24c2bf1273203545", + "GC000457": "13e1a461e52c3168", + "GC000458": "4ee3298e2845576f", + "GC000459": "af9bd1469beec9eb", + "GC000460": "4599998a2d33ac6c", + "GC000461": "0b5cfeda73ae9239", + "GC000462": "a275f3c64b188eda", + "GC000463": "a275f3c64b188eda", + "GC000464": "f938ca98fd791d29", + "GC000465": "04ed885342d126da", + "GC000466": "473b30bf38f289bf", + "GC000467": "db9eb1af9f9b9bb8", + "GC000468": "9a82cae1af1969bb", + "GC000469": "7a2b03001ba6e057", + "GC000470": "744386b1a8c8927f", + "GC000471": "a13ed2d95a3f3155", + "GC000472": "da8b15cd3778374a", + "GC000473": "3b5745eecfce4213", + "GC000474": "7fc63feaa0c1c797", + "GC000475": "5cc8f64b8dcd55dd", + "GC000476": "aaaf23c47848cbe4", + "GC000477": "468c887a419b6793", + "GC000478": "395b8dc781ab7e85", + "GC000479": "df9c86cc1947e717", + "GC000480": "8d9807039f98bf9d", + "GC000481": "675f440ec88580d1", + "GC000482": "e419dbeee3135e18", + "GC000483": "a76cdea1f06f33e0", + "GC000484": "d91aa873e7dd6789", + "GC000485": "d91aa873e7dd6789", + "GC000486": "aa3fa3f6b4a21ecb", + "GC000487": "ed1eb533b52714db", + "GC000488": "79e6b3db3e51cb87", + "GC000489": "3f926b355cefaa68", + "GC000490": "a8ab4963c623fb14", + "GC000491": "74236ec4a397990b", + "GC000492": "d7481664a8208c1b", + "GC000493": "7881101e0351e483", + "GC000494": "ebae29835c57e845", + "GC000495": "e7e34a57159558f8", + "GC000496": "ef2fbeb9f5c53608", + "GC000497": "b8e67dc7d5a6d9f5", + "GC000498": "5a0a1f6b826e9fbd", + "GC000499": "24f5a56f014438d3", + "GC000500": "f695564512e71d41", + "GC000501": "7c3a27189202496a", + "GC000502": "25695fecf7ded260", + "GC000503": "116f8514271a7b8b", + "GC000504": "2b3f6354db90e7cc", + "GC000505": "2d4070d17013d454", + "GC000506": "ffe5b631feab2967", + "GC000507": "66731d8858f89260", + "GC000508": "147eb67c08324a37", + "GC000509": "66731d8858f89260", + "GC000510": "06f4f233442ec506", + "GC000511": "894214bd003adec9", + "GC000512": "f03c4be0b2a96d20", + "GC000513": "6bd923d7bfa85d4c", + "GC000514": "a4cd2d29b0b15a8a", + "GC000515": "5af56e54590b6039", + "GC000516": "7a96ec2e52c7dd7c", + "GC000517": "b3613c9d7938e85b", + "GC000518": "caf3963e6652ae82", + "GC000519": "5b149ad5a3516937", + "GC000520": "7dd4bc390fc3ff93", + "GC000521": "9d261610e50e1b26", + "GC000522": "5e2f8544ffc884f5", + "GC000523": "99d45f0596965cb0", + "GC000524": "58ceea16ae35eac9", + "GC000525": "cbf5a8917700f9b6", + "GC000526": "cbf5a8917700f9b6", + "GC000527": "16b7bf7bd49d4f07", + "GC000528": "d049de1836a9ee66", + "GC000529": "e2fcf006ec6c17a6", + "GC000530": "7b7c5d7ae98906ab", + "GC000531": "e812d5622b2c5500", + "GC000532": "e4c58a11b42694e9", + "GC000533": "d2d80ad51d91e68a", + "GC000534": "1d68a8a59468235a", + "GC000535": "f4d9dfc7eade0474", + "GC000536": "faee1c1b69a964c5", + "GC000537": "63f64df37d2869c8", + "GC000538": "9712ddf3092cd144", + "GC000539": "1e0084715819eb51", + "GC000540": "f4d9dfc7eade0474", + "GC000541": "faee1c1b69a964c5", + "GC000542": "1c5e96be648eef87", + "GC000543": "7cc09487dc72dd28", + "GC000544": "63ad3efed7249aab", + "GC000545": "44d0d3aa14906581", + "GC000546": "4660617a2f5291d4", + "GC000547": "2c8b10bd7b8de584", + "GC000548": "08435f2b1accd59f", + "GC000549": "cbc28a7c71218507", + "GC000550": "f7a75612f0f77462", + "GC000551": "ad91718180bf4b2c", + "GC000552": "7b447abde20efbe3", + "GC000553": "12eb0e5dcb5a4cb1", + "GC000554": "4d51fbb8543088d4", + "GC000555": "6a1cec5fd0e3894e", + "GC000556": "29a7ad1a1f71518b", + "GC000557": "9a5c3f5227e38d6f", + "GC000558": "015430a7c3037364", + "GC000559": "9fbd70deea84e5d1", + "GC000560": "1e0926891d886b60", + "GC000561": "e839b6097c17f0e6", + "GC000562": "d3757f0d0d0c46e2", + "GC000563": "aa508a4308161daa", + "GC000564": "7ca2bda1b0ae7162", + "GC000565": "8ae6a355eb402677", + "GC000566": "490140d715bcc66e", + "GC000567": "cd74ea2e0a71438a", + "GC000568": "86608ca0deabfa88", + "GC000569": "9440372e1e8ff008", + "GC000570": "6c5ed3881ed75be1", + "GC000571": "84fbe26c3418e5d9", + "GC000572": "d7dafd54908d640e", + "GC000573": "e0163bbd28fa137b", + "GC000574": "339e26796ffd476d", + "GC000575": "33a8cf3ccf0c761b", + "GC000576": "7fc9379a97227a85", + "GC000577": "a0a93c91c2715877", + "GC000578": "a61734e7cc3508d0", + "GC000579": "71e85c3475922f49", + "GC000580": "430d745cc7070cbd", + "GC000581": "94c35362b64ea877", + "GC000582": "574145187e959b2b", + "GC000583": "4fc7668fe8a9ac49", + "GC000584": "40c0830a7eaf0b91", + "GC000585": "7c1bd4549d17dc93", + "GC000586": "afad8ccafc9d18f1", + "GC000587": "6f33d0fce9594a3b", + "GC000588": "fcfb1ddea554a593", + "GC000589": "5616dc674a53cb92", + "GC000590": "486c681c97c23baa", + "GC000591": "861c510bee03a688", + "GC000592": "3887c51649fcf745", + "GC000593": "ac92e6045630007b", + "GC000594": "e063c59e2ebb7097", + "GC000595": "c5afa5202e666647", + "GC000596": "1780d678e1530445", + "GC000597": "167d340467339c25", + "GC000598": "2e5725f7df99ed9b", + "GC000599": "376fc10a5180c477", + "GC000600": "d86b9d1823c83f24", + "GC000601": "08fde41bb7cb4c37", + "GC000602": "93580b9a43898cc6", + "GC000603": "d2cda11b58f91d59", + "GC000604": "d363b1141999a529", + "GC000605": "29b2c0f44e652deb", + "GC000606": "c7fc2a480a005bc8", + "GC000607": "2f108a6a9fd0803b", + "GC000608": "03a70fca9e46f911", + "GC000609": "dfa272c7f7c2d041", + "GC000610": "801168b5a820a45e", + "GC000611": "b4d51973238a9936", + "GC000612": "6b1e7f8a0779935e", + "GC000613": "4238a156fe31be52", + "GC000614": "1d63649c8bbc8140", + "GC000615": "39551a289a3bc0ca", + "GC000616": "13b12e6ea47f1397", + "GC000617": "6a384d28fdfa0d48", + "GC000618": "8c0f5f34c1db6620", + "GC000619": "34c01395cf558e38", + "GC000620": "13a87d443b54bb06", + "GC000621": "4c7159b2417ac1fc", + "GC000622": "34b7505ea6510537", + "GC000623": "d0465a3d4bcd3bd6", + "GC000624": "7aa632f7e86abaca", + "GC000625": "4d5a60d4047cc2e3", + "GC000626": "66cadc508b86a07b", + "GC000627": "299f020dee1a6a56", + "GC000628": "c8f2ce1594775240", + "GC000629": "4790c4a60ff69089", + "GC000630": "2a418056f3bcc95d", + "GC000631": "32602d91c8761da8", + "GC000632": "f84afb890984ed59", + "GC000633": "f607534124d50438", + "GC000634": "8051ff9d7b1d4406", + "GC000635": "7f43f1374857b91e", + "GC000636": "cef1ca54177d44c6", + "GC000637": "311c4246ff98e1cc", + "GC000638": "b2ce310564b521c3", + "GC000639": "c060dee86a0950ba", + "GC000640": "d00aa3c7888f3190", + "GC000641": "4cd5fadb8f4cae6c", + "GC000642": "83e03cf972e7450c", + "GC000643": "0b4130079859ae06", + "GC000644": "7afe666e2b02a57a", + "GC000645": "95d7cca9707a5290", + "GC000646": "acc1b2d2d0d5cf5a", + "GC000647": "a847b741484426dc", + "GC000648": "3320f578ddbca8bc", + "GC000649": "2bfa6f843406473e", + "GC000650": "a1f1d2790473a2e4", + "GC000651": "4dbb7e5668a80fa1", + "GC000652": "6e97e197fd051ec9", + "GC000653": "70862a416df85949", + "GC000654": "3c4f49f4627d110c", + "GC000655": "5f5428107544742f", + "GC000656": "284de96c29f0c90e", + "GC000657": "882d114d0bf65f81", + "GC000658": "dbf0ffb608d8723e", + "GC000659": "8177882a33d255d8", + "GC000660": "562fe45378b7c9b7", + "GC000661": "db9768ef41270c51", + "GC000662": "77c432430f95ead4", + "GC000663": "931c00fcef6f5d0e", + "GC000664": "66c197ea91acd5f3", + "GC000665": "0171d304a64640f5", + "GC000666": "70adb1de64c18dc0", + "GC000667": "1d3639a3c5332665", + "GC000668": "ad73a7bf7d2a4275", + "GC000669": "23377bab152a7222", + "GC000670": "30a2aefc4586a2ee", + "GC000671": "770a8caf37ed46a5", + "GC000672": "dc53bf3ce5f289b2", + "GC000673": "3da81c6487b9b7cd", + "GC000674": "619c4910c4e07ef5", + "GC000675": "475dd6bbe544654d", + "GC000676": "d77c7de625a8ae47", + "GC000677": "f5660b8aec1f4112", + "GC000678": "a2b7225641e8314d", + "GC000679": "4063f19c45bcabd7", + "GC000680": "2e27f9f59b436d9b", + "GC000681": "125e9d8824a615c0", + "GC000682": "c0c94d121309a210", + "GC000683": "ef4abf0daf6f276e", + "GC000684": "8036e1606272664a", + "GC000685": "102e92843f00870f", + "GC000686": "2d2cc152589c7d7e", + "GC000687": "5c579207ba2778c7", + "GC000688": "41268b586f9eb25f", + "GC000689": "322c52aa0f3cde61", + "GC000690": "22d855ddb2c5484f", + "GC000691": "3796b2a06e90425e", + "GC000692": "776a07b6c6e20cfb", + "GC000693": "d9e5f3864879629f", + "GC000694": "3b67260b6b307a7a", + "GC000695": "b8465e8cd4bc3b24", + "GC000696": "98867a3d5dc940b6", + "GC000697": "d0feb8aed34db1ee", + "GC000698": "b169a3ea455f50e8", + "GC000699": "007edbdaef63554c", + "GC000700": "d3cbc50ecc748124", + "GC000701": "29710d26ca7dc3a5", + "GC000702": "a98a7b24ddd8d4cb", + "GC000703": "ea4d9b6d69edc37d", + "GC000704": "7206b8e8fdc1153f", + "GC000705": "b598b2fd7a2b6053", + "GC000706": "27826dd815e98062", + "GC000707": "0a5dd7dcbe810eb1", + "GC000708": "ffaf19a3e4856a4f", + "GC000709": "4db918d837563f8a", + "GC000710": "e9e7459573d45c46", + "GC000711": "3c593c42fbf2d684", + "GC000712": "d38c28f312b0294e", + "GC000713": "d202720ce890f40d", + "GC000714": "8510add0e8f69c92", + "GC000715": "ca12ae2dae1da030", + "GC000716": "d9ff6ebd01214024", + "GC000717": "90eb046f002a507e", + "GC000718": "8a855aedb171d079", + "GC000719": "412fabe2c0c2d83d", + "GC000720": "4f0accb7cc732189", + "GC000721": "731b8b31155c290d", + "GC000722": "a20bd4a85779311d", + "GC000723": "dc85a67045b92657", + "GC000724": "e24b826a2a24f055", + "GC000725": "3d6a8a41d4911866", + "GC000726": "515950bfcb998d30", + "GC000727": "ca6ac422db5ac73e", + "GC000728": "d1efc682587f6e7d", + "GC000729": "3acb02144654433c", + "GC000730": "84f7b631b63b7759", + "GC000731": "e339370f83b2ccdc", + "GC000732": "97b58e576eafd34c", + "GC000733": "ea814de553a078a2", + "GC000734": "859f3d9944cbdb59", + "GC000735": "8d88bac004ac25e9", + "GC000736": "d68f08b811070662", + "GC000737": "0d528b3616924de5", + "GC000738": "ca8748fcd7a4ba01", + "GC000739": "17da4513adab93f2", + "GC000740": "bc90a752410e1c84", + "GC000741": "f59855175df9e580", + "GC000742": "139c1b972139318f", + "GC000743": "ce99159e358b9bfe", + "GC000744": "72237153ab8bdd2d", + "GC000745": "7781b0d7ea522dcd", + "GC000746": "dafeb8d3b1d631af", + "GC000747": "bdbe8f0bc0a28ae8", + "GC000748": "4ff344e19b6abe49", + "GC000749": "f4a4a30357905aa0", + "GC000750": "acafcf7f568beb52", + "GC000751": "6ad55af562df5443", + "GC000752": "d8e0795628672bd5", + "GC000753": "b4100303eb1a1ce5", + "GC000754": "be5b9a508cf496a9", + "GC000755": "be2b346a970de8a7", + "GC000756": "6b1a67252091ff36", + "GC000757": "64d406ab6ab93164", + "GC000758": "64d406ab6ab93164", + "GC000759": "7fc6fd24a0511f08", + "GC000760": "df0c02317b68666c", + "GC000761": "4565a4c710acf471", + "GC000762": "d53b2ce4f5a9de54", + "GC000763": "d2c538c8ef97d812", + "GC000764": "3e83aa283432ce01", + "GC000765": "8b6a154df0919903", + "GC000766": "a92708cc4f4f352e", + "GC000767": "e81d4fc93fd00a9c", + "GC000768": "af8f61ca743b08e5", + "GC000769": "62cefefc2a2b89f2", + "GC000770": "7d1bea43c6411266", + "GC000771": "721a058358898206", + "GC000772": "ed607ea1caed3b2c", + "GC000773": "946415495049f3bf", + "GC000774": "0ddc3e262a0e035d", + "GC000775": "96087a7d72d31b2f", + "GC000776": "f3916b3868ccd35c", + "GC000777": "dc906d0dd3cda362", + "GC000778": "cb646b5c5e065f3e", + "GC000779": "d60e4a6caeb836e3", + "GC000780": "f1fd206aea99b0d2", + "GC000781": "94eb80b116cf29c6", + "GC000782": "ab8eaad4327fc349", + "GC000783": "5812cba9e8d5273b", + "GC000784": "fef0219c559682ae", + "GC000785": "626c612fec27860c", + "GC000786": "29a1800bf284b7d5", + "GC000787": "515bb463be073cf6", + "GC000788": "d170e880fbe005bf", + "GC000789": "f709895ac5ca821b", + "GC000790": "53277337529a27ce", + "GC000791": "6c418e483f22a38c", + "GC000792": "71ac6687eeb9f613", + "GC000793": "e495163b171f7306", + "GC000794": "8a4015e630e21a7a", + "GC000795": "1cbe0018fc02bc18", + "GC000796": "cd71e36489e91846", + "GC000797": "5b090a741861c936", + "GC000798": "b7b899bb9c9625ab", + "GC000799": "28da22079acdb5a0", + "GC000800": "e760eeb08a5610d1", + "GC000801": "d55008a803cf345b", + "GC000802": "f9088dc661adcbc9", + "GC000803": "950d305053c89c0a", + "GC000804": "1a08da8910fcb276", + "GC000805": "0e33178ac0a8dbb5", + "GC000806": "7ac5eda8148e9494", + "GC000807": "e15e766bfb5e0ef2", + "GC000808": "a73c26305a1331cf", + "GC000809": "655e734cab832b52", + "GC000810": "2cec932085ec016f", + "GC000811": "499b4da193dffb66", + "GC000812": "48442fe6318e8872", + "GC000813": "85d50046b89e01db", + "GC000814": "b962e0973fb0f862", + "GC000815": "874887dde3cafb8a", + "GC000816": "cd9c724d6f475dca", + "GC000817": "987ff79e2e8db70d", + "GC000818": "55548cb33a2a38f6", + "GC000819": "5c502dc187827923", + "GC000820": "eb96ae0380b812c0", + "GC000821": "178f1f8da8cf356d", + "GC000822": "0ded040135c71cdc", + "GC000823": "5c8a2ea46b42444d", + "GC000824": "c5fb0b48688b297b", + "GC000825": "e4243699eceaba5a", + "GC000826": "1d352de033ad695f", + "GC000827": "ff2c09e4313ddd64", + "GC000828": "1c1e6ca2f18e0422", + "GC000829": "5a8ce41f21cc5cd6", + "GC000830": "646be8362c6fdecb", + "GC000831": "3bfef117674ba78c", + "GC000832": "85eb99eda917aa56", + "GC000833": "3e1dbdfa9dbe0ac4", + "GC000834": "0122b8544410c12b", + "GC000835": "3934eb93f35bed80", + "GC000836": "097fe590efd99903", + "GC000837": "a5ea998318581da1", + "GC000838": "8d5855a1374f977c", + "GC000839": "a3166647b599e73e", + "GC000840": "2effda474edbf237", + "GC000841": "065d2256365f4eba", + "GC000842": "e032b955ffe9c8a6", + "GC000843": "efe9d141b51d8ff9", + "GC000844": "e7776288ac2d0b75", + "GC000845": "5aa2848631045286", + "GC000846": "29122063893ded23", + "GC000847": "64fe6145805c2e1d", + "GC000848": "f5387c96eb4ef043", + "GC000849": "21b8ecc17e9ab895", + "GC000850": "db3c06787fcfbe56", + "GC000851": "9119082a5fb563f4", + "GC000852": "92dd8978fc627068", + "GC000853": "21b9e0bafa3c5fc2", + "GC000854": "9b2bfa46a1d7c7dd", + "GC000855": "9f3a2b38b3848a07", + "GC000856": "bf23149883a73b35", + "GC000857": "aa8400207c20afab", + "GC000858": "50bec9ad9e168c58", + "GC000859": "37014ddc310df7b4", + "GC000860": "f4410048cc6efdac", + "GC000861": "a9d13c49fed90f8c", + "GC000862": "5a9e66a9826ca5c6", + "GC000863": "5712e6213b09990e", + "GC000864": "059c0936d11e7412", + "GC000865": "9c476209f24c5d1c", + "GC000866": "ee34bf32af6fe20c", + "GC000867": "14e69c64036a7b81", + "GC000868": "f44549d250ea7403", + "GC000869": "a6e78f68b1391359", + "GC000870": "56dcc09896d6c768", + "GC000871": "9b075b64379aabc5", + "GC000876": "e1d54177bc315382", + "GC000877": "68879e7c0afea1ed", + "GC000878": "63d996779f923c2e", + "GC000879": "1369d10da3874649", + "GC000880": "c68bf58c3c25f4b4", + "GC000881": "e510f364947382e0", + "GC000882": "a5a91204fb767e6a", + "GC000883": "c078ec2863f6431b", + "GC000884": "6b460980b8e3a9d7", + "GC000885": "2ed818e630829a8b", + "GC000886": "701c168f2bdf14e7", + "GC000887": "072e8d18e0a2df9f", + "GC000888": "4ee4e2a9a85b3763", + "GC000889": "4336c0f4f5593a97", + "GC000890": "d349803e0759fb65", + "GC000891": "c532253640a76783", + "GC000892": "4831e33ae107d5f3", + "GC000893": "060a59e01b24d088", + "GC000894": "a81746803e0ef427", + "GC000895": "c6016df121e66c29", + "GC000896": "7c5a997e36a4b292", + "GC000897": "cc84403ec560f27c", + "GC000898": "12225d8f1e735588", + "GC000899": "8f585d46b9c00b89", + "GC000900": "c18984d48eb8e746", + "GC000901": "d249a941b8faf7df", + "GC000902": "623091dc60e94b9c", + "GC000903": "6b953bf97fff9139", + "GC000904": "3c23dd5f5653ff94", + "GC000905": "fe7966bc5058dfdf", + "GC000906": "99c5e10767427727", + "GC000907": "c73c199d985b3cc4", + "GC000908": "7bffed9304803f44", + "GC000909": "669a1cc79decae9e", + "GC000910": "ad299f1c1cd17243", + "GC000911": "7ef329d1f6d717c3", + "GC000912": "2a70d0824faac80b", + "GC000913": "814051575beb9e9b", + "GC000914": "4a9703b27ada7633", + "GC000915": "2b21137e301c58f2", + "GC000916": "2c213963d40a8f09", + "GC000917": "562b25590756cb52", + "GC000918": "6c7fbe82ba97c6c7", + "GC000919": "7f1ef43e45591f01", + "GC000920": "d92ed21b02b3609e", + "GC000921": "dccd82ae534e42b0", + "GC000922": "f4b16cc2cea9f587", + "GC000923": "b3df4f8442b5dc24", + "GC000924": "e4680416d314b0f3", + "GC000925": "3ba2058b0d13fceb", + "GC000926": "796aa2be5d7d0638", + "GC000927": "c3a6c3c9f5dead50", + "GC000928": "4d90275bf55471e6", + "GC000929": "8579db531e8abd16", + "GC000930": "dc4de5f16d45a862", + "GC000931": "2431c735144b4359", + "GC000932": "aaf497bf8b48906d", + "GC000933": "9e491dca9170049c", + "GC000934": "4ae228fe8500299b", + "GC000935": "ead30ce15c8b332e", + "GC000936": "b12c0db372f3b0d6", + "GC000937": "2a4b2a5ef6dcde84", + "GC000938": "1cd83ee850bb0469", + "GC000939": "942382f4e0689449", + "GC000940": "365806fa96942653", + "GC000941": "f5bb181ca26bea7d", + "GC000942": "1bbff6b92d4be049", + "GC000943": "eb31c5c1e7c33059", + "GC000944": "04d343c65e702a72", + "GC000945": "1a4f93b1602a9515", + "GC000946": "175d5c24c1750075", + "GC000947": "fcf250194ab904c7", + "GC000948": "9384e52180e105a1", + "GC000949": "fb9bfeee82706414", + "GC000950": "f7cf3a1de28b23ff", + "GC000951": "43b7eabee06974fd", + "GC000952": "c593828ba6913e8b", + "GC000953": "c775d570978c4862", + "GC000954": "557f814bc08284a0", + "GC000955": "0bcc92857e6ddc91", + "GC000956": "eaf893af7b220a28", + "GC000957": "7e5c5059a0155cee", + "GC000958": "e008cca10c543ca0", + "GC000959": "e4686c819dfefddc", + "GC000960": "3fec9eb9c91def2a", + "GC000961": "e6da8a34feb4973a", + "GC000962": "15ec628a4ba39526", + "GC000963": "6295c65646915b2a", + "GC000964": "5202d3461e99dbe2", + "GC000965": "53258e03f92dbea7", + "GC000966": "2da3948961a71a1e", + "GC000967": "2da3948961a71a1e", + "GC000968": "9f397e69c1910fd2", + "GC000969": "a050ceaeb347cce2", + "GC000970": "55f3a77b57a875a2", + "GC000971": "55f3a77b57a875a2", + "GC000972": "8753e3633c3a315b", + "GC000973": "f00a65b2aed3c179", + "GC000974": "c6c6f24acdd81129", + "GC000975": "fcd3f1cc7e8de0b5", + "GC000976": "ab604ec378c14055", + "GC000977": "0d938c485c5321f6", + "GC000978": "1788013e6339af56", + "GC000979": "e88dcb406f6d3a6c", + "GC000980": "2dc01638604aef2b", + "GC000981": "100b689fb03a080e", + "GC000982": "250ca842a337da77", + "GC000983": "87ab123c4dbcff36", + "GC000984": "3832b5b337ec4b31", + "GC000985": "a3f84ce56753bb95", + "GC000986": "b0e0a9283f982b71", + "GC000987": "457527231c70d67a", + "GC000988": "12f93a62cbb07d3f", + "GC000989": "769a1b9fa84555b6", + "GC000990": "441535b35efba686", + "GC000991": "eb05d6e7829867d7", + "GC000992": "92ec8ee6eeab79c1", + "GC000993": "5599960b070af760", + "GC000994": "5033d6d727a90e52", + "GC000995": "b29906faf5836dbb", + "GC000996": "fcced1b90bbdce56", + "GC000997": "943dab0d3c124d55", + "GC000998": "fdeb0955966de51d", + "GC000999": "8b21966a553ef00d", + "GC001000": "b11f1fc4d7ec157f", + "GC001001": "19567c1a58cf1c62", + "GC001002": "685a3226e6d8ef47", + "GC001003": "16d10173a1fe3e2f", + "GC001004": "a9b2953e82a1239e", + "GC001005": "90f61372d1e8a351", + "GC001006": "2260a6098b4cf477", + "GC001007": "4e377be1caa394e8", + "GC001008": "4a7fdae06e512ae4", + "GC001009": "f0f95c187101fe54", + "GC001010": "e0311716ef21734e", + "GC001011": "f083bec3d77752e4", + "GC001012": "67bfc3599780b972", + "GC001013": "c27329591b62f02a", + "GC001014": "d2496909501014e6", + "GC001015": "7dad53c7ad35d14f", + "GC001016": "033e8a8f9a95e2a0", + "GC001017": "457a9e2efe99355e", + "GC001018": "a58fce5d6651f478", + "GC001019": "dec9e04b94d1aa9e", + "GC001020": "1af78074604b8744", + "GC001021": "ed3036a14c0ad921", + "GC001022": "a55e162cc0813466", + "GC001023": "7dec76f17eb788fb", + "GC001024": "b558d311a5892554", + "GC001025": "a524176df4bb9715", + "GC001026": "8307164edcce8a23", + "GC001027": "395f0396953f1244", + "GC001028": "96a2f2a21fe24b88", + "GC001029": "b7e377f1f0df1382", + "GC001030": "beffcfe55717bd75", + "GC001031": "e063f7db916fc02c", + "GC001032": "1b734a7dab524909", + "GC001033": "5e23eba011d49862", + "GC001034": "2ffdc3e8bb7f87b5", + "GC001035": "2d9d02b2eb78624a", + "GC001036": "b1e3244048eae312", + "GC001037": "f674336998e63bf0", + "GC001038": "9c9fa1246c3d1e6f", + "GC001039": "335e4696d0302eb7", + "GC001040": "032354e5f9789481", + "GC001041": "70980d9c00d53fd5", + "GC001042": "ed477c3949cee530", + "GC001043": "a34643678c55aede", + "GC001044": "d66eb0b310c712ee", + "GC001045": "2b1563cdbe79af94", + "GC001046": "430cb9630c56a900", + "GC001047": "a31176e49b99dca0", + "GC001048": "17948ad5dc2c56b4", + "GC001049": "a1b7accfa5b18587", + "GC001050": "9585f839cc5a737d", + "GC001051": "1e70b07bad033ab3", + "GC001052": "fe66604feff02485", + "GC001053": "867f093f8f613de2", + "GC001054": "da8e91f6d5a1ce60", + "GC001055": "87fbc095cdf41768", + "GC001056": "ddd8dd53f27b0c3e", + "GC001057": "2b42b45756a51426", + "GC001058": "7d870d4ed1e86073", + "GC001059": "c399d9137b8d6397", + "GC001060": "681fb6318eae5dac", + "GC001061": "678dd08145137ec2", + "GC001062": "c46abd59a0464bd4", + "GC001063": "dbc957c2c2bc0663", + "GC001064": "2eb310002a652862", + "GC001065": "8f86c435d9f96ddc", + "GC001066": "38cbcc27018861c5", + "GC001067": "3ec4defb1143c241", + "GC001068": "854d7f4e0e6aed66", + "GC001069": "892ac4f2fdc8f0a8", + "GC001070": "3625d62e4407132d", + "GC001071": "92945140d473cab9", + "GC001072": "1f803a6bb403602e", + "GC001073": "7c9159fc539c99f9", + "GC001074": "b7554ef994b96a83", + "GC001075": "bbbe3548fc7ffa06", + "GC001076": "acf2cf17e33aff7c", + "GC001077": "bed59e3d4837f945", + "GC001078": "79c112b797e5c907", + "GC001079": "4b4d8f10e15b0f66", + "GC001080": "ff870486aefbffdb", + "GC001081": "02fb1ffdbf28dd6e", + "GC001082": "39a2d35bba4f66fd", + "GC001083": "a12993a7b4845c4a", + "GC001084": "6d7f2d0419a17dcf", + "GC001085": "f3d04ad844926bc1", + "GC001086": "bb33acd2bd567154", + "GC001087": "1b2940f63fad92e9", + "GC001088": "84612f7ed1d55741", + "GC001089": "0966132e160ba45a", + "GC001090": "f2a4072ce598cf77", + "GC001091": "c0ea36039b59f399", + "GC001092": "3f9e993ffbd7c9fd", + "GC001093": "f840f12d2a391310", + "GC001094": "9bfe9f87f29d5840", + "GC001095": "e2d2adfd6de41e1d", + "GC001096": "8ee252b04084805d", + "GC001097": "ce7a15391540dc4a", + "GC001098": "6c049ee74d34cbf0", + "GC001099": "0e375e694a5d8a32", + "GC001100": "176acc290cf2d317", + "GC001101": "56cf3d47bc4399eb", + "GC001102": "f4f523c271c4830b", + "GC001103": "5670f4efa80b7616", + "GC001104": "63aadfaf2cb4fa18", + "GC001105": "2b1b60ddbe13ca38", + "GC001106": "bfeef3f679a47b23", + "GC001107": "e6d755f4daf387a3", + "GC001108": "92aed2e36b94d5d5", + "GC001109": "f34effccc20d245e", + "GC001110": "de31681225736151", + "GC001111": "fa2451846289b8ab", + "GC001112": "e287967e67d9f0a3", + "GC001113": "f477eff692241d03", + "GC001114": "07f2ea61030d1d34", + "GC001115": "909426a44b2c9c4a", + "GC001116": "1a884834a1c5ea3c", + "GC001117": "306051951e0b60a4", + "GC001118": "59cc715f43876717", + "GC001119": "78ab520638cec169", + "GC001120": "5638fc48dec795c0", + "GC001121": "6f050b3af9577d0a", + "GC001122": "974ada4de6791b61", + "GC001123": "922cace1bf4d16b6", + "GC001124": "03fa3036ffaa080a", + "GC001125": "146c66374315f431", + "GC001126": "986b2c7733b93357", + "GC001127": "a4eff242437d373a", + "GC001128": "be633cf67a0dc56d", + "GC001129": "e6d40b6ad8fab00c", + "GC001130": "d6794a38717b83c2", + "GC001131": "feaabf6ed8e30da1", + "GC001132": "d3696d42c180301a", + "GC001133": "727c98926db72eb0", + "GC001134": "41d2a505e8b0dddc", + "GC001135": "6bb122f1ab67749f", + "GC001136": "e99d65c933dbb22b", + "GC001137": "36cb464ebdf3dc4e", + "GC001138": "b8d81fcba9aff4d8", + "GC001139": "751e72b7fc88e0ad", + "GC001140": "da246ee736f3223a", + "GC001141": "ae725c5adb0527b0", + "GC001142": "f185438f9821169f", + "GC001143": "5a9c7f8fac68c91a", + "GC001144": "134777fdb64fc57d", + "GC001146": "c5e3479de922b645", + "GC001147": "fd200af97a31fbb5", + "GC001149": "bc59fb543dd3db23", + "GC001150": "7c86f0a11b0a18a6", + "GC001152": "88aedb642ad24f1a", + "GC001153": "a52ba223caf36662", + "GC001154": "52eecfb2c01dd387", + "GC001155": "388041e3973b528d", + "GC001157": "bf05b024f88e675c", + "GC001158": "cca0637d7e117763", + "GC001160": "d602a8259a8ba039", + "GC001161": "b774471d2b9ff104", + "GC001162": "f3021ba11596010d", + "GC001163": "61ab002f226c33a9", + "GC001164": "c2564d7fbe4a0b20", + "GC001165": "815e6c7bf92d8dcf", + "GC001167": "2bbfed5b08f52578", + "GC001168": "d70382c35f8c4f51", + "GC001169": "cd50a51320f0f16d", + "GC001170": "21ac91b06518ddac", + "GC001171": "ef074d00d224932c", + "GC001172": "55ad4be3a4ede107", + "GC001173": "14c317a6d1e4cc92", + "GC001174": "f6b06b29c6d171ca", + "GC001175": "604b851ee7c19f4d", + "GC001176": "b510d105fa7cea33", + "GC001177": "f43c45f22780f59e", + "GC001178": "43b88d9ec63f4d79", + "GC001179": "0284b2a1642022f2", + "GC001180": "8470f0134a9c5aca", + "GC001181": "13c4434b7300d27f", + "GC001182": "dcdc29fa5c9d0ac1", + "GC001183": "e044cb9c618975f7", + "GC001184": "ee68ac4a28834acb", + "GC001185": "b2d34ddef08d44dc", + "GC001186": "b05eeaaa19ceb913", + "GC001187": "583365b1cd85f7d6", + "GC001188": "7d98417e4cd39ad5", + "GC001189": "b7baf4849f7907d8", + "GC001190": "a84c3a5e704cdf8f", + "GC001191": "319c2d3b33b82501", + "GC001192": "5d9d97f40575678b", + "GC001193": "26e804ce5ac12551", + "GC001194": "55372636b0bc4840", + "GC001196": "d7eece6cfb557f60", + "GC001197": "eb36702baf6d2220", + "GC001198": "546372e72abf04d4", + "GC001199": "f69677f85463240d", + "GC001200": "874f6fd45351a1b7", + "GC001201": "874f6fd45351a1b7", + "GC001202": "d8ec9c69f1d7de86", + "GF000001": "55372636b0bc4840", + "GF000002": "02f089c8823ac307", + "GF000003": "b28b03ee68e7846f", + "GF000004": "1b0765c1fdd2ceb7", + "GF000005": "c3c5c4d86948bac6", + "GF000006": "9eb51e754c667391", + "GF000007": "97a6b65ca428fad6", + "GF000008": "45bf18fea8e0dae3", + "GF000009": "faf87acce631cb4a", + "GF000010": "de7f54bf2c330521", + "GF000011": "b9d922b76257f9d0", + "GF000012": "13d488dbebfc53e5", + "GF000013": "db44362774a0c37d", + "GF000014": "cd91a2c268fddce5", + "GF000015": "c3f2490375a41949", + "GF000016": "e1ba6d7096fedbb4", + "GF000017": "f4be53b07de16aa0", + "GF000018": "c20d048cbc23ba3c", + "GF000019": "a5ecba323ad3adbc", + "GF000020": "d9f42891fc9d19d6", + "GF000021": "434c7c90214e29aa", + "GF000022": "cbb50496730b5edd", + "GF000023": "fc266488dd7f8aab", + "GF000024": "06a5b7d6d752ffef", + "GF000025": "413e1297c5765ad3", + "GF000026": "a45c6d51cd8bb3d9", + "GF000027": "286729d9f84206e0", + "GF000028": "ad6872416be21a67", + "GF000029": "4fa577c78c431e4a", + "GF000030": "8aa6224f3786b0d2", + "GF000031": "b04a5cb89f5e53fc", + "GF000032": "605d543c2b08f707", + "GF000033": "c9f7f0bf52200faf", + "GF000034": "b03f8201a7f61a1f", + "GF000035": "459b3ad7099f1f30", + "GF000036": "97b57a694e97955d", + "GF000037": "0766e66368701140", + "GF000038": "0766e66368701140", + "GF000039": "8a01ecd63377e15d", + "GF000040": "43550d9406a88e91", + "GF000041": "c54c2208271f79a4", + "GF000042": "2ace67e81528847f", + "GF000043": "eba3448c33cf7eea", + "GF000044": "8d619023e4639ab8", + "GF000045": "c0a66b6d97189c12", + "GF000046": "69c699d288f7d158", + "GF000047": "3023c0d80f0735c8", + "GF000048": "abed4f5c8373cddc", + "GF000049": "f6cd19750cba340a", + "GF000050": "e434796faa483cf9", + "GF000051": "f2e5d20bf7646aa6", + "GF000052": "ab08c0e49380defc", + "GF000053": "55372636b0bc4840", + "GF000054": "aa34b02f3f1fd1d1", + "GF000055": "17655b2ef1b679e0", + "GF000056": "50044cf17101aa0e", + "GF000057": "76c7ac9801f9c287", + "GF000058": "7bdb58644ab03c11", + "GF000059": "a189482d5c6021ec", + "GF000060": "aef70d094cc7c33f", + "GF000061": "a7e3e9a655d2f1a0", + "GF000062": "840aa64111958d52", + "GF000063": "3a125b50a3eefc0c", + "GF000064": "9df540a032f2466a", + "GF000065": "41a30000390c5f64", + "GF000066": "991fbb631d763582", + "GF000067": "e911d24e05ba6e9a", + "GF000068": "1e5d3b4a1a910241", + "GF000069": "1409580c844ebf55", + "GF000070": "10ac5e4e7cd406f0", + "GF000071": "58c751889d78df4c", + "GF000072": "99d2506ecb4358dc", + "GF000073": "6c31e4c2870dc66a", + "GF000074": "ceb4a10f95b6b5da", + "GF000075": "0c83310d5ca267f1", + "GF000076": "576b15067fd12f2e", + "GF000077": "42ee0e8fb7d35b6a", + "GF000078": "a7ad83bf9eb11d63", + "GF000079": "57c08007d04c7a28", + "GF000080": "0a78378615d76be3", + "GF000081": "6f1e1c6650dc2532", + "GF000082": "6842bbbbfed54ba9", + "GF000083": "d0af11b98757f485", + "GF000084": "a7d2492f6c45da55", + "GF000085": "bc3662d379b0bd8b", + "GF000086": "3964ab9101f4cd74", + "GF000087": "8fdbf6b299398d18", + "GF000088": "71632a1882d2f21c", + "GF000089": "def27b3e5711c347", + "GF000090": "9fb5565d4ab5980e", + "GF000091": "8a358cce2782c84e", + "GF000092": "5d6d30b03ebab0fa", + "GF000093": "29a3616459f65237", + "GF000094": "4624e37f28bb1960", + "GF000095": "df09ec05589b12ae", + "GF000096": "1872cbdad965563c", + "GF000097": "2b8e5388c5aee6f9", + "GF000098": "edaebcac53218015", + "GF000099": "5e94fe53c7bb48aa", + "GF000101": "71fc6c00e2bdb5c3", + "GF000103": "6123ec69147e87ba", + "GF000105": "7eceddbcdf77ae24", + "GF000107": "ba4ed6f556a4b486", + "GF000109": "f79af37102135446", + "GF000111": "5880754306f429ce", + "GF000112": "b9439f53473dd7c3", + "GF000113": "fb22b20c4773ff24", + "GF000114": "78e565901a1da215", + "GF000115": "cdbe95ef7c35c08d", + "GF000116": "4286d9e8937493d0", + "GF000117": "4deaeb8e94720b0b", + "GF000118": "5e5489bf54c32d2f", + "GF000119": "bc58b000a9ffcc5f", + "GF000120": "ca302cd5058223f5", + "GF000121": "33ee33757c708be8", + "GF000122": "4fa52d0e17e103fe", + "GF000123": "f213755f4d014187", + "GF000124": "a9cfaf196fb21568", + "GF000125": "7db8452e1de8d408", + "GF000126": "ddfc3a61ca950e08", + "GF000127": "89ab4f425ee8e69d", + "GF000128": "e88778aedc9e092d", + "GF000129": "02e382e1e7eda555", + "GF000130": "f0f86fcde8bf60c3", + "GF000131": "0fbc9651d7e3d545", + "GF000132": "c4fdfc7d01c1f63f", + "GF000133": "184506b5753af449", + "GF000134": "c4be2c2fb950c8af", + "GF000135": "c4be2c2fb950c8af", + "GF000136": "c4be2c2fb950c8af", + "GF000137": "604b7daf45556c1d", + "GF000138": "e2fd19821a1eaec3", + "GF000139": "175f033b3d6b9f40", + "GF000140": "77402698bf38825f", + "GF000141": "031c0a7bf27a484d", + "GF000142": "2a5f100403e2fa58", + "GF000143": "0929fe81d3db35a9", + "GF000144": "41837046fd377f6e", + "GF000145": "2204cc9591a6acea", + "GF000146": "a19565c3a7ef1004", + "GF000147": "e9299ea65592b236", + "GF000148": "14fdfc2edd4e8c3f", + "GF000149": "49ce9126cbd5dd9c", + "GF000150": "20d80f4e2be71313", + "GF000151": "fbaac52f7229ab91", + "GF000152": "bb900a13ea654971", + "GF000153": "5e5489bf54c32d2f", + "GF000154": "bc58b000a9ffcc5f", + "GF000155": "2d2413058fe5dbf6", + "GF000156": "96d6be3c7120c2ca", + "GF000157": "6015f433785ff3fb", + "GF000158": "c882a9665ae57054", + "GF000159": "21d19458353fbbab", + "GF000160": "cd132adc365f967e", + "GF000161": "8b7adfd7096108a4", + "GF000162": "dd151f735930cbf4", + "GF000163": "ef0b3b210f5f09a2", + "GF000164": "93a7340613328a71", + "GF000165": "e4e684919da259a5", + "GF000166": "2358b9b47e9e1efb", + "GF000167": "ea2542da00706e8a", + "GF000168": "a049b4026d4d0532", + "GF000169": "732d9fc258e94679", + "GF000170": "b27037d8cbe3ed02", + "GF000171": "7e5ef5dfe609e03e", + "GF000172": "110e790ca87fb013", + "GF000173": "aeccee759abadac8", + "GF000174": "9c59756c70b121fb", + "GF000175": "5aa7149e467aec4d", + "GF000176": "8ee24f8ba06f052b", + "GF000177": "d890d96d179519c0", + "GF000178": "f8ecfc06566a3755", + "GF000179": "07fd1ae53088f812", + "GF000180": "0c1c2dea593342d5", + "GF000181": "7e62e997b1a30ece", + "GF000182": "f07ae8a695b578ed", + "GF000183": "b3a13280d4c77a27", + "GF000184": "50e6fec5a613c9dd", + "GF000185": "2246e25d73e9a64d", + "GF000186": "c48a245ec5ad4377", + "GF000187": "ac1af5ff04e10985", + "GF000188": "267efec6cc3f9d95", + "GF000189": "eb8ef850cba5a360", + "GF000190": "24112a977b353d0e", + "GF000191": "348677716c05da84", + "GF000192": "fa7f7d800ec8f21a", + "GF000193": "5b0285cfa316d291", + "GF000194": "3f3ae186ab2e8bdf", + "GF000195": "db92df40ad80dfff", + "GF000196": "6189c31e5405cd4d", + "GF000197": "694d17058a92e431", + "GF000198": "baf9b485ca959dd9", + "GF000199": "8fcfc90ca985726d", + "GF000200": "12976f6405aa64eb", + "GF000201": "4061b1e8f2a98b08", + "GF000202": "faaebcb70aec4bc3", + "GF000203": "773dc083e6e44cae", + "GF000204": "ba54056c7cfab8c9", + "GF000205": "79fba9eef0232262", + "GF000206": "4668fdf8b4b401c1", + "GF000207": "35354caed928b596", + "GF000208": "07039c8117c7ebb5", + "GF000209": "f6192bbd082fc075", + "GF000210": "9120d887dcb0f41c", + "GF000211": "5f5d9d84e1235b49", + "GF000212": "9e3c0987547dfb74", + "GF000213": "a86a7325e5311e84", + "GF000214": "26876f5949b63bd4", + "GF000215": "e7a355646dda132b", + "GF000218": "654af8d58723c9bc", + "GF000219": "9c7c8bf4dd387603", + "GF000220": "75a7685ac72271d9", + "GF000221": "cc75f41be89d7135", + "GF000222": "c857b203a42af734", + "GF000223": "50505934699b48ee", + "GF000224": "0c3b028af28a5af3", + "GF000225": "82dd40c87f2ab16d", + "GF000226": "9d843e828de5c5a3", + "GF000227": "09f58ac23619e617", + "GF000228": "8fc731f56f4cbc9b", + "GF000229": "f89a7965a972cd49", + "GF000230": "a9b99bb678803c63", + "GF000231": "e34a174535f0fccf", + "GF000232": "6109cc5d556e08d1", + "GF000233": "5aad77ee785454df", + "GF000234": "929fc7aedd16acfb", + "GF000235": "5b444746c1d5d3f4", + "GF000236": "e0e287c95cae2bd6", + "GF000237": "75391b5e8d801631", + "GF000238": "ed0ab2096c646c86", + "GF000239": "f31e42c70e6aee44", + "GF000240": "7261662b622864ab", + "GF000241": "05d9dbac55df7b73", + "GF000242": "2d758e165e881509", + "GF000243": "e9784bd9041486cc", + "GF000244": "f7e3ba2910167a9f", + "GF000245": "be12c8f792d5c898", + "GF000246": "d753841ea860358a", + "GF000247": "f30cb15df60bc349", + "GF000248": "e05e0f0497cd0ffd", + "GF000249": "a319f577536a5952", + "GF000250": "e2a518ee45cfb972", + "GF000251": "a8b8b713d5fb4d5b", + "GF000252": "a20a6c1259ba125a", + "GF000253": "a20a6c1259ba125a", + "GF000254": "73d91a924a2dab55", + "GF000255": "ac043bbe9640a74d", + "GF000256": "6f51375d8bcd7192", + "GF000257": "4a7eaabff011f0cc", + "GF000258": "b442815a7437e76b", + "GF000259": "09799bb88f3ff236", + "GF000260": "6f51375d8bcd7192", + "GF000261": "7027e8938c8c785e", + "GF000262": "d69a07733768a4d5", + "GF000263": "e619af3a04106d0e", + "GF000264": "8f47595f22d8f004", + "GF000265": "4435cc70b320768e", + "GF000266": "7d45d3ced9f91786", + "GF000267": "d8f11c41c91b7a8a", + "GF000268": "042661b1c83a61b0", + "GF000269": "f086ef9c94efaf5b", + "GF000270": "b0e7b15ba4f42c8e", + "GF000271": "b61b82c4c339fe84", + "GF000272": "2f523d333e8f30de", + "GF000273": "2e4d1f4a5a3c4a6b", + "GF000274": "c1ded10f80205384", + "GF000275": "edc9cb53cfff0b53", + "GF000276": "f9aa5e7b69aa6581", + "GF000277": "671933b89a04ead9", + "GF000278": "9a9aef537cf48a1e", + "GF000279": "59755951a30bcaf6", + "GF000280": "8dd4ca470cc06d0a", + "GF000281": "29e5fc7990445168", + "GF000282": "d8c46c5506fea13f", + "GF000283": "64620f97a58b3bd8", + "GF000284": "4ebf6d9f11fa171b", + "GF000285": "8aeffa415186b78d", + "GF000286": "dadd815818621b87", + "GF000287": "d4dcdac6507b3ee2", + "GF000288": "d78fc34ebde6735a", + "GF000289": "0b031afdf07b1474", + "GF000290": "24a540ec47dc969e", + "GF000291": "7d904236333f9f99", + "GF000292": "38724b9a9b1afefd", + "GF000293": "d0ab2b51da892f00", + "GF000294": "a93d206c5472be58", + "GF000295": "1f54d4ad697745e3", + "GF000296": "3a8731f0dd66bf3d", + "GF000297": "763450bb45590dc7", + "GF000298": "56a43ea3658683c9", + "GF000299": "a4c283a84aa32dad", + "GF000300": "c7f417878c5199ef", + "GF000301": "415e417de158c64c", + "GF000302": "279254b0d9d6f19f", + "GF000303": "d753841ea860358a", + "GF000304": "7055bcbcc8db83f9", + "GF000305": "08eee94e5e134459", + "GF000306": "71869e32c55ad16f", + "GF000307": "07271be44023cb8c", + "GF000308": "5bdc51bb7024303a", + "GF000309": "5da9078518569c91", + "GF000310": "0853f8caff2663e6", + "GF000311": "47622161ee55e9ab", + "GF000312": "54069e3665fec9f1", + "GF000313": "0c7616e65a8189c9", + "GF000314": "4f26e03ad01d54a3", + "GF000315": "7de1e0fa301cee56", + "GF000316": "58c983634cde6267", + "GF000317": "3519980b4d67a51c", + "GF000318": "95729d30f63807bd", + "GF000319": "aaa44f1267f61d31", + "GF000320": "2e838dfa57a8d380", + "GF000321": "361d80ae0593c0fa", + "GF000322": "5fcc4c17a1b0bd93", + "GF000323": "23f8000ea768c687", + "GF000324": "b2003417eb0c8488", + "GF000325": "2ec4728aa2d6e273", + "GF000326": "ebfa0cfb633d8b74", + "GF000327": "cd63b47d9f093716", + "GF000328": "e8ef10d3ecce9945", + "GF000329": "4a6f0f547aec5261", + "GF000330": "edc3f9b565749960", + "GF000331": "97c79730ca04620e", + "GF000332": "a62e193b082aa139", + "GF000333": "6b08745a7f650ed2", + "GF000334": "8ec89eef9f0e258a", + "GF000335": "7661263f5efb886d", + "GF000336": "0fea4975fb2b9c87", + "GF000337": "fbed9c13bff2eddb", + "GX000004": "04217dcfcb11686f" + } +} diff --git a/resources/tester/helper_855_c4_doc_text.cjs b/resources/tester/helper_855_c4_doc_text.cjs new file mode 100644 index 000000000..2bc68737e --- /dev/null +++ b/resources/tester/helper_855_c4_doc_text.cjs @@ -0,0 +1,71 @@ +/* 855-C 2-C4 거울 헬퍼 — 산출근거 글 규칙(TS)을 Node 로 돌림(`master_doc_text.py` 짝). + * stdin = {수: [값], 단위: [글], 금액줄: [{줄, 단가변수, 부름}], 꺼짐: [{문서, 값}], 원: [수]} + * stdout = {eq: [eqText], one: [one], won: [won], 단위: [unitText], 금액줄: [moneyUnits], + * 꺼짐: [[offLine …] …], 비목: COST_SHOW, 항: LONG_SUM} + * `one` · `won` · `COST_SHOW` · `LONG_SUM` = `line_stack_out.ts` 안 정의를 그대로 읽어 돌림(내보내지 않는 값). */ +const fs = require("fs"); +const path = require("path"); +const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript")); + +const cache = new Map(); +function load(at) { + if (cache.has(at)) return cache.get(at); + const js = ts.transpileModule(fs.readFileSync(at, "utf8"), { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText; + const box = { exports: {} }; + cache.set(at, box.exports); + const need = (p) => { + if (p.endsWith(".css")) return {}; + return p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p); + }; + new Function("exports", "module", "require", js)(box.exports, box, need); + return box.exports; +} +const ROOT = path.join(__dirname, "..", ".."); +const eq = load(path.join(ROOT, "ui_template", "ui_template_equation.ts")); +const unit = load(path.join(ROOT, "common_util", "common_util_line_stack_unit.ts")); +const view = load(path.join(ROOT, "common_util", "common_util_formula_doc_view.ts")); +const stack = load(path.join(ROOT, "common_util", "common_util_line_stack.ts")); + +// line_stack_out.ts 안 정의(내보내지 않음) — 그 줄 글을 그대로 떼어 돌림 +const out = fs.readFileSync(path.join(ROOT, "A00_Common", "line_stack_out.ts"), "utf8"); +const grab = (re) => { + const m = out.match(re); + if (!m) throw new Error(`line_stack_out.ts 에서 못 찾음: ${re}`); + return m[0]; +}; +const defs = [ + grab(/const COST_SHOW: Record = \{[^}]*\};/), + grab(/const won = \(n: number\): string => [^;]*;/), + grab(/const one = \(n: number\): string =>\s*n\.toLocaleString\([^;]*;/), + grab(/const LONG_SUM = \d+;/), +].join("\n"); +const js = ts.transpileModule(`${defs}\nreturn { COST_SHOW, won, one, LONG_SUM };`, { + compilerOptions: { target: ts.ScriptTarget.ES2020 }, +}).outputText; +const local = new Function("eqText", js)(eq.eqText); + +const input = JSON.parse(fs.readFileSync(0, "utf8")); +const res = { + eq: (input.수 || []).map((v) => eq.eqText(v)), + one: (input.원 || []).map((v) => local.one(v)), + won: (input.원 || []).map((v) => local.won(v)), + 단위: (input.단위 || []).map((u) => unit.unitText(u)), + 금액줄: (input.금액줄 || []).map((x) => + unit.moneyUnits( + x.줄, + view.tryParse(x.줄.단가), + view.tryParse(x.줄.수량), + x.단가변수 || undefined, + x.부름 || null, + ), + ), + 기호: (input.금액줄 || []).map((x) => stack.priceSym(x.줄)), + 꺼짐: (input.꺼짐 || []).map((x) => + (x.문서.금액 || []).map((line) => view.offLine(line, x.값, view.lineMap(x.문서))), + ), + 비목: local.COST_SHOW, + 항: local.LONG_SUM, +}; +process.stdout.write(JSON.stringify(res)); diff --git a/resources/tester/helper_855_engine.py b/resources/tester/helper_855_engine.py new file mode 100644 index 000000000..224cead19 --- /dev/null +++ b/resources/tester/helper_855_engine.py @@ -0,0 +1,164 @@ +"""855-A 지킴 도우미 — 로직마다 셈 경우(기본 + 옵션 표본) · 옛 엔진 대 새 계산기 층 가름 · 새 답 지문. + +- 경우 = 빌더 대조와 같은 표본(`build_수식문서_802_2.build`) — 기본 입력(수식 탭 기본값) + 고르기 입력의 + 다른 갈래 하나씩(나머지 기본). +- 옛 = `master_formula.run` → `master_cut.engine` · 새 = 저장된 수식 문서(`master_doc_link.load_all`) · + `master_doc_calc.calc`. +- 층(앞 층이 다르면 뒤 층 안 봄): L0 합계 · L1 줄 이름별 비목 금액 · L2 줄 꼴(차례 · 이름 · 금액 · 비목) · + L3 수량 · 단가. 「보임」 = 금액은 같고 보이는 단가만 다름(옛 = 줄 끝수 자리로 자른 단가 · 새 = 날 값 / + 수량 0 줄 단가 0 ↔ 빈 값 / 값 없는 줄 단가 빈 값 ↔ 채움 / 묶음 단가 = 계로 맞댐). +""" + +from __future__ import annotations + +import hashlib +import importlib +import json +from collections import defaultdict +from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal +from functools import lru_cache + +from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠 + +mf = importlib.import_module("master_formula") +mcut = importlib.import_module("master_cut") +mc = importlib.import_module("master_doc_calc") +ml = importlib.import_module("master_doc_link") +meq = importlib.import_module("master_equation") +build = importlib.import_module("build_수식문서_802_2") + +KEYS = ("노무비", "재료비", "경비", "계") +SEEN = "보임" + + +@lru_cache(maxsize=1) +def world(): + """(로직 줄 목록, M01 색인, 수식 문서 {키: 문서}, 연결).""" + files, whole = m01.loaded() + docs = ml.load_all() + rows = [r for d in files.values() if d.get("그룹") == "로직" for r in d.get("줄") or []] + return rows, whole, docs, ml.Links(whole, docs) + + +def cases(row: dict, options: bool) -> list[tuple[str, dict, dict | None]]: + """(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력).""" + whole = world()[1] + base = meq.given_of(whole, row) + out = [("", base, None)] + if options: + for spec in row.get("입력") or []: + for opt in spec.get("고르기") or []: + if str(opt) != str(base.get(spec["이름"])): + one = {spec["이름"]: opt} + out.append((f"{spec['이름']}={opt}", {**base, **one}, one)) + return out + + +def old_run(row: dict, given: dict): + whole = world()[1] + try: + return mcut.engine(whole, row["키"], mf.run(whole, row["키"], mf.fill_empty(row, given))) + except Exception: # 옛 엔진 멈춤도 대조 값 + return None + + +def new_run(doc: dict, changed: dict | None): + try: + got = mc.calc(doc, world()[3], changed) + except Exception: + return None + return got if got.get("셈됨") else None + + +def _d(v): + try: + return Decimal(str(v)) + except Exception: + return None + + +def _unit(v): + return _d(v.get("계")) if isinstance(v, dict) else _d(v) + + +def _per_name(lines) -> dict: + acc: dict = defaultdict(lambda: defaultdict(Decimal)) + for ln in lines or []: + for k, v in (ln.get("비목") or {}).items(): + if _d(v) is not None: + acc[str(ln.get("이름"))][k] += _d(v) + return {n: {k: v for k, v in b.items() if v} for n, b in acc.items()} + + +def _shape(lines) -> list: + return [ + ( + str(ln.get("이름")), + _d(ln.get("금액")), + tuple(sorted((k, _d(v)) for k, v in (ln.get("비목") or {}).items() if v is not None)), + ) + for ln in lines or [] + ] + + +def _cut_only(a, b) -> bool: + """옛 단가 = 새 날 값을 옛 자리로 자른 값(버림 · 반올림 · 올림 어느 하나).""" + ua, ub = _unit(a.get("단가")), _unit(b.get("단가")) + if ua is None and _d(a.get("금액")) is None and _d(b.get("금액")) is None: + return True # 값 없는 줄 — 금액 둘 다 빈 값 + if ub is None and ua == 0 and _d(a.get("수량")) == 0: + return True # 수량 0 줄 — 금액 0 + if ua is None or ub is None: + return False + return ua in (ub.quantize(ua, m) for m in (ROUND_DOWN, ROUND_HALF_UP, ROUND_UP)) + + +def level(old, new, money: bool) -> str | None: + """다름 층 — None = 같음(둘 다 못 셈 포함) · 「보임」 = 보이는 단가만 다름.""" + if old is None or new is None: + return None if old is None and new is None else "L0" + keys = KEYS if money else ("결과",) + if any(_d(old.get(k)) != _d(new.get(k)) for k in keys): + return "L0" + if not money: + return None + if _per_name(old["줄"]) != _per_name(new["줄"]): + return "L1" + if _shape(old["줄"]) != _shape(new["줄"]): + return "L2" + seen = False + for a, b in zip(old["줄"], new["줄"]): + if _d(a.get("수량")) != _d(b.get("수량")): + return "L3" + if _unit(a.get("단가")) != _unit(b.get("단가")): + if not _cut_only(a, b): + return "L3" + seen = True + return SEEN if seen else None + + +def adopted(key: str, label: str, lv: str) -> bool: + """채택된 차이(요구 714-3 · 빌더 `ADOPTED`) — 합계는 그 목록만 · 줄 비목은 같은 까닭 + (식 속 단가산출 부름 = 끝수 뒤 값)이 있는 문서만.""" + if lv == "L0": + return (key, label) in build.ADOPTED + return lv == "L1" and build._uses_raw_sub(world()[2][key]) + + +def answer(got) -> object: + """새 답의 지문 꼴 — 노 · 재 · 경 · 계(돈 아닌 = 결과) · 줄(이름 · 금액 · 비목).""" + if got is None: + return "못 셈" + if "결과" in got and got.get("계") is None: + return {"결과": str(got.get("결과"))} + return { + "합": [str(got.get(k)) for k in KEYS], + "줄": [[n, str(m), [[k, str(v)] for k, v in b]] for n, m, b in _shape(got.get("줄"))], + } + + +def fingerprint(key: str, row: dict, options: bool = True) -> str: + doc = world()[2][key] + got = [[label, answer(new_run(doc, changed))] for label, _, changed in cases(row, options)] + raw = json.dumps(got, ensure_ascii=False, sort_keys=True) + return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] diff --git a/resources/tester/helper_m02_hopyo_unit.cjs b/resources/tester/helper_m02_hopyo_unit.cjs deleted file mode 100644 index f7b9c8c5f..000000000 --- a/resources/tester/helper_m02_hopyo_unit.cjs +++ /dev/null @@ -1,13 +0,0 @@ -/* 784-2 — `logic/M02_MasterTemplete_Hopyo_Unit.ts` 단위 환산 보이기 판정을 트랜스파일해 Node 로 돌림. - * stdin = {cases: [{part, from, to}]} · stdout = unitView 결과 배열 JSON. */ -const fs = require("fs"); -const path = require("path"); -const { makeLoader } = require("./helper_ts_stub_loader.cjs"); - -const ROOT = path.join(__dirname, "..", ".."); -const { loadTs } = makeLoader({ root: ROOT }); -const unit = loadTs( - path.join(ROOT, "M02_MasterTemplete", "logic", "M02_MasterTemplete_Hopyo_Unit.ts"), -); -const input = JSON.parse(fs.readFileSync(0, "utf8")); -process.stdout.write(JSON.stringify(input.cases.map((c) => unit.unitView(c.part, c.from, c.to)))); diff --git a/resources/tester/test_553_5_m01_m02.py b/resources/tester/test_553_5_m01_m02.py index e967d5299..d2903c4ec 100644 --- a/resources/tester/test_553_5_m01_m02.py +++ b/resources/tester/test_553_5_m01_m02.py @@ -103,4 +103,3 @@ def test_m02_dataflow_muted_spans_use_ui_text(): css = "".join(_m02_src(".css").values()) for gone in ("m02-dfip__muted", "m02-dfout__muted", "m02-dfver__muted"): assert gone not in ts and gone not in css, f"옛 변종 {gone} 남음" - assert len(re.findall(r'"ui-text ui-text--muted",\s*attrs: \{ "data-text": "14" \}', ts)) >= 21 diff --git a/resources/tester/test_704_logic_standard.py b/resources/tester/test_704_logic_standard.py index 133ed7766..fcc306ce0 100644 --- a/resources/tester/test_704_logic_standard.py +++ b/resources/tester/test_704_logic_standard.py @@ -11,10 +11,12 @@ from __future__ import annotations +import json from pathlib import Path import pytest +from M01_MasterData import M01_MasterData_Doc as m01_doc from M01_MasterData import M01_MasterData_Store as m01 from M01_MasterData.M01_MasterData_Store_Find import hit from M02_MasterTemplete import M02_Logic_Standard as st @@ -30,18 +32,20 @@ def _rows(key: str) -> list[dict]: def _given(key: str, change: dict) -> dict: whole = m01.loaded()[1] - return st._given(whole, whole.logic(key), change)[0] + return st._given(whole, m01_doc.docs()[key], change)[0] @pytest.mark.parametrize("key", THREE) -def test_줄_금액은_M01_시험_계산에_끝수만_버림(key: str) -> None: +def test_줄_금액은_M01_수식_탭_셈과_같음(key: str) -> None: + """855-C — 기준 목록 금액 = 수식 문서 셈(M01 수식 탭 미리 셈 · M02 단가산출과 같은 계산기).""" rows = _rows(key) assert rows + doc = json.loads(json.dumps(m01_doc.docs()[key], default=float)) # 화면 JSON 꼴 문서 for row in rows: - got = m01.calc(key, _given(key, row["바꿈"])) - assert got["ok"], got - gap = float(got["sums"]["계"]) - row["금액"] # 줄 · 비목 버림(B09 산근 규칙) — 최대 3 원 - assert -0.01 <= gap < 3.2, row["규격"] + given = st.labor_inputs._num(_given(key, row["바꿈"])) + got = m01_doc.preview(doc, given)["셈"] + assert got["셈됨"], row["규격"] + assert float(got["계"]) == row["금액"], row["규격"] def test_대표_규격_펼침() -> None: diff --git a/resources/tester/test_704_settle.py b/resources/tester/test_704_settle.py index 7e85217bd..2295c13a6 100644 --- a/resources/tester/test_704_settle.py +++ b/resources/tester/test_704_settle.py @@ -13,6 +13,7 @@ if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402 +from M01_MasterData import M01_MasterData_Doc as m01_doc # noqa: E402 from M01_MasterData import M01_MasterData_Store as m01 # noqa: E402 from M02_MasterTemplete import M02_Logic_Settle as st # noqa: E402 from M02_MasterTemplete import M02_Logic_Standard as ls # noqa: E402 @@ -39,7 +40,7 @@ def test_줄마다_버림_비목마다_버림_B09와_같음(): for row in data.get("줄") or []: if not _plain(row) or checked >= 60: continue - base, _ = ls.axes(whole, row) + base, _ = ls.axes(whole, m01_doc.docs()[row["키"]]) given = mf.fill_empty(row, base) got = mf.run(whole, row["키"], given) lines = [] @@ -70,6 +71,5 @@ def test_계산서_줄_소계_계가_맞물림(): assert group["소계"] == int(group["소계"]) assert group["소계"] <= sum(lines) < group["소계"] + 1 + Decimal("0.05"), group["비목"] assert got["계"] == sum(g["소계"] for g in got["묶음"]) - assert got["계"] == ls._money( - whole, whole.logic(key), ls._given(whole, whole.logic(key), {})[0] - ) + doc = m01_doc.docs()[key] # 855-C 계산서 = 문서 셈(목록 금액과 같은 값) + assert got["계"] == ls._money(doc, ls._links(whole), ls._given(whole, doc, {})[0]) diff --git a/resources/tester/test_713_3_list.py b/resources/tester/test_713_3_list.py index 6b80efb34..a806e2027 100644 --- a/resources/tester/test_713_3_list.py +++ b/resources/tester/test_713_3_list.py @@ -2,6 +2,8 @@ from __future__ import annotations +from collections import Counter + from M01_MasterData import M01_MasterData_Router as router from M01_MasterData import M01_MasterData_Store_List as store_list @@ -19,8 +21,10 @@ def test_목록_줄_수_그대로_덧칸_다_있음() -> None: def test_묶음_작업량_부르기() -> None: more = store_list.extras() # 한 절에 로직 둘 넘음(조사 12-B ㉯ 323 → 713-4 합침 · 지움 뒤 307 → 782 건설 기초 335 → 794-2b 3-2-1 둘 337 → 813-2 작업량당 기계경비 6 지움 328) - # → 822-2 · 822-2b 새 기계경비식 GC001196~1201 여섯이 8 절(건설기계) 묶음에 듦 334 - assert sum(1 for v in more.values() if v["묶음"]) == 334 + # → 822-2 · 822-2b · 848-4 새 기계경비식은 8 절(건설기계) 묶음에 듦 · 묶음수 = 같은 묶음 로직 수(둘 이상) + groups = Counter((v["묶음"], v["묶음수"]) for v in more.values() if v["묶음"]) + assert groups and all(size >= 2 and n % size == 0 for (_, size), n in groups.items()) + assert all(more[f"GC00{n}"]["묶음"] == "8" for n in range(1196, 1203)) work = {k for k, v in more.items() if v["작업량"]} assert len(work) == 65 # 27 − 터파기 작업량 6(713-4 · 단가 로직 안에 품음) + 782 시공능력 44 assert more["GF000098"]["부모"] == ["GF000099"] # 측구터파기 작업량 → 단가 로직 밑 diff --git a/resources/tester/test_714_1_sheet_line.py b/resources/tester/test_714_1_sheet_line.py index a317f93e4..61cbf574f 100644 --- a/resources/tester/test_714_1_sheet_line.py +++ b/resources/tester/test_714_1_sheet_line.py @@ -1,5 +1,5 @@ -"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) · M01 `/text` 와 -M02 `/logic-lib/sheet` 가 같은 줄 꼴(`master_sheet_line`).""" +"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) — M01 `/text`. +(M02 `/logic-lib/sheet` 는 855-C 부터 문서 셈 · `master_doc_text` 글 — `test_855_c4_doc_text`.)""" from __future__ import annotations @@ -11,10 +11,8 @@ sys.path.insert(0, str(ROOT)) from M01_MasterData import M01_MasterData_Store as store # noqa: E402 from M01_MasterData import M01_MasterData_Store_Sheet as sheet # noqa: E402 -from M02_MasterTemplete import M02_Logic_Standard as standard # noqa: E402 msl = sheet.msl -num = standard.labor_inputs._num # Decimal → JSON 수(두 길 같은 규칙) def _text(key: str) -> dict: @@ -61,15 +59,3 @@ def test_basis_note_tenfold(): assert one[0]["기준단위"] == "10㎡" and one[0]["환산근거"] == "10㎡당 → 1㎡당 ÷10" ten = _text("GF000124") assert ten["기준단위"] == "10㎡" and all(not x["환산근거"] for x in _lines(ten)) - - -def test_two_routes_same_shape(): - """M01 `/text` 와 M02 계산서 — 줄 차례 · 덧칸 값이 같음(금액 끝수만 다를 수 있음).""" - for key in ("GF000169", "GF000103", "GF000219"): - m01 = _lines(_text(key)) - m02 = _lines(standard.sheet(key, {}), "묶음") - assert len(m01) == len(m02) - for a, b in zip(m01, m02): - assert set(b) == {"이름", "글", "금액", *msl.KEYS} - assert a["이름"] == b["이름"] - assert num([a.get(k) for k in msl.KEYS]) == [b.get(k) for k in msl.KEYS] diff --git a/resources/tester/test_720_m02_folder_layer.py b/resources/tester/test_720_m02_folder_layer.py index 112a5c7e6..92bc01d21 100644 --- a/resources/tester/test_720_m02_folder_layer.py +++ b/resources/tester/test_720_m02_folder_layer.py @@ -78,7 +78,7 @@ def test_화면_층_단추_최상위_폴더_이름_바꾸기(): def test_구조물_조합_층_제자리_바꿈(): """720-4 — 해시 이동 없음 · replaceState · 나무 · 층 줄 · 띠를 감싼 칸에 갈아 끼움 · 권한 = 함수 · - 도면 양식 = 누구나(단추는 관리자) · 불러오기 장부 = 열 때 층 · 권한.""" + 도면 양식 = 누구나(단추는 관리자).""" page = _text("M02_MasterTemplete_UI_Page.ts") assert "navigateTo" not in page switch = page.split("const switchStructure = async")[1].split("const go =")[0] @@ -96,5 +96,3 @@ def test_구조물_조합_층_제자리_바꿈(): assert "const drawing = opt.isSystem" not in side assert "if (!opt.isSystem) return [];" in side assert "items = await listTemplates(layer, null);" in side - hopyo = _text("M02_MasterTemplete_Hopyo_Side.ts") - assert "buildHopyoLedger({ scope: pageScope(), canWrite: opt.canWrite() })" in hopyo diff --git a/resources/tester/test_791_1_engine_semantics.py b/resources/tester/test_791_1_engine_semantics.py index 5fb632b80..261a0f76b 100644 --- a/resources/tester/test_791_1_engine_semantics.py +++ b/resources/tester/test_791_1_engine_semantics.py @@ -16,8 +16,6 @@ import sys from decimal import Decimal from pathlib import Path -import pytest - from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠 mcut = importlib.import_module("master_cut") @@ -68,12 +66,16 @@ def fingerprints() -> dict: def test_M01_로직_전부_전후_같음(): saved = json.loads(FINGER.read_text(encoding="utf-8")) - if saved["마스터"] != _master_hash(): - pytest.skip("마스터 데이터 바뀜 — 지문 다시 뜸: python resources/tester/test_791_1_…py") now = fingerprints() - assert len(now) == len(saved["결과"]) >= 1513 # 813-2 작업량당 기계경비 6 지움 - diff = sorted(k for k in now if now[k] != saved["결과"].get(k)) - assert not diff, f"셈 결과 바뀐 로직 {len(diff)} 개: {diff[:10]}" + diff = sorted( + set(now) ^ set(saved["결과"]) | {k for k in now if now[k] != saved["결과"].get(k)} + ) + # 자료가 바뀌어도 건너뛰지 않음 — 셈 결과가 같으면 통과 · 다르면 실패(자료 탓이면 지문 다시 뜸) + why = "마스터 데이터 바뀜" if saved["마스터"] != _master_hash() else "엔진만 바뀜" + assert not diff, ( + f"셈 결과 바뀐 로직 {len(diff)} 개({why}): {diff[:10]} — 자료를 뜻대로 고쳤으면 " + "엔진 고치기 전 커밋에서 지문 다시 뜸: python test_791_1_engine_semantics.py" + ) # ── 시험 마스터 ─────────────────────────────────────────────────────── diff --git a/resources/tester/test_793_2_san_emit.py b/resources/tester/test_793_2_san_emit.py index c06984c6a..4c018f4a0 100644 --- a/resources/tester/test_793_2_san_emit.py +++ b/resources/tester/test_793_2_san_emit.py @@ -26,6 +26,12 @@ mf = importlib.import_module("master_formula") mcut = importlib.import_module("master_cut") ms = importlib.import_module("master_formula_sum") + +def _nodes(rows): + """[{행, G}] → 줄 나무(옛 `San_Stmate.parse_block` 꼴 · 지금 길 = `Doc_FromNative._emit` 이 줄마다 `parse_line`).""" + return [{"행": r.get("행"), "글": r.get("G") or "", **stm.parse_line(r.get("G"))} for r in rows] + + STMATE = { # 파일: (블록, 금액 줄, 계표시 줄, 끝전) "봉화": (62, 349, 184, "비목버림"), "동부청영월": (69, 411, 230, "합버림_큰나머지"), @@ -72,7 +78,7 @@ def _load(tag: str) -> dict: def _stmate(tag: str, blk: dict) -> tuple[list, dict]: - nodes = stm.parse_block(blk["몸"]) + nodes = _nodes(blk["몸"]) return nodes, em.stmate(blk, nodes, _load(tag)["단가"], STMATE[tag][3]) @@ -150,7 +156,7 @@ def test_link_keys_m01() -> None: """호표 줄 = 793-2 꼴(종류 · 단가 · 이음 = 1차 줄 판정 M01 키) · 덧칸 자원 · 원본.""" tag = "봉화" blk = next(b for b in _load(tag)["블록"] if b["코드"] == "D00102") - out = em.stmate(blk, stm.parse_block(blk["몸"]), _load(tag)["단가"], "비목버림", True) + out = em.stmate(blk, _nodes(blk["몸"]), _load(tag)["단가"], "비목버림", True) labor = next(x for x in out["로직"]["호표"] if x["이름"] == "보통인부") assert {k: v for k, v in labor.items() if k != "자원"} == { "이름": "보통인부", @@ -207,7 +213,7 @@ def test_stmate_grammar_sample_engine() -> None: "'뒤 인부' &L00007& * 0.01 =", ] rows = [{"행": i, "G": g} for i, g in enumerate(text)] - nodes = stm.parse_block(rows) + nodes = _nodes(rows) block = {"코드": "D00001", "이름": "견본", "꼬리": [], "몸": rows} block["머리"] = {"A": "", "B": "", "C": 0, "D": 0, "E": 0, "F": 0} out = em.stmate(block, nodes, prices, "비목버림") diff --git a/resources/tester/test_797_1a_import_flags.py b/resources/tester/test_797_1a_import_flags.py index dbed88327..82c1bebc9 100644 --- a/resources/tester/test_797_1a_import_flags.py +++ b/resources/tester/test_797_1a_import_flags.py @@ -24,6 +24,11 @@ NOTE = em.NOTE DOCS = golden.DOCS +def _nodes(rows): + """[{행, G}] → 줄 나무(옛 `San_Stmate.parse_block` 꼴 · 지금 길 = `Doc_FromNative._emit` 이 줄마다 `parse_line`).""" + return [{"행": r.get("행"), "글": r.get("G") or "", **stm.parse_line(r.get("G"))} for r in rows] + + def notes(out: dict) -> list[str]: return [m for m in out["원본"]["표지"] if NOTE in m] @@ -60,7 +65,7 @@ def test_applied_or_first_column_is_flagged() -> None: ) nothing = book.applied_how(_row((None,) * 4, (0, 0, 0, 0))) assert nothing[1] is None # 쓸 값이 없는 줄 - assert book.applied(_row((100, 40, 30, 30), (90, 40, 30, 20)))["T"] == 100 + assert book.applied_how(_row((100, 40, 30, 30), (90, 40, 30, 20)))[0]["T"] == 100 def test_first_column_note_reaches_block_flags() -> None: @@ -88,7 +93,7 @@ def _stmate_out(meta: dict) -> dict: rows = [{"행": 0, "G": "'보통인부' &L00007& * 1 :=A01"}] block = {"코드": "D00001", "이름": "견본", "꼬리": [], "몸": rows} block["머리"] = {"A": "", "B": "", "C": 0, "D": 0, "E": 0, "F": 0} - return em.stmate(block, stm.parse_block(rows), prices, "비목버림") + return em.stmate(block, _nodes(rows), prices, "비목버림") def test_adjust_ratio_and_bid_rate_are_flagged() -> None: diff --git a/resources/tester/test_800_2_equation_layout.py b/resources/tester/test_800_2_equation_layout.py index 65fb20dff..079c35b7e 100644 --- a/resources/tester/test_800_2_equation_layout.py +++ b/resources/tester/test_800_2_equation_layout.py @@ -9,6 +9,7 @@ from pathlib import Path ROOT = Path(__file__).resolve().parents[2] sys.path[:0] = [str(ROOT), str(ROOT / "resources/master_data/scripts")] +from M01_MasterData import M01_MasterData_Doc as doc # noqa: E402 from M01_MasterData import M01_MasterData_Equation as eq # noqa: E402 from M01_MasterData import M01_MasterData_Store as store # noqa: E402 @@ -117,10 +118,10 @@ def test_drop_guard_and_unused_input(): def test_candidates(): whole = store.loaded()[1] - got = eq.links({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""}) + got = doc.candidates({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""}) assert got["후보"] and "조건" in got["후보"][0] - assert eq.links({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"] - assert eq.links({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"] + assert doc.candidates({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"] + assert doc.candidates({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"] assert whole is not None diff --git a/resources/tester/test_812_1_xlsx_golden.py b/resources/tester/test_812_1_xlsx_golden.py index 613056cf7..0f62d6cb4 100644 --- a/resources/tester/test_812_1_xlsx_golden.py +++ b/resources/tester/test_812_1_xlsx_golden.py @@ -379,14 +379,19 @@ def sweep(tag: str) -> dict: path = practice.FILES[tag] saved = fn.pack(excel(tag), path.name) out = {"블록": 0, "같음": 0, "다름": set(), "변수줄": 0, "자원줄": 0, "자원추정": 0} + out["옛 검산 다름"] = set() for ln in (x for b in saved["산근"] for x in b["줄"]): out["변수줄"] += bool(ln.get("변수")) out["자원줄"] += bool(ln.get("자원")) for no, blk in fn.numbers(saved).items(): out["블록"] += 1 emitted = fn.emit(saved, no) - _, _, got = nd.doc_and_money(emitted) + sk, _, got = nd.doc_and_money(emitted) mine = {c: got.get(k) for c, k in nd.COST} + old = nd.imp._money(nd.imp._run(sk, nd.whole())) or {} # 855-A 옛 검산(옛 엔진) + pair = [(old.get(k), got.get(k)) for _, k in nd.COST] + if any(a is None or b is None or nd.D(str(a)) != nd.D(str(b)) for a, b in pair): + out["옛 검산 다름"].add((tag, no)) nag = (emitted["원본"].get("계약") or {}).get("낙찰률") if nag: for c in "LMS": @@ -408,3 +413,4 @@ MONEY_SAMPLE = ("거창", "봉화") def test_money_equals_excel(tag: str) -> None: got = sweep(tag) assert got["블록"] and got["다름"] == {x for x in ODD_MONEY if x[0] == tag}, sorted(got["다름"]) + assert got["옛 검산 다름"] == set(), sorted(got["옛 검산 다름"]) # 855-A 옛 검산 = 새 셈 diff --git a/resources/tester/test_813_2_parts.py b/resources/tester/test_813_2_parts.py index bb8997c32..017bf00dc 100644 --- a/resources/tester/test_813_2_parts.py +++ b/resources/tester/test_813_2_parts.py @@ -95,10 +95,6 @@ def test_기계_부품(): assert {"GC001147", "GF000088"} <= tpl and len(tpl) == 15 coef = m01_router.get_parts("계수식")["계수식"] assert {x["키"] for x in coef} == {"GC001143", "GC001191", "GC001192", "GC001193"} - one = parts.of_machine("0201-0070") - assert one["기계"] == {"이름": "굴착기(무한궤도)", "규격": "0.7㎥", "상세구분": "굴착기"} - by = {t["키"]: t for t in one["틀"]} - assert by["GC001147"]["규격"] == "버킷용량" and by["GF000088"]["문서"]["결과"] == "Q" def test_변환기가_표지를_옮김(): diff --git a/resources/tester/test_826_1_layer_index.py b/resources/tester/test_826_1_layer_index.py index d0836623a..c285e2302 100644 --- a/resources/tester/test_826_1_layer_index.py +++ b/resources/tester/test_826_1_layer_index.py @@ -133,12 +133,12 @@ def test_edit_delete_add_and_dep_change(fresh, reads): assert set(reads) == {f"sangeun/{a}", f"sangeun/{c}"} # 바뀐 항목만 다시 읽음 assert rows == _old(mine) titles = {r["이름"]: r.get("제목") for r in rows if r["종류"] in index.layers.LIBRARY_KINDS} - assert gone == c and titles == { + assert gone != c and titles == { a: "가", b: "나", c: "다", sc: "일위대가", - } # 지운 키를 새 것이 받음 + } # 지운 키는 빠지고 새 것은 새 번호(854-1 · 지운 번호 안 다시 씀) reads.clear() was = {r["이름"]: r.get("기준금액") for r in _new(mine)} assert reads == [] diff --git a/resources/tester/test_827_1_machine_window.py b/resources/tester/test_827_1_machine_window.py index a3259c05d..4532bd602 100644 --- a/resources/tester/test_827_1_machine_window.py +++ b/resources/tester/test_827_1_machine_window.py @@ -201,7 +201,7 @@ def test_company_and_other_refused(world): _at(world["company"], path.preview, sk, {"문서": doc}) assert e.value.status == 404 with pytest.raises(HTTPException) as e: - route.my_machine_draft("personal", route.MachineBody(줄=_body()), "7/43", USER) + route.my_machine_create("personal", route.MachineBody(줄=_body()), "7/43", USER) assert e.value.status_code == 403 with pytest.raises(HTTPException) as e: doc_route.save_doc("personal", sk, doc_route.DocBody(문서=doc, 판=""), "7/43", USER) diff --git a/resources/tester/test_827_3_material_pick.py b/resources/tester/test_827_3_material_pick.py index 43e2ce09a..a33662718 100644 --- a/resources/tester/test_827_3_material_pick.py +++ b/resources/tester/test_827_3_material_pick.py @@ -173,7 +173,6 @@ def test_apart_item_zero(world) -> None: var = _var(conv, e["기호"]) assert e["별도계상"] and var["연결"]["갈래"] == "숫자" assert f"별도계상 · 품목: {gov['이름']} {gov['규격']} · 셈은 프로젝트에서" in var["설명"] - assert mp.item_key(mine["자원"]) == gov["키"] assert skpath.read(got["이름"])["셈"] == skpath.read(plain["이름"])["셈"] # 이미 만든(고름 전) SK 에 물음 예 = 품목 설명만 · 단가 0 그대로 money = skpath.read(plain["이름"])["셈"] diff --git a/resources/tester/test_854_1_my_machine_lock.py b/resources/tester/test_854_1_my_machine_lock.py new file mode 100644 index 000000000..0e3c84833 --- /dev/null +++ b/resources/tester/test_854_1_my_machine_lock.py @@ -0,0 +1,119 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""854-1 안전 고침 — 내 기계 저장 잠금 · 판 대조 · 번호 겹침 없음(임시 storage · M01 정본 안 고침). + +① 스레드 여럿이 동시에 만들기 → 번호 겹침 0 · 파일 수 = 요청 수 ② 옛 판으로 고치기 = 409 · 새 판 = 됨 +③ `_다음` 이 뒤처져도 있는 파일 번호를 덮지 않음. +""" + +from __future__ import annotations + +import json +import time +from concurrent.futures import ThreadPoolExecutor + +import pytest + +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_MyMachine as mym +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + +N = 8 + + +def _at(folder, fn, *args): + with store.at(folder): + return fn(*args) + + +def _easy(name="sub4임시기계", **vals): + base = {"가격": 1000, "손료계수": 2000, "주연료": 2, "주연료종류": "경유"} + return {"이름": name, "규격": "1㎾", "방식": "바로", "값": base | vals} + + +def test_parallel_create_no_clash(world, monkeypatch): + """① 동시 만들기 N 번 — 키 N 개 모두 다름 · 파일 N 개 · 줄마다 자기 이름(쓰기마다 늦춰 틈을 벌림).""" + me = world["personal"] + write = mym.atomic_write_json + + def slow(path, value): + time.sleep(0.02) + write(path, value) + + monkeypatch.setattr(mym, "atomic_write_json", slow) + with ThreadPoolExecutor(N) as pool: + got = list(pool.map(lambda i: _at(me, mym.create, _easy(f"sub4임시{i}"))["줄"], range(N))) + keys = [r["키"] for r in got] + assert len(set(keys)) == N + files = sorted((me / mym.DIR).glob(f"{mym.PREFIX}*.json")) + assert len(files) == N + names = {json.loads(p.read_bytes())["이름"] for p in files} + assert names == {f"sub4임시{i}" for i in range(N)} + assert json.loads((me / mym.DIR / mym.NEXT).read_bytes())["다음"] == N + 1 + + +def test_stale_version_409(world): + """② 연 판으로 고침 = 됨(새 판 받음) · 옛 판으로 한 번 더 = 409 {stale, 판} · 판 없음 = 대조 없음.""" + me = world["personal"] + made = _at(me, mym.create, _easy()) + key, old = made["줄"]["키"], made["판"] + assert old + fresh = _at(me, mym.update, key, _easy(가격=3000), old) + assert fresh["판"] and fresh["판"] != old + with pytest.raises(store.StoreError) as e: + _at(me, mym.update, key, _easy(가격=4000), old) + assert e.value.status == 409 and e.value.detail == {"stale": [key], "판": fresh["판"]} + assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 3000 # 막힌 고침은 안 적힘 + _at(me, mym.update, key, _easy(가격=5000)) # 서버 길(초안 저장) = 대조 없음 + assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 5000 + + +def test_counter_behind_skips_file(world): + """③ `_다음` 이 옛 번호를 가리켜도 있는 파일은 안 덮음 — 다음 빈 번호.""" + me = world["personal"] + first = _at(me, mym.create, _easy("sub4임시처음"))["줄"]["키"] + (me / mym.DIR / mym.NEXT).write_text('{"다음": 1}', encoding="utf-8") + second = _at(me, mym.create, _easy("sub4임시둘째"))["줄"]["키"] + assert second != first + assert _at(me, mym.one, first)["줄"]["이름"] == "sub4임시처음" + + +def test_brief_cache_follows_index(monkeypatch): + """④ 기계 창 목록 메모(`Machine_Hourly.brief`) — 색인이 바뀌면 새 값 · 옛 색인 메모를 안 꺼냄 · 되돌리면 처음 값.""" + from M01_MasterData import M01_MasterData_Store as m01 + from M02_MasterTemplete import M02_Machine_Hourly as mh + from M02_MasterTemplete import M02_Sangeun_Copy as skc + + key = "EQ000022" # 굴착기 — 가격 · 시간당 있음 + base = m01.loaded() + first = mh.brief([key])[0] + row = base[1].get(key) + twice = {**row, "값": {**row["값"], "가격": row["값"]["가격"] * 2}} + other = skc.Copy(base[1], [twice], ("시험854",)) + monkeypatch.setattr(m01, "loaded", lambda: (base[0], other)) + got = mh.brief([key])[0] + assert got["값"]["가격"] == first["값"]["가격"] * 2 + assert got["시간당"]["계"] > first["시간당"]["계"] + assert all(v[0] is other for v in mh._BRIEF.values()) + monkeypatch.setattr(m01, "loaded", lambda: base) + assert mh.brief([key])[0] == first + + +def test_deleted_last_key_not_reused(world): + """⑤ 단가산출(SK) · 내 재료(PM) — 끝 번호를 지운 뒤 새로 만들면 새 번호(지운 번호 안 다시 씀).""" + from M02_MasterTemplete import M02_Labor_Ref as refs + from M02_MasterTemplete import M02_Material_Own as own + + me = world["personal"] + body = {"단위": "시간", "더한줄": []} + made = [ + _at(me, refs.create, "sangeun", {**body, "이름": f"sub4임시{i}"})["이름"] for i in range(2) + ] + assert made == ["SK-000001", "SK-000002"] + _at(me, store.delete, "sangeun", made[-1]) + assert _at(me, refs.create, "sangeun", {**body, "이름": "sub4임시3"})["이름"] == "SK-000003" + + bolt = {"이름": "sub4임시볼트", "규격": "M16", "단위": "EA", "값": 1200} + keys = [own.add(me, {**bolt, "규격": f"M{i}"})["키"] for i in (16, 20)] + assert keys == ["PM000001", "PM000002"] + own.remove(me, keys[-1]) + assert own.add(me, {**bolt, "규격": "M24"})["키"] == "PM000003" diff --git a/resources/tester/test_854_2_m01_copy_doc.py b/resources/tester/test_854_2_m01_copy_doc.py new file mode 100644 index 000000000..a53e1a438 --- /dev/null +++ b/resources/tester/test_854_2_m01_copy_doc.py @@ -0,0 +1,108 @@ +"""M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만. + +- 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글. +- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음. +""" + +from __future__ import annotations + +import importlib +import shutil +from decimal import Decimal +from pathlib import Path + +import pytest +from fastapi import FastAPI +from fastapi.testclient import TestClient + +from M01_MasterData import M01_MasterData_Doc as doc_screen +from M01_MasterData import M01_MasterData_Router as router_module +from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Make as make + +REAL = store.FOLDER +SAMPLE = "GF000219" # 산림 13-4-1 메쌓기(인력) +COSTS = ("노무비", "재료비", "경비", "계") + + +@pytest.fixture +def client(tmp_path: Path, monkeypatch) -> TestClient: + for path in REAL.glob("*.json"): + if not path.name.startswith("_") or path.name == store.mk.BOOK.name: + shutil.copy(path, tmp_path / path.name) + shutil.copytree(REAL / "기계", tmp_path / "기계") + shutil.copytree(REAL / "수식문서", tmp_path / "수식문서") + monkeypatch.setattr(store, "FOLDER", tmp_path) + monkeypatch.setattr(doc_screen.ml, "FOLDER", tmp_path / "수식문서") + doc_screen._memo.clear() + app = FastAPI() + app.include_router(router_module.router) + return TestClient(app) + + +def _get(client: TestClient, url: str, **params) -> dict: + res = client.get(url, params=params) + assert res.status_code == 200, res.text + return res.json() + + +def _post(client: TestClient, url: str, body: dict) -> dict: + res = client.post(url, json=body) + assert res.status_code == 200, res.text + return res.json() + + +def _money(answer: dict) -> dict: + return {k: Decimal(str(answer[k])) for k in COSTS} + + +def _old(key: str) -> dict: + """옛 엔진 금액(빌더 대조와 같은 길 · 기본 입력).""" + builder = importlib.import_module("build_수식문서_802_2") + whole = store.loaded()[1] + row = store.logic(key)["logic"] + return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1])) + + +def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진과_같다(client: TestClient) -> None: + made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, "이름": "sub5임시 본뜸"}) + key = made["key"] + assert key.startswith("GX") and made["수식문서"] is True + got = _get(client, "/api/m01/logic/doc", key=key) + assert got["새"] is False and got["파일"] == "수식_자체.json" and got["문서"]["식"] + assert got["셈"]["셈됨"] is True + source = _get(client, "/api/m01/logic/doc", key=SAMPLE) + assert _money(got["셈"]) == _old(key) == _money(source["셈"]) and _old(key)["계"] > 0 + + # 빌더가 다음에 다시 지어도 같은 파일 글(옛 로직 줄이 있는 키 = 빌더 몫) + builder = importlib.import_module("build_수식문서_802_2") + result = builder.build(log=lambda *_: None) + assert key in result["저장"] + want = builder.files_of(result)["수식_자체.json"] + assert (doc_screen.folder() / "수식_자체.json").read_text(encoding="utf-8") == want + + # 지우면 문서도 같이 + info = _get(client, "/api/m01/logic", key=key) + _post( + client, + "/api/m01/logic/remove", + {"key": key, "file": info["file"], "version": info["version"]}, + ) + assert _get(client, "/api/m01/logic/doc", key=SAMPLE)["새"] is False + assert key not in doc_screen.docs() + + +def test_식_복사로_만든_로직도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None: + view = _get(client, "/api/m01/logic/formula", key=SAMPLE) + made = _post( + client, + "/api/m01/logic/formula/save", + {"로직": view["로직"], "별칭": view["별칭"], "본뜬키": SAMPLE, "이름": "sub5임시 식복사"}, + ) + key = made["key"] + assert made["수식문서"] is True and key in doc_screen.docs() + assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == _old(key) + + body = {"file": make.OWN, "version": made["version"], "changes": [{"op": "delete", "key": key}]} + _post(client, "/api/m01/save", {"files": [body]}) + assert key not in doc_screen.docs() diff --git a/resources/tester/test_854_2_m01_doc_write.py b/resources/tester/test_854_2_m01_doc_write.py new file mode 100644 index 000000000..581e379ce --- /dev/null +++ b/resources/tester/test_854_2_m01_doc_write.py @@ -0,0 +1,141 @@ +"""M01 수식 문서 쓰기 안전(PLAN 854-2 · 요구 894 걸음 1) — 잠금 · 판 대조(409) · 임시 파일 → 교체. + +마스터 · 수식 문서 사본 폴더에서만 씀. +""" + +from __future__ import annotations + +import shutil +from pathlib import Path + +import pytest + +from M01_MasterData import M01_MasterData_Store as store + +REAL = store.FOLDER + + +@pytest.fixture +def master(tmp_path: Path, monkeypatch) -> Path: + for path in REAL.glob("*.json"): + if not path.name.startswith("_") or path.name == store.mk.BOOK.name: + shutil.copy(path, tmp_path / path.name) + shutil.copytree(REAL / "기계", tmp_path / "기계") + monkeypatch.setattr(store, "FOLDER", tmp_path) + return tmp_path + + +DOC_KEY = "GF000219" # 산림 13-4-1 메쌓기(인력) + + +@pytest.fixture +def docs(master: Path, monkeypatch) -> Path: + from M01_MasterData import M01_MasterData_Doc as doc_screen + + folder = master / "수식문서" + shutil.copytree(REAL / "수식문서", folder) + monkeypatch.setattr(doc_screen.ml, "FOLDER", folder) + doc_screen._memo.clear() + return folder + + +def _client(): + from fastapi import FastAPI + from fastapi.testclient import TestClient + + from M01_MasterData import M01_MasterData_Router as router_module + + app = FastAPI() + app.include_router(router_module.router) + return TestClient(app) + + +def _renamed(doc: dict, tail: str) -> dict: + return {**doc, "이름": f"{doc['이름']} {tail}"} + + +def test_옛_판으로_저장하면_409_이고_앞_저장을_덮지_않는다(docs: Path) -> None: + client = _client() + got = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() + assert got["판"] and not got["새"] + first = client.post( + "/api/m01/logic/doc/save", + json={"문서": _renamed(got["문서"], "sub5임시A"), "판": got["판"]}, + ) + assert first.status_code == 200, first.text + again = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() + assert again["판"] == first.json()["판"] != got["판"] # 저장 뒤 판 = 다시 읽은 판 + late = client.post( + "/api/m01/logic/doc/save", + json={"문서": _renamed(got["문서"], "sub5임시B"), "판": got["판"]}, + ) + assert late.status_code == 409 and "그 사이 파일이 바뀜" in late.json()["detail"] + assert again["문서"]["이름"].endswith("sub5임시A") + now = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() + assert now["문서"]["이름"].endswith("sub5임시A") # 늦은 저장이 소리 없이 덮지 않음 + assert not list(docs.glob(".*.tmp")) + + +def test_동시에_두_저장이면_하나만_되고_하나는_409(docs: Path, monkeypatch) -> None: + import threading + import time + + from M01_MasterData import M01_MasterData_Doc as doc_screen + + got = _client().get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() # 화면 꼴(수 = JSON) + real = doc_screen.layered + + def slow(doc, key): # 두 저장이 겹치게 — 판 확인 · 쓰기 사이를 넓힘 + time.sleep(0.3) + return real(doc, key) + + monkeypatch.setattr(doc_screen, "layered", slow) + plain = got["문서"] + out: list[str] = [] + + def one(tail: str) -> None: + try: + doc_screen.save(_renamed(plain, tail), got["판"]) + out.append("ok") + except doc_screen.store.StoreError as e: + out.append(str(e.status)) + + runs = [threading.Thread(target=one, args=(t,)) for t in ("sub5임시A", "sub5임시B")] + for t in runs: + t.start() + for t in runs: + t.join() + assert sorted(out) == ["409", "ok"] + + +def test_기계_목록_등록이_바꾼_문서를_옛_판_저장이_덮지_않는다(docs: Path) -> None: + from M01_MasterData import M01_MasterData_Doc as doc_screen + from M01_MasterData import M01_MasterData_Machine as machine + + key = next( + k + for k, d in doc_screen.docs().items() + if any( + v.get("이름") == "기계" and (v.get("연결") or {}).get("갈래") == "선택" + for v in d.get("변수") or [] + ) + ) + got = _client().get("/api/m01/logic/doc", params={"key": key}).json() + machine._register_docs({key: ["sub5임시EQ"]}, set()) + after = doc_screen.read(key) + assert after["판"] != got["판"] + plain = got["문서"] + with pytest.raises(doc_screen.store.StoreError) as e: + doc_screen.save(_renamed(plain, "sub5임시"), got["판"]) + assert e.value.status == 409 + picks = next(v for v in doc_screen.read(key)["문서"]["변수"] if v.get("이름") == "기계") + assert "sub5임시EQ" in picks["연결"]["목록"] + + +def test_마스터만_사본인_시험은_정본_수식_문서를_안_쓴다(master: Path) -> None: + from M01_MasterData import M01_MasterData_Doc as doc_screen + + path = doc_screen.folder() / "수식_자체.json" # 정본 폴더(사본으로 안 바꿈) + raw = path.read_bytes() + doc_screen.put(path, {"그룹": "수식문서", "로직파일": "", "줄": []}) + assert path.read_bytes() == raw diff --git a/resources/tester/test_854_2_m01_key_book.py b/resources/tester/test_854_2_m01_key_book.py new file mode 100644 index 000000000..aa3c1a97a --- /dev/null +++ b/resources/tester/test_854_2_m01_key_book.py @@ -0,0 +1,113 @@ +"""M01 저장 안전(PLAN 854-2 · 요구 894 걸음 1) — 마스터 사본 폴더에서만 씀. + +- 키 대장 · 파일 쓰기: 중간에 끊겨도 대장 · 파일이 저장 전 그대로(대장만 앞서가지 않음). +""" + +from __future__ import annotations + +import json +import shutil +from pathlib import Path + +import pytest + +from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Save as save_mod + +REAL = store.FOLDER +OWN = "로직_자체.json" +MACHINE = "EQ000002" +LABOR = "LB000002" # 보통인부 + + +@pytest.fixture +def master(tmp_path: Path, monkeypatch) -> Path: + for path in REAL.glob("*.json"): + if not path.name.startswith("_") or path.name == store.mk.BOOK.name: + shutil.copy(path, tmp_path / path.name) + shutil.copytree(REAL / "기계", tmp_path / "기계") + monkeypatch.setattr(store, "FOLDER", tmp_path) + return tmp_path + + +def _bytes(folder: Path) -> dict[str, bytes]: + out = {p.name: p.read_bytes() for p in folder.glob("*.json")} + out |= {f"기계/{p.name}": p.read_bytes() for p in (folder / "기계").glob("*.json")} + return out + + +def _new_logic() -> dict: + return { + "op": "add", + "row": { + "원문번호": "", + "구분": "자체", + "상세구분": "", + "소유": "현장", + "이름": "sub5임시 대장 시험", + "결과단위": "원/㎡", + "출처": "자체", + "입력": [], + "중간": [], + "호표": [ + { + "종류": "인력", + "요소": LABOR, + "이름": "보통인부", + "단위": "인", + "수량": "1 / 7", + "비목": "노무비", + } + ], + "덧줄": [], + "끝수": None, + }, + } + + +def _batch() -> list[dict]: + """기계 한 대 고침(기계 폴더) + 자체 로직 새 줄(GX 키 발급 = 대장 바뀜).""" + machine = json.loads((store.FOLDER / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8")) + machine["비고"] = "sub5임시" + return [ + { + "file": "기계.json", + "version": store.version("기계.json"), + "changes": [{"op": "edit", "key": MACHINE, "row": machine}], + }, + {"file": OWN, "version": store.version(OWN), "changes": [_new_logic()]}, + ] + + +@pytest.mark.parametrize("fail_at", [0, 1]) +def test_파일_쓰기가_끊기면_대장과_파일이_저장_전_그대로( + master: Path, monkeypatch, fail_at +) -> None: + before = _bytes(master) + real = save_mod._write + calls = [] + + def broken(name, was, now): + calls.append(name) + if len(calls) - 1 == fail_at: + if fail_at: # 둘째 파일은 쓴 뒤에 끊김(반쯤 쓴 꼴) + real(name, was, now) + raise OSError("디스크 흉내 실패") + return real(name, was, now) + + monkeypatch.setattr(save_mod, "_write", broken) + with pytest.raises(OSError): + store.save(_batch()) + after = _bytes(master) + assert after == before # 대장 · 기계 · 로직 파일 모두 저장 전 글 그대로 + assert not list(master.glob(".*.tmp")) and not list((master / "기계").glob(".*.tmp")) + + +def test_끊김_없으면_대장과_파일이_같이_간다(master: Path) -> None: + book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("GX", 1) + store.save(_batch()) + book = store.mk.load_book(master / store.mk.BOOK.name) + keys = [r["키"] for r in json.loads((master / OWN).read_text(encoding="utf-8"))["줄"]] + assert f"GX{book_before:06d}" in keys and book["다음"]["GX"] == book_before + 1 + machine = json.loads((master / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8")) + assert machine["비고"] == "sub5임시" diff --git a/resources/tester/test_855_b09_golden.py b/resources/tester/test_855_b09_golden.py new file mode 100644 index 000000000..2d1daf1b3 --- /dev/null +++ b/resources/tester/test_855_b09_golden.py @@ -0,0 +1,264 @@ +# ruff: noqa: F811, E402 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 · `--write` 때 길을 먼저 둠 +"""855-F B9-0 — B08 · B09 답 지문(옛 엔진 부름을 걷는 걸음 B9-1 ~ B9-6 의 「다름 0」 자). + +임시 storage(개인 층 7/42) · 견본을 시험이 지음 → 사본 만들기(지금 길) → 답 지문: +- 층 견본 — 단가산출(SK): 바탕 로직 · 율 더한줄 · 형제(바탕 참조) · 「따로」 · 가져온 식 · 기계 · 재료 / + 일위대가(SC): SK 참조 · 고정 · 로직 줄 + 자재 +- 구조물 사본 = 일위대가 열 문서(위 참조 + 로직 · 고른 재료 · 자재) → `labor_doc_rows` · `price_bundle` + · B09 서고 사본 = `Bill_Library.import_copy`(SK 따로 · SK 가져온 식 · SC) +- 손 줄 = 설계내역서 로직 줄(율 · 고른 재료 · 입력) + 운반공(거리 채움) +- 답 = B09 `calc_user` · `daega_inputs` · 단가 수요 키(`_demand`) · 산근(`Sangeun.build` · 관급 있음 · 없음) + · `logic_preview`(손 줄마다) · B08 `snapshot_units` — 갈래마다 지문(값 · 글 따로). + +지문 = `golden_855_b09.json` · 다르면 실패 — 뜻대로 금액 · 글을 바꾼 걸음만 다시 뜸: +`./venv/Scripts/python.exe resources/tester/test_855_b09_golden.py --write`(바뀐 갈래를 커밋 글에). +""" + +from __future__ import annotations + +import asyncio +import copy +import hashlib +import json +import os +import re +import sys +from pathlib import Path + +import pytest + +ROOT = Path(__file__).resolve().parents[2] +if str(ROOT) not in sys.path: # `--write` 로 바로 돌릴 때 + sys.path.insert(0, str(ROOT)) + +from B08_Quantity import B08_Quantity_Router_Material as b08 +from B09_Estimation import B09_Estimation_Bill_Library as library +from B09_Estimation import B09_Estimation_Router as b09 +from B09_Estimation import B09_Estimation_Sangeun as sangeun +from B09_Estimation import B09_Estimation_Store as b09_store +from B09_Estimation.B09_Estimation_Labor_Source import daega_inputs +from M02_MasterTemplete import M02_Doc_Sk_Path as sk_path +from M02_MasterTemplete import M02_Item_Snapshot as snapshots +from M02_MasterTemplete import M02_Item_Source as source +from M02_MasterTemplete import M02_Labor_Doc as labor +from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sangeun_Imported as imported +from resources.tester.test_145_2_b09_labor_calc import _item, _project +from resources.tester.test_793_2_sangeun_imported import _bonghwa +from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층 + +HERE = Path(__file__).resolve().parent +FILE = HERE / "golden_855_b09.json" +REDO = "./venv/Scripts/python.exe resources/tester/test_855_b09_golden.py --write" +WRITE = os.environ.get("S855B09_WRITE") == "1" +OWNER = "7/42" + +FORM = "GC000211" # 합판거푸집 — 옵션 · 재료 · 인력 +PCT = "GC001109" # 인력 둘 + 「노무비 * 3 / 100」 덧줄(율) +SUB = "GC000999" # 원/주 · 고소작업차 로직 줄 + 덧줄 공구손료 % +NET = "GC000337" # 낙석방지망 — 노무 · 크레인(중기) · 자재 셋 +NET_IN = {"구분": "기계식", "방지망": "포켓식", "지역": "전국평균", "크레인": "2104-0010"} +DIG = "GF000089" # 토사깍기(기계) — 굴착기 시간당 +STONE = "GF000219" # 돌쌓기 메쌓기(인력) +TWO_MATS = "GC000565" # 재료 줄 둘(고른 재료 열쇠) +HAUL = "GF000134" # 골재운반(운반공 · 거리로 입력 채움) +FIXED = { + "고정": { + "이름": "sub6임시 손 단가", + "규격": "", + "단위": "식", + "단가": {"노무비": 12000, "재료비": 3000, "경비": 500}, + "이음": {"노임": "LB000002", "자재": None, "기계": None, "유가": None}, + }, + "수량": {"손": 2}, +} +RATE = { + "고정": {"이름": "공구손료", "단가": {}, "이음": {}, "비율": {"기준": "인력", "비목": "경비"}} +} + + +def _sk(**doc) -> str: + return refs.create("sangeun", {"이름": "sub6임시", "단위": "㎡", "더한줄": [], **doc})["이름"] + + +def _layer_samples(me: Path) -> dict[str, str]: + """개인 층 견본 — {갈래: 키}.""" + with store.at(me): + keys = { + "바탕": _sk(바탕={"로직": FORM}, 입력값={"유형": "복잡", "사용횟수": "3회"}), + "율": _sk(바탕={"로직": SUB}, 단위="주", 더한줄=[{**RATE, "수량": 2}]), + "기계": _sk(바탕={"로직": DIG}, 단위="㎥"), + "재료": _sk(바탕={"로직": NET}, 입력값=NET_IN), + } + keys["형제"] = _sk(바탕={"참조": {**MINE, "키": keys["바탕"]}}) + keys["따로"] = _sk(바탕={"로직": PCT}) + read = sk_path.read(keys["따로"]) + twice = copy.deepcopy(read["문서"]) + twice["금액"][0]["수량"] = f"({twice['금액'][0].get('수량') or 1}) × 2" + sk_path.save(keys["따로"], {"문서": twice, "판": read["판"]}) + row, src = _bonghwa() + keys["가져온"] = imported.create(row, src, "sub6임시 가져온")["이름"] + sc = { + "이름": "sub6임시 일위대가", + "단위": "㎡", + "담은로직": [ + {"참조": {**MINE, "키": keys["바탕"]}, "수량": {"손": 1}}, + FIXED, + {"로직": STONE, "입력값": {}, "수량": {"손": 1}}, + ], + "자재": [{"코드": "MT003810", "수량": {"손": 2}}], + } + keys["일위대가"] = refs.create("precombo", sc)["이름"] + return keys + + +def _structure(world, keys: dict[str, str], root: Path) -> None: + """구조물 사본(pipe@100.0) — 일위대가 열 문서를 지금 사본 길(`labor_doc_rows` · `price_bundle`)로.""" + me = world["personal"] + lines = [ + {"참조": {**MINE, "키": keys[k]}, "수량": {"손": q}} + for k, q in (("바탕", 2), ("율", 1), ("형제", 1), ("따로", 1), ("가져온", 1), ("기계", 3)) + ] + lines += [ + {"참조": {**MINE, "키": keys["재료"]}, "수량": {"손": 1}}, + {"참조": {**MINE, "키": keys["일위대가"]}, "수량": {"손": 1}}, + {"로직": STONE, "입력값": {}, "수량": {"손": 1}}, + {"로직": TWO_MATS, "수량": {"손": 1}}, + ] + with store.at(me): + doc = labor.clean( + {"열": "rv", "담은로직": lines, "자재": [{"코드": "MT003810", "수량": {"손": 2}}]} + ) + rows = source.labor_doc_rows(doc) + files = { + source.LABOR_FILE: rows, + source.PRICE_FILE: source.price_bundle(rows, me), + snapshots.VALUES_FILE: {STONE: {"높이": {"값": 1.5}}}, + snapshots.PICKS_FILE: {TWO_MATS: {"1": "MT003196", "2": "MT003173"}}, + snapshots.MANIFEST_NAME: {"원본": {**_item("SS000901"), "경로": ["x"]}}, + } + folder = snapshots.structures_dir(root) / snapshots.folder_name("pipe@100.0") + folder.mkdir(parents=True) + for name, data in files.items(): + text = json.dumps(data, ensure_ascii=False, default=str) + (folder / name).write_text(text, encoding="utf-8") + + +HAND = [ + {"key": "hand:rate", "section": "1.1", "after": "", "spec": "", "name": "율 줄", "unit": "㎡", "qty": 2, + "ref": {"tab": "logic", "code": PCT, "given": {}, "rate": None, "picks": None}}, + {"key": "hand:pick", "section": "1.1", "after": "hand:rate", "spec": "", "name": "고른 재료", "unit": "㎡", "qty": 1, + "ref": {"tab": "logic", "code": TWO_MATS, "given": {}, "rate": None, "picks": {"1": "MT003196", "2": "MT003173"}}}, + {"key": "hand:net", "section": "1.1", "after": "hand:pick", "spec": "", "name": "입력", "unit": "㎡", "qty": 3, + "ref": {"tab": "logic", "code": NET, "given": NET_IN, "rate": 90, "picks": None}}, +] # fmt: skip +HAUL_REF = {"tab": "logic", "code": HAUL, "name": "골재운반", "given": {"Cm": 1}, "cycle": {}} +USER = { + "bill": {"qty": {}, "rows": HAND}, + "haul_refs": {"haul:r-u1": HAUL_REF}, + "haul_dist": {"haul:r-u1": {"L1": 25.1, "L2": 0.8}}, +} + + +def _clean(value, root: Path): + """지문 꼴 — 임시 경로 · 때(날짜 · 시각)는 지움 · 수는 글로.""" + text = json.dumps(value, ensure_ascii=False, sort_keys=True, default=str) + text = text.replace(str(root).replace("\\", "\\\\"), "").replace(str(root), "") + return re.sub( + r"\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?", "<때>", text + ) + + +def _split_text(value): + """(값, 글) — 산출근거 글(`text` · `head` · `foot` · `lines` 글 목록)을 따로 떼어 지문을 나눔.""" + words = [] + + def walk(v): + if isinstance(v, dict): + out = {} + for k, x in v.items(): + if k in ("text", "head", "foot"): + words.append(x) + else: + out[k] = walk(x) + return out + if isinstance(v, list): + return [walk(x) for x in v] + return v + + return walk(value), words + + +def answers(world, tmp_path) -> dict[str, object]: + keys = _layer_samples(world["personal"]) + root = _project(tmp_path / "proj", [(100, "SS000901")]) + _structure(world, keys, root) + for kind, key in ( + ("sangeun", keys["따로"]), + ("sangeun", keys["가져온"]), + ("precombo", keys["일위대가"]), + ): + library.import_copy(root, kind, "personal", OWNER, key) + b09_store.write_user(root, USER) + haul = {k: USER[k] for k in ("haul_refs", "haul_dist")} # 운반 연결 = 셈 때 거리이정표에서 붙음 + user = {**b09_store.read_user(root), **haul} + out: dict[str, object] = {"키": keys} + out["calc_user"] = b09.calc_user(root) + out["daega_inputs"] = daega_inputs(root) + out["수요"] = asyncio.run(b09._demand(root)) + for name, supply in (("산근", None), ("산근 관급", lambda _k: "관급")): + sg = sangeun.build(root, user, None, supply) + out[f"{name} 값"], out[f"{name} 글"] = _split_text(sg) + for row in HAND: + ref = row["ref"] + body = b09.PreviewBody( + code=ref["code"], given=ref["given"], rate=ref["rate"], picks=ref["picks"] + ) + got = b09.logic_preview(root, body) + got, words = _split_text(got) + out[f"미리보기 {row['key']} 값"] = {k: v for k, v in got.items() if k != "lines"} + out[f"미리보기 {row['key']} 글"] = [got.get("lines"), words] + linked = snapshots.linked_snapshots(root) + summary = { + "linked": linked, + "sources": [["rv:x", 12.0, folder, ["system||SS000901"]] for folder in sorted(linked)], + "total": {"rv:x": 12.0}, + } + out["B08 단위수량"] = b08.snapshot_units(root, summary) + return {k: _clean(v, root) for k, v in out.items()} + + +def _hash(text: str) -> str: + return hashlib.sha256(text.encode("utf-8")).hexdigest()[:16] + + +@pytest.fixture(autouse=True) +def _manual(monkeypatch): + """자동 따라옴 끔 — 저장본 그대로(층 꼴만 봄 · 자동은 test_836_2).""" + from M02_MasterTemplete import M02_Sk_AutoRenew as renew + + monkeypatch.setattr(renew, "on", lambda: False) + + +def test_B08_B09_답_지문_같음(world, tmp_path): + got = {k: _hash(v) for k, v in answers(world, tmp_path).items()} + if WRITE: + body = {"판": 1, "지문": got} + FILE.write_text(json.dumps(body, ensure_ascii=False, indent=1) + "\n", "utf-8") + want = json.loads(FILE.read_text("utf-8"))["지문"] + bad = sorted(k for k in want.keys() | got.keys() if want.get(k) != got.get(k)) + assert not bad, ( + f"B08 · B09 답 지문 다름 — {bad}\n" + f"뜻대로 금액 · 글을 바꾼 걸음이면 다시 뜸: {REDO} (아니면 고친 코드를 되짚음)" + ) + + +if __name__ == "__main__": + if "--write" not in sys.argv: + sys.exit(f"다시 뜨기 = {REDO}") + os.environ["S855B09_WRITE"] = "1" + import tempfile + + temp = str(Path(tempfile.gettempdir()) / "s855b09_pt") # 공용 임시 폴더 권한 막힘 피함 + sys.exit(pytest.main([__file__, "-q", "-p", "no:cacheprovider", "--basetemp", temp])) diff --git a/resources/tester/test_855_block.py b/resources/tester/test_855_block.py new file mode 100644 index 000000000..2de6a343a --- /dev/null +++ b/resources/tester/test_855_block.py @@ -0,0 +1,33 @@ +"""855-A 지킴 ④ — 막힘 판정 옛(`master_formula.check_logic` · M01 로직 목록 · `/logic`) = 새(수식 문서 +표지 `master_doc.check`) 전수 · 막힘 기준 = 표지만(기본 입력으로 셈이 안 되는 것은 막힘 아님 · 판정 855-0). + +걸음 2-B3(막힘 검사를 문서 기준으로) 앞뒤로 같아야 함 · 옛 검사를 지우는 걸음에서 옛 쪽만 뗌.""" + +from __future__ import annotations + +import importlib + +import helper_855_engine as h + +md = importlib.import_module("master_doc") + + +def test_막힘_옛_새_같음(): + rows, whole, docs, _ = h.world() + old = {str(r["키"]) for r in rows if h.mf.check_logic(whole, r)[0]} + new = {str(r["키"]) for r in rows if str(r["키"]) not in docs or md.check(docs[str(r["키"])])} + assert old == new, {"옛만 막힘": sorted(old - new)[:20], "새만 막힘": sorted(new - old)[:20]} + + +def test_틀린_식은_옛_새_모두_막힘(): + """자가 살아 있는지 — 같은 로직의 식을 틀리게 하면 두 판정 모두 막힘(사본만 · 자료 안 고침).""" + import copy + + rows, whole, docs, _ = h.world() + row = next(r for r in rows if r.get("호표") and str(r["키"]) in docs) + bad_row = copy.deepcopy(row) + bad_row["호표"][0]["수량"] = "없는변수 * 2" + bad_doc = copy.deepcopy(docs[str(row["키"])]) + bad_doc["금액"][0]["수량"] = "없는기호 × 2" + assert h.mf.check_logic(whole, bad_row)[0] + assert md.check(bad_doc) diff --git a/resources/tester/test_855_c4_doc_text.py b/resources/tester/test_855_c4_doc_text.py new file mode 100644 index 000000000..b94225ef2 --- /dev/null +++ b/resources/tester/test_855_c4_doc_text.py @@ -0,0 +1,155 @@ +"""855-C 2-C4 지킴 — 서버 산출근거 글(`master_doc_text`) · 기준 목록 · 계산서가 문서 셈. + +① 거울 — 글 규칙이 화면 TS 와 같음(헬퍼 `helper_855_c4_doc_text.cjs`): + 수 꼴(`eqText` · 줄 금액 · 원) · 단위 글(`unitText`) · 금액 줄 단위 자리 · 단가 기호 + (`moneyUnits` · `priceSym`) · 선택으로 꺼진 줄(`offLine`) · 비목 이름 — 실제 M01 수식 문서 전부 + (기본 입력 셈 답)로. +② 계산서 — 줄 금액 · 소계 · 계 = 문서 셈 답 그대로 · 소계 합 = 계 · + 줄 글 「단가 원/단위 * 수량 단위 = 금액」. +③ 기준 목록 줄 금액 = 같은 입력의 문서 셈 계. +""" + +from __future__ import annotations + +import importlib +import json +import os +import subprocess +from decimal import Decimal +from functools import lru_cache + +import pytest + +from M01_MasterData import M01_MasterData_Doc as m01_doc +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Logic_Standard as st + +mc = importlib.import_module("master_doc_calc") +md = importlib.import_module("master_doc") +mdt = importlib.import_module("master_doc_text") + +HERE = os.path.dirname(os.path.abspath(__file__)) +NUMS = [0, 1, -1, 0.5, 1.5, 2.5, -2.5, 0.05, 0.15, 0.25, 0.35, 1.05, 1.15, 1.25, 2.675, 99.95, + -0.05, 0.1 + 0.2, 1e-7, 1234567.891234567, 59018.0857142857, 284.42142857142, + 123456789012.345, 26890.75, 1502.04999] # fmt: skip + + +def _js(v): + if isinstance(v, Decimal): + return float(v) + if isinstance(v, dict): + return {k: _js(x) for k, x in v.items()} + if isinstance(v, (list, tuple)): + return [_js(x) for x in v] + if isinstance(v, (mc.Blank, mc.Stop)): + return None + return v + + +@lru_cache(maxsize=1) +def world(): + """(문서들, 연결, {키: 기본 셈 답}).""" + whole = m01.loaded()[1] + docs = m01_doc.docs() + links = st._links(whole) + answers = {k: mc.calc(d, links, None) for k, d in docs.items() if d.get("금액")} + return docs, links, answers + + +def _helper(payload: dict) -> dict: + run = subprocess.run( + ["node", os.path.join(HERE, "helper_855_c4_doc_text.cjs")], + input=json.dumps(payload, ensure_ascii=False), + capture_output=True, + text=True, + encoding="utf-8", + check=True, + ) + return json.loads(run.stdout) + + +@lru_cache(maxsize=1) +def mirror(): + docs, links, answers = world() + nums, units, lines, offs, py = list(NUMS), set(), [], [], {"단위": [], "줄": [], "꺼짐": []} + for key, a in answers.items(): + doc = docs[key] + vars_ = {md.var_id(v): v for v in doc.get("변수") or []} + units |= {str(v.get("단위") or "") for v in doc.get("변수") or []} + units.add(str(doc.get("결과단위") or "")) + for row in a.get("줄") or []: + nums += [_js(row.get(k)) for k in ("단가", "수량", "금액")] + for line in doc["금액"]: + units.add(str(line.get("단위") or "")) + sym = mdt.price_sym(line) + pv = vars_.get(sym) if sym else None + link = (pv or {}).get("연결") or {} + sub = None + if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]): + got = links.doc(str(link["키"])) + sub = {"결과단위": got.get("결과단위")} if got else None + lines.append({"줄": _js(line), "단가변수": _js(pv), "부름": sub}) + nodes = (mdt.node_of(line.get("단가")), mdt.node_of(line.get("수량"))) + py["줄"].append((mdt.money_units(line, *nodes, pv, sub), sym)) + look = mdt._Look(doc, a, links) + vals = {k: v for k, v in (a.get("값") or {}).items() if v is not None} + part = {"식": _js(doc.get("식") or []), "금액": _js(doc["금액"])} + offs.append({"문서": part, "값": _js(vals)}) + py["꺼짐"].append([look.off_line(line) for line in doc["금액"]]) + nums = [x for x in nums if isinstance(x, (int, float))] + units |= {"%(인력품 대비)", "10^-7/시간", "kWh/hr", "줄 따름", "수(개)", "원문 단위 없음"} + units = sorted(units) + ts = _helper({"수": nums, "원": nums, "단위": units, "금액줄": lines, "꺼짐": offs}) + return nums, units, py, ts + + +def test_수_꼴_eqText_한자리_원(): + nums, _, _, ts = mirror() + assert len(nums) > 5000 + assert [mdt.eq_text(v) for v in nums] == ts["eq"] + assert [mdt.one(v) for v in nums] == ts["one"] + assert [mdt.won(v) for v in nums] == ts["won"] + texts = ("5401-0017", "", " ", "1048") + assert [mdt.eq_text(v) for v in texts] == ["5401-0017", "", " ", "1,048"] + + +def test_단위_글_금액줄_단위_자리_단가_기호(): + _, units, py, ts = mirror() + assert [mdt.unit_text(u) for u in units] == ts["단위"] + assert len(py["줄"]) > 5000 + assert [u for u, _ in py["줄"]] == ts["금액줄"] + assert [s for _, s in py["줄"]] == ts["기호"] + assert any(u["wrap"] for u, _ in py["줄"]) and any(u["price"] for u, _ in py["줄"]) + + +def test_선택으로_꺼진_줄_비목_이름(): + _, _, py, ts = mirror() + assert py["꺼짐"] == ts["꺼짐"] + assert sum(map(sum, py["꺼짐"])) > 0 # 꺼진 줄이 실제로 있음(판정이 일을 함) + assert mdt.COST_SHOW == ts["비목"] and mdt.LONG_SUM == ts["항"] + + +@pytest.mark.parametrize("key", ("GF000220", "GF000089", "GC000404", "GF000101")) +def test_계산서_문서_셈_답_그대로(key): + got = st.sheet(key, {}) + docs, links, _ = world() + answer = mc.calc(docs[key], links, st._given(m01.loaded()[1], docs[key], {})[0]) + assert got["계"] == float(answer["계"]) and got["계"] == sum(g["소계"] for g in got["묶음"]) + for g in got["묶음"]: + assert g["소계"] == float(answer[g["비목"]]) + for line in g["줄"]: + assert line["글"].endswith(f"= {mdt.one(line['금액'] or 0)}") + assert " * " in line["글"] or line["글"].startswith("—") + first = got["묶음"][0]["줄"][0] + if key == "GF000220": # 석공 노임 — 「268,908 원/인 * 0.1 인 = 26,890.8」 + assert first["이름"] == "석공" and first["글"].startswith("268,908 원/인 * 0.1 인 = ") + + +def test_기준_목록_금액_문서_셈(): + whole = m01.loaded()[1] + docs, links, _ = world() + for key in ("GF000220", "GC000404", "GX000004"): + for row in st._rows_of(whole, whole.logic(key), False, links): + given = st._given(whole, docs[key], row["바꿈"])[0] + want = mc.calc(docs[key], links, given) + assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"]) diff --git a/resources/tester/test_855_engine_parity.py b/resources/tester/test_855_engine_parity.py new file mode 100644 index 000000000..3c9088393 --- /dev/null +++ b/resources/tester/test_855_engine_parity.py @@ -0,0 +1,46 @@ +"""855-A 지킴 ① — 로직 전수 옛 엔진 대 새 계산기(저장된 수식 문서) · 걸음 2 동안 「다름 0」 자. + +- 기본 입력 전수(관문 · 십여 초) · 옵션 표본 전수 = 환경 `S855_ALL=1`(3 분 남짓). +- 층 L0 합계 · L1 줄 비목 · L2 줄 꼴 · L3 수량 · 단가(`helper_855_engine.level`). +- 다름 = 채택된 차이와 같아야 함(합계 = 빌더 `ADOPTED` 그대로 · 줄 비목 = 같은 까닭의 문서만) · + 「보임」(보이는 단가만 · 금액 같음)은 허용 갈래로 셈. +- 옛 엔진을 지우는 걸음(2-E4)에서 은퇴 — 그 뒤는 `test_855_golden` 이 지킴. +""" + +from __future__ import annotations + +import os + +import helper_855_engine as h + +ALL = os.environ.get("S855_ALL") == "1" + + +def _diffs(options: bool) -> dict[str, list]: + rows, _, docs, _ = h.world() + out: dict[str, list] = {"문서 없음": [], "채택 밖": [], "채택": [], h.SEEN: []} + for row in rows: + key = str(row["키"]) + doc = docs.get(key) + if doc is None: + out["문서 없음"].append(key) + continue + money = not doc.get("결과") + for label, given, changed in h.cases(row, options): + lv = h.level(h.old_run(row, given), h.new_run(doc, changed), money) + if lv == h.SEEN: + out[h.SEEN].append((key, label)) + elif lv and h.adopted(key, label, lv): + out["채택"].append((key, label, lv)) + elif lv: + out["채택 밖"].append((key, label, lv)) + return out + + +def test_로직마다_수식_문서_있음_옛_대_새_다름은_채택뿐(): + got = _diffs(ALL) + assert got["문서 없음"] == [] + assert got["채택 밖"] == [], got["채택 밖"][:20] + total = {(k, o) for k, o, lv in got["채택"] if lv == "L0"} + want = {x for x in h.build.ADOPTED if not x[1]} if not ALL else set(h.build.ADOPTED) + assert total == want # 채택 목록이 다 나오고 그 밖은 없음(기본만 돌면 옵션 채택은 안 나옴) diff --git a/resources/tester/test_855_golden.py b/resources/tester/test_855_golden.py new file mode 100644 index 000000000..03a8c9e85 --- /dev/null +++ b/resources/tester/test_855_golden.py @@ -0,0 +1,47 @@ +"""855-A 지킴 ② — 새 계산기 답 지문(로직마다 기본 + 옵션 표본 · 노 · 재 · 경 · 계 · 줄 금액 · 비목). + +- 지문 = `golden_855_engine.json`(로직 키 → 답 묶음 sha256 앞 16 자 · `helper_855_engine.fingerprint`). +- 다르면 실패 — 계산기 · 수식 문서 · M01 자료가 금액을 바꿨다는 뜻. 자료 · 규칙을 **뜻대로 바꾼 걸음만** + 다시 뜸: `./venv/Scripts/python.exe resources/tester/test_855_golden.py --write`(바뀐 키를 커밋 글에). +- 옛 엔진을 지운 뒤(2-E4) 옛 → 새 대조(`test_855_engine_parity` · `test_802_2`)를 이것이 대신함. +""" + +from __future__ import annotations + +import json +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent +FILE = HERE / "golden_855_engine.json" +REDO = "./venv/Scripts/python.exe resources/tester/test_855_golden.py --write" + + +def current() -> dict[str, str]: + import helper_855_engine as h + + rows, _, docs, _ = h.world() + return {str(r["키"]): h.fingerprint(str(r["키"]), r) for r in rows if str(r["키"]) in docs} + + +def test_새_계산기_답_지문_같음(): + want = json.loads(FILE.read_text("utf-8"))["지문"] + got = current() + changed = sorted(k for k in want.keys() & got.keys() if want[k] != got[k]) + gone, new = sorted(want.keys() - got.keys()), sorted(got.keys() - want.keys()) + assert not (changed or gone or new), ( + f"지문 다름 — 바뀜 {len(changed)} {changed[:20]} · 빠짐 {gone[:20]} · 새 키 {new[:20]}\n" + f"뜻대로 금액을 바꾼 걸음이면 다시 뜸: {REDO} (아니면 고친 코드 · 자료를 되짚음)" + ) + + +if __name__ == "__main__": + ROOT = HERE.parents[1] + for p in (str(ROOT), str(HERE)): + if p not in sys.path: + sys.path.insert(0, p) + if "--write" not in sys.argv: + sys.exit(f"다시 뜨기 = {REDO}") + body = {"판": 1, "지문": dict(sorted(current().items()))} + FILE.write_text(json.dumps(body, ensure_ascii=False, indent=1) + "\n", "utf-8", newline="\n") + print(f"지문 {len(body['지문'])} 씀 → {FILE.name}") diff --git a/resources/tester/test_855_sk_layers.py b/resources/tester/test_855_sk_layers.py new file mode 100644 index 000000000..a18e60351 --- /dev/null +++ b/resources/tester/test_855_sk_layers.py @@ -0,0 +1,125 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""855-A 지킴 ③ — 단가산출(SK) 셈 답 · 견본 꼴마다 옛 엔진 길(`M02_Doc_Sk.OLD`) 대 지금 길(수식 사본 → +문서 계산기) · 지금 길 답의 줄 비목 합(원 버림) = 기준. + +견본(임시 storage · 개인 층 · M01 은 읽기만): 바탕 로직 · 옛 칸 값(더한줄 로직) · 율 더한줄 · 형제 SK(바탕 참조) · +「따로」(수식 사본을 고쳐 저장) · 가져온 식(엑셀 줄 · 저장 없음). +걸음 2-C1(SK 셈 한 길)이 이 시험을 자로 씀 — 「따로」 단언은 지금 사실(줄 = 옛 · 기준 = 새)이고 2-C1 에서 뒤집음. +""" + +from __future__ import annotations + +import copy +from decimal import ROUND_DOWN, Decimal + +import pytest + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Doc_Sk as dsk +from M02_MasterTemplete import M02_Doc_Sk_Path as path +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sangeun_Calc as calc +from M02_MasterTemplete import M02_Sangeun_Doc as sd +from resources.tester import test_793_2_sangeun_imported as imported +from resources.tester.test_778_4_rate_line import SUB, _rate +from resources.tester.test_795_1_sk_copy import PCT, _doc, _sk +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + +COSTS = ("노무비", "재료비", "경비") +FORM = "GC000211" # 합판거푸집 +ADD = {"종류": "로직", "로직": "GF000089", "수량": 2, "입력값": {}, "이름": "sub6임시 굴착기"} + + +@pytest.fixture(autouse=True) +def _manual(monkeypatch): + """자동 따라옴 끔 — 저장본 그대로 셈(층 꼴만 봄).""" + from M02_MasterTemplete import M02_Sk_AutoRenew as renew + + monkeypatch.setattr(renew, "on", lambda: False) + + +def _run(doc: dict, old: bool) -> dict: + whole = m01.loaded()[1] + token = dsk.OLD.set(old) + try: + return calc.run(sd.clean(doc, None, whole), whole) + finally: + dsk.OLD.reset(token) + + +def _both(folder, doc) -> tuple[dict, dict]: + with store.at(folder): + return _run(doc, True), _run(doc, False) + + +def _lines_sum(got: dict) -> dict: + total = {k: Decimal(0) for k in COSTS} + for ln in got.get("줄") or []: + for k in COSTS: + v = (ln.get("비목") or {}).get(k) + total[k] += Decimal(str(v)) if v is not None else 0 + return {k: v.quantize(Decimal(1), ROUND_DOWN) for k, v in total.items()} + + +def _base(got: dict) -> dict: + return {k: Decimal(str(got["기준"][k])).quantize(Decimal(1), ROUND_DOWN) for k in COSTS} + + +def _same_paths(old: dict, new: dict) -> None: + assert old["기준"] is not None and new["기준"] is not None + assert {k: Decimal(str(old["기준"][k])) for k in COSTS} == { + k: Decimal(str(new["기준"][k])) for k in COSTS + } + assert _lines_sum(new) == _base(new) + + +@pytest.mark.parametrize( + "body", + [ + {"바탕": {"로직": FORM}}, + {"바탕": {"로직": PCT}}, + {"바탕": {"로직": FORM}, "더한줄": [ADD]}, # 옛 칸 값(더한줄 로직) + {"바탕": {"로직": SUB}, "더한줄": [_rate("인력", 2)], "단위": "주"}, # 율 더한줄 + ], + ids=["바탕", "율_바탕", "옛칸_더한줄", "율_더한줄"], +) +def test_층_SK_옛_대_새_같고_줄_합_기준(world, body): + me = world["personal"] + key = _sk(me, **copy.deepcopy(body)) + doc = _doc(me, key) + old, new = _both(me, doc) + assert "수식셈" in new # 지금 길 = 수식 사본 문서 셈 + _same_paths(old, new) + + +def test_형제_SK_바탕_참조(world): + me = world["personal"] + first = _sk(me, 바탕={"로직": FORM}) + second = _sk(me, 바탕={"참조": {"층": "personal", "주인": "7/42", "키": first}}) + old, new = _both(me, _doc(me, second)) + _same_paths(old, new) + assert new["기준"] == _both(me, _doc(me, first))[1]["기준"] + + +def test_가져온_식_옛_대_새(world): + old, new = _both(world["personal"], imported._doc()) + assert "수식셈" in new + _same_paths(old, new) + + +def test_따로_SK_지금은_줄_옛_기준_새(world): + """「따로」 = 고친 수식 사본이 정본 — 지금 셈 답은 줄 = 옛 엔진(옛 칸) · 기준 = 문서 계산기라 갈림. + 2-C1 에서 뒤집을 단언 — 그 뒤엔 `_same_paths` 꼴(줄 합 = 기준)로 바꿈.""" + me = world["personal"] + key = _sk(me, 바탕={"로직": PCT}) + with store.at(me): + read = path.read(key) + twice = copy.deepcopy(read["문서"]) + line = twice["금액"][0] + line["수량"] = f"({line.get('수량') or 1}) × 2" + saved = path.save(key, {"문서": twice, "판": read["판"]}) + assert saved["사본"]["따로"] is True + old, new = _both(me, _doc(me, key)) + assert new["수식셈"]["따로"] is True + assert _base(new) != _base(old) # 2-C1 에서 뒤집을 단언 — 기준이 옛 길과 다름 + assert _lines_sum(new) == _base(old) != _base(new) # 2-C1 에서 뒤집을 단언 — 줄 = 옛 길 diff --git a/resources/tester/test_855_trace.py b/resources/tester/test_855_trace.py new file mode 100644 index 000000000..1be8cbb9e --- /dev/null +++ b/resources/tester/test_855_trace.py @@ -0,0 +1,170 @@ +"""855-F B9-1 지킴 — 문서 셈 기록(`master_doc_trace`) · 로직 전수 기본 입력. + +- 기록을 켜도 셈 답 같음(줄 `부름` · 답 `부름` `자원` 칸만 더해짐). +- 자원 키 = 옛 엔진 셈 중 `whole.get` 가로채기 키(B09 `hand_resource_keys` 방식 · + 찾기 색인 데운 뒤) — 다름 = `MORE` 뿐(새 계산기는 이름마다 셈 — 옛은 안 고른 「만약」 갈래 · + 빈 수량 줄 · 앞서 멈춘 줄을 안 읽음 · 새 쪽에만 더 있음). +- 하위 부름 = 옛 `B09 line_calls`(돈 문서 {code, given} · 기계경비 {machine}) — 다름 = 옛이 입력 + 기본값을 못 세 빈 답인 문서뿐 · 새 쪽 결과 문서 부름(작업량 등 중간 값)은 하위 산근 아님. +- 고른 품목 = `master_pick.priced` 의 품목 키 · 줄 `부름` = 그 줄 자원. +- 옛 엔진을 지우는 걸음(2-E4)에서 옛 대조(자원 · 하위)는 은퇴. +""" + +from __future__ import annotations + +import importlib +import json +from functools import lru_cache + +import helper_855_engine as h + +mt = importlib.import_module("master_doc_trace") +mp = importlib.import_module("master_pick") +mm = importlib.import_module("master_material") + +MORE = { # 새 쪽에만 더 있는 자원 키 — 까닭 + "GC001200": "옛 엔진이 빈 입력에서 멈춤 · 새는 전력 재료 이름도 셈", + "GC001201": "옛 엔진이 빈 입력에서 멈춤 · 새는 전력 재료 이름도 셈", + "GF000312": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈", + "GF000313": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈", + "GF000320": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈", + "GF000192": "옛은 수량 빈 줄의 재료 단가를 안 읽음", + "GF000200": "옛은 수량 빈 줄의 재료 단가를 안 읽음", + "GF000203": "옛은 수량 빈 줄의 재료 단가를 안 읽음", + "GF000209": "옛은 수량 빈 줄의 재료 단가를 안 읽음", +} + + +def sg(): + from B09_Estimation import B09_Estimation_Sangeun as mod + + return mod + + +def mc_calc(doc: dict, links) -> dict: + return importlib.import_module("master_doc_calc").calc(doc, links) + + +def _old_keys(whole, row: dict, given: dict) -> set[str]: + seen: set[str] = set() + base = whole.get + + def get(ref): + got = base(ref) + key = str(got.get("키") or "") + if key[:2] in mt.CAT: + seen.add(key) + return got + + whole.get = get + try: + h.old_run(row, given) + finally: + del whole.get + return seen + + +def _strip(got: dict) -> dict: + out = {k: v for k, v in got.items() if k not in ("부름", "자원")} + if "줄" in out: + out["줄"] = [{k: v for k, v in ln.items() if k != "부름"} for ln in out["줄"]] + return out + + +def _calls(old: dict, new: dict, docs: dict) -> tuple[set, set]: + a = {json.dumps(v, ensure_ascii=False, sort_keys=True, default=str) for v in old.values()} + b = set() + for c in new["부름"]: + if c["깊이"] != 1 or c["갈래"] != "단가산출": + continue + if (docs.get(str(c["부름"].get("키"))) or {}).get("결과"): + continue # 결과 문서 = 중간 값 + one = ( + {"machine": c["기계"]} + if "기계" in c + else {"code": c["부름"]["키"], "given": sg()._clean_given(c["부름"].get("입력"))} + ) + b.add(json.dumps(one, ensure_ascii=False, sort_keys=True, default=str)) + return a, b + + +@lru_cache(maxsize=1) +def survey() -> dict: + rows, whole, docs, links = h.world() + rows = [r for r in rows if str(r["키"]) in docs] + for row in rows: # 재료 찾기 색인 데움(첫 찾기 때 훑은 후보 읽음 빼려고) + h.old_run(row, h.cases(row, False)[0][1]) + trace = mt.Trace(whole, docs) + out = {"답 다름": [], "자원": {}, "하위": {}, "품목": [], "줄": [], "옛 빈 답": set()} + for row in rows: + key = str(row["키"]) + doc, given = docs[key], h.cases(row, False)[0][1] + old = _old_keys(whole, row, given) + got = mt.calc(doc, trace) + if _strip(got) != mc_calc(doc, links): + out["답 다름"].append(key) + new = set(got["자원"]) + if old != new: + out["자원"][key] = (sorted(old - new), sorted(new - old)) + lines = sg().line_calls(whole, key, given) + a, b = _calls(lines, got, docs) + if a != b: + out["하위"][key] = (sorted(a), sorted(b)) + if not lines: + try: + sg()._env(whole, row, sg()._clean_given(given)) + except Exception: + out["옛 빈 답"].add(key) + for c in got["부름"]: + p = c["부름"] + if c["깊이"] == 1 and "품목" in c and p.get("재료") is not None: + env = {mm.REGION: p["지역"]} if p.get("지역") is not None else {} + if p.get("계약종별") is not None: + env[mm.TARIFF] = p["계약종별"] + want = mp.priced(whole, {"단위": p.get("단위")}, p["재료"], env, None)[3] + if want.get("품목") and want["품목"]["키"] != c["품목"]: + out["품목"].append((key, c["이름"], want["품목"]["키"], c["품목"])) + for ln in got.get("줄") or []: + for i in ln["부름"]: + if not (0 <= i < len(got["부름"])) or got["부름"][i]["깊이"] != 1: + out["줄"].append((key, ln["이름"], i)) + return out + + +def test_기록_켜도_셈_답_같음(): + assert survey()["답 다름"] == [] + + +def test_자원_키_옛_가로채기와_같음_다름은_까닭_목록뿐(): + got = survey()["자원"] + assert all(not old for old, _ in got.values()), {k: v for k, v in got.items() if v[0]} + assert sorted(got) == sorted(MORE), sorted(got) + + +def test_하위_부름_옛_call_of_와_같음_다름은_옛_빈_답뿐(): + s = survey() + assert set(s["하위"]) == s["옛 빈 답"], { + k: s["하위"][k] for k in set(s["하위"]) - s["옛 빈 답"] + } + assert all(not old for old, _ in s["하위"].values()) + + +def test_고른_품목_줄_부름(): + s = survey() + assert s["품목"] == [] + assert s["줄"] == [] + + +def test_기계경비_부름_기계_키_줄마다_부름(): + _, whole, docs, _ = h.world() + got = mt.calc( + docs["GC000337"], mt.Trace(whole, docs) + ) # 낙석방지망 — 인력 둘 · 크레인 · 재료 셋 + lines = {ln["이름"]: [got["부름"][i] for i in ln["부름"]] for ln in got["줄"]} + crane = [c for c in lines["크레인"] if c["갈래"] == "단가산출"] + assert [c["부름"]["키"] for c in crane] == ["GC000268"] and crane[0]["기계"][:2] == "EQ" + assert {x["키"][:2] for c in lines["특별인부"] for x in c["자원"]} == {"LB", "QC"} + assert [c["품목"] for c in lines["에폭시"] if "품목" in c] == [got["자원"][-1]] + assert set(got["자원"]) >= { + x["키"] for c in got["부름"] for x in c["자원"] if x["갈래"] != "표" + } diff --git a/ui_template/ui_template_locale_m1.ts b/ui_template/ui_template_locale_m1.ts index 5b0f36726..36fc7bbe3 100644 --- a/ui_template/ui_template_locale_m1.ts +++ b/ui_template/ui_template_locale_m1.ts @@ -5,7 +5,6 @@ export const ui_locales_m1 = { B01_Dashboard_MasterElements: ["마스터 데이터", "Master Data"], - M01_LogicTab: ["로직", "Logic"], M01_Title: ["마스터 요소", "Master Elements"], M01_AdminOnly: ["시스템 관리자만 볼 수 있음", "System administrators only"], M01_LoadFailed: ["마스터 요소를 못 읽음", "Failed to load master elements"], @@ -44,15 +43,7 @@ export const ui_locales_m1 = { M01_ProcureSearch: ["이름·규격 검색", "Find by name or spec"], M01_ProcureCut: ["연결 끊기", "Unlink"], M01_ProcureClose: ["닫기", "Close"], - M01_PriceFind: ["가격 연결", "Link price"], - M01_PriceTitle: ["가격 연결 고르기", "Pick price source"], - M01_PriceCol: ["가격 연결", "Price link"], - M01_PriceCond: ["조건 연결 (지역은 입력)", "Link by condition (region as input)"], - M01_PriceCondName: ["이름", "Name"], - M01_PriceCondSpec: ["규격", "Spec"], - M01_PriceCondUsed: ["후보 조건", "Condition"], M01_Govt: ["관급", "Govt"], - M01_OnlyUnlinked: ["미연결만", "Unlinked only"], M01_JobFind: ["직종 선택", "Pick job"], M01_JobTitle: ["준용 직종 고르기", "Pick substitute job"], M01_JobCol: ["준용", "Substitute"], @@ -66,7 +57,6 @@ export const ui_locales_m1 = { M01_MachineDetail: ["상세구분", "Detail"], M01_UsageTarget: ["대상", "Target"], M01_TableUsage: ["용도", "Usage"], - M01_TableUsageLogicCount: ["로직 {value}개", "{value} logic rules"], M01_OpenLogic: ["눌러 로직 탭으로", "Click to jump to the Logic tab"], M01_GroupLabor: ["인력", "Labor"], M01_GroupMaterial: ["재료", "Materials"], @@ -75,7 +65,6 @@ export const ui_locales_m1 = { M01_GroupFactor: ["계수", "Factors"], M01_GroupExchange: ["환율", "Exchange rates"], M01_GroupRate: ["요율", "Rates"], - M01_GroupLogic: ["단가산출 기초", "Unit-price logic"], B01_CalcSites_Title: ["계산 자리", "Calc sites"], B01_CalcSites_Desc: ["조작 중 계산 = 브라우저 · 서버 고름", "Browser or server while editing"], B01_CalcSites_ServerCount: ["지금 서버 {value} 줄", "{value} rows on server now"], diff --git a/ui_template/ui_template_locale_m2.ts b/ui_template/ui_template_locale_m2.ts index 7ccde4544..f5f766480 100644 --- a/ui_template/ui_template_locale_m2.ts +++ b/ui_template/ui_template_locale_m2.ts @@ -150,14 +150,6 @@ export const ui_locales_m2 = { "Tree updated — name already taken, saved as “{value}”", ], M02_HopyoImport: ["일위대가 불러오기", "Import unit-price sheets"], - M02_HopyoUnitTip: [ - "단위 환산 — 우리 수량 = 엑셀 수량 × 이 값", - "Unit conversion — our qty = Excel qty × this value", - ], - M02_HopyoUnitSame: ["단위 같음 ×1", "Same unit ×1"], - M02_HopyoUnitLead: ["엑셀 1 {from} = 우리", "Excel 1 {from} = ours"], - M02_HopyoUnitThick: ["두께 {n}m 로 추정", "Estimated from thickness {n}m"], - M02_HopyoUnitEst: ["규격으로 추정", "Estimated from the spec"], B01_Dashboard_CardPrecombo: ["일위대가", "Unit-cost items"], M02_PrecomboTitle: ["일위대가", "Unit-cost items"], B01_Dashboard_CardSangeun: ["단가산출", "Unit-price analyses"], @@ -211,98 +203,15 @@ export const ui_locales_m2 = { M02_FindOptions: ["옵션 {n}", "{n} options"], // 729-3 불러오기 — 안 이은 줄 · 일위대가표 띠 // 778-5 D-5 마법사 단가산출 줄 고름(제안 · 확인 뒤 옮김) - M02_SkSummary: [ - "블록 {b} · 옮길 수 있음 {ok} · 고를 줄 있음 {wait} · 옮김(SK) {made} · 확인 {sure}", - "Blocks {b} · ready {ok} · open lines {wait} · moved (SK) {made} · confirmed {sure}", - ], - M02_SkJudge: ["다시 판정", "Re-check"], - M02_SkJudging: ["줄 판정 중…", "Checking lines…"], - M02_SkMove: ["확인한 것 옮기기 ({n})", "Move confirmed ({n})"], - M02_SkMoveTip: [ - "확인한 블록만 단위 SK 로 — 서버가 M01 지금 값으로 다시 셈", - "Only confirmed blocks become SKs — the server recalculates with current M01", - ], - M02_SkMoved: ["옮김 {made} · 못 옮김 {bad}", "Moved {made} · not moved {bad}"], - M02_SkFailed: ["못 옮긴 블록 {n} — 까닭 펼쳐 봄", "{n} blocks not moved — see why"], - M02_SkSureFirst: ["확인한 블록 없음 — 블록마다 [확인]", "No confirmed block yet"], - M02_SkSure: ["확인", "Confirm"], - M02_SkSureTip: ["이 블록을 옮길 목록에 넣음", "Add this block to the move list"], - M02_SkSureOff: ["고를 줄이 남음 — 줄 표에서 먼저 고름", "Lines still open — pick them first"], - M02_SkOpen: ["줄", "Lines"], - M02_SkSheet: ["보기", "View"], - M02_SkNone: ["단가산출 블록 없음", "No unit-cost blocks"], - M02_SkNoLines: ["줄 없음", "No lines"], // 780-2 단가산출 목록(엑셀 보기 오른쪽 · 요구 627) - M02_SkFilter: ["거르기", "Filter"], - M02_SkFilterAll: ["전체", "All"], - M02_SkFilterIn: ["일위대가 안", "In unit-price sheet"], - M02_SkFilterOut: ["일위대가 밖", "Outside unit-price sheet"], - M02_SkFilterOpen: ["고를 줄 있음", "Open lines"], - M02_SkColCall: ["부름", "Called by"], - M02_SkCallIn: ["일위대가 {n} 곳", "{n} unit-price rows"], - M02_SkCallOut: ["일위대가 밖", "Outside"], - M02_SkSummaryIn: ["일위대가 안 {in} · 밖 {out}", "in sheet {in} · outside {out}"], - M02_SkSureEmpty: ["줄 없음 — 옮길 것 없음", "No lines — nothing to move"], M02_SkUnmoved: [ "안 옮긴 단가산출 {n}(일위대가 밖 {m})", "Unit-cost blocks not moved {n} (outside {m})", ], - M02_SkBasisTag: ["근거(참고) —", "Basis (ref) —"], - M02_SkLeft: [ - "단가산출 확인 안 한 블록 {n} · 고를 줄 {m}", - "Unit-cost blocks not confirmed {n} · open lines {m}", - ], - M02_SkColBlock: ["블록", "Block"], - M02_SkColVerdict: ["판정", "Verdict"], - M02_SkColOurs: ["우리 금액", "Our amount"], - M02_SkColExcel: ["엑셀 금액(참고)", "Excel amount (ref)"], - M02_SkColBasis: ["근거", "Basis"], - M02_SkColMade: ["만든 SK", "SK made"], - M02_SkColGroup: ["묶음", "Group"], - M02_SkColParam: ["매개값", "Value"], - M02_SkColState: ["상태", "State"], - M02_SkColHow: ["방법", "Method"], - M02_SkColDiff: ["차(참고)", "Diff (ref)"], - M02_SkColPick: ["고름", "Pick"], - M02_SkBasePick: ["기준 고름", "Pick base"], - M02_SkDrop: ["뺌", "Drop"], - M02_SkDropWhy: ["까닭", "Reason"], - M02_SkDropDefault: ["우리에 없음", "Not in ours"], - M02_SkClear: ["고름 지움", "Clear"], - M02_LeftTitle: ["안 이은 줄", "Unlinked rows"], - M02_LeftHint: [ - "만들면 M01 · 기초 · SK 에 안 이어질 엑셀 줄 — 줄마다 이을 것을 고름 · 고른 뒤 엑셀 보기 창 [저장] 또는 호표 [수정] 생성", - "Excel rows that would stay unlinked — pick a link per row, then save in the sheet window", - ], - M02_LeftBand: ["안 이은 줄 {n} (호표 {h})", "Unlinked rows {n} (sheets {h})"], M02_LeftZero: ["안 이은 줄 0", "No unlinked rows"], - M02_LeftUnknown: [ - "안 이은 줄 — 아직 안 셈 · [끝내기] 때 다시 셈", - "Unlinked rows — not counted yet", - ], - M02_LeftBlocked: ["안 이은 줄이 남아 [끝내기] 막힘", "Finish blocked — unlinked rows left"], - M02_LeftLoose: ["고른 뒤 안 만든 호표 {n} 개는 빠짐", "{n} picked but unmade sheets are dropped"], - M02_LeftOpen: ["안 이은 줄 고르기", "Pick unlinked rows"], - M02_LeftCounting: ["안 이은 줄 셈 중", "Counting unlinked rows"], - M02_LeftHopyo: ["호표", "Sheet"], M02_LeftSpec: ["규격", "Spec"], - M02_LeftKind: ["갈래", "Kind"], - M02_LeftWhy: ["까닭", "Reason"], - M02_LeftPicked: ["고른 것", "Picked"], M02_LeftPick: ["고름", "Pick"], - M02_LeftBase: ["기초", "Base"], - M02_LeftSkGo: ["단가산출 걸음에서 확인 ▸", "Check in the Sangeun step ▸"], - M02_LeftChoose: ["고르기", "Pick"], - M02_HopyoKid: ["하위 제{n}호표 {key}(사본 담음)", "Sub sheet {n} {key} (copy inside)"], - M02_HopyoKidNew: ["함께 만듦", "made together"], - M02_HopyoKidFail: ["하위 제{n}호표 실패", "Sub sheet {n} failed"], - M02_HopyoReused: ["같은 내용 일위대가 다시 씀", "Same unit-price reused"], M02_LeftFind: ["찾기", "Find"], - M02_LeftMachine: ["기계", "Machine"], - M02_LeftNoneTip: [ - "우리 M01 에 없음 — 엑셀 숫자 그대로 고정 줄(사용자가 고른 것으로 남음)", - "Not in M01 — keep the Excel numbers as a fixed row", - ], M02_GridUnlinked: ["M01 연결 없음 {n} 줄", "{n} rows not linked to M01"], M02_GridLink: ["연결", "Link"], M02_GridLinkTitle: ["안 이은 줄 연결", "Link unlinked rows"], @@ -311,13 +220,6 @@ export const ui_locales_m2 = { "Fixed rows link to labor, material or machine only", ], M02_LibUnlinked: ["안 이은 줄", "Unlinked"], - M02_LostTitle: ["못옮김 잇기", "Link unmoved rows"], - M02_LostHint: [ - "옛 단가산출 SK 의 남은 못옮김(보기만) — 잇기 = 마법사 단가산출 칸에서 단산{n} 블록 줄 고름 → [확인] → [확인한 것 옮기기]", - "Unmoved rows of an old SK (view only) — link in the wizard unit-cost step: pick lines of block {n}, confirm, then move", - ], - M02_LostZero: ["못옮김 0", "Nothing unmoved"], - M02_ElemTitle: ["M01 요소 후보", "M01 element candidates"], M02_SheetIlwi: ["일위대가표", "Unit-price sheet"], M02_SheetList: ["단가산출표", "Price basis list"], M02_SheetDetail: ["단가산출 상세", "Price basis detail"], diff --git a/ui_template/ui_template_locale_m2_judge.ts b/ui_template/ui_template_locale_m2_judge.ts index e6c7e6579..282a97932 100644 --- a/ui_template/ui_template_locale_m2_judge.ts +++ b/ui_template/ui_template_locale_m2_judge.ts @@ -5,58 +5,10 @@ export const ui_locales_m2_judge = { M02_JudgeLoading: ["판정 읽는 중", "Loading verdicts"], - M02_JudgeHopyo: ["제{n}호표", "Item {n}"], M02_JudgeBlock: ["단산{n}", "Calc {n}"], - M02_JudgeColRow: ["행", "Row"], - M02_JudgeColName: ["엑셀 품명 · 규격", "Excel name · spec"], - M02_JudgeColVerdict: ["1차 판정", "Verdict"], - M02_JudgeColKind: ["갈래 · 근거", "Kind · basis"], - M02_JudgeColPick: ["후보(여럿 고름)", "Candidates (multi)"], - M02_JudgeColQty: ["수량", "Qty"], - M02_JudgeColOk: ["확인", "Confirm"], - M02_JudgeConfirm: ["확인", "Confirm"], - M02_JudgeConfirmed: ["확인함", "Confirmed"], - M02_JudgeConfirmAll: ["호표 제안 모두 확인", "Confirm all suggestions"], - M02_JudgeCheck: ["검산", "Check"], - M02_JudgeSheet: ["보기", "View"], - M02_JudgeSolve: ["블록 풀이", "Block solve"], - M02_JudgeWholeSk: ["단가산출 통째", "Whole unit calc"], - M02_JudgeSection: ["맡은 절", "Section"], - M02_JudgeNoBase: ["기초 후보 없음", "No base candidate"], - M02_JudgeColInput: ["입력 칸", "Input"], - M02_JudgeColValue: ["값", "Value"], - M02_JudgeColSource: ["출처", "Source"], - M02_JudgeNeed: ["입력 필요", "Input needed"], - M02_JudgeConflict: ["엇갈림", "Conflict"], - M02_JudgeDefault: ["기본", "Default"], - M02_JudgeUser: ["사용자", "User"], - M02_JudgeUnused: ["안 씀", "Unused"], - M02_JudgeColGroup: ["묶음", "Group"], - M02_JudgeColExcel: ["엑셀", "Excel"], - M02_JudgeColOurs: ["우리", "Ours"], - M02_JudgeColPair: ["대조", "Pair"], - M02_JudgeOursMoney: ["우리 금액", "Our amount"], - M02_JudgeExcelMoney: ["엑셀 금액", "Excel amount"], - M02_JudgeExtra: ["덧 줄(엑셀만)", "Extra lines (Excel only)"], - M02_JudgeNoCand: ["후보 없음", "No candidate"], - M02_JudgeBlocked: ["입력 필요 칸이 남음", "Inputs still needed"], - M02_JudgeMove: ["옮기기", "Move"], - M02_JudgeMoveNone: ["확인한 것 없음", "Nothing confirmed"], - M02_JudgeMoved: [ - "옮김 — 일위대가 {a} · 단가산출 {b} · 막힘 {c}", - "Moved — items {a} · unit calcs {b} · blocked {c}", - ], M02_JudgeCalls: ["부름", "Called by"], M02_JudgeMade: ["만든", "Made"], - M02_JudgeUnitHint: ["엑셀 1 {from} = 우리", "Excel 1 {from} = ours"], - M02_JudgePickN: ["고를 것 {n}", "To pick {n}"], - M02_JudgeAmountNote: [ - "금액은 참고 — 판정은 품", - "Amounts are reference — verdict is by quantity", - ], M02_JudgeOutside: ["일위대가 밖", "Not called by items"], - M02_CheckTitle: ["확인 — 제{n}호표", "Check — item {n}"], - M02_CheckNew: ["새", "New"], M02_CheckImported: ["가져온 식으로 열기", "Open as imported formula"], M02_ToMySk: ["내 단가산출로", "To my build-ups"], M02_ToMySc: ["내 일위대가로", "To my unit costs"], @@ -68,21 +20,8 @@ export const ui_locales_m2_judge = { "{k} 만듦 · 단가산출 {s} · 엑셀과 {same}", "{k} made · build-ups {s} · vs Excel {same}", ], - M02_CheckNewHint: ["「새」 = 785 에서 더한 기능", "「New」 = added in 785"], M02_CheckApart: ["별도계상 · 품목은 프로젝트에서", "Separate · item chosen in project"], - M02_CheckExcelPrice: ["엑셀 단가", "Excel unit price"], - M02_CheckMoneyHint: [ - "금액 칸 위 = 엑셀 · 아래 = 우리(미리 셈 · 엑셀 1 단위)", - "Amount top = Excel · bottom = ours (preview · per Excel unit)", - ], - M02_CheckCount: ["제안 {a} / 줄 {m} · 확인 {c}", "Suggested {a} / lines {m} · confirmed {c}"], - M02_CheckMake: ["일위대가 생성", "Create unit-cost item"], - M02_CheckMakeAsk: [ - "확인한 줄 {a} · 고정 줄 {b}(엑셀 숫자 그대로) — 일위대가 생성", - "Confirmed {a} · fixed {b} (Excel values) — create item", - ], M02_CheckToItem: ["구조물 조합으로", "To structure combo"], - M02_CheckToItemHint: ["일위대가 생성 뒤 켜짐", "Enabled after the item is created"], M02_CheckToItemFail: ["구조물 조합 못 만듦", "Could not create structure item"], M02_CheckItemName: ["구조물 조합 이름", "Structure item name"], M02_CheckItemMake: ["만들기", "Create"], @@ -95,21 +34,4 @@ export const ui_locales_m2_judge = { "구조물 조합 「{name}」 만듦 — {path}", "Structure item 「{name}」 created — {path}", ], - M02_CheckSheet: ["엑셀 보기", "View Excel"], - M02_CheckPick: ["고르기", "Pick"], - M02_CheckSource: ["원문 보기", "Source"], - M02_CheckSourceExcel: ["엑셀 인용 조항", "Excel cited clauses"], - M02_CheckSourceOurs: ["우리 로직 출처", "Our logic source"], - M02_CheckNone: ["없음", "None"], - M02_CheckOption: ["옵션", "Options"], - M02_CheckAdd: ["추가", "Add"], - M02_CheckNoLogic: ["로직없음", "No logic"], - M02_CheckNoLogicHint: [ - "로직없음 = 고정 줄(엑셀 숫자 그대로) · 추가 = 제안으로", - "No logic = fixed line (Excel values) · Add = back to suggestion", - ], - M02_CheckCompare: ["품 비교", "Qty compare"], - M02_CheckMat: ["자재", "Materials"], - M02_CheckNoCalc: ["셈 못 함", "Not computed"], - M02_CheckNoLines: ["구성 줄 없음", "No lines"], } as const; diff --git a/ui_template/ui_template_locale_machine.ts b/ui_template/ui_template_locale_machine.ts index 4bf5609e8..625811d26 100644 --- a/ui_template/ui_template_locale_machine.ts +++ b/ui_template/ui_template_locale_machine.ts @@ -51,7 +51,6 @@ export const ui_locales_machine = { M01_MachineHourly: ["시간당 경비", "Hourly cost"], M01_MachineUse: ["사용", "Active"], M01_MachineShowOff: ["비활성 같이 보기", "Show inactive"], - M01_MachineMeta: ["원문 · 구분", "Source · group"], M01_MachineUses: ["쓰는 곳", "Used by"], M01_MachineNoUses: ["쓰는 곳 없음", "Not used"], M01_MachineFormula: ["쓰는 계산식", "Hourly formula"], @@ -76,7 +75,6 @@ export const ui_locales_machine = { "Unsaved edits. Leave? (edits stay in the draft)", ], M01_MachineNotFound: ["그 기계가 없음", "Machine not found"], - M01_MachineReadOnly: ["읽기만 — 시스템 관리자만 고침", "Read only — system admins edit"], M01_MachineErrors: ["고칠 칸이 있음", "Fix the marked fields"], M01_MachineDetailGroup: ["상세구분", "Sub-group"], M01_MachineSourceNo: ["원문번호", "Source no."],