From 024a0b07adc4b6c933ca63ce1538f4860782a71f Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 05:00:18 +0900 Subject: [PATCH 01/13] =?UTF-8?q?fix(856-G):=20=EB=8B=A8=EA=B0=80=EC=82=B0?= =?UTF-8?q?=EC=B6=9C=20=EB=A8=B8=EB=A6=AC=20=EC=B9=B8=20Tab=20=EC=B4=88?= =?UTF-8?q?=EC=A0=90=20=EC=9C=A0=EC=A7=80=20=E2=80=94=20=EC=9D=B4=EB=A6=84?= =?UTF-8?q?=20=C2=B7=20=EB=8B=A8=EC=9C=84=20=EA=B3=A0=EC=B9=A8=EC=9D=B4=20?= =?UTF-8?q?=EB=A8=B8=EB=A6=AC=EB=A5=BC=20=EB=8B=A4=EC=8B=9C=20=EA=B7=B8?= =?UTF-8?q?=EB=A6=AC=EC=A7=80=20=EC=95=8A=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 까닭: 머리 칸 change 마다 머리 전체를 다시 그려 Tab 으로 옮긴 다음 칸(단위)이 새 칸으로 바뀌며 초점 · 타자가 끊김(불러온 식 미리 보기도 같은 화면) - 고침: 칸 고침 = 문서 · 고침 알림만 · 단위 고침 · 환산 고침 = 환산 자리(display: contents)만 새로 그림 · 바탕 읽기 · 수식 저장 뒤 다시 그림은 그대로 - 일위대가 머리(이름 = input · 구분 = 같은 선택 칸 옵션만 바꿈)는 다시 그리지 않아 그대로 - 시험: test_856_0_sk_screen ⑥ 이름 · 단위 change 뒤 머리 칸 같은 칸 · 환산 다시 그린 수 · 문서(옛 코드 = 칸 바뀜 실패 확인) · 가짜 칸이 머리 나무에 달리게 · 사건 일으킴 더함 - 화면 8009: 새 단가산출(sub7임시) 이름 타자 → Tab → 단위 칸 초점 · 타자 m2 → Tab → 다음 단추 · [저장] · 다시 열기 같음 · 지움 · 콘솔 0 Co-Authored-By: Claude Opus 5.5 --- .../M02_MasterTemplete_Sangeun.css | 5 ++ .../M02_MasterTemplete_Sangeun_Detail.ts | 38 ++++++++----- resources/tester/helper_856_0_sk_screen.cjs | 55 ++++++++++++++++++- resources/tester/test_856_0_sk_screen.py | 11 ++++ 4 files changed, 91 insertions(+), 18 deletions(-) diff --git a/M02_MasterTemplete/M02_MasterTemplete_Sangeun.css b/M02_MasterTemplete/M02_MasterTemplete_Sangeun.css index 1e6c6c43d..3b91bf96d 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Sangeun.css +++ b/M02_MasterTemplete/M02_MasterTemplete_Sangeun.css @@ -29,6 +29,11 @@ min-width: 120px; } +/* 856-G 환산 자리 — 머리 줄 배치에 안 끼어듦 */ +.m02-sk__swap-slot { + display: contents; +} + .m02-sk__tags { display: flex; flex-wrap: wrap; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts b/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts index 357579531..33aad305f 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts @@ -161,6 +161,7 @@ export function mountSangeunDetail( }; function drawHead(): void { + // 856-G 칸 고침 = 머리를 다시 그리지 않음(Tab 으로 옮긴 다음 칸 초점 · 타자 유지) · 환산만 새로 const field = (label: string, key: "이름" | "단위"): HTMLElement => { const box = createInputField({ label, value: doc[key] ?? "", compact: true, size: 28 }); box.input.dataset.sk = key; @@ -168,29 +169,36 @@ export function mountSangeunDetail( box.input.addEventListener("change", () => { doc[key] = box.input.value.trim(); box.setError(doc[key] ? undefined : L("M02_SangeunNeed")); - touch(); + report(); + if (key === "단위") drawSwap(); }); return box.root; }; const baseName = base ? `${base.logic.키} ${base.logic.이름}` : null; const baseText = baseName ?? doc.바탕?.참조?.키 ?? L("M02_SangeunNoBase"); - const swap = base - ? buildUnitSwap({ - result: base.logic.결과단위, - unit: doc.단위 ?? "", - how: doc.환산 as SwapHow | undefined, - edit, - onChange: (how) => { - if (how) doc.환산 = how; - else delete doc.환산; - touch(); - }, - }) - : null; + const swapSlot = el("span", { className: "m02-sk__swap-slot" }); + const drawSwap = (): void => { + const swap = base + ? buildUnitSwap({ + result: base.logic.결과단위, + unit: doc.단위 ?? "", + how: doc.환산 as SwapHow | undefined, + edit, + onChange: (how) => { + if (how) doc.환산 = how; + else delete doc.환산; + report(); + drawSwap(); + }, + }) + : null; + swapSlot.replaceChildren(...(swap ? [swap] : [])); + }; + drawSwap(); head.replaceChildren( field(L("M02_Name"), "이름"), field(L("M02_SangeunUnit"), "단위"), - ...(swap ? [swap] : []), + swapSlot, el("div", { className: "m02-sk__tags", attrs: { "data-sk-base": baseKey() ?? "" }, diff --git a/resources/tester/helper_856_0_sk_screen.cjs b/resources/tester/helper_856_0_sk_screen.cjs index 85ff67f65..c162ca4b9 100644 --- a/resources/tester/helper_856_0_sk_screen.cjs +++ b/resources/tester/helper_856_0_sk_screen.cjs @@ -40,8 +40,14 @@ class Fake { get firstChild() { return this.children[0] ?? null; } - addEventListener() {} + addEventListener(t, f) { + ((this.on ??= {})[t] ??= []).push(f); + } removeEventListener() {} + /** 사건 일으킴(⑥ 머리 칸 change) */ + fire(t) { + for (const f of this.on?.[t] ?? []) f({ target: this }); + } setAttribute(k, v) { this.attrs[k] = v; if (k.startsWith("data-")) this.dataset[camel(k.slice(5))] = v; @@ -87,7 +93,9 @@ const button = (o = {}) => box("button", { "data-button": o.label ?? "" }); const input = (o = {}) => { const i = box("input"); i.value = o.value ?? ""; - return { root: box("label", { "data-input": o.label ?? "" }, ""), input: i, setError() {} }; + const root = box("label", { "data-input": o.label ?? "" }, ""); + root.append(i); // ⑥ 칸이 머리 나무에 달림 + return { root, input: i, setError() {} }; }; const modals = []; // 열린 모달 — 제목 · 몸 const ui = { @@ -193,7 +201,10 @@ const stubs = { tabOf: () => ({}), }, M01_MasterData_UI_LogicLab_Ho: { buildHo: () => [box("div", { "data-ho": "" })] }, - M02_MasterTemplete_Sangeun_Unit: { buildUnitSwap: () => null, baseUnitOf: () => "" }, + M02_MasterTemplete_Sangeun_Unit: { + buildUnitSwap: () => (swaps.n++, box("div", { "data-swap": "" })), // ⑥ 환산 다시 그린 수 + baseUnitOf: () => "", + }, M02_MasterTemplete_Labor_LogicMats: { logicMatRows: () => [] }, M02_Labor_Values_Model: { valueLine: () => ({ text: "", empty: 0 }), @@ -219,6 +230,7 @@ const stubs = { }, }; const picked = { rows: 0 }; +const swaps = { n: 0 }; const real = new Set([ "M02_MasterTemplete_Sangeun_Detail", "M02_MasterTemplete_Sangeun_Tabs", @@ -460,6 +472,43 @@ async function openSk(doc, opt = {}) { }; } globalThis.fetch = fetch0; + + // ⑥ 머리 칸 고침(856-G) — 이름 change 뒤 머리 칸 그대로(Tab 으로 옮긴 단위 칸 = 같은 칸 · 초점 유지) · + // 단위 change = 환산만 새로 · 문서 · 고침 알림 + { + const { mountSangeunDetail } = M("M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts"); + const host = box("div"); + let dirty = false; + const doc = { 키: "SK-000011", 이름: "견본", 단위: "㎡", 바탕: { 로직: "GC001109" } }; + const h = mountSangeunDetail(host, doc, { + layer: "system", + owner: null, + readOnly: false, + mode: "page", + onChanged: (d) => (dirty = d), + }); + await settle(); + const fields = () => all(host, (n) => n.dataset.sk === "이름" || n.dataset.sk === "단위"); + const before = fields(); + const [name, unit] = before; + const same = () => fields().length === 2 && fields().every((n, i) => n === before[i]); + let n0 = swaps.n; + name.value = " 고친 이름 "; + name.fire("change"); + const afterName = { same: same(), swaps: swaps.n - n0, dirty }; + n0 = swaps.n; + unit.value = "m2"; + unit.fire("change"); + const afterUnit = { same: same(), swaps: swaps.n - n0, shown: all(host, (n) => "swap" in n.dataset).length }; // prettier-ignore + const got = h.getDoc(); + out.head = { + order: before.map((n) => n.dataset.sk), + afterName, + afterUnit, + doc: [got.이름, got.단위], + }; + h.destroy(); + } console.log(JSON.stringify(out)); })().catch((e) => { console.error(e.stack || String(e)); diff --git a/resources/tester/test_856_0_sk_screen.py b/resources/tester/test_856_0_sk_screen.py index 1287c9e5d..87d235b05 100644 --- a/resources/tester/test_856_0_sk_screen.py +++ b/resources/tester/test_856_0_sk_screen.py @@ -6,6 +6,7 @@ ③ 머리 띠(까닭 · M01 개정 · 빠진 줄)가 뜨는 경우 — 줄 쌓기 셈 답 · 사본 표지 견본(856-2 · 짝 잃음 = 덮개 없음) ④ M01 로직 상세 그릇 = 기본정보 접힘 + 줄 쌓기 ⑤ 줄 쌓기 [+ 줄] 찾아 넣기 — 빈 낱말로 열어도 종류마다 서버 찾기 · 목록이 그려짐(856-F) +⑥ 머리 칸 고침 — 이름 · 단위 change 뒤 머리 칸 그대로(Tab 으로 옮긴 다음 칸 초점 유지 · 856-G) · 환산만 새로 """ from __future__ import annotations @@ -100,3 +101,13 @@ def test_stack_find_lists_each_kind() -> None: got = find[f"{side}_{kind}"] assert got["paths"] == paths, (side, kind, got) assert got["rows"] >= 1, (side, kind, got) + + +def test_head_edit_keeps_fields() -> None: + got = _run()["head"] + assert got["order"] == ["이름", "단위"] + # 이름 고침 → 머리를 다시 그리지 않음 = Tab 으로 간 단위 칸이 같은 칸(초점 · 타자 유지) · 고침 알림 + assert got["afterName"] == {"same": True, "swaps": 0, "dirty": True} + # 단위 고침 → 칸 그대로 · 환산 자리만 새로 그림 + assert got["afterUnit"] == {"same": True, "swaps": 1, "shown": 1} + assert got["doc"] == ["고친 이름", "m2"] From 4ff4f369c35f1509bd41b68808065d86072db839 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 05:00:40 +0900 Subject: [PATCH 02/13] =?UTF-8?q?refactor(855-2-E2):=20SK=20=EC=98=9B=20?= =?UTF-8?q?=EC=8B=9D=20=EC=B9=B8=20=EA=B1=B7=EC=9D=8C=20=E2=80=94=20?= =?UTF-8?q?=EB=B3=80=EC=88=98=EC=A4=84=20=C2=B7=20=EC=8B=9D=EB=8D=AE?= =?UTF-8?q?=EA=B0=9C=20=C2=B7=20=EC=88=98=EB=9F=89=EC=8B=9D=20=C2=B7=20?= =?UTF-8?q?=EC=83=81=EC=88=98=20=C2=B7=20=ED=91=9C=EA=B0=92=20=EB=8D=AE?= =?UTF-8?q?=EA=B0=9C(=EC=85=88=20=EC=9D=80=ED=87=B4=20=EB=92=A4=20?= =?UTF-8?q?=EB=B0=9B=EC=A7=80=20=EC=95=8A=EC=9D=8C)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 2-C1 뒤 셈 = 수식 사본 문서 한 길 · 이 칸을 쓰는 화면 0(856-1 상세 몸 걷음) · 저장본 0(storage 전수 · git 자료 0) - Sangeun_Formula: 식 칸 검사 · 얹기(clean · has · settle · _build · _check · _uses · _zero · _path · _reserved …) 걷음 — 남김 = 이름 꼴 ↔ 엔진 식 번역 · 상한(M01 수식 탭 · 가져온 식이 부름) - Sangeun_Const: 상수 · 표값 덮개(scan · swap · _parser · places · formulas · formulas_lost · _covers) 걷음 · clean_more = 옛 식 칸 오면 400(말없이 버리지 않음) · restore = 덮개 · 뺀줄 · 까닭만(자리 하나 [M01 원래로] 걷음) · no_flat = 수식 고침만 · covers_n = 덮개 · 뺀줄 - Sangeun_Doc: patched 첫머리 식 칸 얹기 · 더한줄 수량식 걷음 - M02 옛 엔진 속살 부름(census) 69 → 63(Const._parser · Formula._check · _uses · _zero) - 시험: 790_2 = scan · 상수 덮개 단언 걷고 글줄 · 까닭 꼴만 · 792_1 = 번역 왕복 · 상한 · 옛 식 칸 400 · 초기화 · 빈 칸 지문 · 793_2 = 가져온 식 상수 · 식덮개 · 변수줄 세 단언만 걷음(덮개 · 뺀줄 · 더한줄 그대로) Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Library_Flat.py | 2 +- M02_MasterTemplete/M02_Sangeun_Const.py | 222 +++------------ M02_MasterTemplete/M02_Sangeun_Doc.py | 7 +- M02_MasterTemplete/M02_Sangeun_Formula.py | 263 +----------------- resources/tester/test_790_2_sangeun_const.py | 56 +--- .../tester/test_792_1_sangeun_formula.py | 113 +++----- .../tester/test_793_2_sangeun_imported.py | 9 +- 7 files changed, 82 insertions(+), 590 deletions(-) diff --git a/M02_MasterTemplete/M02_Library_Flat.py b/M02_MasterTemplete/M02_Library_Flat.py index 3fc98d56c..bc09a4c09 100644 --- a/M02_MasterTemplete/M02_Library_Flat.py +++ b/M02_MasterTemplete/M02_Library_Flat.py @@ -569,7 +569,7 @@ def reset(kind: str, doc: dict) -> tuple[dict, int]: return imported.reset(doc) if kind == "sangeun": adds, n = _reset_adds(doc.get("더한줄") or []) - n += const.covers_n(doc) # 790-2 상수 · 표값 덮개도 걷음(까닭 같이) + n += const.covers_n(doc) # 덮개 · 뺀줄(까닭 같이) items = formula_edits(doc) out = {**const.restore(doc), "더한줄": adds} if items: diff --git a/M02_MasterTemplete/M02_Sangeun_Const.py b/M02_MasterTemplete/M02_Sangeun_Const.py index 5c90e5ea3..a538f06e7 100644 --- a/M02_MasterTemplete/M02_Sangeun_Const.py +++ b/M02_MasterTemplete/M02_Sangeun_Const.py @@ -1,158 +1,49 @@ -"""M02 단가산출(SK) 숫자 넓힘(PLAN 790-2 · 요구서_652 · _분석_650-H3 E2) — 새 덮개 갈래. +"""M02 단가산출(SK) 글 칸 · 옛 칸 막음 · [초기화] 걷기 · 셈 답(PLAN 790-2 · 855 2-E2). -시험 `resources/tester/test_790_2_sangeun_const.py` · 799-2 — 화면 짝(`Const_Model.ts` · 시트 탭)은 걷음, 서버만 남음. - -문서 덧칸(없으면 안 둠 — 옛 SK 그대로 · 지문 그대로): - 상수덮개 {자리: {n: 값}} 자리 식의 n 번째 숫자 상수(0 부터 · 엔진 파서 차례 · 찾기 머리 · 키 · - 따옴표 글 안 셈) → 값 · 식 구조 그대로(옵션 바꾸면 나머지 따라감) - 표값덮개 {자리: {n: 값}} 자리 식의 n 번째 표 찾기 값(`찾기(…).칸`) → 값 · 그 줄만 표 연결 끊김 - 글줄 [{자리, 글}] 셈 없는 글 줄(근거 · ※ 조건) · 자리 뒤에 찍힘("" = 맨 위) - 까닭 {열쇠: 글} 덮개 · 더한줄 · 뺀줄 · 새 덮개마다(예정가격작성기준 제2조 ②) - M01판 {자리: 지문} (옛 칸 — 읽던 시트를 2-C1 에서 걷어 855 2-D 부터 안 적음 · 옛 파일 칸은 `sd.clean` 이 버림) -자리 = 바탕 줄 cid(호표 · 덧줄 `kind:키#n`) · 중간 줄 `mid:이름` · 열쇠 = 자리 · `add:#k` · -`add:#k/세부 cid` · 식 칸 = 중간 「식」 · 호표 「수량」 · 덧줄 「식」. -셈 = `M02_Sangeun_Doc.patched` 첫머리 `formulas`(바탕 줄 식을 바꾼 사본) → 모든 셈 길(화면 · 저장 -원값 · B09 · 펼침 겹침) 한 벌 · 펼침(`M02_Library_Flat._read`) = 새 덮개 SK 는 안 펼침 -(옛 참조 그대로) · [초기화](`M02_Library_Flat.reset`) = `restore` 전체. +문서 덧칸(없으면 안 둠): + 글줄 [{자리, 글}] 셈 없는 글 줄(근거 · ※ 조건) · 자리 뒤에 찍힘("" = 맨 위) + 까닭 {열쇠: 글} 덮개 · 더한줄 · 뺀줄마다(예정가격작성기준 제2조 ②) +자리 = 바탕 줄 cid(호표 · 덧줄 `kind:키#n`) · 중간 줄 `mid:이름` · 열쇠 = 자리 · `add:#k` · `add:#k/세부 cid`. +옛 식 칸(상수덮개 · 표값덮개 790-2 · 변수줄 · 식덮개 · 더한줄 수량식 792-1)은 셈 은퇴(855 2-C1) 뒤 받지 않음 +(`clean_more` = 400 · 저장본 0 · 855 2-E2) · 셈 = 수식 사본 문서 한 길. +펼침(`M02_Library_Flat._read`) = 수식 고침 · 가져온 식 SK 는 안 펼침(옛 참조 그대로) · +[초기화](`M02_Library_Flat.reset`) = `restore`(덮개 · 뺀줄 · 까닭). 셈 답(`answer`) = 문서 셈 답 1 단위 몫(옛 `원래` · `시트` 덧칸 855 2-C1 · 머리 띠 855 2-E2 에서 걷음). """ from __future__ import annotations -import functools import re from typing import Any from M02_MasterTemplete import M02_Sangeun_Doc as sd from M02_MasterTemplete import M02_Sangeun_Equation as eqm -from M02_MasterTemplete import M02_Sangeun_Formula as fx from M02_MasterTemplete import M02_Sangeun_Imported as imp -NEW = ("상수덮개", "표값덮개", "글줄", "까닭") -_SPOT = re.compile(r"^(mid:.+|(labor|material|machine|logic|pct):.*#\d+)$") +NEW = ("글줄", "까닭") +OLD = ("상수덮개", "표값덮개", "변수줄", "식덮개") # 옛 식 칸 — 셈 은퇴 · 받지 않음(855 2-E2) _KEY = re.compile(r"^(mid:.+|(add:#\d+/)?(labor|material|machine|logic|pct):.*#\d+|add:#\d+)$") _ADD = re.compile(r"^add:#(\d+)(/.*)?$") -FIELD = {"중간": "식", "호표": "수량", "덧줄": "식"} LONG = 500 # 글 · 까닭 길이 상한 MANY = 200 # 글줄 수 상한 -# ── 식 속 자리 ──────────────────────────────────────────────────────── -@functools.cache -def _parser() -> type: - """엔진 파서(`master_formula._Parser`) + 숫자 · 표 찾기 글자 자리 기록(엔진과 같은 차례).""" - from M02_MasterTemplete import M02_Labor_Doc as labor - - class Spots(labor.m01.cm.mf._Parser): - def __init__(self, text: str) -> None: - super().__init__(text) - self.spots: list[tuple[str, int, int]] = [] - - def primary(self): # noqa: ANN202 - self.ws() - at = self.i - node = super().primary() - if node[0] == "num" and self.s[at : at + 1] != "(": # 「(11)」 = 안쪽 수만 - self.spots.append(("num", at, self.i)) - return node - - def unary(self): # noqa: ANN202 - self.ws() - at = self.i - node = super().unary() - inner = node - while inner[0] == "field": - inner = inner[1] - if node[0] == "field" and inner[0] == "find": - self.spots.append(("find", at, self.i)) - return node - - return Spots - - -@functools.lru_cache(maxsize=4096) -def scan(text: str) -> dict[str, list[tuple[int, int]]]: - """식 글 → {num: [(처음,끝)], find: [(처음, 끝)]}(왼쪽부터) · 못 읽는 식 = 빈 목록.""" - p = _parser()(text) - try: - p.parse() - except Exception: # noqa: BLE001 — 엔진 FormulaError · 깊은 괄호 - return {"num": [], "find": []} - spots = [(t, a, a + len(text[a:b].rstrip())) for t, a, b in p.spots] # 뒤 빈칸(`.` 엿봄) 뗌 - return {k: sorted((a, b) for t, a, b in spots if t == k) for k in ("num", "find")} - - -def _lit(value: Any) -> str: - got = sd.text(value) - return f"({got})" if got.startswith("-") else got - - -def swap(text: str, nums: dict, finds: dict) -> str: - """식 글의 n 번째 숫자 · 표 찾기를 값으로(원래 식 차례 · 바꾼 표 찾기 안 숫자는 버림).""" - spots = scan(text) - cuts = [(*spots["find"][int(n)], v) for n, v in finds.items() if int(n) < len(spots["find"])] - for n, v in nums.items(): - if int(n) < len(spots["num"]): - a, b = spots["num"][int(n)] - if not any(x <= a and b <= y for x, y, _ in cuts): - cuts.append((a, b, v)) - for a, b, v in sorted(cuts, reverse=True): - text = text[:a] + _lit(v) + text[b:] - return text - - -def places(row: dict) -> dict[str, tuple[str, int]]: - """자리 → (갈래, 차례) — 중간 `mid:이름` · 호표 · 덧줄 cid.""" - out = {f"mid:{s.get('이름')}": ("중간", at) for at, s in enumerate(row.get("중간") or [])} - n = len(row.get("호표") or []) - for at, cid in enumerate(sd.line_ids(row)): - out[cid] = ("호표", at) if at < n else ("덧줄", at - n) - return out - - -def formulas(row: dict, doc: dict) -> dict: - """바탕 줄 + 식 칸(792-1) · 상수 · 표값 덮개 → 식 바꾼 사본(덮개 없음 = 그 줄 그대로 · 순수).""" - return formulas_lost(row, doc)[0] - - -def formulas_lost(row: dict, doc: dict) -> tuple[dict, list[dict], dict]: - """(식 바꾼 사본, 틀린 식 자리 짝잃음, 수량식 엔진 꼴 문서) — `sd.patched` 첫머리.""" - row, bad, doc = fx.settle(row, doc) - return _swapped(row, doc), bad, doc - - -def _swapped(row: dict, doc: dict) -> dict: - nums, finds = doc.get("상수덮개") or {}, doc.get("표값덮개") or {} - if not nums and not finds: - return row - out = {**row, **{k: list(row.get(k) or []) for k in FIELD}} - for spot, (part, at) in places(row).items(): - if spot in nums or spot in finds: - line = out[part][at] = dict(out[part][at]) - field = FIELD[part] - line[field] = swap(str(line.get(field)), nums.get(spot) or {}, finds.get(spot) or {}) - return out - - +# ── 펼침 · 초기화 ───────────────────────────────────────────────────── def no_flat(doc: Any) -> None: - """펼침 막음 — 상수 · 표값 덮개 SK(펼친 줄에 못 옮김 · 옛 참조 그대로 = 값 그대로).""" - keys = ("상수덮개", "표값덮개", eqm.KEY) # 수식 고침(796-2b) - if isinstance(doc, dict) and (any(doc.get(k) for k in keys) or fx.has(doc)): - raise sd.DocError( - "상수 · 표값 덮개 · 식 칸 · 수식 고침 단가산출은 펼치지 않음(참조 그대로)" - ) + """펼침 막음 — 수식 고침 SK(펼친 줄에 못 옮김 · 옛 참조 그대로 = 값 그대로).""" + if isinstance(doc, dict) and doc.get(eqm.KEY): # 수식 고침(796-2b) + raise sd.DocError("수식 고침 단가산출은 펼치지 않음(참조 그대로)") if imp.is_imported(doc): # 가져온 식(793-2) = M01 기초 없음 raise sd.DocError("가져온 식 단가산출은 펼치지 않음(참조 그대로)") def covers_n(doc: dict) -> int: - """[초기화] 걷힐 고침 수 — 덮개 · 뺀줄 · 상수 · 표값 덮개 칸.""" - keys = ("덮개", "뺀줄", "상수덮개", "표값덮개", "식덮개") - return sum(len(doc.get(k) or ()) for k in keys) + """[초기화] 걷힐 고침 수 — 덮개 · 뺀줄 칸.""" + return sum(len(doc.get(k) or ()) for k in ("덮개", "뺀줄")) # ── 문서 꼴 ────────────────────────────────────────────────────────── -def _key(raw: Any, where: str, pat: re.Pattern = _SPOT) -> str: +def _key(raw: Any, where: str, pat: re.Pattern = _KEY) -> str: if not isinstance(raw, str) or not pat.match(raw): raise sd.DocError(f"{where} · 자리 꼴 아님 「{raw}」") return raw @@ -165,32 +56,14 @@ def _words(raw: Any, where: str) -> str: return got -def _covers(raw: Any, name: str) -> dict: - if raw in (None, {}): - return {} - if not isinstance(raw, dict): - raise sd.DocError(f"{name} · 묶음 아님") - out = {} - for spot, one in raw.items(): - where = f"{name} 「{spot}」" - if not isinstance(one, dict): - raise sd.DocError(f"{where} · {{n: 값}} 아님") - got = {} - for n, v in one.items(): - if not re.fullmatch(r"\d{1,3}", str(n)): - raise sd.DocError(f"{where} · n 은 0 부터 수 「{n}」") - got[str(int(n))] = sd.plain(sd._num(v, f"{where} {n}")) - if got: - out[_key(spot, name)] = got - return out - - def clean_more(raw: Any, out: dict) -> dict: - """`sd.clean` 끝 — 새 덮개 칸 검사 · 빈 칸은 안 둠(`M01판` · 원값은 서버 몫이라 버림).""" + """`sd.clean` 끝 — 글 칸 검사 · 빈 칸은 안 둠(`M01판` · 원값은 서버 몫이라 버림) · 옛 식 칸 = 400.""" raw = raw if isinstance(raw, dict) else {} - for name in ("상수덮개", "표값덮개"): - if got := _covers(raw.get(name), name): - out[name] = got + old = [k for k in OLD if raw.get(k) not in (None, {}, [], "")] + adds = [x for x in raw.get("더한줄") or [] if isinstance(x, dict)] + old += ["더한줄 수량식"] if any(x.get("수량식") not in (None, "") for x in adds) else [] + if old: + raise sd.DocError(f"옛 식 칸 {old} — 셈 은퇴 · 받지 않음(수식 문서로 고칠 것)") texts = raw.get("글줄") or [] if not isinstance(texts, list) or len(texts) > MANY: raise sd.DocError(f"글줄 · {MANY} 줄까지 목록") @@ -200,13 +73,13 @@ def clean_more(raw: Any, out: dict) -> dict: spot = str(one.get("자리") or "") words = _words(one.get("글"), f"글줄 {at}째") if words: - lines.append({"자리": spot and _key(spot, f"글줄 {at}째", _KEY), "글": words}) + lines.append({"자리": spot and _key(spot, f"글줄 {at}째"), "글": words}) if lines: out["글줄"] = lines why = raw.get("까닭") or {} if not isinstance(why, dict): raise sd.DocError("까닭 · 묶음 아님") - why = {_key(k, "까닭", _KEY): _words(v, f"까닭 「{k}」") for k, v in why.items()} + why = {_key(k, "까닭"): _words(v, f"까닭 「{k}」") for k, v in why.items()} if why := {k: v for k, v in why.items() if v}: out["까닭"] = why if isinstance(raw.get("사본"), dict): # 로직 사본(795-1) — 셈 · 저장 첫머리 settle 이 정함 @@ -214,17 +87,14 @@ def clean_more(raw: Any, out: dict) -> dict: if isinstance(raw.get("수식"), dict): # 수식 사본(802-4a) — 저장 끝 `M02_Doc_Sk.settle` 이 정함 out["수식"] = raw["수식"] out = eqm.clean(raw, out) # 수식 고침(796-2b) - return imp.clean(raw, fx.clean(raw, out)) # 식 칸(792-1) · 가져온 식(793-2) + return imp.clean(raw, out) # 가져온 식(793-2) def stamp(row: dict, doc: dict | None = None) -> dict[str, Any]: - """저장 때 서버 칸 — 바탕판(바탕 줄 지문 · 화면 「기초가 바뀜」) · `doc` = 식 칸(792-1)을 - 엔진 식으로 바꿔 넣음(제자리 · 틀린 식 = `DocError`) · 옛 `M01판`(자리마다 지문 — 읽던 시트 걷음)은 안 적음(855 2-D).""" + """저장 때 서버 칸 — 바탕판(바탕 줄 지문 · 화면 「기초가 바뀜」) · 가져온 식 검산 · + 옛 `M01판`(자리마다 지문 — 읽던 시트 걷음)은 안 적음(855 2-D).""" from M02_MasterTemplete import M02_Sangeun_Calc as calc - if doc is not None and fx.has(doc): - fixed = fx.settle(row, doc, strict=True)[2] - doc.update({k: fixed[k] for k in ("더한줄", *fx.FIELDS) if k in fixed}) if doc is not None and imp.is_imported(doc): # 가져온 식 검산(793-2) = 서버가 다시 doc[imp.KEY]["검산"] = imp.check(doc) @@ -232,34 +102,12 @@ def stamp(row: dict, doc: dict | None = None) -> dict[str, Any]: # ── 고치기 ────────────────────────────────────── -def restore(doc: dict, key: str | None = None) -> dict: - """[M01 원래로] — 전체(None) = 덮개 · 뺀줄 · 상수 · 표값 · 식 덮개 · 그 까닭 지움(더한줄 · - 글줄 · 변수줄 · 옵션 남김) · 열쇠 하나 = 그 자리 덮개 · 뺀줄 · 새 덮개 · 까닭(세부 - `add:#k/cid` = 그 더한줄 세부).""" - out = {k: v for k, v in doc.items() if k not in ("상수덮개", "표값덮개", "식덮개", "까닭")} - why = dict(doc.get("까닭") or {}) - if key is None: - out |= {"덮개": {}, "뺀줄": []} - why = {k: v for k, v in why.items() if _top_add(k)} - return out | ({"까닭": why} if why else {}) - hit = _ADD.match(key) - if hit and hit[2]: - k, sub = int(hit[1]), hit[2][1:] - adds = [dict(x) for x in doc.get("더한줄") or []] - if k < len(adds): - one = {n: v for n, v in adds[k].items() if n not in ("덮개", "뺀줄")} - covers = {c: v for c, v in (adds[k].get("덮개") or {}).items() if c != sub} - drop = [c for c in adds[k].get("뺀줄") or [] if c != sub] - adds[k] = one | ({"덮개": covers} if covers else {}) | ({"뺀줄": drop} if drop else {}) - out["더한줄"] = adds - else: - out["덮개"] = {c: v for c, v in (doc.get("덮개") or {}).items() if c != key} - out["뺀줄"] = [c for c in doc.get("뺀줄") or [] if c != key] - for name in ("상수덮개", "표값덮개", "식덮개"): - if got := {s: v for s, v in (doc.get(name) or {}).items() if s != key}: - out[name] = got - why.pop(key, None) - return out | ({"까닭": why} if why else {}) +def restore(doc: dict) -> dict: + """[초기화] — 덮개 · 뺀줄 · 그 까닭 지움(더한줄 몫 까닭 · 더한줄 · 글줄 · 옵션 남김) · + 옛 자리 하나 [M01 원래로](상세 몸 856-1)는 걷음(855 2-E2).""" + out = {k: v for k, v in doc.items() if k != "까닭"} + why = {k: v for k, v in (doc.get("까닭") or {}).items() if _top_add(k)} + return out | {"덮개": {}, "뺀줄": []} | ({"까닭": why} if why else {}) def _top_add(key: str) -> bool: diff --git a/M02_MasterTemplete/M02_Sangeun_Doc.py b/M02_MasterTemplete/M02_Sangeun_Doc.py index 3ed709ca5..96f620a6b 100644 --- a/M02_MasterTemplete/M02_Sangeun_Doc.py +++ b/M02_MasterTemplete/M02_Sangeun_Doc.py @@ -352,7 +352,7 @@ def clean(doc: Any, base_row: dict | None = None, whole: Any = None) -> dict[str if len(set(drop)) != len(drop): raise DocError("뺀줄에 같은 줄 두 번") out |= {"뺀더한줄": gone} if (gone := _gone_adds(doc.get("뺀더한줄"), whole)) else {} - return const.clean_more(doc, out) # 새 덮개 칸(790-2) + return const.clean_more(doc, out) # 글 칸(790-2) · 옛 식 칸 막음(855 2-E2) def is_rate(one: Any) -> bool: @@ -440,7 +440,7 @@ def _covered(item: dict, cover: dict, extra: bool) -> tuple[dict, str | None]: def _add_item(one: dict) -> dict: """더한줄 → 엔진 호표 줄 — 참조 · 고정 줄 `값묶음` 은 셈(`M02_Sangeun_Calc`)이 채움.""" head = {"이름": one.get("이름") or "", "단위": one.get("단위") or ""} - qty = one.get("수량식") or text(one["수량"]) # 수량식(792-1) = 엔진 식(`fx.settle` 이 바꿈) + qty = text(one["수량"]) if "참조" in one or "고정" in one: kept = {k: one[k] for k in ("참조", "고정") if k in one} if is_rate(one): # 율 줄(778-4) = 그 비목 한 칸(엔진 묶음 · 보기 상자 = 비목) @@ -464,12 +464,11 @@ def patched( `picks` · `shown` = 바탕 쪽 차례 열쇠 고름 · 자재표시(바탕 SK 사슬) → 새 차례로 옮김. 돌려줌 = {줄, 고름 {차례: MT}, 자재표시 {차례: 칸}, 정체 [새 줄 cid · 더한줄 = `add:#k`], 짝잃음 [{cid, 까닭}]}.""" - row, bad, doc = const.formulas_lost(row, doc) # 식 칸(792-1) · 상수 · 표값 덮개(790-2) items, extras = list(row.get("호표") or []), list(row.get("덧줄") or []) ids = line_ids(row) covers, drop = doc.get("덮개") or {}, set(doc.get("뺀줄") or []) mine, marks = doc.get("고름") or {}, doc.get("자재표시") or {} - lost = bad + [ + lost = [ {"cid": c, "까닭": "뺀줄 — 바탕에 없는 줄"} for c in doc.get("뺀줄") or [] if c not in ids ] new_items, new_extras, cids, out_picks, out_marks = [], [], [], {}, {} diff --git a/M02_MasterTemplete/M02_Sangeun_Formula.py b/M02_MasterTemplete/M02_Sangeun_Formula.py index 9d74ef16b..d8856562c 100644 --- a/M02_MasterTemplete/M02_Sangeun_Formula.py +++ b/M02_MasterTemplete/M02_Sangeun_Formula.py @@ -1,22 +1,11 @@ -"""M02 단가산출(SK) 사용자 식 칸(PLAN 792-1 · 요구서_652 1 장 3 · _분석_650-H3 E4) — 변수 줄 · -식 덮개 · 더한줄 수량식 · 이름 꼴 ↔ 엔진 식 · 검사(「덮개 = 숫자만」 원칙을 바꿈). +"""M02 단가산출 식 글 번역(PLAN 792-1 · 855 2-E2) — 이름 꼴 ↔ 엔진 식 · 식 글 상한. -시험 `resources/tester/test_792_1_sangeun_formula.py` · 799-2 — 화면 짝(`Formula_Model.ts` · 시트 탭)은 걷음, 서버만 남음. - -문서 덧칸(없으면 안 둠 — 옛 SK 그대로 · 저장 = 엔진 식 · 이름 꼴 글도 받아 서버가 번역): - 변수줄 [{이름, 식, 표시?, 자리}] 엔진 중간 줄로 끼움 · 자리 = 그 뒤 중간 `mid:이름` - ("" = 맨 위 · 없는 자리 = 중간 끝 + 짝잃음) · 표시 = 엔진 `표시`(0~6 반올림) - 식덮개 {자리: 식} 중간 `mid:이름` 식 · 호표 cid 수량 · 덧줄 cid 식 - (원래 식 = 바탕 · M01 바뀜 = 790-2 M01판) - 더한줄[k].수량식 인력 · 재료 · 기계 · 참조 · 고정(율 줄 빼고) · `수량` = 보기 값 +M01 수식 탭(`M01_MasterData_Equation`) · 가져온 식(`M02_Sangeun_Imported`)이 부름. 이름 꼴 — `×` `÷`(= `*` `/`) · `[노임 형틀목공]`(요소 · 겹치면 키 덧붙임) · `[별칭]`(바탕 줄 `찾기` · `로직` 부르기 = `master_copy.aliases` · 별칭표는 바탕 줄에서만 지음 = 사용자 고침에 안 흔들림) · 맨 이름 = 입력 · 중간 · 변수 · 덧줄 · 비목 · 엔진 날식도 그대로 받음. -셈 = `settle`(바탕 줄 + 식 칸 → 엔진 줄 · `M02_Sangeun_Const.formulas` 첫머리 → `patched` → -`_Over` 로 같은 엔진 한 벌 · B09 굳힘 `GX9#####` 도 그 줄) · 틀린 식 = 그 자리만 M01 식으로 + -짝잃음(셈 길) · 저장(`strict`) = 400. -보안 — eval 없음(엔진 파서만) · 식 길이 `LONG` · 괄호 깊이 `DEEP` · 변수 줄 `MANY` · -로직 부르기 깊이 20(엔진). +옛 SK 식 칸(변수줄 · 식덮개 · 더한줄 수량식)은 셈 은퇴(855 2-C1) 뒤 받지 않음(`M02_Sangeun_Const.clean_more` · 855 2-E2). +보안 — eval 없음(엔진 파서만) · 식 길이 `LONG` · 괄호 깊이 `DEEP`. """ from __future__ import annotations @@ -26,13 +15,8 @@ import json import re from typing import Any -from M02_MasterTemplete import M02_Sangeun_Doc as sd - -FIELDS = ("변수줄", "식덮개") LONG = 300 # 식 글 길이 DEEP = 12 # 괄호 깊이 -MANY = 100 # 변수 줄 수 -FIELD = {"중간": "식", "호표": "수량", "덧줄": "식"} WORD = { "LB": "노임", "EQ": "기계", @@ -42,9 +26,6 @@ WORD = { "FX": "환율", "RT": "요율", } -_VAR = re.compile(r"^[A-Za-z가-힣_][\w가-힣]{0,19}$") -_ADD = re.compile(r"^add:#(\d+)$") -_SPOT = re.compile(r"^(mid:.+|(labor|material|machine|logic|pct):.*#\d+)$") def _eng() -> Any: @@ -59,7 +40,7 @@ def _whole() -> Any: return m01.loaded()[1] -# ── 꼴 검사(문서 · `sd.clean` 끝) ───────────────────────────────────── +# ── 식 글 상한 ──────────────────────────────────────────────────────── def limits(text: str) -> list[str]: """식 글 상한 — 길이 · 괄호 깊이(파서 앞 · 깊은 괄호 = 서버 500 막음).""" out, depth, top, quoted = [], 0, 0, False @@ -78,75 +59,6 @@ def limits(text: str) -> list[str]: return out -def _text(raw: Any, where: str) -> str: - got = str(raw if raw is not None else "").strip() - if not got: - raise sd.DocError(f"{where} · 식이 빔") - if bad := limits(got): - raise sd.DocError(f"{where} · {bad[0]}") - return got - - -def clean(raw: dict, out: dict) -> dict: - """`sd.clean` 끝(790-2 `clean_more` 뒤) — 변수줄 · 식덮개 · 더한줄 수량식 꼴 · 상한 · 겹침.""" - lines = raw.get("변수줄") or [] - if not isinstance(lines, list) or len(lines) > MANY: - raise sd.DocError(f"변수줄 · {MANY} 줄까지 목록") - got, seen = [], set() - for at, one in enumerate(lines, 1): - one = one if isinstance(one, dict) else {} - name, where = str(one.get("이름") or "").strip(), f"변수줄 {at}째" - if not _VAR.match(name) or _eng().mk.KEY.fullmatch(name): - raise sd.DocError(f"{where} · 이름 꼴 아님 「{name}」(글자로 시작 · 20 자까지)") - if name in seen: - raise sd.DocError(f"{where} · 같은 이름 「{name}」") - seen.add(name) - line = {"이름": name, "식": _text(one.get("식"), f"{where} 「{name}」")} - if one.get("표시") not in (None, ""): - show = sd._num(one["표시"], f"{where} 표시") - if show != int(show) or not 0 <= show <= 6: - raise sd.DocError(f"{where} · 표시는 0~6 자리") - line["표시"] = int(show) - spot = str(one.get("자리") or "") - if spot and not spot.startswith("mid:"): - raise sd.DocError(f'{where} · 자리는 중간 `mid:이름` · 맨 위 ""') - got.append(line | {"자리": spot}) - if got: - out["변수줄"] = got - covers = raw.get("식덮개") or {} - if not isinstance(covers, dict): - raise sd.DocError("식덮개 · 묶음 아님") - fx = {} - for spot, text in covers.items(): - if not isinstance(spot, str) or not _SPOT.match(spot): - raise sd.DocError(f"식덮개 · 자리 꼴 아님 「{spot}」") - if spot in (out.get("상수덮개") or {}) or spot in (out.get("표값덮개") or {}): - raise sd.DocError(f"식덮개 「{spot}」 · 상수 · 표값 덮개와 같이 못 둠") - if "qty" in ((out.get("덮개") or {}).get(spot) or {}): - raise sd.DocError(f"식덮개 「{spot}」 · 품 덮개(qty)와 같이 못 둠 — 식에 넣을 것") - fx[spot] = _text(text, f"식덮개 「{spot}」") - if fx: - out["식덮개"] = fx - adds = raw.get("더한줄") or [] - for k, one in enumerate(out.get("더한줄") or []): - text = adds[k].get("수량식") if k < len(adds) and isinstance(adds[k], dict) else None - if text in (None, ""): - continue - where = f"더한줄 {k + 1}째 수량식" - if sd.is_rate(one) or one.get("종류") == "로직": - raise sd.DocError(f"{where} · 율 줄 · 로직 줄은 수만") - one["수량식"] = _text(text, where) - return out - - -def has(doc: Any) -> bool: - """식 칸을 쓰는 문서.""" - if not isinstance(doc, dict): - return False - adds = [x for x in doc.get("더한줄") or [] if isinstance(x, dict)] - return any(doc.get(k) for k in FIELDS) or any(x.get("수량식") for x in adds) - - # ── 이름 꼴 ↔ 엔진 식 ──────────────────────────────────────────────── @functools.lru_cache(maxsize=2) def _labels(whole: Any) -> tuple[dict, dict]: @@ -291,168 +203,3 @@ def _unmask(text: str, raw_of: dict) -> str: def _names(row: dict) -> set[str]: return {str(x.get("이름")) for k in ("입력", "중간", "덧줄") for x in row.get(k) or []} - - -# ── 바탕 줄 + 식 칸 → 엔진 줄 ────────────────────────────────────────── -def _places(row: dict) -> dict[str, tuple[str, int]]: - from M02_MasterTemplete import M02_Sangeun_Const as const - - return const.places(row) - - -def _bad(spot: str, why: str) -> dict: - return {"cid": spot, "까닭": f"식 — {why}"} - - -def settle(row: dict, doc: dict, strict: bool = False) -> tuple[dict, list[dict], dict]: - """바탕 줄 + 식 칸 → (엔진 줄, 틀린 자리 [{cid, 까닭}], 엔진 식으로 바꾼 문서) · 틀린 자리 = - M01 식(변수 = 뺌 · 수량식 = 수) · `strict` = 하나라도 틀리면 `DocError`(저장).""" - if not has(doc): - return row, [], doc - where, bad, gone = _places(row), [], [] - covers, lines, adds = {}, [], [dict(x) for x in doc.get("더한줄") or []] - for spot, text in (doc.get("식덮개") or {}).items(): - got, why = to_engine(text, row) - if spot not in where: - gone.append(_bad(spot, "바탕에 없는 줄")) - elif why: - bad += [_bad(spot, w) for w in why] - else: - covers[spot] = got - taken, mf = _names(row), _eng() - for one in doc.get("변수줄") or []: - spot, (got, why) = f"mid:{one['이름']}", to_engine(one["식"], row) - if one["이름"] in taken or one["이름"] in _reserved(): - bad.append( - _bad(spot, f"이름 「{one['이름']}」 이 이미 있음(입력 · 중간 · 덧줄 · 예약)") - ) - elif why: - bad += [_bad(spot, w) for w in why] - else: - lines.append({**one, "식": got}) - for k, one in enumerate(adds): - if one.get("수량식"): - got, why = to_engine(one["수량식"], row) - bad += [_bad(f"add:#{k}", w) for w in why] - if why: - one.pop("수량식") - else: - one["수량식"] = got - while True: # 틀린 자리를 빼면 다른 자리가 틀릴 수 있음 — 더 안 틀릴 때까지 - out, lost = _build(row, covers, lines) - more = _check(out, covers, lines, adds, mf) - if not more: - break - bad += more - hit = {b["cid"] for b in more} - covers = {s: v for s, v in covers.items() if s not in hit} - lines = [x for x in lines if f"mid:{x['이름']}" not in hit] - for k in [int(_ADD.match(c)[1]) for c in hit if _ADD.match(c)]: - adds[k].pop("수량식", None) - if strict and bad: # 짝 잃음(바탕에 없는 줄 · 자리)은 알림만 — [M01 원래로] 로 걷음 - raise sd.DocError(f"「{bad[0]['cid']}」 {bad[0]['까닭']}") - fixed = {k: v for k, v in doc.items() if k not in FIELDS} | {"더한줄": adds} - fixed |= ({"식덮개": covers} if covers else {}) | ({"변수줄": lines} if lines else {}) - return out, bad + gone + lost, fixed - - -@functools.cache -def _reserved() -> frozenset: - mf = _eng() - return frozenset( - (*mf.FUNCS, *mf.COST_ITEMS, "찾기", "로직", "그리고", "또는", "계", "줄", "번지", "단계") - ) - - -def _build(row: dict, covers: dict, lines: list[dict]) -> tuple[dict, list[dict]]: - """식 덮개를 바탕 칸에 · 변수 줄을 자리 뒤에 끼움(같은 자리 = 넣은 차례).""" - out = {**row, **{k: list(row.get(k) or []) for k in FIELD}} - for spot, (part, at) in _places(row).items(): - if spot in covers: - out[part][at] = {**out[part][at], FIELD[part]: covers[spot]} - mids, after, lost = out["중간"], {}, [] - for one in lines: - spot = one["자리"] - names = [f"mid:{x.get('이름')}" for x in mids] - if spot and spot not in names: - lost.append(_bad(f"mid:{one['이름']}", f"자리 「{spot}」 없음 — 중간 끝에 둠")) - at = len(mids) - else: - at = after.get(spot, names.index(spot) + 1 if spot else 0) - step = {"이름": one["이름"], "식": one["식"], "변수": True} - mids.insert(at, step | ({"표시": one["표시"]} if "표시" in one else {})) - after = {k: v + (v >= at) for k, v in after.items()} | {spot: at + 1} - return out, lost - - -def _uses(text: str) -> set[str] | None: - mf = _eng() - try: - return {n[1] for n in mf.walk(mf.parse(text)) if n[0] == "name"} - except (mf.FormulaError, RecursionError): - return None - - -def _zero(node: tuple, mf: Any) -> bool: - return any(n[0] == "bin" and n[1] == "/" and n[3] == ("num", 0) for n in mf.walk(node)) - - -def _check(row: dict, covers: dict, lines: list, adds: list, mf: Any) -> list[dict]: - """식 칸 자리만 검사 — 식 · 0 나눔 · 이름(엔진 `_check_node`) · 아래 줄 · 순환.""" - inputs = {str(x.get("이름")) for x in row.get("입력") or []} - mids = [str(x.get("이름")) for x in row["중간"]] - deps = {n: (_uses(str(x.get("식"))) or set()) & set(mids) for n, x in zip(mids, row["중간"])} - mine = set(covers) | {f"mid:{x['이름']}" for x in lines} - full = inputs | set(mids) - tail = full | set(mf.COST_ITEMS) | {"줄"} | ({"번지", "단계"} if mf.ms.uses(row) else set()) - jobs = [ - (f"mid:{n}", str(x["식"]), inputs | set(mids[:i]), n) - for i, (n, x) in enumerate(zip(mids, row["중간"])) - ] - jobs = [j for j in jobs if j[0] in mine] - places = _places(row) - for spot, (part, at) in places.items(): - if spot in covers and part != "중간": - names = ( - tail | {str(x.get("이름")) for x in row["덧줄"][:at]} if part == "덧줄" else full - ) - jobs.append((spot, covers[spot], names, None)) - jobs += [(f"add:#{k}", x["수량식"], full, None) for k, x in enumerate(adds) if x.get("수량식")] - out = [] - for spot, text, known, me in jobs: - try: - node = mf.parse(text) - except (mf.FormulaError, RecursionError) as e: - out.append(_bad(spot, str(e))) - continue - why = ["0 으로 나눔"] if _zero(node, mf) else [] - used = {n[1] for n in mf.walk(node) if n[0] == "name"} - for n in sorted(used - known): - if n == me: - why.append(f"순환 — 「{n}」 이 자기 자신을 씀") - elif me and n in deps: - loop = _path(deps, n, me) - why.append( - f"순환 — {' → '.join([me, *loop])}" - if loop - else f"「{n}」 은 아래 줄 — 위로 옮길 것" - ) - found: list[str] = [] - mf._check_node(row, node, known | (used & set(mids)), _whole(), "", found, set()) - why += [w.lstrip(" ·") for w in found] - out += [_bad(spot, w) for w in why] - return out - - -def _path(deps: dict, start: str, goal: str) -> list[str] | None: - """`start` 에서 `goal` 로 가는 의존 길(있으면 순환).""" - seen, todo = {start}, [[start]] - while todo: - path = todo.pop() - if path[-1] == goal: - return path - for nxt in sorted(deps.get(path[-1], ())): - if nxt not in seen: - seen.add(nxt) - todo.append([*path, nxt]) - return None diff --git a/resources/tester/test_790_2_sangeun_const.py b/resources/tester/test_790_2_sangeun_const.py index 46c80ad6f..07078fc04 100644 --- a/resources/tester/test_790_2_sangeun_const.py +++ b/resources/tester/test_790_2_sangeun_const.py @@ -1,18 +1,12 @@ # ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 -"""790-2 단가산출(SK) 숫자 넓힘 — 상수 · 표값 덮개 · 글 줄 · 까닭 · M01 원래로 · 짝잃음(요구서_652). +"""790-2 단가산출(SK) 글 줄 · 까닭 칸 꼴 · 옛 SK 셈 답(요구서_652). -- 금액 = 서버 셈 = _분석_650-H2 4 장 견본(지붕 감률 17 → 20 = 61,088 · 공구손료 1 → 2 % = 51,802 · - 인력운반 120 → 100 = 38,696 · 표값 운반량 30 = 35,764) · 옵션 바꿔도 상수 덮개 식 따라감 -- 식 속 숫자 차례 = 엔진 파서(찾기 머리 · 키 · EQ: · 따옴표 글 안 셈) -- 옛 SK(새 칸 없음) = 꼴 · 금액 그대로 · 저장 = M01판 · 셈 답 `원래` · `시트` -- 799-2 — TS 거울(`Const_Model.ts`)은 시트 탭과 함께 걷음 · 서버 `M02_Sangeun_Const` 만 지킴 -- 펼침 = 상수 덮개 SK 안 펼침(참조 그대로 · 값 그대로) · [초기화] = 새 덮개도 걷음 +- 글줄 · 까닭 = 꼴 검사 · 빈 칸 안 둠 · 상수 · 표값 덮개 = 셈 은퇴 뒤 받지 않음(855 2-E2 · 시험 792_1) +- 옛 SK(새 칸 없음) = 꼴 · 금액 그대로 · M01판 = 서버 몫(버림) """ from __future__ import annotations -import json -from pathlib import Path import pytest @@ -24,11 +18,7 @@ from M02_MasterTemplete import M02_Sangeun_Const as const from M02_MasterTemplete import M02_Sangeun_Doc as sd from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층 -ROOT = Path(__file__).resolve().parents[2] FORM = "GC000211" # 합판거푸집 -CARRY = "GC001140" # 인력운반(지게) -ROOF = "지붕 슬래브(경사 20˚ 미만)" -TOOL = "pct:공구손료 및 경장비#0" F211 = { "자재지역": "포항", "유형": "보통", @@ -46,15 +36,6 @@ def _whole(): return m01.loaded()[1] -def _carry(): - return { - **json.loads(json.dumps(_whole().logic(CARRY)["시험입력"], default=str)), - "재료종별": "암석", - "재료형상": "화강암", - "운반회수": 0, - } - - def _doc(code, given, **more): return { "키": "SK-000001", @@ -66,47 +47,19 @@ def _doc(code, given, **more): } -def _sum(doc): - whole = _whole() - return float(calc.run(sd.clean(doc, None, whole), whole)["기준"]["계"]) - - -# ── 식 속 자리 ──────────────────────────────────────────────────────── -def test_scan_엔진_차례(): - t = "찾기(QC000431, 유형=유형).시공량 * (1 - (높이감률 + 만약(지붕슬래브 == '아님', 0, 17)) / 100)" - got = const.scan(t) - assert [t[a:b] for a, b in got["num"]] == ["1", "0", "17", "100"] - assert [t[a:b] for a, b in got["find"]] == ["찾기(QC000431, 유형=유형).시공량"] - tool = "(형틀목공 * LB000007 + 보통인부 * LB000002) * 1 / 100" - assert [tool[a:b] for a, b in const.scan(tool)["num"]] == ["1", "100"] - assert const.scan("EQ:0201-0012.잡재료율 * 2 + '3t/㎡'")["num"] == [(20, 21)] - assert const.scan("((((") == {"num": [], "find": []} # 못 읽는 식 = 빈 - assert const.swap(t, {"2": 20}, {"0": -45}).startswith("(-45) * (1 - ") - assert ", 0, 20)) / 100)" in const.swap(t, {"2": 20}, {}) - - -# ── 금액 = 견본(서버 셈) ────────────────────────────────────────────── - - # ── 문서 꼴 ────────────────────────────────────────────────────────── def test_새_칸_꼴_검사(): whole = _whole() doc = _doc( FORM, F211, - 상수덮개={"mid:시공량": {"2": "20"}, TOOL: {}}, - 표값덮개={}, 글줄=[{"자리": "", "글": " 건설표준품셈 6-3-1 "}, {"자리": "mid:시공량", "글": ""}], 까닭={"mid:시공량": "현장 경사 반영", "add:#0": " ", "add:#1/labor:LB000002#0": "x"}, ) got = sd.clean(doc, None, whole) - assert got["상수덮개"] == {"mid:시공량": {"2": 20}} and "표값덮개" not in got assert got["글줄"] == [{"자리": "", "글": "건설표준품셈 6-3-1"}] assert got["까닭"] == {"mid:시공량": "현장 경사 반영", "add:#1/labor:LB000002#0": "x"} for bad in ( - {"상수덮개": {"엉뚱": {"0": 1}}}, - {"상수덮개": {"mid:시공량": {"a": 1}}}, - {"표값덮개": {"mid:운반량": {"0": "글"}}}, {"까닭": {"x": "y"}}, {"글줄": [{"자리": "", "글": "가" * 501}]}, ): @@ -119,9 +72,6 @@ def test_옛_SK_꼴_금액_그대로(): old = _doc(FORM, F211, 덮개={"labor:LB000007#0": {"qty": 0.2}}, 뺀줄=["labor:LB000002#0"]) got = sd.clean(old, None, whole) assert not set(got) & {*const.NEW, "M01판"} - assert const.formulas(whole.logic(FORM), got) is whole.logic( - FORM - ) # 새 덮개 없음 = 그 줄 그대로 assert sd.clean({**old, "M01판": {"mid:시공량": "x"}}, None, whole) == got # M01판 = 서버 몫 diff --git a/resources/tester/test_792_1_sangeun_formula.py b/resources/tester/test_792_1_sangeun_formula.py index 183f63dc7..e6dc28b7a 100644 --- a/resources/tester/test_792_1_sangeun_formula.py +++ b/resources/tester/test_792_1_sangeun_formula.py @@ -1,39 +1,27 @@ -# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 -"""792-1 단가산출(SK) 사용자 식 칸 — 변수 줄 · 식 덮개 · 더한줄 수량식 · 이름 꼴 ↔ 엔진 식 · 검사. +"""792-1 식 글 번역 · 옛 SK 식 칸 막음. -- 금액 = 서버 셈 = _분석_650-H2 4 장 견본(인력운반 「할증율 20」 변수 줄 + 보통인부 품 식 - × (1 + 할증율 / 100) = 51,501) · 합판거푸집 줄 식 고침 · 공구손료 식 2 % = 51,802(790-2 같은 값) -- 이름 꼴(`×` · `[노임 형틀목공]` · `[별칭]`) ↔ 엔진 식 왕복 = M01 로직 견본 식 전부 같음 -- 꼴 상한 — 변수 줄 수 · 이름 꼴 · 자리 겹침 · 괄호 깊이(식 칸 검사 길은 894 에서 걷음) -- 옛 SK(식 칸 없음) = 꼴 · 금액 그대로 · 저장 = 엔진 식 · 틀린 식 저장 400 · 셈 답 덧칸 -- B09 사본 굳힘(`GX9#####`) 줄 = 식 칸 그대로 · 다시 셈 같은 금액 -- 799-2 — TS 거울(`Formula_Model.ts` · `Const_Model.ts`)은 시트 탭과 함께 걷음 · 서버만 지킴 +- 이름 꼴(`×` · `[노임 형틀목공]` · `[별칭]`) ↔ 엔진 식 왕복 = M01 로직 견본 식 전부 같음(M01 수식 탭 · 가져온 식이 씀) +- 식 글 상한 — 괄호 깊이 · 길이 +- 옛 SK 식 칸(변수줄 · 식덮개 · 더한줄 수량식)과 상수 · 표값 덮개 = 셈 은퇴(855 2-C1) 뒤 받지 않음 400(855 2-E2) +- [초기화] = 덮개 · 뺀줄 · 그 까닭 걷음 · 빈 옛 식 칸 = 지문 그대로 """ from __future__ import annotations import json -from pathlib import Path import pytest from M01_MasterData import M01_MasterData_Store as m01 -from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Library_Flat as flat -from M02_MasterTemplete import M02_MasterTemplete_Store as store -from M02_MasterTemplete import M02_Sangeun_Calc as calc from M02_MasterTemplete import M02_Sangeun_Const as const from M02_MasterTemplete import M02_Sangeun_Doc as sd from M02_MasterTemplete import M02_Sangeun_Formula as fx -from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층 -ROOT = Path(__file__).resolve().parents[2] FORM, CARRY = "GC000211", "GC001140" # 합판거푸집 · 인력운반(지게) MAN = "labor:LB000002#0" # 인력운반 보통인부 -TOOL = "pct:공구손료 및 경장비#0" F211 = {"자재지역": "포항", "유형": "보통", "사용횟수": "6회", "높이감률": 0, "지붕슬래브": "아님"} F211 |= {"폼타이": "아님", "폼타이규격": "12.7㎜", "측압": "3t/㎡", "구멍땜": 0} -PLUS = "무게 / 운반량 / 일운반회수 × (1 + 할증율 / 100)" def _whole(): @@ -59,23 +47,6 @@ def _sk_doc(code, given, **more): return {**_doc(code, given), **more} -def _run(doc): - whole = _whole() - return calc.run(sd.clean(doc, None, whole), whole) - - -def _sum(doc): - return float(_run(doc)["기준"]["계"]) - - -def _plus(**more): - var = [{"이름": "할증율", "식": "20", "자리": ""}] - return _sk_doc(CARRY, _carry(), **({"변수줄": var, "식덮개": {MAN: PLUS}} | more)) - - -# ── 견본 금액 ───────────────────────────────────────────────────────── - - # ── 이름 꼴 ↔ 엔진 식 ──────────────────────────────────────────────── def test_이름_꼴_양방향(): whole = _whole() @@ -98,61 +69,43 @@ def test_이름_꼴_양방향(): assert fx.to_engine(fx.to_name(str(x[f]), one), one) == (str(x[f]), []) -def test_꼴_상한_겹침(): +def test_식_글_상한(): + assert fx.limits("(" * 13 + "1" + ")" * 13) == [f"괄호가 {fx.DEEP} 겹을 넘음"] + assert fx.limits("1" * (fx.LONG + 1)) == [f"식이 {fx.LONG} 자를 넘음"] + assert fx.limits("'((((((((((((('") == [] # 따옴표 글 안 괄호 안 셈 + + +def test_옛_식_칸_받지_않음(): whole = _whole() - many = [{"이름": f"v{i}", "식": "1", "자리": ""} for i in range(fx.MANY + 1)] - for bad, why in ( - ({"변수줄": many}, "까지 목록"), - ({"변수줄": [{"이름": "1가", "식": "1"}]}, "이름 꼴"), - ({"변수줄": [{"이름": "가", "식": "1"}, {"이름": "가", "식": "2"}]}, "같은 이름"), - ({"변수줄": [{"이름": "가", "식": "1", "표시": 7}]}, "0~6"), - ({"식덮개": {"mid:시공량": "1"}, "상수덮개": {"mid:시공량": {"0": 1}}}, "같이 못 둠"), - ({"식덮개": {"labor:LB000007#0": "1"}, "덮개": {"labor:LB000007#0": {"qty": 1}}}, "qty"), - ({"식덮개": {"엉뚱": "1"}}, "자리 꼴"), - ({"식덮개": {"mid:시공량": "(" * 13}}, "괄호"), + plain = sd.clean(_sk_doc(FORM, F211), None, whole) + for bad in ( + {"변수줄": [{"이름": "할증율", "식": "20"}]}, + {"식덮개": {"mid:시공량": "1"}}, + {"상수덮개": {"mid:시공량": {"0": 1}}}, + {"표값덮개": {"mid:운반량": {"0": 30}}}, + {"더한줄": [{"종류": "인력", "요소": "LB000002", "수량": 1, "수량식": "2"}]}, ): - with pytest.raises(sd.DocError, match=why): + with pytest.raises(sd.DocError, match="옛 식 칸"): sd.clean(_sk_doc(FORM, F211, **bad), None, whole) + empty = {"변수줄": [], "식덮개": {}, "상수덮개": {}, "표값덮개": {}} + assert sd.clean(_sk_doc(FORM, F211, **empty), None, whole) == plain # 빈 칸 = 옛 SK 그대로 -# ── 옛 SK · 저장 · 셈 답 · 펼침 · 초기화 ───────────────────────────────── +# ── 초기화 · 지문 ───────────────────────────────────────────────────── -def _sk(folder, **doc): - with store.at(folder): - made = refs.create("sangeun", {"이름": "내 단가산출", "단위": "식", "더한줄": [], **doc}) - return made["이름"] +def test_초기화_걷음(): + doc = _sk_doc(CARRY, _carry(), 덮개={MAN: {"qty": 1}}, 까닭={MAN: "할증", "add:#0": "더함"}) + got, n = flat.reset("sangeun", doc) + assert n == 1 and got["덮개"] == {} and got["까닭"] == {"add:#0": "더함"} # 더한줄 몫 까닭 남김 + assert const.restore(doc)["뺀줄"] == [] and const.covers_n(doc) == 1 -def _read(folder, key): - with store.at(folder): - return store.read("sangeun", key)["문서"] - - -def _calc(folder, doc): - with store.at(folder): - return calc.calc_doc(doc) - - -def test_펼침_막음_초기화_걷음(world): - mine = world["personal"] - a = _sk(mine, 바탕={"로직": CARRY}, 입력값=_carry(), 변수줄=[{"이름": "할증율", "식": "20"}]) - with store.at(mine), pytest.raises(sd.DocError): - const.no_flat(_read(mine, a)) # 식 칸 SK = 안 펼침(저장 · 읽기 펼침 첫머리) - doc, n = flat.reset("sangeun", {**_plus(), "까닭": {MAN: "할증"}}) - assert n == 1 and "식덮개" not in doc and "까닭" not in doc and doc["변수줄"] - assert const.restore(_plus(), MAN).get("식덮개") is None - assert const.covers_n(_plus()) == 1 - - -# ── B09 사본 굳힘 ───────────────────────────────────────────────────── - - -def test_같은_내용_지문_식_칸_가림(): - """식 칸만 다른 SK = 다른 내용(409 같은 것 물음 안 함) · 옛 SK 지문 그대로.""" +def test_같은_내용_지문_빈_옛_칸(): + """빈 옛 식 칸 = 옛 SK 지문 그대로.""" from M02_MasterTemplete import M02_Library_Same as same plain = _doc(CARRY, _carry()) - one, two = same.finger("sangeun", plain), same.finger("sangeun", _plus()) - assert one and two and one != two - assert same.finger("sangeun", {**plain, "식덮개": {}, "변수줄": []}) == one + assert same.finger("sangeun", {**plain, "식덮개": {}, "변수줄": []}) == same.finger( + "sangeun", plain + ) diff --git a/resources/tester/test_793_2_sangeun_imported.py b/resources/tester/test_793_2_sangeun_imported.py index 088cce60b..54f6120c3 100644 --- a/resources/tester/test_793_2_sangeun_imported.py +++ b/resources/tester/test_793_2_sangeun_imported.py @@ -154,16 +154,11 @@ def test_북부청_18_줄_자리_셈_엑셀(): # ── 덮개 · 식 칸 · 셈 답 ───────────────────────────────────────────── -def test_덮개_상수_식칸_가져온_줄에_먹음(): +def test_덮개_뺀줄_더한줄_가져온_줄에_먹음(): base = _total(_doc()) covered = _doc(덮개={"labor:형틀목공#0": {"qty": 0.2}}) assert _total(covered) > base # 형틀목공 5/50 → 0.2 인 - assert ( - _total(_doc(상수덮개={BURN: {"0": 12}})) == 45652 + 101 - ) # 소모자재 11 → 12 %(A01 재료 10,083.7 × 1 %) - assert _total(_doc(식덮개={"labor:형틀목공#0": "6 / 50"})) > base - var = [{"이름": "할증", "식": "1.2", "자리": ""}] - assert _total(_doc(변수줄=var, 식덮개={"labor:형틀목공#0": "5 / 50 * 할증"})) > base + # 상수덮개 · 식덮개 · 변수줄 = 셈 은퇴 뒤 받지 않음(855 2-E2 · 시험 792_1) assert _total(_doc(뺀줄=[PLY])) < base adds = [{"종류": "인력", "요소": MAN, "수량": 0.01}] assert _total(_doc(더한줄=adds)) > base From 1b33d141a3c4b7992c40d3e53f5a737cf45ec499 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 05:06:52 +0900 Subject: [PATCH 03/13] =?UTF-8?q?refactor(857-5):=20=ED=98=B8=ED=91=9C=20?= =?UTF-8?q?=EC=AA=BD=20=EC=98=9B=20=EA=B0=80=EB=A6=84=20=EB=B3=B8=EC=B2=B4?= =?UTF-8?q?=20=EA=B1=B7=EC=9D=8C=20=E2=80=94=20=EC=8B=9C=ED=8A=B8=EB=A5=BC?= =?UTF-8?q?=20=EC=A7=81=EC=A0=91=20=EA=B0=80=EB=A5=B4=EB=8D=98=20ReadEst.r?= =?UTF-8?q?ead=20=C2=B7=20Stmate.=5Fblocks=20=C2=B7=20Excel.=5Fcolumns=20?= =?UTF-8?q?=C2=B7=20=5Fsummary?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 857-2 뒤 호표 계보는 둘 꼴 위에서 읽음(from_two) — 옛 본체 부르는 곳 0(저장소 전체 · 옛 조사 스크립트 docs 만) - 딸린 것: ReadEst `_columns` · `_cell_text` · `WIDE` · `_MONEY` · Stmate `_HEAD_D` · `_HEAD_B` · `_COLS` · Excel `HEADS` - B09 `Bill_Excel` 이 쓰는 `Hopyo_Excel._money` · `_HOPYO` 는 남김 - 시험 test_778_3 STmate 합성 줄 = 같은 줄을 칸줄로 싸서 from_two 로(판정 그대로) - 머리 글의 옛 이름(UnitLine · San_Book · Excel) 고침 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Hopyo_Excel.py | 33 +------- M02_MasterTemplete/M02_Hopyo_ReadEst.py | 76 +------------------ M02_MasterTemplete/M02_Hopyo_Stmate.py | 23 +----- M02_MasterTemplete/M02_Hopyo_UnitLine.py | 2 +- M02_MasterTemplete/M02_San_Book.py | 2 +- .../tester/test_778_3_hopyo_unit_lines.py | 3 +- 6 files changed, 10 insertions(+), 129 deletions(-) diff --git a/M02_MasterTemplete/M02_Hopyo_Excel.py b/M02_MasterTemplete/M02_Hopyo_Excel.py index a2a7ba5b0..f8636083c 100644 --- a/M02_MasterTemplete/M02_Hopyo_Excel.py +++ b/M02_MasterTemplete/M02_Hopyo_Excel.py @@ -17,7 +17,7 @@ STmate 꼴(「일위대가표」 · 「단가산출근거」 시트) = `M02_Hopy % 줄 = floor(바탕 × 율 / 100 × 10) / 10 · 호표 비목 = floor(줄 금액 합) · 총괄표 합계 — 어긋남은 글 목록(막지 않음). 행(329-1) = 호표 [제N호표 줄, 마지막 구성 줄] · 구성 줄 한 줄(엑셀 1부터) · -근거(330-1) = 단산N참조 줄에 「단가산출」 블록 `{출처, 직종, 행}`(`M02_Hopyo_ReadEst.read`) · +근거(330-1) = 단산N참조 줄에 「단가산출」 블록 `{출처, 직종, 행}`(`M02_Hopyo_ReadEst.from_two`) · `단산` = 블록마다 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`(338 · 글 = 머리 뺀 몸 줄) · `꼴` = 「엑셀꼴」 · 두 형식 끝에 `UnitLine.settle`(단위 줄 하위 · 재현 · 덮음 · 일위대가 줄 투영 · 778-3). @@ -40,7 +40,6 @@ SHEET = "일위대가" SUMMARY = "일위대가총괄표" LISTS = ("단가산출총괄표", "일위대가목록표") # 엑셀 보기 목록 시트(779-1 격자) — 같이 읽음 COSTS = ("노무비", "재료비", "경비") -HEADS = ("호표", "품명", "규격", "수량", "단위", "비고") NO_SHEET = "일위대가 시트 없음" _HOPYO = re.compile(r"제\s*(\d+)\s*호표") _REF = re.compile(r"^(?:(단산|산근|단가산출)|(일위대가|일위|대가))(\d+)(?:참조|호표)?$") @@ -88,19 +87,6 @@ def _out(value: Decimal | None) -> int | float | None: return int(value) if value == value.to_integral_value() else float(value) -def _columns(rows: list[list[Any]], money: tuple[str, ...]) -> tuple[int, dict[str, int]]: - """(자료 첫 줄, {머리: 열}) — 머리 글은 앞 10 줄 안 「호표」 · 「품명」 이 든 줄.""" - for at, row in enumerate(rows[:10]): - flat = [_flat(v) for v in row] - if "호표" not in flat or "품명" not in flat: - continue - cols = {head: flat.index(head) for head in (*HEADS, *money) if head in flat} - below = [_flat(v) for v in rows[at + 1]] if at + 1 < len(rows) else [] - start = at + 2 if "단가" in below or "금액" in below else at + 1 - return start, cols - raise ExcelError(f"{SHEET} 시트 머리 글(호표 · 품명)을 못 찾음") - - def _cell(row: list[Any], col: int | None) -> Any: return row[col] if col is not None and col < len(row) else None @@ -200,23 +186,6 @@ def _check_hopyo(hopyo: dict[str, Any], lines: list[dict[str, Any]]) -> list[str return bad -def _summary(rows: list[list[Any]] | None) -> dict[int, Decimal]: - """총괄표 {호표 번: 합계} — 머리 글이 없으면 빈 것.""" - if not rows: - return {} - try: - start, cols = _columns(rows, ("합계",)) - except ExcelError: - return {} - out = {} - for row in rows[start:]: - hit = _HOPYO.fullmatch(_flat(_cell(row, cols.get("호표")))) - total = _num(_cell(row, cols.get("합계"))) - if hit and total is not None: - out[int(hit.group(1))] = total - return out - - def _by_name(raw: list[list[dict[str, Any]]], blocks: dict[int, dict[str, Any]]) -> None: """비고 빈 줄(노무비 · 경비 단가 있음) → 품명 + 단위가 같은 블록이 하나뿐이면 단산 이음.""" index: dict[tuple[str, str], list[int]] = {} diff --git a/M02_MasterTemplete/M02_Hopyo_ReadEst.py b/M02_MasterTemplete/M02_Hopyo_ReadEst.py index 0c54c00ec..7f7fe279b 100644 --- a/M02_MasterTemplete/M02_Hopyo_ReadEst.py +++ b/M02_MasterTemplete/M02_Hopyo_ReadEst.py @@ -1,14 +1,13 @@ """M02 일위대가 실무자료 EST(엑셀꼴) 단가산출 어댑터(PLAN 776-2 · 요구 621-1 ② 정규화) — -엑셀 「단가산출」 시트 → 블록 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`. +둘 꼴 EST 산근 블록(`from_two` · 857-2) → 블록 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`. 형식(EST 글)을 아는 곳은 여기까지. -블록 = B열(머리 「산출근거」) 머리 줄 「N.이름[단위]」(앞 빈칸 없음)부터 다음 머리 앞까지 · +블록 = 머리 「N.이름[단위]」부터 다음 머리 앞까지 · 출처 = 「…품셈」(오타 「품줌」) 뒤 20 글자 안 절 번호 — 책 = 앞 낱말(`book_of` · 781-1: 산림 · 임도(옛) · 사방(옛) · 건설 부문 · 그 밖 건설품셈(부문 모름)) · 부문 풀이 · 옛 번호 대응 = `M02_Hopyo_Clause.settle` · 직종 = 「이름 : 수」 줄의 빈칸 뺀 이름이 우리 인력(LB) 이름 · 옛이름일 때만(지금 이름으로) · -글 = 머리 뺀 몸 줄 `GLINES` 줄 · 줄마다 `GCHARS` 자 안 · 산출근거 열이 빈 줄은 그 오른쪽 ~ 돈 머리 -(맨 오른쪽 묶음) 앞 칸을 빈칸으로 이어 붙임(거창 꼴 · 돈 머리 없으면 `WIDE` 열) · +글 = 머리 뺀 몸 줄 `GLINES` 줄 · 줄마다 `GCHARS` 자 안 · 금액 = 머리 줄 돈 칸(1 단위). 항목(Book 블록 항목 · 778-3) = 글 줄 → 단위 줄(꼴 = `M02_Hopyo_UnitLine`) · 줄 금액 = 「= 금액」 · 끝 점(「28,500. ×」) 뗌 · 율(호표 줄 이름 · 규격)에 기대지 않는 것만(섞음 율은 지문 몫): @@ -34,7 +33,7 @@ from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs from M02_MasterTemplete.M02_Hopyo_Words import mtypes, parse_rhs SHEET = "단가산출" -GLINES, GCHARS, WIDE = 200, 300, 140 +GLINES, GCHARS = 200, 300 _HEAD = re.compile(r"^(\d+)\.\s*(.*?)\s*\[([^\[\]]*)\]\s*$") _BOOK = re.compile(r"품[셈줌]") _TRADE = re.compile(r"^[\s*·\-]*([가-힣][가-힣\s]*?)\s*:\s*[\d,]") @@ -46,7 +45,6 @@ _BOOK_WORDS = { # 책 낱말(781-1) — 옛 책 = 「(옛)」 · 건설 부문 } _BOOK_WORD = re.compile(r"(" + "|".join(_BOOK_WORDS) + r")\s*(?:부문|사업|공사)?\s*(?:표준)?\s*$") _TYPO_CLAUSE = re.compile(r"^(\d+)-(\d)(\d)(\d)$") # 「13-114」 = 13-11-4 -_MONEY = {"합계": "계", "노무비": "노무비", "재료비": "재료비", "경비": "경비"} # 항목 풀이 — 지문(`Finger`)과 같은 규칙 COST = ("노무비", "재료비", "경비") SKIPW = frozenset( @@ -88,12 +86,6 @@ def _flat(value: Any) -> str: return re.sub(r"\s+", "", str(value or "")) -def _cell_text(value: Any) -> str: - if isinstance(value, float) and value == int(value): - value = int(value) - return str(value).strip() if value is not None else "" - - # ── 이름 · 출처(두 어댑터 · 뒤 단계 공용) ──────────────────────────────── @lru_cache(maxsize=2) def _trade_names(whole_id: int) -> dict[str, str]: @@ -156,66 +148,6 @@ def rates_in(text: Any) -> set[float]: return out -# ── 블록 읽기 ───────────────────────────────────────────────────────── -def _columns(rows: list[list[Any]]) -> tuple[int, int, dict[str, int]]: - """(자료 첫 줄, 산출근거 열, {계 · 노무비 · 재료비 · 경비: 열}) — 머리 없으면 (0, 1, {}) · - 돈 머리가 둘 묶음이면 맨 오른쪽(거창 꼴 · 값이 든 쪽).""" - for at, row in enumerate(rows[:10]): - flat = [_flat(v) for v in row] - if "산출근거" in flat: - last = len(flat) - 1 - money = { - key: last - flat[::-1].index(head) for head, key in _MONEY.items() if head in flat - } - return at + 1, flat.index("산출근거"), money - return 0, 1, {} - - -def read(rows: list[list[Any]] | None) -> dict[int, dict[str, Any]]: - """단가산출 시트 줄 → `{N: {번, 이름, 단위, 행: [시작, 끝], 출처, 직종, 글, 글행, 금액, 항목, - 절}}`(행 = 엑셀 1부터 · 글행 = 글 줄마다 행 · 절 = `M02_Hopyo_Formula.tree`).""" - if not rows: - return {} - start, col, money = _columns(rows) - end = min(money.values()) if money and min(money.values()) > col + 1 else WIDE - names = trade_names() - blocks: dict[int, dict[str, Any]] = {} - block: dict[str, Any] | None = None - for at, row in enumerate(rows[start:], start + 1): - text = row[col] if col < len(row) else None - head = None - if isinstance(text, str) and text.strip(): - head = None if text[:1].isspace() else _HEAD.match(text) - else: - text = " ".join(_cell_text(v) for v in row[col + 1 : end] if _cell_text(v)) - if not text: - continue - if head: - block = blocks.setdefault( - int(head.group(1)), - { - "번": int(head.group(1)), - "이름": head.group(2), - "단위": head.group(3).strip(), - "행": [at, at], - "출처": [], - "직종": [], - "글": [], - "금액": { - key: v - for key, c in money.items() - for v in [row[c] if c < len(row) else None] - if isinstance(v, (int, float)) and not isinstance(v, bool) - }, - "_글행": [], - }, - ) - continue - if block is not None: - _take(block, at, text, names) - return _finish(blocks) - - def _take(block: dict[str, Any], at: int, text: str, names: dict[str, str]) -> None: """몸 줄 하나 → 블록 끝 행 · 글(`GLINES` 줄 · 줄마다 `GCHARS` 자) · 출처 · 직종.""" block["행"][1] = at diff --git a/M02_MasterTemplete/M02_Hopyo_Stmate.py b/M02_MasterTemplete/M02_Hopyo_Stmate.py index fd898ff23..ddf10bd92 100644 --- a/M02_MasterTemplete/M02_Hopyo_Stmate.py +++ b/M02_MasterTemplete/M02_Hopyo_Stmate.py @@ -40,13 +40,10 @@ LISTS = ("단가산출근거목록표", "노무비목록표", "중기목록표", SHEETS = (SHEET, CALC, *LISTS) _CODE = ilwi.CODE _META = re.compile(r"(? dict[str, dict[str, Any]]: return out -def _blocks(rows: list[list[Any]], table: dict[str, dict[str, str]]) -> dict[str, dict[str, Any]]: - """{D 코드: {번, 코드, 이름, 규격, 단위, 행, 출처, 직종, 글, 자원, 금액, 항목}}.""" - out: dict[str, dict[str, Any]] = {} - block: dict[str, Any] | None = None - state = {"절": "", "라벨": ""} # 절 제목 · 율 행 위 라벨 줄(코드 · 금액 없는 글) - for at, row in enumerate(rows, 1): - head = next( - (hit for v in row[:8] if (hit := _HEAD_D.search(_s(v)))), None - ) # 머리 = G 열(판마다 B 열 글이 다름) - if head: - block = out.setdefault(head.group(1), _new(head.group(1), at, row, table)) - state = {"절": "", "라벨": ""} - continue - if block is not None and not _take(block, at, row, table, state): - block = None - return _finish(out) - - def from_two(blocks: list[dict[str, Any]], table: dict[str, dict[str, str]]) -> dict[str, Any]: """둘 꼴 STmate 산근 블록 `칸줄`(머리 ~ 다음 머리 앞 칸 · `M02_San_Xlsx_Stmate.cells` · 857-2) → - `_blocks` 와 같은 블록 — 시트를 다시 가르지 않음 · D 코드 블록만.""" + 블록 — 시트를 다시 가르지 않음 · D 코드 블록만.""" out: dict[str, dict[str, Any]] = {} for b in blocks: code = str(b.get("코드") or "") diff --git a/M02_MasterTemplete/M02_Hopyo_UnitLine.py b/M02_MasterTemplete/M02_Hopyo_UnitLine.py index ead5c3da6..fbf9fc7d0 100644 --- a/M02_MasterTemplete/M02_Hopyo_UnitLine.py +++ b/M02_MasterTemplete/M02_Hopyo_UnitLine.py @@ -1,6 +1,6 @@ """M02 일위대가 실무자료 단위 줄(PLAN 778-3 · D-1 · 요구 622) — 단가산출 블록 · 일위대가 줄을 같은 「세부항목 계산 단위」 꼴로 · 자체 검산. 형식(EST · STmate)을 모름 — 읽기 어댑터 -(`M02_Hopyo_ReadEst.items` · `M02_Hopyo_Stmate._blocks`)가 블록 `항목` 을 단위 줄로 냄. +(`M02_Hopyo_ReadEst.items` · `M02_Hopyo_Stmate.from_two`)가 블록 `항목` 을 단위 줄로 냄. 단위 줄 = `{묶음, 이름, 규격, 단위, 품, 밑품, 율, 인자, 계수, 단가, 금액, 밖, 기준, 기준값, 하위, 할증, 재현, 직종, 절, 절율, 코드, 어떻게, 행}`: diff --git a/M02_MasterTemplete/M02_San_Book.py b/M02_MasterTemplete/M02_San_Book.py index 7c90f8c93..c767c66f9 100644 --- a/M02_MasterTemplete/M02_San_Book.py +++ b/M02_MasterTemplete/M02_San_Book.py @@ -3,7 +3,7 @@ STmate(.xlsx) = 단가산출근거 시트 G 열 「BDCOD|D…」 머리 · POSS~POSE 몸(숨은 G 열 원문) · 꼬리(계 · 계약단가 · 총계) + 목록표 단가(노무비 · 재료비 · 경비 = E 열 · 숨은 G 열 `COD` · 중기 · 단가산출근거 = E~H 열 계 · 노 · 재 · 경 · 숨은 J 열 메타). -EST(.xls · .xlsx) = 단가산출 시트 블록 글(`M02_Hopyo_ReadEst.read`) + 노임단가 · +EST(.xls · .xlsx) = 단가산출 시트 블록 글 + 노임단가 · 자재단가(적용단가) · 기계경비총괄표 · 견적단가 · 단가산출총괄표(적용 칸 · 합이 안 맞으면 당초 칸). """ diff --git a/resources/tester/test_778_3_hopyo_unit_lines.py b/resources/tester/test_778_3_hopyo_unit_lines.py index d91bc22fc..85a0dd0f7 100644 --- a/resources/tester/test_778_3_hopyo_unit_lines.py +++ b/resources/tester/test_778_3_hopyo_unit_lines.py @@ -118,7 +118,8 @@ def test_STmate_같은_코드_두_묶음_따로_계수_율_밖(): ), # fmt: skip _row(c0="총계"), ] - blocks = st._blocks(rows, {}) + lines = [{"행": at, **{chr(65 + c): v for c, v in enumerate(r) if v is not None}} for at, r in enumerate(rows, 1)] # fmt: skip + blocks = st.from_two([{"코드": "D00001", "칸줄": lines}], {}) units = blocks["D00001"]["항목"] xs = [u for u in units if u["묶음"] == "X"] assert [x["품"] for x in xs] == [0.1, 0.2] # 두 묶음 따로(단가 두 배 아님) From 639602f523f8e1e102a32ac87c359269dba92718 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 05:06:52 +0900 Subject: [PATCH 04/13] =?UTF-8?q?refactor(857-5):=20=EB=B6=88=EB=9F=AC?= =?UTF-8?q?=EC=98=A4=EA=B8=B0=20=EC=98=9B=20=ED=8C=8C=EC=9D=BC=20=EC=A0=95?= =?UTF-8?q?=EB=A6=AC=20CLI(Forget.tidy=20=C2=B7=20main)=20=C2=B7=20?= =?UTF-8?q?=EB=B6=88=EB=9F=AC=EC=98=B4.json=20=EC=A7=80=EB=AC=B8=20?= =?UTF-8?q?=EC=B9=B8=20=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - tidy = 743 전 옛 HP · 끝낸 기록 지문 한 번 정리용 손 CLI — 산 코드 부름 0(시험 test_743_1 하나) - 지문 칸 = tidy 만 읽음 · storage 셋 다 빈 사전 → `Store.done` = {번} 만 · 다음 올림부터 안 씀 - `forget(apply)` 매개 · `_HP` · `import sys` 같이 걷음 - 시험 test_743_1 옛 정리 시험 지움(죽은 CLI 만 붙듦) · 끝낸 기록 판정 = {번: 1} Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Hopyo_Forget.py | 55 ++------------------- M02_MasterTemplete/M02_Hopyo_Store.py | 8 ++- resources/tester/test_743_1_hopyo_forget.py | 30 +---------- 3 files changed, 7 insertions(+), 86 deletions(-) diff --git a/M02_MasterTemplete/M02_Hopyo_Forget.py b/M02_MasterTemplete/M02_Hopyo_Forget.py index 0b54d8060..6be387bde 100644 --- a/M02_MasterTemplete/M02_Hopyo_Forget.py +++ b/M02_MasterTemplete/M02_Hopyo_Forget.py @@ -8,16 +8,12 @@ 걷음(742-1 · 다르면 남김 = 금액 그대로)) · SK · SC `본뜬.또` = 그 HP 몫만 뺌 · 문서 몸(줄 · 덮개 · 더한줄 · 별칭 · 구분)과 별칭 장부는 그대로 · 끝낸 기록 없음(같은 엑셀 다시 올림 됨 · 키 번은 `불러옴.json` 번으로 다시 안 씀). -옛 파일 정리 `tidy`(한 번 · 층 폴더마다 · 미리 보기 = 표만) — 옛 HP(지문 없음) · 하루 지난 HP 끝냄 · - 끝낸 기록 지문 비움 · HP 가 없는 SC · SK 엑셀 사본 걷음. - `python -m M02_MasterTemplete.M02_Hopyo_Forget <층 폴더>… [--apply]`(없으면 미리 보기). """ from __future__ import annotations import json import re -import sys from collections.abc import Callable from datetime import datetime from pathlib import Path @@ -30,7 +26,6 @@ from M02_MasterTemplete import M02_Labor_Ref as refs ORIGIN = "실무자료" KEEP = ("층", "파일", "전국자재", "복사원본") _MEMO = re.compile(r"^실무 ") -_HP = re.compile(r"^(HP-\d{6}) ") # ── 사본 걷음(순수) ─────────────────────────────────────────────────── @@ -99,8 +94,8 @@ def _here(got: dict[str, Any], here: refs.Here) -> bool: return not got.get("원본") or tuple(got["원본"]) == tuple(here) -def forget(folder: str | Path, gone: Callable[[str], bool], apply: bool = True) -> list[str]: - """`gone(본뜬 키)` 인 이 층 SC · SK 엑셀 사본 걷음 → 걷은 문서 키(`apply` 거짓 = 셈만).""" +def forget(folder: str | Path, gone: Callable[[str], bool]) -> list[str]: + """`gone(본뜬 키)` 인 이 층 SC · SK 엑셀 사본 걷음 → 걷은 문서 키.""" folder, out = Path(folder), [] here = refs.where(folder) @@ -120,8 +115,7 @@ def forget(folder: str | Path, gone: Callable[[str], bool], apply: bool = True) new["본뜬"]["또"] = also # 777-1 같은 내용 SC 를 나눠 쓴 다른 불러오기 몫은 그대로 if new != doc: out.append(path.stem) - if apply: - atomic_write_json(path, new) + atomic_write_json(path, new) return out @@ -150,46 +144,3 @@ def sweep(folder: str | Path, now: datetime | None = None) -> list[str]: for key in (got := expired(folder, now)): finish(folder, key) return got - - -# ── 옛 파일 정리(한 번) ─────────────────────────────────────────────── -def tidy(folder: str | Path, apply: bool = False) -> list[dict[str, str]]: - """옛 실무자료 정리 표 `[{할일, 대상}]` — `apply` 거짓 = 미리 보기(쓰기 없음).""" - folder = Path(folder) - home = folder / hopyo_store.DIRNAME - rows: list[dict[str, str]] = [] - every = sorted(p.stem for p in home.glob("HP-*.json")) - old = [k for k in every if not (hopyo_store._load(home / f"{k}.json") or {}).get("지문")] - ended = [*old, *expired(folder)] - live = set(every) - set(ended) - for key in ended: - rows.append({"할일": "HP 끝냄(옛 · 하루 지남)", "대상": f"{hopyo_store.DIRNAME}/{key}"}) - if apply: - finish(folder, key) - log = hopyo_store.done(folder) - if log["지문"]: - rows.append({"할일": f"끝낸 기록 지문 {len(log['지문'])} 비움", "대상": "불러옴.json"}) - if apply: - hopyo_store._put_done(folder, {"번": log["번"]}) - - def gone(mark: str) -> bool: - m = _HP.match(mark) - return bool(m) and m.group(1) not in live - - for key in forget(folder, gone, apply): - rows.append({"할일": "엑셀 사본 걷음(출처만)", "대상": key}) - return rows - - -def main(argv: list[str]) -> int: - apply = "--apply" in argv - for one in [a for a in argv if a != "--apply"]: - rows = tidy(one, apply) - print(f"# {one} — {'고침' if apply else '미리 보기'} {len(rows)}") - for row in rows: - print(f"{row['할일']}\t{row['대상']}") - return 0 - - -if __name__ == "__main__": - sys.exit(main(sys.argv[1:])) diff --git a/M02_MasterTemplete/M02_Hopyo_Store.py b/M02_MasterTemplete/M02_Hopyo_Store.py index f8e28d3e1..6baa1b0e0 100644 --- a/M02_MasterTemplete/M02_Hopyo_Store.py +++ b/M02_MasterTemplete/M02_Hopyo_Store.py @@ -6,7 +6,7 @@ 층 종류(`layers.KINDS`) 밖 폴더 — 양식 목록 · 복사 · 프로젝트 씨앗에 안 섞임 · 권한은 길 몫. 한시 불러오기(718-1 · 743-1) — 파일에 `지문`(올린 엑셀 sha256) · 목록 = 지문 있고 하루 안 지난 것 (작업 중)만 · 옛 HP · 하루 지난 HP 는 목록에서 숨김(지움 = `M02_Hopyo_Forget`) · -`실무자료/불러옴.json` `{번}` = 낸 키 가장 큰 번(지운 뒤에도 키를 다시 안 씀 · 옛 `지문` 안 읽음). +`실무자료/불러옴.json` `{번}` = 낸 키 가장 큰 번(지운 뒤에도 키를 다시 안 씀). 판(776-2) = 읽기 꼴(Book) 판 `BOOK` 을 HP 에 찍음 · 다른 판 = 지난 것(목록에서 숨김 · 다음 올림 때 끝냄 · 작업 중 열기 = 409 「다시 올림」 · 옛 꼴 읽기 갈래 없음). """ @@ -95,11 +95,9 @@ def rows(folder: str | Path) -> list[dict[str, Any]]: def done(folder: str | Path) -> dict[str, Any]: - """키 번 기록 `{번, 지문}`(지문 = 743 전 끝낸 기록 · 안 읽음 · 정리 `Forget.tidy`).""" + """키 번 기록 `{번}`.""" doc = _load(_dir(folder) / f"{DONE}.json") - doc = doc if isinstance(doc, dict) else {} - marks = doc.get("지문") - return {"번": int(doc.get("번") or 0), "지문": marks if isinstance(marks, dict) else {}} + return {"번": int((doc if isinstance(doc, dict) else {}).get("번") or 0)} def _put_done(folder: str | Path, got: dict[str, Any]) -> None: diff --git a/resources/tester/test_743_1_hopyo_forget.py b/resources/tester/test_743_1_hopyo_forget.py index accf207e9..248ce1de8 100644 --- a/resources/tester/test_743_1_hopyo_forget.py +++ b/resources/tester/test_743_1_hopyo_forget.py @@ -103,7 +103,7 @@ def test_끝내기_남는_파일_0_금액_그대로_출처만_다시_올림(clie assert not {"키", "원본", "확인", "품셈", "갈래", "엑셀품", "못옮김", "또"} & set(got) lines = doc.get("담은로직") or [] assert not any(str(x.get("메모", "")).startswith("실무 ") for x in lines) - assert hs.done(folder)["지문"] == {} # 끝낸 기록 없음 + assert hs.done(folder) == {"번": 1} # 끝낸 기록 없음 · 번만 again = _post(client) # 같은 엑셀 다시 올림 = 새 키(409 없음) assert again.status_code == 200 and again.json()["키"] == "HP-000002" @@ -121,31 +121,3 @@ def test_하루_지난_HP_목록_숨김_올림_때_지움(client): got = _post(client).json() # 같은 엑셀이어도 지난 것 = 지우고 새로(이어서 아님) assert got["키"] == "HP-000002" and not got.get("이어서") assert _files(folder) == ["HP-000002.json"] * 3 # 이번 것 + 격자 + 산근 시트(793-3b) - - -def test_옛_파일_정리_미리_보기_쓰기_0_고침(client): - folder = layers.personal_dir(7, 42) - assert _post(client).json()["키"] == "HP-000001" # 작업 중 — 그대로 - home = folder / hs.DIRNAME - (home / "HP-000007.json").write_text(json.dumps({"키": "HP-000007", "호표": []}), "utf-8") - hs._put_done(folder, {"번": 7, "지문": {"ab": {"파일": "옛.xls", "만든": ["SC-000001"]}}}) - (folder / "precombo").mkdir(exist_ok=True) - gone = {"이름": "옛", "단위": "개", "담은로직": [{"로직": "L", "메모": "실무 1개 × 1"}], - "본뜬": {**HEAD, "키": "HP-000005 제1호표", "확인": SURE}} # fmt: skip - live = {**gone, "본뜬": {**HEAD, "키": "HP-000001 제1호표", "확인": SURE}} - for key, doc in (("SC-000001", gone), ("SC-000002", live)): - text = json.dumps(doc, ensure_ascii=False) - (folder / "precombo" / f"{key}.json").write_text(text, "utf-8") - snap = {p: p.read_bytes() for p in folder.rglob("*.json")} - - rows = forget.tidy(folder) - assert [r["대상"] for r in rows] == ["실무자료/HP-000007", "불러옴.json", "SC-000001"] - assert {p: p.read_bytes() for p in folder.rglob("*.json")} == snap # 미리 보기 = 쓰기 0 - - assert forget.tidy(folder, apply=True) == rows - assert _files(folder) == ["HP-000001.json"] * 3 - assert hs.done(folder) == {"번": 7, "지문": {}} - docs = _docs(folder, "precombo") - assert "키" not in docs["SC-000001"]["본뜬"] and "메모" not in docs["SC-000001"]["담은로직"][0] - assert docs["SC-000002"] == live # 작업 중 HP 것 그대로 - assert forget.tidy(folder) == [] # 두 번째 = 할 일 없음 From b42418dde942ed27348e7bfed2571fda7a8331c2 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 05:06:52 +0900 Subject: [PATCH 05/13] =?UTF-8?q?refactor(857-5):=20=EA=B0=80=EC=A0=B8?= =?UTF-8?q?=EC=98=A8=20=EC=8B=9D=20=EC=98=9B=20=EC=A4=84=20=EB=B9=88=20?= =?UTF-8?q?=EA=BB=8D=EB=8D=B0=EA=B8=B0=20Sangeun=5FImported.row=5Fof=20?= =?UTF-8?q?=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 857-3b 부터 늘 None · 부르는 곳 0(Item_Source.row_of · Sangeun_Block 은 다른 함수) - San_MyMachine 머리 글의 옛 이름 걷음 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_San_MyMachine.py | 2 +- M02_MasterTemplete/M02_Sangeun_Imported.py | 5 ----- 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/M02_MasterTemplete/M02_San_MyMachine.py b/M02_MasterTemplete/M02_San_MyMachine.py index ea626a4a8..51f014197 100644 --- a/M02_MasterTemplete/M02_San_MyMachine.py +++ b/M02_MasterTemplete/M02_San_MyMachine.py @@ -13,7 +13,7 @@ 구성 없음 → 직접(그 파일 시간당 노 · 재 · 경). 잇기(`attach` · 층 저장 길 `M02_Sangeun_FromHopyo.make` 만) = 그 층 내 기계 같은 이름 · 규격이면 그 줄 · 없으면 새로(`M02_MyMachine.create`) · 바로 = 기계 줄 이음 키 · 로직 줄 = 시간당 부름 글 / 직접 = 이음 없이 자원 - `내기계` 키(셈 = 그 파일 값 · [우리 단가로] = 내 기계 시간당 · `M02_Sangeun_Imported.row_of`) · + `내기계` 키(셈 = 그 파일 값 · [우리 단가로] = 내 기계 시간당) · 원본 `내기계` [{키, 이름, 규격, 새로}] · 개인 층 아님 = 안 만듦(원본 `내기계예정` [{이름, 규격}] 만). 금액(엑셀 단가 그대로)은 줄 값을 안 건드려 그대로. 기계 한 대 안 여러 줄(842-4) = 구성에 `인력줄` [[직종 글, 인]] · `연료줄` [[종류, ℓ]] · `잡품줄` [율 %] · `재료줄` [[이름, 수량, 단위]] diff --git a/M02_MasterTemplete/M02_Sangeun_Imported.py b/M02_MasterTemplete/M02_Sangeun_Imported.py index 28759dabc..5a7a6688a 100644 --- a/M02_MasterTemplete/M02_Sangeun_Imported.py +++ b/M02_MasterTemplete/M02_Sangeun_Imported.py @@ -92,11 +92,6 @@ def hourly_of(key: str) -> dict: return _HOURLY["rows"][key] -def row_of(doc: Any) -> None: - """옛 가져온 줄(엔진 로직 줄) — 857-3b 부터 저장 안 함 · 읽지 않음(늘 None · 2-D 가 부름 걷음).""" - return None - - def base_row(doc: dict) -> dict[str, Any]: """바탕 없는 SK 바탕 줄(`sd.empty_row`) — 입력 · 줄 없음 · 가져온 식 결과단위 = 문서 결과단위(1 단위 배).""" first = (doc.get(KEY) or {}).get(FIRST) if isinstance(doc.get(KEY), dict) else None From 455542231169a7a51487e8ab88dbe13c8a6afecb Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 05:06:53 +0900 Subject: [PATCH 06/13] =?UTF-8?q?test(857-5):=20=EB=B6=88=EB=9F=AC?= =?UTF-8?q?=EC=98=A4=EA=B8=B0=20=EC=86=8C=EC=8A=A4=20=EA=B8=80=EC=9E=90=20?= =?UTF-8?q?=EC=8B=9C=ED=97=98=20=EC=A0=95=EB=A6=AC=20=E2=80=94=20=ED=99=94?= =?UTF-8?q?=EB=A9=B4=20=C2=B7=20=EB=9D=BC=EC=9A=B0=ED=84=B0=20=EA=B8=80=20?= =?UTF-8?q?=EC=9D=BD=EA=B8=B0=20=EC=A7=80=EC=9B=80=20=C2=B7=20=EB=8F=99?= =?UTF-8?q?=EC=9E=91=20=EC=8B=9C=ED=97=98=EB=A7=8C=20=EB=82=A8=EA=B9=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 지움(파일): test_m02_hopyo_screen · test_785_4_import_screen — 전부 TS 소스 글 포함 확인(CLAUDE.md 4 장 금지 꼴) - 그 부분만 지움: test_837_1(라우터 · TS 글 셋 · 층 고정 동작 시험 남김) · test_793_3b(TS 글 셋 · 서버 길 시험 남김) · test_627(TS 글 둘 · node 동작 시험 남김) · test_807_1(원문 찾기 TS 글 하나) - 화면 동작은 ORCA 화면 한 바퀴로 확인(올림 · 칠 · [수정] · [내 일위대가로] · 가져온 식 두 판 · 저장 · 다시 열기 · 고를 재료) Co-Authored-By: Claude Opus 5.5 --- resources/tester/test_627_sheet_sk.py | 44 +---------- resources/tester/test_785_4_import_screen.py | 75 ------------------- resources/tester/test_793_3b_import_screen.py | 54 ------------- resources/tester/test_807_1_import_doc_one.py | 13 ---- .../tester/test_837_1_import_personal_only.py | 23 ------ resources/tester/test_m02_hopyo_screen.py | 58 -------------- 6 files changed, 4 insertions(+), 263 deletions(-) delete mode 100644 resources/tester/test_785_4_import_screen.py delete mode 100644 resources/tester/test_m02_hopyo_screen.py diff --git a/resources/tester/test_627_sheet_sk.py b/resources/tester/test_627_sheet_sk.py index 65bd93327..7b031662e 100644 --- a/resources/tester/test_627_sheet_sk.py +++ b/resources/tester/test_627_sheet_sk.py @@ -3,18 +3,14 @@ 서버 없이 잡음: 탭(역할) 따라 판 바꿈(일위대가표 = 호표 목록 · 단가산출 탭 = 단가산출 목록 · 칸은 처음 한 번만 지음) · 시트 행 → 목록 강조 · 목록 줄 → 지금 탭의 블록 자리 + 개인 층 가져온 식 모달(835-1 · [내 단가산출로] 단추 걷음) · 줄 끝 [가져온 식으로 열기](809-1 · 판정 블록 판 걷음) · -[끝내기] = 막지 않고 물음창 글만 · -화면 = 부품 상자만 · 700 줄. +[끝내기] = 막지 않고 물음창 글만. """ import json import os -import re import subprocess -from pathlib import Path HERE = os.path.dirname(__file__) -M02 = Path(__file__).resolve().parents[2] / "M02_MasterTemplete" def _node(payload: dict) -> dict: @@ -59,7 +55,9 @@ def test_판_바꿈_목록_지음_강조_뛰기(): assert got["opened"] == [{"no": 8, "canWrite": True, "to": "personal"}] * 6 rows = {r["label"]: r for r in got["rows"]} assert rows["단산8 거푸집"]["sub"] == "㎡ · M02_JudgeCalls 1" - assert rows["단산8 거푸집"]["tail"] == [] # 만들 층 = 개인 → [가져온 식으로 열기] 숨김 · 저장 단추 없음 + assert ( + rows["단산8 거푸집"]["tail"] == [] + ) # 만들 층 = 개인 → [가져온 식으로 열기] 숨김 · 저장 단추 없음 assert rows["단산9 잡석"]["sub"] == "㎥ · M02_JudgeOutside" assert rows["단산10 운반"]["tail"] == ["success:M02_JudgeMade SK-000001"] assert got["count"] == {"블록": 2, "밖": 1, "줄": 0} # 만든 SK 뺌 @@ -71,37 +69,3 @@ def test_권한_그대로_넘김(): {"no": 8, "canWrite": True, "to": "personal"}, {"no": 8, "canWrite": False, "to": "company"}, ] - - -def _src(name: str) -> str: - return (M02 / f"M02_MasterTemplete_Hopyo_{name}.ts").read_text(encoding="utf-8") - - -def test_캐시_공유_알림_칠_다시(): - sheet = _src("Sheet") - assert "createSheetSk(" in sheet and "sk?.at(s);" in sheet - side = _src("SheetSk") - assert "readHopyoMarks(opt.scope, opt.key, opt.target)" in side # 809-1 블록 칠 재료 목록 - assert ( - "createJudgeBlock" not in side and "createJudgeMove" not in side - ) # 판정 블록 판 · 옮기기 걷음 - nav = _src("SheetNav") - assert "blockAt(sheet: string, row: number)" in nav and "spotOf(no: number, role: Role)" in nav - wizard = _src("Import") - assert ( - 'L("M02_SkUnmoved")' in wizard and "leftCount" not in wizard - ) # 밖 = 안 막음 · 옛 남은 줄 막음 걷음 - tone = (M02 / "logic" / "M02_MasterTemplete_Hopyo_SheetMap.ts").read_text(encoding="utf-8") - assert '글: "일위대가 밖"' in tone - - -def test_부품_상자만_700줄(): - for name in ("SheetSk", "Sheet", "SheetNav", "Import", "Side"): - src = _src(name) - assert len(src.splitlines()) <= 700, name - assert not re.search(r"#[0-9a-fA-F]{3,6}\b|rgb\(", src), name - for name in ("SheetSk", "Import"): - assert not re.search(r'el\("(button|input|select)"| str: - return (M02 / f"M02_MasterTemplete_Hopyo_{name}.ts").read_text(encoding="utf-8") - - -def test_가운데_상세_페이지_없음(): - assert not (M02 / "M02_MasterTemplete_Hopyo_Wizard.ts").exists() - every = "\n".join(p.read_text(encoding="utf-8") for p in M02.glob("*.ts")) - for gone in ("buildHopyoWizard", "HopyoWizard", "wantSangeun", "M02_WizSkCheck", "STEPS"): - assert gone not in every, gone - for key in ("M02_WizSkHead", "M02_WizIlwiHead", "M02_SkHint"): - assert key not in (ROOT / "ui_template" / "ui_template_locale_m2.ts").read_text("utf-8") - - -def test_누름_하나_바로_엑셀(): - side = _src("Side") - choose = side.split("async function choose()")[1].split("input.addEventListener")[0] - assert "input.click();" in choose # [불러오기] = 바로 파일 고르기 창 - change = side.split('input.addEventListener("change"')[1].split("async function leaveOk")[0] - assert "uploadHopyo(MINE, file)" in change and "return show(got, true);" in change - show = side.split("async function show(")[1].split("async function showLedger")[0] - assert "buildHopyoImport({" in show and "opt.show(" in show # 올림 뒤 본 칸 바로 - imp = _src("Import") - assert "m.buildHopyoSheet({" in imp and "headExtra: [finish]" in imp - - -def test_층_가르기_없음_늘_개인(): # 837-1 · 요구 855 — 예전 「결과 층 고름」 걷음 - side, imp = _src("Side"), _src("Import") - for gone in ("createSegment", "writableLayers", "LAYERS", "layerText", "seg.hidden", "pick"): - assert gone not in side, gone - for gone in ("LAYERS", "layerText", "writableLayers", "layerNote", "createBadge"): - assert gone not in imp, gone - assert 'export const MINE: HopyoScope = { layer: "personal", owner: null };' in imp - - -def test_끝내기_머리_막대_끝냄_뒤_빈_본_칸(): - imp = _src("Import") - end = imp.split("async function end()")[1] - assert ( - "skCount()" in end.split("showConfirmDialog(")[0] - ) # 안 만든 단가산출 = 물음 글만(막지 않음) - assert "deleteHopyo(scope, file.키)" in end and "a.onEnded();" in end - side = _src("Side") - assert "onEnded: () => {" in side and "void refresh();" in side - sheet = _src("Sheet") - assert "dropButton" not in sheet and "onDeleted" not in sheet # [삭제] 걷음 - - -def test_부품_상자만_700줄_늘리지_않음(): - for name in ("Import", "Side", "Sheet", "SheetSk"): - src = _src(name) - assert len(src.splitlines()) <= 700, name - assert not re.search(r"#[0-9a-fA-F]{3,6}\b|rgb\(", src), name # 색 = 공통 값 - for name in ("Import", "SheetSk"): - assert not re.search(r'el\("(button|input|select)"| body?.matDirty()" in _src("Import") - assert "location.hash" not in _src("Import") + _src("Side") # 새 해시 열쇠 없음 diff --git a/resources/tester/test_793_3b_import_screen.py b/resources/tester/test_793_3b_import_screen.py index 02986b756..435bfbf35 100644 --- a/resources/tester/test_793_3b_import_screen.py +++ b/resources/tester/test_793_3b_import_screen.py @@ -5,16 +5,10 @@ 블록 → 793-2a 내보내기 → 793-2 가져온 식 SK(만들 층 · 엑셀 단가 그대로 · 검산 = 엑셀) · 같은 내용 = 그 SK 다시 씀 · 산근 없는 옛 HP = 409 · HP 지우면 산근도 지움 · STmate 블록 끝전 = 엑셀 계와 맞는 쪽 -- 화면 소스 — 단가산출 탭 목록 [가져온 식으로 열기](`Hopyo_SheetSk`) · 시트 모달 - (`Sangeun_Detail`) · 머리 판(검산 · [우리 단가로] / [엑셀 단가로] · [원본 글 보기] · - [이음 고르기] · 소요량 이음) · 부품 상자만 · 700 줄 - 809-1 걷음(요구 703) — [우리 기초로 바꾸기] · 근거 세 단 · 입력 필요 · [이 줄에 잇기] · 옮기기 판정 길 없음 임시 storage(`client` 마당) · M01 원본 그대로. """ -import re -from pathlib import Path - import helper_m02_hopyo_golden as golden import pytest @@ -26,15 +20,8 @@ from M02_MasterTemplete import M02_Template_Layers as layers # ruff: noqa: F811 from resources.tester.test_m02_hopyo_excel import _post, client, master_hash # noqa: F401 -ROOT = Path(__file__).resolve().parents[2] -M02 = ROOT / "M02_MasterTemplete" API = "/api/m02/layers/personal" KEY = "HP-000001" -MINE = ("Hopyo_Imported", "Hopyo_ImportedPanel", "Hopyo_SheetSk", "Hopyo_View") - - -def _src(name: str) -> str: - return (M02 / f"M02_MasterTemplete_{name}.ts").read_text(encoding="utf-8") def _skcount() -> int: @@ -97,44 +84,3 @@ def test_STmate_끝전_엑셀_계와_맞는_쪽(tag, code, rule): got = sx.read(path.name, path.read_bytes()) assert got["옵션"]["SAN_TYP"] == xs.RULE[rule] assert any(b["코드"] == code for b in got["산근"]) - - -# ── 화면 소스 ───────────────────────────────────────────────────────── -def test_단산_줄_길_잇기(): - sk, view = _src("Hopyo_SheetSk"), _src("Hopyo_View") - assert "openImported({" in sk and "dataset.skOpen" in sk # 단가산출 탭 목록 = 가져온 식 모달 - assert ( - '"/sangeun/from-hopyo"' not in view and "openImported({" in view - ) # [수정] 단산 줄 = 가져온 식 모달(미리 보기 · 835-1) - imp = _src("Hopyo_Imported") - assert '"/sangeun/from-hopyo/preview"' in imp and '"/sangeun/from-hopyo"' in imp - assert "/sangeun/imported/${how}" in imp - assert "mountSangeunDetail(" in imp and "saveTemplate(" in imp and "openModal({" in imp - for how in ('run("price"', 'run("link"'): - assert how in imp, how - for gone in ("to-base", "toBase", "onLink", "skPick", "checkJudge", "readJudgeBlock"): - assert gone not in imp, gone # 809-1 · 요구 703 - # 옛 M02 수식 나무 화면(「엑셀 원래」 위 줄) 걷음 — 수식 탭 = 공용 수식 문서 화면(802-4b-2) - assert not (M02 / "M02_MasterTemplete_Sangeun_Equation.ts").exists() - - -def test_머리_판_기초_없음(): - panel = _src("Hopyo_ImportedPanel") - for word in ("ToOurs", "ToExcel", "Source", "Link", "Same", "Diff"): - assert f'tx("{word}")' in panel, word - for gone in ("ToBase", "PickBase", "data-basis-tiers", "우리 기초로 바꾸기", "근거 제안"): - assert gone not in panel, gone - model = (M02 / "logic/M02_Hopyo_Imported_Model.ts").read_text(encoding="utf-8") - assert "BasisCand" not in model and "skPick" not in model and "근거후보" not in model - assert not re.search(r"from \"@ui|document\.|fetch\(|sessionStorage\.", model) # 순수 - - -def test_부품상자만_700줄_공용_안_고침(): - for name in MINE: - text = _src(name) - assert len(text.splitlines()) <= 700, name - assert not re.search(r"""\bel\(\s*["'](button|input|select)["']""", text), name - assert not re.search(r"""createElement\(\s*["'](button|input|select)["']""", text), name - assert "#" not in "".join(re.findall(r"color:\s*[^;]+", text)), name - for name in ("Labor_Rows", "Labor_SkEdit", "Sangeun_Detail", "Sangeun_Tabs"): - assert "Hopyo_Imported" not in _src(name), name # 공용 쪽은 새 모달을 모름 diff --git a/resources/tester/test_807_1_import_doc_one.py b/resources/tester/test_807_1_import_doc_one.py index 6c648a3b1..a7dec4b82 100644 --- a/resources/tester/test_807_1_import_doc_one.py +++ b/resources/tester/test_807_1_import_doc_one.py @@ -145,16 +145,3 @@ def test_origin_card_and_clauses(world) -> None: ("임도품셈", "5-1-2", 4), ] assert plain is None # 우리 SK = 카드 없음(원문 먼저) - - -def test_source_find_on_m01_and_m02_panels() -> None: - m02 = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Sangeun_Side.ts").read_text("utf-8") - m01 = (ROOT / "M01_MasterData/M01_MasterData_UI_LogicLab_Side.ts").read_text("utf-8") - assert "createSourceFind" in m02 and "createSourceFind" in m01 - assert "originOf" in m02 - sheet = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Hopyo_Mine.ts").read_text("utf-8") - block = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Hopyo_SheetSk.ts").read_text("utf-8") - assert "/hopyo-build-all" in sheet and "번: h.번" in sheet - assert '{ layer: "personal", owner: null }' in block and "openImported" in block - detail = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts").read_text("utf-8") - assert "], doc);" in detail # 원문 패널에 SK 문서(가져온 머리 · 810-4 가져온보관)를 넘김 diff --git a/resources/tester/test_837_1_import_personal_only.py b/resources/tester/test_837_1_import_personal_only.py index 96d23093d..aa50e77b3 100644 --- a/resources/tester/test_837_1_import_personal_only.py +++ b/resources/tester/test_837_1_import_personal_only.py @@ -21,26 +21,3 @@ def test_불러오기_길_층_고정(monkeypatch): hopyo._root({}, layer, owner, write=True) hopyo._root({}, layer, owner) assert seen == [("personal", None, True), ("personal", None, False)] * 3 - - -def test_라우터_루트_모두_고정_함수(): - src = (ROOT / "M02_MasterTemplete" / "M02_Hopyo_Router.py").read_text(encoding="utf-8") - assert "import _root as _layer_root" in src - assert "_layer_root(" in src.split("def _root(")[1].split("\n\n")[0] - assert src.count("_layer_root(") == 1 # 층 고르는 길은 이 한 곳뿐 - - -def test_단산_블록_만들기_개인_층만(): - src = (ROOT / "M02_MasterTemplete" / "M02_Sangeun_Router.py").read_text(encoding="utf-8") - for fn in ("def sangeun_from_hopyo(", "def sangeun_from_hopyo_preview("): - body = src.split(fn)[1].split("\n@router")[0] - assert "body.층" not in body and "_root(session, layer" not in body, fn - assert '_root(session, "personal", None' in body, fn - - -def test_화면_층_고름_없음(): - m02 = ROOT / "M02_MasterTemplete" - side = (m02 / "M02_MasterTemplete_Hopyo_Side.ts").read_text(encoding="utf-8") - imp = (m02 / "M02_MasterTemplete_Hopyo_Import.ts").read_text(encoding="utf-8") - assert "createSegment" not in side and "writableLayers" not in side + imp - assert '"회사"' not in side + imp and '"마스터"' not in side + imp diff --git a/resources/tester/test_m02_hopyo_screen.py b/resources/tester/test_m02_hopyo_screen.py deleted file mode 100644 index eed03d6c1..000000000 --- a/resources/tester/test_m02_hopyo_screen.py +++ /dev/null @@ -1,58 +0,0 @@ -"""일위대가 실무자료 화면(PLAN 324-4 · 718-1 · 785-4) — 좌측 판 자리 · 권한 · 불러오기 본 칸 · [끝내기] · 떠남. - -옛 확인 창 · 고르기 창 · [로직 추가] 「실무 호표」 · 엑셀 보기 모달 시험은 785-7 에서 지움(판정 화면 = `test_642_6_screen`). -""" - -import os -from pathlib import Path - -HERE = os.path.dirname(os.path.abspath(__file__)) -M02 = Path(HERE).parents[1] / "M02_MasterTemplete" - - -def _text(name: str) -> str: - return (M02 / name).read_text(encoding="utf-8") - - -def test_좌측_판_자리와_권한(): - side = _text("M02_MasterTemplete_UI_Side.ts") - assert 'import { buildHopyoSection } from "./M02_MasterTemplete_Hopyo_Side";' in side - host = side.split('className: "m02-side__lists ui-sidebar-panel"')[1] - # 716-3 차례 — 일위대가 › 구조물 조합 › 구분선 › 일위대가 불러오기 › 도면 양식 - order = ("precomboSec,", "summary,", "createDivider(),", "section(hopyo.title, hopyo.body),") - assert [host.index(k) for k in order] == sorted(host.index(k) for k in order) - assert host.index("section(hopyo.title, hopyo.body),") < host.index("drawing,") - assert "canWrite: opt.canWrite," not in side # 옛 [별칭 장부] 걷음(815-2) - assert "hopyo.paint();" in side.split("function paint(): void {")[1] - hopyo_side = _text("M02_MasterTemplete_Hopyo_Side.ts") - # 718-1 · 785-4 — 제목 = 화면 글 키 · [불러오기] = 구조물 조합 층 단추 꼴 → 바로 파일 고르기 → 본 칸 불러오기 보기 - assert 'L("M02_HopyoImport")' in hopyo_side and "일위대가 실무자료" not in hopyo_side - start = hopyo_side.split("const start = createButton({")[1].split("start.title")[0] - assert 'label: "불러오기"' in start and 'start.classList.add("m02-layers__btn");' in start - assert "buildHopyoImport({" in hopyo_side and "Hopyo_Wizard" not in hopyo_side - assert not (M02 / "M02_MasterTemplete_Hopyo_Wizard.ts").exists() # 가운데 상세 페이지 없음 - assert "uploadHopyo(" in hopyo_side and "openHopyoSheet" not in hopyo_side - assert "buildHopyoLedger" not in hopyo_side and "data-hopyo-ledger" not in hopyo_side - assert not (M02 / "M02_MasterTemplete_Hopyo_Ledger.ts").exists() # 옛 [별칭 장부] 걷음(815-2) - imp = _text("M02_MasterTemplete_Hopyo_Import.ts") - assert 'accept: ".xls,.xlsx,.estx,.stc"' in hopyo_side # 810-3 · 814-1 원파일도 - assert "input.hidden = true;" in hopyo_side - choose = hopyo_side.split("async function choose()")[1].split("input.addEventListener")[0] - assert "input.click();" in choose # 누름 하나 — 바로 파일 고르기 창 - assert "writableLayers" not in imp + hopyo_side # 837-1 층 고름 걷음 — 늘 개인 층 - assert "uploadHopyo(MINE, file)" in hopyo_side - for gone in ("wantSangeun", "STEPS", "second(", "steps.set", "data-hopyo-sangeun"): - assert gone not in imp + hopyo_side, gone # 중간 걸음 · 단가산출 체크 없음 - - -def test_372_2_저장은_개인_층에_삭제는_화면_층_권한(): - """718-1 — 만들 층 = 올린 층 · [끝내기] 로 올린 파일 지움 → 빈 본 칸(785-4: 엑셀 보기 [삭제] 걷음) · - 743-1 — 떠남(화면 바뀜 · 페이지 닫음) = 쥔 파일 지움.""" - imp = _text("M02_MasterTemplete_Hopyo_Import.ts") - open_ = imp.split("m.buildHopyoSheet({")[1].split("});")[0] - assert "target: scope," in open_ and "canWrite: true," in open_ - assert "onDeleted" not in imp and "dropButton" not in _text("M02_MasterTemplete_Hopyo_Sheet.ts") - assert "a.onEnded();" in imp and "held = false;" in imp - assert 'addEventListener("pagehide", leave)' in imp and " leave,\n" in imp - panel = _text("M02_MasterTemplete_Hopyo_Side.ts") - assert panel.count("open?.imp?.leave()") == 1 and panel.count("open.imp?.leave()") == 1 From 482ef981c063abe24262ce052f2bd7b69da90c62 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 05:32:35 +0900 Subject: [PATCH 07/13] =?UTF-8?q?refactor(856-3):=20=EC=9D=BC=EC=9C=84?= =?UTF-8?q?=EB=8C=80=EA=B0=80=20=EB=8B=A8=EA=B0=80=EC=82=B0=EC=B6=9C=20?= =?UTF-8?q?=EC=A4=84=20=EB=88=84=EB=A6=84=20=3D=20=EC=A4=84=20=EC=8C=93?= =?UTF-8?q?=EA=B8=B0=20=ED=95=9C=20=EA=B8=B8=20=E2=80=94=20=ED=94=84?= =?UTF-8?q?=EB=A1=9C=EC=A0=9D=ED=8A=B8=20=EC=82=AC=EB=B3=B8=EC=9D=80=20?= =?UTF-8?q?=EA=B5=B3=ED=9E=8C=20SK=20=EB=AC=B8=EC=84=9C=20=EB=B3=B4?= =?UTF-8?q?=EA=B8=B0=EB=A7=8C=20=C2=B7=20M01=20=EB=A1=9C=EC=A7=81=20?= =?UTF-8?q?=EC=A4=84=20=EC=B0=BD=20=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 프로젝트 사본(구조물 고르기 카드 · B08 카드) 단가산출 줄 누름 = 사본 참조사본의 굳힌 SK 문서째 줄 쌓기 보기만(memory · 고침 칸 잠김 · 저장 없음 · 층 파일 읽기 0) · 사본에 없으면 알림 - 셈 주입 원본 층 카드 = 그 층 SK 줄 쌓기 읽기만(옛 「프로젝트 사본 줄」 안내 대신) - M01 로직을 바로 담은 줄(저장본 0) = 창 없이 안내 한 줄 · 프로젝트 · 셈 주입 표(늘 보기만)의 [로직 추가] M01 바로 담기 갈래 지움(서버 from-logic 은 project 층 안 받음 · 서버 고침 0) - Labor_RowModal = 자재 모달만 · Labor_LogicMats 고침 손잡이 · setLogicMark · 안 쓰는 글 키 지움 - 시험: 856-0 가짜 DOM 에 사본 보기 · 원본 층 읽기만 · 로직 줄 안내 덧 · 소스 글자 시험(175 · 222-1 · 742-1 · 806-1 둘 · logic_mats) 지움 · 811-1 · mat_marks 는 글자 줄만 지우고 700 줄 · 날 단추 · 서버 ↔ 화면 허용 값 짝 남김 Co-Authored-By: Claude Opus 5.5 --- B08_Quantity/B08_Quantity_UI_Drawing.ts | 4 + .../M02_MasterTemplete_ItemCards.ts | 1 + .../M02_MasterTemplete_ItemSource.ts | 4 +- .../M02_MasterTemplete_Labor_Detail.ts | 3 + .../M02_MasterTemplete_Labor_LogicMats.ts | 91 ++----------- .../M02_MasterTemplete_Labor_MatMarks.ts | 10 -- .../M02_MasterTemplete_Labor_RowModal.ts | 124 +----------------- .../M02_MasterTemplete_Labor_SkEdit.ts | 37 ++++-- .../M02_MasterTemplete_Labor_Table.ts | 54 ++++---- .../M02_MasterTemplete_Labor_Text.ts | 13 +- resources/tester/helper_856_0_sk_screen.cjs | 35 ++++- resources/tester/test_175_precombo_mats.py | 14 -- resources/tester/test_222_1_m02_apart.py | 7 - resources/tester/test_742_1_sc_qty_saved.py | 14 -- resources/tester/test_806_1_labor_view.py | 34 ----- resources/tester/test_811_1_labor_ref.py | 10 -- resources/tester/test_856_0_sk_screen.py | 35 +++-- resources/tester/test_m02_labor_logic_mats.py | 13 -- resources/tester/test_m02_labor_mat_marks.py | 9 -- ui_template/ui_template_item_picker_detail.ts | 8 ++ 20 files changed, 146 insertions(+), 374 deletions(-) diff --git a/B08_Quantity/B08_Quantity_UI_Drawing.ts b/B08_Quantity/B08_Quantity_UI_Drawing.ts index b05c33f84..49650941d 100644 --- a/B08_Quantity/B08_Quantity_UI_Drawing.ts +++ b/B08_Quantity/B08_Quantity_UI_Drawing.ts @@ -22,6 +22,7 @@ import { showToast } from "@ui/ui_template_elements"; import { PART_OF, projectItems, withCopyValues } from "@ui/ui_template_item_picker_project"; import type { EditView } from "@ui/ui_template_item_picker_edit"; import type { LaborDoc } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Api"; +import { lineId } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Calc"; import type { ValueDoc } from "../M02_MasterTemplete/M02_Labor_Values_Model"; import type { EditKind, ItemCardsHandle } from "../M02_MasterTemplete/M02_MasterTemplete_ItemCards"; import type { ItemSource } from "../M02_MasterTemplete/M02_MasterTemplete_ItemSource"; @@ -79,6 +80,9 @@ function sourceOf(projectId: string, folder: string): ItemSource { return { 문서: withCopyValues(labor.줄, values, picks) }; }, calc: () => items.calcLabor(folder), + // 856-3 단가산출 줄 = 사본의 굳힌 SK 문서(`참조사본`) — 줄 쌓기 보기만 + sk: async (ref) => + ((await items.read(folder, "일위대가")) as { 참조사본?: Record> } | null)?.참조사본?.[lineId({ 참조: ref }) ?? ""] ?? null, // prettier-ignore }, }; } diff --git a/M02_MasterTemplete/M02_MasterTemplete_ItemCards.ts b/M02_MasterTemplete/M02_MasterTemplete_ItemCards.ts index d84d38233..5e7dd8077 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_ItemCards.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_ItemCards.ts @@ -333,6 +333,7 @@ export function createItemCards(opts: ItemCardsOptions): ItemCardsHandle { ? { calc: (doc, 수량) => via.calc(at, doc, 수량), readArea: () => src.read("area", at), + ...(via.sk ? { skCopy: via.sk } : {}), // 856-3 사본 단가산출 줄 = 보기만 } : {}), onChanged: (dirty) => laborCard.saver.mark(dirty && laborWritable()), diff --git a/M02_MasterTemplete/M02_MasterTemplete_ItemSource.ts b/M02_MasterTemplete/M02_MasterTemplete_ItemSource.ts index 4e9fb08cc..67be0038a 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_ItemSource.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_ItemSource.ts @@ -12,7 +12,7 @@ import { type Layer, } from "./M02_MasterTemplete_Api_Fetch"; import type { LaborDoc } from "./M02_MasterTemplete_Labor_Api"; -import type { LaborCalc } from "./M02_MasterTemplete_Labor_Calc"; +import type { LaborCalc, LaborRef } from "./M02_MasterTemplete_Labor_Calc"; /** 집계표 열 하나에 딸린 문서 — 구조물 도면 · 면적산출 */ export type ItemPart = "structure" | "area"; @@ -34,6 +34,8 @@ export interface ItemSource { doc: LaborDoc, 수량?: Record, ) => Promise; + /** 프로젝트 사본(856-3) — 단가산출 줄의 굳힌 SK 문서(`참조사본`) · 줄 누름 = 줄 쌓기 보기만 */ + sk?: (ref: LaborRef) => Promise | null>; }; } diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts index 1a563f3e1..e2035e67b 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts @@ -12,6 +12,7 @@ import type { DataColumn } from "@ui/ui_template_data_table"; import type { Layer } from "./M02_MasterTemplete_Api_Fetch"; import type { LaborCalc, LaborDoc } from "./M02_MasterTemplete_Labor_Api"; +import type { LaborRef } from "./M02_MasterTemplete_Labor_Calc"; import { mountLaborTable } from "./M02_MasterTemplete_Labor_Table"; export interface LaborDetailOptions { @@ -32,6 +33,8 @@ export interface LaborDetailOptions { /** 셈 · 면적 자리 주입(142-1 · 고르기 모달 = 프로젝트 복사본) — 없으면 층 길 */ calc?: (doc: LaborDoc, 수량?: Record) => Promise; readArea?: () => Promise<{ 문서: unknown; 판?: string | null }>; + /** 프로젝트 사본(856-3) — 단가산출 줄의 굳힌 SK 문서 · 있으면 그 줄 누름 = 줄 쌓기 보기만 */ + skCopy?: (ref: LaborRef) => Promise | null>; } /** 덧칸 — `cell(n, 열)` = 문서 줄 n 의 값 · `onRow(n)` 참 = 기본 줄 모달 안 엶 */ diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts index 4b9d04872..786cbb4ea 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts @@ -2,34 +2,19 @@ * M02_MasterTemplete_Labor_LogicMats.ts * 자재목록 표의 로직 자재 줄(103-1) — 담은 로직 맨 위 층 재료 줄(서버 calc `줄[].재료`) · 사용자 자재 줄과 같은 칸 * (코드 · 이름 · 규격 · 수량 · 단위 · 가격 다섯 · 단가 / 금액) · 사용자 자재 앞. - * · 삭제 없음 · [바꾸기] = M01 자재품목 표에서 고름(문서 `담은로직[].고름` · 엔진 `choosing`) · 바꾼 줄만 [기본](고름 풂) - * · 금액은 로직 단가 안이라 합에 다시 안 더함(보기만) · 수량은 로직 것(누름 · 알약 없음) - * · 하위 로직 안 재료는 안 보임(엔진이 맨 위 층만 고름) - * · 줄 누름(148-1) = 그 로직 줄 [옵션] 모달(읽기만이면 보기) · [바꾸기] · [기본]은 고칠 때만 + * · 보기만(856-3 — 로직 줄 창 · [바꾸기] · [기본] · 세 칸 고침 걷음 · 일위대가 면적 보기 `Labor_View` 가 씀) + * · 금액은 로직 단가 안이라 합에 다시 안 더함 · 수량은 로직 것 · 하위 로직 안 재료는 안 보임(엔진이 맨 위 층만 고름) * ========================================================================== */ -import { createButton, el } from "@ui/ui_template_elements"; +import { el } from "@ui/ui_template_elements"; 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"; +import type { LaborCalc, LaborRow } from "./M02_MasterTemplete_Labor_Api"; import { lineId } from "./M02_MasterTemplete_Labor_Calc"; import { markCells } from "./M02_MasterTemplete_Labor_MatMarks"; import { moneyCell, PRICE_SLOTS } from "./M02_MasterTemplete_Labor_Rows"; import { tc } from "./M02_MasterTemplete_Labor_Text"; import type { LogicMat } from "./M02_Labor_LogicMats_Model"; -export interface LogicMatHandlers { - /** 줄 누름(148-1) = 그 자재를 낸 로직 줄 [옵션] 모달 — `row` = 담은 로직 차례 */ - open: (row: number) => void; - /** [바꾸기]로 고른 품목 키 — `row` = 담은 로직 차례 · `at` = 호표 차례 · 없으면(읽기만) 단추 칸 없음 */ - swap?: (row: number, at: number, key: string) => void; - /** [기본] — 그 줄 고름 풂 */ - reset?: (row: number, at: number) => void; - /** 세 칸(148-4) — 로직 줄 `자재표시` · 없으면 글만 */ - mark?: (row: number, at: number, key: MatMarkKey, v: string) => void; -} - const num = (v: number | null): string => v === null ? "—" @@ -40,21 +25,14 @@ export function logicMatRows( rows: LaborRow[], calc: LaborCalc | null, wait: boolean, - on?: LogicMatHandlers, ): HTMLElement[] { - return rows.flatMap((row, r) => { + return rows.flatMap((row) => { const line = row.참조 ? undefined : calc?.줄.find((l) => lineId(l) === lineId(row)); - return (line?.재료 ?? []).map((mat) => matRow(row, r, mat, wait, on)); + return (line?.재료 ?? []).map((mat) => matRow(row, mat, wait)); }); } -function matRow( - row: LaborRow, - r: number, - mat: LogicMat, - wait: boolean, - on?: LogicMatHandlers, -): HTMLElement { +function matRow(row: LaborRow, mat: LogicMat, wait: boolean): HTMLElement { const item = mat.품목; const name = item?.이름 ?? mat.이름; const owner = `${row.별칭 ?? row.로직} · ${mat.이름}`; @@ -69,51 +47,8 @@ function matRow( }; const money = moneyCell(mat.단가, mat.금액, wait, tc("Labor_AppliedSum")); money.title = tc("LogicMat_Inside"); - const swap = on?.swap; - const reset = on?.reset; - const tools = swap - ? [ - el("td", { - className: "m02-labrow__move", - children: [ - el("div", { - className: "ui-btn-group", - children: [ - createButton({ - label: tc("LogicMat_Swap"), - variant: "ghost", - onClick: (e) => { - e.stopPropagation(); - openPickTable({ - kind: "재료", - title: `${tc("LogicMat_PickTitle")} · ${mat.이름}`, - seed: headWord(name), - alt: [headWord(mat.이름)], - isCurrent: (x) => String(x["키"]) === item?.키, - onPick: (x) => swap(r, mat.차례, String(x["키"])), - }); - }, - }), - ...(mat.고름 && reset - ? [ - createButton({ - label: tc("LogicMat_Reset"), - variant: "ghost", - onClick: (e) => { - e.stopPropagation(); - reset(r, mat.차례); - }, - }), - ] - : []), - ], - }), - ], - }), - ] - : []; - const tr = el("tr", { - className: `m02-labrow__row m02-labrow__logic-mat${mat.고름 ? " is-picked-mat" : ""}${on ? " is-open" : ""}`, + return el("tr", { + className: `m02-labrow__row m02-labrow__logic-mat${mat.고름 ? " is-picked-mat" : ""}`, attrs: { "data-labor-logic-mat": `${row.로직}|${mat.차례}` }, children: [ el("td", { className: "m02-labrow__code", text: item?.키 ?? "—" }), @@ -146,15 +81,9 @@ function matRow( text: mat.단위, attrs: { "data-label": tc("Labor_Unit") }, }), - ...markCells( - row.자재표시?.[String(mat.차례)] ?? {}, - on?.mark ? (k, v) => on.mark?.(r, mat.차례, k, v) : undefined, - ), + ...markCells(row.자재표시?.[String(mat.차례)] ?? {}), ...PRICE_SLOTS.map(priceCell), money, - ...tools, ], }); - if (on) tr.addEventListener("click", () => on.open(r)); - return tr; } diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_MatMarks.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_MatMarks.ts index ee9fc13b3..26f7710ef 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_MatMarks.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_MatMarks.ts @@ -10,7 +10,6 @@ import { createSelectField, el } from "@ui/ui_template_elements"; import { MAT_MARK_DEFAULT, MAT_MARKS, - type LaborRow, type MatMarkKey, type MatMarks, } from "./M02_MasterTemplete_Labor_Api"; @@ -60,12 +59,3 @@ export function setMark(target: MatMarks, key: MatMarkKey, v: string): void { if (v) (target as Record)[key] = v; else delete target[key]; } - -/** 로직 줄 `자재표시` 한 차례 한 칸 — 빈 차례 · 빈 묶음은 뺌 */ -export function setLogicMark(row: LaborRow, at: number, key: MatMarkKey, v: string): void { - const all = (row.자재표시 ??= {}); - const one = (all[String(at)] ??= {}); - setMark(one, key, v); - if (!Object.keys(one).length) delete all[String(at)]; - if (!Object.keys(all).length) delete row.자재표시; -} diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_RowModal.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_RowModal.ts index b5cebe2f9..d23ffd569 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_RowModal.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_RowModal.ts @@ -1,134 +1,20 @@ /* ============================================================================= * M02_MasterTemplete_Labor_RowModal.ts - * 일위대가표 줄 누름 모달(PLAN 723-2 · 요구서_내역16 2장 4 · 5 · 856-1) — 일위대가표에서 빠진 줄 동작을 모달 안으로. - * · 로직 줄(단가산출 문서 없음) · 셈 주입 줄(프로젝트 사본) = 머리(이름 · 「1 ㎡ 당」 · 옵션 값 · 메모) + 안내 한 줄 - * (856-1 — 옛 단가산출 상세 몸 · [적용] 걷음 · 고침 = 단가산출 줄 쌓기 · 856-3 에서 줄 쌓기 보기로) · - * 로직 자재(바꾸기 · 기본 · 세 칸 · `Labor_LogicMats`) - * · 사용자 자재 줄 = 자재 모달(세 칸 · `Labor_MatTable` 한 줄) + * 일위대가표 사용자 자재 줄 누름 모달(PLAN 723-2 · 요구서_내역16 2장 4 · 5) — 세 칸(`Labor_MatTable` 한 줄) · 가격 다섯 보기. * · 고침 = 그 줄 화면 캐시(저장은 [저장]) · 금액은 표가 다시 셈 → `watch` 로 받아 다시 그림 + * · 단가산출(SK) 줄 = `Labor_SkEdit`(프로젝트 사본 = 보기만) · M01 로직 줄 창은 걷음(856-3) * ========================================================================== */ -import { createBanner } from "@ui/ui_template_banner"; -import { el, showToast } from "@ui/ui_template_elements"; +import { el } from "@ui/ui_template_elements"; import { openModal } from "@ui/ui_template_modal"; -import { createText } from "@ui/ui_template_text"; -import type { ItemLogic } from "./M02_MasterTemplete_Api_Fetch"; -import type { LaborCalc, LaborMat, LaborRow, MatMarkKey } from "./M02_MasterTemplete_Labor_Api"; -import { logicMatRows } from "./M02_MasterTemplete_Labor_LogicMats"; -import { setLogicMark, setMark } from "./M02_MasterTemplete_Labor_MatMarks"; +import type { LaborCalc, LaborMat } from "./M02_MasterTemplete_Labor_Api"; +import { setMark } from "./M02_MasterTemplete_Labor_MatMarks"; import { matTable } from "./M02_MasterTemplete_Labor_MatTable"; import { tc } from "./M02_MasterTemplete_Labor_Text"; -import { valueLine } from "./M02_Labor_Values_Model"; /** 표가 다시 센 답을 받음 — 돌려준 함수 = 그만 받음 */ export type CalcWatch = (fn: (calc: LaborCalc | null) => void) => () => void; -export interface RowModalOptions { - row: LaborRow; - logic: ItemLogic | null; - title: string; - /** 일위대가 머리(이름 · 「1 ㎡ 당」) */ - head: string; - readOnly: boolean; - /** 셈 주입(프로젝트 복사본) — 안내 글이 다름 */ - inject: boolean; - /** 사용자 자재 코드 — 로직 자재 [바꾸기]로 같은 품목 막음 */ - userMats: string[]; - watch: CalcWatch; - /** 고침 뒤 — `again` = 서버 다시 셈(입력 · 고름 · 별도계상) · 아니면 화면만 */ - done: (again: boolean) => void; -} - -const TEXT = { - NoDoc: [ - "M01 로직을 바로 담은 줄 — 단가산출 화면 없음 · 고침은 단가산출로 담아(일위대가 [로직 추가]) 그 줄에서", - "Uses the M01 logic directly — add it as a build-up to edit", - ], - FromSk: [ - "단가산출 「{k}」 에서 담아 온 줄 — 고침은 그 단가산출에서 고쳐 다시 담음", - "Copied from build-up 「{k}」 — edit it there and re-add", - ], - Inject: [ - "프로젝트 사본 줄 — 단가산출 화면 없음 · 수식 고침은 M02 단가산출에서 고쳐 [재생성]", - "Project copy line — edit the build-up in M02 and regenerate", - ], -} as const; -const t = (k: keyof typeof TEXT): string => TEXT[k][0]; - -export function openRowModal(o: RowModalOptions): void { - const row = o.row; - const edit = !o.readOnly; - const info = el("div", { attrs: { "data-row-head": "" } }); - const mats = el("div", { attrs: { "data-row-mats": "" } }); - let calc: LaborCalc | null = null; - - const draw = (): void => { - const values = valueLine(o.logic?.입력 ?? [], row.입력값); - info.replaceChildren( - createText(o.head, "muted", 14), - ...(values.text ? [createText(values.text)] : []), - ...(values.empty - ? [createText(tc("Labor_Empty").replace("{n}", String(values.empty)), "error")] - : []), - ...(row.켜쌓기율 != null - ? [createText(tc("Labor_Layer").replace("{n}", String(row.켜쌓기율)), "muted")] - : []), - ...(row.메모 ? [createText(row.메모, "muted")] : []), - ); - const lead = row.참조 - ? [] - : logicMatRows([row], calc, !calc, { - open: () => undefined, - ...(edit - ? { - swap: (_r: number, at: number, key: string) => { - if (o.userMats.includes(key)) - return showToast(tc("Labor_AlreadyMat").replace("{value}", key), "error"); - row.고름 = { ...row.고름, [String(at)]: key }; - o.done(true); - }, - reset: (_r: number, at: number) => { - if (!row.고름) return; - delete row.고름[String(at)]; - if (!Object.keys(row.고름).length) delete row.고름; - o.done(true); - }, - mark: (_r: number, at: number, key: MatMarkKey, v: string) => { - setLogicMark(row, at, key, v); - o.done(key === "별도계상"); - draw(); - }, - } - : {}), - }); - mats.replaceChildren( - ...(lead.length - ? [el("h4", { text: tc("Labor_Mats") }), matTable({ mats: [], calc, lead })] - : []), - ); - }; - - // 안내 한 줄(856-1) — 로직 줄 = 온 단가산출(`본뜬`) · 셈 주입 = 프로젝트 사본 - const from = row.본뜬 && typeof row.본뜬.이름 === "string" ? row.본뜬.이름 : ""; - const note = createBanner({ - tone: "info", - text: o.inject ? t("Inject") : from ? t("FromSk").replace("{k}", from) : t("NoDoc"), - }); - const stop = o.watch((c) => { - calc = c; - draw(); - }); - openModal({ - title: o.title, - closeLabel: tc("In_Close"), - width: "1100px", - wide: true, - beforeClose: () => (stop(), true), - mount: (body) => body.append(info, note, mats), - }); - draw(); -} - export interface MatModalOptions { mat: LaborMat; watch: CalcWatch; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_SkEdit.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_SkEdit.ts index 73da2c5f3..cac217356 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_SkEdit.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_SkEdit.ts @@ -5,6 +5,8 @@ * · [저장] = 수식 저장(`flush`) → 그 SK 문서 저장(`saveTemplate` · 그 층 · 그 주인) → 닫음 → 부르는 쪽이 일위대가 금액을 다시 셈 * · 그 층을 못 고치면(위 층 · 남의 주인) 읽기만 · [저장] 없음 · 고친 것 있이 닫으면 물음(버리면 수식 캐시도 비움) * · 머리(808-1 · 요구 701-4 · 5) = 단가산출 페이지 머리와 같음 — 보기 고르기 · [단가 갱신] · [재생성] · [저장] · [닫기] + * · 프로젝트 사본(856-3 · `copy`) = 사본의 굳힌 SK 문서째 줄 쌓기 보기만(`memory` · 파일 안 읽음 · 저장 없음) · + * 고침은 M02 단가산출에서 고쳐 [재생성](요구 898 ①) * 짝 모달 = `Labor_RefEdit`(일위조합 SC 줄). * ========================================================================== */ @@ -23,6 +25,8 @@ export interface SkEditOptions { /** 일위대가 머리(이름 · 「1 ㎡ 당」) */ head: string; readOnly: boolean; + /** 프로젝트 사본(856-3) — 그 사본의 굳힌 SK 문서(있으면 보기만 · 파일 안 읽음) */ + copy?: Record; /** 닫힘 — `saved` = 그 SK 문서를 저장함(부르는 쪽이 금액을 다시 셈) */ closed: (saved: boolean) => void; } @@ -39,12 +43,16 @@ export async function openSkEdit(opt: SkEditOptions): Promise { const at = `${layer}/${opt.ref.주인 ?? ""}/${opt.ref.키}`; if (opened.has(at)) return; opened.add(at); - let doc: unknown; - let version: string; + const copy = !!opt.copy; + const readOnly = copy || opt.readOnly; + let doc: unknown = opt.copy; + let version = ""; try { - const got = await readTemplate(layer, "sangeun", opt.ref.키, null, opt.ref.주인); - doc = got.문서; - version = got.판 ?? ""; + if (!copy) { + const got = await readTemplate(layer, "sangeun", opt.ref.키, null, opt.ref.주인); + doc = got.문서; + version = got.판 ?? ""; + } } catch (error) { opened.delete(at); return void showToast(error instanceof Error ? error.message : tc("Load_Failed"), "error"); @@ -72,12 +80,13 @@ export async function openSkEdit(opt: SkEditOptions): Promise { const host = el("div", { attrs: { "data-labor-sk": opt.ref.키 } }); const slot = el("span", { className: "m02-main__tools" }); // 보기 고르기 · [단가 갱신] · [재생성](808-1 · 페이지 머리와 같음) handle = mountSangeunDetail(host, doc, { - layer, - owner: opt.ref.주인, - readOnly: opt.readOnly, - onChanged: (d) => (dirty = d && !opt.readOnly), + // 사본 = 층 읽기 길(굳힌 문서째 셈 · 주인 층 권한 없이) + layer: copy ? "system" : layer, + owner: copy ? null : opt.ref.주인, + readOnly, + onChanged: (d) => (dirty = d && !readOnly), onVersion: (v) => (version = v), // 수식 저장이 파일 판을 바꿈 — 문서 저장이 이어 받음 - mode: "page", // 페이지와 같은 길 — 수식 저장 단추는 이 [저장] 한 번에 모임 + mode: copy ? "memory" : "page", // 페이지와 같은 길 — 수식 저장 단추는 이 [저장] 한 번에 모임 slot, }); const ok = createButton({ @@ -110,13 +119,17 @@ export async function openSkEdit(opt: SkEditOptions): Promise { body.append( createText(opt.head, "muted", 14), createText( - opt.readOnly ? `${tc("Ref_Shared")} · ${tc("Ref_ReadOnly")}` : tc("Ref_Shared"), + copy + ? tc("Ref_Copy") + : opt.readOnly + ? `${tc("Ref_Shared")} · ${tc("Ref_ReadOnly")}` + : tc("Ref_Shared"), "hint", ), host, ); head.append(slot); - if (!opt.readOnly) head.append(ok); // [저장] = 머리 [닫기] 왼쪽 + if (!readOnly) head.append(ok); // [저장] = 머리 [닫기] 왼쪽 }, }); } diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts index cbddeba71..a528f61f5 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts @@ -7,15 +7,16 @@ * 금액 빠짐) → 그 줄 금액 · 합계 바로(짝 셈 `Labor_Calc.settle`) · 구조물 조합 · 공사 알약이 이어지면 그 값이 앞섬 * · 합계 열 = 「기준단위 단가」(줄 1 단위) · 「수량 반영 금액」(× 수량) * · 머리 단추 = [항목 추가](736-1 · 자재는 찾기 창에서 고름 → 자재 목록) · 줄 우클릭 · 줄 끝 ⋯ = 위로 · 아래로 · 별칭 · 삭제 - * · 줄 누름 = 줄 모달(`Labor_RowModal` — 옵션 · 메모 · 켜쌓기율 · 로직 자재 바꾸기 · 세 칸 · 안내 한 줄 · 856-1) · - * 사전조합 참조 줄 = 서고 원본 모달(`Labor_RefEdit`) · 사용자 자재 줄 = 자재 모달(세 칸) + * · 줄 누름 = 단가산출 줄 = 줄 쌓기(`Labor_SkEdit` · 프로젝트 사본 = 굳힌 문서 보기만 · 856-3) · + * 사전조합 참조 줄 = 서고 원본 모달(`Labor_RefEdit`) · 사용자 자재 줄 = 자재 모달(세 칸) · + * M01 로직을 바로 담은 줄 = 안내 한 줄(창 없음 · 새로 안 생김) * · 금액 = 서버 calc(최신 응답만 · 저장 안 함) · [저장]은 UI_Main(서버가 다시 셈) * · 안 이은 고정 줄(729-3) = 격자 위 띠 · [연결](`Labor_Unlinked` — 이음만 · 저장은 [저장]) * 구조물 조합 일위대가(카드 · 열 상세 · PLAN 806-1)도 이 한 부품 — `mode` 없음 = 조합 갈래: 정보 칸(이름 · 구분) * 없음 · 수량 칸 = 수량산출 모달(`Labor_Combo` — 면적산출 잇기) · 규격 열 줄(`Labor_Spec`) · 다이어그램(열 상세) · * 새 줄 수량 = 면적을 따름(빈 값). 단가산출(SK) 참조 줄 누름 = 그 단가산출 문서 모달(`Labor_SkEdit` — 수식 탭 · 저장 = 그 SK). * 811-1(요구 707-1) — 단가산출 줄 = SK 참조 한 행(저장 때 안 펼침) · [로직 추가] M01 기초 = 이 층 SK 사본 · 다른 층 SK = - * 이 층 사본 뒤 참조(`Labor_SkPick`) · 프로젝트 · 셈 주입 = 옛 로직 줄. + * 이 층 사본 뒤 참조(`Labor_SkPick`) · 프로젝트 · 셈 주입 표 = 늘 보기만이라 [로직 추가] 없음(856-3). * ========================================================================== */ import { createButton, createInputField, el, showToast } from "@ui/ui_template_elements"; @@ -49,7 +50,7 @@ import { unlinkedBar } from "./M02_MasterTemplete_Labor_Unlinked"; import { pasteInto } from "./M02_MasterTemplete_Labor_Paste"; import { openLogicPicker, withSangeun } from "./M02_MasterTemplete_Labor_Pick"; import { openRefEdit } from "./M02_MasterTemplete_Labor_RefEdit"; -import { openMatModal, openRowModal } from "./M02_MasterTemplete_Labor_RowModal"; +import { openMatModal } from "./M02_MasterTemplete_Labor_RowModal"; import { tc } from "./M02_MasterTemplete_Labor_Text"; import { insideKeys } from "./M02_Labor_LogicMats_Model"; import { valueLine } from "./M02_Labor_Values_Model"; @@ -333,26 +334,23 @@ export function mountLaborTable( closed: () => alive && recalc(), }); if (row.고정) return; // 고정 줄 = 숫자 그대로(이름 · 별칭은 우클릭) - // 단가산출(SK) 줄 = 그 단가산출 문서 모달(수식 탭 · 806-1) — 셈 주입(프로젝트 복사본)엔 줄 모달(안내 · 856-3 까지) - if (isSkRef(row.참조) && !opt.calc) - return void openSkEdit({ - ref: row.참조, - title: nameOf(row), - head: head(), - readOnly: !edit || row.참조.층 !== opt.layer, - closed: (done) => alive && done && recalc(), // 저장했으면 금액을 다시 셈 - }); - openRowModal({ - row, - logic: logics.get(row.로직) ?? null, + if (!isSkRef(row.참조)) return showToast(tc("Logic_Direct"), "info"); // M01 로직 줄 — 창 없음(856-3) + const ref = row.참조; + const sk = { + ref, title: nameOf(row), head: head(), - watch, - readOnly: !edit, - inject: !!opt.calc, - userMats: cur.자재.map((m) => m.코드), - done: (again) => changed(!again), - }); + readOnly: !edit || ref.층 !== opt.layer, + closed: (done: boolean) => alive && done && recalc(), // 저장했으면 금액을 다시 셈 + }; + // 단가산출(SK) 줄 = 그 단가산출 문서 줄 쌓기(806-1) · 프로젝트 사본 = 굳힌 문서 보기만(856-3) + if (!opt.skCopy) return void openSkEdit(sk); + void opt + .skCopy(ref) + .then( + (copy) => (copy ? void openSkEdit({ ...sk, copy }) : showToast(tc("Sk_NoCopy"), "error")), + failed, + ); } function openMat(i: number): void { const mat = cur.자재[i]; @@ -456,7 +454,7 @@ export function mountLaborTable( changed(); }, }; - /** SK 사본 길(811-1) — M02 층 일위대가 · 조합만(프로젝트 · 셈 주입 = 옛 로직 줄) */ + /** SK 사본 길(811-1) — M02 층 일위대가 · 조합만(프로젝트 · 셈 주입 = 늘 보기만 · [로직 추가] 없음 · 856-3) */ const own: SkPickScope | null = opt.layer !== "project" && !opt.calc ? { layer: opt.layer, owner: library.owner } : null; const addLogic = createButton({ @@ -464,16 +462,12 @@ export function mountLaborTable( variant: "filled", onClick: () => openLogicPicker((x) => { + // 811-1 — M01 기초 = 이 층 SK 사본 참조 한 행(펼치지 않음) if (own) - // 811-1 — M01 기초 = 이 층 SK 사본 참조 한 행(펼치지 않음) - return void skFromLogic(own, x.키).then( + void skFromLogic(own, x.키).then( (r) => r && alive && addRef(r, x.이름 || x.키, null), failed, ); - if (cur.담은로직.some((r) => r.로직 === x.키)) - return showToast(tc("Labor_Already").replace("{value}", `${x.키} ${x.이름}`), "error"); - cur.담은로직.push({ 로직: x.키, 별칭: null, 메모: null, 입력값: {}, 수량: fresh() }); - void loadLogics().then(() => changed()); }, withSangeun(library)), }); @@ -538,7 +532,7 @@ export function mountLaborTable( className: "m01-logic__section-head", children: [ el("h3", { text: tc("Grid_Title") }), - ...(edit && !(combo && opt.card) + ...(edit && own && !(combo && opt.card) ? [el("div", { className: "ui-btn-group", children: [addLogic] })] : []), ], diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts index 7de04947b..2f33a4acd 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts @@ -42,6 +42,15 @@ const TEXT = { "Edits the library original — every structure using it follows", ], Ref_ReadOnly: ["이 층은 고칠 수 없음 — 읽기만", "Read-only layer"], + Ref_Copy: [ + "프로젝트 사본 — 보기만 · 고침은 M02 단가산출에서 고쳐 [재생성]", + "Project copy — view only · edit the build-up in M02 and regenerate", + ], + Sk_NoCopy: ["사본에 이 단가산출 문서가 없음", "This copy has no build-up document"], + Logic_Direct: [ + "M01 로직을 바로 담은 줄 — 단가산출 화면 없음 · 단가산출로 담아 쓰세요(일위대가 [로직 추가])", + "Uses the M01 logic directly — add it as a build-up to view or edit", + ], Lib_SaveFailed: ["저장 못 함", "Save failed"], Ref_Discard: ["저장 안 한 고침을 버리고 닫음?", "Discard unsaved edits?"], Labor_Source: ["원문", "Source"], @@ -109,13 +118,9 @@ const TEXT = { ], Labor_Code: ["코드", "Code"], Labor_Spec: ["규격", "Spec"], - Labor_Already: ["이미 담은 단가산출 기초 — {value}", "Already added — {value}"], Labor_AlreadyMat: ["이미 담은 자재 — {value}", "Already added — {value}"], // 로직 자재(103-1) Labor_InLogicMat: ["로직 자재에 있는 품목 — {value}", "Already a logic material — {value}"], - LogicMat_Swap: ["바꾸기", "Change"], - LogicMat_Reset: ["기본", "Default"], - LogicMat_PickTitle: ["로직 자재 바꾸기", "Change logic material"], LogicMat_Inside: [ "로직 단가 안 금액 — 합계에 다시 안 더함", "Inside the logic price — not added again", diff --git a/resources/tester/helper_856_0_sk_screen.cjs b/resources/tester/helper_856_0_sk_screen.cjs index 85ff67f65..fd8b33809 100644 --- a/resources/tester/helper_856_0_sk_screen.cjs +++ b/resources/tester/helper_856_0_sk_screen.cjs @@ -90,12 +90,13 @@ const input = (o = {}) => { return { root: box("label", { "data-input": o.label ?? "" }, ""), input: i, setError() {} }; }; const modals = []; // 열린 모달 — 제목 · 몸 +const toasts = []; // 알림 글(856-3 M01 로직 줄 안내) const ui = { ui_template_elements: { el, createButton: button, createInputField: input, - showToast() {}, + showToast: (text, kind) => toasts.push([kind, text]), showConfirmDialog: async () => true, }, ui_template_button: { createButton: button }, @@ -112,7 +113,7 @@ const ui = { const head = box("div"); const close = () => {}; o.mount?.(body, close, head); - modals.push({ title: o.title, body, head, actions: o.actions ?? [] }); + modals.push({ title: o.title, body, head, actions: o.actions ?? [], shut: o.beforeClose }); return { close }; }, askConfirm: async () => true, @@ -158,6 +159,7 @@ const screen = { // 서버 부름 — 길 · 몸을 적고 견본 답 const calls = []; +const files = { reads: 0, saves: 0 }; // 층 파일 읽기 · 저장 수 const api = { call: async (p, init) => { calls.push({ path: p, body: init?.body ? JSON.parse(init.body) : null }); @@ -166,8 +168,11 @@ const api = { return { items: [{ ref: "X1", 이름: "견본", 단위: "EA", 값: 1 }] }; // 찾아 넣기(⑤) return {}; }, - readTemplate: async (_l, _k, key) => ({ 문서: { 키: key, 이름: "견본", 단위: "㎡" }, 판: "1" }), - saveTemplate: async () => ({}), + readTemplate: async (_l, _k, key) => ( + files.reads++, + { 문서: { 키: key, 이름: "견본", 단위: "㎡" }, 판: "1" } + ), + saveTemplate: async () => (files.saves++, {}), getActiveLayer: () => "system", getActiveOwner: () => null, }; @@ -366,7 +371,7 @@ async function openSk(doc, opt = {}) { ); out.bands_fail = await bandCase({ doc: null, answer: null, fail: "서버 못 닿음" }, "SK-000004"); - // ② 일위대가 표 줄 누름 — SK 참조 줄 · M01 로직 줄 · 셈 주입(프로젝트 사본) SK 줄 + // ② 일위대가 표 줄 누름 — SK 참조 줄 · M01 로직 줄 · 셈 주입(원본 층 카드) · 프로젝트 사본(856-3 굳힌 SK 문서) const { mountLaborTable } = M("M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts"); const rows = [ { @@ -377,7 +382,9 @@ async function openSk(doc, opt = {}) { }, { 로직: "GC001109", 별칭: null, 메모: null, 입력값: {}, 수량: { 손: 1 } }, ]; - const click = async (calc) => { + const copyDoc = { 키: "SK-000010", 이름: "사본", 단위: "㎡", 수식: { 따로: true, 굳힘: true } }; + const asked = []; + const click = async (calc, copy) => { const res = []; for (let i = 0; i < rows.length; i++) { const t = mountLaborTable( @@ -387,16 +394,21 @@ async function openSk(doc, opt = {}) { mode: "precombo", layer: "system", column: "공통", - readOnly: false, + readOnly: !!calc && !copy, // 셈 주입 카드 = 보기만 · 사본은 표가 열려 있어도 줄 쌓기는 보기만인지 봄 owner: null, onChanged() {}, ...(calc ? { calc: async () => ({ 줄: [], 자재: [] }) } : {}), + ...(copy + ? { skCopy: async (ref) => (asked.push(ref.키), ref.키 === copy.키 ? copy : null) } + : {}), }, ); await settle(); modals.length = 0; stacks.length = 0; calls.length = 0; + toasts.length = 0; + files.reads = files.saves = 0; grid.onRowClick(i); await settle(); const m = modals[0]; @@ -405,16 +417,25 @@ async function openSk(doc, opt = {}) { modal: m ? m.title : null, skModal: m ? all(m.body, (n) => "laborSk" in n.dataset).length : 0, // 그 SK 문서 모달(806-1) stack: s ? { shown: shown(s.root), draws: s.draws.map((d) => d.key) } : null, + memory: s ? s.draws.map((d) => d.memory) : [], + admin: s ? s.opt.admin : null, // 고침 칸(편집) 열림 + save: m ? all(m.head, (n) => n.dataset.button === "Save").length : 0, // [저장] 단추 + files: { ...files }, + toasts: toasts.map((x) => x[0]), body: m ? all(m.body, (n) => "skCover" in n.dataset && shown(n)).length : 0, banners: m ? all(m.body, (n) => "banner" in n.dataset).map((n) => n.dataset.banner) : [], calc: skCalls().length, }); + for (const one of modals) await one.shut?.(); // 닫기(같은 SK 다시 열 수 있게) t.destroy?.(); } return res; }; out.labor = await click(false); out.labor_inject = await click(true); + out.labor_copy = await click(true, copyDoc); + out.labor_copy_asked = asked.slice(); + out.labor_copy_none = await click(true, { ...copyDoc, 키: "SK-999999" }); // ④ M01 로직 상세 그릇 — 기본정보 접힘 + 줄 쌓기 const { buildLabDetail } = M("M01_MasterData/M01_MasterData_UI_LogicLab_Detail.ts"); diff --git a/resources/tester/test_175_precombo_mats.py b/resources/tester/test_175_precombo_mats.py index f42133eaf..073e3e588 100644 --- a/resources/tester/test_175_precombo_mats.py +++ b/resources/tester/test_175_precombo_mats.py @@ -34,20 +34,6 @@ def _save(folder, doc): return key, json.loads((folder / "precombo" / f"{key}.json").read_bytes()) -def test_화면_서고_모드도_자재목록_세_칸_자재_저장(world): # noqa: F811 - """723-2 — 서고 = 일위대가표만(`Labor_Table`) · [항목 추가] 머리(736-1 · 자재 추가 단추 걷음) · 세 칸 = 줄 모달(`Labor_RowModal`).""" - read = lambda name: open(os.path.join(SRC, name), encoding="utf-8").read() # noqa: E731 - detail, lib = ( - read("M02_MasterTemplete_Labor_Detail.ts"), - read("M02_MasterTemplete_Labor_Table.ts"), - ) - modal = read("M02_MasterTemplete_Labor_RowModal.ts") - assert "return mountLaborTable(host, doc, opt);" in detail # 806-1 — 조합도 같은 부품 - assert 'className: "ui-btn-group", children: [addLogic]' in lib and "addMat" not in lib - assert "setLogicMark(row, at, key, v);" in modal and "setMark(o.mat, key, v);" in modal - assert "delete out.자재" not in lib and "delete out.열" in lib - - def test_저장_왕복_고름_자재표시_자재_남음(world): # noqa: F811 line = {"로직": NET, "고름": {"4": NET_ITEM}, "자재표시": {"3": {"자재구분": "관급"}}} mats = [ diff --git a/resources/tester/test_222_1_m02_apart.py b/resources/tester/test_222_1_m02_apart.py index de67ef303..bf391275d 100644 --- a/resources/tester/test_222_1_m02_apart.py +++ b/resources/tester/test_222_1_m02_apart.py @@ -130,13 +130,6 @@ def test_사전조합_안_줄도_별도계상_뺌(): assert got["기준"]["계"] == _kept(raw)["계"] -def test_화면_별도계상_바꾸면_다시_셈(): - # 806-1 — 조합 · 서고 모두 일위대가표 부품 · 세 칸은 줄 모달(`Labor_RowModal`) - modal = open(os.path.join(SRC, "M02_MasterTemplete_Labor_RowModal.ts"), encoding="utf-8").read() - assert 'o.done(key === "별도계상");' in modal # 사용자 자재 · 로직 자재 모두 별도계상만 다시 셈 - assert modal.count('o.done(key === "별도계상");') == 2 - - # ── ③ 원문 여럿 ────────────────────────────────────────────────────── def test_원문_출처는_같은_책_절_모두(): src = inputs.sources(_whole().logic(MIX)) diff --git a/resources/tester/test_742_1_sc_qty_saved.py b/resources/tester/test_742_1_sc_qty_saved.py index 601ae821e..168b1aca7 100644 --- a/resources/tester/test_742_1_sc_qty_saved.py +++ b/resources/tester/test_742_1_sc_qty_saved.py @@ -110,17 +110,3 @@ def test_B09_옛_사본_null_은_그대로_빈_줄(): def _src(name: str) -> str: return open(os.path.join(SRC, name), encoding="utf-8").read() - - -def test_화면_수량_칸_저장_새_줄_1_두_칸(): - table = _src("M02_MasterTemplete_Labor_Table.ts") - assert "const temp = new Map" not in table and "withTemp" not in table # 휘발 칸 걷음 - assert "row.수량 = raw ? { 손: v } : null;" in table and "changed(true);" in table - assert ( - table.count("수량: fresh()") == 4 - ) # 기초 · 참조 · 고정 · 자재 새 줄 = 서고 1 · 조합 면적 따름(806-1) - assert "const fresh = (): LaborRow" in table and "{ ...ONE }" in table - assert 'BasePrice: ["기준단위 단가"' in table and 'QtyAmount: ["수량 반영 금액"' in table - assert 'sum_price: t("BasePrice"), sum: t("QtyAmount")' in table - assert 'NeedQty: ["수량 입력"' in table - assert 'if (!edit || key !== "qty" || n === null) return false;' in table # 읽기 층 못 고침 diff --git a/resources/tester/test_806_1_labor_view.py b/resources/tester/test_806_1_labor_view.py index 8b71e9e41..b66ae49ab 100644 --- a/resources/tester/test_806_1_labor_view.py +++ b/resources/tester/test_806_1_labor_view.py @@ -45,25 +45,6 @@ def test_조합_상세_카드_서고_한_부품(): assert "openQtyModal({" in combo and "linkAreaCell(" in combo and "saveTemplate(" in combo -def test_단가산출_줄은_SK_문서_모달_저장은_그_SK(): - table = _src("M02_MasterTemplete_Labor_Table.ts") - modal = _src("M02_MasterTemplete_Labor_SkEdit.ts") - assert 'ref.키.startsWith("SK-")' in modal # SK 참조 줄만 - assert "if (isSkRef(row.참조) && !opt.calc)" in table # 셈 주입(프로젝트 복사본)엔 옛 줄 모달 - assert "readOnly: !edit || row.참조.층 !== opt.layer," in table # 위 층 SK = 읽기만 - assert re.search(r'readTemplate\(layer, "sangeun", opt\.ref\.키, null, opt\.ref\.주인\)', modal) - assert re.search( - r'saveTemplate\(\s*layer,\s*"sangeun",\s*opt\.ref\.키', modal - ) # 저장 = 그 SK 문서 - assert ( - "mountSangeunDetail(host, doc," in modal and 'mode: "page"' in modal - ) # 수식 탭 부품 그대로 - assert "await handle.flush();" in modal # 수식 저장 먼저 → 문서 저장 - assert "if (!opt.readOnly) head.append(ok);" in modal # 읽기만 = [저장] 없음 - assert "if (opened.has(at)) return;" in modal # 빨리 두 번 눌러도 하나 - assert "closed: (done) => alive && done && recalc()," in table # 저장했으면 금액 다시 셈 - - def test_부품상자만_700줄_명사형(): for name in ( "M02_MasterTemplete_Labor_Table.ts", @@ -119,18 +100,3 @@ def test_옛_판_저장_409(world): with pytest.raises(store.StoreError) as why: store.write("sangeun", key, got["판"], got["문서"]) assert why.value.status == 409 - - -def test_808_1_모달_머리_일원화(): - """808-1(요구 701-4 · 5) — 단가산출 줄 모달 머리 = 페이지 머리(보기 고르기 · [단가 갱신] · [재생성]) · - 로직 줄 모달(저장된 일위대가 줄 = 펼친 로직 줄 · 740-1) = 옛 [옵션] · [단가산출로도 저장] · [항목 추가] · [율 줄 추가] 없음 · - 보기 고르기 없이 상세만 + 안내(온 단가산출) · 줄 문서 키 SK-000000 = 수식 문서 안 읽음(404 없음).""" - sk = _src("M02_MasterTemplete_Labor_SkEdit.ts") - assert "slot,\n" in sk and "head.append(slot);" in sk - row = _src("M02_MasterTemplete_Labor_RowModal.ts") - for gone in ("AlsoSk", "createCheckbox", "openLaborInput", "saveAsSk", "Labor_Option"): - assert gone not in row, gone - assert 't("FromSk")' in row - detail = _src("M02_MasterTemplete_Sangeun_Detail.ts") - assert "...(opt.slot ? [] : [" in detail # 머리 칸 있으면 머리 줄 없음 - assert "children: [tabs.tools]" in detail and "tabs.picker" not in detail diff --git a/resources/tester/test_811_1_labor_ref.py b/resources/tester/test_811_1_labor_ref.py index ff51e79a9..f4394cb52 100644 --- a/resources/tester/test_811_1_labor_ref.py +++ b/resources/tester/test_811_1_labor_ref.py @@ -122,16 +122,6 @@ def test_마스터_층_단가산출_로직_줄_0(): def test_화면_줄_넣기_SK_사본_참조_부품(): table = _src("M02_MasterTemplete_Labor_Table.ts") pick = _src("M02_MasterTemplete_Labor_SkPick.ts") - assert 'opt.layer !== "project" && !opt.calc ? { layer: opt.layer' in table # 프로젝트 = 옛 길 - assert "return void skFromLogic(own, x.키).then(" in table # M01 기초 = SK 사본 - assert "own && isSkRef(ref)" in table and "void ownSk(own, ref)" in table # 다른 층 = 사본 - assert "if (isSkRef(row.참조) && !opt.calc)" in table # 줄 누름 = SK 수식 모달 - assert "/sangeun/from-logic" in pick and "{ 본뜬 }" in pick and "withSameAsk(" in pick - assert ( - "fetchSessionUser()" in pick - ) # 주인 null = 자기 층 → 서버 참조 꼴(같은 층 SK 를 사본으로 안 만듦) - combo = _src("M02_MasterTemplete_Labor_Combo.ts") - assert "...refCards(doc, calc)" in combo and "key: r.참조.키," in combo # 다이어그램 참조 카드 for text in (table, pick): assert len(text.splitlines()) <= 700 assert not re.search(r"""\bel\(\s*["'](button|input|select)["']""", text) diff --git a/resources/tester/test_856_0_sk_screen.py b/resources/tester/test_856_0_sk_screen.py index 1287c9e5d..d0298c9b0 100644 --- a/resources/tester/test_856_0_sk_screen.py +++ b/resources/tester/test_856_0_sk_screen.py @@ -2,7 +2,7 @@ """PLAN 856-0 — 단가산출 화면 지킴(가짜 DOM · 진짜 코드 · `helper_856_0_sk_screen.cjs`). ① 단가산출 화면을 열 때 서버 `/sangeun/calc` 부름 0(856-2) · 숨은 상세 몸 DOM · 줄 쌓기 그림 -② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 · 셈 주입(프로젝트 사본) 줄 +② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 = 안내 · 프로젝트 사본 = 보기만(856-3) ③ 머리 띠(까닭 · M01 개정 · 빠진 줄)가 뜨는 경우 — 줄 쌓기 셈 답 · 사본 표지 견본(856-2 · 짝 잃음 = 덮개 없음) ④ M01 로직 상세 그릇 = 기본정보 접힘 + 줄 쌓기 ⑤ 줄 쌓기 [+ 줄] 찾아 넣기 — 빈 낱말로 열어도 종류마다 서버 찾기 · 목록이 그려짐(856-F) @@ -44,20 +44,37 @@ def test_sk_page_open_calls_and_hidden_body() -> None: def test_labor_row_click() -> None: sk, logic = _run()["labor"] - # 단가산출 참조 줄 = 그 SK 문서 모달 · 줄 쌓기가 그 키로 보임 + # 단가산출 참조 줄 = 그 SK 문서 모달 · 줄 쌓기가 그 키로 보임 · 고칠 수 있음([저장] 있음) assert sk["skModal"] == 1 and sk["stack"]["shown"] is True assert sk["stack"]["draws"] == ["SK-000010"] and sk["calc"] == 0 - # M01 로직 줄 = 줄 모달(안내 한 줄) · 상세 몸 · 줄 쌓기 · 셈 없음(856-1) - assert logic["skModal"] == 0 and logic["stack"] is None - assert logic["body"] == 0 and logic["banners"] == ["info"] and logic["calc"] == 0 + assert sk["admin"] is True and sk["save"] == 1 and sk["files"] == {"reads": 1, "saves": 0} + # M01 로직 줄 = 창 없음 · 안내 알림 한 줄(856-3) · 셈 없음 + assert logic["modal"] is None and logic["stack"] is None + assert logic["toasts"] == ["info"] and logic["calc"] == 0 def test_labor_row_click_inject() -> None: sk, logic = _run()["labor_inject"] - # 셈 주입(프로젝트 사본) = 줄 모달 · 안내 한 줄(856-3 까지) · 셈 없음 - for row in (sk, logic): - assert row["modal"] and row["stack"] is None - assert row["body"] == 0 and row["banners"] == ["info"] and row["calc"] == 0 + # 셈 주입 원본 층 카드(보기만 표) = 그 층 SK 줄 쌓기 읽기만 · [저장] 없음 + assert sk["skModal"] == 1 and sk["stack"]["draws"] == ["SK-000010"] + assert sk["admin"] is False and sk["save"] == 0 and sk["files"]["saves"] == 0 + assert logic["modal"] is None and logic["toasts"] == ["info"] + + +def test_labor_row_click_project_copy() -> None: + got = _run() + sk, logic = got["labor_copy"] + # 856-3 프로젝트 사본 = 그 사본의 굳힌 SK 문서째 줄 쌓기 보기만 — 빈 키 + 문서째(memory) · + # 고침 칸 잠김 · [저장] 없음 · 층 파일 읽기 · 저장 0 · 서버 셈 길 0 + assert sk["skModal"] == 1 and sk["stack"]["shown"] is True + assert sk["stack"]["draws"] == [""] and sk["memory"] == [True] + assert sk["admin"] is False and sk["save"] == 0 + assert sk["files"] == {"reads": 0, "saves": 0} and sk["calc"] == 0 + assert got["labor_copy_asked"] == ["SK-000010"] + assert logic["modal"] is None and logic["toasts"] == ["info"] + # 사본에 그 문서가 없음 = 창 없음 · 알림(error) + none = got["labor_copy_none"][0] + assert none["modal"] is None and none["toasts"] == ["error"] def test_head_bands() -> None: diff --git a/resources/tester/test_m02_labor_logic_mats.py b/resources/tester/test_m02_labor_logic_mats.py index 934fabbc2..9bf93cef2 100644 --- a/resources/tester/test_m02_labor_logic_mats.py +++ b/resources/tester/test_m02_labor_logic_mats.py @@ -142,16 +142,3 @@ def test_입력이_바뀌면_걸린_고름만_풂_화면_짝(): def _src(name): with open(os.path.join(HERE, "..", "..", "M02_MasterTemplete", name), encoding="utf-8") as f: return f.read() - - -def test_로직_자재_줄_누름은_그_로직_옵션_모달_사용자_줄은_그대로(): - """148-1 — 고칠 때 · 읽기만 둘 다 `open: openRow` · 바꾸기 단추 칸은 swap 있을 때만 · 사용자 줄 = openMat.""" - # 806-1 — 조합 · 서고 모두 일위대가표 부품 — 로직 자재 바꾸기 · 세 칸은 줄 모달(`Labor_RowModal`) 안 - modal = _src("M02_MasterTemplete_Labor_RowModal.ts") - assert ( - "open: () => undefined," in modal and "swap: (_r: number, at: number, key: string)" in modal - ) - mats = _src("M02_MasterTemplete_Labor_LogicMats.ts") - assert "const tools = swap" in mats - assert 'tr.addEventListener("click", () => on.open(r))' in mats - assert '${on ? " is-open" : ""}' in mats diff --git a/resources/tester/test_m02_labor_mat_marks.py b/resources/tester/test_m02_labor_mat_marks.py index 4e2bf0a5f..a59752ae9 100644 --- a/resources/tester/test_m02_labor_mat_marks.py +++ b/resources/tester/test_m02_labor_mat_marks.py @@ -118,15 +118,6 @@ def _src(name): def test_화면_칸_부품_사용자_줄_로직_줄_같은_칸(): - marks = _src("M02_MasterTemplete_Labor_MatMarks.ts") - assert '"—"' not in marks # 「—」 항목 없음(162-1) - assert "e.stopPropagation()" in marks # 줄 누름과 따로 - rows = _src("M02_MasterTemplete_Labor_MatTable.ts") # 717-3 자재목록 표 나눔 - assert "...markCells(mat, on?.mark" in rows and "...markHeads()," in rows - assert "...markCells(" in _src("M02_MasterTemplete_Labor_LogicMats.ts") - modal = _src("M02_MasterTemplete_Labor_RowModal.ts") # 806-1 — 조합 · 서고 모두 줄 모달 안 - assert "mark: (_r: number, at: number, key: MatMarkKey, v: string)" in modal - assert "mark: (_i, key, v) =>" in modal # 서버 허용 값 = 화면 허용 값 api = _src("M02_MasterTemplete_Labor_Api.ts") for key, allowed in labor.MARKS.items(): diff --git a/ui_template/ui_template_item_picker_detail.ts b/ui_template/ui_template_item_picker_detail.ts index 9553767a2..2df87d9ce 100644 --- a/ui_template/ui_template_item_picker_detail.ts +++ b/ui_template/ui_template_item_picker_detail.ts @@ -18,6 +18,7 @@ import { readTemplate } from "../M02_MasterTemplete/M02_MasterTemplete_Api_Fetch import { formatMoney } from "../common_util/common_util_money"; import { dateText } from "../common_util/common_util_time"; import { calcLabor, type LaborDoc } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Api"; +import { lineId } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Calc"; import type { EditKind, ItemCardsHandle } from "../M02_MasterTemplete/M02_MasterTemplete_ItemCards"; import type { ItemSource } from "../M02_MasterTemplete/M02_MasterTemplete_ItemSource"; import type { ValueDoc } from "../M02_MasterTemplete/M02_Labor_Values_Model"; @@ -193,6 +194,13 @@ export function createItemDetail(opts: ItemDetailOptions): ItemDetail { return { 문서: labor?.줄 ? withCopyValues(labor.줄, values, picks) : {} }; }, calc: () => calcCopy(at), + // 856-3 단가산출 줄 = 사본의 굳힌 SK 문서(`참조사본`) — 줄 쌓기 보기만 + sk: async (ref) => { + const labor = (await readCopy(at, "일위대가")) as { + 참조사본?: Record>; + } | null; + return labor?.참조사본?.[lineId({ 참조: ref }) ?? ""] ?? null; + }, }, }; } From 84c27e7a3ec2252b1fade286260ea4970d01f039 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 05:41:47 +0900 Subject: [PATCH 08/13] =?UTF-8?q?refactor(855-E=202-E1):=20/logic=20=C2=B7?= =?UTF-8?q?=20/logic/formula=20=EB=8B=B5=EC=9D=98=20=EC=98=9B=20=EB=8B=A8?= =?UTF-8?q?=EA=B0=80=20=EB=AF=B8=EB=A6=AC=EB=B3=B4=EA=B8=B0(prices)=20?= =?UTF-8?q?=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 읽는 곳 = 옛 상세 몸 재료 · 표 모달뿐(9c7807297 에 걷음) · 서버 모듈 · B08 · B09 0 → Store._prices · _pick_brief · 두 답의 prices 걷음 - 남김: /logic 셈 칸(입력 · 호표 …) · version — 화면 [저장]이 줄째 받아 /save 로 되돌려 씀(L3) - 서버 답 243 건 전후 — prices(139 답) · 지문 말고 다름 0 - 시험: test_m01_api 의 단가 미리보기 단언 셋(한 시험 통째 · 두 시험 그 줄) 걷음 · 관련 1,157(마지막 판) 통과 · 빌더 --check 같음 · typecheck 0 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Store.py | 41 +------------------ M01_MasterData/M01_MasterData_Store_Make.py | 1 - M01_MasterData/M01_MasterData_UI_Logic_Api.ts | 2 - resources/tester/test_m01_api.py | 36 +--------------- 4 files changed, 3 insertions(+), 77 deletions(-) diff --git a/M01_MasterData/M01_MasterData_Store.py b/M01_MasterData/M01_MasterData_Store.py index 3cb80e821..b6b6efb2e 100644 --- a/M01_MasterData/M01_MasterData_Store.py +++ b/M01_MasterData/M01_MasterData_Store.py @@ -390,8 +390,8 @@ def logics(sub: str, detail: str, q: str, blocked: int | None, owner: str = "") def logic(key: str) -> dict: - """로직 하나 — 키는 전체에서 하나 · 있는지 · 파일 · 이름표 = 수식 문서(855 L2 ⓐ) · 셈 칸(입력 · 호표 …) - · `prices` · `version` = 로직 파일(옛 상세 몸 · 저장 짝 — 856 · L3 에서 걷음).""" + """로직 하나 — 키는 전체에서 하나 · 있는지 · 파일 · 이름표 = 수식 문서(855 L2 ⓐ) · + 셈 칸(입력 · 호표 …) · `version` = 로직 파일(화면 [저장]이 줄째 되돌려 씀 — L3 에서 걷음).""" files, whole = loaded() name, doc = _docs().find(key) row = next((r for r in (files.get(name) or {}).get("줄") or [] if str(r.get("키")) == key), {}) @@ -404,7 +404,6 @@ def logic(key: str) -> dict: "logic": row, "blocked": bool(reasons), "reasons": reasons, - "prices": _prices(whole, row), } @@ -418,42 +417,6 @@ def _brief(ref: str, row: dict) -> dict: } -def _pick_brief(whole, cond: dict, unit: str | None = None) -> dict | None: - """고르기 조건 줄의 단가 미리보기 — 후보 수와 시험 계산이 쓸 줄(값 열 다섯 포함). - `unit` = 호표 줄 단위 — 후보를 같은 단위 줄로만 거름.""" - try: - keys = cm.mf.candidates(whole, cond, {}, unit) - brief = _market_brief(whole.get(cm.mf.pick(whole, cond, {}, unit))) - except (cm.mf.FormulaError, KeyError, TypeError): - return None - return {**brief, "조건": cond, "후보": len(keys)} - - -def _prices(whole, row: dict) -> dict: - """호표 요소 → 요소 줄 요약(단가 자동 칸) · `{이름}` 낀 원문번호·하위 로직은 계산 때 정해짐. - 품셈재료는 연결을 따라간 낮은 값과 출처 · 자재지역 후보는 계산 때 정해짐(값 None). - 재료 고르기 조건 줄은 열쇠가 조건 글(`구분|상세구분|규격|대표`) · 값 = 시험 계산이 쓸 줄.""" - out = {} - for item in row.get("호표") or []: - if isinstance(item.get("요소"), dict): - out[cm.mf.cond_text(item["요소"])] = _pick_brief(whole, item["요소"], item.get("단위")) - continue - ref = str(item.get("요소", "")) - if item.get("종류") != "로직" and "{" not in ref: - try: - out[ref] = _brief(ref, whole.get(ref)) - except cm.mf.FormulaError: - out[ref] = None - continue - if ref[:2] == cm.mf.LINKED: - try: - value, source = cm.mf.element(whole, ref, {}) - except (cm.mf.FormulaError, KeyError, TypeError): - value, source = None, None - out[ref].update({"값": value, "출처": source}) - return out - - def elements(group: str, q: str, limit: int) -> dict: """요소 찾기 창 — 그룹 전체에서 키·원문번호·이름 찾기 · `ref` 는 식에 그대로 넣는 키.""" if group not in cm.mf.GROUPS: diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py index 5f1dec18d..2718e60fa 100644 --- a/M01_MasterData/M01_MasterData_Store_Make.py +++ b/M01_MasterData/M01_MasterData_Store_Make.py @@ -404,7 +404,6 @@ def logic_formula(key: str) -> dict: "version": got["version"], "key": key, "소유": got["logic"].get("소유") or "", - "prices": got["prices"], **mcp.spread(master, got["logic"]), } diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Api.ts b/M01_MasterData/M01_MasterData_UI_Logic_Api.ts index 8685767a5..11adb2238 100644 --- a/M01_MasterData/M01_MasterData_UI_Logic_Api.ts +++ b/M01_MasterData/M01_MasterData_UI_Logic_Api.ts @@ -87,7 +87,6 @@ export interface LogicOne { logic: LogicRow; blocked: boolean; reasons: string[]; - prices: Record; } export interface CalcLine { @@ -270,7 +269,6 @@ export interface LogicFormula { version: string; key: string; 소유: string; - prices: Record; 로직: LogicRow; 별칭: FormulaAlias[]; 줄: FormulaLine[]; diff --git a/resources/tester/test_m01_api.py b/resources/tester/test_m01_api.py index 682ef3c23..5082983d2 100644 --- a/resources/tester/test_m01_api.py +++ b/resources/tester/test_m01_api.py @@ -258,8 +258,6 @@ def test_요소_찾기_기계는_구분_상세구분_실림(client: TestClient) def test_단가_자동_요소_찾기_저장전_시험계산(client: TestClient) -> None: one = _get(client, "/api/m01/logic", key=LOGIC_KEY) - labor = one["prices"][key_of("LB:1016")] - assert labor["이름"] == "화약취급공" and labor["값"] > 0 found = _get(client, "/api/m01/elements", group="인력", q="보통인부") assert key_of("LB:1002") in [x["ref"] for x in found["items"]] tables = _get(client, "/api/m01/elements", group="소요량", q="암발파", limit=5) @@ -387,21 +385,11 @@ def test_구분_목록(client: TestClient) -> None: assert steel["details"] -def test_재료_고르기_줄_단가는_검색어_첫째_자재품목의_낮은_값(client: TestClient) -> None: - """옛 대표 키 줄이 기본 검색어로 바뀜(PLAN 8-3) — 값은 검색어 첫째(옛 대표) 줄의 낮은 값.""" - one = _get(client, "/api/m01/logic", key=key_of("GC000628")) - cond = {"구분": "시멘트·골재", "상세구분": "시멘트", "검색어": "시멘트 전국"} - cement = one["prices"][store.cm.mf.cond_text(cond)] - assert cement["ref"] == "MT004176" and cement["값"] > 0 and cement["후보"] >= 1 - - def test_전력은_계약종별을_골라야_값이_섬(client: TestClient) -> None: """후보 조건 「계약종별: 입력」(PLAN 7-4b 뒤 절반 — 품셈재료 간접 없이 호표에 바로 박음) — - 계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인). 화면 단가 미리보기(_pick_brief)는 - 구분·상세구분 자리로만 후보를 찾아 지역·계약종별 조건은 아직 못 다뤄 None — 아는 구멍.""" + 계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인).""" one = _get(client, "/api/m01/logic", key=key_of("GC000893")) cond = {"이름": "전력량요금", "계약종별": "입력"} - assert one["prices"][store.cm.mf.cond_text(cond)] is None assert "전력 계약종별" in {x["이름"] for x in one["logic"]["입력"]} with pytest.raises(store.cm.mf.FormulaError, match="전력 계약종별"): store.cm.mf.element(store.cm.master(), cond, {}) @@ -531,25 +519,3 @@ def test_재료_고르기_후보_다섯_값(client: TestClient) -> None: } assert first["값"] == 18000 and first["관급"] is True # 조달청 100 은 낮은 값에 안 듦 assert second["ref"] == blank["키"] and second["값"] is None - - -def test_로직_고르기_줄_단가_미리보기(client: TestClient) -> None: - """호표 요소가 고르기 조건인 줄 — `prices` 열쇠 = 조건 글 · 후보 수와 값 열 다섯.""" - for path in sorted(store.FOLDER.glob("로직_*.json")): - rows = json.loads(path.read_text(encoding="utf-8"))["줄"] - hit = next( - ( - (row, item["요소"]) - for row in rows - for item in row.get("호표") or [] - if isinstance(item.get("요소"), dict) - ), - None, - ) - if hit: - break - row, cond = hit - got = _get(client, "/api/m01/logic", key=row["키"]) - brief = got["prices"][store.cm.mf.cond_text(cond)] - assert brief["조건"] == cond and brief["후보"] >= 1 - assert set(brief["값들"]) == set(store.cm.mf.SLOTS) From 2bb5a53f1e5610098d5e99126f94b3cdc94eb700 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 06:40:16 +0900 Subject: [PATCH 09/13] =?UTF-8?q?refactor(855-E=20L2=E2=93=91-1):=20?= =?UTF-8?q?=EB=8B=A8=EA=B0=80=EC=82=B0=EC=B6=9C=20=EA=B0=92=20=EC=82=AC?= =?UTF-8?q?=EB=B3=B8=EC=97=90=EC=84=9C=20=EB=A1=9C=EC=A7=81=20=EC=A4=84(GF?= =?UTF-8?q?=20=C2=B7=20GC=20=C2=B7=20GX)=20=EA=B1=B7=EC=9D=8C=20=E2=80=94?= =?UTF-8?q?=20M01=20=EB=B0=94=EB=80=9C=20=3D=20=EC=88=98=EC=8B=9D=20?= =?UTF-8?q?=EB=AC=B8=EC=84=9C=20=EC=A7=80=EB=AC=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 단가산출 값 사본(층 파일 `수식.로직` · 셈 중 `사본.로직`)에 M01 로직 줄을 안 담음 · 옛 저장본의 로직 줄은 읽을 때 뺌(`skc.held` · 다음 [저장] 때 새 꼴 · 호환 없음) · 사본 정함 끝(`settle`) · 층 저장 관문(`Copy_Slim.trim` sangeun) · 따라옴(`Sk_AutoRenew.rows`) · 빈틈(`Doc_Gap`) · 사본없음 셈(`Doc_Sk_Path._rows`) - 부름 로직 줄을 값 사본에 두던 고리 걷음(`Doc_Sk.settle` — 부름 = 문서 사본) - M01 바뀜 표지 = 수식 사본 문서(부름 · 원본) 지문 대조(`skc.mark` · `same_part` · 자동 따라옴 SK 는 안 봄) · 원본 판 = 셈에 쓴 기초 문서(`base_doc`) - 프로젝트 층(자동 따라옴 꺼짐) 굳힘 = 저장 때 `바탕문서`(굳히기 전과 같은 문서 · 옛 자동값 길 그대로) · [재생성] 때 새로 - 일위대가 · 사전조합 값 사본 = 로직 줄 그대로(브레인 (나) — 프로젝트 사본 묶음 `Item_Source.copy_rows` 가 읽음 · B9-6 뒤 `Labor_Copy.stamp` 에서 뺌) - 시험: test_795_1 `_fake` = 가짜 M01 을 M01 꼴 복사로(`skc.Copy` 로 만들면 `dc.base` 가 벗겨 가짜가 사라짐 — 값 사본 로직 줄이 가리던 흠) · ① 값 사본 로직 줄 「없음」 으로 · ⑤ 바탕 로직 지움 갈래 뺌(M01 이 쓰는 로직 지우기 409) · 새 test_855_l2b_copy_plain(저장본 로직 줄 0 · 옛 저장본 로직 줄 안 읽음 · 금액 같음) 검증: 층 서고 SK 14 + SC 6 셈 답 · 표지 다름 0 · m855_sk 14 다름 0 · 다시 저장 파일 로직 줄 6 → 0 · 값 사본 로직 줄 읽힘 14 → 0 · 관련 39 + 지킴 + 핵심 447 통과 · 빌더 같음 · typecheck 0 · 화면 8006 만들기 · M01 고침 따라옴 131,716 · 되돌림 79,279 · 지움 · 콘솔 0 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Copy_Slim.py | 8 ++- M02_MasterTemplete/M02_Doc_Gap.py | 4 +- M02_MasterTemplete/M02_Doc_Sk.py | 22 +++++---- M02_MasterTemplete/M02_Doc_Sk_Path.py | 3 +- M02_MasterTemplete/M02_Sangeun_Copy.py | 55 ++++++++++++++++++--- M02_MasterTemplete/M02_Sk_AutoRenew.py | 4 +- resources/tester/test_795_1_sk_copy.py | 23 ++++++--- resources/tester/test_855_l2b_copy_plain.py | 50 +++++++++++++++++++ 8 files changed, 138 insertions(+), 31 deletions(-) create mode 100644 resources/tester/test_855_l2b_copy_plain.py diff --git a/M02_MasterTemplete/M02_Copy_Slim.py b/M02_MasterTemplete/M02_Copy_Slim.py index 482265429..196b3e4f2 100644 --- a/M02_MasterTemplete/M02_Copy_Slim.py +++ b/M02_MasterTemplete/M02_Copy_Slim.py @@ -7,7 +7,7 @@ 이 문서 셈 = 사본 줄 묶음이 이 문서 사본 안에 드는 색인(남의 SK · SC 참조 셈 = 제 사본 → 안 셈). 파일 꼴 그대로 — 옛 코드는 사본에 없는 줄을 지금 M01 로 읽음(지금 옵션에서 안 읽는 줄 = 금액 같음). 읽은 줄 없음(셈 안 돎) · 프로젝트 층 = 그대로 · 이미 저장된 파일은 다음 [저장] 때 줄어듦. -층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀) · 단가산출 빈 옛 칸 뺌. +층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀 · 단가산출 로직 줄 안 담음 855 L2 ⓑ) · 단가산출 빈 옛 칸 뺌. """ from __future__ import annotations @@ -129,4 +129,10 @@ def trim(kind: str, doc: Any) -> Any: form = out.get(dc.KEY) # 단가산출 · 일위대가 · 사전조합 같은 꼴(SC `수식` = 값 몫 + 부름) if skc.has(out) and isinstance(form, dict) and isinstance(form.get("로직"), list): out[dc.KEY] = {**form, **dc.values_of(out.pop(skc.KEY))} + form = out.get(dc.KEY) + if kind == "sangeun" and isinstance(form, dict) and isinstance(form.get("로직"), list): + out[dc.KEY] = { + **form, + **skc.held({"종류": "단가산출", dc.KEY: form}), + } # 로직 줄 안 씀(855 L2 ⓑ) return out diff --git a/M02_MasterTemplete/M02_Doc_Gap.py b/M02_MasterTemplete/M02_Doc_Gap.py index fbe8b4653..1695a2cf1 100644 --- a/M02_MasterTemplete/M02_Doc_Gap.py +++ b/M02_MasterTemplete/M02_Doc_Gap.py @@ -56,7 +56,8 @@ def gaps(copy: dict) -> list[str]: except dc._ERR: pass have = _have(copy) - return sorted({*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have) + got = {*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have + return sorted(k for k in got if k[:2] not in skc.LOGIC) # 로직 줄 = 문서 사본(855 L2 ⓑ) def fill(copy: dict) -> dict: @@ -78,6 +79,7 @@ def fill_imported(sk: dict, doc: Any) -> dict: seen = _Seen(dim._index(sk, None, doc)) dim.run(doc, sk, index=seen) # 셈 틀림 = 읽은 데까지(run 이 받음) keys = sorted({*seen.keys, *mym.keys_in(doc), *own.keys_in(doc)} - _have(sk[skc.KEY])) + keys = [k for k in keys if k[:2] not in skc.LOGIC] # 로직 줄 안 담음(855 L2 ⓑ) if not keys: return sk return {**sk, skc.KEY: skc.grow(sk[skc.KEY], skc.snap([], keys))} diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index 857649a66..8bcba8554 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -97,8 +97,8 @@ def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]: if renew.on() and live is not None: return dc.doc_of(whole, key), True kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None - if kept: - return cp.deepcopy(kept), True + if kept: # 프로젝트 층 = 굳힐 때 문서 + 옛 자동값(855 L2 ⓑ — 전과 같은 옵션 값) + return cp.deepcopy(kept), renew.on() if live is not None and live.get(mcv.HAND): from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게 @@ -247,7 +247,8 @@ def copy_of(sk: dict, whole: Any = None) -> dict | None: whole = dc.over(values) calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름")) base = str((sk.get("바탕") or {}).get("로직") or "") - seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지) + # 바탕 문서 판(「M01 새 판」 표지) = 셈에 쓴 기초 문서(층 = 지금 M01 · 프로젝트 = `바탕문서` · 855 L2 ⓑ) + seen = base_doc({**sk, KEY: got}, whole, base)[0] if base else None origin = {"원본": {"키": base, "판": dc.doc_fp(seen)}} if seen else {} return {**got, **values, "문서": root, "부름": calls, **origin} @@ -315,17 +316,18 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict: UPPER ): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1) first[UPPER] = have[UPPER] + if not renew.on() and not patched(out): # 프로젝트 층 = 기초 문서 사본으로 굳힘(855 L2 ⓑ ㉣) + kept = None if job == skc.REGEN else (have or {}).get(BASE_DOC) + key = str((out.get("바탕") or {}).get("로직") or "") + if kept is None and key in dc.folder(): + kept = base_doc({**out, KEY: {}}, whole, key)[0] # 굳히기 전과 같은 문서 + if kept: + first[BASE_DOC] = norm(_bare_doc(kept)) copy = copy_of({**out, KEY: first}, whole) if ( copy and skc.READS.get() is not None - ): # 저장 관문 — 문서 셈 · 부름 줄이 읽은 줄을 적음(826-3) + ): # 저장 관문 — 문서 셈이 읽은 줄을 적음(826-3 · 부름 = 문서 사본 · 로직 줄 안 둠 855 L2 ⓑ) run({**out, KEY: copy}, copy, whole) - index = dc.over(copy) - for key in copy.get("부름") or {}: # 부름 문서를 가른 값 사본 줄(`dc.doc_of`)도 둠 - try: - index.logic(key) - except dc._ERR: - pass if ( copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy)) ): # 파생 — 옛 로직 사본에 박음(822-1) diff --git a/M02_MasterTemplete/M02_Doc_Sk_Path.py b/M02_MasterTemplete/M02_Doc_Sk_Path.py index 0611e02e2..fd00e77b1 100644 --- a/M02_MasterTemplete/M02_Doc_Sk_Path.py +++ b/M02_MasterTemplete/M02_Doc_Sk_Path.py @@ -271,7 +271,8 @@ def plain(mine: dict, sk: dict) -> dict: def _rows(copy: dict) -> set[str]: - return {str(r.get("키")) for r in [*(copy.get("로직") or []), *(copy.get("단가") or [])]} + rows = [*skc.plain(copy.get("로직")), *(copy.get("단가") or [])] # 로직 줄 안 셈(855 L2 ⓑ) + return {str(r.get("키")) for r in rows} def _basis(doc: dict, body: dict) -> dict: diff --git a/M02_MasterTemplete/M02_Sangeun_Copy.py b/M02_MasterTemplete/M02_Sangeun_Copy.py index c92cc9cd7..31e99baf1 100644 --- a/M02_MasterTemplete/M02_Sangeun_Copy.py +++ b/M02_MasterTemplete/M02_Sangeun_Copy.py @@ -3,7 +3,9 @@ 사본 = 저장 때 서버가 찍는 M01 닫힌 묶음(`M02_Item_Prices.collect` 다시 씀) — 셈 중 문서 칸 `사본` · 층 저장 파일 = `수식` 의 값 몫 한 벌(`held` · 855 2-D — 파일엔 `사본` 안 씀 · 프로젝트 사본 꼴은 그대로): {판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 줄], 빠진?} - 로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직 · 찾기 표 · 그 밖 요소(요율 등) + 로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직이 닿는 찾기 표 · 그 밖 요소(요율 등) — + 단가산출 = 로직 줄(GF · GC · GX) 자체는 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름` · M01 바뀜 = + 문서 지문) · 일위대가 · 사전조합 = 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 `Labor_Copy.stamp` 에서 뺌) 단가 = 자원 단가 줄(`RES` 노임 · 자재 · 기계 · 유가전력 · 환율) = 단가 기준 시점 묶음. 셈 = M01 색인 위에 사본 줄을 얹은 `Copy`(키 · 원문번호 찾기만 사본 먼저 · M01 색인 안 고침) — `M02_Sangeun_Calc._base_of`(바탕 줄) · `run`(엔진 · 하위 로직 · 표 · 단가)이 `over` 로 부름 · @@ -67,16 +69,31 @@ def has(doc: Any) -> bool: FORM = "수식" # 수식 사본 칸(`M02_Doc_Copy.KEY`) — 층 저장 파일의 값 사본 자리(855 2-D) VALUES = ("판", "시점", "로직", "단가판", "단가시점", "단가") +#: M01 로직 줄 키 머리(GF · GC · GX) — 단가산출 값 사본에 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름`) +LOGIC = frozenset(t for t, g in prices.mf.mk.GROUP_OF.items() if g == "로직") + + +def plain(rows: Any) -> list: + """값 사본 줄에서 로직 줄을 뺌(표 · 요율 · 자원 줄만).""" + return [r for r in rows or [] if not (isinstance(r, dict) and str(r.get("키"))[:2] in LOGIC)] + + +def _plain(copy: dict) -> dict: + """단가산출 값 사본 — 로직 줄 뺀 꼴 · 판 다시(옛 저장본 = 읽을 때 뺌 · 파일은 다음 [저장] 때 새 꼴).""" + rows = plain(copy["로직"]) + return copy if len(rows) == len(copy["로직"]) else {**copy, "로직": rows, "판": _fp(rows)} def held(doc: Any) -> dict | None: """문서의 값 사본 — 셈 · 저장 중 `settle` 이 붙인 `사본` › 층 저장 파일 `수식` 의 값 몫(855 2-D · - 층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 없음 = None.""" + 층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 단가산출 = 로직 줄 뺌(855 L2 ⓑ) · 없음 = None.""" + sk = isinstance(doc, dict) and doc.get("종류") == sd.TITLE if has(doc): - return doc[KEY] + return _plain(doc[KEY]) if sk else doc[KEY] form = doc.get(FORM) if isinstance(doc, dict) else None if isinstance(form, dict) and isinstance(form.get("로직"), list): - return {k: form[k] for k in VALUES if k in form} + got = {k: form[k] for k in VALUES if k in form} + return _plain(got) if sk else got return None @@ -327,7 +344,7 @@ def settle(doc: Any, save: bool = False) -> Any: if save and copy and READS.get() is None: # 읽은 줄만(826-3) = 저장 관문이 더함 copy = grow(copy, stamp(out)) out = _formula_job(out, job) - return {**out, KEY: copy} if copy else out + return {**out, KEY: _plain(copy)} if copy else out # 로직 줄 안 담음(855 L2 ⓑ) def _formula_job(out: dict, job: Any) -> dict: @@ -340,7 +357,14 @@ def _formula_job(out: dict, job: Any) -> dict: if got is None or job not in (PRICE, REGEN): return out if job == REGEN: # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2)도 버림 - drop = ("문서", "끊음", "따로", "처음", *renew.KEEP) + drop = ( + "문서", + "끊음", + "따로", + "처음", + "바탕문서", + *renew.KEEP, + ) # 바탕문서 = 프로젝트 굳힘(855 L2 ⓑ) got = {k: v for k, v in got.items() if k not in drop} | {"부름": {}} elif got.get("따로"): got = dc.refresh(got)[0] @@ -373,7 +397,22 @@ def mark(ans: dict, doc: dict) -> dict: return ans copy = doc[KEY] head = {"시점": copy.get("시점"), "단가시점": copy.get("단가시점")} - return {**ans, KEY: {**head, **state(copy, whole_())}} + got = state(copy, whole_()) + if not got["M01새판"] and _doc_moved(doc): + got = {**got, "M01새판": True} + return {**ans, KEY: {**head, **got}} + + +def _doc_moved(doc: dict) -> bool: + """M01 바뀜 = 수식 사본 문서(부름 · 원본) 지문 ≠ 지금 M01 문서(855 L2 ⓑ · 로직 줄 값 사본 대신) · + 자동 따라옴 SK = 늘 지금 문서라 안 봄.""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Sk_AutoRenew as renew + + form = doc.get(FORM) + if not dc.has(doc) or (renew.is_sk(doc) and renew.on() and not renew.frozen(form)): + return False + return bool(dc.state(form)["문서새판"]) def same_part(doc: Any) -> str | None: @@ -382,5 +421,5 @@ def same_part(doc: Any) -> str | None: if copy is None: return None seen = state(copy, whole_()) - fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"]) + fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"] or _doc_moved(doc)) return None if fresh else f"{copy.get('판')}:{copy.get('단가판')}" diff --git a/M02_MasterTemplete/M02_Sk_AutoRenew.py b/M02_MasterTemplete/M02_Sk_AutoRenew.py index c893a4bb9..c0057bcb5 100644 --- a/M02_MasterTemplete/M02_Sk_AutoRenew.py +++ b/M02_MasterTemplete/M02_Sk_AutoRenew.py @@ -97,9 +97,9 @@ def rows(copy: Any) -> Any: return {**copy, **hit} got: dict = {} for part, mark in (("로직", "판"), ("단가", "단가판")): - old = copy.get(part) or [] + old = skc.plain(copy.get(part)) # 로직 줄 = 문서 사본 · 값 사본에 안 둠(855 L2 ⓑ) new = [_fresh(r, live) if isinstance(r, dict) else r for r in old] - if any(a is not b for a, b in zip(old, new)): + if len(old) != len(copy.get(part) or []) or any(a is not b for a, b in zip(old, new)): got |= {part: new, mark: skc._fp(new)} if len(_MEMO) > 64: # ponytail: 통째 비움 · SK 가 많아 느려지면 LRU 로 _MEMO.clear() diff --git a/resources/tester/test_795_1_sk_copy.py b/resources/tester/test_795_1_sk_copy.py index 1a28585d6..29fc83f18 100644 --- a/resources/tester/test_795_1_sk_copy.py +++ b/resources/tester/test_795_1_sk_copy.py @@ -47,9 +47,18 @@ def _fake(monkeypatch, rows=(), drop=()): from M02_MasterTemplete import M02_Doc_Copy as dc files, live = m01.loaded() - fake = skc.Copy(live, [copy.deepcopy(r) for r in rows]) + fake = copy.copy( + live + ) # M01 꼴 그대로(값 사본 색인 `skc.Copy` 로 만들면 `dc.base` 가 벗김 · 855 L2 ⓑ) + fake.index = {t: dict(v) for t, v in live.index.items()} + fake.numbers = {t: dict(v) for t, v in live.numbers.items()} + for row in rows: + row, key = copy.deepcopy(row), str(row["키"]) + fake.index.setdefault(key[:2], {})[key] = row + if row.get("원문번호"): + fake.numbers.setdefault(key[:2], {})[str(row["원문번호"])] = row for key in drop: - skc.Copy._own(fake.index, live.index, key[:2]).pop(key, None) + fake.index.get(key[:2], {}).pop(key, None) monkeypatch.setattr(m01, "loaded", lambda: (files, fake)) docs = {k: v for k, v in dc.folder().items() if k not in drop} docs |= {str(r["키"]): dc.cv.convert(fake, copy.deepcopy(r))[0] for r in rows if "호표" in r} @@ -93,7 +102,7 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch): me = world["personal"] key = _sk(me, 바탕={"로직": PCT}) got = skc.held(_doc(me, key)) - assert PCT in {r["키"] for r in got["로직"]} + assert PCT not in {r["키"] for r in got["로직"]} # 로직 줄 = 문서 사본(855 L2 ⓑ) assert got["단가"] and all(r["키"][:2] in skc.RES for r in got["단가"]) assert not any(r["키"][:2] in skc.RES for r in got["로직"]) first = _calc(me, _doc(me, key)) @@ -130,17 +139,15 @@ def test_price_refresh_only_on_press(world, monkeypatch): def test_deleted_keys_keep_last_value(world, monkeypatch): - """⑤ 사본이 부르는 M01 키(바탕 로직 · 노임)가 지워져도 마지막 값 · 지운키 표지.""" + """⑤ 사본이 부르는 M01 노임이 지워져도 마지막 값 · 지운키 표지(바탕 로직 = M01 이 지우기 막음 409).""" me = world["personal"] key = _sk(me, 바탕={"로직": PCT}) was = _sum(me, key) lb = next(r["키"] for r in skc.held(_doc(me, key))["단가"] if r["키"].startswith("LB")) - _fake(monkeypatch, drop=[PCT, lb]) - with pytest.raises(Exception): - m01.loaded()[1].logic(PCT) + _fake(monkeypatch, drop=[lb]) now = _calc(me, _doc(me, key)) assert now["기준"]["계"] == was - assert {PCT, lb} <= set(now["사본"]["지운키"]) + assert {lb} <= set(now["사본"]["지운키"]) with store.at(me): got = path.preview(key, {"할일": skc.PRICE}) assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"] diff --git a/resources/tester/test_855_l2b_copy_plain.py b/resources/tester/test_855_l2b_copy_plain.py new file mode 100644 index 000000000..5f8ec907f --- /dev/null +++ b/resources/tester/test_855_l2b_copy_plain.py @@ -0,0 +1,50 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""855 L2 ⓑ-1 — 단가산출 값 사본에 M01 로직 줄(GF · GC · GX)을 안 담음 · 옛 저장본의 로직 줄은 안 읽음 · +일위대가(SC) 값 사본은 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 뺌). + +임시 storage · 개인 층. 셈 = 수식 문서 사본(`부름`) · 로직 줄 값 사본이 없어도 금액 같음. +""" + +from __future__ import annotations + +import copy +import json +from decimal import Decimal + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sangeun_Calc as calc +from M02_MasterTemplete import M02_Sangeun_Copy as skc +from resources.tester.test_795_1_sk_copy import _doc, _sk +from resources.tester.test_795_2_sc_copy import PCT, _read, _sc +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + + +def _logic_rows(doc: dict) -> list[str]: + rows = [r for slot in ("수식", "사본") for r in ((doc.get(slot) or {}).get("로직") or [])] + return [str(r["키"]) for r in rows if str(r["키"])[:2] in skc.LOGIC] + + +def _sum(folder, doc) -> Decimal: + with store.at(folder): + return Decimal(str(calc.run(doc, m01.loaded()[1])["기준"]["계"])) + + +def test_저장본에_로직줄_없음_금액_같음(world): + me = world["personal"] + sk = _doc(me, _sk(me, 바탕={"로직": PCT})) + sc = _read(me, "precombo", _sc(me, [{"로직": PCT, "수량": {"손": 1}}])) + assert _logic_rows(sk) == [] and PCT in _logic_rows(sc) + assert _sum(me, sk) > 0 + + +def test_옛_저장본_로직줄은_안_읽음(world): + me = world["personal"] + sk = _doc(me, _sk(me, 바탕={"로직": PCT})) + was = _sum(me, sk) + old = copy.deepcopy(sk) # 옛 꼴 — 값 사본에 바탕 로직 줄(값을 틀리게 바꾼 것) + row = json.loads(json.dumps(m01.loaded()[1].logic(PCT), default=str)) + row["호표"] = row["호표"][:1] + old["수식"]["로직"] = [*old["수식"]["로직"], row] + assert skc.held(old)["로직"] == skc.held(sk)["로직"] + assert _sum(me, old) == was From d880392e5feebe49e0b89541008959852a64d972 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 07:04:42 +0900 Subject: [PATCH 10/13] =?UTF-8?q?refactor(855-E=202-E4=20=EC=A4=80?= =?UTF-8?q?=EB=B9=84):=20=EC=98=9B=20=EC=97=94=EC=A7=84=EC=97=90=EC=84=9C?= =?UTF-8?q?=20=EB=B0=94=ED=83=95=20=EA=B8=B0=EB=B0=98=EC=9D=84=20master=5F?= =?UTF-8?q?base=20=EB=A1=9C=20=EA=B0=80=EB=A6=84=20=E2=80=94=20=EB=8F=99?= =?UTF-8?q?=EC=9E=91=20=EB=B6=88=EB=B3=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 새 master_base.py: master_formula 의 바탕 기반(Master 색인 · find · FormulaError · EmptyInput · NoRow · _plain · GROUPS · TABLE_GROUPS · TABLE_IDS · COST_ITEMS · BUNDLE)을 글자 그대로 옮김 · 재료 이음 이름 · mp 다시 내보냄 - master_formula: 같은 이름을 master_base 에서 그대로 다시 내보냄(부르는 쪽 고침 0) · 파서 · 엔진 몸은 그대로(불러오기가 옛 파서를 더는 안 씀 → 2-E4 에서 지움) - 새 계산기 쪽 scripts 다섯(master_material · master_pick · master_doc_link · master_doc_block · master_doc_record) import 를 master_base 로 — 새 계산기 셈에 엔진 몸 모듈 0 - 새 지킴 시험 test_855_e4a_base_only: 자식 해석기에서 master_base + 새 계산기만으로 견본 24 로직 셈 · 엔진 몸 읽힘 0 · 지문 = golden_855_engine - 검증: 관련 + 관문 670 통과 · 빌더 --check 같음 · typecheck 0 · 서버 health 200 · M02 단가산출 셈 전후 같음 · 자료 변경 0 Co-Authored-By: Claude Opus 5.5 --- resources/master_data/scripts/master_base.py | 175 ++++++++++++++++++ .../master_data/scripts/master_doc_block.py | 2 +- .../master_data/scripts/master_doc_link.py | 2 +- .../master_data/scripts/master_doc_record.py | 2 +- .../master_data/scripts/master_formula.py | 159 ++-------------- .../master_data/scripts/master_material.py | 2 +- resources/master_data/scripts/master_pick.py | 2 +- resources/tester/test_855_e4a_base_only.py | 111 +++++++++++ 8 files changed, 307 insertions(+), 148 deletions(-) create mode 100644 resources/master_data/scripts/master_base.py create mode 100644 resources/tester/test_855_e4a_base_only.py diff --git a/resources/master_data/scripts/master_base.py b/resources/master_data/scripts/master_base.py new file mode 100644 index 000000000..8b405543e --- /dev/null +++ b/resources/master_data/scripts/master_base.py @@ -0,0 +1,175 @@ +# -*- coding: utf-8 -*- +"""마스터 바탕 기반 — 요소 · 표 색인(`Master`) · 표 줄 찾기(`find`) · 오류 · 비목 이름 · 재료 고르기 이음. + +옛 엔진(`master_formula` — 식 읽기 · 셈 · 끝수)과 새 계산기(`master_doc_*`) · 불러오기 · 서고가 같이 씀. +`master_formula` 는 이 이름들을 그대로 다시 내보냄(855-E 2-E4 준비 — 엔진 몸을 지워도 이 모듈은 남음). +""" + +from __future__ import annotations + +from decimal import Decimal + +import master_keys as mk +import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3) + +# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음 +# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸) +GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직") +TABLE_GROUPS = ("소요량", "계수") +TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS) +COST_ITEMS = ("노무비", "재료비", "경비") +BUNDLE = (*COST_ITEMS, "계") + + +class FormulaError(ValueError): + pass + + +class EmptyInput(FormulaError): + """값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`).""" + + +class NoRow(EmptyInput): + """표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길).""" + + +def _plain(v) -> str: + """사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이.""" + return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v) + + +# ── 마스터 모음 ──────────────────────────────────────────────────────── +class Master: + """요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal). + `ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨).""" + + def __init__(self, files: dict[str, dict]): + self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄} + self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄} + self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름 + for data in files.values(): + rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄") + for row in rows or []: + key = str(row.get("키")) + self.index.setdefault(key[:2], {}).setdefault(key, row) + if row.get("원문번호"): + number = str(row["원문번호"]) + slot = self.numbers.setdefault(key[:2], {}) + if number in slot: + self.twice.add((key[:2], number)) + slot.setdefault(number, row) + mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게 + + def get(self, ref: str) -> dict: + tid, _, number = ref.partition(":") + if number and mk.KEY.fullmatch(number) and number[:2] == tid: + row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리 + elif number: + if (tid, number) in self.twice: + raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것") + row = self.numbers.get(tid, {}).get(number) + else: + row = self.index.get(ref[:2], {}).get(ref) + if row is None: + raise FormulaError(f"없는 요소 「{ref}」") + return row + + def label(self, ref) -> str: + """알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글.""" + if isinstance(ref, dict): + return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v) + try: + row = self.get(ref) + except FormulaError: + return ref + return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}" + + def value(self, ref: str): + """요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값.""" + row = self.get(ref) + alias = row.get("준용") + if alias not in (None, ""): + target = self.get(str(alias)) + name = target.get("이름") or alias + if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠 + return row.get("값"), f"추정(준용: {name})" + return target.get("값"), f"준용: {name}" + return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None + + def logic(self, ref: str) -> dict: + if mk.GROUP_OF.get(mk.id_of(ref)) != "로직": + raise FormulaError(f"로직 아님 「{ref}」") + return self.get(ref) + + +# ── 표 줄 찾기 ──────────────────────────────────────────────────────── +def _match(table: dict, row: dict, cond: str, want) -> bool: + if cond not in row: # 빈 조건 칸은 무엇이든 맞음 + return True + have = row[cond] + if table.get("조건", {}).get(cond) == "범위": + low, high = have + rule, *more = table.get("범위규칙", "초과·이하").split(" · ") + rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌 + if rule == "이상·이하": + return (low is None or want >= low) and (high is None or want <= high) + if rule == "초과·이하": + return (low is None or want > low) and (high is None or want <= high) + if rule == "이상·미만": + # 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함 + top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None) + closed = any("이하 포함" in x for x in more) and high == top + return (low is None or want >= low) and ( + high is None or want < high or (closed and want == high) + ) + if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find) + return (low is None or want > low) and (high is None or want <= high) + if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find) + return (low is None or want >= low) and (high is None or want <= high) + raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」") + return have == want + + +def _name(row: dict) -> str: + return f"{row.get('키')} {row.get('원문번호')}" + + +def find(table: dict, conds: dict, want: str | None = None) -> dict: + for cond in conds: + if cond not in table.get("조건", {}): + raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」") + hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())] + if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"): + for c in conds: + ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)] + if ups and None not in ups: + hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)] + if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만 + hits = [row for row in hits if want in row] + if len(hits) != 1: + where = f"표 {table.get('키')}({table.get('원문번호')})" + what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items()) + raise NoRow( + f"{where}에 {what} 인 줄이 없음" + if not hits + else f"{where}에 {what} 인 줄이 {len(hits)}개" + ) + return hits[0] + + +# 품셈재료 단가 · 고르기 — 서로 부르는 모듈이라 끝에서 읽음 +from master_material import ( # noqa: E402, F401 + LINKED, + PICK_KEYS, + REGION, + SLOTS, + TARIFF, + candidates, + check_pick, + check_unit, + static, + cond_text, + element, + pick, +) +import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위 diff --git a/resources/master_data/scripts/master_doc_block.py b/resources/master_data/scripts/master_doc_block.py index fe466e96f..69ca054be 100644 --- a/resources/master_data/scripts/master_doc_block.py +++ b/resources/master_data/scripts/master_doc_block.py @@ -11,7 +11,7 @@ from __future__ import annotations import master_doc as md -import master_formula as mf # 마스터 색인(`Master.get`) — 없는 키 = FormulaError +import master_base as mf # 바탕 기반 · 마스터 색인(`Master.get`) — 없는 키 = FormulaError import master_keys as mk import master_material as mm # 재료 고르기 조건 검사(`check_pick`) diff --git a/resources/master_data/scripts/master_doc_link.py b/resources/master_data/scripts/master_doc_link.py index 64d3d9b38..353c54126 100644 --- a/resources/master_data/scripts/master_doc_link.py +++ b/resources/master_data/scripts/master_doc_link.py @@ -20,7 +20,7 @@ from pathlib import Path import master_doc as md import master_doc_calc as mc -import master_formula as mf +import master_base as mf # 바탕 기반(색인 · 오류) import master_machine_crew as mcrew import master_material as mm import master_pick as mp diff --git a/resources/master_data/scripts/master_doc_record.py b/resources/master_data/scripts/master_doc_record.py index 49416118c..ee7b647b3 100644 --- a/resources/master_data/scripts/master_doc_record.py +++ b/resources/master_data/scripts/master_doc_record.py @@ -13,7 +13,7 @@ from __future__ import annotations import master_doc_calc as mc -import master_formula as mf +import master_base as mf # 바탕 기반(색인 · 오류) class Rec: diff --git a/resources/master_data/scripts/master_formula.py b/resources/master_data/scripts/master_formula.py index 4cd540ecd..a5e35281d 100644 --- a/resources/master_data/scripts/master_formula.py +++ b/resources/master_data/scripts/master_formula.py @@ -3,6 +3,7 @@ 식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게). `check_master.py` 가 부름. +바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄. """ from __future__ import annotations @@ -12,15 +13,22 @@ import re from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal import master_keys as mk -import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3) +from master_base import ( # noqa: F401 — 바탕 기반(855-E 2-E4 준비) · 이름은 여기서 그대로 + BUNDLE, + COST_ITEMS, + GROUPS, + TABLE_GROUPS, + TABLE_IDS, + EmptyInput, + FormulaError, + Master, + NoRow, + _match, + _name, + _plain, + find, +) -# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음 -# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸) -GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직") -TABLE_GROUPS = ("소요량", "계수") -TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS) -COST_ITEMS = ("노무비", "재료비", "경비") -BUNDLE = (*COST_ITEMS, "계") FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대") _NAME = re.compile(r"[\w가-힣]+") _NUMBER = re.compile(r"\d+(?:\.\d+)?") @@ -38,18 +46,6 @@ def inputs_of(row: dict) -> list[dict]: raise FormulaError(FLOW_GONE) -class FormulaError(ValueError): - pass - - -class EmptyInput(FormulaError): - """값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`).""" - - -class NoRow(EmptyInput): - """표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길).""" - - class Blank: """못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움.""" @@ -57,11 +53,6 @@ class Blank: self.why = why -def _plain(v) -> str: - """사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이.""" - return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v) - - # ── 읽기 ────────────────────────────────────────────────────────────── class _Parser: def __init__(self, text: str): @@ -257,70 +248,6 @@ def walk(node): yield from walk(item) -# ── 마스터 모음 ──────────────────────────────────────────────────────── -class Master: - """요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal). - `ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨).""" - - def __init__(self, files: dict[str, dict]): - self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄} - self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄} - self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름 - for data in files.values(): - rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄") - for row in rows or []: - key = str(row.get("키")) - self.index.setdefault(key[:2], {}).setdefault(key, row) - if row.get("원문번호"): - number = str(row["원문번호"]) - slot = self.numbers.setdefault(key[:2], {}) - if number in slot: - self.twice.add((key[:2], number)) - slot.setdefault(number, row) - mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게 - - def get(self, ref: str) -> dict: - tid, _, number = ref.partition(":") - if number and mk.KEY.fullmatch(number) and number[:2] == tid: - row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리 - elif number: - if (tid, number) in self.twice: - raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것") - row = self.numbers.get(tid, {}).get(number) - else: - row = self.index.get(ref[:2], {}).get(ref) - if row is None: - raise FormulaError(f"없는 요소 「{ref}」") - return row - - def label(self, ref) -> str: - """알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글.""" - if isinstance(ref, dict): - return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v) - try: - row = self.get(ref) - except FormulaError: - return ref - return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}" - - def value(self, ref: str): - """요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값.""" - row = self.get(ref) - alias = row.get("준용") - if alias not in (None, ""): - target = self.get(str(alias)) - name = target.get("이름") or alias - if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠 - return row.get("값"), f"추정(준용: {name})" - return target.get("값"), f"준용: {name}" - return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None - - def logic(self, ref: str) -> dict: - if mk.GROUP_OF.get(mk.id_of(ref)) != "로직": - raise FormulaError(f"로직 아님 「{ref}」") - return self.get(ref) - - def fill(template: str, env: dict) -> str: def one(m): if m.group(1) not in env: @@ -338,60 +265,6 @@ def _round(x: Decimal, places, mode) -> Decimal: return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode) -def _match(table: dict, row: dict, cond: str, want) -> bool: - if cond not in row: # 빈 조건 칸은 무엇이든 맞음 - return True - have = row[cond] - if table.get("조건", {}).get(cond) == "범위": - low, high = have - rule, *more = table.get("범위규칙", "초과·이하").split(" · ") - rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌 - if rule == "이상·이하": - return (low is None or want >= low) and (high is None or want <= high) - if rule == "초과·이하": - return (low is None or want > low) and (high is None or want <= high) - if rule == "이상·미만": - # 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함 - top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None) - closed = any("이하 포함" in x for x in more) and high == top - return (low is None or want >= low) and ( - high is None or want < high or (closed and want == high) - ) - if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find) - return (low is None or want > low) and (high is None or want <= high) - if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find) - return (low is None or want >= low) and (high is None or want <= high) - raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」") - return have == want - - -def _name(row: dict) -> str: - return f"{row.get('키')} {row.get('원문번호')}" - - -def find(table: dict, conds: dict, want: str | None = None) -> dict: - for cond in conds: - if cond not in table.get("조건", {}): - raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」") - hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())] - if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"): - for c in conds: - ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)] - if ups and None not in ups: - hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)] - if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만 - hits = [row for row in hits if want in row] - if len(hits) != 1: - where = f"표 {table.get('키')}({table.get('원문번호')})" - what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items()) - raise NoRow( - f"{where}에 {what} 인 줄이 없음" - if not hits - else f"{where}에 {what} 인 줄이 {len(hits)}개" - ) - return hits[0] - - def evaluate(node, env: dict, master: Master, depth: int = 0): kind = node[0] if kind in ("num", "str"): diff --git a/resources/master_data/scripts/master_material.py b/resources/master_data/scripts/master_material.py index c6e3b3f47..b12cf25f7 100644 --- a/resources/master_data/scripts/master_material.py +++ b/resources/master_data/scripts/master_material.py @@ -284,5 +284,5 @@ def element( return min(offers, key=lambda x: x[0]) if offers else (None, None) -import master_formula as mf # noqa: E402 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음 +import master_base as mf # noqa: E402 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음 import master_pick as mp # noqa: E402 — 검색어 찾기 diff --git a/resources/master_data/scripts/master_pick.py b/resources/master_data/scripts/master_pick.py index ffc906650..e17db0c85 100644 --- a/resources/master_data/scripts/master_pick.py +++ b/resources/master_data/scripts/master_pick.py @@ -230,4 +230,4 @@ def check_warn(master, where: str, cond: dict, unit: str | None) -> list[str]: return [] -import master_formula as mf # noqa: E402, F401 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음 +import master_base as mf # noqa: E402, F401 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음 diff --git a/resources/tester/test_855_e4a_base_only.py b/resources/tester/test_855_e4a_base_only.py new file mode 100644 index 000000000..4ff887b3a --- /dev/null +++ b/resources/tester/test_855_e4a_base_only.py @@ -0,0 +1,111 @@ +"""855-E 2-E4 준비 지킴 — 바탕 기반(`master_base`)만으로 새 계산기가 셈. + +- 새 해석기(자식)가 scripts 길만 두고 `master_base` · `master_doc_link` · `master_doc_calc` 를 읽어 + 견본 로직(기본 + 옵션 표본)을 셈 → 옛 엔진 몸(`master_formula` 무리)이 한 번도 안 읽힘. +- 그 답 지문 = 골든(`golden_855_engine.json` · `test_855_golden` 과 같은 지문 규칙)과 같음. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import subprocess +import sys +from decimal import Decimal +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SCRIPTS = ROOT / "resources" / "master_data" / "scripts" +N = 24 # 견본 로직 수(키 차례 고르게) +ENGINE = ( # 엔진 몸 — 자식에서 읽히면 실패 + "master_formula", + "master_formula_check", + "master_formula_sum", + "master_cut", + "master_text", + "master_text_item", + "master_auto", + "master_combo", + "master_sheet_line", + "master_gate", + "master_equation", + "check_master", +) + + +def _enc(v): + if isinstance(v, Decimal): + return {"$d": str(v)} + raise TypeError(type(v).__name__) + + +def _dec(d: dict): + return Decimal(d["$d"]) if set(d) == {"$d"} else d + + +def _child() -> None: + """자식 — 표준 입력 {키: [[옵션 글, 바뀐 입력]]} → {답: {키: [[옵션 글, 셈 답]]}, 읽힌 엔진: [...]}.""" + sys.path.insert(0, str(SCRIPTS)) + import master_base as mb + import master_doc_calc as mc + import master_doc_link as ml + import master_machine_files as mmf + + folder = Path(os.environ.get("AISLO_MASTER_DIR") or SCRIPTS.parent).resolve() + files = {} + for name in mmf.names(folder): # `M01_MasterData_Store_Cache.loaded` 와 같은 읽기 + if name == mmf.NAME and mmf.here(folder): + files[name] = mmf.table(folder)[0] + elif not name.startswith("_"): + raw = (folder / name).read_bytes() + files[name] = json.loads(raw, parse_float=Decimal, parse_int=Decimal) + docs = ml.load_all() + links = ml.Links(mb.Master(files), docs) + want = json.loads(sys.stdin.buffer.read().decode("utf-8"), object_hook=_dec) + out = {} + for key, cases in want.items(): + rows = [] + for label, changed in cases: + try: + got = mc.calc(docs[key], links, changed) + except Exception: + got = None + rows.append([label, got if got and got.get("셈됨") else None]) + out[key] = rows + body = {"답": out, "읽힌 엔진": sorted(m for m in ENGINE if m in sys.modules)} + sys.stdout.buffer.write(json.dumps(body, ensure_ascii=False, default=str).encode("utf-8")) + + +def test_바탕_기반만으로_새_계산기_지문_골든과_같음(): + import helper_855_engine as h + from helper_test_all import spread + + rows, _, docs, _ = h.world() + rows = spread([r for r in rows if str(r["키"]) in docs], N) + want = { + str(r["키"]): [[label, changed] for label, _, changed in h.cases(r, True)] for r in rows + } + run = subprocess.run( + [sys.executable, str(Path(__file__)), "--child"], + input=json.dumps(want, ensure_ascii=False, default=_enc).encode("utf-8"), + capture_output=True, + cwd=str(ROOT), + timeout=600, + ) + assert run.returncode == 0, run.stderr.decode("utf-8", "replace")[-2000:] + body = json.loads(run.stdout.decode("utf-8")) + assert body["읽힌 엔진"] == [], f"엔진 몸이 읽힘 {body['읽힌 엔진']}" + golden = json.loads((HERE / "golden_855_engine.json").read_text("utf-8"))["지문"] + diff = [] + for key, cases in body["답"].items(): + got = [[label, h.answer(g)] for label, g in cases] + raw = json.dumps(got, ensure_ascii=False, sort_keys=True) + if hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] != golden[key]: + diff.append(key) + assert len(body["답"]) == len(rows) and not diff, f"지문 다름 {diff}" + + +if __name__ == "__main__" and "--child" in sys.argv: + _child() From cce57c2984e733690a6b3c06441ff8d099942c8f Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 07:18:00 +0900 Subject: [PATCH 11/13] auto: 2026-11-18 07:18 (ESD_LAPTOP) --- M01_MasterData/M01_MasterData_Alias.py | 23 +- M01_MasterData/M01_MasterData_Doc.py | 61 ++-- M01_MasterData/M01_MasterData_Machine.py | 39 +-- M01_MasterData/M01_MasterData_Router.py | 49 +--- M01_MasterData/M01_MasterData_Store.py | 25 +- M01_MasterData/M01_MasterData_Store_Cache.py | 9 +- M01_MasterData/M01_MasterData_Store_Logic.py | 267 ++++++++++++++++++ M01_MasterData/M01_MasterData_Store_Make.py | 216 ++++---------- M01_MasterData/M01_MasterData_Store_Revise.py | 41 ++- 9 files changed, 410 insertions(+), 320 deletions(-) create mode 100644 M01_MasterData/M01_MasterData_Store_Logic.py diff --git a/M01_MasterData/M01_MasterData_Alias.py b/M01_MasterData/M01_MasterData_Alias.py index 69c2514e8..314c238f4 100644 --- a/M01_MasterData/M01_MasterData_Alias.py +++ b/M01_MasterData/M01_MasterData_Alias.py @@ -80,10 +80,16 @@ def _find(key: str, files: tuple[str, ...] | None = None) -> tuple[str, dict[str def set_alias(key: str, text: str) -> dict[str, Any]: - """그 줄 `별칭` 만 바꿔 M01 저장 길로(빈 글 = 칸 없음 · 별칭만이라 정본 개정 확인 안 물음).""" - file, _ = _find(key) - data, version = store.read(file) - row = dict(next(r for r in data["줄"] if str(r.get("키")) == key)) + """그 줄 `별칭` 만 바꿔 M01 저장 길로(빈 글 = 칸 없음 · 별칭만이라 정본 개정 확인 안 물음) · + 단가산출 기초 = 문서 머리(855 L3 ⓐ · `Store_Logic`).""" + doc = store._docs().docs().get(key) + if doc is not None: + file = store._docs().find(key)[0] + version, row = store._docs().file_version(file), store._docs().head_of(doc) + else: + file, _ = _find(key) + data, version = store.read(file) + row = dict(next(r for r in data["줄"] if str(r.get("키")) == key)) row[ALIAS] = text change = {"op": "edit", "key": key, "row": row} make.save([{"file": file, "version": version, "changes": [change]}], True) @@ -109,11 +115,10 @@ def board() -> dict[str, Any]: (str(v.get("키")), ma.norm(v.get(ALIAS))) for v in book.values() if v.get("상태") == "승인" } rows = [] - logic = ( - store._docs().logic_files() - ) # 단가산출 기초 = 수식 문서 머리(855 L2 ⓐ) · 파일 차례는 그대로 - for file, data in store.loaded()[0].items(): - data = logic.get(file, {}) if data.get("그룹") == "로직" else data + every = {n: d for n, d in store.loaded()[0].items() if d.get("그룹") != "로직"} + every |= store._docs().logic_files() # 단가산출 기초 = 수식 문서 머리(855 L2 ⓐ · L3 ⓐ) + for file in sorted(every): # 파일 이름 차례(마스터 폴더 차례와 같음) + data = every[file] kind = kind_of(file, str(data.get("그룹") or "")) for row in data.get("줄") or []: if not str(row.get(ALIAS) or "").strip(): diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index 1b7c086fd..eec60ecf8 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -48,6 +48,12 @@ def version_of(doc: dict | None) -> str: return "" if doc is None else store.version_of(ml.dump(doc).encode("utf-8")) +def file_version(logic_file: str) -> str: + """기초 파일 판(855 L3 ⓐ) — 옛 로직 파일 이름에 짝인 수식 문서 파일 글의 지문 · 없음 = 빈 글.""" + path = folder() / ml.file_of(logic_file) + return store.version_of(path.read_bytes()) if path.is_file() else "" + + def put(path: Path, data: dict) -> None: """수식 문서 파일 한 벌 — 임시 파일 → 교체(원자적) · `_LOCK` 안에서 부름. 마스터만 사본으로 바꾼 시험(`Store.FOLDER` ≠ 정본)이 정본 수식 문서를 쓰지 않게 건너뜀.""" @@ -152,18 +158,15 @@ def _check(doc) -> dict: def read(key: str) -> dict: + """기초마다 문서가 늘 있음(855 L3 ⓐ — 만들 때 문서부터) · 없는 키 = 404.""" found = docs().get(key) - fresh = found is None - if fresh: # 로직 줄은 있고 문서가 없는 키(옛 자료 받침 — 새 로직은 `ensure` 가 문서를 둠) - row = _row(key) - if row is None: - raise store.StoreError(404, f"없는 로직 「{key}」") - found = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원")) + if found is None: + raise store.StoreError(404, f"없는 로직 「{key}」") out = _run(found) - up = None if fresh else built(key) + up = built(key) # ponytail: 빌더 문서(층바탕) — 로직 JSON 이 없으면 None · 둘째 박자에서 걷음 more = {"층바탕": {"위": up}} if up is not None else {} - 판 = version_of(None if fresh else found) # 저장 때 대조(다른 곳에서 바뀌면 409) - return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, "판": 판, **more} + 판 = version_of(found) # 저장 때 대조(다른 곳에서 바뀌면 409) + return {"문서": found, **out, "파일": _where(key) or "", "새": False, "판": 판, **more} def preview(doc: dict, given: dict | None = None) -> dict: @@ -171,24 +174,15 @@ def preview(doc: dict, given: dict | None = None) -> dict: def _file_for(key: str) -> str: - """문서 파일 — 있던 파일 › 로직 줄이 든 로직 파일 짝(쓰기 짝 · L3 에서 걷음) › 자체.""" - have = _where(key) - if have: - return have - for name, data in store.loaded()[0].items(): - if data.get("그룹") == "로직" and any( - str(r.get("키")) == key for r in data.get("줄") or [] - ): - return ml.file_of(name) - return OWN_FILE + """문서 파일 — 있던 파일 › 자체(새 기초는 자체에만 · 855 L3 ⓐ).""" + return _where(key) or OWN_FILE def _new_file(name: str) -> dict: - """새 문서 파일 머리 — 짝 로직 파일의 이름 · 머리(원문 · 부문 · 차례)를 그대로(목록 분류 정본).""" + """새 문서 파일 머리 — 자체 문서 파일만 새로 생김(원문 = 자체 · 목록 분류 정본).""" logic = "로직_" + name.split("_", 1)[1] - head = store.loaded()[0].get(logic) or {} - tags = {k: head[k] for k in md.FILE_TAGS if k in head} - return {"그룹": "수식문서", "로직파일": logic if head else "", **tags, "줄": []} + tags = {"원문": "자체"} if name == OWN_FILE else {} + return {"그룹": "수식문서", "로직파일": logic, **tags, "줄": []} def _row(key: str) -> dict | None: @@ -345,14 +339,14 @@ def save(doc: dict, 판: str | None = None) -> dict: doc = _check(doc) key = str(doc["키"]).strip() with _LOCK: - if (row := _row(key)) is not None: # 이름표 = 로직 줄 것(화면 왕복에 안 지워짐 · 855 L1) - doc = md.tag(doc, row) - doc = layered(doc, key) name = _file_for(key) path = folder() / name data = ml.load_file(path) if path.exists() else _new_file(path.name) rows = data.setdefault("줄", []) at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None) + if at is not None: # 이름표 = 저장된 문서 것(화면 왕복에 안 지워짐 · 고침은 기초 [저장] 길) + doc = md.tag(doc, rows[at]) + doc = layered(doc, key) 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: @@ -428,15 +422,8 @@ def drop(key: str) -> None: def remove(key: str, file: str, version: str, confirmed: bool) -> dict: - """로직 지우기 — 부르는 곳이 있으면 409 {쓰는곳} · 로직 저장 길(개정 확인 · 판 · 검사) 뒤 문서도.""" - from M01_MasterData import M01_MasterData_Store_Make as make + """로직 지우기 — 기초 저장 길(`Store_Logic` — 쓰는 곳 409 · 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기).""" + from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 그 파일이 이 파일을 부름 — 늦게 - used = users(key) - if used: - raise store.StoreError(409, {"쓰는곳": used}) - got = make.save( - [{"file": file, "version": version, "changes": [{"op": "delete", "key": key}]}], - confirmed, - ) - drop(key) - return got + part = {"file": file, "version": version, "changes": [{"op": "delete", "key": key}]} + return logic_store.save([part], confirmed) diff --git a/M01_MasterData/M01_MasterData_Machine.py b/M01_MasterData/M01_MasterData_Machine.py index b4787a23f..2a38b88ca 100644 --- a/M01_MasterData/M01_MasterData_Machine.py +++ b/M01_MasterData/M01_MasterData_Machine.py @@ -11,7 +11,6 @@ M01 에서 만든 기계(출처 모두 「자체」)를 지우면 그 번호 기 from __future__ import annotations -import copy from decimal import Decimal from typing import Any, Callable @@ -118,20 +117,10 @@ def formula(row: dict) -> dict: return base | ({"키": got["키"], "이름": got.get("이름")} if got else {}) -def _family_files() -> dict[str, str]: - """기계경비식 키 → 로직 파일 이름.""" - return { - str(r.get("키")): name - for name, data in store.loaded()[0].items() - if data.get("그룹") == "로직" and "건설기계" in name - for r in data.get("줄") or [] - } - - def register(batch: list[dict]) -> Callable[[], None]: """[새 기계] 저장 = 꼴 식 「기계」 목록에 그 원문번호 더함 · M01 에서 만든 기계(출처 모두 「자체」)를 - 지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 로직 파일 고침을 같은 저장 묶음에 붙임(정본 저장 길) · - 돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록에도 같은 더함 · 뺌(848-5 · 두 목록 한 벌).""" + 지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록(정본 · + 848-5)에 더함 · 뺌 + 옛 로직 줄 고르기 같이 쓰기(`Store_Logic.mirror` · 855 L3 ⓐ).""" from M02_MasterTemplete import M02_Machine_Hourly as mh # M02 가 M01 을 부름 — 늦게 from M02_MasterTemplete import M02_MyMachine as mym @@ -162,23 +151,13 @@ def register(batch: list[dict]) -> Callable[[], None]: drop.add(code) if not add and not drop: return lambda: None - files = _family_files() - for name in dict.fromkeys(files.values()): - changes = [] - for logic in store.read(name)[0].get("줄") or []: - ins = logic.get("입력") or [] - pick = next((i for i in ins if i.get("이름") == "기계" and "고르기" in i), None) - if pick is None: - continue - codes = [c for c in pick["고르기"] if str(c) not in drop] - codes += [c for c in add.get(str(logic["키"]), []) if c not in codes] - if codes != pick["고르기"]: - new = copy.deepcopy(logic) - next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes - changes.append({"op": "edit", "key": logic["키"], "row": new}) - if changes: - batch.append({"file": name, "version": store.read(name)[1], "changes": changes}) - after = lambda: _register_docs(add, drop) # noqa: E731 + + def after() -> None: + from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 늦게(서로 부름) + + _register_docs(add, drop) + logic_store.mirror([], (add, drop)) + after.lists = ( add, drop, diff --git a/M01_MasterData/M01_MasterData_Router.py b/M01_MasterData/M01_MasterData_Router.py index 13e79738b..2363f6657 100644 --- a/M01_MasterData/M01_MasterData_Router.py +++ b/M01_MasterData/M01_MasterData_Router.py @@ -48,26 +48,14 @@ class SaveBody(BaseModel): class CopyLogic(BaseModel): + """[복사/생성](본떠 만들기) — 원본 문서를 새 자체 기초로 · 빈 글 = 원본 그대로.""" + key: str 이름: str = "" owner: str = make.OWNERS[0] - - -class FormulaLogic(BaseModel): - """복사해서 만들기 — 별칭 꼴 식이 든 로직 줄과 그 별칭표(되돌릴 원문).""" - - 로직: dict[str, Any] - 별칭: list[dict[str, Any]] = [] - owner: str = make.OWNERS[0] - 이름: str = "" - 본뜬키: str = "" - - -class FormulaPreview(BaseModel): - """저장 전 미리보기 — 별칭을 원문으로 되돌린 로직 줄만 받고 싶을 때(시험 계산 전).""" - - 로직: dict[str, Any] - 별칭: list[dict[str, Any]] = [] + 원문번호: str = "" + 결과단위: str = "" + 출처: str = "" def _num(v): @@ -248,27 +236,8 @@ def post_save(body: SaveBody) -> dict: @router.post("/logic/copy") def post_logic_copy(body: CopyLogic) -> dict: - return _call(make.logic_copy, body.key, body.이름, body.owner) - - -@router.get("/logic/formula") -def get_logic_formula(key: str) -> dict: - """복사해서 만들기 — 로직 한 줄을 별칭 꼴 식 묶음으로.""" - return _call(make.logic_formula, key) - - -@router.post("/logic/formula/save") -def post_logic_formula_save(body: FormulaLogic) -> dict: - """고친 식 묶음을 자체 로직(`GX`)으로 — 별칭은 원문으로 되돌려 저장.""" - return _call(make.logic_from_formula, body.로직, body.별칭, body.owner, body.이름, body.본뜬키) - - -@router.post("/logic/formula/preview") -def post_logic_formula_preview(body: FormulaPreview) -> dict: - """저장 전 시험 계산용 — 별칭을 원문으로 되돌린 로직 줄 + 저장하면 지을 수식 문서 - {logic, 문서}(저장 안 함 · 화면은 `문서` 를 `/logic/doc/preview` 로 셈 · 855 2-B4).""" - got = _call(make.logic_formula_preview, body.로직, body.별칭) - return {**got, "문서": doc_screen.of_row(got["logic"])} + more = {"원문번호": body.원문번호, "결과단위": body.결과단위, "출처": body.출처} + return _call(make.logic_copy, body.key, body.이름, body.owner, more) # ── 수식 문서(802-3) — 단가산출 기초 정본 · 화면은 같은 계산기로 즉시 셈 ── @@ -280,7 +249,7 @@ class DocBody(BaseModel): @router.get("/logic/doc") def get_logic_doc(key: str) -> dict: - """수식 문서 {문서, 셈, 연결, 파일, 새} — 없으면 빈 문서(쓰기 없음).""" + """수식 문서 {문서, 셈, 연결, 파일, 새} — 없는 키 = 404(쓰기 없음).""" return _call(doc_screen.read, key) @@ -311,7 +280,7 @@ def get_logic_users(key: str) -> dict: @router.post("/logic/remove") def post_logic_remove(body: RemoveBody) -> dict: - """로직 지우기(804-7) — 로직 줄 + 수식 문서 · 부르는 곳 있으면 409 {쓰는곳}.""" + """로직 지우기(804-7) — 수식 문서(+ 옛 로직 줄 같이 쓰기) · 부르는 곳 있으면 409 {쓰는곳}.""" return _call(doc_screen.remove, body.key, body.file, body.version, body.개정확인) diff --git a/M01_MasterData/M01_MasterData_Store.py b/M01_MasterData/M01_MasterData_Store.py index b6b6efb2e..8dcd7421d 100644 --- a/M01_MasterData/M01_MasterData_Store.py +++ b/M01_MasterData/M01_MasterData_Store.py @@ -21,7 +21,6 @@ sys.path.insert(0, str(SCRIPTS)) import check_master as cm # noqa: E402 import master_auto as mau # noqa: E402,F401 (M02 `Sangeun_Calc` · `Labor_Doc` · `Labor_Inputs` · B09 `Sangeun` 가 `store.mau` 로 씀) import master_combo as mcb # noqa: E402,F401 (`_Store_Combo` 가 `store.mcb` 로 씀) -import master_copy as mcp # noqa: E402,F401 (`_Store_Make` 가 `store.mcp` 로 씀) import master_keys as mk # noqa: E402 import master_text as mtx # noqa: E402,F401 (B09 `Sangeun_Text` · M02 `Logic_Settle` 가 `store.mtx` 로 씀) @@ -116,7 +115,7 @@ def _docs(): def files_of(group: str) -> list[dict]: - """로직 = 수식 문서 파일(855 L2 ⓐ) · 판(해) · version 은 로직 파일(저장 409 짝 · L3 에서 문서로).""" + """로직 = 수식 문서 파일(855 L2 ⓐ) · 판 = 문서 파일 머리 · version = 문서 파일 글 지문(855 L3 ⓐ).""" if group not in cm.mf.GROUPS: raise StoreError(404, f"없는 그룹 「{group}」") logic = _docs().logic_files() if group == "로직" else None @@ -124,8 +123,12 @@ def files_of(group: str) -> list[dict]: for name in sorted(logic) if logic is not None else cm.mmf.names(FOLDER): if name != f"{group}.json" and not name.startswith(f"{group}_"): continue - data, version = read(name) - head = data if logic is None else logic[name] + if logic is None: + data, version = read(name) + head = data + else: + data = head = logic[name] + version = _docs().file_version(name) out.append( { "file": name, @@ -390,18 +393,14 @@ def logics(sub: str, detail: str, q: str, blocked: int | None, owner: str = "") def logic(key: str) -> dict: - """로직 하나 — 키는 전체에서 하나 · 있는지 · 파일 · 이름표 = 수식 문서(855 L2 ⓐ) · - 셈 칸(입력 · 호표 …) · `version` = 로직 파일(화면 [저장]이 줄째 되돌려 씀 — L3 에서 걷음).""" - files, whole = loaded() + """로직 하나 — 키는 전체에서 하나 · 파일 · `logic` = 수식 문서 머리(키 · 이름표 · 이름 · 결과단위 · 출처 · + 부품 — 화면 [저장]이 이 칸만 되돌려 보냄 · 셈은 줄 쌓기 문서) · `version` = 문서 파일 판(855 L3 ⓐ).""" name, doc = _docs().find(key) - row = next((r for r in (files.get(name) or {}).get("줄") or [] if str(r.get("키")) == key), {}) - head, named = _docs().head_of(doc), (*_docs().md.TAGS, *_docs().HEAD) - row = {k: head.get(k, v) for k, v in row.items() if k in head or k not in named} | head - reasons = cache.reasons(key, whole) # 수식 문서 기준(855 2-B3) + reasons = cache.reasons(key, loaded()[1]) # 수식 문서 기준(855 2-B3) return { "file": name, - "version": read(name)[1], - "logic": row, + "version": _docs().file_version(name), + "logic": _docs().head_of(doc), "blocked": bool(reasons), "reasons": reasons, } diff --git a/M01_MasterData/M01_MasterData_Store_Cache.py b/M01_MasterData/M01_MasterData_Store_Cache.py index 230240e04..9af34c9dc 100644 --- a/M01_MasterData/M01_MasterData_Store_Cache.py +++ b/M01_MasterData/M01_MasterData_Store_Cache.py @@ -330,10 +330,11 @@ def _labor_files() -> list[tuple[str, Path]]: ] -def labor_errors(whole, keys=None) -> list[str]: +def labor_errors(whole, keys=None, have=None) -> list[str]: """일위대가 · 사전조합 문서가 담은 로직 마스터에 없음(39-1d · 50-3) — 로직 지우기를 막음 · 어디서 쓰는지 알림 · 참조 줄(로직 없음)은 건너뜀. 전부터 깨진 것은 - `save` 가 고치기 전 검사와 견주어 뺌. `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶).""" + `save` 가 고치기 전 검사와 견주어 뺌. `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶) · + `have` = 있는 기초 키(저장 뒤 문서 · 855 L3 ⓐ — 주면 `whole` 대신).""" out = [] if keys is not None and not keys: return out @@ -350,6 +351,10 @@ def labor_errors(whole, keys=None) -> list[str]: key = str(one.get("로직") or "") if isinstance(one, dict) else "" if not key or (keys is not None and key not in keys): continue + if have is not None: + if key not in have: + out.append(f"{where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌") + continue try: whole.logic(key) except cm.mf.FormulaError: diff --git a/M01_MasterData/M01_MasterData_Store_Logic.py b/M01_MasterData/M01_MasterData_Store_Logic.py new file mode 100644 index 000000000..1683b2a09 --- /dev/null +++ b/M01_MasterData/M01_MasterData_Store_Logic.py @@ -0,0 +1,267 @@ +"""M01 단가산출 기초 저장 — 수식 문서가 정본(PLAN 855 L3 ⓐ · 요구 898). + +화면 [저장](`/save` 의 로직 파일 몫) · [신규] · [본떠 만들기] · [복사/생성] · [삭제] · 별칭이 이 길로. +- 판 = 문서 파일 글 지문(`Doc.file_version`) — 다르면 409 {stale} +- 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`) +- 키 = 대장(`_키대장.json` · 자체 GX 다음 번호) · 검사 = 문서(쓰는 곳 · 일위대가 담은 로직 · 키 겹침 · 대장) +- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`) +화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫. +""" + +from __future__ import annotations + +import copy +import os +from pathlib import Path + +from common_util.common_util_time import kst_today +from M01_MasterData import M01_MasterData_Doc as doc_store +from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Revise as revise +from M01_MasterData.M01_MasterData_Store_Shape import dump, keep_shape + +md, ml, mk, cm = doc_store.md, doc_store.ml, store.mk, store.cm + +#: 로직 줄 같이 쓰기 — M02 · B09 가 로직 줄을 더 안 읽게 되면(둘째 박자) 끄고 `mirror` 를 지움 +WRITE = os.environ.get("AISLO_LOGIC_WRITE", "1") != "0" +OWN = "로직_자체.json" +FIELDS = revise.FIELDS +CALC = {"입력": [], "중간": [], "호표": [], "끝수": None} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음) + + +def is_logic(file: str) -> bool: + return file.startswith("로직_") and file.endswith(".json") + + +def head(row: dict) -> dict: + """화면이 보낸 줄에서 쓸 칸 — 키 · 이름표 · 머리.""" + return {k: row[k] for k in FIELDS if k in row} + + +def _doc_file(file: str) -> Path: + return doc_store.folder() / ml.file_of(file) + + +def _rows(data: dict) -> list[dict]: + return data.setdefault("줄", []) + + +def _at(rows: list[dict], key: str) -> int | None: + return next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None) + + +def _fresh_doc(key: str, row: dict, base: dict | None) -> dict: + """새 기초 문서 — 원본 문서 복제(본뜸) 또는 빈 문서(출처 = 결과단위 다음) · 이름표 · 머리 = 받은 줄.""" + if base is None: + blank = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원")) + items = list(blank.items()) + base = {**dict(items[:5]), "출처": row.get("출처"), **dict(items[5:])} + else: + base = {k: v for k, v in copy.deepcopy(base).items() if k != "손고침"} + base["키"] = key + return doc_store._headed(base, {**head(row), "키": key}) + + +def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]: + """고침 · 더함 · 지움을 문서 파일 사본에 — (문서 파일 → 내용, 같이 쓰기 편집, 더한 키, 지운 키).""" + plan: dict[str, dict] = {} + edits, added, gone = [], [], set() + for part in parts: + file = str(part.get("file") or "") + path = _doc_file(file) + if path.name not in plan: + plan[path.name] = ( + copy.deepcopy(ml.load_file(path)) if path.is_file() else doc_store._new_file(path.name) + ) + rows = _rows(plan[path.name]) + for ch in part.get("changes") or []: + op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row") + if op not in ("edit", "add", "delete"): + raise store.StoreError(400, f"모르는 op 「{op}」") + at = None if op == "add" else _at(rows, key) + if op != "add" and at is None: + raise store.StoreError(404, f"{file} · 없는 키 「{key}」") + if op != "delete" and ( + not isinstance(row, dict) or not str(row.get("이름") or "").strip() + ): + raise store.StoreError(400, f"{file} · 줄에 「이름」 이 없음") + if op == "edit": + if str(row.get("키")) != key: + raise store.StoreError(400, f"{file} · 키는 바꾸지 않음 「{key}」") + rows[at] = doc_store._headed(rows[at], head(row)) + edits.append(("머리", key, doc_store.head_of(rows[at]))) + elif op == "add": + if file != OWN: + raise store.StoreError(400, f"새 기초는 {OWN} 에만") + tid = mk.table_id("로직", "자체") + number = str(row.get("원문번호") or "") + key = mk.issue(book, tid, store.ledger_label(book, tid, number, row), file) + source = str(ch.get("from") or "") + base = doc_store.docs().get(source) if source else None + rows.append(_fresh_doc(key, row, base)) + edits.append(("더함", key, {"file": file, "row": head(row), "from": source})) + added.append({"file": file, "key": key}) + else: + del rows[at] + gone.add(key) + edits.append(("지움", key, None)) + return plan, edits, added, gone + + +def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]: + """문서 검사 — 일위대가 · 사전조합이 담은 기초가 빠짐 · 키 겹침 · 대장(저장 전에 있던 흠은 뺌).""" + have = dict(doc_store.logic_files()) + after = dict(have) + for name, data in plan.items(): + logic = str(data.get("로직파일") or "") or "로직_" + name.split("_", 1)[1] + after[logic] = {"그룹": "로직", "줄": data.get("줄") or []} + keys = {str(d.get("키")) for f in after.values() for d in f["줄"]} + old = set(cm.duplicate_keys(have, old_book)) + out = [x for x in cm.duplicate_keys(after, book) if x not in old] + return out + store.cache.labor_errors(None, gone, keys) + + +def save(parts: list[dict], confirmed: bool = False) -> dict: + """로직 파일 몫 저장 — {files: [{file, version}], added: [{file, key}], warnings}.""" + revise.guard(parts, confirmed) + gone_used = { + k: used + for p in parts + for c in p.get("changes") or [] + if c.get("op") == "delete" and (k := str(c.get("key") or "")) + and (used := doc_store.users(k)) + } + if gone_used: + raise store.StoreError(409, {"쓰는곳": [x for v in gone_used.values() for x in v]}) + with doc_store._LOCK: + stale = [ + str(p.get("file")) for p in parts + if doc_store.file_version(str(p.get("file"))) != (p.get("version") or "") + ] # fmt: skip + if stale: + raise store.StoreError(409, {"stale": stale}) + book_path = store.FOLDER / mk.BOOK.name + book = mk.load_book(book_path) + old_book = {"키": dict(book["키"]), "다음": dict(book["다음"])} + plan, edits, added, gone = _plan(parts, book) + mk.finish(book) + if bad := _errors(plan, gone, old_book, book): + raise store.StoreError(422, {"errors": bad}) + paths = {n: doc_store.folder() / n for n in plan} + raw = {n: p.read_bytes() for n, p in paths.items() if p.is_file()} + book_raw = book_path.read_bytes() if book["다음"] != old_book["다음"] else None + try: + if book_raw is not None: + mk.save_book(book, book_path) + for name, data in plan.items(): + doc_store.put(paths[name], data) + except BaseException: + _undo(paths, raw, book_path, book_raw) + raise + mirror(edits) + files = list(dict.fromkeys(str(p.get("file")) for p in parts)) + return { + "files": [{"file": f, "version": doc_store.file_version(f)} for f in files], + "added": added, + "warnings": [], + } + + +def _undo(paths: dict, raw: dict, book_path: Path, book_raw: bytes | None) -> None: + """쓰기 중간 실패 — 문서 파일 · 대장을 저장 전 글로(새로 만든 문서 파일은 지움).""" + for name, path in paths.items(): + if name in raw: + _put(path, raw[name]) + else: + path.unlink(missing_ok=True) + if book_raw is not None: + _put(book_path, book_raw) + doc_store._memo.clear() + + +def _put(path: Path, data: bytes) -> None: + tmp = path.with_name(f".{path.name}.tmp") + tmp.write_bytes(data) + os.replace(tmp, path) + + +# ── 옛 로직 줄 같이 쓰기 — 로직 JSON 을 쓰는 단 한 자리(둘째 박자에서 지움) ────────── +def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None: + """문서에 한 고침을 옛 로직 줄에도 — 머리(이름표 · 이름 · 결과단위 · 출처 · 부품 덮음) · + 더함(본뜬 로직 줄 셈 칸 / 빈 셈 칸) · 지움 · 기계 고르기 목록(`picks` = 더함 · 뺌). + 검사 없음(문서가 정본) · 스위치 `WRITE` 가 꺼지면 아무것도 안 함.""" + if not WRITE or (not edits and not picks): + return + with store._LOCK: + files = store.loaded()[0] + logic = {n: d for n, d in files.items() if d.get("그룹") == "로직"} + where = {str(r.get("키")): n for n, d in logic.items() for r in d.get("줄") or []} + after = {n: {**d, "줄": list(d.get("줄") or [])} for n, d in logic.items()} + touched: set[str] = set() + for op, key, what in edits: + if op == "더함": + name = what["file"] + if name not in after: # 자체 로직 파일이 없으면 머리만 두고 만듦 + after[name] = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []} + src = next((r for r in logic.get(where.get(what["from"], ""), {}).get("줄") or [] + if str(r.get("키")) == what["from"]), None) # fmt: skip + calc = {k: copy.deepcopy(v) for k, v in (src or CALC).items() if k not in FIELDS} + after[name]["줄"].append(_ordered({**what["row"], **calc, "키": key})) + where[key] = name + elif (name := where.get(key)) is not None: + rows = after[name]["줄"] + at = _at(rows, key) + if at is None: + continue + if op == "지움": + del rows[at] + else: + rows[at] = _headed_row(rows[at], what) + else: + continue + touched.add(name) + if picks: + touched |= _picks(after, *picks) + for name in touched: + _write(name, logic.get(name), after[name]) + store.cache.stale(touched) + + +def _ordered(row: dict) -> dict: + """새 로직 줄 칸 차례 — `_틀.md` 2장(`mk.ROW_ORDER`) 다음 나머지.""" + order = mk.ROW_ORDER["로직"] + return {**{k: row[k] for k in order if k in row}, **{k: v for k, v in row.items() if k not in order}} + + +def _headed_row(row: dict, head_: dict) -> dict: + """로직 줄 머리를 문서 머리와 같게 — 있던 칸은 제자리 · 빠진 머리 칸은 뺌 · 새 칸은 끝(옛 [저장]과 같음).""" + out = {k: head_[k] if k in FIELDS else v for k, v in row.items() if k not in FIELDS or k in head_} + return {**out, **{k: v for k, v in head_.items() if k not in out}} + + +def _picks(after: dict, add: dict, drop: set) -> set[str]: + """기계경비식 로직 줄 「기계」 고르기 목록에 더함 · 뺌(문서 `선택 목록` 과 같게 · 848-5).""" + touched = set() + for name, data in after.items(): + if "건설기계" not in name: + continue + for at, row in enumerate(data["줄"]): + pick = next((i for i in row.get("입력") or [] if i.get("이름") == "기계" and "고르기" in i), None) + if pick is None: + continue + codes = [c for c in pick["고르기"] if str(c) not in drop] + codes += [c for c in add.get(str(row["키"]), []) if c not in codes] + if codes != pick["고르기"]: + new = copy.deepcopy(row) + next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes + data["줄"][at] = new + touched.add(name) + return touched + + +def _write(name: str, before: dict | None, after: dict) -> None: + path = store.FOLDER / name + text = None + if before is not None and path.is_file(): + text = keep_shape(path.read_bytes().decode("utf-8"), before, after, "줄") + _put(path, (text or dump(after)).encode("utf-8")) diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py index 2718e60fa..2eefbac48 100644 --- a/M01_MasterData/M01_MasterData_Store_Make.py +++ b/M01_MasterData/M01_MasterData_Store_Make.py @@ -1,21 +1,20 @@ -"""M01 「만들기」 저장소 — 원문 절 목록 · 표 조건 값 · 자체 로직 만들기·본뜨기·고치기·지우기 -· 복사해서 만들기(정본 로직을 별칭 꼴 식으로 펴 보이고 되돌려 저장). +"""M01 「만들기」 저장소 — 원문 절 목록 · 표 조건 값 · 자체 로직 만들기 · 본뜨기(= [복사/생성]) · 고치기 · 지우기. -계약: `resources/master_data/_화면_계약.md` 2장·5장·7장 · 파일 모양: `_틀.md` 7장. -자체 로직은 `로직_자체.json` 한 파일 · 키는 `_키대장.json` 의 `GX` 다음 번호(서버가 줌). +계약: `resources/master_data/_화면_계약.md` 2장·5장 · 파일 모양: `_틀.md` 7장. +기초(로직) 저장 = 수식 문서 먼저(`Store_Logic` · 855 L3 ⓐ) · 자체 기초는 `수식_자체.json` 한 파일 · +키는 `_키대장.json` 의 `GX` 다음 번호(서버가 줌). """ from __future__ import annotations import re -from pathlib import Path - -from common_util.common_util_time import kst_today +from M01_MasterData import M01_MasterData_Doc as doc_store from M01_MasterData import M01_MasterData_Machine as machine from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Logic as logic_store from M01_MasterData import M01_MasterData_Store_Revise as revise -cm, mk, mcp = store.cm, store.mk, store.mcp +cm, mk = store.cm, store.mk OWN = "로직_자체.json" # 자체 로직 한 자리 — 이 파일 줄만 고치고 지울 수 있음 OWNERS = ("현장", "공용") @@ -206,97 +205,46 @@ def source(src: str) -> dict: return {"source": src, "found": found} -# ── 자체 로직 ────────────────────────────────────────────────────────── -def _own_path() -> Path: - return store.FOLDER / OWN - - -def _make_file() -> None: - """자체 로직 파일이 없으면 머리만 두고 만듦.""" - path = _own_path() - if path.is_file(): - return - head = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []} - path.write_text(store.dump(head), encoding="utf-8", newline="\n") +# ── 저장 ────────────────────────────────────────────────────────────── +def _alias(part: dict) -> None: + """별칭(815-2) = 앞뒤 빈칸만 뗌 · 빈 글 = 칸 없음.""" + for ch in part.get("changes") or []: + row = ch.get("row") + if isinstance(row, dict) and "별칭" in row: + text = str(row["별칭"] or "").strip() + row.update(별칭=text) if text else row.pop("별칭") def save(batch: list[dict], confirmed: bool = False) -> dict: - """`/save` — 로직 정본 줄 고침은 `confirmed`(「원문 개정 반영」) 없으면 409(`Store_Revise`) · - 자체 파일 새 줄(키 없음)은 서버가 칸을 잡고 GX 다음 키 — {files, added, warnings}.""" - revise.guard(batch, confirmed) + """`/save` — 기초(로직 파일 몫)는 `Store_Logic`(문서 먼저 · 정본 머리 고침은 `confirmed` 없으면 409) · + 요소 · 표는 `store.save` · 자체 새 줄(키 없음)은 서버가 칸을 잡고 GX 다음 키 — {files, added, warnings}.""" + logic = [p for p in batch if logic_store.is_logic(str(p.get("file") or ""))] + rest = [p for p in batch if not logic_store.is_logic(str(p.get("file") or ""))] + revise.guard(logic, confirmed) for part in batch: + _alias(part) + for part in logic: for ch in part.get("changes") or []: row = ch.get("row") - if ( - isinstance(row, dict) and "별칭" in row - ): # 별칭(815-2) = 앞뒤 빈칸만 뗌 · 빈 글 = 칸 없음 - text = str(row["별칭"] or "").strip() - row.update(별칭=text) if text else row.pop("별칭") - machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2) - _keep_same(part) - docs_too = machine.register( - batch - ) # [새 기계] = 꼴 식 목록 등록(822-2 · 개정확인 밖 — 자동 고침) - fresh = False - for part in batch: - if part.get("file") != OWN: - continue - for ch in part.get("changes") or []: - row = ch.get("row") - if isinstance(row, dict) and (ch.get("op") == "add" or not ch.get("key")): + if part.get("file") == OWN and isinstance(row, dict) and (ch.get("op") == "add" or not ch.get("key")): ch.update(op="add", key=None, row=_clean(row, str(row.get("소유") or OWNERS[0]))) - if not _own_path().is_file(): - _make_file() - fresh = True - part["version"] = part.get("version") or store.read(OWN)[1] - before = {p["file"]: set(_file_keys(p["file"])) for p in batch} # 자재 3만 키 — 목록 찾기 금지 - try: + files, added = [], [] + if rest: + for part in rest: + machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2) + _keep_same(part) + docs_too = machine.register(rest) # [새 기계] = 꼴 식 목록 등록(822-2 · 848-5 문서 정본) + before = {p["file"]: set(_file_keys(p["file"])) for p in rest} # 자재 3만 키 — 목록 찾기 금지 with store.cache.picks(*getattr(docs_too, "lists", ({}, set()))): - files = store.save(batch) - except store.StoreError: - if fresh: - _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 - ] - _sync_tags(batch, added) + files = store.save(rest) + docs_too() + added = [{"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old] + if logic: + got = logic_store.save(logic, True) + files, added = files + got["files"], added + got["added"] return {"files": files, "added": added, "warnings": []} -def _sync_tags(batch: list[dict], added: list[dict]) -> None: - """고친 · 더한 로직 줄 이름표(비고 · 별칭 · 이름 · 개정 …)를 수식 문서에도(855 L1 · 두 곳 같게) · - 더한 로직 줄은 문서부터 둠(`Doc.ensure` — 목록이 문서에서 읽음 · 855 L2 ⓐ).""" - from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게 - - files = store.loaded()[0] - for a in added: - if (files.get(a["file"]) or {}).get("그룹") == "로직": - doc_store.ensure(a["key"]) - keys = {a["key"] for a in added} | { - str(c.get("key")) - for p in batch - for c in p.get("changes") or [] - if c.get("op") == "edit" and c.get("key") - } - doc_store.sync_tags(keys) - - -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) @@ -315,11 +263,7 @@ def _file_keys(file: str) -> list[str]: return [str(r.get("키")) for r in data.get(store.items_key(data)) or []] -def _find(key: str) -> tuple[str, dict]: - got = store.logic(key) - return got["file"], got["logic"] - - +# ── 자체 로직 ────────────────────────────────────────────────────────── def _clean(logic: dict, owner: str, key: str | None = None) -> dict: """서버가 잡는 칸 — 키·소유·구분·상세구분. 화면이 보낸 것은 안 씀.""" if not isinstance(logic, dict) or not str(logic.get("이름") or "").strip(): @@ -354,79 +298,23 @@ def _chapter_of(logic: dict) -> str: return "" -def _write(changes: list[dict]) -> dict: - """자체 파일 한 벌 저장 — 검사는 `/save` 와 같음(422 면 아무것도 안 씀).""" - fresh = not _own_path().is_file() - _make_file() - try: - out = store.save([{"file": OWN, "version": store.read(OWN)[1], "changes": changes}]) - except store.StoreError: - if fresh: - _own_path().unlink(missing_ok=True) - raise - return out[0] +def logic_new(logic: dict, owner: str = OWNERS[0], source: str = "") -> dict: + """새 자체 기초 — 키 = 서버가 `GX` 다음 번호 · 문서 = 빈 문서 / `source` 문서 복제(본뜸) · + 옛 로직 줄은 같이 쓰기(`Store_Logic.mirror`).""" + change = {"op": "add", "row": _clean(logic, owner), "from": source} + part = {"file": OWN, "version": doc_store.file_version(OWN), "changes": [change]} + got = logic_store.save([part], True) + key = got["added"][-1]["key"] + return {**got["files"][0], "key": key, "logic": store.logic(key)["logic"], "수식문서": True} -def _keys() -> list[str]: - if not _own_path().is_file(): - return [] - return [str(r.get("키")) for r in store.read(OWN)[0].get("줄") or []] - - -def logic_new(logic: dict, owner: str = OWNERS[0]) -> dict: - """새 자체 로직 — 키 = 서버가 `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), "") - made = doc_store.ensure(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: - """본떠 만들기 — 정본도 본뜰 수 있음 · 비고 끝에 본뜬 키를 적음.""" - _, row = _find(key) +def logic_copy(key: str, 이름: str = "", owner: str = OWNERS[0], more: dict | None = None) -> dict: + """본떠 만들기 = [복사/생성] — 원본 문서를 새 자체 기초로 복제(정본도 본뜸) · 비고 끝에 본뜬 키 · + `more` = 기본정보 창에서 고친 원문번호 · 결과단위 · 출처(빈 글은 원본 그대로).""" + _, doc = doc_store.find(key) + row = doc_store.head_of(doc) note = " · ".join(x for x in (str(row.get("비고") or ""), f"{key} 를 본뜸") if x) - copy = {**row, "비고": note} + copy = {**row, "비고": note, **{k: v for k, v in (more or {}).items() if v}} if 이름: copy["이름"] = 이름 - return logic_new(copy, owner) - - -# ── 복사해서 만들기 ──────────────────────────────────────────────────── -def logic_formula(key: str) -> dict: - """로직 한 줄을 별칭 꼴 식 묶음으로 펴 보임 — 되돌릴 원문은 `별칭` 에 그대로(정본은 안 바뀜).""" - got = store.logic(key) - master = store.loaded()[1] - return { - "file": got["file"], - "version": got["version"], - "key": key, - "소유": got["logic"].get("소유") or "", - **mcp.spread(master, got["logic"]), - } - - -def _gather(logic: dict, marks: list[dict]) -> dict: - try: - return mcp.gather(logic, marks) - except cm.mf.FormulaError as e: - raise store.StoreError(400, str(e)) from e - - -def logic_formula_preview(logic: dict, marks: list[dict]) -> dict: - """별칭을 원문으로 되돌린 로직 줄만 — 저장 안 함(시험 계산 전 미리보기).""" - return {"logic": _gather(logic, marks)} - - -def logic_from_formula( - logic: dict, marks: list[dict], owner: str = OWNERS[0], 이름: str = "", 본뜬키: str = "" -) -> dict: - """고친 식 묶음을 자체 로직으로 저장 — 별칭을 원문으로 되돌린 뒤 `logic_new` 를 그대로 씀.""" - row = _gather(logic, marks) - if 이름: - row["이름"] = 이름 - if 본뜬키: - row["비고"] = " · ".join(x for x in (str(row.get("비고") or ""), f"{본뜬키} 를 본뜸") if x) - return logic_new(row, owner) + return logic_new(copy, owner, key) diff --git a/M01_MasterData/M01_MasterData_Store_Revise.py b/M01_MasterData/M01_MasterData_Store_Revise.py index 2d28fba21..1c05a9926 100644 --- a/M01_MasterData/M01_MasterData_Store_Revise.py +++ b/M01_MasterData/M01_MasterData_Store_Revise.py @@ -1,23 +1,20 @@ -"""M01 로직 정본 개정 확인 (PLAN 713-1 · 요구서 내역12 4장 10 · 17). +"""M01 단가산출 기초 정본 개정 확인 (PLAN 713-1 · 요구서 내역12 4장 10 · 17 · 855 L3 ⓐ 문서 기준). -- 로직 정본 파일(`로직_*.json` · 자체 `로직_자체.json` 뺌) 줄을 실제로 바꾸는 `/save`(흐름 저장 · - 지우기 포함)는 「원문 개정 반영」 확인 값(`개정확인`)이 있어야 함 — 없으면 409 + 까닭. -- 요소 파일(인력 · 재료 · 표 …) · 자체 로직 · 같은 줄 그대로 다시 보냄은 대상 밖. -- 줄 바탕 지문(`row_print`) = 계산 칸만 정렬 JSON(수는 Decimal 정규 글) sha256 앞 16 자 — - M02 덮개가 담아 두고 「M01 개정 — 확인」 배지를 띄울 값. -- 판 칸 · 옛 줄 사본은 안 둠 — 정본 이력은 git. +- 정본 기초(로직 파일 이름 `로직_*.json` · 자체 `로직_자체.json` 뺌)의 문서 머리를 실제로 바꾸는 저장 + (지우기 포함)은 「원문 개정 반영」 확인 값(`개정확인`)이 있어야 함 — 없으면 409 + 까닭. +- 대조 = 문서 머리(키 · 이름표 · 이름 · 결과단위 · 출처 · 부품) — 같은 머리를 그대로 다시 보냄은 대상 밖. +- 자체 기초 · 요소 파일(인력 · 재료 · 표 …)은 대상 밖 · 판 칸 · 옛 줄 사본은 안 둠 — 정본 이력은 git. """ from __future__ import annotations -import hashlib -import json from decimal import Decimal -from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Doc as doc_store OWN = "로직_자체.json" -PRINT_FIELDS = ("결과단위", "입력", "중간", "호표", "덧줄", "결과", "끝수", "흐름") +#: 기초 머리 — 화면 [저장]이 보내 문서에 쓰는 칸(셈 칸은 줄 쌓기 문서 저장 몫) +FIELDS = ("키", *doc_store.md.TAGS, *doc_store.HEAD) WHY = "로직 정본(품셈 원문) 줄을 바꿈 — 「원문 개정 반영」 확인 뒤 저장(개정확인)" @@ -38,30 +35,24 @@ def _norm(v): return str(v) -def row_print(row: dict) -> str: - """줄 바탕 지문 — 계산 칸(`PRINT_FIELDS`)만 · 이름 · 별칭 · 비고 고침은 지문을 안 바꿈.""" - calc = {k: _norm(row[k]) for k in PRINT_FIELDS if row.get(k) is not None} - raw = json.dumps(calc, ensure_ascii=False, sort_keys=True, separators=(",", ":")) - return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] +def _head(row: dict) -> dict: + return _norm({k: row[k] for k in FIELDS if k in row}) def changed(batch: list[dict]) -> list[dict]: - """정본 줄을 바꾸는 고침 — `[{file, key, op, 이름}]` · 같은 줄을 그대로 다시 보낸 edit 은 뺌.""" + """정본 기초 머리를 바꾸는 고침 — `[{file, key, op, 이름}]` · 같은 머리를 그대로 다시 보낸 edit 은 뺌.""" + have = doc_store.docs() out = [] for part in batch: file = str(part.get("file") or "") if not is_canon(file): continue - try: - rows = {str(r.get("키")): r for r in store.read(file)[0].get("줄") or []} - except store.StoreError: - continue # 없는 파일 — `store.save` 가 404 for ch in part.get("changes") or []: op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row") - old = rows.get(key) - if op == "edit" and old is not None and store._dec(row) == old: + old = have.get(key) + if op == "edit" and old is not None and isinstance(row, dict) and _head(row) == _head(old): continue - name = (row or {}).get("이름") if isinstance(row, dict) else None + name = row.get("이름") if isinstance(row, dict) else None out.append( { "file": file, @@ -78,4 +69,4 @@ def guard(batch: list[dict], confirmed: bool) -> None: return hits = changed(batch) if hits: - raise store.StoreError(409, {"개정": hits, "까닭": WHY}) + raise doc_store.store.StoreError(409, {"개정": hits, "까닭": WHY}) From 5dfe3761a2e1de42245abe38ff18daa0add813da Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 07:18:04 +0900 Subject: [PATCH 12/13] auto: 2026-11-18 07:18 (ESD_LAPTOP) --- M02_MasterTemplete/M02_Labor_Inputs.py | 104 ++++++++++-------- M02_MasterTemplete/M02_Logic_Settle.py | 115 -------------------- M02_MasterTemplete/M02_Logic_Standard.py | 55 ++++------ resources/tester/test_222_1_m02_apart.py | 10 +- resources/tester/test_704_logic_standard.py | 2 +- resources/tester/test_704_settle.py | 48 +------- resources/tester/test_727_sk_base_add.py | 3 +- resources/tester/test_855_c4_doc_text.py | 2 +- 8 files changed, 94 insertions(+), 245 deletions(-) delete mode 100644 M02_MasterTemplete/M02_Logic_Settle.py diff --git a/M02_MasterTemplete/M02_Labor_Inputs.py b/M02_MasterTemplete/M02_Labor_Inputs.py index 204102bfe..6e885c795 100644 --- a/M02_MasterTemplete/M02_Labor_Inputs.py +++ b/M02_MasterTemplete/M02_Labor_Inputs.py @@ -1,9 +1,9 @@ """M02 일위대가 입력 목록(39-3). 담은 단가산출 로직마다 입력 전부 · 로직마다 갈라 보이고 이름이 같아도 합치지 않음 · 입력 목록은 -그 로직 줄의 `입력` 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직 입력으로만) · 자동값 = -`master_auto.values`(보기용 · 저장 안 함). 일위대가 입력 모달(`GET /api/m02/logic-lib/inputs`)이 -씀. M01 은 읽기만 · 권한은 부르는 쪽 몫. +그 수식 문서의 입력 변수(갈래 입력 · 선택) 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직 +입력으로만) · 자동값 = `M02_Doc_Copy.auto_of`(보기용 · 저장 안 함). 일위대가 입력 모달 +(`GET /api/m02/logic-lib/inputs`)이 씀. M01 은 읽기만(수식 문서 · 855 L2 ⓑ) · 권한은 부르는 쪽 몫. """ from __future__ import annotations @@ -12,10 +12,10 @@ import re from decimal import Decimal from typing import Any +from M01_MasterData import M01_MasterData_Doc as m01doc from M01_MasterData import M01_MasterData_Store as m01 -from M01_MasterData import M01_MasterData_Store_Combo as combo_store -_SPEC = ("이름", "설명", "단위", "고르기", "범위") +INPUTS = ("입력", "선택") # 문서 입력 변수 갈래 _LAYERED = "골쌓기 기준" # 85-2 — 표 주문에 이 글이 있으면 켜쌓기율 대상 로직 _NUMBER = re.compile(r"(? Any: return value -def _logics(codes: list[str]) -> tuple[list[dict], list[str]]: - """([로직 줄 …], 빠진 로직 키) — 키 차례 그대로.""" - whole = m01.loaded()[1] - found, missing = [], [] - for code in codes: - try: - found.append(whole.logic(code)) - except combo_store.cm.mf.FormulaError: - missing.append(code) - return found, missing +def _docs(codes: list[str]) -> tuple[list[dict], list[str]]: + """([수식 문서 …], 빠진 로직 키) — 키 차례 그대로.""" + docs = m01doc.docs() + found = [docs[code] for code in codes if code in docs] + return found, [code for code in codes if code not in docs] + + +def specs(doc: dict) -> list[dict[str, Any]]: + """문서 입력 변수 → 입력 칸 `{이름: 열쇠, 설명, 단위, 고르기?(선택 목록), 범위?}`(변수 차례).""" + out = [] + for v in doc.get("변수") or []: + link = v.get("연결") or {} + if link.get("갈래") not in INPUTS or not v.get("열쇠"): + continue + one = {"이름": v["열쇠"], "설명": v.get("설명") or None, "단위": v.get("단위") or None} + if link.get("갈래") == "선택": + one["고르기"] = list(link.get("목록") or []) + if link.get("범위"): + one["범위"] = list(link["범위"]) + out.append(one) + return out def layered() -> set[str]: @@ -65,50 +76,51 @@ def _labels(whole: Any, spec: dict) -> dict[str, str]: return out -def sources(logic: dict) -> Any: - """원문 출처(222-1) — 로직 `출처` + 호표 · 입력 · 중간 · 덧줄 `출처` 가운데 같은 책(번호 앞 글이 - 같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이 절마다 찾음 · M01 - `make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로.""" - main = str(logic.get("출처") or "") +def sources(doc: dict) -> Any: + """원문 출처(222-1) — 문서 `출처` + 금액 수량 줄 · 변수 · 금액 식 줄(수량 없음) `출처` + 가운데 같은 책(번호 앞 글이 같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이 + 절마다 찾음 · M01 `make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로.""" + main = str(doc.get("출처") or "") head = _NUMBER.search(main) if not head: - return logic.get("출처") + return doc.get("출처") book, seen = main[: head.start()], set(_NUMBER.findall(main)) + money = [x for x in doc.get("금액") or [] if isinstance(x, dict)] + rows = [x for x in money if "수량" in x] + list(doc.get("변수") or []) extra = [] - for part in ("호표", "입력", "중간", "덧줄"): - for row in logic.get(part) or []: - src = str(row.get("출처") or "") if isinstance(row, dict) else "" - hit = _NUMBER.search(src) - if hit and src[: hit.start()] == book and hit.group() not in seen: - seen.add(hit.group()) - extra.append(hit.group()) + for row in rows + [x for x in money if "수량" not in x]: + src = str(row.get("출처") or "") if isinstance(row, dict) else "" + hit = _NUMBER.search(src) + if hit and src[: hit.start()] == book and hit.group() not in seen: + seen.add(hit.group()) + extra.append(hit.group()) return " · ".join([main, *extra]) -def _listed(logics: list[dict]) -> list[dict[str, Any]]: - """로직 줄마다 `{로직, 이름, 결과단위, 출처, 켜쌓기, 입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`.""" +def _listed(docs: list[dict]) -> list[dict[str, Any]]: + """문서마다 `{로직, 이름, 결과단위, 출처, 켜쌓기, + 입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`.""" + from M02_MasterTemplete import M02_Doc_Copy as dc + whole = m01.loaded()[1] layers = layered() out = [] - for logic in logics: - auto = m01.mau.values(whole, logic) - specs = [] - for spec in logic.get("입력") or []: - one = {k: spec[k] for k in _SPEC if k in spec} - one.setdefault("설명", None) - one.setdefault("단위", None) - labels = _labels(whole, spec) + for doc in docs: + auto = dc.auto_of(doc, whole) + rows = [] + for one in specs(doc): + labels = _labels(whole, one) if labels: one["고르기이름"] = labels - specs.append({**one, "자동값": auto.get(spec["이름"])}) + rows.append({**one, "자동값": auto.get(one["이름"])}) out.append( { - "로직": logic.get("키"), - "이름": logic.get("이름"), - "결과단위": logic.get("결과단위"), - "출처": sources(logic), - "켜쌓기": logic.get("키") in layers, - "입력": specs, + "로직": doc.get("키"), + "이름": doc.get("이름"), + "결과단위": doc.get("결과단위"), + "출처": sources(doc), + "켜쌓기": doc.get("키") in layers, + "입력": rows, } ) return out @@ -116,5 +128,5 @@ def _listed(logics: list[dict]) -> list[dict[str, Any]]: def logic_inputs(codes: list[str]) -> dict[str, Any]: """일위대가 입력 모달 — 로직 키들의 입력 목록 `{로직: [...], 빠진로직}`(키 차례 · 겹침 한 번)""" - found, missing = _logics(list(dict.fromkeys(c for c in codes if c))) + found, missing = _docs(list(dict.fromkeys(c for c in codes if c))) return _num({"로직": _listed(found), "빠진로직": missing}) diff --git a/M02_MasterTemplete/M02_Logic_Settle.py b/M02_MasterTemplete/M02_Logic_Settle.py deleted file mode 100644 index 8900471e7..000000000 --- a/M02_MasterTemplete/M02_Logic_Settle.py +++ /dev/null @@ -1,115 +0,0 @@ -"""M02 기준 목록 · 계산서 끝수(PLAN 704-2 딸림) — B09 산근 끝수 규칙으로 셈(③ 서버 단독 · -`B09_Estimation_Sangeun` 과 규칙 짝 · 거울 시험 `test_704_settle`). - -줄 금액 = ROUNDDOWN(단가 × 수량, 1) 비목마다 · 비목 총계 = ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합 · -작업량 Q(중간 이름 Q · Q1 …) = ROUND(식, 2) 뒤 쓰임 · % 덧줄 밑수 = 그때까지 줄 합(줄 끝수 뒤). -근거 = 지식DB `technical_info/01_임도/05_원가정보/단수처리_규칙.md`(행 금액 절사 · 관측 후보 규칙). -M01 엔진(`master_formula.run`)의 구조 그대로 — 끝수 자리만 다름(엔진은 줄 끝수 없이 계에서 한 번). -하위 로직(기계경비 포함)은 같은 규칙으로 다시 셈 · 흐름 · 결과 로직은 엔진 값 그대로. -""" - -from __future__ import annotations - -import re -from decimal import ROUND_DOWN, ROUND_HALF_UP, Decimal -from typing import Any - -from M01_MasterData import M01_MasterData_Store as m01 - -mf = m01.cm.mf -_Q = re.compile(r"Q\d*") - - -def _down(value: Any, places: int) -> Any: - return None if value is None else mf._round(Decimal(value), places, ROUND_DOWN) - - -def _bundle(whole: Any, item: dict, env: dict, depth: int) -> dict: - """로직 호표 줄이 부르는 하위 로직 — 같은 규칙으로 다시 셈(엔진 `logic` 마디 그대로).""" - node = mf.parse(item["요소"]) - if node[0] != "logic": - return mf.evaluate(node, env, whole, depth) - given = {k: mf.evaluate(v, env, whole, depth) for k, v in node[2]} - got = settle(whole, mf.fill(node[1], env), given, depth + 1) - return got["결과"] if "결과" in got else {k: got[k] for k in mf.BUNDLE} - - -def settle(whole: Any, ref: str, given: dict, depth: int = 0) -> dict: - """`master_formula.run` 과 같은 꼴 `{줄, 노무비, 재료비, 경비, 계, 중간}` — 끝수만 B09 규칙.""" - row = whole.logic(ref) - if isinstance(row.get("흐름"), dict) or "결과" in row: - return mf.run(whole, ref, given, depth) - env = mf._inputs(row, given) - for step in row.get("중간", []): - try: - value = mf.evaluate(mf.parse(step["식"]), env, whole, depth) - except mf.EmptyInput as e: - env[step["이름"]] = mf.Blank(str(e)) - continue - if _Q.fullmatch(step["이름"]) and isinstance(value, Decimal): - value = value.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP) - env[step["이름"]] = value - lines: list[dict] = [] - for n, item in enumerate(row.get("호표", [])): - try: - qty = mf.evaluate(mf.parse(item["수량"]), env, whole, depth) - if item["종류"] == "로직": - bundle = _bundle(whole, item, env, depth) - price = bundle["계"] - split = ( - {k: qty * bundle[k] for k in mf.COST_ITEMS} - if "비목" not in item - else {item["비목"]: qty * price} - ) - else: - ref_ = ( - { - k: mf.fill(v, env) if isinstance(v, str) else v - for k, v in item["요소"].items() - } - if isinstance(item["요소"], dict) - else mf.fill(item["요소"], env) - ) - if isinstance(ref_, str) and qty != 0: - whole.get(ref_) - price = mf.mp.priced(whole, item, ref_, env, n if depth == 0 else None)[0] - if price is None and qty == 0: - price = Decimal(0) - split = {item["비목"]: None if price is None else qty * price} - except mf.EmptyInput as e: - lines.append(mf._blank_line(item, str(e))) - continue - lines.append(_line(item["이름"], split)) - sums = {k: sum((x["비목"].get(k) or 0 for x in lines), Decimal(0)) for k in mf.COST_ITEMS} - env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None} - for extra in row.get("덧줄", []): - env.update(sums) - try: - value = mf.evaluate(mf.parse(extra["식"]), env, whole, depth) - env[extra["이름"]] = value - except mf.FormulaError: - value = None - sums[extra["비목"]] += _down(value, 1) or 0 - lines.append(_line(extra["이름"], {extra["비목"]: value})) - if value is not None: - env["줄"][extra["이름"]] = lines[-1]["금액"] - sums = {k: mf.cut(row, _down(v, 0), "계") for k, v in sums.items()} - return {"줄": lines, **sums, "계": sum(sums.values()), "중간": mf._shown(env)} - - -def _line(name: str, split: dict) -> dict: - cut = {k: _down(v, 1) for k, v in split.items()} - whole_sum = None if all(v is None for v in cut.values()) else sum(v or 0 for v in cut.values()) - return {"이름": name, "비목": cut, "금액": whole_sum} - - -def apply(groups: list[dict], engine: dict, done: dict) -> None: - """계산서 묶음의 줄 금액 · 소계를 `settle` 값으로 바꿈 — 줄 차례는 엔진과 같음.""" - seq: dict[str, list] = {k: [] for k in mf.COST_ITEMS} - for eng, mine in zip(engine["줄"], done["줄"]): - for part, _ in m01.mtx._shares(eng): - seq[part].append(mine["비목"].get(part)) - for group in groups: - for line, amount in zip(group["줄"], seq.get(group["비목"], [])): - line["금액"] = amount - group["소계"] = done[group["비목"]] diff --git a/M02_MasterTemplete/M02_Logic_Standard.py b/M02_MasterTemplete/M02_Logic_Standard.py index 953cd8ba7..456f29962 100644 --- a/M02_MasterTemplete/M02_Logic_Standard.py +++ b/M02_MasterTemplete/M02_Logic_Standard.py @@ -8,13 +8,12 @@ 바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌). 금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) · 계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판). -(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.) 목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본 (storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` · 같으면 안 셈 · 셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸). 실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음. -이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫). +이름표(이름 · 구분 · 출처 · 별칭) · 기초 차례(장 차례) = 수식 문서(`M01_MasterData_Doc` · 855 L2 ⓑ). M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인). """ @@ -196,8 +195,8 @@ def _spec(given: dict, ax: list) -> str: return " · ".join(parts) -def _unit(logic: dict) -> str: - unit = str(logic.get("결과단위") or "") +def _unit(doc: dict) -> str: + unit = str(doc.get("결과단위") or "") return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit) @@ -223,24 +222,21 @@ def _money(doc: dict, links: Any, given: dict) -> Decimal | 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 [] +def _rows_of(whole: Any, doc: dict, blocked: bool, links: Any = None) -> list[dict]: 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)] head = { - "키": logic.get("키"), - "이름": logic.get("이름") or "", - "단위": _unit(logic), - "출처": logic.get("출처") or "", - "공종": kind_of(logic), - "별칭": ", ".join(x for x in [logic.get("별칭") or "", *words_of(logic)] if x), - "구분": logic.get("구분") or "", - "상세구분": logic.get("상세구분") or "", + "키": doc.get("키"), + "이름": doc.get("이름") or "", + "단위": _unit(doc), + "출처": doc.get("출처") or "", + "공종": kind_of(doc), + "별칭": ", ".join(x for x in [doc.get("별칭") or "", *words_of(doc)] if x), + "구분": doc.get("구분") or "", + "상세구분": doc.get("상세구분") or "", "막힘": blocked, } out = [] @@ -283,12 +279,12 @@ def _stamp() -> str: def _chunk(keys: list[str], blocked: set[str]) -> list[dict]: - """일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음).""" - whole = m01.loaded()[1] + """일꾼 프로세스 몫 — 로직 키들의 줄(마스터 · 수식 문서는 그 프로세스가 읽음).""" + whole, docs = m01.loaded()[1], m01_doc.docs() links = _links(whole) out = [] for key in keys: - out += _rows_of(whole, whole.logic(key), key in blocked, links) + out += _rows_of(whole, docs[key], key in blocked, links) return out @@ -296,11 +292,8 @@ def build(files: dict, workers: int = 1) -> dict: """기준 목록 통째 — 장 차례 · `workers` > 1 이면 로직을 나눠 프로세스 여럿이 셈(차례 그대로).""" why_of = m01.blocks() blocked = {k for k, why in why_of.items() if why} - keys = [ - str(logic.get("키")) - for _, data in sorted(m01._logic_files(files), key=lambda f: m01.chapter_order(f[1])) - for logic in data.get("줄") or [] - ] + chapters = sorted(m01_doc.logic_files().values(), key=m01.chapter_order) + keys = [str(doc.get("키")) for data in chapters for doc in data.get("줄") or []] size = max(1, len(keys) // (workers * 8)) parts = [keys[i : i + size] for i in range(0, len(keys), size)] if workers > 1: @@ -379,13 +372,11 @@ def _given(whole: Any, doc: 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) + m01_doc.head(key) # 없는 · 로직 아닌 키 = 옛 `Master.logic` 과 같은 까닭 글 except m01.cm.mf.FormulaError as e: raise m01.StoreError(404, str(e)) from e - if doc is None: - raise m01.StoreError(404, f"수식 문서 없음 「{key}」") + doc = m01_doc.docs()[key] given, ax = _given(whole, doc, change) links = _links(whole) got = _calc(doc, links, given) or {} @@ -393,14 +384,14 @@ def sheet(key: str, change: dict) -> dict: return labor_inputs._num( { "키": key, - "이름": logic.get("이름") or "", + "이름": doc.get("이름") or "", "규격": _spec(given, ax), - "단위": _unit(logic), - "출처": labor_inputs.sources(logic) or "", + "단위": _unit(doc), + "출처": labor_inputs.sources(doc) or "", "판": edition(files), "입력": given, "묶음": mdt.sheet_groups(doc, got, links) if got and money else [], "계": got.get("계") if money else got.get("결과"), - "기준단위": _unit(logic) or None, + "기준단위": _unit(doc) or None, } ) diff --git a/resources/tester/test_222_1_m02_apart.py b/resources/tester/test_222_1_m02_apart.py index bf391275d..00a54a552 100644 --- a/resources/tester/test_222_1_m02_apart.py +++ b/resources/tester/test_222_1_m02_apart.py @@ -5,7 +5,7 @@ 자동값(master_auto 「나누는 자리 = 1」)이 1 이라 838 ㎥(자료 · 기본값 몫 — 223 보고). ② 별도계상 — 로직 자재(`자재표시` · 빈 칸 = 기본 별도계상) = 기준에서 빠지고 `줄` 에서 지움 · `재료` 는 남음 · 사용자 자재 = 합에서 뺌(짝 TS `settle`) · 사전조합 안 줄 · 사본 셈 같은 길. -③ 원문 — 로직 출처 + 호표 · 입력 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」). +③ 원문 — 문서 출처 + 금액 줄 · 변수 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」). """ import os @@ -13,6 +13,7 @@ from decimal import Decimal import pytest +from M01_MasterData import M01_MasterData_Doc as m01_doc from M01_MasterData import M01_MasterData_Store as m01 from M01_MasterData import M01_MasterData_Store_Make as make from M02_MasterTemplete import M02_Labor_Doc as labor @@ -132,7 +133,7 @@ def test_사전조합_안_줄도_별도계상_뺌(): # ── ③ 원문 여럿 ────────────────────────────────────────────────────── def test_원문_출처는_같은_책_절_모두(): - src = inputs.sources(_whole().logic(MIX)) + src = inputs.sources(m01_doc.docs()[MIX]) assert src == "산림품셈 12-1-2 · 12-1-3" assert inputs.logic_inputs([MIX])["로직"][0]["출처"] == src assert [f["number"] for f in make.source(src)["found"]] == ["12-1-2", "12-1-3"] @@ -143,6 +144,9 @@ def test_원문_출처_번호_없거나_더할_것_없으면_그대로(): assert inputs.sources({"출처": None}) is None one = { "출처": "산림품셈 3-1", - "호표": [{"출처": "건설품셈 공통 1-2-4 3"}, {"출처": "산림품셈 3-1"}], + "금액": [ + {"수량": "1", "출처": "건설품셈 공통 1-2-4 3"}, + {"수량": "1", "출처": "산림품셈 3-1"}, + ], } assert inputs.sources(one) == "산림품셈 3-1" # 다른 책 · 같은 절은 안 붙임 diff --git a/resources/tester/test_704_logic_standard.py b/resources/tester/test_704_logic_standard.py index fcc306ce0..974face24 100644 --- a/resources/tester/test_704_logic_standard.py +++ b/resources/tester/test_704_logic_standard.py @@ -27,7 +27,7 @@ THREE = ("GF000220", "GC000404", "GF000101") # 돌쌓기 메쌓기(장비) · def _rows(key: str) -> list[dict]: whole = m01.loaded()[1] - return st._rows_of(whole, whole.logic(key), False) + return st._rows_of(whole, m01_doc.docs()[key], False) def _given(key: str, change: dict) -> dict: diff --git a/resources/tester/test_704_settle.py b/resources/tester/test_704_settle.py index 2295c13a6..8bfcee708 100644 --- a/resources/tester/test_704_settle.py +++ b/resources/tester/test_704_settle.py @@ -1,9 +1,8 @@ -"""704-2 딸림 — 기준 목록 · 계산서 끝수 = B09 산근 규칙(줄마다 ROUNDDOWN 1 · 비목마다 ROUNDDOWN 0). +"""704-2 딸림 — 계산서 끝수(줄마다 0.1 · 비목 소계 정수) · 계 = 기준 목록 금액(문서 셈). -거울: 엔진 줄(수량 · 단가)에 B09 `_money` · `block_totals` 를 그대로 씌운 값 = `settle` 값. +옛 거울(엔진 줄 + B09 끝수 = `M02_Logic_Settle`)은 부르는 곳 0 이라 그 파일과 함께 걷음(855 L2 ⓑ). """ -import re import sys from decimal import Decimal from pathlib import Path @@ -12,53 +11,10 @@ ROOT = Path(__file__).resolve().parents[2] 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 -mf = m01.cm.mf -PART_OF = {"노무비": "labor", "재료비": "material", "경비": "expense"} - - -def _plain(row: dict) -> bool: - """로직 줄 · 덧줄 · 작업량 Q 가 없는 돈 로직 — 엔진 줄만으로 B09 값을 낼 수 있음.""" - return ( - str(row.get("결과단위") or "").startswith("원") - and not row.get("덧줄") - and not row.get("끝수") - and not any(i.get("종류") == "로직" for i in row.get("호표") or []) - and not any(re.fullmatch(r"Q\d*", s["이름"]) for s in row.get("중간") or []) - ) - - -def test_줄마다_버림_비목마다_버림_B09와_같음(): - files, whole = m01.loaded() - checked = 0 - for _, data in m01._logic_files(files): - for row in data.get("줄") or []: - if not _plain(row) or checked >= 60: - continue - base, _ = ls.axes(whole, m01_doc.docs()[row["키"]]) - given = mf.fill_empty(row, base) - got = mf.run(whole, row["키"], given) - lines = [] - for line in got["줄"]: - one = dict.fromkeys(PART_OF.values(), 0.0) - for part, money in line["비목"].items(): - one[PART_OF[part]] = sg._money(1.0, float(money)) if money is not None else None - lines.append(one) - if any(v is None for one in lines for v in one.values()): - continue - want = sg.block_totals(lines) - mine = st.settle(whole, row["키"], given) - for name, part in PART_OF.items(): - assert float(mine[name]) == want[part], (row["키"], name) - assert float(mine["계"]) == want["sum"], row["키"] - checked += 1 - assert checked >= 30 - def test_계산서_줄_소계_계가_맞물림(): files, whole = m01.loaded() diff --git a/resources/tester/test_727_sk_base_add.py b/resources/tester/test_727_sk_base_add.py index 3490829dd..a0368cd12 100644 --- a/resources/tester/test_727_sk_base_add.py +++ b/resources/tester/test_727_sk_base_add.py @@ -15,6 +15,7 @@ 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 M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs @@ -52,7 +53,7 @@ def test_727_1_기초마다_한_줄(): whole = m01.loaded()[1] rows = [] for key in (GF, "GC000269", "GC001109"): - rows += standard._rows_of(whole, whole.logic(key), False) + rows += standard._rows_of(whole, m01_doc.docs()[key], False) assert sum(r["키"] == GF for r in rows) == 3 # 옵션 축 보정작업 두 값 + 바탕 got = _heads(rows) assert [r["키"] for r in got] == [GF, "GC000269", "GC001109"] diff --git a/resources/tester/test_855_c4_doc_text.py b/resources/tester/test_855_c4_doc_text.py index b94225ef2..795fd891a 100644 --- a/resources/tester/test_855_c4_doc_text.py +++ b/resources/tester/test_855_c4_doc_text.py @@ -149,7 +149,7 @@ 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): + for row in st._rows_of(whole, docs[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 0e4f3604b8833868265e33123e3f6a2151e49f06 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 07:18:07 +0900 Subject: [PATCH 13/13] auto: 2026-11-18 07:18 (ESD_LAPTOP) --- M02_MasterTemplete/M02_Labor_Ref.py | 78 ++------ M02_MasterTemplete/M02_Labor_Router.py | 4 +- M02_MasterTemplete/M02_Layer_Index.py | 50 +---- M02_MasterTemplete/M02_Library_Delete.py | 69 +++---- M02_MasterTemplete/M02_Library_Same_Router.py | 22 +-- M02_MasterTemplete/M02_Library_Uses.py | 185 ++++++++++++++++++ M02_MasterTemplete/M02_Material_Own.py | 33 +--- M02_MasterTemplete/M02_MyMachine.py | 49 +++-- resources/tester/test_740_1_library_flat.py | 3 +- resources/tester/test_797_1_import_links.py | 3 +- resources/tester/test_826_1_layer_index.py | 9 +- resources/tester/test_827_1_machine_window.py | 3 +- resources/tester/test_m02_labor_ref.py | 7 +- 13 files changed, 290 insertions(+), 225 deletions(-) create mode 100644 M02_MasterTemplete/M02_Library_Uses.py diff --git a/M02_MasterTemplete/M02_Labor_Ref.py b/M02_MasterTemplete/M02_Labor_Ref.py index ea15b79a5..468cb5b8f 100644 --- a/M02_MasterTemplete/M02_Labor_Ref.py +++ b/M02_MasterTemplete/M02_Labor_Ref.py @@ -398,7 +398,7 @@ def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]: def summary( - folder: Path, kind: str, key: str, expand: Expand | None = None, files: UseFiles | None = None + folder: Path, kind: str, key: str, expand: Expand | None = None, files: list | None = None ) -> dict[str, Any]: """층 목록 한 줄에 붙일 것 — `{제목, 단위, 구분, 상세구분, 연결}`(51-12) · `expand` 면 1 단위 기준 계(`기준금액` · 51-4).""" @@ -422,14 +422,16 @@ def summary( top, (layer, owner) = doc.get("바탕") or {}, where(folder) logic = top.get("로직") out["바탕"] = logic or (top.get("참조") or {}).get("키") - if logic and expand is not None: - try: - out["바탕"] = f"{logic} {expand.whole.logic(logic).get('이름') or ''}".strip() - except Exception: # noqa: BLE001 — 없는 로직 = 키만(셈 때 까닭) - pass + if logic and expand is not None: # 이름 = M01 수식 문서(로직 줄 안 읽음 · 855 L2 ⓑ) + from M01_MasterData import M01_MasterData_Doc as m01doc + + name = (m01doc.docs().get(str(logic)) or {}).get("이름") or "" + out["바탕"] = f"{logic} {name}".strip() # 없는 기초 = 키만(셈 때 까닭) out["고친줄수"] = sum(len(doc.get(k) or ()) for k in ("덮개", "더한줄", "뺀줄")) - # SK 마다 모든 층 훑음(users) — 파일 읽기는 판 기억(`_ids_of`)이라 처음 한 번만 무거움 - out["쓰는곳수"] = len(users({"층": layer, "주인": owner, "키": key}, files)) + # SK 마다 모든 층 훑음 — 파일 읽기는 판 기억(`M02_Library_Uses.ids_of`)이라 처음 한 번만 무거움 + from M02_MasterTemplete import M02_Library_Uses as uses + + out["쓰는곳수"] = len(uses.users({"층": layer, "주인": owner, "키": key}, files)) return out @@ -439,66 +441,20 @@ def summaries(folder: Path, rows: list[dict[str, Any]]) -> None: from M02_MasterTemplete.M02_Labor_Expand import Expand expand = Expand(m01.loaded()[1]) - files = use_files() if any(row["종류"] == "sangeun" for row in rows) else None + from M02_MasterTemplete import M02_Library_Uses as uses + + files = uses.files() if any(row["종류"] == "sangeun" for row in rows) else None for row in rows: if row["종류"] in layers.LIBRARY_KINDS: row.update(summary(folder, row["종류"], row["이름"], expand, files)) # ── 쓰는 곳 · 지우기 ────────────────────────────────────────────────── -UseFiles = list[tuple[str, str, Path]] - - -def use_files() -> UseFiles: - """쓰는 곳을 찾을 파일 — (무엇, 어디, 파일) · 목록 한 번에 한 번 찾음(818-1).""" - # 「일위대가」 = 사전조합 새 이름(내역 14 확정 1) · 구조물 조합 일위대가 = 「구조물 조합」 - kinds = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출")) - return [(what, at, path) for kind, what in kinds for at, path in layers.layer_files(kind)] - - -def users(ref: Ref, files: UseFiles | None = None) -> list[str]: - """`ref` 를 담은 일위대가 · 사전조합 · 단가산출(바탕 · 더한줄) — 「어디 이름」 목록(모든 층 훑음 · - 프로젝트 뺌).""" - rid, out = ref_id(ref), [] - for what, at, path in use_files() if files is None else files: - got = _ids_of(path) - if got and rid in got[1]: - out.append(f"{what} {at} 「{got[0]}」") - return out - - -_IDS: dict[Path, tuple[tuple[int, int], tuple[str, frozenset[str]]]] = {} - - -def _ids_of(path: Path) -> tuple[str, frozenset[str]] | None: - """파일 하나의 (이름, 참조 이름표들) — 판(고친 때 · 크기)이 같으면 기억한 것(818-1 · 로직 사본으로 - SK 파일이 MB 단위라 목록 줄마다 모든 층을 다시 읽으면 분 단위).""" - try: - st = path.stat() - stamp = (st.st_mtime_ns, st.st_size) - if (hit := _IDS.get(path)) and hit[0] == stamp: - return hit[1] - doc = json.loads(path.read_bytes()) - except (OSError, ValueError): - return None - name = ( - (doc.get("일위대가번") or doc.get("이름") or path.stem) - if isinstance(doc, dict) - else path.stem - ) - got = (str(name), frozenset(ref_id(one) for one in refs_in(doc))) - _IDS[path] = (stamp, got) - return got - - def refuse_used(folder: Path, kind: str, key: str) -> None: - """쓰는 곳이 있으면 409 + 이름(서고 종류만).""" - if kind not in PREFIX: - return - layer, owner = where(folder) - found = users({"층": layer, "주인": owner, "키": key}) - if found: - raise _bad(f"쓰는 곳이 있어 못 지움 「{key}」 — " + " · ".join(found), 409) + """쓰는 곳이 있으면 409 — 쓰는 곳 색인 한 벌(`M02_Library_Uses` · 858 5-5).""" + from M02_MasterTemplete import M02_Library_Uses as uses + + uses.refuse_used(folder, kind, key) # ── 층 사이 복사 ────────────────────────────────────────────────────── diff --git a/M02_MasterTemplete/M02_Labor_Router.py b/M02_MasterTemplete/M02_Labor_Router.py index a1ea5e11f..2b8253dfc 100644 --- a/M02_MasterTemplete/M02_Labor_Router.py +++ b/M02_MasterTemplete/M02_Labor_Router.py @@ -175,7 +175,9 @@ def own_materials( return {"줄": []} folder = _root(session, layer, owner) rows = own.rows(folder) - used = own.usage(folder, [str(r.get("키")) for r in rows]) + from M02_MasterTemplete import M02_Library_Uses as library_uses + + used = library_uses.materials(folder, [str(r.get("키")) for r in rows]) return {"줄": [{**r, "쓰는곳": used[str(r.get("키"))]} for r in rows]} diff --git a/M02_MasterTemplete/M02_Layer_Index.py b/M02_MasterTemplete/M02_Layer_Index.py index 9203e5d68..00a04b1e9 100644 --- a/M02_MasterTemplete/M02_Layer_Index.py +++ b/M02_MasterTemplete/M02_Layer_Index.py @@ -6,9 +6,9 @@ 요약 서고 줄 `M02_Labor_Ref.summary`(쓰는곳수 뺌) — 자국 · 바탕 · 기댐이 모두 같을 때만 씀 바탕 셈 코드 내용 · M01 폴더 · 층 곁 파일(내 기계 등 — 항목 폴더 · manifest 뺌) 자국 지문 기댐 셈 때 읽은 참조 파일(SC · SK) 자국(`refs.SEEN`) -쓰는곳수 = 요청마다 쓰는 곳 파일을 한 번 훑어 거꾸로 셈(`refs._ids_of` 기억 · 파일당 stat 한 번). +쓰는곳수 = 요청마다 쓰는 곳 색인을 한 번 훑어 거꾸로 셈(`M02_Library_Uses.counts` · 파일당 stat 한 번). 자리 = 프로세스 메모리 + storage `_derived/m02_layer_index/`(파생 저장본 · 층마다 한 파일 · -참조 이름표 기억 `ids.json`) — 없거나 깨지면 다시 지음 · 지워도 됨 · 다른 PC · 옛 코드는 안 읽음. +참조 이름표 기억 `ids.json` 은 `M02_Library_Uses` 몫) — 없거나 깨지면 다시 지음 · 지워도 됨. """ from __future__ import annotations @@ -28,11 +28,9 @@ from M02_MasterTemplete import M02_Template_Layers as layers KIND = "m02_layer_index" SHAPE = 1 # 기록 꼴이 바뀌면 올림(옛 기록 = 다시 셈) -IDS = "ids" CODE_DIRS = ("M02_MasterTemplete", "M01_MasterData", "resources/master_data/scripts", "common_util") _LOCK = threading.RLock() _MEM: dict[str, dict[str, Any]] = {} # 층 열쇠 → {항목: 기록} -_IDS_LOADED: list[bool] = [] @lru_cache(maxsize=1) @@ -175,47 +173,9 @@ def summaries(folder: str | Path, rows: list[dict[str, Any]]) -> None: _save(key, recs) sk = [row for row in lib if row["종류"] == "sangeun" and "고친줄수" in row] if sk: - uses, (layer, owner) = _uses(), refs.where(folder) + from M02_MasterTemplete import M02_Library_Uses as library_uses + + uses, (layer, owner) = library_uses.counts(), refs.where(folder) for row in sk: rid = refs.ref_id({"층": layer, "주인": owner, "키": row["이름"]}) row["쓰는곳수"] = uses.get(rid, 0) - - -# ── 쓰는 곳 수 ──────────────────────────────────────────────────────── -def _uses() -> dict[str, int]: - """참조 이름표 → 담은 파일 수(`refs.users` 개수와 같음) — 쓰는 곳 파일 한 번 훑음.""" - _load_ids() - before = {path: hit[0] for path, hit in refs._IDS.items()} - files = [path for _what, _at, path in refs.use_files()] - count: dict[str, int] = {} - for path in files: - got = refs._ids_of(path) - for rid in got[1] if got else (): - count[rid] = count.get(rid, 0) + 1 - if any(before.get(path) != refs._IDS[path][0] for path in files if path in refs._IDS): - _save_ids() - return count - - -def _load_ids() -> None: - """참조 이름표 기억을 파생 저장본에서 채움 — 프로세스에 한 번 · 자국은 `_ids_of` 가 다시 봄.""" - if _IDS_LOADED: - return - _IDS_LOADED.append(True) - got = read_derived(layers.storage_root(), KIND, IDS) - for text, one in ((got or {}).get("value") or {}).items(): - try: - mtime, size, name, ids = one - refs._IDS.setdefault(Path(text), ((int(mtime), int(size)), (str(name), frozenset(ids)))) - except (TypeError, ValueError): - continue - - -def _save_ids() -> None: - """지금 기억을 디스크 것에 덧씀(다른 서버 몫 유지) · 없어진 파일 뺌.""" - got = read_derived(layers.storage_root(), KIND, IDS) - value = dict((got or {}).get("value") or {}) - for path, ((mtime, size), (name, ids)) in list(refs._IDS.items()): - value[str(path)] = [mtime, size, name, sorted(ids)] - value = {text: one for text, one in value.items() if Path(text).is_file()} - _save(IDS, value) diff --git a/M02_MasterTemplete/M02_Library_Delete.py b/M02_MasterTemplete/M02_Library_Delete.py index 47c2f7ccf..61329df94 100644 --- a/M02_MasterTemplete/M02_Library_Delete.py +++ b/M02_MasterTemplete/M02_Library_Delete.py @@ -25,12 +25,11 @@ from typing import Any from common_util.common_util_json import atomic_write_json from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Layer_Access as access +from M02_MasterTemplete import M02_Library_Uses as uses from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_MasterTemplete_Tree as tree -from M02_MasterTemplete import M02_Template_Layers as layers GONE = "_합친것" -USER_KINDS = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출")) _ADD = re.compile(r"^add:#(\d+)(.*)$") _PATCH = ("덮개", "고름", "자재표시") @@ -66,42 +65,44 @@ def _columns(folder: Path, memo: dict[Path, dict[str, str]]) -> dict[str, str]: def users(session: dict[str, Any] | None, kind: str, gone: list[str]) -> list[dict[str, Any]]: - """지금 층(`store.at`) 지울 문서를 쓰는 줄 — 모든 층(프로젝트 뺌 · 지우는 것끼리 뺌).""" + """지금 층(`store.at`) 지울 문서를 쓰는 줄 — 모든 층(프로젝트 뺌 · 지우는 것끼리 뺌) · + 쓰는 파일 = 쓰는 곳 색인(`M02_Library_Uses.index`)에 걸린 것만 열어 줄 자리를 셈.""" mine = refs.here() rids = {refs.ref_id({"층": mine[0], "주인": mine[1], "키": k}): k for k in gone} skip = {(store.root() / kind / f"{k}.json").resolve() for k in gone} + found = uses.index() + hit_files = {path for rid in rids for path, _k, _l in found.get(rid, [])} rows, memo = [], {} - for ukind, what in USER_KINDS: - for where, path in layers.layer_files(ukind): - if path.resolve() in skip: - continue - try: - doc = json.loads(path.read_bytes()) - except (OSError, ValueError): - continue - hits = _hits(doc, rids) if isinstance(doc, dict) else [] - if not hits: - continue - at = refs.where(path.parent.parent) - ok = can_write(session, at) - name = doc.get("일위대가번") or doc.get("이름") or path.stem - if ukind == "labor" and (title := _columns(path.parent.parent, memo).get(path.stem)): - name = f"{title} · {name}" - for line, key in hits: - rows.append( - { - "층": at[0], - "주인": at[1], - "어디": where, - "종류": what, - "문서종류": ukind, - "문서": path.stem, - "이름": name, - "키": key, - "줄": line, - "쓰기": ok, - } - ) + for ukind, what, where, path in uses.files(): + if path not in hit_files or path.resolve() in skip: + continue + try: + doc = json.loads(path.read_bytes()) + except (OSError, ValueError): + continue + hits = _hits(doc, rids) if isinstance(doc, dict) else [] + if not hits: + continue + at = refs.where(path.parent.parent) + ok = can_write(session, at) + name = doc.get("일위대가번") or doc.get("이름") or path.stem + if ukind == "labor" and (title := _columns(path.parent.parent, memo).get(path.stem)): + name = f"{title} · {name}" + for line, key in hits: + rows.append( + { + "층": at[0], + "주인": at[1], + "어디": where, + "종류": what, + "문서종류": ukind, + "문서": path.stem, + "이름": name, + "키": key, + "줄": line, + "쓰기": ok, + } + ) return rows diff --git a/M02_MasterTemplete/M02_Library_Same_Router.py b/M02_MasterTemplete/M02_Library_Same_Router.py index 0c4b89389..d17ee2a0f 100644 --- a/M02_MasterTemplete/M02_Library_Same_Router.py +++ b/M02_MasterTemplete/M02_Library_Same_Router.py @@ -36,16 +36,15 @@ from M02_MasterTemplete import M02_Layer_Access as access from M02_MasterTemplete import M02_Library_Delete as deleting from M02_MasterTemplete import M02_Library_Flat as flat from M02_MasterTemplete import M02_Library_Same as same +from M02_MasterTemplete import M02_Library_Uses as uses from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Precombo_Folders as pre_folders -from M02_MasterTemplete import M02_Template_Layers as layers from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _root router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete Library Same"]) Kind = Literal["precombo", "sangeun"] GONE = deleting.GONE -USER_KINDS = deleting.USER_KINDS _ORDER = {"system": 0, "company": 1, "personal": 2} @@ -89,21 +88,6 @@ def _docs(at: refs.Here, kind: str) -> list[tuple[str, dict[str, Any]]]: # ── 쓰는 곳 ─────────────────────────────────────────────────────────── -def _user_index() -> dict[str, list[tuple[Path, str, str]]]: - """모든 층(프로젝트 뺌) 훑기 한 번 — {ref_id: [(파일, 종류, 「어디 이름」)]}.""" - out: dict[str, list[tuple[Path, str, str]]] = {} - for kind, what in USER_KINDS: - for where, path in layers.layer_files(kind): - try: - doc = json.loads(path.read_bytes()) - except (OSError, ValueError): - continue - name = doc.get("일위대가번") or doc.get("이름") or path.stem - for rid in {refs.ref_id(one) for one in refs.refs_in(doc)}: - out.setdefault(rid, []).append((path, kind, f"{what} {where} 「{name}」")) - return out - - def _can_write(session: Session, at: refs.Here) -> bool: return access.can_write(session, at) @@ -177,7 +161,7 @@ def _gone_rows(folder: Path, kind: str) -> list[dict[str, Any]]: def find(folder: Path, kind: str) -> dict[str, Any]: """이 층 + 위 층 같은 지문 묶음 — 이 층 문서가 든 묶음 · 둘 이상만.""" mine = refs.where(folder) - index = _user_index() + index = uses.index() groups: dict[str, list[tuple[refs.Here, str, dict[str, Any]]]] = {} marks = same.Same() # 한 요청 안 참조 지문 메모 for at in [mine, *same.above(mine)]: @@ -235,7 +219,7 @@ def _merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[s rids = {refs.ref_id(_ref(mine, k)): k for k in gone} by_file: dict[Path, tuple[str, set[str]]] = {} labels: dict[Path, str] = {} - index = _user_index() + index = uses.index() for rid in rids: for path, ukind, label in index.get(rid, []): by_file.setdefault(path, (ukind, set()))[1].add(rid) diff --git a/M02_MasterTemplete/M02_Library_Uses.py b/M02_MasterTemplete/M02_Library_Uses.py new file mode 100644 index 000000000..f8b1ab3f8 --- /dev/null +++ b/M02_MasterTemplete/M02_Library_Uses.py @@ -0,0 +1,185 @@ +"""M02 서고 쓰는 곳 색인 한 벌(858 5-5 · 설계 `설계_858_서고한벌.md` 부품 ⑦) — 「이 문서를 누가 쓰나」. + +참조 찾기(단가산출 · 일위대가 · 구조물 조합 · 사본 블록 안 산근 — `M02_Labor_Ref.refs_in`): + 쓰는 파일 = 모든 층(마스터 · 회사 · 개인 · 프로젝트 뺌) `labor` · `precombo` · `sangeun` 파일(`files`) · + 파일마다 (이름, 참조 이름표들) 을 판(고친 때 · 크기)으로 기억(`ids_of` · 818-1) — 같은 판이면 안 엶 · + 기억은 파생 저장본 `_derived/m02_layer_index/ids.json` 에도 둠(서버를 다시 띄워도 처음부터 안 읽음 · + 지워도 다시 셈) · `users` = 「무엇 어디 「이름」」 목록 · `index` = {이름표: [(파일, 종류, 글)]} · + `counts` = {이름표: 파일 수}(목록 쓰는곳수) · `refuse_used` = 쓰는 곳 있으면 409. +자원 키 찾기(층 안): + `machines` = 내 기계 키 → 이 층 단가산출(사본 · 수식 사본 단가 줄에 그 키) · + `materials` = 내 재료 키 → 이 층 모든 문서(글에 그 키 · `_` `.` 폴더 · 내 재료 파일 뺌). +지우기 · 합치기는 `store.batch` 한 잠금 안에서 이 색인을 씀(`M02_Library_Delete` · `M02_Library_Same_Router`). +""" + +from __future__ import annotations + +import json +from pathlib import Path +from typing import Any + +from common_util.common_util_derived_store import derived_dir, read_derived +from common_util.common_util_json import atomic_write_json +from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Template_Layers as layers + +#: 쓰는 쪽 종류 — 「일위대가」 = 사전조합 새 이름(내역 14 확정 1) · 구조물 조합 일위대가 = 「구조물 조합」 +KINDS = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출")) +DERIVED, IDS = "m02_layer_index", "ids" # 파생 저장본 자리(826-1 층 목록 색인과 같은 폴더) + +UseFiles = list[tuple[str, str, str, Path]] # (종류, 무엇, 어디, 파일) +Ids = tuple[str, frozenset[str]] + +_IDS: dict[Path, tuple[tuple[int, int], Ids]] = {} +_LOADED: list[bool] = [] + + +# ── 참조 ────────────────────────────────────────────────────────────── +def files() -> UseFiles: + """쓰는 곳을 찾을 파일 — 종류 차례 · 층 차례(마스터 → 회사 → 개인).""" + return [(kind, what, at, path) for kind, what in KINDS for at, path in layers.layer_files(kind)] + + +def ids_of(path: Path) -> Ids | None: + """파일 하나의 (이름, 참조 이름표들) — 판이 같으면 기억한 것(로직 사본으로 SK 파일이 커서).""" + _load() + try: + st = path.stat() + stamp = (st.st_mtime_ns, st.st_size) + if (hit := _IDS.get(path)) and hit[0] == stamp: + return hit[1] + doc = json.loads(path.read_bytes()) + except (OSError, ValueError): + return None + name = ( + (doc.get("일위대가번") or doc.get("이름") or path.stem) if isinstance(doc, dict) else None + ) + got = (str(name or path.stem), frozenset(refs.ref_id(one) for one in refs.refs_in(doc))) + _IDS[path] = (stamp, got) + return got + + +def _scan(found: UseFiles | None) -> list[tuple[str, str, str, Path, Ids]]: + """쓰는 파일마다 (종류, 무엇, 어디, 파일, 이름표) — 기억이 바뀌었으면 파생 저장본에 덧씀.""" + found = files() if found is None else found + _load() + before = {path: hit[0] for path, hit in _IDS.items()} + out = [(*one, got) for one in found if (got := ids_of(one[3]))] + if any(before.get(one[3]) != _IDS[one[3]][0] for one in found if one[3] in _IDS): + _save() + return out + + +def users(ref: refs.Ref, found: UseFiles | None = None) -> list[str]: + """`ref` 를 담은 구조물 조합 · 일위대가 · 단가산출 — 「무엇 어디 「이름」」(프로젝트 뺌).""" + rid = refs.ref_id(ref) + return [f"{what} {at} 「{ids[0]}」" for _k, what, at, _p, ids in _scan(found) if rid in ids[1]] + + +def index(found: UseFiles | None = None) -> dict[str, list[tuple[Path, str, str]]]: + """한 번 훑어 {이름표: [(파일, 종류, 「무엇 어디 「이름」」)]}.""" + out: dict[str, list[tuple[Path, str, str]]] = {} + for kind, what, at, path, (name, rids) in _scan(found): + for rid in rids: + out.setdefault(rid, []).append((path, kind, f"{what} {at} 「{name}」")) + return out + + +def counts(found: UseFiles | None = None) -> dict[str, int]: + """{이름표: 담은 파일 수} — `users` 개수와 같음.""" + return {rid: len(hits) for rid, hits in index(found).items()} + + +def refuse_used(folder: Path, kind: str, key: str) -> None: + """쓰는 곳이 있으면 409 + 이름(서고 종류만).""" + if kind not in refs.PREFIX: + return + layer, owner = refs.where(folder) + if found := users({"층": layer, "주인": owner, "키": key}): + raise store.StoreError(409, f"쓰는 곳이 있어 못 지움 「{key}」 — " + " · ".join(found)) + + +def _load() -> None: + """기억을 파생 저장본에서 채움 — 프로세스에 한 번 · 판은 `ids_of` 가 다시 봄.""" + if _LOADED: + return + _LOADED.append(True) + got = read_derived(layers.storage_root(), DERIVED, IDS) + for text, one in ((got or {}).get("value") or {}).items(): + try: + mtime, size, name, ids = one + _IDS.setdefault(Path(text), ((int(mtime), int(size)), (str(name), frozenset(ids)))) + except (TypeError, ValueError): + continue + + +def _save() -> None: + """지금 기억을 디스크 것에 덧씀(다른 서버 몫 유지) · 없어진 파일 뺌 · 못 써도 다음에 다시 셈.""" + got = read_derived(layers.storage_root(), DERIVED, IDS) + value = dict((got or {}).get("value") or {}) + for path, ((mtime, size), (name, ids)) in list(_IDS.items()): + value[str(path)] = [mtime, size, name, sorted(ids)] + value = {text: one for text, one in value.items() if Path(text).is_file()} + try: + path = derived_dir(layers.storage_root(), DERIVED) / f"{IDS}.json" + atomic_write_json(path, {"key": IDS, "value": value}) + except OSError: + pass + + +# ── 자원 키(층 안) ───────────────────────────────────────────────────── +def machines(folder: Path | None = None) -> dict[str, list[dict[str, Any]]]: + """{내 기계 키: [{키, 이름}]} — 이 층 단가산출 가운데 사본(옛 칸 · 수식) 단가 줄에 그 키를 가진 것.""" + from M02_MasterTemplete import M02_MyMachine as mym + from M02_MasterTemplete import M02_Sangeun_Copy as skc + from M02_MasterTemplete import M02_Sangeun_Doc as sd + + out: dict[str, list[dict[str, Any]]] = {} + for path in sorted(Path(folder or store.root()).joinpath(sd.KIND).glob("SK-*.json")): + raw = path.read_bytes() + if mym.PREFIX.encode() not in raw: + continue + try: + doc = json.loads(raw) + except ValueError: + continue + keys = { # 옛 칸 사본 · 수식 길 사본(827-1) — 한 SK 한 번 + str(row["키"]) + for part in (skc.KEY, "수식") + for row in (doc.get(part) or {}).get("단가") or [] + if mym.mine(row.get("키")) + } + for key in sorted(keys): + out.setdefault(key, []).append({"키": doc.get("키"), "이름": doc.get("이름")}) + return out + + +def materials(folder: str | Path, keys: list[str]) -> dict[str, list[dict[str, Any]]]: + """{내 재료 키: [{종류, 키, 이름}]} — 그 층 문서 글에 키가 든 것(파일은 한 번씩 읽음).""" + from M02_MasterTemplete import M02_Material_Own as own + + folder = Path(folder) + out: dict[str, list[dict[str, Any]]] = {k: [] for k in keys} + for path in sorted(folder.rglob("*.json")): # 종류 폴더 · 그 밑 폴더 — 내 목록 파일 뺌 + if path.name == own.FILE or _aside(path, folder): + continue + try: + text = path.read_text(encoding="utf-8") + except OSError: + continue + if not (hit := [k for k in keys if k in text]): + continue + try: + doc = json.loads(text) + except ValueError: + continue + name = (doc.get("이름") if isinstance(doc, dict) else None) or path.stem + for k in hit: + out[k].append({"종류": path.parent.name, "키": path.stem, "이름": name}) + return out + + +def _aside(path: Path, folder: Path) -> bool: + """밑줄 · 점 폴더(「_합친것」 등 파생 · 보관) — 쓰는 곳 아님.""" + return any(x.startswith(("_", ".")) for x in path.relative_to(folder).parts[:-1]) diff --git a/M02_MasterTemplete/M02_Material_Own.py b/M02_MasterTemplete/M02_Material_Own.py index 789962c58..c7cad14a8 100644 --- a/M02_MasterTemplete/M02_Material_Own.py +++ b/M02_MasterTemplete/M02_Material_Own.py @@ -135,36 +135,11 @@ def update(folder: str | Path, key: str, body: dict[str, Any]) -> dict[str, Any] return got -def _aside(path: Path, folder: str | Path) -> bool: - """밑줄 · 점 폴더(「_합친것」 등 파생 · 보관) — 쓰는 곳 아님.""" - return any(x.startswith(("_", ".")) for x in path.relative_to(folder).parts[:-1]) - - -def usage(folder: str | Path, keys: list[str]) -> dict[str, list[dict[str, Any]]]: - """그 층에서 키마다 쓰는 문서(단가산출 · 일위대가 …) {키: [{종류, 키, 이름}]} — 파일은 한 번씩 읽음.""" - out: dict[str, list[dict[str, Any]]] = {k: [] for k in keys} - for path in sorted(Path(folder).rglob("*.json")): # 종류 폴더 · 그 밑 폴더 — 내 목록 파일 뺌 - if path.name == FILE or _aside(path, folder): - continue - try: - text = path.read_text(encoding="utf-8") - except OSError: - continue - hit = [k for k in keys if k in text] - if not hit: - continue - try: - doc = json.loads(text) - except ValueError: - continue - name = (doc.get("이름") if isinstance(doc, dict) else None) or path.stem - for k in hit: - out[k].append({"종류": path.parent.name, "키": path.stem, "이름": name}) - return out - - def uses(folder: str | Path, key: str) -> list[dict[str, Any]]: - return usage(folder, [key])[key] + """쓰는 문서 — 쓰는 곳 색인 한 벌(`M02_Library_Uses.materials` · 858 5-5).""" + from M02_MasterTemplete import M02_Library_Uses as library_uses + + return library_uses.materials(folder, [key])[key] def remove(folder: str | Path, key: str) -> None: diff --git a/M02_MasterTemplete/M02_MyMachine.py b/M02_MasterTemplete/M02_MyMachine.py index 9a5f2b25f..141e483b0 100644 --- a/M02_MasterTemplete/M02_MyMachine.py +++ b/M02_MasterTemplete/M02_MyMachine.py @@ -259,13 +259,26 @@ def hourly(row: dict, index: Any) -> dict[str, Any]: 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 · 855 2-B2) - got = mh.hour(row, logic, index) + got = mh.hour(row, _head(key), index) return {"ok": got["ok"], **head, **got} +def _head(key: str) -> dict[str, Any]: + """식 머리 {키, 입력} — M01 수식 문서에서(로직 줄 안 읽음 · 855 L2 ⓑ) · 입력 = 고르기 · 입력 변수 + (옛 로직 줄 「입력」 과 1,521 문서 같음) · 문서 없음 = 빈 입력(`hour` 가 「식 문서 없음」).""" + from M01_MasterData import M01_MasterData_Doc as m01doc + + doc = m01doc.docs().get(key) or {} + opens = [ + {"이름": v.get("이름")} + for v in doc.get("변수") or [] + if isinstance(v, dict) and (v.get("연결") or {}).get("갈래") in ("선택", "입력") + ] + return {"키": key, "입력": opens} + + # ── 검사 ────────────────────────────────────────────────────────────── def _num(value: Any, name: str) -> float | None: if value in (None, ""): @@ -479,36 +492,18 @@ def delete(key: str) -> dict[str, Any]: """지움 — 이미 만든 단가산출은 사본의 마지막 값 그대로(「지운키」).""" _user() _old(key) - used = uses().get(key, []) + used = _uses().get(key, []) with _LOCK: _old(key) (_dir() / f"{key}.json").unlink(missing_ok=True) return {"지움": key, "쓰는곳": used} -def uses() -> dict[str, list[dict]]: - """{내 기계 키: [{키, 이름}]} — 이 층 단가산출 가운데 사본(옛 칸 · 수식) 단가 줄에 그 키를 가진 것.""" - from M02_MasterTemplete import M02_Sangeun_Copy as skc - from M02_MasterTemplete import M02_Sangeun_Doc as sd +def _uses() -> dict[str, list[dict]]: + """{내 기계 키: [{키, 이름}]} — 쓰는 곳 색인 한 벌(`M02_Library_Uses.machines` · 858 5-5).""" + from M02_MasterTemplete import M02_Library_Uses as library_uses - out: dict[str, list[dict]] = {} - for path in sorted((store.root() / sd.KIND).glob("SK-*.json")): - raw = path.read_bytes() - if PREFIX.encode() not in raw: - continue - try: - doc = json.loads(raw) - except ValueError: - continue - keys = { # 옛 칸 사본 · 수식 길 사본(827-1) — 한 SK 한 번 - str(row["키"]) - for part in (skc.KEY, "수식") - for row in (doc.get(part) or {}).get("단가") or [] - if mine(row.get("키")) - } - for key in sorted(keys): - out.setdefault(key, []).append({"키": doc.get("키"), "이름": doc.get("이름")}) - return out + return library_uses.machines() def same(name: Any, spec: Any, skip: str = "") -> list[dict]: @@ -542,12 +537,12 @@ def one(key: str) -> dict[str, Any]: got = next((r for r in rows() if r["키"] == key), None) if got is None: raise _bad(f"없는 내 기계 「{key}」", 404) - return answer(got, uses().get(key, [])) + return answer(got, _uses().get(key, [])) def listing() -> dict[str, Any]: """목록 — 줄마다 시간당 · 쓰는곳수(넣은 차례).""" - index, used = whole(), uses() + index, used = whole(), _uses() return { "줄": [ {**r, "시간당": hourly(engine(r), index), "쓰는곳수": len(used.get(r["키"], []))} diff --git a/resources/tester/test_740_1_library_flat.py b/resources/tester/test_740_1_library_flat.py index 0e496cf7b..bbca3739f 100644 --- a/resources/tester/test_740_1_library_flat.py +++ b/resources/tester/test_740_1_library_flat.py @@ -21,6 +21,7 @@ from fastapi.testclient import TestClient from common_util.common_util_auth import verify_session from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_Library_Uses as library_uses from M02_MasterTemplete import M02_Library_Same as same from M02_MasterTemplete import M02_Library_Same_Router as same_router from M02_MasterTemplete import M02_MasterTemplete_Store as store @@ -112,7 +113,7 @@ def test_SC_에_SC_사본_블록_실무수량_겹침_원본_지워도(world): assert _sc_value(me, host) == pytest.approx(before, rel=1e-9) with store.at(me): (me / "precombo" / f"{old}.json").unlink() # 옛 꼴 문서(참조) 치움 - assert refs.users({**MINE, "키": inner}) == [] + assert library_uses.users({**MINE, "키": inner}) == [] store.delete("precombo", inner) assert _sc_value(me, host) == pytest.approx(before, rel=1e-9) # 원본 지워도 그대로 diff --git a/resources/tester/test_797_1_import_links.py b/resources/tester/test_797_1_import_links.py index 5215d62df..9c270f506 100644 --- a/resources/tester/test_797_1_import_links.py +++ b/resources/tester/test_797_1_import_links.py @@ -20,6 +20,7 @@ import pytest from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Hopyo_Store as hs from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_Library_Uses as library_uses from M02_MasterTemplete import M02_Machine_Hourly as machine from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_San_Emit as em @@ -142,7 +143,7 @@ def test_nested_stmate_follows_inner(world) -> None: assert made["검산"]["같음"] is True and made["검산"]["셈"]["계"] == 67383 assert _money(doc) == 67383 assert fh.make(folder, KEY, 2200)["이름"] == made["이름"] # 다시 올려도 같은 SK - assert refs.users(ref) # 쓰는 곳에 바깥 SK + assert library_uses.users(ref) # 쓰는 곳에 바깥 SK with pytest.raises(store.StoreError) as why: refs.refuse_used(folder, "sangeun", ref["키"]) assert why.value.status == 409 diff --git a/resources/tester/test_826_1_layer_index.py b/resources/tester/test_826_1_layer_index.py index 4953b8a38..66e1f7267 100644 --- a/resources/tester/test_826_1_layer_index.py +++ b/resources/tester/test_826_1_layer_index.py @@ -11,6 +11,7 @@ import pytest from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_Library_Uses as library_uses from M02_MasterTemplete import M02_Layer_Index as index from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Template_Layers as layers @@ -26,15 +27,15 @@ LIB = ("sangeun", "precombo", "labor") def fresh(world, monkeypatch): # noqa: F811 """색인 기억 비움 — 시험끼리 안 섞임.""" monkeypatch.setattr(index, "_MEM", {}) - monkeypatch.setattr(index, "_IDS_LOADED", []) - monkeypatch.setattr(refs, "_IDS", {}) + monkeypatch.setattr(library_uses, "_LOADED", []) + monkeypatch.setattr(library_uses, "_IDS", {}) return world def _forget(): index._MEM.clear() - index._IDS_LOADED.clear() - refs._IDS.clear() + library_uses._LOADED.clear() + library_uses._IDS.clear() def _sk(folder, name, extra=None): diff --git a/resources/tester/test_827_1_machine_window.py b/resources/tester/test_827_1_machine_window.py index 4532bd602..2b506ab56 100644 --- a/resources/tester/test_827_1_machine_window.py +++ b/resources/tester/test_827_1_machine_window.py @@ -18,6 +18,7 @@ from fastapi import HTTPException from M02_MasterTemplete import M02_Doc_Router as doc_route from M02_MasterTemplete import M02_Doc_Sk_Path as path from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_Library_Uses as library_uses from M02_MasterTemplete import M02_Machine_Hourly as mh from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_MyMachine as mym @@ -104,7 +105,7 @@ def test_save_creates_links_and_stamps(world): assert f"'개인 {key}'" in text assert key in [r["키"] for r in saved["단가"]] # 사본에 박힘 assert after["셈"]["계"] == look["셈"]["계"] and after["사본"]["단가새값"] is False - assert _at(me, mym.uses)[key] == [{"키": sk, "이름": "sub1임시"}] + assert _at(me, library_uses.machines)[key] == [{"키": sk, "이름": "sub1임시"}] def test_same_draft_two_lines(world): diff --git a/resources/tester/test_m02_labor_ref.py b/resources/tester/test_m02_labor_ref.py index ee77ac30f..c4ec1d66a 100644 --- a/resources/tester/test_m02_labor_ref.py +++ b/resources/tester/test_m02_labor_ref.py @@ -13,6 +13,7 @@ import pytest from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_Library_Uses as library_uses from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Template_Layers as layers from resources.tester.test_m02_labor_calc_mirror import _same, _ts @@ -324,10 +325,12 @@ def test_쓰는_곳_기억은_파일을_고치면_다시_읽음_818_1(world): ref = {**SYS, "키": sc} with store.at(world["personal"]): store.write("labor", "x1", "", {"열": "x1", "담은로직": [{"참조": ref}], "자재": []}) - assert len(refs.users(ref)) == 1 and refs.users(ref) == refs.users(ref, refs.use_files()) + assert len(library_uses.users(ref)) == 1 and library_uses.users(ref) == library_uses.users( + ref, library_uses.files() + ) ver = store.read("labor", "x1")["판"] store.write("labor", "x1", ver, {"열": "x1", "담은로직": [], "자재": []}) - assert refs.users(ref) == [] + assert library_uses.users(ref) == [] def test_복사는_못_읽는_참조를_같이_복사_본뜬(world):