From 4ff4f369c35f1509bd41b68808065d86072db839 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 05:00:40 +0900 Subject: [PATCH] =?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