From 3eea3fe8a3a1bad759f55a0b3461c4d92b255495 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 15:34:24 +0900 Subject: [PATCH 01/23] =?UTF-8?q?chore(ledger):=20=EC=9A=94=EA=B5=AC=20897?= =?UTF-8?q?=20=EC=9E=A5=EB=B6=80=20=E2=80=94=20=EC=B0=BD=20=EC=97=AC?= =?UTF-8?q?=EB=8D=9F=EA=B9=8C=EC=A7=80=20=C2=B7=20=EA=B1=B8=EB=A6=AC?= =?UTF-8?q?=EB=8A=94=20=EC=8B=9C=EA=B0=84=20=EB=AC=BC=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude --- docs/raw/요구_1104/사용자요구_1104.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/docs/raw/요구_1104/사용자요구_1104.md b/docs/raw/요구_1104/사용자요구_1104.md index 24510cfb3..bbd17e25e 100644 --- a/docs/raw/요구_1104/사용자요구_1104.md +++ b/docs/raw/요구_1104/사용자요구_1104.md @@ -1583,3 +1583,13 @@ b09원가에서는 확인할필요 없음. 어차피 m02의정보를 가져가 ## 요구 896 (11-17 · 사용자 · 분석 894 보고 답 — 정할 것 5 번(옛 자료 · 한 번용 스크립트)은 tmp 폴더에 보관 · 나머지 항목 전체 동의 · 천천히 단계적으로 오류 없게 진행) 5번 tmp폴더에 보관. 나머지 항목은 전체 동의. 천천히 단계적으로 오류 없게 진행할것. + +## 요구 897 (11-17 · 사용자 · 예상 종료 시간 물음 · 워크트리를 늘리면 빨라지는지 · 창 여덟까지 늘려도 됨 · 왜 오래 걸리는지 물음) + +예상종료시간? + +워크트리를 더 늘려서 진행하면 빨라질까? + +8개 창까지는 늫려도 됨. + +그런데 궁금한게 왜 이렇게 오래걸리는거야? From 0d44d6346b749cb69d939266bcbb01558b0a58b1 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 15:35:24 +0900 Subject: [PATCH 02/23] =?UTF-8?q?chore(853-3):=20=EB=8B=A8=EA=B0=80?= =?UTF-8?q?=EC=82=B0=EC=B6=9C=20=EA=B3=84=EB=B3=B4=20=EC=A3=BD=EC=9D=80=20?= =?UTF-8?q?=EA=B2=83=20=EA=B1=B7=EC=9D=8C=20=E2=80=94=20=EB=AC=B6=EC=9D=8C?= =?UTF-8?q?=20=E2=91=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 길 POST sangeun/imported(만들기 · TS 0 — 화면은 from-hopyo 만) + ImportedBody 지움 · 서버 길 482 → 481 - San_Book.est_prices · applied · _hcol(부르는 곳 0 · applied · _hcol 은 est_prices 만 씀) · San_MatPick.item_key · San_Stmate.parse_block(시험만) 지움 - 남김: Sangeun_Imported.create — 길은 걷혔으나 시험 11 파일(793-2 · 792-3 · 795-1 · 796-2b · 796-2d · 802-4b1 · 822-1 · 823-1 · 836-2 …)이 가져온 식 SK 바탕을 만드는 입구로 씀(keep(new_doc) 한 줄) — 머리 글에 적음 - 시험: 793-2 san_emit · 797-1a 줄 나무 = 지금 길과 같은 parse_line 줄마다(시험 안 _nodes) · 797-1a applied → applied_how[0] · 827-3 item_key 확인 줄 뺌(바로 위 줄이 같은 값을 봄) Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_San_Book.py | 56 -------------------- M02_MasterTemplete/M02_San_MatPick.py | 6 --- M02_MasterTemplete/M02_San_Stmate.py | 7 --- M02_MasterTemplete/M02_San_Xlsx.py | 2 +- M02_MasterTemplete/M02_Sangeun_Imported.py | 3 +- M02_MasterTemplete/M02_Sangeun_Router.py | 27 +--------- resources/tester/test_793_2_san_emit.py | 12 +++-- resources/tester/test_797_1a_import_flags.py | 9 +++- resources/tester/test_827_3_material_pick.py | 1 - 9 files changed, 20 insertions(+), 103 deletions(-) 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/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_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["이름"])["셈"] From cce681df122af9ea3849b3394b1c0d2bedba6beb Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 15:59:02 +0900 Subject: [PATCH 03/23] =?UTF-8?q?fix(854-1):=20=EB=82=B4=20=EA=B8=B0?= =?UTF-8?q?=EA=B3=84=20=EC=A0=80=EC=9E=A5=20=EC=9E=A0=EA=B8=88=20=C2=B7=20?= =?UTF-8?q?=ED=8C=90=20=EB=8C=80=EC=A1=B0=20=C2=B7=20=EB=B2=88=ED=98=B8=20?= =?UTF-8?q?=EA=B2=B9=EC=B9=A8=20=EB=A7=89=EC=9D=8C=20=E2=80=94=20=EB=AC=B6?= =?UTF-8?q?=EC=9D=8C=20=E2=91=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 번호 발급 + 쓰기를 한 잠금 안에서(`M02_MyMachine.add`) · 이미 있는 파일 번호는 건너뜀(덮어쓰기 없음) - 화면 만들기 · 단가산출 [저장] 초안(`M02_MyMachine_Draft._new`) · 불러오기 자동 생성(`create` 꼴 그대로) 모두 이 한 길 - 고치기 = 화면이 연 판을 보냄 · 다르면 409 {stale, 판} → 화면 「그 사이 다른 곳에서 바뀜」 · 서버 길(판 없음) = 대조 없음 - 답에 `판` · 지우기도 잠금 안 - 시험 test_854_1 — 동시 만들기 8 번 번호 겹침 0(옛 코드 = 8 번 중 3 번호) · 옛 판 409 · 뒤처진 `_다음` 이 있는 파일을 안 덮음 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_MyMachine.py | 75 +++++++++++++----- M02_MasterTemplete/M02_MyMachine_Api.ts | 5 +- M02_MasterTemplete/M02_MyMachine_Draft.py | 16 ++-- M02_MasterTemplete/M02_MyMachine_Form.ts | 10 ++- M02_MasterTemplete/M02_MyMachine_Router.py | 6 +- M02_MasterTemplete/M02_MyMachine_Text.ts | 1 + .../tester/test_854_1_my_machine_lock.py | 77 +++++++++++++++++++ 7 files changed, 157 insertions(+), 33 deletions(-) create mode 100644 resources/tester/test_854_1_my_machine_lock.py diff --git a/M02_MasterTemplete/M02_MyMachine.py b/M02_MasterTemplete/M02_MyMachine.py index bb5e0ef15..7778fc825 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) @@ -420,9 +447,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 +457,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 +543,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..75bc55a6a 100644 --- a/M02_MasterTemplete/M02_MyMachine_Router.py +++ b/M02_MasterTemplete/M02_MyMachine_Router.py @@ -2,7 +2,8 @@ GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) · POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) · -PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · +PUT `/{키}` 몸 {줄, 판?}(판 = 연 판 · 다르면 409 {stale, 판} · 854-1) · +POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}. 권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404). ⚠ 등록은 `main.py`(로그인만). @@ -30,6 +31,7 @@ class MachineBody(BaseModel): 본뜬: 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): @@ -78,7 +80,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/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..001cf95e4 --- /dev/null +++ b/resources/tester/test_854_1_my_machine_lock.py @@ -0,0 +1,77 @@ +# 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임시처음" From 6bffb24f2d6ff60e5a8ed030e40b18f6c7af92df Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:00:19 +0900 Subject: [PATCH 04/23] =?UTF-8?q?fix(854-1):=20=EA=B8=B0=EA=B3=84=20?= =?UTF-8?q?=EC=B0=BD=20=EB=AA=A9=EB=A1=9D=20=EC=8B=9C=EA=B0=84=EB=8B=B9=20?= =?UTF-8?q?=EB=A9=94=EB=AA=A8=EC=97=90=20=EC=83=89=EC=9D=B8=20=EC=A7=80?= =?UTF-8?q?=ED=82=B4=20=E2=80=94=20=EB=AC=B6=EC=9D=8C=20=E2=91=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - `M02_Machine_Hourly._BRIEF` 열쇠 = 색인 주소(`id`) → 키 · 값에 만든 색인을 같이 두고 꺼낼 때 `is` 확인 · 색인이 바뀌면 통째 비움 (옛 색인 주소가 다시 쓰이면 옛 시간당이 나올 수 있던 틈 · `M02_Sangeun_Copy._CACHE` 와 같은 꼴) - 시험 test_854_1 ④ — 색인을 바꾸면 새 가격 · 시간당 · 되돌리면 처음 값 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Machine_Hourly.py | 15 +++++++++---- .../tester/test_854_1_my_machine_lock.py | 21 +++++++++++++++++++ 2 files changed, 32 insertions(+), 4 deletions(-) diff --git a/M02_MasterTemplete/M02_Machine_Hourly.py b/M02_MasterTemplete/M02_Machine_Hourly.py index c263059c6..1911f808c 100644 --- a/M02_MasterTemplete/M02_Machine_Hourly.py +++ b/M02_MasterTemplete/M02_Machine_Hourly.py @@ -235,7 +235,9 @@ 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]]: @@ -246,11 +248,15 @@ def brief(keys: list[str]) -> list[dict[str, Any]]: 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: @@ -272,7 +278,8 @@ def brief(keys: list[str]) -> list[dict[str, Any]]: ) 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} + got = {**head, "값": to_json(row.get("값")), "시간당": hour} + _BRIEF[key] = (index, got) out.append(got) return out diff --git a/resources/tester/test_854_1_my_machine_lock.py b/resources/tester/test_854_1_my_machine_lock.py index 001cf95e4..ede2f0ada 100644 --- a/resources/tester/test_854_1_my_machine_lock.py +++ b/resources/tester/test_854_1_my_machine_lock.py @@ -75,3 +75,24 @@ def test_counter_behind_skips_file(world): 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 From ba6f25b9712e6a53de864831c09a36c71809e782 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:00:36 +0900 Subject: [PATCH 05/23] =?UTF-8?q?fix(854-2):=20M01=20=ED=82=A4=20=EB=8C=80?= =?UTF-8?q?=EC=9E=A5=20=EC=93=B0=EA=B8=B0=20=EC=9B=90=EC=9E=90=EC=A0=81=20?= =?UTF-8?q?=C2=B7=20=ED=8C=8C=EC=9D=BC=20=EC=93=B0=EA=B8=B0=20=EC=A4=91?= =?UTF-8?q?=EA=B0=84=20=EC=8B=A4=ED=8C=A8=20=EB=95=8C=20=EB=8C=80=EC=9E=A5?= =?UTF-8?q?=20=C2=B7=20=ED=8C=8C=EC=9D=BC=20=EC=A0=80=EC=9E=A5=20=EC=A0=84?= =?UTF-8?q?=EC=9C=BC=EB=A1=9C=20=EB=90=98=EB=8F=8C=EB=A6=BC=20=E2=80=94=20?= =?UTF-8?q?=EB=AC=B6=EC=9D=8C=20=E2=91=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - master_keys.save_book = 임시 파일 → 교체(반쪽 대장 없음 · 빌더도 같은 길) - Store_Save.save = 대장 → 파일 차례 그대로 · 파일 쓰기가 끊기면 쓴(쓰려던) 파일 · 기계 대 · 대장을 저장 전 글로(대장만 앞서가지 않음) - 시험 test_854_2_m01_key_book — 첫 파일 · 둘째 파일(반쯤 쓴 뒤) 끊김 = 바이트 그대로 · 끊김 없음 = 대장 · 파일 같이 감 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Store_Save.py | 42 ++++++- resources/master_data/scripts/master_keys.py | 5 +- resources/tester/test_854_2_m01_key_book.py | 113 +++++++++++++++++++ 3 files changed, 155 insertions(+), 5 deletions(-) create mode 100644 resources/tester/test_854_2_m01_key_book.py 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/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/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임시" From 9ef07f86afb1159889ebaae5994c022267c3b2d0 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:01:54 +0900 Subject: [PATCH 06/23] =?UTF-8?q?fix(854-1):=20=EB=8B=A8=EA=B0=80=EC=82=B0?= =?UTF-8?q?=EC=B6=9C=20=C2=B7=20=EC=9D=BC=EC=9C=84=EB=8C=80=EA=B0=80=20?= =?UTF-8?q?=C2=B7=20=EB=82=B4=20=EC=9E=AC=EB=A3=8C=20=EB=B2=88=ED=98=B8=20?= =?UTF-8?q?=E2=80=94=20=EC=A7=80=EC=9A=B4=20=EB=81=9D=20=EB=B2=88=ED=98=B8?= =?UTF-8?q?=20=EB=8B=A4=EC=8B=9C=20=EC=95=88=20=EC=94=80=20=E2=80=94=20?= =?UTF-8?q?=EB=AC=B6=EC=9D=8C=20=E2=91=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - SK · SC(`M02_Labor_Ref.next_key`) = 층 뿌리 장부 `_번호.json` {종류: 발급한 가장 큰 번호} · 다음 = 파일 · 장부 가운데 큰 번호 + 1 · 만들기 성공 뒤 장부에 적음(store 잠금 안 · 더 클 때만) - 내 재료 PM(`M02_Material_Own._last`) = 층 파일 `개인자재.json` 의 `마지막` 칸도 셈 · 새로 넣을 때 적음 - 내 기계 EQP 는 이미 `_다음` 카운터라 그대로 · 있는 번호 · 파일은 안 건드림(층마다 같은 SK 번호 = 층 따로라 정상) - 시험 test_854_1 ⑤ — 끝 번호 지운 뒤 새로 만들기 = 새 번호(옛 코드 = 지운 번호 다시 씀) Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Labor_Ref.py | 32 +++++++++++++++++-- M02_MasterTemplete/M02_Material_Own.py | 20 ++++++------ .../tester/test_854_1_my_machine_lock.py | 21 ++++++++++++ 3 files changed, 61 insertions(+), 12 deletions(-) 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_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/resources/tester/test_854_1_my_machine_lock.py b/resources/tester/test_854_1_my_machine_lock.py index ede2f0ada..0e3c84833 100644 --- a/resources/tester/test_854_1_my_machine_lock.py +++ b/resources/tester/test_854_1_my_machine_lock.py @@ -96,3 +96,24 @@ def test_brief_cache_follows_index(monkeypatch): 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" From 6ed71abde207fa038c5d7e7df3c3b37e4ed3bca0 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:10:25 +0900 Subject: [PATCH 07/23] =?UTF-8?q?chore(853-3):=20=EB=B6=88=EB=9F=AC?= =?UTF-8?q?=EC=98=A4=EA=B8=B0=20=ED=99=94=EB=A9=B4=20=EC=A3=BD=EC=9D=80=20?= =?UTF-8?q?=EA=B2=83=20=C2=B7=20=EA=B8=80=20=ED=82=A4=20=EA=B1=B7=EC=9D=8C?= =?UTF-8?q?=20=E2=80=94=20=EB=AC=B6=EC=9D=8C=20=E2=91=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - logic/M02_MasterTemplete_Hopyo_Unit.ts(TS import 0) + helper_m02_hopyo_unit.cjs(부르는 시험 0) 지움 - Hopyo_SheetNav.dropGrid · Hopyo_Side 표지 data-hopyo-wizard-open(읽는 곳 0) 지움 - Hopyo.css 선택자 열(m02-hopyo__search · table · parts · part · times · unit · unit-text · acts — TS · html 0 · 조립 이름 0)과 딸린 주석 지움 - 글 키(저장소 전체 ts · js · cjs · py · html 낱말 찾기 · 조립 키 M02_TreeCopyTo* 셋 뺌): ui_template_locale_m2 247 → 173(−74 · 불러오기 Sk · Left · HopyoUnit · HopyoKid · Lost · Elem) · ui_template_locale_m2_judge 81 → 18(−63 · 옛 판정 · 확인 창) - test_720 의 옛 장부 단추 글자 확인 두 줄 뺌(815-2 에 걷힌 buildHopyoLedger · 전부터 실패하던 글자 시험) - typecheck 0 Co-Authored-By: Claude Opus 5.5 --- .../M02_MasterTemplete_Hopyo.css | 51 ---------- .../M02_MasterTemplete_Hopyo_SheetNav.ts | 1 - .../M02_MasterTemplete_Hopyo_Side.ts | 1 - .../logic/M02_MasterTemplete_Hopyo_Unit.ts | 61 ------------ resources/tester/helper_m02_hopyo_unit.cjs | 13 --- resources/tester/test_720_m02_folder_layer.py | 4 +- ui_template/ui_template_locale_m2.ts | 98 ------------------- ui_template/ui_template_locale_m2_judge.ts | 78 --------------- 8 files changed, 1 insertion(+), 306 deletions(-) delete mode 100644 M02_MasterTemplete/logic/M02_MasterTemplete_Hopyo_Unit.ts delete mode 100644 resources/tester/helper_m02_hopyo_unit.cjs 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/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/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_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/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; From 9805d605544d93184bd73cbc8b53e41a361757d7 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:17:42 +0900 Subject: [PATCH 08/23] =?UTF-8?q?chore(ledger):=20=EC=84=A4=EA=B3=84=20855?= =?UTF-8?q?=20=E2=80=94=20=EA=B1=B8=EC=9D=8C=202=20=EC=A0=95=EB=B3=B8=20?= =?UTF-8?q?=ED=95=98=EB=82=98=20=C2=B7=20=EA=B3=84=EC=82=B0=EA=B8=B0=20?= =?UTF-8?q?=ED=95=98=EB=82=98(=EC=98=9B=20=EC=97=94=EC=A7=84=20=EB=B6=80?= =?UTF-8?q?=EB=A5=B4=EB=8A=94=20=EC=9E=90=EB=A6=AC=20=EC=A0=84=EC=88=98=20?= =?UTF-8?q?=C2=B7=20=EC=B8=A1=EC=A0=95=20=C2=B7=2013=20=EA=B1=B8=EC=9D=8C)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude --- .../요구_1104/설계_855_정본하나_계산기하나.md | 311 ++++++++++++++++++ 1 file changed, 311 insertions(+) create mode 100644 docs/raw/요구_1104/설계_855_정본하나_계산기하나.md 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 코드는 이름만 봄(무엇을 부르는지) · 그 페이지 동작은 안 봄. From 4a672d99a3ece36863097de4879977c1c1e72cc2 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:26:34 +0900 Subject: [PATCH 09/23] =?UTF-8?q?test(854-1):=20=EC=B8=B5=20=EB=AA=A9?= =?UTF-8?q?=EB=A1=9D=20=EA=B8=B0=EC=96=B5=20=EC=8B=9C=ED=97=98=20=E2=80=94?= =?UTF-8?q?=20=EC=A7=80=EC=9A=B4=20SK=20=EB=B2=88=ED=98=B8=EB=A5=BC=20?= =?UTF-8?q?=EC=83=88=20=EA=B2=83=EC=9D=B4=20=EB=B0=9B=EB=8A=94=EB=8B=A4?= =?UTF-8?q?=EB=8A=94=20=EA=B8=B0=EB=8C=80=EB=A5=BC=20=EC=83=88=20=EB=B2=88?= =?UTF-8?q?=ED=98=B8=EB=A1=9C=20=E2=80=94=20=EB=AC=B6=EC=9D=8C=20=E2=91=A2?= =?UTF-8?q?=20=EB=92=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - test_826_1 `test_edit_delete_add_and_dep_change` 가 옛 동작(지운 끝 번호 다시 씀)을 전제 · 묶음 ③ 으로 바뀐 그 한 줄만 고침 (바뀐 항목만 다시 읽음 · 목록 같음 판정은 그대로) Co-Authored-By: Claude Opus 5.5 --- resources/tester/test_826_1_layer_index.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 == [] From e371b431654f7763e41646299c877177e5f1ff27 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:31:55 +0900 Subject: [PATCH 10/23] =?UTF-8?q?chore(853-3):=20853-1=20=C2=B7=20853-2=20?= =?UTF-8?q?=EA=B0=80=20=EB=84=98=EA=B8=B4=20=EA=B2=83=20=EA=B1=B7=EC=9D=8C?= =?UTF-8?q?=20=E2=80=94=20=EB=AC=B6=EC=9D=8C=20=E2=91=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 껍데기 M01_MasterData_UI_Logic_Money.ts 지움 — M02 네 파일(Labor_Diagram · LogicMats · MatTable · Rows) import 를 공용 common_util_money 로 - M01 Parts.of_machine(비시험 0) · Equation.links(비시험 0 · Doc.candidates 와 같은 함수) 지움 · 시험 813-2 해당 줄 뺌 · 800-2 = Doc.candidates 로 - 공용 사전 죽은 M01_ 키 13(locale_m1 11 · locale_machine 2 — 저장소 전체 낱말 0 · 조립 키 0) 지움 - 길 POST /layers/{층}/my-machines/draft(화면 0) + 몸 칸 키 · 표지 지움 · 서버 길 481 → 480 · 시험 827-1 남의 층 403 = 만들기 길로 봄 - 남김: Equation.export_row — 비시험 0 이나 시험 796-1 · 800-2 의 수식 모델(옛 엔진 · edit_row 왕복) 바탕 → 옛 엔진 은퇴(걸음 2)와 같이 · MyMachine_Draft.check — 시험 827-1 이 미리 셈 · 저장 셈과 맞대는 기준값 - typecheck 0 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Equation.py | 8 +------- M01_MasterData/M01_MasterData_Parts.py | 13 ------------- M01_MasterData/M01_MasterData_UI_Logic_Money.ts | 11 ----------- .../M02_MasterTemplete_Labor_Diagram.ts | 2 +- .../M02_MasterTemplete_Labor_LogicMats.ts | 2 +- .../M02_MasterTemplete_Labor_MatTable.ts | 2 +- .../M02_MasterTemplete_Labor_Rows.ts | 2 +- M02_MasterTemplete/M02_MyMachine_Router.py | 15 +-------------- resources/tester/test_800_2_equation_layout.py | 7 ++++--- resources/tester/test_813_2_parts.py | 4 ---- resources/tester/test_827_1_machine_window.py | 2 +- ui_template/ui_template_locale_m1.ts | 11 ----------- ui_template/ui_template_locale_machine.ts | 2 -- 13 files changed, 11 insertions(+), 70 deletions(-) delete mode 100644 M01_MasterData/M01_MasterData_UI_Logic_Money.ts 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_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_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_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_MyMachine_Router.py b/M02_MasterTemplete/M02_MyMachine_Router.py index 31ee23219..ceb71b437 100644 --- a/M02_MasterTemplete/M02_MyMachine_Router.py +++ b/M02_MasterTemplete/M02_MyMachine_Router.py @@ -3,7 +3,7 @@ GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) · POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) · PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · -POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}. +옛 POST `/draft`(기계 창 [확인] · 화면 0)은 853-3 에서 지움 — 확인 셈 `M02_MyMachine_Draft.check` 는 시험 827-1 기준값으로 남김. 권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404). ⚠ 등록은 `main.py`(로그인만). """ @@ -17,7 +17,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 +27,6 @@ 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) — 화면이 정한 표지(셈 기록 열쇠) def _folder(session: Session, layer: str, owner: str | None, write: bool = False): @@ -43,16 +40,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) 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_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_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/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_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."], From 62eb64854047a206795f40da216e8ddb9305211c Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:35:02 +0900 Subject: [PATCH 11/23] =?UTF-8?q?chore(ledger):=20=EC=9A=94=EA=B5=AC=20898?= =?UTF-8?q?=20=EC=9E=A5=EB=B6=80=20=E2=80=94=20B08=20=C2=B7=20B09=20?= =?UTF-8?q?=EC=A7=81=EC=A0=91=20=EA=B3=84=EC=82=B0=20=EC=97=86=EC=9D=8C=20?= =?UTF-8?q?=C2=B7=20=EC=98=9B=20=EB=A1=9C=EC=A7=81=20=ED=8C=8C=EC=9D=BC=20?= =?UTF-8?q?tmp=20=EB=A1=9C=20=C2=B7=20=EB=A7=89=ED=9E=98=20=EC=9C=A0?= =?UTF-8?q?=EC=A7=80=20=C2=B7=20=ED=91=9C=EC=8B=9C=20=3D=20=EC=9B=90?= =?UTF-8?q?=EB=AC=B8=20=EC=9E=90=EB=A6=BF=EC=88=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude --- docs/raw/요구_1104/사용자요구_1104.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docs/raw/요구_1104/사용자요구_1104.md b/docs/raw/요구_1104/사용자요구_1104.md index bbd17e25e..40174df14 100644 --- a/docs/raw/요구_1104/사용자요구_1104.md +++ b/docs/raw/요구_1104/사용자요구_1104.md @@ -1593,3 +1593,10 @@ b09원가에서는 확인할필요 없음. 어차피 m02의정보를 가져가 8개 창까지는 늫려도 됨. 그런데 궁금한게 왜 이렇게 오래걸리는거야? + +## 요구 898 (11-17 · 사용자 · 걸음 2 설계 「브레인이 정한 것」 넷에 답 — B08 · B09 는 M02 것을 복사해 가져가 비목별 합산만 · 직접 계산 없음 / 옛 로직 파일은 tmp 로 이동(한 번에 삭제 예정) / 막힘 기준 일단 유지 / 화면 단가는 품셈 원문 자릿수로 보이고 계산은 정밀하게) + +1. B08/B09는 M02에서 만들어진 단가산출, 일위대가, 구조물조합을 통해 복사하여 프로젝트 내부로 들어감. 계산은 인건비, 재료비, 경비를 구분하여 합산 정도만 함. 계산을 직접할 일은 없음. +2. 옛로직 파일은 tmp 폴더로 이동(한번에 삭제예정) +3. 일단유지 +4. 화면의 단가는 끝수는 사용자에게 보여질때는 품셈의 원문의 단위당 소수점 자리수를 따르게 되어있으며 계산은 정밀도 있게 계산해달라고 요청했었음. 반영되어있을걸로 보임. From 177c0fa423276304880849a0ebbbcc8ec1347b34 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:36:22 +0900 Subject: [PATCH 12/23] =?UTF-8?q?chore(ledger):=20=EC=9A=94=EA=B5=AC=20899?= =?UTF-8?q?=20=EC=9E=A5=EB=B6=80=20=E2=80=94=20M02=20=EC=B8=B5=20=EC=A0=80?= =?UTF-8?q?=EC=9E=A5=EB=B3=B8=EC=9D=80=20=EC=8B=9C=ED=97=98=20=EC=9E=90?= =?UTF-8?q?=EB=A3=8C(=EC=A7=80=EC=9B=8C=EB=8F=84=20=EB=90=A8)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude --- docs/raw/요구_1104/사용자요구_1104.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/raw/요구_1104/사용자요구_1104.md b/docs/raw/요구_1104/사용자요구_1104.md index 40174df14..312fd38fb 100644 --- a/docs/raw/요구_1104/사용자요구_1104.md +++ b/docs/raw/요구_1104/사용자요구_1104.md @@ -1600,3 +1600,7 @@ b09원가에서는 확인할필요 없음. 어차피 m02의정보를 가져가 2. 옛로직 파일은 tmp 폴더로 이동(한번에 삭제예정) 3. 일단유지 4. 화면의 단가는 끝수는 사용자에게 보여질때는 품셈의 원문의 단위당 소수점 자리수를 따르게 되어있으며 계산은 정밀도 있게 계산해달라고 요청했었음. 반영되어있을걸로 보임. + +## 요구 899 (11-17 · 사용자 · 지금 M02 의 개인 · 회사 · 마스터 데이터는 개발 중 테스트 결과 — 삭제해도 됨) + +추가로 현재 M02의 개인/회사/마스터 데이터는 프로그램 개발과정에서 테스트한 결과임. 삭제 해도됨. From 77c7a0e3467d3ea034f1ac77b414dae1569de2a2 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:38:45 +0900 Subject: [PATCH 13/23] =?UTF-8?q?test(853-4):=20=EB=B2=94=EC=9C=84=20?= =?UTF-8?q?=EC=8B=9C=ED=97=98=20=EA=B8=B0=EC=A4=80=EC=84=A0=20=E2=80=94=20?= =?UTF-8?q?=EB=82=A1=EC=9D=80=20=EA=B8=B0=EB=8C=80=EA=B0=92=20=EB=91=98=20?= =?UTF-8?q?=EB=B0=94=EB=A1=9C=EC=9E=A1=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - test_553_5 test_m02_dataflow_muted_spans_use_ui_text: 보조 글 꼴 21 곳 이상 셈 단언 걷음 — 794-1b(598b80eb2)가 DataFlow 화면을 지운 뒤 2 곳 · 죽은 화면을 붙든 소스 글자 셈(옛 변종 없음 확인은 남김) - test_713_3 test_묶음_작업량_부르기: 묶음 줄 수 334 박음 → 뜻(묶음수 = 같은 묶음 로직 수 · 새 기계경비식 GC001196~1202 = 8 절 묶음) — 848-4(7b1985b69) GC001202 가 묶음에 들어 335 Co-Authored-By: Claude Opus 5.5 --- resources/tester/test_553_5_m01_m02.py | 1 - resources/tester/test_713_3_list.py | 8 ++++++-- 2 files changed, 6 insertions(+), 3 deletions(-) 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_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"] # 측구터파기 작업량 → 단가 로직 밑 From c918e09343c3578942b5848725b2060779a1415b Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:38:45 +0900 Subject: [PATCH 14/23] =?UTF-8?q?test(853-4):=20791-1=20=EC=85=88=20?= =?UTF-8?q?=EC=A7=80=EB=AC=B8=20=E2=80=94=20=EC=9E=90=EB=A3=8C=20=EB=B0=94?= =?UTF-8?q?=EB=80=8C=EB=A9=B4=20=EC=A1=B0=EC=9A=A9=ED=9E=88=20=EA=B1=B4?= =?UTF-8?q?=EB=84=88=EB=9B=B0=EB=8D=98=20=EA=BC=B4=EC=9D=84=20=EC=8B=A4?= =?UTF-8?q?=ED=8C=A8=EB=A1=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 마스터 데이터 해시가 달라도 건너뛰지 않고 셈 결과를 맞댐 — 같으면 통과 · 다르면 실패(까닭 자료/엔진 · 지문 다시 뜨는 법을 실패 글에) - 853-3 이 찾은 「한 달 가까이 건너뜀」 재발 막음 · 로직 수 단언은 키 대조(빠짐 · 늘어남)로 갈음 Co-Authored-By: Claude Opus 5.5 --- resources/tester/test_791_1_engine_semantics.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) 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" + ) # ── 시험 마스터 ─────────────────────────────────────────────────────── From fe9920851cf8d63f385a85250be0d99548483ef2 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:43:09 +0900 Subject: [PATCH 15/23] =?UTF-8?q?fix(854-2):=20M01=20=EC=88=98=EC=8B=9D=20?= =?UTF-8?q?=EB=AC=B8=EC=84=9C=20=EC=93=B0=EA=B8=B0=20=EC=95=88=EC=A0=84=20?= =?UTF-8?q?=EA=B8=B8=20=E2=80=94=20=EC=9E=A0=EA=B8=88=20=C2=B7=20=EC=9E=84?= =?UTF-8?q?=EC=8B=9C=20=ED=8C=8C=EC=9D=BC=20=E2=86=92=20=EA=B5=90=EC=B2=B4?= =?UTF-8?q?=20=C2=B7=20=EB=AC=B8=EC=84=9C=EB=B3=84=20=ED=8C=90=20=EB=8C=80?= =?UTF-8?q?=EC=A1=B0=20409=20=E2=80=94=20=EB=AC=B6=EC=9D=8C=20=E2=91=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Doc.put 한 곳으로 씀(save · drop · Machine._register_docs) · Doc._LOCK 안 · 임시 파일 → os.replace - 판 = 문서 한 장 저장 글 지문 · 읽기가 「판」 을 줌 · /logic/doc/save 가 받은 판과 다르면 409(화면 Save_Stale 과 같은 글) · 판 없음 = 대조 안 함(옛 부름 · 시험) - M01 줄 쌓기 [저장]이 판을 보냄(M02 사본 길은 그대로) — 기계 목록 등록이 바꾼 문서를 옛 화면이 덮지 않음 - 수식 문서 폴더가 AISLO_MASTER_DIR 사본을 따름(마스터 사본 · 문서 정본이 갈리던 것) · 마스터만 사본인 시험은 정본 문서를 안 씀 - 시험 test_854_2_m01_doc_write — 옛 판 409 · 동시 두 저장 = 하나 ok 하나 409 · 기계 등록 뒤 옛 판 409 · 정본 안 씀 Co-Authored-By: Claude Opus 5.5 --- A00_Common/line_stack_screen.ts | 5 +- M01_MasterData/M01_MasterData_Doc.py | 75 +++++++--- M01_MasterData/M01_MasterData_Machine.py | 32 ++-- M01_MasterData/M01_MasterData_Router.py | 3 +- .../master_data/scripts/master_doc_link.py | 5 +- resources/tester/test_854_2_m01_doc_write.py | 141 ++++++++++++++++++ 6 files changed, 221 insertions(+), 40 deletions(-) create mode 100644 resources/tester/test_854_2_m01_doc_write.py diff --git a/A00_Common/line_stack_screen.ts b/A00_Common/line_stack_screen.ts index 10bb90115..d37ca76ef 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..3627779db 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: @@ -150,22 +174,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 +251,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_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_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/resources/master_data/scripts/master_doc_link.py b/resources/master_data/scripts/master_doc_link.py index 72facfb2a..6cc42b297 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/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 From 327fdc5d9b0f417a6a95076d60035a676fdab3f3 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:45:14 +0900 Subject: [PATCH 16/23] =?UTF-8?q?test(855-A):=20=EA=B1=B8=EC=9D=8C=202=20?= =?UTF-8?q?=EC=A7=80=ED=82=B4=20=EC=8B=9C=ED=97=98=20=EB=8B=A4=EC=84=AF=20?= =?UTF-8?q?=E2=80=94=20=EC=98=9B=20=EC=97=94=EC=A7=84=20=EB=8C=80=20?= =?UTF-8?q?=EC=83=88=20=EA=B3=84=EC=82=B0=EA=B8=B0=20=C2=B7=20=EC=83=88=20?= =?UTF-8?q?=EB=8B=B5=20=EC=A7=80=EB=AC=B8=20=C2=B7=20SK=20=EA=B2=AC?= =?UTF-8?q?=EB=B3=B8=20=C2=B7=20=EB=A7=89=ED=9E=98=20=C2=B7=20=EB=B6=88?= =?UTF-8?q?=EB=9F=AC=EC=98=A4=EA=B8=B0=20=EC=98=9B=20=EA=B2=80=EC=82=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - test_855_engine_parity: 로직 전수 기본 입력 L0 ~ L3 옛 대 새 · 다름 = 채택 목록(빌더 ADOPTED)과 같음 · 보이는 단가만 다름은 허용 갈래 · 옵션 전수 = S855_ALL=1 - test_855_golden + golden_855_engine.json: 새 계산기 답 지문(로직마다 기본 + 옵션 표본) · 다르면 실패 · 다시 뜨기 = --write(자료를 뜻대로 바꾼 걸음만) - test_855_sk_layers: 임시 층 SK 견본(바탕 · 옛 칸 더한줄 · 율 더한줄 · 형제 SK · 가져온 식) 옛 = 새 · 줄 합 = 기준 · 「따로」 는 지금 사실(줄 = 옛 · 기준 = 새)을 단언 — 2-C1 에서 뒤집음 - test_855_block: 막힘 옛(check_logic) = 새(문서 표지) · 틀린 식은 둘 다 막힘 - test_812_1_xlsx_golden: 금액 표본 sweep 에 옛 검산(옛 엔진) = 새 셈 단언 하나 - 도우미 helper_855_engine(경우 · 층 가름 · 지문) · 제품 코드 고침 0 - 싱크 관문에는 안 넣음 — 기존 관문 넷이 이미 약 7 분(5 분 넘음) Co-Authored-By: Claude Opus 5.5 --- resources/tester/golden_855_engine.json | 1526 ++++++++++++++++++++ resources/tester/helper_855_engine.py | 164 +++ resources/tester/test_812_1_xlsx_golden.py | 8 +- resources/tester/test_855_block.py | 33 + resources/tester/test_855_engine_parity.py | 46 + resources/tester/test_855_golden.py | 47 + resources/tester/test_855_sk_layers.py | 125 ++ 7 files changed, 1948 insertions(+), 1 deletion(-) create mode 100644 resources/tester/golden_855_engine.json create mode 100644 resources/tester/helper_855_engine.py create mode 100644 resources/tester/test_855_block.py create mode 100644 resources/tester/test_855_engine_parity.py create mode 100644 resources/tester/test_855_golden.py create mode 100644 resources/tester/test_855_sk_layers.py 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_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/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_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_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 에서 뒤집을 단언 — 줄 = 옛 길 From fe6452f8585160b7f61b94a0cd2e08b7be37cc23 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:54:07 +0900 Subject: [PATCH 17/23] =?UTF-8?q?chore(ledger):=20=EC=84=A4=EA=B3=84=20855?= =?UTF-8?q?=20=EB=B3=B4=EC=B6=A9=20=E2=80=94=20B08=20=C2=B7=20B09=20?= =?UTF-8?q?=EC=98=9B=20=EC=97=94=EC=A7=84=20=EA=B1=B7=EA=B8=B0=20=C2=B7=20?= =?UTF-8?q?=EB=A1=9C=EC=A7=81=20JSON=20=EC=97=86=EC=95=A0=EA=B8=B0=20?= =?UTF-8?q?=C2=B7=20=ED=98=B8=ED=99=98=20=EB=BA=8C=20=C2=B7=20=EB=B0=94?= =?UTF-8?q?=EB=80=90=20=EA=B1=B8=EC=9D=8C=20=ED=91=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude --- .../설계_855_보충_B09_로직JSON_호환.md | 286 ++++++++++++++++++ 1 file changed, 286 insertions(+) create mode 100644 docs/raw/요구_1104/설계_855_보충_B09_로직JSON_호환.md 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 에서 봄. +- 줄 수 어림은 함수 크기로 짐작한 값. From 7d19c0389d807870cde3f0683a915bae3b53e92f Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 17:00:54 +0900 Subject: [PATCH 18/23] =?UTF-8?q?feat(854-2):=20M01=20[=EB=A1=9C=EC=A7=81?= =?UTF-8?q?=20=EB=B3=B5=EC=82=AC/=EC=83=9D=EC=84=B1]=20=EC=9D=B4=20?= =?UTF-8?q?=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C=EB=A5=BC=20=EA=B0=99?= =?UTF-8?q?=EC=9D=B4=20=EC=A7=80=EC=9D=8C=20=C2=B7=20=EB=A1=9C=EC=A7=81=20?= =?UTF-8?q?=EC=A7=80=EC=9A=B0=EB=A9=B4=20=EB=AC=B8=EC=84=9C=EB=8F=84=20?= =?UTF-8?q?=E2=80=94=20=EB=AC=B6=EC=9D=8C=20=E2=91=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Doc.make = 빌더와 같은 변환(convert) · 같은 대조(옛 엔진 = 새 계산기 · 기본 + 옵션 표본 · 부르는 단가산출 저장본)를 지난 것만 수식_<파일>.json 에 씀(빌더가 다시 지어도 같은 글) · 못 지나면 안 씀 - Store_Make.logic_new(/logic/copy · /logic/formula/save 공용)가 make 부름 · 답에 「수식문서」 - Store_Make.save 의 로직 줄 지움(/save)도 그 수식 문서를 지움(/logic/remove 와 같은 끝 · 문서만 남지 않게) - 빌더 build_수식문서_802_2 = 대조 갈래 cases_of · agree 로 꺼냄(동작 같음 · --check 같음) - 시험 test_854_2_m01_copy_doc — 복사 · 식 복사 → 문서 있음 · 금액 = 옛 엔진 = 본뜬 로직 · 빌더 다시 지음 = 같은 파일 글 · 지움 → 문서 없음 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Doc.py | 42 +++++++ M01_MasterData/M01_MasterData_Store_Make.py | 21 +++- .../scripts/build_수식문서_802_2.py | 29 +++-- resources/tester/test_854_2_m01_copy_doc.py | 108 ++++++++++++++++++ 4 files changed, 189 insertions(+), 11 deletions(-) create mode 100644 resources/tester/test_854_2_m01_copy_doc.py diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index 3627779db..767827b1f 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -154,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 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 · 다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로.""" 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/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/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() From f6d7fd14f1a6391303ec7e1bb6e9adfea5cacb3c Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 17:22:41 +0900 Subject: [PATCH 19/23] =?UTF-8?q?test(855-F):=20B9-0=20B08=20=C2=B7=20B09?= =?UTF-8?q?=20=EB=8B=B5=20=EC=A7=80=EB=AC=B8=20=E2=80=94=20=EC=9E=84?= =?UTF-8?q?=EC=8B=9C=20=EC=B8=B5=20=EA=B2=AC=EB=B3=B8=20=C2=B7=20=EC=82=AC?= =?UTF-8?q?=EB=B3=B8=20=EC=A7=80=EA=B8=88=20=EA=B8=B8=20=C2=B7=20=EC=86=90?= =?UTF-8?q?=20=EC=A4=84=20=C2=B7=20=EB=8B=A4=EB=A5=B4=EB=A9=B4=20=EC=8B=A4?= =?UTF-8?q?=ED=8C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - test_855_b09_golden + golden_855_b09.json: 개인 층 견본(SK 바탕 · 율 더한줄 · 형제 · 따로 · 가져온 식 · 기계 · 재료 / SC 참조 · 고정 · 로직 + 자재) → 구조물 사본(labor_doc_rows · price_bundle) · B09 서고 사본(import_copy) · 설계내역서 손 줄(율 · 고른 재료 · 입력 · 운반공 거리 채움) - 지문 갈래 15: calc_user · daega_inputs · 단가 수요 키 · 산근(관급 있음 · 없음 · 값 / 글 따로) · logic_preview 손 줄마다(값 / 글) · B08 snapshot_units - 다르면 실패 + 다시 뜨기(--write) 글 · 세 번 돌려 같음 · 제품 코드 고침 0 Co-Authored-By: Claude Opus 5.5 --- resources/tester/golden_855_b09.json | 20 ++ resources/tester/test_855_b09_golden.py | 264 ++++++++++++++++++++++++ 2 files changed, 284 insertions(+) create mode 100644 resources/tester/golden_855_b09.json create mode 100644 resources/tester/test_855_b09_golden.py 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/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])) From a251bf663166a303c9373677634e7aeaf7c979ef Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 17:45:49 +0900 Subject: [PATCH 20/23] =?UTF-8?q?refactor(855-B2):=20=EA=B8=B0=EA=B3=84=20?= =?UTF-8?q?=EC=8B=9C=EA=B0=84=EB=8B=B9=20=EC=98=9B=20=EC=97=94=EC=A7=84=20?= =?UTF-8?q?=ED=8F=B4=EB=B0=B1=20=EA=B1=B7=EC=9D=8C=20=E2=80=94=20=EC=88=98?= =?UTF-8?q?=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20=EC=97=86=EC=9D=8C=20=3D=20?= =?UTF-8?q?=EB=AA=BB=20=EC=85=88=20+=20=EA=B9=8C=EB=8B=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - `M02_Machine_Hourly.hourly`(M01 `store.calc`) · `brief`(`mf.run`) · `M02_MyMachine.hourly`(`mf.run`) 세 폴백 걷음 - 세 곳의 같은 몸 = 새 `M02_Machine_Hourly.hour`(문서 계산기 한 길) · `doc_sums` 는 None 대신 {ok False, reason 「식 문서 없음 — 「키」」, 로직} - 854-1 잠금 · 판 · 메모 지킴 그대로 - 대조: M01 기계 655 대 hourly · brief 옛 코드와 다름 0(문서 없음 0 · 못 셈 44 는 원래 그대로) · 관련 309 통과 · 빌더 같음 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Machine_Hourly.py | 70 ++++++++---------------- M02_MasterTemplete/M02_MyMachine.py | 20 +------ 2 files changed, 25 insertions(+), 65 deletions(-) diff --git a/M02_MasterTemplete/M02_Machine_Hourly.py b/M02_MasterTemplete/M02_Machine_Hourly.py index 1911f808c..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) @@ -243,8 +230,6 @@ _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 @@ -265,20 +250,9 @@ 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 = {**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_MyMachine.py b/M02_MasterTemplete/M02_MyMachine.py index 7778fc825..33859078c 100644 --- a/M02_MasterTemplete/M02_MyMachine.py +++ b/M02_MasterTemplete/M02_MyMachine.py @@ -254,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} # ── 검사 ────────────────────────────────────────────────────────────── From d6f35e16a54279689e4a82d1f6697e485a2358f1 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 17:49:50 +0900 Subject: [PATCH 21/23] =?UTF-8?q?feat(855-F=20B9-1):=20=EB=AC=B8=EC=84=9C?= =?UTF-8?q?=20=EC=85=88=20=EA=B8=B0=EB=A1=9D=20=E2=80=94=20=EC=A4=84?= =?UTF-8?q?=EB=A7=88=EB=8B=A4=20=EB=B6=80=EB=A5=B8=20=EC=9E=90=EC=9B=90=20?= =?UTF-8?q?=ED=82=A4=20=C2=B7=20=ED=95=98=EC=9C=84=20=EB=AC=B8=EC=84=9C(?= =?UTF-8?q?=ED=82=A4=20+=20=EC=9E=85=EB=A0=A5)=20=C2=B7=20=EA=B3=A0?= =?UTF-8?q?=EB=A5=B8=20=ED=92=88=EB=AA=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 새 master_doc_trace.py(서버 단독 · TS 짝 없음) — Links 를 이어받아 마스터 get 을 감싸 연결마다 부른 것을 적음 · 셈 답에 「부름」 · 「자원」 · 줄마다 「부름」 차례 번호 · 기계경비 부름 「기계」 키 - master_doc_calc 훅 두 곳(link · 금액 줄) — links 에 at 이 없으면 안 탐 = 기록 안 켜면 지금 길 그대로 - 재료 찾기 = 고른 품목 하나만(첫 찾기 색인 짓기 때 훑는 후보 읽음은 캐시 따라 들쭉날쭉이라 뺌) - 새 시험 test_855_trace — 로직 1,521 기본 입력: 기록 켜도 셈 답 같음 · 자원 키 = 옛 whole.get 가로채기 키(새 쪽에만 더 있음 10 문서 = 새 계산기는 이름마다 셈 · 까닭 목록) · 하위 부름 = 옛 B09 line_calls(다름 7 = 옛 빈 입력 멈춤) · 고른 품목 = master_pick.priced 품목 - _수식문서_틀.md 파일 목록 한 줄 Co-Authored-By: Claude Opus 5.5 --- resources/master_data/_수식문서_틀.md | 1 + .../master_data/scripts/master_doc_calc.py | 4 + .../master_data/scripts/master_doc_trace.py | 175 ++++++++++++++++++ resources/tester/test_855_trace.py | 170 +++++++++++++++++ 4 files changed, 350 insertions(+) create mode 100644 resources/master_data/scripts/master_doc_trace.py create mode 100644 resources/tester/test_855_trace.py 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/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_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/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["갈래"] != "표" + } From c42d66ad68f77aba6ffe446f60def4fc72cb4c4d Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 17:59:31 +0900 Subject: [PATCH 22/23] =?UTF-8?q?feat(855-C):=202-C4=20=EA=B8=B0=EC=A4=80?= =?UTF-8?q?=20=EB=AA=A9=EB=A1=9D=20=C2=B7=20=EA=B3=84=EC=82=B0=EC=84=9C?= =?UTF-8?q?=EB=A5=BC=20=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20=EC=85=88?= =?UTF-8?q?=EC=9C=BC=EB=A1=9C=20=C2=B7=20=EC=84=9C=EB=B2=84=20=EC=82=B0?= =?UTF-8?q?=EC=B6=9C=EA=B7=BC=EA=B1=B0=20=EA=B8=80=20=EB=AA=A8=EB=93=88=20?= =?UTF-8?q?=EC=83=88=EB=A1=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 새 `master_doc_text.py` — 문서 셈 답 → 산출근거 글(금액 줄 · 묶음 줄 · 계 줄 · 계산서 묶음) · 화면 짝(line_stack_out · eqText · unitText · moneyUnits · offLine) 규칙을 옮김 · 거울 시험 `test_855_c4_doc_text`(+ helper .cjs) - `M02_Logic_Standard` — 기준 목록 축 = 문서 선택 변수 · 표 조건 입력 변수 · 바탕 = 문서 기본값 · 금액 = 문서 셈 · 계산서 = 문서 셈 + 새 글 · 파생 저장본 열쇠에 수식 문서 지문(SHAPE 4) · 답 꼴 그대로(화면 안 고침) · `M02_Logic_Settle` 은 B09 짝이라 남김 - 전수(1,521 기초 · 옛 줄 11,267): 같은 입력이면 금액 같음 11,165 · 다름 101 = 옛 목록만의 B09 산근 끝수(settle) — 새 값 = 옛 엔진 값 = M02 단가산출 값 · 옛 엔진 멈춤 1(새 0 원 줄은 목록에서 빠짐) - 바탕 = 문서 기본값(옛 = master_auto 자동값) — 114 기초의 바탕 줄 규격이 바뀜(시험입력 · 기본 칸을 담은 문서 기본값) - 시험 고침: test_704_logic_standard(옛 엔진 끝수 차 3 원 허용 → 수식 탭 셈과 같음) · test_704_settle(축 · 금액 인자가 문서) · test_714_1 의 「M01 /text 와 M02 계산서가 같은 줄 꼴」 시험 지움(M02 계산서가 옛 덧칸 길을 안 탐 — 까닭: 855-C 새 길) Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Logic_Standard.py | 164 +++++---- .../master_data/scripts/master_doc_text.py | 327 ++++++++++++++++++ resources/tester/helper_855_c4_doc_text.cjs | 71 ++++ resources/tester/test_704_logic_standard.py | 16 +- resources/tester/test_704_settle.py | 8 +- resources/tester/test_714_1_sheet_line.py | 18 +- resources/tester/test_855_c4_doc_text.py | 155 +++++++++ 7 files changed, 672 insertions(+), 87 deletions(-) create mode 100644 resources/master_data/scripts/master_doc_text.py create mode 100644 resources/tester/helper_855_c4_doc_text.cjs create mode 100644 resources/tester/test_855_c4_doc_text.py 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/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/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/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_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_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["규격"]) From 8a9c84b6bedbb62172937f6984fdea801845c03f Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 18:01:05 +0900 Subject: [PATCH 23/23] =?UTF-8?q?chore(ledger):=20=EC=84=A4=EA=B3=84=20858?= =?UTF-8?q?=20=E2=80=94=20=EA=B1=B8=EC=9D=8C=205=20=EC=84=9C=EA=B3=A0=20?= =?UTF-8?q?=ED=95=9C=20=EB=B2=8C(=EC=A7=80=EA=B8=88=20=EB=AA=A8=EC=8A=B5?= =?UTF-8?q?=20=C2=B7=20=ED=95=9C=20=EB=B2=8C=20=ED=8B=80=20=C2=B7=20?= =?UTF-8?q?=EA=B1=B8=EC=9D=8C=205-0=20~=205-8)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude --- docs/raw/요구_1104/설계_858_서고한벌.md | 221 ++++++++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 docs/raw/요구_1104/설계_858_서고한벌.md 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 길 묶음 |