- POST /layers/{층}/sangeun/calc(calc_sangeun · _calc · SangeunCalcBody) 지움 — 화면 부름 0(856-2) · B08 · B09 · 서버 모듈 0
- POST /layers/{층}/{kind}-flat(library_flat · FlatBody) · Library_Flat.flat_lines 지움 — 화면 부름 0(찾아 넣기 = 참조 줄)
- calc_doc 의 seen 인자(몸에서 안 씀) · Sangeun_Calc.head_of · 답 머리 칸(화면만 먹던 띠) 걷음
- 시험: 778_2 = 길 대신 calc_doc 바로(같은 셈 묶음) · 740_1 = 넣기 길 단언 걷고 초기화 길만 · 792_1 = 펼침 막음을 const.no_flat 로 · 728_2 = head_of 단언 걷음(죽은 화면 띠) · 795_1 · 821_1 · 822_2 · 826_3 · 836_2 = seen 인자 뺌
- /openapi.json 길 480 → 478(뜻한 둘만 빠짐)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
291 lines
14 KiB
Python
291 lines
14 KiB
Python
"""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판 {자리: 지문} (옛 칸 — 읽던 시트를 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` 전체.
|
|
셈 답(`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+)$")
|
|
_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 stamp(row: dict, doc: dict | None = None) -> dict[str, Any]:
|
|
"""저장 때 서버 칸 — 바탕판(바탕 줄 지문 · 화면 「기초가 바뀜」) · `doc` = 식 칸(792-1)을
|
|
엔진 식으로 바꿔 넣음(제자리 · 틀린 식 = `DocError`) · 옛 `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)
|
|
|
|
return {"바탕판": calc.fingerprint(row)}
|
|
|
|
|
|
# ── 고치기 ──────────────────────────────────────
|
|
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 단위 몫) + 가져온 식 원본 보기(옛 `원래` · `시트` · 머리 걷음)."""
|
|
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
|
|
|
return calc.labor._json(imp.more(calc.per_unit(got, clean), clean))
|