"""M02 단가산출(SK) 숫자 넓힘(PLAN 790-2 · 요구서_652 · _분석_650-H3 E2) — 새 덮개 갈래. 시험 `resources/tester/test_790_2_sangeun_const.py` · 799-2 — 화면 짝(`Const_Model.ts` · 시트 탭)은 걷음, 서버만 남음. 문서 덧칸(없으면 안 둠 — 옛 SK 그대로 · 지문 그대로): 상수덮개 {자리: {n: 값}} 자리 식의 n 번째 숫자 상수(0 부터 · 엔진 파서 차례 · 찾기 머리 · 키 · 따옴표 글 안 셈) → 값 · 식 구조 그대로(옵션 바꾸면 나머지 따라감) 표값덮개 {자리: {n: 값}} 자리 식의 n 번째 표 찾기 값(`찾기(…).칸`) → 값 · 그 줄만 표 연결 끊김 글줄 [{자리, 글}] 셈 없는 글 줄(근거 · ※ 조건) · 자리 뒤에 찍힘("" = 맨 위) 까닭 {열쇠: 글} 덮개 · 더한줄 · 뺀줄 · 새 덮개마다(예정가격작성기준 제2조 ②) M01판 {자리: 지문} 저장 때 서버가 바탕 줄마다 적음(`stamp` · `sd.clean` 은 버림 = 바탕판처럼) · 셈 때 받은 값과 지금 바탕이 다르면 「M01바뀜」 자리 = 바탕 줄 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` 전체. 화면 셈 답(`answer`) = 문서 셈 답 + 머리(옛 `원래` · `시트` 덧칸은 855 2-C1 에서 걷음 · 상세 몸 856-1). """ from __future__ import annotations import functools import hashlib import json 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+)$") _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( "상수 · 표값 덮개 · 식 칸 · 수식 고침 단가산출은 펼치지 않음(참조 그대로)" ) 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) # ── 문서 꼴 ────────────────────────────────────────────────────────── def _key(raw: Any, where: str, pat: re.Pattern = _SPOT) -> str: if not isinstance(raw, str) or not pat.match(raw): raise sd.DocError(f"{where} · 자리 꼴 아님 「{raw}」") return raw def _words(raw: Any, where: str) -> str: got = str(raw or "").strip() if len(got) > LONG: raise sd.DocError(f"{where} · 글이 {LONG} 자를 넘음") 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판` · 원값은 서버 몫이라 버림).""" raw = raw if isinstance(raw, dict) else {} for name in ("상수덮개", "표값덮개"): if got := _covers(raw.get(name), name): out[name] = got texts = raw.get("글줄") or [] if not isinstance(texts, list) or len(texts) > MANY: raise sd.DocError(f"글줄 · {MANY} 줄까지 목록") lines = [] for at, one in enumerate(texts, 1): one = one if isinstance(one, dict) else {} spot = str(one.get("자리") or "") words = _words(one.get("글"), f"글줄 {at}째") if words: lines.append({"자리": spot and _key(spot, f"글줄 {at}째", _KEY), "글": 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()} if why := {k: v for k, v in why.items() if v}: out["까닭"] = why if isinstance(raw.get("사본"), dict): # 로직 사본(795-1) — 셈 · 저장 첫머리 settle 이 정함 out["사본"] = raw["사본"] 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) def _print(one: Any) -> str: raw = json.dumps(one, ensure_ascii=False, sort_keys=True, default=str) return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:12] def stamp(row: dict, doc: dict | None = None) -> dict[str, Any]: """저장 때 서버 칸 — 바탕판(옛 칸 그대로) + M01판(자리마다 지문) · `doc` = 식 칸(792-1)을 엔진 식으로 바꿔 넣음(제자리 · 틀린 식 = `DocError`).""" 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) lines = [*(row.get("중간") or []), *(row.get("호표") or []), *(row.get("덧줄") or [])] spots = [f"mid:{s.get('이름')}" for s in row.get("중간") or []] + sd.line_ids(row) return {"바탕판": calc.fingerprint(row), "M01판": dict(zip(spots, map(_print, lines)))} # ── 고치기 ────────────────────────────────────── 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 _top_add(key: str) -> bool: hit = _ADD.match(key) return bool(hit) and not hit[2] def kinds(doc: dict, spot: str) -> list[str]: """자리의 덮개 갈래 — 품 · 단가 · 상수 · 표값 · 뺌(차례 그대로).""" cover, out = (doc.get("덮개") or {}).get(spot) or {}, [] if "qty" in cover or "배율" in cover: out.append("품") if any(k in cover for k in sd.PARTS): out.append("단가") out += [ n for n, k in (("상수", "상수덮개"), ("표값", "표값덮개"), ("식", "식덮개")) if spot in (doc.get(k) or {}) ] return out + (["뺌"] if spot in (doc.get("뺀줄") or []) else []) # ── 화면 셈 답 ──────────────────────────────────────────────────────── def answer(got: dict, clean: dict) -> dict: """`M02_Sangeun_Calc.calc_doc` 답 — 셈 답(1 단위 몫) + 머리 · 가져온 식 원본 보기(옛 `원래` · `시트` 걷음 · 855 2-C1).""" from M02_MasterTemplete import M02_Sangeun_Calc as calc out = {**calc.per_unit(got, clean), "머리": calc.head_of(clean)} return calc.labor._json(imp.more(out, clean))