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

This commit is contained in:
2026-11-18 01:21:28 +09:00
3 changed files with 235 additions and 33 deletions
+17 -21
View File
@@ -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)
+89 -12
View File
@@ -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)
+129
View File
@@ -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())