diff --git a/M02_MasterTemplete/M02_Doc_Import.py b/M02_MasterTemplete/M02_Doc_Import.py index 33d9ad5b8..f885b0117 100644 --- a/M02_MasterTemplete/M02_Doc_Import.py +++ b/M02_MasterTemplete/M02_Doc_Import.py @@ -74,10 +74,9 @@ def _index(sk: dict, master: Any = None, doc: Any = None) -> Any: # ── 엑셀 단가 그대로 고친 줄(가져온 로직 줄 + SK 고침 · 엔진 셈 없음) ───────── def _engine_adds(doc: dict) -> bool: - """값을 엔진 셈으로만 얻는 더한줄(형제 SK · 율 · 세부 고친 둘째 기초)이 있음 — 못 셈(옛 셈 은퇴).""" - return any( - one.get("참조") or sd.is_rate(one) or sd.sub_patched(one) for one in doc.get("더한줄") or [] - ) + """값을 엔진 셈으로만 얻는 더한줄(율 · 세부 고친 둘째 기초)이 있음 — 못 셈(옛 셈 은퇴) · + 형제 SK 더한줄 = 단가산출 연결(`_attach`).""" + return any(sd.is_rate(one) or sd.sub_patched(one) for one in doc.get("더한줄") or []) def _ctx(sk: dict, whole: Any) -> tuple: @@ -92,7 +91,7 @@ def _ctx(sk: dict, whole: Any) -> tuple: raw = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": "엑셀"}} doc = sd.clean(raw, None, whole) if _engine_adds(doc): - raise ValueError("형제 SK · 율 · 고친 둘째 기초 더한줄 — 옛 엔진 셈 은퇴 · 못 셈") + raise ValueError("율 · 고친 둘째 기초 더한줄 — 옛 엔진 셈 은퇴 · 못 셈") w = skc.over(doc, whole) base = sd.empty_row(doc) base = {**base, "호표": [dict(x) for x in base.get("호표") or []]} @@ -103,6 +102,9 @@ def _ctx(sk: dict, whole: Any) -> tuple: filled, lack = calc._fill(doc, w, dict(doc.get("입력값") or {})) got = sd.patched(base, filled, {}, {}) items = got["줄"]["호표"] + for item in items: # 더한 형제 SK 줄도 0 자리값(`_attach` 가 단가산출 연결로 갈음) + if "참조" in item and item.get("값묶음") is None: + item["값묶음"] = dict.fromkeys(imp.COSTS, Decimal(0)) calc._direct(got["자재표시"], items) for at, cid in enumerate(got["정체"][: len(items)]): if cid.startswith("add:#") and int(cid[5:]) in lack: @@ -258,24 +260,13 @@ def hourly_link(eq: str, part: str) -> dict | None: return {"갈래": "단가산출", "키": str(logic["키"]), "입력": given, "칸": part} -_HEAD = re.compile(r"\s*로직\(\s*([^,()'{}]+?)\s*(?=[,)])") -_ARG = re.compile(r"\s*,\s*(?:'([^']*)'|(\w+))\s*=\s*(?:'([^']*)'|(\d+(?:\.\d+)?))") - - def _logic_link(text: str) -> dict | None: - """「로직(GC…, 이름='값')」 → 단가산출 연결 · 인자가 수 · 글 아니면 None(불러오기가 짓는 글 꼴).""" - s = str(text) - head = _HEAD.match(s) - if head is None: + """「로직(GC…, 이름='값')」 → 단가산출 연결 · 인자가 수 · 글 아니면 None(`San_ToDoc.logic_call`).""" + got = todoc.logic_call(text) + if got is None: return None - at, given = head.end(), {} - while arg := _ARG.match(s, at): - name = arg[1] if arg[1] is not None else arg[2] - given[name] = f"'{arg[3]}'" if arg[3] is not None else _lit(Decimal(arg[4])) - at = arg.end() - if not re.fullmatch(r"\s*\)\s*", s[at:]): - return None - return {"갈래": "단가산출", "키": head[1], "입력": given} + given = {k: f"'{v[1]}'" if v[0] == "str" else _lit(v[1]) for k, v in got[1]} + return {"갈래": "단가산출", "키": got[0], "입력": given} def _link_of(item: dict) -> tuple[dict | None, str]: @@ -466,6 +457,11 @@ def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict: bare = imp.row_of({**sk, imp.KEY: {**meta, "단가기준": "엑셀"}}) or {} base = sd.line_ids(bare) src = dict(zip(base, meta["로직"].get("호표") or [])) + src |= { # 더한 형제 SK 줄 = 그 줄 스스로(연결 · 엑셀 값 없음) + cid: one + for cid, one in zip(ids, row["호표"]) + if cid.startswith("add:#") and one.get("참조") + } keep = _picks(row, ids, base, meta, master) doc, notes = todoc.build(row, master, values) # 857-3a 불러오기 자기 문서 짓기(변환기 안 부름) _attach(doc, row, ids, src) diff --git a/M02_MasterTemplete/M02_San_ToDoc.py b/M02_MasterTemplete/M02_San_ToDoc.py index a4acf2a37..47b890d7a 100644 --- a/M02_MasterTemplete/M02_San_ToDoc.py +++ b/M02_MasterTemplete/M02_San_ToDoc.py @@ -3,7 +3,8 @@ 불러오기 읽기기(둘 꼴 · 로직 줄 꼴 블록)가 낸 `가져온.로직` 줄(+ SK 고침 · 고른 칸 중간)을 불러오기 자기 모듈에서 문서로 지음 — 옛 변환기(`master_doc_convert`) · 색인 `.logic` · 옛 식 파서 (`master_formula.parse`) 안 부름 · 식 글 = 문서 파서(`master_doc.parse`). -가져온 줄 꼴: 입력 · 결과 없음 · 호표 = 손 값(값묶음 · 단가) = 숫자 연결 · +가져온 줄 꼴: 입력 · 결과 없음 · 호표 = 손 값(값묶음 · 단가) = 숫자 연결 · 사람이 더한 줄 = + 요소 키(인력 · 재료 · 기계 — 요소 연결 · M01 값) · 로직 부름(단가산출 연결) · 중간 = 식 줄(표시 = 반올림) · 고른 칸 중간(`연결` 든 줄) = 그 기호에 바로 연결 · 덧줄 = 금액 줄(단가 = 식) · `줄.'이름'` · 앞 덧줄 이름 = 그 금액 줄 기호 · 끝수 · 끝전 · 단계 · 조정 그대로. @@ -85,10 +86,30 @@ class _Reg: return self.ids.get(key, "?") +_HEAD = re.compile(r"\s*로직\(\s*([^,()'{}]+?)\s*(?=[,)])") +_ARG = re.compile(r"\s*,\s*(?:'([^']*)'|(\w+))\s*=\s*(?:'([^']*)'|(\d+(?:\.\d+)?))") +_CODE = re.compile(r"^(?:EQ|MT|LB)\d") # 요소 키가 아래첨자로 샌 것(804-7) +LINKED = "MP" # 품셈재료 — 줄 단위로 값이 갈림(`master_material.LINKED`) + + +def logic_call(text: Any) -> tuple[str, list[tuple[str, tuple]]] | None: + """「로직(GC…, 이름='값', 이름=수)」 → (키, [(이름, ('str' | 'num', 값))]) · 그 밖 꼴 = None.""" + s = str(text) + head = _HEAD.match(s) + if head is None: + return None + at, args = head.end(), [] + while arg := _ARG.match(s, at): + name = arg[1] if arg[1] is not None else arg[2] + args.append((name, ("str", arg[3]) if arg[3] is not None else ("num", Decimal(arg[4])))) + at = arg.end() + return (head[1], args) if re.fullmatch(r"\s*\)\s*", s[at:]) else None + + class _Doc: - def __init__(self, row: dict) -> None: - self.row, self.reg = row, _Reg() - self.links: dict[tuple, dict] = {} # 손 값 열쇠 → 변수 칸(이름 · 단위 · 연결) + def __init__(self, row: dict, master: Any = None) -> None: + self.row, self.reg, self.master = row, _Reg(), master + self.links: dict[tuple, dict] = {} # 값 변수 열쇠 → 변수 칸(이름 · 단위 · 연결) self.order: list[tuple] = [] self.kinds = {s["이름"]: "입력" for s in row.get("입력") or []} self.kinds |= {s["이름"]: "중간" for s in row.get("중간") or []} @@ -140,18 +161,62 @@ class _Doc: value: Any = {k: Decimal(str(given.get(k) or 0)) for k in md.COSTS} else: value = Decimal(str(item["단가"])) - key = ("손", at) + return self.var(("손", at), f"{name}단가", {"갈래": "숫자", "값": value}) + + def var(self, key: tuple, label: str, link: dict, unit: str = "") -> str: + """값 변수 하나(열쇠마다 한 기호) — 기호 = 이름 끝말 규칙.""" if key not in self.links: - self.reg.want(key, msym.lookup(f"{name}단가", "요소")) + sign, low, up = msym.lookup(label, "요소") + self.reg.want(key, (sign, self._low(link, low), up)) self.order.append(key) - self.links[key] = {"이름": f"{name}단가", "단위": "", "연결": {}} - self.links[key]["연결"] = {"갈래": "숫자", "값": value} + self.links[key] = {"이름": label, "단위": unit, "연결": link} + self.links[key]["연결"] = link return self.reg.id(key) + def _low(self, link: dict, low: str) -> str: + """요소 키가 아래첨자로 샌 것(`k_EQ0006`) → 자원 이름 끝 낱말.""" + if not _CODE.match(low or "") or link.get("갈래") != "요소": + return low + try: + row = self.master.get(str(link.get("키") or "")) + except Exception: # noqa: BLE001 — 없는 키 = 그대로 + return low + name = re.sub(r"\(.*?\)", "", str(row.get("이름") or "")).split(",")[0] + words = [w for w in name.split() if not w[:1].isdigit()] + got = msym.short(words[-1]) if words else "" + return got if got and got != "·" else low + + def element(self, ref: str, unit: str | None, part: str = "") -> str: + """사람이 더한 요소 줄(인력 · 재료 · 기계 키) — 요소 연결(M01 값 · 품셈재료 = 줄 단위) · + 기계 = 시간당 기계경비 단가산출의 그 비목(가져온 기계 줄과 같은 짝 · 자료 없음 = 요소).""" + from M02_MasterTemplete.M02_Doc_Import import hourly_link # 서로 부름 — 늦게 + + link = {"갈래": "요소", "키": ref} | ({"단위": unit} if unit is not None else {}) + try: + label = self.master.label(ref) + except Exception: # noqa: BLE001 — 없는 키 = 셈이 끊김 표지 + label = ref + if ref[:2] == "EQ" and (hourly := hourly_link(ref, part)): + return self.var(("기계", ref, part), label, hourly) + return self.var(("요소", ref, unit), label, link) + + def logic(self, text: str) -> str | None: + """사람이 더한 로직 부름 줄 — 단가산출 연결(이름 · 결과단위 = M01 수식 문서 머리).""" + got = logic_call(text) + if got is None: + return None + from M02_MasterTemplete import M02_Doc_Copy as dc + + code, args = got + link = {"갈래": "단가산출", "키": code, "입력": {k: md.text_of(v) for k, v in args}} + head = dc.folder().get(code) or {} + label = str(head.get("이름") or code) + return self.var(("블록", text), label, link, str(head.get("결과단위") or "")) + def build(row: dict, master: Any, given: dict | None = None) -> tuple[dict, list[str]]: """가져온 로직 줄 → (수식 문서, 알림) · `master` = 단위 채움 색인 · given = 입력 값.""" - c = _Doc(row) + c = _Doc(row, master) for kind in ("입력", "중간"): for spec in row.get(kind) or []: c.reg.want((kind, spec["이름"]), _merge(str(spec["이름"]), "", "")) @@ -250,9 +315,21 @@ def _money(c: _Doc, row: dict) -> list[dict]: except md.DocError as e: c.notes.append(f"호표 「{name}」 수량 못 읽음 — {e}") qty = str(item["수량"]) - price, line["비목"] = c.hand(at, item), item.get("비목") or "묶음" - if line["비목"] != "묶음" and item.get("값묶음"): - price = f"{price}.계" + if item.get("값묶음") or item.get("단가") is not None: # 손 값(가져온 줄 · 고정 줄) + price, line["비목"] = c.hand(at, item), item.get("비목") or "묶음" + if line["비목"] != "묶음" and item.get("값묶음"): + price = f"{price}.계" + elif item.get("종류") == "로직": + price = c.logic(str(item.get("요소") or "")) + if price is None: + raise ValueError(f"호표 「{name}」 로직 부름 꼴 아님 「{item.get('요소')}」") + line["비목"] = item.get("비목") or "묶음" + price = f"{price}.계" if "비목" in item else price + else: + ref = str(item["요소"]) + line["비목"] = item["비목"] + unit = str(item.get("단위") or "") if ref[:2] == LINKED else None + price = c.element(ref, unit, str(line["비목"])) line |= {"수량": qty, "단가": price} line |= {k: item[k] for k in LINE_KEYS if k in item} out.append(line) diff --git a/resources/tester/test_857_3a_import_adds.py b/resources/tester/test_857_3a_import_adds.py new file mode 100644 index 000000000..56ec2c674 --- /dev/null +++ b/resources/tester/test_857_3a_import_adds.py @@ -0,0 +1,129 @@ +"""857-3a 지킴 — 가져온 식 단가산출에 사람이 더한 줄(`더한줄`) 갈래마다 문서로 지어지고 셈됨. + +- 요소 줄(인력 · 재료 · 기계 키) = 요소 연결 · 금액 = 수량 × M01 값(두 판 같음). +- 손 단가 요소 줄 = 그 단가 · 고정 줄 = 줄 단가 · 로직 부름 = 그 단가산출 값. +- 형제 SK 부름 = 단가산출 연결 · 금액 = 수량 × 그 SK 값. +- 율 줄 = 옛 엔진 셈 은퇴(855 2-C1) — 못 셈 까닭이 남음. +""" + +from __future__ import annotations + +from decimal import Decimal + +import pytest + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Doc_Import as dim +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sangeun_Doc as sd +from M02_MasterTemplete import M02_Sangeun_Imported as imp +from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층 + +MAN = "LB000002" # 보통인부 + + +def _whole(): + return m01.loaded()[1] + + +def _sk(adds: list | None = None, key: str = "SK-000001") -> dict: + row = { + "이름": "더한줄 sub8임시", + "결과단위": "원/식", + "호표": [ + {"종류": "인력", "이름": "작업반장", "단위": "인", "수량": "0.1"} + | {"비목": "노무비", "단가": 200000}, + { + "종류": "재료", + "이름": "모래", + "단위": "㎥", + "수량": "2", + "비목": "재료비", + "단가": 30000, + }, + ], + } + meta = {"로직": row, "단가기준": "엑셀", "원본": {"엑셀금액": {}}} + doc = {"키": key, "이름": "더한줄", "단위": "식", "바탕": None, imp.KEY: meta} + return sd.clean({**doc, "더한줄": adds or []}, None, _whole()) + + +def _total(sk: dict, basis: str = "엑셀") -> Decimal: + one = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": basis}} + got = dim.run(dim.derive(one, None, _whole()), one) + assert got["셈됨"], got.get("표지") + return Decimal(str(got["계"])) + + +def _m01(code: str, unit: str | None = None) -> Decimal: + import master_material as mm # `M02_Doc_Copy` 가 scripts 를 길에 둠 + + return Decimal(str(mm.element(_whole(), code, {}, unit)[0])) + + +BASE = Decimal(20000 + 60000) + + +def test_바탕_엑셀_값(): + assert _total(_sk()) == BASE + + +@pytest.mark.parametrize("basis", ["엑셀", "우리"]) +def test_인력_요소_줄_수량x_M01_노임(basis): + got = _total(_sk([{"종류": "인력", "요소": MAN, "수량": 0.5}]), basis) + assert got - BASE == pytest.approx(Decimal("0.5") * _m01(MAN), abs=1) + doc = dim.derive(_sk([{"종류": "인력", "요소": MAN, "수량": 0.5}]), None, _whole()) + var = next(v for v in doc["변수"] if (v.get("연결") or {}).get("키") == MAN) + assert var["연결"]["갈래"] == "요소" + + +def _first(head: str) -> str: + return next(iter(_whole().index[head])) + + +def test_재료_요소_줄_수량x_M01_값(): + code = _first("MT") + got = _total(_sk([{"종류": "재료", "요소": code, "수량": 3}])) + assert got - BASE == pytest.approx(3 * _m01(code), abs=1) + + +def test_기계_요소_줄_시간당_경비_그_비목(): + code = next(k for k in _whole().index["EQ"] if imp.hourly_of(k).get("ok")) + sk = _sk([{"종류": "기계", "요소": code, "수량": 2, "비목": "경비"}]) + var = next(v for v in dim.derive(sk, None, _whole())["변수"] if "기계" in str(v["연결"])) + assert var["연결"]["갈래"] == "단가산출" and var["연결"]["칸"] == "경비" + assert _total(sk) > BASE + + +def test_손_단가_요소_줄_그_단가(): + adds = [{"종류": "인력", "요소": MAN, "수량": 2, "단가": 1000}] + assert _total(_sk(adds)) == BASE + 2000 + + +def test_고정_줄_줄_단가(): + fixed = {"이름": "잡비 sub8임시", "단위": "식", "단가": {"노무비": 0, "재료비": 700, "경비": 0}} + assert _total(_sk([{"고정": fixed, "수량": 3}])) == BASE + 2100 + + +def test_로직_부름_줄_단가산출_값(): + code = "GC000206" + alone = _sk([{"종류": "로직", "로직": code, "입력값": {}, "수량": 1}]) + doc = dim.derive(alone, None, _whole()) + var = next(v for v in doc["변수"] if (v.get("연결") or {}).get("키") == code) + assert var["연결"]["갈래"] == "단가산출" + assert _total(alone) > BASE + + +def test_형제_SK_부름_수량x_그_SK(world): # noqa: F811 — 같은 임시 층 fixture + with store.at(world["personal"]): + store.write("sangeun", "SK-000002", "", _sk(key="SK-000002")) + ref = {"층": MINE["층"], "주인": MINE["주인"], "키": "SK-000002"} + got = _total(_sk([{"참조": ref, "수량": 2}])) + assert got == BASE * 3 + + +def test_율_줄_못_셈_까닭(): + rate = {"이름": "공구손료", "단위": "%", "단가": {}, "비율": {"기준": "노무비", "비목": "경비"}} + sk = _sk([{"고정": rate, "수량": 3}]) + with pytest.raises(ValueError, match="율"): + dim.derive(sk, None, _whole())