Merge commit '3a7320ac71edbe70135aa7296f1143931653f435' into main_laptop_1

This commit is contained in:
2026-11-18 09:15:13 +09:00
10 changed files with 186 additions and 223 deletions
+27 -14
View File
@@ -141,7 +141,8 @@ def derive(sk: dict, whole: Any) -> dict:
"""이 SK 문서(855 2-C1 · 옛 엔진 안 돎) — 바탕 로직 = 기초 문서(`base_doc`) 사본 · 바탕 없음 = 빈 문서 ·
옵션 = 기초 문서 기본 위에 내가 고른 값(848-10 · 손고침 · 프로젝트 층 = 옛 로직 줄 자동값) ·
줄 규칙(켜쌓기율 · 고름 · 자재표시 · 일위대가 [+ 줄] 사본 811-1) = 문서 규칙(`dc.line_doc` ·
SK 재료 빈 칸 = 직접계산 747-1). `whole` = 값 사본 색인. 옛 칸 고침 SK 는 부르는 쪽이 먼저 막음."""
열쇠 = 금액#n 기초 문서 금액 줄 · 로직 줄 안 읽음 855 L2 ⓑ-3 · SK 재료 빈 칸 = 직접계산 747-1).
`whole` = 값 사본 색인. 옛 칸 고침 SK 는 부르는 쪽이 먼저 막음."""
key = str(sk.get("키") or "")
base_key = str((sk.get("바탕") or {}).get("로직") or "")
if not base_key:
@@ -149,29 +150,41 @@ def derive(sk: dict, whole: Any) -> dict:
plain, real = base_doc(sk, whole, base_key)
if plain is None:
raise ValueError(f"기초 문서 없음 「{base_key}」")
row = whole.logic(base_key)
got = sd.patched(row, sk) # 줄 규칙 칸 cid → 차례(옛 칸 고침 없음 = 바탕 줄 그대로)
names = {str(i.get("이름")) for i in row.get("입력") or []}
mats = {n for n, _, _ in dc.prices._mat_lines(plain)} # 재료 금액 줄(855 L2 ⓑ-3)
picks = {n: mt for n, mt in _rules(sk, "고름").items() if n in mats} # 재료 줄만(옛과 같음)
names = {str(i["이름"]) for i in sd.doc_row(whole, base_key)["입력"]}
values = {k: v for k, v in (sk.get("입력값") or {}).items() if k in names}
given = dc.given_of(whole, base_key, values) if values or not real else {}
doc = cp.deepcopy(_bare_doc(plain)) # ① = `위덮음`(848-1)
_set_values(doc, {k: v for k, v in given.items() if k in values} if real else given)
apart = [] if isinstance(row.get("흐름"), dict) else _apart(got)
doc = dc.line_doc(doc, sk.get("켜쌓기율"), got["고름"] or None, apart)
apart = _apart(_rules(sk, "자재표시"), mats)
doc = dc.line_doc(doc, sk.get("켜쌓기율"), picks or None, apart)
return {**doc, "키": key or base_key, "이름": str(sk.get("이름") or doc.get("이름"))}
def _apart(got: dict) -> list[int]:
"""별도계상 재료 줄 차례 — SK 빈 칸 = 직접계산(747-1) · 「별도계상」 고른 줄만."""
RULE_WHY = "옛 줄 가리킴(kind:키#n) 단가산출 — 줄 규칙은 금액#n · 다시 만들어야 셈"
def _rules(sk: dict, field: str) -> dict[int, Any]:
"""줄 규칙 칸(고름 · 자재표시) {금액#n: 값} → {n: 값} · 옛 cid 꼴 = 못 셈(855 L2 ⓑ-3 · 호환 없음)."""
out = {}
for key, value in (sk.get(field) or {}).items():
n = sd.amount_at(key)
if n is None:
raise ValueError(RULE_WHY)
out[n] = value
return out
def _apart(marks: dict[int, Any], mats: set[int]) -> list[int]:
"""별도계상 재료 줄 차례 — SK 빈 칸 = 직접계산(747-1) · 「별도계상」 고른 재료 줄만."""
from M02_MasterTemplete import M02_Labor_Doc as labor # 늦게 — 일위대가 셈이 이 파일을 부름
marks = got["자재표시"]
return [
return sorted(
n
for n, item in enumerate(got["줄"].get("호표") or [])
if item.get("종류") == "재료"
and labor.apart({"별도계상": "직접계산", **labor.marks(marks.get(str(n)))})
]
for n, mark in marks.items()
if n in mats and labor.apart({"별도계상": "직접계산", **labor.marks(mark)})
)
def seed(sk: dict) -> dict | None:
+8 -16
View File
@@ -2,7 +2,7 @@
줄 칸 `패치` = 단가산출(SK) 문서 꼴 `{덮개, 뺀줄, 더한줄}`(한 벌 · `M02_Sangeun_Doc`) — 그 줄에만 ·
로직 줄(`{로직, 입력값, 고름, 자재표시, 패치}`) · 단가산출 참조 줄(`{참조: SK, 패치}`)만 받음 ·
줄 `고름` · `자재표시`(호표 차례 열쇠)는 바탕 줄 차례 그대로 — 셈 때 cid 로 바꿔 뺀줄 뒤에도 제자리.
줄 `고름` · `자재표시`(차례 열쇠 「n」 = 기초 문서 금액 줄 차례) → SK 줄 규칙 「금액#n」(855 L2 ⓑ-3).
더한줄은 인력 · 재료 · 기계 · 로직 · 고정만(참조는 일위대가에 참조 줄로).
셈 = 못 셈 + 까닭 하나(옛 칸 고침 셈 은퇴 · 855 2-C5) · [단가산출로 저장] = `as_doc` + 이름 · 단위 → 층 SK.
"""
@@ -61,34 +61,26 @@ def ref_clean(one: dict, ref: dict, where: str) -> dict:
return clean(one, where, m01.loaded()[1], None, doc.get("열린입력"))
def _keyed(value: Any, ids: list[str]) -> dict:
"""차례 열쇠 → cid 열쇠(바탕 줄 차례)."""
out = {}
for n, v in (value or {}).items() if isinstance(value, dict) else ():
at = int(n) if str(n).isdigit() else -1
if 0 <= at < len(ids):
out[ids[at]] = v
return out
def _keyed(value: Any) -> dict:
"""차례 열쇠 「n」 → SK 줄 규칙 열쇠 「금액#n」(같은 기초 문서 금액 줄 · 로직 줄 안 읽음)."""
items = value.items() if isinstance(value, dict) else ()
return {sd.amount_key(n): v for n, v in items if str(n).isdigit()}
def as_doc(one: dict, whole: Any, name: str = "줄", unit: str = "식") -> dict[str, Any]:
"""일위대가 줄 → SK 문서(바탕 = 그 로직 · 그 SK) — 고름 · 자재표시는 cid 로."""
"""일위대가 줄 → SK 문서(바탕 = 그 로직 · 그 SK) — 고름 · 자재표시는 「금액#n」 으로."""
body = {k: (one.get(FIELD) or {}).get(k) or ([] if k != "덮개" else {}) for k in CALC}
head = {"키": TEMP, "이름": name, "단위": unit, **body}
if "참조" in one:
return {**head, "바탕": {"참조": one["참조"]}}
try:
ids = sd.line_ids(whole.logic(one["로직"]))
except Exception: # noqa: BLE001 — 없는 로직 = 셈이 까닭
ids = []
extra = {"켜쌓기율": one["켜쌓기율"]} if one.get("켜쌓기율") is not None else {}
return {
**head,
**extra,
"바탕": {"로직": one["로직"]},
"입력값": dict(one.get("입력값") or {}),
"고름": _keyed(one.get("고름"), ids),
"자재표시": _keyed(one.get("자재표시"), ids),
"고름": _keyed(one.get("고름")),
"자재표시": _keyed(one.get("자재표시")),
}
+4 -5
View File
@@ -29,6 +29,7 @@ def _whole() -> Any:
def logic_doc(one: dict, doc: dict, whole: Any) -> dict[str, Any]:
"""로직 줄 `one`(일위대가 `doc` 안) → SK 문서 몸(키 없음 · 저장은 부르는 쪽)."""
from M02_MasterTemplete import M02_Item_Prices as prices
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Patch as patch
from M02_MasterTemplete import M02_Sangeun_Calc as calc
@@ -38,12 +39,10 @@ def logic_doc(one: dict, doc: dict, whole: Any) -> dict[str, Any]:
code = str(one["로직"])
m01doc.head(code) # 없는 기초 = 옛 `Master.logic` 과 같은 까닭
doc_ = m01doc.docs()[code]
row = whole.logic(code) # 호표 재료 차례 = 옛 자재표시 칸 몫(남김)
shown = dict(one.get("자재표시") or {})
for n, item in enumerate(row.get("호표") or []):
if item.get("종류") == "재료":
mine = shown.get(str(n))
shown[str(n)] = {**labor.marks(mine), "별도계상": labor.mark_of(mine, "별도계상")}
for n, _, _ in prices._mat_lines(doc_): # 재료 금액 줄 차례(855 L2 ⓑ-3 · 로직 줄 안 읽음)
mine = shown.get(str(n))
shown[str(n)] = {**labor.marks(mine), "별도계상": labor.mark_of(mine, "별도계상")}
unit = calc.base_unit(doc_)
name = str(one.get("별칭") or doc_.get("이름") or code)
sk = patch.to_sangeun({**one, "자재표시": shown}, name, unit[1] if unit else "식", whole)
+25 -121
View File
@@ -15,22 +15,21 @@
`{층: 사본, 주인: 몸 지문, 키: 본 SC, 몸}` 에 담음(`M02_Labor_Ref.copy_ref` · 원본
연결 없음 · 하위 호표 끝수 단계 · B09 하위 대가 블록 그대로 · 같은 기초 겹침도
블록 안)
바탕 SK 참조 · 패치 있는 SK 참조 줄 = 위 덮개를 아래 덮개에 겹쳐 한 벌(`compose` · 율 기준 줄 열쇠
`add:#k` 도 새 차례로 · 778-4)
바탕 SK 참조 = 줄 규칙 · 입력값을 겹쳐 한 벌(`compose`) · 옛 칸 고침 든 겹침 · 패치 있는 SK 참조 줄 =
못 펼침(옛 칸 · 못 셈 855 L2 ⓑ-3)
율 줄(778-4) 있는 바탕 없는 SK = 한 줄로 못 펼침(율 · 기준 묶음이 넣는 쪽 줄로 번짐) → 참조 그대로
못 펼친 줄 = 저장 · 읽기 · 옮기기에선 옛 참조 그대로(값 그대로) · `strict` = 400 까닭(옛 찾아 넣기 `-flat` 길은 걷음 · 855 2-E2).
초기화(`reset`) = 덮개 · 뺀줄 · 더한줄 단가 걷음(안쪽 넣은 몸 · 사본 블록까지) · 이음 기계 고정 줄
단가 = M01 기계 한 시간 값 다시 받음(736-3) · 항목 · 수량 · 입력값 · 고름 · 자재표시 · 켜쌓기율 ·
기본정보 남김 → 값 = 연결된 M01 키 값.
한 번용 옮기기(`migrate`)는 끝나 걷음(894).
기초 이름 · 결과단위 · 입력 이름 = M01 수식 문서(855 L2 ⓑ · `_doc`) · 줄 정체(cid) · 호표 재료 차례는
옛 패치 칸(덮개 · 뺀줄 · 고름 · 자재표시) 몫이라 아직 로직 줄(`compose` · `sk_line` · 옛 패치 칸 걷기 때 같이).
기초 이름 · 결과단위 · 입력 이름 · 재료 줄 차례 = M01 수식 문서(855 L2 ⓑ · `_doc`) · SK 고름 · 자재표시
「금액#n」 ↔ 일위대가 줄 차례 「n」(`sk_line` · 로직 줄 안 읽음).
"""
from __future__ import annotations
import json
import re
import time
from decimal import Decimal
from typing import Any
@@ -42,7 +41,6 @@ from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Sangeun_Const as const
from M02_MasterTemplete import M02_Sangeun_Doc as sd
ADD = re.compile(r"^add:#(\d+)$")
FAIL = (ArithmeticError, KeyError, TypeError, ValueError) # 못 펼침(DocError · FormulaError 포함)
EMPTY = (None, {}, [], "")
Read = Any
@@ -113,7 +111,7 @@ def flat_sk(doc: dict, read: Read, whole: Any, trail: tuple = (), strict: bool =
try:
under, path = _read(base["참조"], read, trail)
under = flat_sk(sd.clean(under, None, whole), read, whole, path)
out = compose(under, out, whole)
out = compose(under, out)
except FAIL:
if strict:
raise
@@ -237,135 +235,41 @@ def sc_adds(z: dict, q: Decimal, whole: Any, tag: dict) -> list[dict]:
return out
# ── 겹침(바탕 SK · 패치 SK 참조) ─────────────────────────────────────────
def _merge(a: dict | None, b: dict) -> dict:
"""아래 덮개 a 위에 위 덮개 b — 품 qty 바꿈 · 배율 곱 · 단가 위 것."""
if not a:
return dict(b)
out = {k: v for x in (a, b) for k, v in x.items() if k in sd.PARTS}
if "qty" in b:
out["qty"] = b["qty"]
elif "배율" in b and "qty" in a:
out["qty"] = sd.plain(_d(a["qty"]) * _d(b["배율"]))
elif "배율" in b:
out["배율"] = sd.plain(_d(a.get("배율", 1)) * _d(b["배율"]))
else:
out |= {k: a[k] for k in ("qty", "배율") if k in a}
return out | ({"원값": a["원값"]} if "원값" in a else {})
# ── 겹침(바탕 SK 참조) ───────────────────────────────────────────────────
def compose(under: dict, over: dict) -> dict:
"""펼친 바탕 SK `under` 위에 `over` → 한 벌 — 줄 규칙(고름 · 자재표시 「금액#n」 = 같은 기초 문서
자리) · 입력값 = 위 것이 덮음 · 옛 칸 고침(덮개 · 뺀줄 · 더한줄 …) 든 쪽 = 못 펼침(855 L2 ⓑ-3 —
cid 옮김 겹침 걷음 · 로직 줄 안 읽음)."""
from M02_MasterTemplete import M02_Doc_Sk as dsk # 늦게 — dsk 가 이 파일을 거쳐 부름
def _cover_add(add: dict, cover: dict) -> dict:
"""위 덮개를 아래 더한줄 항목에 — 수량 · 그 비목 단가만(그 밖 = 못 겹침)."""
out = dict(add)
if "qty" in cover:
out["수량"] = cover["qty"]
elif "배율" in cover:
out["수량"] = sd.plain(_d(add.get("수량") or 0) * _d(cover["배율"]))
prices = {sd.PARTS[k]: cover[k] for k in sd.PARTS if k in cover}
if prices and (add.get("종류") not in sd.ADD_PART or set(prices) != {add.get("비목")}):
raise sd.DocError("더한줄 단가 덮개를 못 겹침")
if prices:
out["단가"] = prices[add["비목"]]
return out
def compose(under: dict, over: dict, whole: Any) -> dict:
"""펼친 바탕 SK `under` 위에 `over`(덮개 · 뺀줄 · 고름 · 자재표시 · 더한줄 · 입력값) → 한 벌 —
위 줄 정체를 아래 바탕 정체로 옮김(`patched` 의 `정체` 짝) · 짝 잃은 위 고침은 버림(값 없음)."""
const.no_flat(over) # 위 상수 · 표값 덮개 자리 = 아래 정체로 못 옮김(790-2)
base = under.get("바탕")
row = whole.logic(base["로직"]) if (base or {}).get("로직") else sd.empty_row(under)
got = sd.patched(row, under)
where = dict(zip(sd.line_ids(got["줄"]), got["정체"]))
covers = {c: dict(v) for c, v in (under.get("덮개") or {}).items()}
drop, picks = list(under.get("뺀줄") or []), dict(under.get("고름") or {})
marks, adds, gone = (
dict(under.get("자재표시") or {}),
[dict(x) for x in under.get("더한줄") or []],
set(),
)
def to(cid: str) -> tuple[str, Any] | None:
o = where.get(cid)
hit = ADD.match(o) if o else None
return None if o is None else ("add", int(hit[1])) if hit else ("base", o)
for cid, cover in (over.get("덮개") or {}).items():
if t := to(cid):
if t[0] == "base":
covers[t[1]] = _merge(covers.get(t[1]), cover)
else:
adds[t[1]] = _cover_add(adds[t[1]], cover)
for cid in over.get("뺀줄") or []:
if (t := to(cid)) and t[0] == "add":
gone.add(t[1])
elif t and t[1] not in drop:
drop.append(t[1])
for name, mine, into in (
("고름", over.get("고름"), picks),
("자재표시", over.get("자재표시"), marks),
):
for cid, value in (mine or {}).items():
if (t := to(cid)) and t[0] == "add":
raise sd.DocError(f"더한줄 {name}를 못 겹침")
if t:
into[t[1]] = value
const.no_flat(over) # 위 상수 · 표값 덮개 자리 = 못 겹침(790-2)
if dsk.patched(under) or dsk.patched(over):
raise sd.DocError(dsk.OLD_WHY)
out = {**over, "바탕": under.get("바탕")}
for name in ("고름", "자재표시", "입력값"):
out[name] = {**(under.get(name) or {}), **(over.get(name) or {})}
rate = over.get("켜쌓기율", under.get("켜쌓기율"))
out = {**over, "바탕": base, "덮개": covers, "뺀줄": drop, "고름": picks, "자재표시": marks}
kept = [k for k in range(len(adds)) if k not in gone]
new = {f"add:#{k}": f"add:#{n}" for n, k in enumerate(kept)} # 율 기준 열쇠(778-4)
mine = [
_rekey(a, lambda x: new.get(x) if ADD.match(x) else x)
for k, a in enumerate(adds)
if k not in gone
]
def up(cid: str) -> str | None: # 위 문서 열쇠 → 한 벌 열쇠
hit = ADD.match(cid)
if hit:
return f"add:#{len(kept) + int(hit[1])}"
t = to(cid)
return cid if t is None else t[1] if t[0] == "base" else new.get(f"add:#{t[1]}")
out["더한줄"] = mine + [_rekey(dict(a), up) for a in over.get("더한줄") or []]
out["입력값"] = {**(under.get("입력값") or {}), **(over.get("입력값") or {})}
return out | ({"켜쌓기율": rate} if rate is not None else {})
def _rekey(one: dict, move: Any) -> dict:
"""율 더한줄 기준 줄 목록 열쇠를 `move` 로(못 옮긴 열쇠 = 버림 · 778-4)."""
rate = ((one.get("고정") or {}).get("비율") or {}) if isinstance(one, dict) else {}
if not isinstance(rate.get("기준"), list):
return one
keys = []
for x in rate["기준"]:
line, cost = fixed.split_key(x) # `열쇠@비목` = 비목 꼬리 그대로
if got := move(line):
keys.append(f"{got}@{cost}" if cost else got)
fx = {**one["고정"], "비율": {**rate, "기준": keys}}
return {**one, "고정": fx}
# ── SC ────────────────────────────────────────────────────────────────
def sk_line(y: dict, one: dict, whole: Any, tag: dict) -> dict:
"""펼친 SK → 일위대가 로직 줄 하나(+ 패치) — 옛 참조 줄 `one` 의 별칭 · 메모 · 수량 · 패치
이어받음."""
from M02_MasterTemplete import M02_Item_Prices as prices
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Patch as patch
from M02_MasterTemplete import M02_Sangeun_Calc as calc
if one.get(patch.FIELD):
y = compose(y, {"입력값": {}, **one[patch.FIELD]}, whole)
if one.get(patch.FIELD): # 줄 덮개(옛 칸) = 못 셈 · 겹침 걷음(855 L2 ⓑ-3)
raise sd.DocError(patch.WHY)
code = (y.get("바탕") or {}).get("로직")
if not code:
raise sd.DocError("바탕 기초 없는 단가산출은 일위대가 줄로 못 담음 — 그 안 줄을 따로 넣음")
doc = _doc(code)
if calc.ratio_of(y, doc, whole) != calc.times_of(doc):
raise sd.DocError("단위 환산 단가산출은 일위대가 줄로 못 담음(값 단위가 바뀜)")
row = whole.logic(code) # 줄 정체 · 호표 재료 차례 = 옛 패치 칸 몫(남김)
ids = sd.line_ids(row)
names = _names(doc)
at = {c: str(n) for n, c in enumerate(ids)}
body = {k: y[k] for k in ("덮개", "뺀줄") if y.get(k) not in EMPTY}
body |= {"더한줄": adds} if (adds := filled_adds(y, whole)) else {}
line: dict[str, Any] = {
@@ -375,13 +279,13 @@ def sk_line(y: dict, one: dict, whole: Any, tag: dict) -> dict:
"메모": one.get("메모"),
"수량": one.get("수량"),
}
for name in ("고름", "자재표시"):
if got := {at[c]: v for c, v in (y.get(name) or {}).items() if c in at}:
for name in ("고름", "자재표시"): # SK 「금액#n」 → 일위대가 줄 차례 「n」(855 L2 ⓑ-3)
rules = ((sd.amount_at(c), v) for c, v in (y.get(name) or {}).items())
if got := {str(n): v for n, v in rules if n is not None}:
line[name] = got
shown = line.get("자재표시") or {}
for n, item in enumerate(row.get("호표") or []): # 747-1 SK 재료 빈 칸 = 직접계산 → 적어 둠
if item.get("종류") == "재료":
shown[str(n)] = {"별도계상": "직접계산", **labor.marks(shown.get(str(n)))}
for n, _, _ in prices._mat_lines(doc): # 747-1 SK 재료 빈 칸 = 직접계산 → 적어 둠
shown[str(n)] = {"별도계상": "직접계산", **labor.marks(shown.get(str(n)))}
line |= {"자재표시": shown} if shown else {}
if y.get("켜쌓기율") is not None:
line["켜쌓기율"] = y["켜쌓기율"]
+23 -4
View File
@@ -4,7 +4,7 @@
{종류: "단가산출", 키, 이름, 단위(필수), 구분, 상세구분, 본뜬,
바탕: {로직: GF…} | {참조: {층, 주인, 키: SK-…}} | null(바탕 없음 = 더한줄만),
입력값 {이름: 값}, 열린입력 [이름](설계 때 정함 · 그 SK 품 덮개 = 배율만), 켜쌓기율?,
고름 {cid: MT키}, 자재표시 {cid: {세 칸}},
고름 {금액#n: MT키}, 자재표시 {금액#n: {세 칸}},
덮개 {cid: {qty | 배율, labor, material, expense, 원값}},
더한줄 [{종류: 인력|재료|기계, 요소, 이름, 단위, 수량, 비목?, 단가?,
별도계상?(재료 · 없음 = 계 안)}
@@ -23,7 +23,8 @@ SK `입력값` = 바탕 입력 + 더한줄 로직 입력(727-3 · 넣은 뒤 고
줄 정체 cid = `kind:키#n`(B09 702 덮개 꼴) — kind = labor · material · machine · logic · pct(덧줄) ·
키 = 요소 키(로직 줄 = 부르는 GC 키 · 조건 재료 = 이름 · 덧줄 = 이름 · 더한줄 참조 = 그 키) ·
n = 같은 머리 차례 · 바탕 줄(M01 로직 줄 · 바탕 SK 의 고친 줄)에서 셈 — 뺀줄 · 더한줄 뒤 같은 줄.
고름 · 자재표시도 cid 열쇠(호표 차례 열쇠면 뺀줄 뒤 엉뚱한 줄에 붙음) → `patched` 가 차례로 바꿈.
고름 · 자재표시 열쇠 = 「금액#n」(기초 수식 문서 금액 줄 차례 · 855 L2 ⓑ-3 · 옛 cid 꼴 = 400 ·
저장본 옛 꼴 = 못 셈) · 일위대가 줄은 차례 「n」(`amount_key` · `amount_at` 로 오감).
덮개 = 숫자만(식 안 받음 · 4-1 확정 4) — qty = 품 수 · 배율 = 품 × 율 · labor · material · expense =
줄 단가(로직 줄 = 노 · 재 · 경 묶음) · 덧줄 = qty(율 %) · 배율만 · `원값` · `바탕판` = 저장 때
서버가 셈(브라우저 값 안 받음). 짝 잃은 덮개(M01 개정으로 줄이 사라짐) = 지우지 않고 `짝잃음` 알림.
@@ -47,6 +48,7 @@ COVER_KEYS = ("qty", "배율", *PARTS)
KINDS = {"인력": "labor", "재료": "material", "기계": "machine", "로직": "logic"}
ADD_PART = {"인력": "노무비", "재료": "재료비", "기계": "경비"}
_CID = re.compile(r"^(labor|material|machine|logic|pct):.*#\d+$")
AMOUNT = re.compile(r"^금액#(\d+)$") # 줄 규칙 열쇠 = 수식 문서 금액 줄 차례(855 L2 ⓑ-3)
_CALL = re.compile(r"^\s*로직\(\s*([A-Z]{2}\d{6})")
_PCT = re.compile(r"^(?P<x>.+)\*(?P<y>[^*]+)/\s*100\s*$", re.S) # 「X * Y / 100」
_NAME = re.compile(r"^[\w가-힣]+$")
@@ -115,6 +117,23 @@ def _cid(raw: Any, where: str) -> str:
return raw
def amount_key(n: Any) -> str:
"""일위대가 줄 차례 열쇠 「n」 → 단가산출 줄 규칙 열쇠 「금액#n」."""
return f"금액#{int(n)}"
def amount_at(key: Any) -> int | None:
"""「금액#n」 → n · 다른 꼴(옛 cid 등) = None."""
hit = AMOUNT.match(str(key))
return int(hit[1]) if hit else None
def _amount(raw: Any, where: str) -> str:
if amount_at(raw) is None:
raise DocError(f"{where} · 줄 가리킴은 금액#n(수식 문서 금액 줄 차례) 「{raw}」")
return str(raw)
def _base(raw: Any) -> dict | None:
if raw is None:
return None
@@ -357,7 +376,7 @@ def clean(doc: Any, base_row: dict | None = None, whole: Any = None) -> dict[str
mt = str(mt or "")
if not mt.startswith("MT") or (whole is not None and _element(whole, mt, "고름") is None):
raise DocError(f"고름 「{cid}」 · M01 자재품목 키 아님 「{mt}」")
picks[_cid(cid, "고름")] = mt
picks[_amount(cid, "고름")] = mt
out["고름"] = picks
out["자재표시"] = _marks(doc.get("자재표시"))
out["덮개"] = {
@@ -420,7 +439,7 @@ def _marks(raw: Any) -> dict[str, dict[str, str]]:
for cid, one in (raw or {}).items() if isinstance(raw, dict) else ():
got = labor.marks(one)
if got:
out[_cid(cid, "자재표시")] = got
out[_amount(cid, "자재표시")] = got
return out
+2 -26
View File
@@ -104,21 +104,6 @@ def test_patched_cover_qty_price_ratio():
assert got["짝잃음"] == [] and ROW["호표"][2]["수량"] == "0.2" # 바탕은 안 바뀜
def test_drop_keeps_pick_on_its_line():
"""뺀줄 뒤 고름 제자리 — 자갈(바탕 3째) 고름이 뺀줄 뒤 새 2째로 옮겨 감 · 모래 줄에 안 붙음."""
doc = sd.clean(_doc(뺀줄=["material:모래#0"], 고름={"material:자갈#0": "MT000010"}), ROW)
got = sd.patched(ROW, doc)
names = [x["이름"] for x in got["줄"]["호표"]]
assert names == ["석공", "석공", "자갈", "굴착기"]
assert got["고름"] == {"2": "MT000010"}
assert got["정체"][:4] == [
"labor:LB000033#0",
"labor:LB000033#1",
"material:자갈#0",
"logic:GC000276#0",
]
def test_added_lines_before_extras():
doc = sd.clean(
_doc(
@@ -144,11 +129,10 @@ def test_added_lines_before_extras():
def test_lost_covers_kept_and_listed():
"""짝 잃은 덮개 = 문서에 남김 + 목록(지우지 않음) · 비목 다른 단가 · 재료 아닌 고름."""
"""짝 잃은 덮개 = 문서에 남김 + 목록(지우지 않음) · 비목 다른 단가."""
doc = sd.clean(
_doc(
덮개={"labor:LB999999#0": {"qty": 1}, "labor:LB000033#0": {"material": 5}},
고름={"labor:LB000033#1": "MT000010"},
뺀줄=["material:없음#0"],
),
ROW,
@@ -156,18 +140,10 @@ def test_lost_covers_kept_and_listed():
got = sd.patched(ROW, doc)
why = {x["cid"]: x["까닭"] for x in got["짝잃음"]}
assert why["labor:LB999999#0"].startswith("덮개") and "비목 다름" in why["labor:LB000033#0"]
assert why["labor:LB000033#1"].startswith("고름") and why["material:없음#0"].startswith("뺀줄")
assert why["material:없음#0"].startswith("뺀줄")
assert "labor:LB999999#0" in doc["덮개"]
def test_chain_moves_base_picks():
"""바탕 SK 사슬 — 바탕 쪽 차례 고름이 아래 SK 뺀줄 뒤에도 그 줄에."""
first = sd.patched(ROW, sd.clean(_doc(고름={"material:자갈#0": "MT000010"}), ROW))
child = sd.clean({**_doc(뺀줄=["labor:LB000033#0"]), "바탕": None}, first["줄"])
got = sd.patched(first["줄"], child, first["고름"])
assert got["고름"] == {"2": "MT000010"} and got["줄"]["호표"][2]["이름"] == "자갈"
def test_empty_base():
row = sd.empty_row({"키": "SK-000003", "이름": "자체", "단위": "식"})
doc = sd.clean(
@@ -44,29 +44,6 @@ def _bare(code):
return labor.run_line(_whole(), code, {})
def test_layer_copy_round_trip(world):
"""개인 B(바탕 = 개인 A) → 회사로 복사 = 펼친 몸(바탕 = 기초 · 본뜬) → 개인으로 다시 =
같은 값."""
a = _sk(world["personal"], 바탕={"로직": PCT}, 덮개={"labor:LB000036#0": {"qty": 0.5}})
b = _sk(world["personal"], 바탕={"참조": {**MINE, "키": a}}, 뺀줄=["labor:LB000002#0"])
want = _calc(world["personal"], b)["기준"]
src = _doc(world["personal"], b)
with store.at(world["company"]):
made = refs.create(
"sangeun", refs.carry(refs.origin_mark(src, {**MINE, "키": b}), ("personal", "7/42"))
)
assert not list((world["company"] / "sangeun").glob("*.json"))[1:] # A 따로 복사 안 함
copy = _doc(world["company"], made["이름"])
assert copy["바탕"] == {"로직": PCT} and copy["본뜬"]["키"] == b
assert _calc(world["company"], made["이름"])["기준"] == want
with store.at(world["personal"]):
back = refs.create(
"sangeun",
refs.carry(refs.origin_mark(copy, {**COMPANY, "키": made["이름"]}), ("company", "7")),
)
assert _calc(world["personal"], back["이름"])["기준"] == want
def test_refusals(world):
with store.at(world["personal"]):
for bad, status in (
+1 -1
View File
@@ -9,7 +9,7 @@ from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
FORM = "GC000211" # 6-3-1 합판거푸집 — 합판 1.03 · 각재 0.038 · 폼타이 0 · 소모자재 = 재료비 %
PLY = "material:합판(내수 12㎜)#0"
PLY = "금액#2" # 합판 = 기초 문서 금액 줄 2째(855 L2 ⓑ-3 줄 규칙 열쇠)
def _whole():
-13
View File
@@ -257,17 +257,4 @@ def test_바탕_없는_SK_율_줄은_한_줄로_안_펼침():
assert flat.sk_adds(plain, Decimal(2), whole, {})[0]["수량"] == 1 # 율 없으면 그대로
def test_겹침_율_열쇠_새_차례():
whole = _whole()
under = sd.clean(
{**_doc([LABOR[0], _rate(["add:#0"])]), "바탕": {"로직": SUB}, "단위": "주"}, None, whole
)
seen = sd.patched(whole.logic(SUB), under)
view = dict(zip(seen["정체"], sd.line_ids(seen["줄"]))) # 아래 차례 → 위 문서 cid
over = {"더한줄": [LABOR[1], _rate(["add:#0", view["add:#1"], view["add:#0"]], 3)]}
out = flat.compose(under, over, whole)
keys = [((a.get("고정") or {}).get("비율") or {}).get("기준") for a in out["더한줄"]]
assert keys == [None, ["add:#0"], None, ["add:#2", "add:#1", "add:#0"]]
# ── 화면 — 더한줄 지움 · 되살림 때 율 기준 열쇠 옮김(`logic/M02_Sangeun_Undo.ts`) ──────────
@@ -0,0 +1,96 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""855 L2 ⓑ-3 — 단가산출 줄 규칙(고름 · 자재표시) 열쇠 = 「금액#n」(기초 수식 문서 금액 줄 차례).
- 별도계상 고른 재료 줄 = 그 줄 금액만 계 밖(셈 결과로 봄).
- 옛 cid 꼴(kind:키#n) — 받으면 400 · 저장본이면 못 셈 + 까닭(호환 없음).
- [+ 줄](일위대가 줄 → SK)과 SK → 일위대가 줄은 「n」 ↔ 「금액#n」 으로 오가고 금액 같음.
임시 storage · 개인 층.
"""
from __future__ import annotations
import json
from decimal import Decimal
import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Doc_Sk as dsk
from M02_MasterTemplete import M02_Labor_Copy as lc
from M02_MasterTemplete import M02_Labor_SkRow as skrow
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_Doc as sd
from resources.tester.test_795_1_sk_copy import _doc, _sk
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
BASE = "GC000031" # 비계 낙하물방지망 — 재료 줄 다섯(금액 2 ~ 6)
def _run(folder, doc) -> dict:
with store.at(folder):
return calc.run(doc, m01.loaded()[1])
def _mats() -> list[int]:
return [n for n, _, _ in dc.prices._mat_lines(dc.folder()[BASE])]
def test_별도계상_금액줄_차례로_계_밖(world):
me = world["personal"]
m = _mats()[0]
plain = _run(me, _doc(me, _sk(me, 바탕={"로직": BASE})))
apart = _run(
me, _doc(me, _sk(me, 바탕={"로직": BASE}, 자재표시={f"금액#{m}": {"별도계상": "별도계상"}}))
)
line = Decimal(str(plain["줄"][m]["금액"]))
assert line > 0
total = Decimal(str(plain["기준"]["재료비"])) - Decimal(str(apart["기준"]["재료비"]))
assert abs(total - line) <= 1 # 그 재료 줄 금액만 빠짐(원 끝수)
def test_옛_cid_꼴_받으면_400_저장본이면_못셈(world):
me = world["personal"]
old = {"material:MT000001#0": {"별도계상": "별도계상"}}
with pytest.raises(sd.DocError, match="금액#n"):
sd.clean(
{"키": "SK-000001", "이름": "가", "단위": "㎡", "바탕": {"로직": BASE}, "자재표시": old}
)
key = _sk(me, 바탕={"로직": BASE})
doc = {**_doc(me, key), "자재표시": old} # 옛 꼴 저장본(검사 앞 파일)
_save_raw(me, key, doc)
got = _run(me, _doc(me, key))
assert got["기준"] is None and dsk.RULE_WHY in str(got["수식셈"].get("까닭"))
def _save_raw(folder, key, doc):
"""검사를 안 지나는 파일 쓰기 — 검사 앞에 저장된 옛 꼴 저장본 흉내."""
with store.at(folder):
store._path("sangeun", key).write_text(json.dumps(doc, ensure_ascii=False), "utf-8")
def test_더한줄_오가도_열쇠_금액_같음(world):
me = world["personal"]
whole = m01.loaded()[1]
m, mt = _mats(), sorted(whole.index["MT"])[0]
line = {
"로직": BASE,
"입력값": {},
"고름": {str(m[1]): mt},
"자재표시": {str(m[0]): {"별도계상": "별도계상"}},
"수량": {"손": 1},
}
with store.at(me):
made = skrow.logic_doc(line, {}, whole)
assert set(made["고름"]) == {f"금액#{m[1]}"} and f"금액#{m[0]}" in made["자재표시"]
sk = _run(me, {**made, "키": "SK-900001"})
back = flat.sk_line(
sd.clean({**made, "키": "SK-900001"}, None, whole), {"수량": {"손": 1}}, whole, {}
)
assert back["고름"] == {str(m[1]): mt}
assert back["자재표시"][str(m[0])]["별도계상"] == "별도계상"
a = lc.line(whole, {"키": "SC-900001", "담은로직": [line]}, line)
b = lc.line(whole, {"키": "SC-900002", "담은로직": [back]}, back)
assert sk["기준"] is not None and a["기준"] == b["기준"]