Merge branch 'sub_laptop_4' of C:/Aislo_wt/sub_laptop_4 into main_laptop_1

# Conflicts:
#	resources/tester/test_793_2_sangeun_imported.py
This commit is contained in:
2026-11-18 05:03:02 +09:00
12 changed files with 98 additions and 732 deletions
+1 -1
View File
@@ -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:
+35 -202
View File
@@ -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:
@@ -267,21 +115,6 @@ def _top_add(key: str) -> bool:
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 단위 몫) + 가져온 식 원본 보기(옛 `원래` · `시트` · 머리 걷음)."""
+1 -43
View File
@@ -16,9 +16,7 @@
재생성 = 지금 M01 로 새로 찍음 — 덮개 · 식덮개 · 변수줄 · 상수 · 표값 · 까닭은 cid 열쇠라
새 사본에 그대로 얹힘 · 못 얹은 칸 = 짝잃음.
저장 때 = 사본에 없는 새 줄(더한줄 로직 더함 · 기초 바꿈)만 지금 M01 에서 더함.
길(`M02_Sangeun_Router`): POST …/sangeun/copy/{price|regen} 몸 {문서, 입력값?} →
{문서(사본할일), 전, 후, 바뀐자원 [{키, 이름, 전, 후, 지워짐?}] · 못얹은 [{cid, 까닭}]}
(저장 없음).
미리 셈 = `M02_Doc_Sk_Path.preview`(몸 `할일` · 옛 `preview` 는 걷음 · 855 2-E2).
셈 답 덧칸 `사본` = {시점, 단가시점, M01새판, 지운키, 단가새값} · 같은 내용 지문 몫 = `same_part`.
"""
@@ -386,43 +384,3 @@ def same_part(doc: Any) -> str | None:
seen = state(copy, whole_())
fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"])
return None if fresh else f"{copy.get('판')}:{copy.get('단가판')}"
# ── [단가 갱신] · [재생성] 미리 셈(저장 없음) ──────────────────────────
def _money(ans: dict) -> dict | None:
base = ans.get("기준")
return {k: base.get(k) for k in ("노무비", "재료비", "경비", "계")} if base else None
def _lost(ans: dict) -> dict[str, dict]:
rows = [*(ans.get("짝잃음") or []), *((ans.get("시트") or {}).get("짝잃음") or [])]
return {str(x.get("cid")): x for x in rows if isinstance(x, dict)}
def preview(doc: Any, job: str, given: dict | None = None) -> dict[str, Any]:
"""{문서(할일 얹음), 전, 후, 바뀐자원 · 못얹은} — 재생성은 단가갱신을 품음."""
from M02_MasterTemplete import M02_Sangeun_Calc as calc
if not isinstance(doc, dict):
raise sd.DocError("단가산출 문서가 묶음 아님")
old = doc.get(JOB)
new = REGEN if REGEN in (old, job) else job
after_doc = {**doc, JOB: new}
before = calc.calc_doc(doc, given)
after = calc.calc_doc(after_doc, given)
out: dict[str, Any] = {"문서": after_doc, "전": _money(before), "후": _money(after)}
if cut := [
str(x.get("이름") or x.get("로직")) for x in doc.get("더한줄") or [] if x.get("끊음")
]:
out["끊은기초"] = cut # 줄은 그대로 · 자원 단가만(요구 656-1)
if job == PRICE:
copy = _stored(doc.get("키")) or taken(held(doc))
out["바뀐자원"] = refresh(copy, whole_())[1] if copy else []
else:
was = _lost(before)
out["못얹은"] = [
{"cid": c, "까닭": x.get("까닭") or "새 사본에 그 줄 없음"}
for c, x in _lost(after).items()
if c not in was
]
return out
+3 -4
View File
@@ -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 = [], [], [], {}, {}
+5 -329
View File
@@ -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,239 +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
# ── 셈 답 덧칸(790-2 `시트`) ─────────────────────────────────────────
def sheet_more(spots: dict, base: dict, clean: dict, mids: dict) -> list[dict]:
"""790-2 시트 자리에 덧칸 — 식글(지금 식 이름 꼴) · 원식글 · 식덮개 · 식틀림 · 변수 줄 ·
더한줄 식글 · 돌려줌 = 틀린 식 · 짝 잃은 식 칸(시트 `짝잃음` 에 더함)."""
from M02_MasterTemplete import M02_Sangeun_Const as const
row, bad, fixed = settle(base, clean)
eff, covers = const._swapped(row, clean), fixed.get("식덮개") or {}
now, why = _places(eff), clean.get("까닭") or {}
wrong: dict[str, list[str]] = {}
for b in bad:
wrong.setdefault(b["cid"], []).append(b["까닭"])
for spot, one in spots.items():
if spot in now and one.get("갈래") != "더한줄":
part, at = now[spot]
one["원식글"] = to_name(str(one.get("식")), base)
one["식글"] = to_name(str(eff[part][at].get(FIELD[part])), base)
one["식덮개"] = spot in covers
hit = _ADD.match(spot)
adds = fixed.get("더한줄") or []
if hit and int(hit[1]) < len(adds) and adds[int(hit[1])].get("수량식"):
one["식"] = adds[int(hit[1])]["수량식"]
one["식글"] = to_name(one["식"], base)
if spot in wrong:
one["식틀림"] = wrong[spot]
good = {x["이름"]: x["식"] for x in fixed.get("변수줄") or []}
for line in clean.get("변수줄") or []:
spot, text = f"mid:{line['이름']}", good.get(line["이름"], line["식"])
spots[spot] = {
"갈래": "변수",
"이름": line["이름"],
"식": text,
"식글": to_name(text, base),
"표시": line.get("표시"),
"자리": line["자리"],
"원래": None,
"지금": mids.get(line["이름"]) if line["이름"] in good else None,
"덮개": [],
"까닭": why.get(spot),
"M01바뀜": False,
**({"식틀림": wrong[spot]} if spot in wrong else {}),
}
return bad
def name_table(base: dict, clean: dict) -> list[dict]:
"""식 칸에서 부를 이름 — 입력 · 중간 · 변수 · 덧줄 · 비목 · 별칭 · 자원 · 번지 · 단계."""
mf = _eng()
out = [{"글": str(x.get("이름")), "갈래": "입력"} for x in base.get("입력") or []]
out += [{"글": str(x.get("이름")), "갈래": "중간"} for x in base.get("중간") or []]
out += [{"글": x["이름"], "갈래": "변수"} for x in clean.get("변수줄") or []]
out += [{"글": str(x.get("이름")), "갈래": "덧줄"} for x in base.get("덧줄") or []]
out += [{"글": k, "갈래": "비목"} for k in mf.COST_ITEMS]
out += [{"글": f"[{k}]", "갈래": "별칭"} for k in aliases(base)]
label_of, seen = _labels(_whole())[0], set()
for part in FIELD:
for x in base.get(part) or []:
texts = [
str(x.get(FIELD[part])),
*([x["요소"]] if isinstance(x.get("요소"), str) else []),
]
for key in (k for t in texts for k in mf.mk.KEY.findall(t)):
if key in label_of and key not in seen:
seen.add(key)
out.append({"글": f"[{label_of[key]}]", "갈래": "자원"})
lines = [*(base.get("호표") or []), *(base.get("덧줄") or [])]
out += [{"글": f"번지.{x['번지']}", "갈래": "번지"} for x in lines if x.get("번지")]
out += [{"글": f"단계.'{x.get('이름')}'", "갈래": "단계"} for x in base.get("단계") or []]
return out
+3 -53
View File
@@ -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판 = 서버 몫
+33 -80
View File
@@ -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.kinds(_plus(), MAN) == ["식"] and 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
)
@@ -163,7 +163,6 @@ def test_북부청_18_줄_자리_셈_엑셀():
"more",
[
{"덮개": {"labor:형틀목공#0": {"qty": 0.2}}},
{"상수덮개": {BURN: {"0": 12}}},
{"뺀줄": [PLY]},
{"더한줄": [{"종류": "인력", "요소": MAN, "수량": 0.01}]},
],
+9 -9
View File
@@ -14,6 +14,7 @@ import json
import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Same as same
@@ -118,12 +119,11 @@ def test_price_refresh_only_on_press(world, monkeypatch):
assert _sum(me, key) == was # 누르기 전 = 단가 기준 시점 값
fresh = _sum(me, _sk(me, 바탕={"로직": PCT})) # 지금 M01 로 새로 찍은 SK
assert fresh != was
with store.at(me):
got = skc.preview(_doc(me, key), skc.PRICE)
with store.at(me): # 화면 [단가 갱신] 미리 셈 = 수식 길(옛 `skc.preview` 걷음 · 855 2-E2)
got = path.preview(key, {"할일": skc.PRICE})
assert got["전"]["계"] == was and got["후"]["계"] == fresh
assert [x["키"] for x in got["바뀐자원"]] == [lb]
assert got["문서"][skc.JOB] == skc.PRICE
_save(me, key, got["문서"]) # [저장] = 서버가 할일 적용
_save(me, key, {**_doc(me, key), skc.JOB: skc.PRICE}) # [저장] = 서버가 할일 적용
saved = _doc(me, key)
assert skc.JOB not in saved and _sum(me, key) == fresh
assert skc.held(saved)["단가시점"] >= skc.held(saved)["시점"]
@@ -142,7 +142,7 @@ def test_deleted_keys_keep_last_value(world, monkeypatch):
assert now["기준"]["계"] == was
assert {PCT, lb} <= set(now["사본"]["지운키"])
with store.at(me):
got = skc.preview(_doc(me, key), skc.PRICE)
got = path.preview(key, {"할일": skc.PRICE})
assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"]
assert got["후"]["계"] == was
@@ -195,7 +195,7 @@ def test_imported_same_rule(world, monkeypatch):
row["값"] = row["값"] * 2
_fake(monkeypatch, [row])
assert _sum(me, key) == was
with store.at(me):
got = skc.preview(_doc(me, key), skc.PRICE)
assert [x["키"] for x in got["바뀐자원"]] == [MAN]
assert got["후"]["노무비"] == pytest.approx(got["전"]["노무비"] * 2, abs=1)
before = _calc(me, _doc(me, key))["기준"]["노무비"]
_save(me, key, {**_doc(me, key), skc.JOB: skc.PRICE}) # [단가 갱신] 뒤 [저장] = 할일 적용
after = _calc(me, _doc(me, key))["기준"]["노무비"]
assert after == pytest.approx(before * 2, abs=1)
+5 -3
View File
@@ -15,6 +15,7 @@ import pytest
from fastapi import HTTPException
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Machine_Find as mfind
from M02_MasterTemplete import M02_Machine_Hourly as mh
@@ -147,11 +148,12 @@ def test_sk_copy_edit_refresh_delete(world):
assert now["기준"]["계"] == was and now["사본"]["단가새값"] is True
assert now["사본"]["지운키"] == []
new = _at(me, mh.hourly, key)["계"]
look = _at(me, skc.preview, _doc(me, sk), skc.PRICE)
look = _at(me, path.preview, sk, {"할일": skc.PRICE}) # 화면 [단가 갱신] 미리 셈(수식 길)
assert float(look["전"]["계"]) == float(was) and float(look["후"]["계"]) == new
assert [x["키"] for x in look["바뀐자원"]] == [key]
with store.at(me): # [저장] = 할일 적용
store.write("sangeun", sk, store.read("sangeun", sk)["판"], look["문서"])
got = store.read("sangeun", sk)
store.write("sangeun", sk, got["판"], {**got["문서"], skc.JOB: skc.PRICE})
assert float(_sum(me, sk)) == new
assert _calc(me, _doc(me, sk))["사본"]["단가새값"] is False
# 층 사이 복사 — 사본이 따라감(받은 층에 그 내 기계 없음 · 마지막 값)
@@ -162,7 +164,7 @@ def test_sk_copy_edit_refresh_delete(world):
assert gone["쓰는곳"] == [{"키": sk, "이름": "sub3임시 내기계"}]
after = _calc(me, _doc(me, sk))
assert float(after["기준"]["계"]) == new and after["사본"]["지운키"] == [key]
look = _at(me, skc.preview, _doc(me, sk), skc.PRICE)
look = _at(me, path.preview, sk, {"할일": skc.PRICE})
assert look["바뀐자원"] == [{"키": key, "이름": NAME, "지워짐": True}]
assert float(look["후"]["계"]) == new
+3 -3
View File
@@ -207,9 +207,9 @@ def test_imported_ours(world, monkeypatch):
was = _sum(me, key)
_move(monkeypatch, MAN)
assert _sum(me, key) == was
doc = _at(me, lambda: store.read("sangeun", key)["문서"])
got = _at(me, skc.preview, doc, skc.PRICE)
assert [x["키"] for x in got["바뀐자원"]] == [MAN] and got["후"]["계"] > was
doc = _at(me, lambda: store.read("sangeun", key)) # [단가 갱신] 뒤 [저장] = 할일 적용
_at(me, lambda: store.write("sangeun", key, doc["판"], {**doc["문서"], skc.JOB: skc.PRICE}))
assert _sum(me, key) > was
def test_layer_copy_keeps_copy(world, monkeypatch):
-4
View File
@@ -170,10 +170,6 @@ export const ui_locales_m2 = {
"바탕 단가산출 기초가 저장 뒤 바뀜 — 고친 칸의 바탕 값을 확인하고 [저장]하면 새 판으로 맞춤",
"The base M01 logic changed since saving — check edited cells, then Save to adopt the new version",
],
M02_SangeunLost: [
"바탕에서 짝을 잃은 고침 — 지우지 않고 남겨 둠",
"Edits that lost their base row — kept, not deleted",
],
M02_SangeunGap: [
"못 셈 줄 — 금액 빼고 나머지로 셈 · 줄을 빼거나 입력을 채움",
"Lines not priced — total uses the rest · drop the line or fill its input",