diff --git a/M02_MasterTemplete/M02_Hopyo_Excel.py b/M02_MasterTemplete/M02_Hopyo_Excel.py index aeedea10b..ff1fc21e7 100644 --- a/M02_MasterTemplete/M02_Hopyo_Excel.py +++ b/M02_MasterTemplete/M02_Hopyo_Excel.py @@ -18,8 +18,9 @@ STmate 꼴(「일위대가표」 · 「단가산출근거」 시트) = `M02_Hopy 어긋남은 글 목록(막지 않음). 행(329-1) = 호표 [제N호표 줄, 마지막 구성 줄] · 구성 줄 한 줄(엑셀 1부터) · 근거(330-1) = 단산N참조 줄에 「단가산출」 블록 `{출처, 직종, 행}`(`M02_Hopyo_Basis.read`) · -`단산` = 블록마다 `{번, 이름, 단위, 행, 출처, 직종, 글}`(338 · 글 = 머리 뺀 몸 줄) · -`꼴` = 「엑셀꼴」. +`단산` = 블록마다 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`(338 · 글 = 머리 뺀 몸 줄) · +`꼴` = 「엑셀꼴」 · 두 형식 끝에 `UnitLine.settle`(단위 줄 하위 · 재현 · 덮음 · 일위대가 줄 +투영 · 778-3). """ from __future__ import annotations @@ -31,6 +32,7 @@ from typing import Any from M02_MasterTemplete import M02_Hopyo_ReadEst as hopyo_basis # EST 단가산출 어댑터(776-2) from M02_MasterTemplete import M02_Hopyo_Stmate as hopyo_stmate +from M02_MasterTemplete import M02_Hopyo_UnitLine as unit_line SHEET = "일위대가" SUMMARY = "일위대가총괄표" @@ -300,7 +302,7 @@ def read_book(name: str, data: bytes) -> dict[str, Any]: sheets, xls = _open(name, data, LISTS) _OPENED = (data, sheets, xls) # 격자(`Grid.read`)가 이어 씀 — 한 번 열기 if hopyo_stmate.is_stmate(sheets): - return hopyo_stmate.read(sheets) + return unit_line.settle(hopyo_stmate.read(sheets)) rows = sheets.get(SHEET) if rows is None: raise ExcelError(NO_SHEET) @@ -365,13 +367,14 @@ def read_book(name: str, data: bytes) -> dict[str, Any]: ] keep = ("번", "이름", "단위", "행", "출처", "직종", "글", "금액", "항목") basis = [{k: b[k] for k in keep} for b in blocks.values()] - return { + book = { "꼴": "엑셀꼴", "시트": SHEET, "호표": out, "단산": basis, "검산": {"어긋남": wrong, "총괄표": len(totals)}, } + return unit_line.settle(book) # 단위 줄 하위 · 재현 · 덮음 · 일위대가 줄 투영(778-3) def _json(value: Any) -> Any: diff --git a/M02_MasterTemplete/M02_Hopyo_ReadEst.py b/M02_MasterTemplete/M02_Hopyo_ReadEst.py index fa09e86cc..2c75c78e8 100644 --- a/M02_MasterTemplete/M02_Hopyo_ReadEst.py +++ b/M02_MasterTemplete/M02_Hopyo_ReadEst.py @@ -9,16 +9,15 @@ 글 = 머리 뺀 몸 줄 `GLINES` 줄 · 줄마다 `GCHARS` 자 안 · 산출근거 열이 빈 줄은 그 오른쪽 ~ 돈 머리 (맨 오른쪽 묶음) 앞 칸을 빈칸으로 이어 붙임(거창 꼴 · 돈 머리 없으면 `WIDE` 열) · 금액 = 머리 줄 돈 칸(1 단위). -항목(Book 블록 항목) = 글 줄 풀이 — 줄 율(호표 줄 이름 · 규격)에 기대지 않는 것만 · -지문 단계가 율을 가름: +항목(Book 블록 항목 · 778-3) = 글 줄 → 단위 줄(꼴 = `M02_Hopyo_UnitLine`) · 줄 금액 = 「= 금액」 · +끝 점(「28,500. ×」) 뗌 · 율(호표 줄 이름 · 규격)에 기대지 않는 것만(섞음 율은 지문 몫): L 직종 줄 「직종 : 단가 × 식 = 금액」(못 풀면 금액 ÷ 단가 「역산」 · `직종` = 우리 이름) · X 장비 = 장비 절 · 장비 글 줄 뒤 「노무비 · 경비 · 재료비 : 단가 ÷ Q」 — 절 · 장비마다 하나 - (노무비(단가 > 0) > 경비 > 재료비 줄의 품) · 이름 = 장비 글 · 단가 = 비목마다 · - M 자재 = 「이름 단가 × 수량 = 금액」 · 「이름 : 별도계상」(품 없음). - 항목 = `{갈래, 이름, 규격, 품, 밑품, 율, 인자, 단가, 절, 절율, 어떻게, 행}`(L 은 + 직종) · - STmate 어댑터(`M02_Hopyo_Stmate`)도 같은 꼴. -풀이 규칙은 지문(`M02_Hopyo_Finger._text`)과 같음 — 776-3 이 지문을 항목 위로 옮기면 -그쪽 사본을 걷음. + (품 = 노무비(단가 > 0) › 경비 › 재료비 줄 · 비목마다 매개값이 다르면 `계수`) · + M 자재 = 「이름 단가 × 수량 = 금액」(이름 속 = · / 도) · 「이름 : 별도계상」(품 없음) · + R 율 = 「기준 × N% = 금액」(라벨 = 이 줄 · 앞 줄 · 기준 = 「노무비의」 앞 낱말) · + E 값 = 셈 글 아닌 「이름 : … = 금액」(하위 가름은 `UnitLine.settle`) · + 절 = 제목(작은 절 = 「윗 제목 · 작은 제목」) · 합계 · 소계 절 안 줄 = `밖`. """ from __future__ import annotations @@ -28,6 +27,7 @@ from functools import lru_cache from typing import Any from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Hopyo_UnitLine as unit_line from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs from M02_MasterTemplete.M02_Hopyo_Words import mtypes, parse_rhs @@ -53,6 +53,26 @@ _MAT = re.compile( _SEC = re.compile(r"^\s*(\d+)\.\s*(.*)$") _SUB = re.compile(r"^\s*([가-하])\.\s*(.*)$") _LASTNUM = re.compile(r"=\s*([\d,]+(?:\.\d+)?)\s*$") +# 단위 줄(778-3) — 줄 금액 · 끝 점 · 율 · 느슨한 자재 · 셈 글 · 합계 절 +NUM = r"[\d,]+(?:\.\d+)?" +_AMOUNT = re.compile( # 끝 「= 금액」 — 원 · ￦ · 「\/㎡」 단위 · 「(지주)」 꼬리 허용 + r"=\s*[A-Z]?\s*(" + NUM + r")\s*\.?\s*(?:원|￦)?\s*(?:\\?/\s*\S+)?\s*(?:\([^()]*\))?\s*$" +) +_DOT = re.compile(r"(\d)\.(?=\s|$|%)") +_DECR = re.compile(r"[×xX*]\s*(0?\.\d+)\s*=") +_PCTN = re.compile(r"(\d+(?:\.\d+)?)\s*%") +_BASEW = re.compile(r"([가-힣]+)의\s*[\d.]+\s*%") +_TOTAL = re.compile(r"(합\s*계|소\s*계|총\s*계)") +_NUMBERED = re.compile(r"^\s*(?:\d+|[가-하])\s*[.)]\s*") # 「3.」 · 「가.」 · 「1)」 머리 +_TOP_L = re.compile(r"^\s*\d+\s*\.\s*(.*)$") +_SUB_L = re.compile(r"^\s*[가-하]\s*\.\s*(.*)$") +_DECIMAL = re.compile(r"^\s*\d+\.\d") +_LOOSE = re.compile( + r"^\s*(?P[^\d\s:：].*?[A-Za-z가-힣)\]])\s+(?P" + NUM + r"\s*[×xX*÷/].*=.*)$" +) +_CALC = re.compile( + r"(^|[\s(])(Q\d?|q\w?|K|k|f\d?|E\w?|Cm|L|V\d|T|rt|n|t\d|A|N|W|V|S)\s*[=:]|─|㎥/hr|m3/hr|/hr\b" +) def _flat(value: Any) -> str: @@ -187,7 +207,7 @@ def read(rows: list[list[Any]] | None) -> dict[int, dict[str, Any]]: return blocks -# ── 글 → 항목 ───────────────────────────────────────────────────────── +# ── 글 → 단위 줄 ─────────────────────────────────────────────────────── def _ratio(rhs: str) -> float | None: """식을 못 풀 때만 — 금액 ÷ 단가(품 되찾기용).""" m = re.match(r"^\s*([\d,]+(?:\.\d+)?)", rhs) @@ -198,22 +218,82 @@ def _ratio(rhs: str) -> float | None: return a / p if p else None +def _num(text: str) -> float | None: + try: + return float(text.replace(",", "")) + except ValueError: + return None + + +def amount(row: str) -> float | None: + """줄 끝 「= 금액」(원 · 끝 점 · 앞 글자 하나 허용).""" + m = _AMOUNT.search(row.replace("W", "")) + return _num(m.group(1)) if m else None + + def _item(kind: str, name: str, got: dict[str, Any], how: str, **more: Any) -> dict[str, Any]: - keep = {k: got.get(k) for k in ("품", "밑품", "율", "인자")} - return {"갈래": kind, "이름": name, "규격": "", **keep, "어떻게": how, **more} + keep = {"품": got.get("품"), "밑품": got.get("밑품")} + keep |= {"율": got.get("율") or [], "인자": got.get("인자") or []} + return {"묶음": kind, "이름": name, "규격": "", **keep, "어떻게": how, **more} + + +def _material(hit: Any, row: str, money: float | None, place: dict) -> dict[str, Any]: + """자재 줄 「이름 단가 × 수량 [× 손료율] = 금액」 — 손료율 = 식 속 % · 끝 「× 0.xx =」.""" + got = parse_rhs(hit.group("rhs")) + more = {"단가": {"재료비": got["단가"]} if got else {}, "금액": money, **place} + one = _item("M", hit.group("name").strip(), got or {}, "식", **more) + pct = [v for v, note in (got or {}).get("율") or [] if note == "%"] + dec = _DECR.search(row) + dec = float(dec.group(1)) if dec and 0.5 <= float(dec.group(1)) < 1 else None + if ( + pct or dec + ): # ponytail: 끝 「× 0.95 =」 = 손료율(0.5~1) 어림 — 글에 「손료」 표지가 생기면 그것으로 + one["손료율"] = pct[-1] if pct else dec + return one + + +def _rate(row: str, prev: str, cm: Any) -> dict[str, Any]: + """율 줄 「기준 × N% = 금액」(라벨 = 이 줄 이름 · 없으면 앞 줄) → + {이름, 품 = 율, 기준값, 기준}.""" + pm = _PCTN.findall(row) or _PCTN.findall(prev) + rate = float(pm[-1]) / 100 if pm else None + dec = _DECR.search(row) + if dec and not _PCTN.findall(row): + rate = float(dec.group(1)) + body = row.split(":", 1)[-1] if cm else row + par = re.search(r"\(([^()]*\d[^()]*)\)\s*[×xX*]", body) + if par and "+" in par.group(1): + base: float | None = sum(_num(x) or 0 for x in re.findall(NUM, par.group(1))) + else: + hit = re.search(r"(" + NUM + r")\s*[×xX*]\s*(?:" + NUM + r")\s*(?:%|=)", body) + hit = hit or re.search(r"(" + NUM + r")", body) + base = _num(hit.group(1)) if hit else None + word = _BASEW.search(row) or _BASEW.search(prev) + label = _NUMBERED.sub("", (cm.group("name") if cm else prev)).strip()[:40] + return {"이름": label, "품": rate, "기준값": base, "기준": word.group(1) if word else ""} def items(text: list[str], rows: list[int] | None = None) -> list[dict[str, Any]]: - """블록 몸 글(머리 뺌) → 항목 목록(L · M 은 글 차례 · X 는 절 · 장비 처음 나온 차례로 뒤에).""" + """블록 몸 글(머리 뺌) → 단위 줄(글 차례 · 기계 = 절 · 장비마다 하나 · 첫 비목 줄 자리 · + 품 = 노무비(단가 > 0) › 경비 › 재료비 줄) · 합계 · 소계 절 안 = `밖` · 값 → 하위 가름은 책 + 단위(`M02_Hopyo_UnitLine.settle`).""" rows = rows or [0] * len(text) names = trade_names() out: list[dict[str, Any]] = [] machines: dict[tuple, dict[str, Any]] = {} - sec, sub, mach, label = 0, "", False, "" + sec, sub, mach, label, total, prev = 0, "", False, "", False, "" + top = path = "" # 절 제목 · 작은 절이면 「윗 제목 · 작은 제목」 + whole_out = False # 합계 · 소계 맨 윗 절 안 sec_rates: set[float] = set() for raw, at in zip(text, rows, strict=True): row = str(raw).rstrip() h, s = _SEC.match(row), _SUB.match(row) + if (lt := _TOP_L.match(row)) and not _DECIMAL.match(row): # 몫 절 · 셈 밖(띄어 쓴 「가 .」) + top = path = lt.group(1).strip() + whole_out = total = bool(_TOTAL.search(top)) + elif ls := _SUB_L.match(row): + total = whole_out or bool(_TOTAL.search(ls.group(1))) + path = path if total else f"{top} · {ls.group(1).strip()}" if h or s: if h: sec, sub = int(h.group(1)), "" @@ -225,46 +305,87 @@ def items(text: list[str], rows: list[int] | None = None) -> list[dict[str, Any] ts = mtypes(title) mach = bool(ts) label = title.strip() if ts else "" - where = f"{sec}.{sub}" if sub else str(sec) - place = {"절": where, "절율": sorted(sec_rates), "행": at} + else: + row = _DOT.sub(r"\1", row) # 「28,500. ×」 끝 점 + place = { + "절": path, + "윗절": top, + "절율": sorted(sec_rates), + "행": at, + **({"밖": True} if total else {}), + } + money = amount(row) cm = _COLON.match(row) name = re.sub(r"^[0-9가-힣]\.", "", _flat(cm.group("name"))) if cm else "" who = names.get(name) if cm else None if who: rhs = cm.group("rhs") - raw_name, how = cm.group("name").strip(), {"직종": who, **place} + raw_name, how = cm.group("name").strip(), {"직종": who, "금액": money, **place} if got := parse_rhs(rhs): out.append(_item("L", raw_name, got, "식", 단가={"노무비": got["단가"]}, **how)) elif r := _ratio(rhs): - got = {"품": r, "밑품": r, "율": [], "인자": []} - out.append(_item("L", raw_name, got, "역산", **how)) + got = {"품": r, "밑품": r} + out.append(_item("L", raw_name, got, "역산", 단가={}, **how)) + elif money is not None: # 품 없는 「직종 : P」 선언 줄은 뺌(값은 뒤 줄) + out.append(_item("L", raw_name, {}, "식", 단가={}, **how)) + prev = row continue if cm and name in COST: got = parse_rhs(cm.group("rhs")) - if got and mach: + if mach and (got or money is not None): key = (sec, sub, label) - prio = 0 if (name == "노무비" and got["단가"] > 0) else 1 if name == "경비" else 2 one = machines.get(key) - if one is None or prio < one["_순"]: - price = one["단가"] if one else {} - one = _item("X", label, got, "식", 단가=price, _순=prio, **place) + if one is None: + one = _item("X", label, {}, "식", 단가={}, 금액=0.0, _순=9, _q={}, **place) machines[key] = one - one["단가"][name] = got["단가"] + out.append(one) + one["금액"] = round(one["금액"] + (money or 0), 6) + if got: + prio = ( + 0 if (name == "노무비" and got["단가"] > 0) else 1 if name == "경비" else 2 + ) + if prio < one["_순"]: + one.update({k: got[k] for k in ("품", "밑품", "율", "인자")}, _순=prio) + one["단가"][name] = got["단가"] + one["_q"][name] = got["품"] + prev = row continue if cm and name not in SKIPW and re.search(r"(별도|별산)", cm.group("rhs")): - got = {"품": None, "밑품": None, "율": [], "인자": []} - out.append(_item("M", cm.group("name").strip(), got, "별도", **place)) + more = {"단가": {}, "금액": 0.0, **place} + out.append(_item("M", cm.group("name").strip(), {}, "별도", **more)) + prev = row continue mm = _MAT.match(row) - if mm and not cm and (got := parse_rhs(mm.group("rhs"))): - price = {"재료비": got["단가"]} - out.append(_item("M", mm.group("name").strip(), got, "식", 단가=price, **place)) + if mm and not cm: + out.append(_material(mm, row, money, place)) + prev = row continue if not (h or s): ts = mtypes(row) if ts and "%" not in row and not cm: mach, label = True, row.strip() + if ( + money is None + or total + or (cm and (name in ("소계", "계", "합계") or name.endswith("소계"))) + ): + prev = row + continue + dec = _DECR.search(row) + loose = None if cm else _LOOSE.match(row) + if loose and (names.get(_flat(loose.group("name"))) or _BASEW.search(loose.group("name"))): + loose = None # 직종 · 「…의 N%」 이름 = 자재 아님 + if loose: # 자재(이름 속 = · / · 손료율 % 도) + out.append(_material(loose, row, money, place)) + elif "%" in row or (dec and "%" in prev): + got = {"묶음": "R", "규격": "", **_rate(row, prev, cm), "단가": {}, "금액": money} + out.append({**got, "어떻게": "율", **place}) + elif cm and not _CALC.search(row): + first = re.search(r"(" + NUM + r")\s*[×xX*]", cm.group("rhs")) + price = {"계": _num(first.group(1))} if first else {} + one = {"묶음": "E", "이름": cm.group("name").strip()[:40], "규격": "", "품": None} + out.append({**one, "단가": price, "금액": money, "어떻게": "값", **place}) + prev = row for one in machines.values(): - del one["_순"] - out.append(one) + unit_line.machine_done(one) return out diff --git a/M02_MasterTemplete/M02_Hopyo_Stmate.py b/M02_MasterTemplete/M02_Hopyo_Stmate.py index f8f6efafe..dae50371f 100644 --- a/M02_MasterTemplete/M02_Hopyo_Stmate.py +++ b/M02_MasterTemplete/M02_Hopyo_Stmate.py @@ -15,9 +15,12 @@ PR · 단위 % = % · 그 밖 기타. 비면 목록표 · 기계 셋 줄(노무비 · 재료비 · 경비)은 하나로 · 절 = 그 앞 번호 절 제목) · 머리 이름 · 규격 · 단위 = 단가산출근거목록표 · 출처 = 블록 글 `ReadEst.sources` · 직종 = 자원 L 이름(우리 인력 · 옛이름 = 지금 이름) · -금액 = 머리 줄 C~F(1 단위) · 항목(776-2 · Book 블록 항목 · EST 어댑터 `M02_Hopyo_ReadEst` 와 -같은 꼴) = 자원 + `{직종(L), 밑품 = 품, 율 [], 인자 [], 단가 I~L, 금액 C~F, 어떻게 「QTY」, 행}` -(기계 셋 줄 = 더함). +금액 = 머리 줄 C~F(1 단위) · 항목(778-3 · 단위 줄 꼴 = `M02_Hopyo_UnitLine`) = 행마다 + 자원 L 노무 · X 기계 · M 자재 · S 경비 = E 값(품 = H · 단가 I~L · 줄 금액 C · 어떻게 「QTY」) · + 기계 셋 줄 = 같은 코드 · 절 · 아직 빈 비목일 때만 하나(같은 코드 두 묶음 = 따로 · + 비목마다 H 가 다르면 `계수`) · G 열 「&자원& * N'%'」 = R 율(기준값 = I) · + PR · RR 행 = R 율(PR = N % · RR = 곱 · 기준 = G 열 표지 「&PA01M:M&」 앞) · + D 코드 행 = S 하위 · N 열 「C…」 = `밖`(소계(제외금액)) · 자원 = 자원 코드 줄 옛 칸. 검산 안 함 — `검산 {어긋남: [], 총괄표: 0}`. """ @@ -28,6 +31,7 @@ from typing import Any from M02_MasterTemplete import M02_Hopyo_Excel as hopyo_excel # 서로 부름 — 부를 때만 씀 from M02_MasterTemplete import M02_Hopyo_ReadEst as hopyo_est +from M02_MasterTemplete import M02_Hopyo_UnitLine as unit_line SHEET = "일위대가표" CALC = "단가산출근거" @@ -45,6 +49,17 @@ _COLS = {"합계": 4, "노무비": 6, "재료비": 8, "경비": 10} _CALC_AMOUNT = {"합계": 2, "노무비": 3, "재료비": 4, "경비": 5} # 단가산출근거 C~F 금액 _CALC_PRICE = {"합계": 8, "노무비": 9, "재료비": 10, "경비": 11} # I~L 단가(T · L · M · S) NOTE, CODE_COLS, RES_COL, QTY_COL, NAME_COL = 12, range(12, 26), 12, 7, 23 +FORMULA_COL, OUT_COL = 6, 13 # G 식 · N 합 갈 곳(C = 셈 밖 「소계(제외금액)」) +COSTS = ("노무비", "재료비", "경비") +_KIND = {"L": "L", "X": "X", "M": "M", "S": "E"} # 자원 코드 머리 → 단위 줄 묶음(S 경비 = 값) +_RES_CODE = re.compile(r"^[LMXS]\d{5}$") +_RATE = re.compile(r"^(?:PR|RR)[A-Z]?_") # 율 행 「PR_1」 · 「RRS_(8)_1」 +_SUB_D = re.compile(r"^(D\d{5})_\d+$") # 다른 블록 부름 +_PCT_REF = re.compile(r"&([A-Z][A-Z0-9_]*?)(?::[A-Z])?&\s*\*\s*[\d.]+\s*'%'\s*=") # 율 꼴 자원 행 +_LOSS = re.compile(r"\*\s*([\d.]+)\s*'%'") # 자재 손료율 「* 0.443'%'」 +_BASE_WORD = re.compile(r"([가-힣]+)의\s*[\d.]+\s*%") # 율 기준글 「(인건비의 3%)」 +_NUMBERED = re.compile(r"^\s*(?:\d+|[가-하])\s*[.)]\s*") +_TAG = re.compile(r"&([A-Z][A-Z0-9_]*?)(?::[A-Z])?&") # 율 기준 표지 「&PA01M:M&」 → PA01M def is_stmate(names: Any) -> bool: @@ -100,12 +115,78 @@ def _lists(sheets: dict[str, list[list[Any]]]) -> dict[str, dict[str, str]]: # ── 단가산출근거 블록 ────────────────────────────────────────────────── +def _part(row: list[Any]) -> str | None: + """기계 셋 줄 가운데 이 줄 비목(I~L 단가 칸 · 노무비 › 재료비 › 경비).""" + return next((k for k in COSTS if _cell(row, _CALC_PRICE[k]) not in (None, "")), None) + + +def _same_machine(last: dict[str, Any] | None, code: str, title: str, part: str | None) -> bool: + """바로 앞 기계 줄과 한 기계(셋 줄)인가 — 같은 코드 · 절 · 이 비목이 아직 빔 + (같은 코드 두 묶음 = 따로 · 울진대흥 1129).""" + return bool( + last + and last["묶음"] == "X" + and last["코드"] == code + and last["절"] == title + and part + and part not in last["_q"] + ) + + +def _unit(row: list[Any], code: str, title: str, info: dict[str, str]) -> dict[str, Any]: + """자원 행 → 단위 줄(L 노무 · X 기계 · M 자재 · S 경비 = E 값 · G 열 「'%'」 = R 율).""" + name, _, spec = _s(_cell(row, NAME_COL)).partition("/") + qty = hopyo_excel._num(_cell(row, QTY_COL)) + q = float(qty) if qty is not None else None + one = { + "묶음": _KIND.get(code[0], "E"), + "코드": code, + "이름": name.strip() or info.get("이름", ""), + "규격": spec.strip() if name.strip() else info.get("규격", ""), + "단위": info.get("단위", ""), + "품": q, + "절": title, + } + if rate := _PCT_REF.search(_s(_cell(row, FORMULA_COL))): # 「기구손료 : &L00020& * 2'%'」 + base = hopyo_excel._num(_cell(row, _CALC_PRICE["합계"])) + more = {"기준": rate.group(1), "기준값": float(base) if base is not None else None} + return {**one, "묶음": "R", "품": q / 100 if q is not None else None, **more} + if one["묶음"] == "M" and (loss := _LOSS.search(_s(_cell(row, FORMULA_COL)))): + one["손료율"] = round(float(loss.group(1)) / 100, 9) # 「&M00081& * 1.03'㎡'* 0.443'%'」 + return one + + +def _rate_row(row: list[Any], code: str, text: str, label: str) -> dict[str, Any]: + """PR · RR 율 행 → 단위 줄 R(기준 = G 열 표지 「&PA01M:M&」 앞 · PR = N % · RR = 곱) · 이름이 + 없는 식 줄(「210,212.3 * 0.09」)은 위 라벨 줄(「기구손료 : (가공노력품의 9%)」)에서 이름 · + 기준글 · 못 찾으면 이름 빈 줄 + `이름없음`.""" + qty = hopyo_excel._num(_cell(row, QTY_COL)) + base = hopyo_excel._num(_cell(row, _CALC_PRICE["합계"])) + tag = _TAG.search(_s(_cell(row, FORMULA_COL))) + rate = float(qty) / (100 if code.startswith("PR") else 1) if qty is not None else None + name = text.split(":")[0] if ":" in text else "" + if not re.search(r"[가-힣A-Za-z]", name): + name = _NUMBERED.sub("", label.split(":")[0] if ":" in label else label) + word = _BASE_WORD.search(f"{text} {label}") + return { + "묶음": "R", + "코드": code, + "이름": name.strip()[:40], + "규격": "", + "품": rate, + "기준": tag.group(1) if tag else "", + "기준값": float(base) if base is not None else None, + **({"기준글": word.group(1)} if word else {}), + **({} if name.strip() else {"이름없음": True}), + } + + def _blocks(rows: list[list[Any]], table: dict[str, dict[str, str]]) -> dict[str, dict[str, Any]]: """{D 코드: {번, 코드, 이름, 규격, 단위, 행, 출처, 직종, 글, 자원, 금액, 항목}}.""" names = hopyo_est.trade_names() out: dict[str, dict[str, Any]] = {} block: dict[str, Any] | None = None - title = "" + title = label = "" # 절 제목 · 율 행 위 라벨 줄(코드 · 금액 없는 글) for at, row in enumerate(rows, 1): head = next( (hit for v in row[:8] if (hit := _HEAD_D.search(_s(v)))), None @@ -123,12 +204,11 @@ def _blocks(rows: list[list[Any]], table: dict[str, dict[str, str]]) -> dict[str "단위": info.get("단위", ""), "행": [at, at], "글": [], - "자원": [], "금액": _calc_money(row, _CALC_AMOUNT), "항목": [], }, ) - title = "" + title = label = "" continue if block is None: continue @@ -137,16 +217,18 @@ def _blocks(rows: list[list[Any]], table: dict[str, dict[str, str]]) -> dict[str block["행"][1] = at block = None continue - text = _s(_cell(row, 1)) - res = _RES.match(_s(_cell(row, RES_COL))) + text, cell = _s(_cell(row, 1)), _s(_cell(row, RES_COL)) + res = _RES.match(cell) code = res.group(1) + res.group(2) if res else None if not code: - alt = _RES_A.match(first) or _RES_G.search(_s(_cell(row, 6))) + alt = _RES_A.match(first) or _RES_G.search(_s(_cell(row, FORMULA_COL))) code = alt.group(1) if alt else None + rate = None if code else _RATE.match(cell) + sub = None if code or rate else _SUB_D.match(cell) if not text and not code: continue block["행"][1] = at - if _s(_cell(row, RES_COL)) == block["코드"]: # 머리 이름 줄 「이름 규격 / 단위」 + if cell == block["코드"]: # 머리 이름 줄 「이름 규격 / 단위」 if not block["이름"]: name, _, unit = text.rpartition("/") block["이름"], block["단위"] = name.strip() or text, unit.strip() @@ -156,41 +238,56 @@ def _blocks(rows: list[list[Any]], table: dict[str, dict[str, str]]) -> dict[str block["글"].append(text[: hopyo_est.GCHARS]) if (sec := _SECTION.match(text)) and not re.match(r"^\s*\d+\.\d", text): title = sec.group(1).strip() + money = _calc_money(row, _CALC_AMOUNT) + place = { + "단가": _calc_money(row, _CALC_PRICE), + "금액": money.get("계"), + "행": at, + "절": title, + "윗절": title, + **({"밖": True} if _s(_cell(row, OUT_COL)).startswith("C") else {}), + } + if rate: + block["항목"].append({**_rate_row(row, cell, text, label), **place, "어떻게": "율"}) + continue + if code or sub or money.get("계") is not None: + label = "" # 라벨은 바로 위 글 줄만 + elif text: + label = text.strip() + if sub and sub.group(1) != block["코드"] and money.get("계"): + qty = hopyo_excel._num(_cell(row, QTY_COL)) + one = {"묶음": "S", "코드": sub.group(1), "이름": text[:40], "규격": ""} + more = {"품": float(qty) if qty is not None else None, "어떻게": "QTY"} + block["항목"].append( + {**one, **more, **place, "하위": {"종류": "단산", "번": int(sub.group(1)[1:])}} + ) + continue if not code: continue - price, amount = _calc_money(row, _CALC_PRICE), _calc_money(row, _CALC_AMOUNT) - last = block["자원"][-1] if block["자원"] else None - if code[0] == "X" and last and last["코드"] == code and last["절"] == title: - _add(block["항목"][-1]["단가"], price) # 기계 노무비 · 재료비 · 경비 셋 줄 = 하나 - _add(block["항목"][-1]["금액"], amount) + last, part = block["항목"][-1] if block["항목"] else None, _part(row) + if code[0] == "X" and _same_machine(last, code, title, part): + _add(last["단가"], place["단가"]) # 기계 노무비 · 재료비 · 경비 셋 줄 = 하나 + last["금액"] = hopyo_excel._out( + hopyo_excel._num(last["금액"] or 0) + hopyo_excel._num(place["금액"] or 0) + ) + last["_q"][part] = hopyo_excel._num(_cell(row, QTY_COL)) continue - name, _, spec = _s(_cell(row, NAME_COL)).partition("/") - info = table.get(code) or {} - qty = hopyo_excel._num(_cell(row, QTY_COL)) - res = { - "갈래": code[0], - "코드": code, - "이름": name.strip() or info.get("이름", ""), - "규격": spec.strip() if name.strip() else info.get("규격", ""), - "품": float(qty) if qty is not None else None, - "절": title, - } - block["자원"].append(res) - who = hopyo_est.trade(res["이름"]) if code[0] == "L" else None - block["항목"].append( - { - **res, - **({"직종": who} if code[0] == "L" else {}), - "밑품": res["품"], - "율": [], - "인자": [], - "단가": price, - "금액": amount, - "어떻게": "QTY", - "행": at, - } - ) + one = _unit(row, code, title, table.get(code) or {}) + who = hopyo_est.trade(one["이름"]) if one["묶음"] == "L" else None + one = {**one, **({"직종": who} if one["묶음"] == "L" else {}), "밑품": one["품"]} + one.update(율=[], 인자=[], 어떻게="율" if one["묶음"] == "R" else "QTY", **place) + if one["묶음"] == "X": + one["_q"] = {part: hopyo_excel._num(_cell(row, QTY_COL))} if part else {} + block["항목"].append(one) for block in out.values(): + for one in block["항목"]: + if "_q" in one: + unit_line.machine_done(one) + block["자원"] = [ # 옛 칸(S1 투영) — 자원 코드 줄만 + {"갈래": one["코드"][0], **{k: one[k] for k in ("코드", "이름", "규격", "품", "절")}} + for one in block["항목"] + if _RES_CODE.match(one["코드"]) + ] block["출처"] = hopyo_est.sources(" ".join(block["글"])) trades = [names.get(_flat(r["이름"])) for r in block["자원"] if r["갈래"] == "L"] block["직종"] = list(dict.fromkeys(t for t in trades if t)) diff --git a/M02_MasterTemplete/M02_Hopyo_Store.py b/M02_MasterTemplete/M02_Hopyo_Store.py index 981e9525c..b3ce67a73 100644 --- a/M02_MasterTemplete/M02_Hopyo_Store.py +++ b/M02_MasterTemplete/M02_Hopyo_Store.py @@ -32,7 +32,7 @@ DONE = "불러옴" NO_GRID = "격자 없음 — 다시 올리면 보임" RELOAD = "읽기 꼴이 바뀐 옛 불러오기 — 엑셀을 다시 올림" EXPIRE = timedelta(days=1) # 작업 중 HP 보관 — 올린 뒤 하루 -BOOK = 2 # 읽기 꼴(Book) 판 — 읽기 · 정규화 출력 꼴을 바꾸면 올림 +BOOK = 3 # 읽기 꼴(Book) 판 — 읽기 · 정규화 출력 꼴을 바꾸면 올림 _KEY = re.compile(r"^HP-(\d{6})$") # ponytail: 프로세스 안 잠금 — 서버를 여럿 띄우면 파일 잠금으로 _LOCK = threading.Lock() diff --git a/M02_MasterTemplete/M02_Hopyo_UnitLine.py b/M02_MasterTemplete/M02_Hopyo_UnitLine.py new file mode 100644 index 000000000..ead5c3da6 --- /dev/null +++ b/M02_MasterTemplete/M02_Hopyo_UnitLine.py @@ -0,0 +1,219 @@ +"""M02 일위대가 실무자료 단위 줄(PLAN 778-3 · D-1 · 요구 622) — 단가산출 블록 · 일위대가 줄을 같은 +「세부항목 계산 단위」 꼴로 · 자체 검산. 형식(EST · STmate)을 모름 — 읽기 어댑터 +(`M02_Hopyo_ReadEst.items` · `M02_Hopyo_Stmate._blocks`)가 블록 `항목` 을 단위 줄로 냄. + +단위 줄 = `{묶음, 이름, 규격, 단위, 품, 밑품, 율, 인자, 계수, 단가, 금액, 밖, 기준, 기준값, +하위, 할증, 재현, 직종, 절, 절율, 코드, 어떻게, 행}`: + 묶음 = L 노무 · X 기계 · M 자재 · R 율 · S 하위 · E 값 + 품 = 매개값(L 품 · X 시간 · M 수량 · R 율 소수 · S 수량 · E 없음) · 밑품 · 율 · 인자 = 지문 몫 + 계수 = X 비목마다 매개값이 다를 때 `{비목: 그 비목 매개값 ÷ 품}`(덤프 재료비 (Cm-t1)/Cm) + 단가 = {노무비 · 재료비 · 경비(· 계)} · 금액 = 줄 금액(None = 엑셀에 없음) + 밖 = 셈 밖(STmate N 열 C · EST 합계 · 소계 절) · 기준 · 기준값 = 율 줄 기준 표지 · 기준 금액 · + 기준글 = 라벨 「…의 N%」 앞 낱말(STmate) · 기준꼴 · 기준줄 = 기준값이 어느 줄 합인가 + (`base_rows`) · + 이름없음 = 율 줄 이름 못 찾음 · 손료율 = M 「수량 × 손료율 × 단가」 꼴 표지(율 줄 아님) + 하위 = S `{종류 단산|일위, 번}` · 할증 = X 이름 · 규격 「할증120%」 → 1.2 + 재현 = 단가 × 매개값(× 계수) ≈ 금액(0.5 % · 1 원) · 율 = 기준값 × 율 · 별도 · 값 = 참 +블록 `줄합` = 밖 아닌 줄 금액 합 · `덮음` = 줄합 ≈ 블록 금액(금액 없으면 None). +일위대가 줄 → `묶음` · `재현` · % 줄 `기준`(노무비 · 재료비 · 주재료비 · 경비 = 규격 글) · +호표 `줄합` · `덮음`. +값 줄(E · 첫 수 = 다른 블록 · 호표 1 단위 금액 ±0.51 · 100 넘음) → S 하위. +""" + +from __future__ import annotations + +import re +from typing import Any + +COSTS = ("노무비", "재료비", "경비") +TOL = 0.005 +_SURCHARGE = re.compile(r"할증\s*(\d+(?:\.\d+)?)\s*%") +_KIND = { + "노임": "L", + "기계": "X", + "자재": "M", + "별도계상": "M", + "%": "R", + "단가산출": "S", + "호표": "S", +} + + +def near(a: Any, b: Any, tol: float = TOL) -> bool: + if a is None or b is None: + return False + a, b = float(a), float(b) + return abs(a - b) <= max(tol * max(abs(a), abs(b)), 1.0) + + +def money(d: Any) -> float | None: + """금액 · 단가 칸 → 수(계 › 비목 합 · 수면 그대로).""" + if isinstance(d, (int, float)) and not isinstance(d, bool): + return float(d) + if not isinstance(d, dict): + return None + if d.get("계") not in (None, ""): + return float(d["계"]) + vals = [float(d[c]) for c in COSTS if d.get(c) not in (None, "")] + return sum(vals) if vals else None + + +def machine_done(one: dict[str, Any]) -> None: + """기계 줄 마무리(두 어댑터) — 비목마다 매개값이 다르면 `계수`.""" + one.pop("_순", None) + got_q, main = one.pop("_q", {}), one.get("품") + if main: + ratio = { + k: round(float(q) / main, 9) + for k, q in got_q.items() + if q is not None and abs(float(q) / main - 1) > 1e-6 + } + if ratio: + one["계수"] = ratio + + +def _parts(price: dict[str, Any]) -> float | None: + vals = [float(price[c]) for c in COSTS if price.get(c) not in (None, "")] + return sum(vals) if vals else money(price) + + +def redo(one: dict[str, Any]) -> bool: + """줄 재현 — 단가 × 매개값(× 계수) ≈ 금액.""" + kind, q, got = one["묶음"], one.get("품"), one.get("금액") + if one.get("어떻게") == "별도" or (kind == "E" and q is None): + return True + if kind == "S" and q is None: + return got is not None + if kind == "R": + return bool(q is not None and near((one.get("기준값") or 0) * q, got)) + price = one.get("단가") or {} + if q is None or got is None: + return False + if kind == "X": + ratio = one.get("계수") or {} + want = sum(float(price[c]) * q * ratio.get(c, 1) for c in COSTS if price.get(c)) + return near(want, got) + unit = _parts(price) + return bool(unit is not None and (near(unit * q, got) or (unit == 0 and got == 0))) + + +def _subs(units: list[dict[str, Any]], totals: dict[tuple[str, int], float]) -> None: + """값 줄 첫 수가 다른 블록 · 호표 1 단위 금액이면 하위.""" + for one in units: + p = money(one.get("단가")) if one["묶음"] == "E" else None + if not p or p < 100: + continue + hit = next((k for k, v in totals.items() if abs(p - v) <= 0.51), None) + if hit: + got = one.get("금액") + q = round(float(got) / p, 6) if got is not None else None + one.update(묶음="S", 품=q, 하위={"종류": hit[0], "번": hit[1]}, 어떻게="QTY") + + +def _labor_part(one: dict[str, Any]) -> float: + """기계 줄 노무비 몫 = 노무 단가 × 시간(× 계수).""" + price, q = (one.get("단가") or {}).get("노무비"), one.get("품") + return float(price) * q * (one.get("계수") or {}).get("노무비", 1) if price and q else 0.0 + + +def base_rows(units: list[dict[str, Any]]) -> None: + """율 줄 기준값 = 어느 줄 합인가 → `기준꼴` · `기준줄 [행]`(못 찾으면 안 붙임) — 차례: + 바로 앞 같은 묶음 줄들(절 소계) › 앞 인력 › 앞 인력 + 기계 노무 › 앞 자재 › 앞 자재 + 율 › + 앞 줄 모두 › 블록 인력 › 블록 자재.""" + live = [u for u in units if not u.get("밖") and u.get("금액")] + for i, one in enumerate(units): + if one["묶음"] != "R" or not one.get("기준값"): + continue + prev = [u for u in units[:i] if u in live] + run: list[dict[str, Any]] = [] + for u in reversed(prev): + if u["묶음"] == "R" or (run and u["묶음"] != run[0]["묶음"]): + break + run.insert(0, u) + of = lambda us, k: [u for u in us if u["묶음"] in k] # noqa: E731 + pools = [ + ("절 소계", run, None), + ("인력", of(prev, "L"), None), + ("노무비", of(prev, "LX"), "L+X노무"), + ("자재", of(prev, "M"), None), + ("자재 + 율", of(prev, "MR"), None), + ("앞 줄 모두", of(prev, "LXM"), None), + ("인력(블록)", of(live, "L"), None), + ("자재(블록)", of(live, "M"), None), + ] + for name, pool, how in pools: + total = sum( + _labor_part(u) if how and u["묶음"] == "X" else float(u["금액"]) for u in pool + ) + if pool and near(total, one["기준값"]): + one["기준꼴"], one["기준줄"] = name, [u.get("행") for u in pool] + break + + +def check_block(block: dict[str, Any], totals: dict[tuple[str, int], float]) -> None: + units = block.get("항목") or [] + own = ("단산", int(block["번"])) + _subs(units, {k: v for k, v in totals.items() if k != own}) + base_rows(units) + for one in units: + if one["묶음"] == "X" and (hit := _SURCHARGE.search(f"{one['이름']} {one['규격']}")): + one["할증"] = round(float(hit.group(1)) / 100, 4) + one["재현"] = redo(one) + total = money(block.get("금액")) + lines = round(sum(float(one.get("금액") or 0) for one in units if not one.get("밖")), 4) + block["줄합"] = lines + block["덮음"] = near(lines, total) if total else None + + +def check_hopyo(hopyo: dict[str, Any]) -> None: + """일위대가 줄 → 단위 줄 투영(묶음 · 재현 · % 기준) · 호표 줄합 · 덮음.""" + run = dict.fromkeys(COSTS, 0.0) + main = lines = 0.0 + for line in hopyo.get("줄") or []: + kind = _KIND.get(str(line.get("갈래")), "E") + q, got = line.get("수량"), money(line.get("금액")) + line["묶음"] = kind + if line.get("갈래") == "별도계상": + line["재현"] = True + elif kind == "R": + spec = re.sub(r"\s+", "", str(line.get("규격") or "")) + base = ( + "주재료비" + if "주재료" in spec + else "재료비" + if "재료비" in spec + else "경비" + if spec.startswith("경비") + else "노무비" + ) + line["기준"] = base + value = main if base == "주재료비" else run[base] + line["재현"] = bool(q and got is not None and near(value * float(q) / 100, got)) + else: + p = money(line.get("단가")) + line["재현"] = bool(q is not None and p is not None and near(float(q) * p, got)) + if kind != "R": + for c in COSTS: + run[c] += float((line.get("금액") or {}).get(c) or 0) + if line.get("갈래") == "자재": + main += float((line.get("금액") or {}).get("재료비") or 0) + lines += got or 0 + total = money(hopyo.get("금액")) + hopyo["줄합"] = round(lines, 4) + hopyo["덮음"] = near(lines, total) if total else None + + +def settle(book: dict[str, Any]) -> dict[str, Any]: + """읽은 책(HP 꼴) → 블록 단위 줄 하위 가름 · 재현 · 덮음 + 일위대가 줄 투영(제자리).""" + totals: dict[tuple[str, int], float] = {} + for block in book.get("단산") or []: + if (v := money(block.get("금액"))) is not None: + totals[("단산", int(block["번"]))] = v + for hopyo in book.get("호표") or []: + if (v := money(hopyo.get("금액"))) is not None: + totals[("일위", int(hopyo["번"]))] = v + for block in book.get("단산") or []: + check_block(block, totals) + for hopyo in book.get("호표") or []: + check_hopyo(hopyo) + return book diff --git a/resources/tester/test_778_3_hopyo_unit_lines.py b/resources/tester/test_778_3_hopyo_unit_lines.py new file mode 100644 index 000000000..d91bc22fc --- /dev/null +++ b/resources/tester/test_778_3_hopyo_unit_lines.py @@ -0,0 +1,174 @@ +"""778-3(D-1) 단위 줄 — 단가산출 블록 · 일위대가 줄을 같은 계산 단위 꼴로(`M02_Hopyo_UnitLine`). + +꼴(EST 글 · STmate 행) · 같은 기계 코드 두 묶음 따로 · 비목마다 매개값 `계수` · 율 행 · 셈 밖 · +여덟 파일(불리는 블록) 줄 수 · 재현 · 덮음 · 할증 풀이 · 요구 624(이름 없는 율 줄 · 두 행 노무 · +손료율 표지). 읽기만 · 서버 없음. +""" + +from __future__ import annotations + +import warnings +from collections import Counter +from functools import lru_cache + +import pytest + +from M02_MasterTemplete import M02_Hopyo_Excel as hx +from M02_MasterTemplete import M02_Hopyo_ReadEst as est +from M02_MasterTemplete import M02_Hopyo_Sangeun as sg +from M02_MasterTemplete import M02_Hopyo_Stmate as st +from M02_MasterTemplete import M02_Hopyo_UnitLine as ul +from resources.tester.helper_m02_hopyo_golden import FILES + +warnings.filterwarnings("ignore", category=UserWarning, module="openpyxl") +KEYS = {"묶음", "이름", "규격", "품", "단가", "금액", "어떻게", "행", "절", "윗절"} + + +def test_EST_글_단위_줄(): + text = [ + " 1. 굴착기(무한궤도)(0.7㎥)", + " 노무비 : 59,020 ÷ 26.95 × 0.9 = 1,970.9", + " 재료비 : 19,473 ÷ 26.95 = 722.5", + " 2. 인 부", + " 보통인부 : 172,068 × 0.011인 = 1,892.7 (지주)", + " 합판(내수),대전 (12×1220=2440) 28,500. × 0.1 = 2,850.", + " 각재(외송) 500,000 × 0.038 ㎥ × 38. % = 7,220 ￦ / ㎡", + " 특별인부 : P", + " 3. 공구손료(인력품의 3%)", + " 1,892.7 × 0.03 = 56.7", + " 레미콘 : 별도계상", + " 4. 합 계", + " 보통인부 : 172,068 × 0.011인 = 1,892.7", + ] + got = est.items(text, list(range(1, len(text) + 1))) + book = {"단산": [{"번": 1, "금액": {"계": 14712.8}, "항목": got}], "호표": []} + ul.settle(book) + kinds = [(u["묶음"], bool(u.get("밖"))) for u in got] + assert kinds == [ + ("X", False), + ("L", False), + ("M", False), + ("M", False), + ("R", False), + ("M", False), + ("L", True), + ] # fmt: skip — 「특별인부 : P」 선언 줄 뺌 + assert all(KEYS <= set(u) for u in got) + mach, labor, mat, loss, rate = got[:5] + assert mach["품"] == pytest.approx(0.9 / 26.95) and mach["계수"] == { + "재료비": pytest.approx(1 / 0.9) + } + assert mach["금액"] == pytest.approx(2693.4) and mach["재현"] + assert labor["직종"] == "보통인부" and labor["금액"] == 1892.7 and labor["재현"] + assert mat["이름"].startswith("합판") and mat["품"] == 0.1 and mat["재현"] # 끝 점 · 이름 속 = + assert loss["손료율"] == 0.38 and loss["금액"] == 7220 and loss["재현"] # 손료율 = 자재 줄 표지 + assert rate["품"] == 0.03 and rate["기준값"] == 1892.7 and rate["기준"] == "인력품" + assert ( + rate["재현"] and rate["절"] == "공구손료(인력품의 3%)" and rate["이름"].startswith("공구") + ) + assert rate["기준꼴"] == "인력" and rate["기준줄"] == [5] + assert book["단산"][0]["줄합"] == pytest.approx(14712.8) and book["단산"][0]["덮음"] + + +def _row(**cells) -> list: + row = [None] * 24 + for col, v in cells.items(): + row[int(col[1:])] = v + return row + + +def test_STmate_같은_코드_두_묶음_따로_계수_율_밖(): + machine = "굴삭기(0.7m3) / 0.7㎥,(암석)" + rows = [ + _row(c0="제 1호표", c2=100, c6="`BDCOD|D00001"), + _row(c1=" (1) 채집"), + _row(c1=" ① 굴삭기", c2=10, c3=10, c7=0.1, c8=100, c9=100, c12="X00009_1", c23=machine), + _row(c1=" 재료비", c2=5, c4=5, c7=0.05, c8=100, c10=100, c12="X00009_1", c23=machine), + _row(c1=" (2) 상차"), + _row(c1=" 노무비", c2=20, c3=20, c7=0.2, c8=100, c9=100, c12="X00009_1", c23=machine), + _row( + c1=" 기구손료 : 30 * 2 %", + c2=0.6, + c4=0.6, + c6="&PA01M:M& * 2'%' =", + c7=2, + c8=30, + c12="PR_1", + ), + _row(c1=" 기구손료 : (가공노력품의 9%)"), + _row( + c1=" 30 * 0.09 = 2.7", + c2=2.7, + c4=2.7, + c6="&RA01:M& * 0.09 =", + c7=0.09, + c8=30, + c12="RR_1", + ), + _row( + c1=" 보통인부 : 1 * 0.5", + c2=50, + c3=50, + c7=0.5, + c8=100, + c9=100, + c12="L00002_1", + c13="C1_1", + c23="보통인부 / ", + ), # fmt: skip + _row(c0="총계"), + ] + blocks = st._blocks(rows, {}) + units = blocks["D00001"]["항목"] + xs = [u for u in units if u["묶음"] == "X"] + assert [x["품"] for x in xs] == [0.1, 0.2] # 두 묶음 따로(단가 두 배 아님) + assert xs[0]["단가"]["계"] == 200 and xs[1]["단가"]["계"] == 100 + assert xs[0]["계수"] == {"재료비": 0.5} and xs[0]["금액"] == 15 + rate, bare = [u for u in units if u["묶음"] == "R"] + assert rate["품"] == 0.02 and rate["기준"] == "PA01M" and rate["기준값"] == 30 + assert bare["이름"] == "기구손료" and bare["기준글"] == "가공노력품" and bare["품"] == 0.09 + assert next(u for u in units if u["묶음"] == "L").get("밖") is True + assert [r["코드"] for r in blocks["D00001"]["자원"]] == ["X00009", "X00009", "L00002"] + + +@lru_cache(maxsize=1) +def _books() -> dict: + return {tag: hx.read_book(p.name, p.read_bytes()) for tag, p in FILES.items()} + + +def test_여덟_파일_불리는_블록_줄_재현_덮음(): + kinds, outside, redo, cover = Counter(), Counter(), Counter(), Counter() + lines = Counter() + for book in _books().values(): + _, first = sg.calls(book) + called = {int(k) for k in first} + for block in book["단산"]: + if int(block["번"]) not in called: + continue + cover[block["덮음"]] += 1 + for u in block["항목"]: + if u.get("밖"): + outside[u["묶음"]] += 1 + continue + kinds[u["묶음"]] += 1 + redo[u["재현"]] += 1 + for hopyo in book["호표"]: + lines.update(bool(x["재현"]) for x in hopyo["줄"]) + assert dict(kinds) == {"L": 366, "X": 190, "M": 130, "R": 152, "S": 3, "E": 1} + assert dict(outside) == {"L": 2} + assert redo[True] >= 836 and sum(redo.values()) == 842 # 전 811/836 + assert cover[True] == 204 and sum(cover.values()) == 206 # 남은 둘 = 엑셀 자체 흠(합이 줄 뺌) + assert lines[True] == 1344 and sum(lines.values()) == 1350 + + +def test_할증_풀이_같은_코드_따로(): + books = _books() + block = next(b for b in books["울진소광"]["단산"] if b["번"] == 1448) + xs = [u for u in block["항목"] if u["묶음"] == "X"] + assert [x["할증"] for x in xs] == [1.2, 1.2, 1.25] and all(x["재현"] for x in xs) + block = next(b for b in books["울진대흥"]["단산"] if b["번"] == 1129) + dig = [u for u in block["항목"] if u.get("코드") == "X00009"] + assert len(dig) == 2 and all(u["단가"]["계"] == 100378 and u["재현"] for u in dig) + block = next(b for b in books["봉화"]["단산"] if b["번"] == 3) + dump = next(u for u in block["항목"] if u["이름"].startswith("덤프")) + assert dump["계수"]["재료비"] == pytest.approx(0.1527, abs=1e-4) and dump["재현"]