Merge remote-tracking branch 'origin/sub_laptop_1' into main_laptop_1
This commit is contained in:
@@ -6,7 +6,7 @@
|
||||
노임 = LB 이름 글자 묶음 닮음 · 단가 = LB 값
|
||||
기계 = EQ 갈래 겹침 · 규격 수(같음 1 · 겹침 0.5) · 이름 낱말 덤 · 괄호 낱말 어긋남 깎음 ·
|
||||
단가 없음(기계경비는 로직 셈) · `machine` = 하나로 가름(778-1)
|
||||
차례 = 점수(0.1 단위로 접음) › 엑셀 단가에 가까운 것(엑셀 단가 = 블록 글 「이름 단가 × 식 = 금액」 · 모르면 점수만).
|
||||
차례 = 점수(0.1 단위로 접음) › 엑셀 단가에 가까운 것(엑셀 단가 = 블록 단위 줄 단가 · 모르면 점수만).
|
||||
서버 단독 · 읽기만.
|
||||
"""
|
||||
|
||||
@@ -17,10 +17,10 @@ import re
|
||||
from typing import Any
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Hopyo_Finger as finger
|
||||
from M02_MasterTemplete import M02_Hopyo_Match as hm
|
||||
from M02_MasterTemplete import M02_Hopyo_Material as hmat
|
||||
from M02_MasterTemplete.M02_Hopyo_Words import mtypes, nfkc, parse_rhs, specnums
|
||||
from M02_MasterTemplete import M02_Hopyo_UnitLine as unit_line
|
||||
from M02_MasterTemplete.M02_Hopyo_Words import mtypes, nfkc, specnums
|
||||
|
||||
TOP = 3
|
||||
POOL = 5
|
||||
@@ -35,16 +35,12 @@ PARTS = ("자동덮개", "부착용", "콤팩터", "습지")
|
||||
|
||||
|
||||
def prices(block: dict[str, Any] | None) -> dict[str, float]:
|
||||
"""블록 글 → `{이름: 엑셀 단가}`(직종 줄 「직종 : 단가 × 식」 · 자재 줄 「이름 단가 × 식 = 금액」)."""
|
||||
"""블록 단위 줄(노무 · 자재 · 값) → `{이름: 엑셀 단가}`(첫 것 · 776-3 — 글 다시 안 풂)."""
|
||||
out: dict[str, float] = {}
|
||||
for raw in (block or {}).get("글") or []:
|
||||
row = str(raw).rstrip()
|
||||
cm = finger._COLON.match(row)
|
||||
mm = None if cm else finger._MAT.match(row)
|
||||
name = (cm or mm).group("name").strip() if (cm or mm) else ""
|
||||
got = parse_rhs((cm or mm).group("rhs")) if name else None
|
||||
if got and got.get("단가"):
|
||||
out.setdefault(re.sub(r"^[0-9가-힣]\.", "", name).strip(), float(got["단가"]))
|
||||
for one in (block or {}).get("항목") or []:
|
||||
price = unit_line.money(one.get("단가")) if one.get("묶음") in ("L", "M", "E") else None
|
||||
if price:
|
||||
out.setdefault(re.sub(r"^[0-9가-힣]\.", "", str(one.get("이름") or "")).strip(), price)
|
||||
return out
|
||||
|
||||
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -1,102 +1,45 @@
|
||||
"""M02 일위대가 실무자료 엑셀 지문(PLAN 338-1 · 설계 2-2) — 호표 줄 + 이어진 단가산출 블록 →
|
||||
직종 품 · 장비 시간 · 자재 수량 · 율 · 계수 · 조건 · 조항 · 몫. 금액 안 씀(식 맨 앞 단가는 뗌).
|
||||
"""M02 일위대가 실무자료 엑셀 지문(PLAN 338-1 · 설계 2-2 · 776-3) — 호표 줄 + 이어진 단가산출 블록 →
|
||||
직종 품 · 장비 시간 · 자재 수량 · 율 · 계수 · 조건 · 조항 · 몫. 금액 안 씀.
|
||||
|
||||
엑셀꼴 = 블록 `글`(머리 뺀 몸 줄)을 줄마다 풂 — 절 `^\\d+\\.` · 작은 절 `^[가-하]\\.` ·
|
||||
직종 줄 「직종 : 단가 × 식 = 금액」(우리 인력 이름 · 옛이름) · 장비 = 「노무비 · 경비 · 재료비 :
|
||||
단가 ÷ Q」
|
||||
+ 지금 장비(노무비 > 경비 > 재료비) · 자재 = 「이름 단가 × 수량 = 금액」 · 「: 별도계상」 ·
|
||||
못 풀면 금액 ÷ 단가(「역산」 · 품 되찾기만).
|
||||
STmate = 블록 `자원`(L · X · M · S) 품이 곧 품(노무비 · 재료비 · 경비 세 줄 같은 품은 한 번) ·
|
||||
섞음 = 이름 · 규격 몫 둘(작은 쪽 인력 · 큰 쪽 장비).
|
||||
몫(조합용 · 설계 2-7) = 맨 윗 절마다 노임 · 장비 벡터(`M02_Hopyo_Shares`).
|
||||
형식 모름 — 블록 단위 줄(`항목` · `M02_Hopyo_UnitLine`)의 투영:
|
||||
L 노무 = 직종 품 · 식이 있으면 맨 인자가 섞음 비율 후보(호표 이름 · 규격 · 절 제목의 (N%) ·
|
||||
8:2)와 같을 때 율로 가름 · 식 없는 줄(QTY)은 호표 이름 비율 둘 이상이면 작은 쪽(인력)
|
||||
X 기계 = 장비 {갈래, 규격, 시간, 밑시간, 율, 절, 글} · 식 없는 줄은 큰 비율(장비)로 가름
|
||||
M 자재 = 식(수량) · 별도계상(품 없음) · E 값 줄에 수량이 있으면 장비 글이면 장비 · 아니면 자재
|
||||
셈 밖 · 율 · 하위 줄 = 안 씀(율 % 는 글에서).
|
||||
글(블록 머리 「N.이름 [단위]」 + 몸 글) = 조건 · 옛 판 · 계수(q · K · f …) · 글 속 「…의 N %」.
|
||||
몫(조합용 · 설계 2-7) = 절마다 노임 · 장비 벡터(`M02_Hopyo_Shares.sections`).
|
||||
블록 없는 기계(hr) 줄 = `machine` · 노임 · 장비를 바로 적은 호표 = `direct`.
|
||||
값 · 규칙은 336 실험(C4 `s1_excel_fp` · K5 `stmate`) 그대로.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from collections import Counter
|
||||
from typing import Any
|
||||
|
||||
from M02_MasterTemplete import M02_Hopyo_Basis as hopyo_basis
|
||||
from M02_MasterTemplete import M02_Hopyo_ReadEst as hopyo_est
|
||||
from M02_MasterTemplete import M02_Hopyo_Shares as shares
|
||||
from M02_MasterTemplete.M02_Hopyo_Shares import trade
|
||||
from M02_MasterTemplete.M02_Hopyo_Words import conds, mtypes, parse_rhs, specnums
|
||||
from M02_MasterTemplete.M02_Hopyo_Words import conds, mtypes, specnums
|
||||
|
||||
COST = {"노무비", "재료비", "경비"}
|
||||
SKIPW = {
|
||||
"소계",
|
||||
"계",
|
||||
"합계",
|
||||
"인부소계",
|
||||
"자재소계",
|
||||
"주자재소계",
|
||||
"운반",
|
||||
"상차",
|
||||
"기계",
|
||||
"다짐",
|
||||
"적사",
|
||||
"살수",
|
||||
"집토",
|
||||
"암절취",
|
||||
"채집",
|
||||
"인력",
|
||||
"장비",
|
||||
"작업조건",
|
||||
"1일시공량",
|
||||
"작업면적",
|
||||
"1시간작업량",
|
||||
"기계채집",
|
||||
"구조물터파기",
|
||||
}
|
||||
_COLON = re.compile(
|
||||
r"^\s*(?:\d+\)|[0-9가-힣]\.)?\s*(?P<name>[^:：=]{1,40}?)\s*[:：]\s*(?P<rhs>.*)$"
|
||||
)
|
||||
_MAT = re.compile(
|
||||
r"^\s*(?P<name>[^\d\s:：=][^:：=]*?[A-Za-z가-힣)\]])\s+(?P<rhs>[\d,]+(?:\.\d+)?\s*[×xX*÷/].*=.*)$"
|
||||
)
|
||||
_PCT = re.compile(r"([가-힣]+)의\s*([\d.]+)\s*%")
|
||||
_COEF = re.compile(
|
||||
r"(?<![A-Za-z가-힣])(q|qs|q1|K|k|f|f1|f2|E|Es|Cm|L|V1|V2|T|rt|n|t1|t2|t3|t4)\s*=\s*"
|
||||
r"(\d+(?:\.\d+)?)(?![\d.]*\s*[×x*÷/])"
|
||||
)
|
||||
_HEAD = re.compile(r"^\s*(\d+)\.\s*(.*)$")
|
||||
_SUB = re.compile(r"^\s*([가-하])\.\s*(.*)$")
|
||||
_SECTION = re.compile(r"^\s*(\d+\.|[가-하]\.)")
|
||||
OLD = re.compile(
|
||||
r"((?<![\d,.])20(0\d|1\d|20)(?![\d,.])|(?<!\d)(1\d|20)년|임도품셈|임도표준품셈|사방품셈|사방사업표준품셈)"
|
||||
)
|
||||
_LASTNUM = re.compile(r"=\s*([\d,]+(?:\.\d+)?)\s*$")
|
||||
_HOURS = re.compile(r"(hr|시간)", re.I)
|
||||
TRADE_UNITS = ("인",)
|
||||
rates_in = hopyo_est.rates_in
|
||||
|
||||
|
||||
def _flat(s: Any) -> str:
|
||||
return re.sub(r"\s+", "", str(s or ""))
|
||||
|
||||
|
||||
def _ratio(rhs: str) -> float | None:
|
||||
"""식을 못 풀 때만 — 금액 ÷ 단가(품 되찾기용)."""
|
||||
m = re.match(r"^\s*([\d,]+(?:\.\d+)?)", rhs)
|
||||
n = _LASTNUM.search(rhs)
|
||||
if not m or not n:
|
||||
return None
|
||||
p, a = float(m.group(1).replace(",", "")), float(n.group(1).replace(",", ""))
|
||||
return a / p if p else None
|
||||
|
||||
|
||||
def rates_in(text: Any) -> set[float]:
|
||||
"""글 속 섞음 비율 후보 — (N%) · 8:2 · 9:1."""
|
||||
t = str(text or "")
|
||||
out = {round(float(n) / 100, 4) for n in re.findall(r"(\d+(?:\.\d+)?)\s*%", t)}
|
||||
out = {v for v in out if 0 < v < 1}
|
||||
for a, b in re.findall(r"(\d+)\s*:\s*(\d+)", t):
|
||||
a, b = float(a), float(b)
|
||||
if a and b and a + b <= 20:
|
||||
out |= {round(a / (a + b), 4), round(b / (a + b), 4)}
|
||||
return out
|
||||
|
||||
|
||||
def empty(line: dict[str, Any], block: dict[str, Any] | None = None) -> dict[str, Any]:
|
||||
block = block or {}
|
||||
basis = line.get("근거") or {}
|
||||
@@ -133,12 +76,10 @@ def _round(fp: dict[str, Any]) -> dict[str, Any]:
|
||||
|
||||
|
||||
def excel(block: dict[str, Any] | None, line: dict[str, Any]) -> dict[str, Any]:
|
||||
"""HP 블록(설계 3-1) + 그 줄(이름 · 규격 · 단위) → 지문 · 블록이 없거나 글 · 자원이 없으면
|
||||
"""HP 블록(설계 3-1) + 그 줄(이름 · 규격 · 단위) → 지문 · 블록이 없거나 단위 줄 · 글이 없으면
|
||||
기계(hr) 줄 지문(장비 1 시간) 또는 빈 지문."""
|
||||
if block and block.get("자원"):
|
||||
return _round(_stmate(block, line))
|
||||
if block and block.get("글"):
|
||||
return _round(_text(block, line))
|
||||
if block and (block.get("항목") or block.get("글")):
|
||||
return _round(_units(block, line))
|
||||
return machine(line)
|
||||
|
||||
|
||||
@@ -155,124 +96,59 @@ def machine(line: dict[str, Any]) -> dict[str, Any]:
|
||||
return fp
|
||||
|
||||
|
||||
def _text(block: dict[str, Any], line: dict[str, Any]) -> dict[str, Any]:
|
||||
"""엑셀꼴 — 블록 글 줄마다 풂(C4 `north`)."""
|
||||
fp = empty(line, block)
|
||||
def _text(fp: dict[str, Any], block: dict[str, Any]) -> None:
|
||||
"""블록 글 → 조건(머리 + 앞 넉 줄 + ※ · 작업조건 줄) · 옛 판 · 계수 · 「…의 N %」."""
|
||||
head = f"{block.get('번', '')}.{block.get('이름', '')} [{block.get('단위', '')}]"
|
||||
text = [head, *[str(t) for t in block.get("글") or []]]
|
||||
front = [t for t in text[:5]] + [t for t in text if "※" in t or "작업조건" in t]
|
||||
head_text = " ".join([fp["이름"], fp["규격"], *front])
|
||||
fp["조건"] = {k: sorted(v) for k, v in conds(head_text).items()}
|
||||
front = text[:5] + [t for t in text if "※" in t or "작업조건" in t]
|
||||
got = conds(" ".join([fp["이름"], fp["규격"], *front]))
|
||||
fp["조건"] = {k: sorted(v) for k, v in got.items()}
|
||||
fp["옛판"] = bool(OLD.search(" ".join(text[:6])))
|
||||
sec, sub, mach, label = 0, "", None, ""
|
||||
got_cost: dict[tuple, tuple] = {}
|
||||
item_rates = rates_in(f"{fp['이름']} {fp['규격']}")
|
||||
sec_rates: set[float] = set()
|
||||
|
||||
def unmix(got: dict | None) -> dict | None:
|
||||
"""율 메모가 없는데 맨 인자가 섞음 비율 후보와 같으면 율로 가름."""
|
||||
if got and not got["율"]:
|
||||
for v in got.get("인자") or []:
|
||||
if round(v, 4) in item_rates | sec_rates and 0 < v < 1:
|
||||
return {**got, "밑품": got["밑품"] / v, "율": [[round(v, 4), "섞음"]]}
|
||||
return got
|
||||
|
||||
for raw in text[1:]:
|
||||
row = raw.rstrip()
|
||||
h, s = _HEAD.match(row), _SUB.match(row)
|
||||
if h or s:
|
||||
if h:
|
||||
sec, sub = int(h.group(1)), ""
|
||||
sec_rates = rates_in(h.group(2))
|
||||
else:
|
||||
sub = s.group(1)
|
||||
sec_rates = sec_rates | rates_in(s.group(2))
|
||||
title = (h or s).group(2)
|
||||
ts = mtypes(title)
|
||||
mach = (ts, specnums(title)) if ts else None
|
||||
label = title.strip() if ts else ""
|
||||
for k, v in _PCT.findall(row):
|
||||
fp["율"].append([k, float(v)])
|
||||
cm = _COLON.match(row)
|
||||
name = re.sub(r"^[0-9가-힣]\.", "", _flat(cm.group("name"))) if cm else ""
|
||||
who = hopyo_basis.trade_names().get(name) if cm else None
|
||||
if who:
|
||||
rhs = cm.group("rhs")
|
||||
got = unmix(parse_rhs(rhs))
|
||||
if got:
|
||||
_labor(fp, who, got["품"], got["밑품"], got["율"], "식")
|
||||
elif r := _ratio(rhs):
|
||||
_labor(fp, who, r, r, [], "역산")
|
||||
continue
|
||||
if cm and name in COST:
|
||||
got = unmix(parse_rhs(cm.group("rhs")))
|
||||
if got and mach:
|
||||
key = (sec, sub, label)
|
||||
prio = 0 if (name == "노무비" and got["단가"] > 0) else 1 if name == "경비" else 2
|
||||
if key not in got_cost or prio < got_cost[key][0]:
|
||||
got_cost[key] = (prio, mach, got)
|
||||
continue
|
||||
if cm and name not in SKIPW and re.search(r"(별도|별산)", cm.group("rhs")):
|
||||
fp["자재"].append({"이름": cm.group("name").strip(), "품": None, "밑품": None})
|
||||
continue
|
||||
mm = _MAT.match(row)
|
||||
if mm and not cm and (got := parse_rhs(mm.group("rhs"))):
|
||||
fp["자재"].append(
|
||||
{"이름": mm.group("name").strip(), "품": got["품"], "밑품": got["밑품"]}
|
||||
)
|
||||
continue
|
||||
if not (h or s):
|
||||
ts = mtypes(row)
|
||||
if ts and "%" not in row and not cm:
|
||||
mach, label = (ts, specnums(row)), row.strip()
|
||||
for row in text[1:]:
|
||||
fp["율"] += [[k, float(v)] for k, v in _PCT.findall(row)]
|
||||
if not _SECTION.match(row):
|
||||
for k, v in _COEF.findall(row):
|
||||
fp["계수"].setdefault(k, float(v))
|
||||
for (sec_, sub_, lab), (_, (ts, sp), got) in got_cost.items():
|
||||
where = f"{sec_}.{sub_}" if sub_ else str(sec_)
|
||||
one = {"갈래": sorted(ts), "규격": sorted(sp), "시간": got["품"], "밑시간": got["밑품"]}
|
||||
fp["장비"].append({**one, "율": got["율"], "절": where, "글": lab})
|
||||
fp["몫"] = shares.sections(text[1:])
|
||||
return fp
|
||||
|
||||
|
||||
def _stmate(block: dict[str, Any], line: dict[str, Any]) -> dict[str, Any]:
|
||||
"""STmate — 자원 품이 곧 품(K5 `stmate`)."""
|
||||
def _unmix(one: dict[str, Any], rates: set[float]) -> tuple[float, list]:
|
||||
"""(밑품, 율) — 율 메모가 없는데 맨 인자가 섞음 비율 후보와 같으면 율로 가름."""
|
||||
if not one.get("율"):
|
||||
for v in one.get("인자") or []:
|
||||
if round(v, 4) in rates and 0 < v < 1:
|
||||
return one["밑품"] / v, [[round(v, 4), "섞음"]]
|
||||
return one["밑품"], one.get("율") or []
|
||||
|
||||
|
||||
def _units(block: dict[str, Any], line: dict[str, Any]) -> dict[str, Any]:
|
||||
fp = empty(line, block)
|
||||
text = [str(t) for t in block.get("글") or []][:60]
|
||||
fp["조건"] = {
|
||||
k: sorted(v) for k, v in conds(" ".join([fp["이름"], fp["규격"], *text[:4]])).items()
|
||||
}
|
||||
fp["옛판"] = bool(OLD.search(" ".join(text[:4])))
|
||||
for t in text:
|
||||
for k, v in _COEF.findall(t):
|
||||
fp["계수"].setdefault(k, float(v))
|
||||
for k, v in _PCT.findall(t):
|
||||
fp["율"].append([k, float(v)])
|
||||
rates = rates_in(f"{fp['이름']} {fp['규격']}")
|
||||
lab_rate = min(rates) if len(rates) >= 2 else None
|
||||
mach_rate = max(rates) if len(rates) >= 2 else None
|
||||
seen: Counter = Counter()
|
||||
for x in block.get("자원") or []:
|
||||
kind, q = x.get("갈래"), x.get("품")
|
||||
nm, sp = str(x.get("이름") or ""), str(x.get("규격") or "")
|
||||
if not q:
|
||||
_text(fp, block)
|
||||
item_rates = rates_in(f"{fp['이름']} {fp['규격']}")
|
||||
pair = sorted(item_rates) if len(item_rates) >= 2 else []
|
||||
lab_rate, mach_rate = (pair[0], pair[-1]) if pair else (None, None)
|
||||
for one in block.get("항목") or []:
|
||||
kind, q, how = one.get("묶음"), one.get("품"), one.get("어떻게")
|
||||
if one.get("밖") or (q is None and how != "별도"):
|
||||
continue
|
||||
seen[(x.get("코드"), round(float(q), 9))] += 1
|
||||
if seen[(x.get("코드"), round(float(q), 9))] > 1: # 노무비 · 재료비 · 경비 세 줄 같은 품
|
||||
continue
|
||||
q = float(q)
|
||||
ts = mtypes(f"{nm} {sp}")
|
||||
if kind == "L":
|
||||
if who := trade(nm):
|
||||
base = q / lab_rate if lab_rate else q
|
||||
_labor(fp, who, q, base, [[lab_rate, "섞음"]] if lab_rate else [], "QTY")
|
||||
elif kind == "X" or (kind == "S" and ts):
|
||||
one = {"갈래": sorted(ts), "규격": sorted(specnums(sp) | specnums(nm)), "시간": q}
|
||||
base = q / mach_rate if mach_rate else q
|
||||
fp["장비"].append({**one, "밑시간": base, "율": [], "절": "0", "글": f"{nm} {sp}"})
|
||||
elif kind in ("M", "S"):
|
||||
fp["자재"].append({"이름": f"{nm} {sp}".strip(), "품": q, "밑품": q})
|
||||
fp["몫"] = shares.sections_stm(block.get("자원") or [], text)
|
||||
text = f"{one.get('이름') or ''} {one.get('규격') or ''}".strip()
|
||||
rates = item_rates | set(one.get("절율") or [])
|
||||
if kind == "L" and (who := one.get("직종") or trade(one.get("이름"))):
|
||||
if how == "QTY":
|
||||
base, r = (q / lab_rate, [[lab_rate, "섞음"]]) if lab_rate else (q, [])
|
||||
else:
|
||||
base, r = _unmix(one, rates) if how == "식" else (one["밑품"], one["율"])
|
||||
_labor(fp, who, q, base, r, how)
|
||||
elif kind == "X" or (kind == "E" and mtypes(text)):
|
||||
if how == "QTY":
|
||||
base, r = (q / mach_rate if mach_rate else q), []
|
||||
else:
|
||||
base, r = _unmix(one, rates)
|
||||
sizes = specnums(one.get("규격") or "") | specnums(one.get("이름") or "")
|
||||
got = {"갈래": sorted(mtypes(text)), "규격": sorted(sizes), "시간": q}
|
||||
fp["장비"].append({**got, "밑시간": base, "율": r, "절": one.get("절"), "글": text})
|
||||
elif kind in ("M", "E") and (how in ("식", "별도", "QTY")):
|
||||
fp["자재"].append({"이름": text, "품": q, "밑품": one.get("밑품", q)})
|
||||
fp["몫"] = shares.sections(block.get("항목") or [])
|
||||
return fp
|
||||
|
||||
|
||||
@@ -282,7 +158,7 @@ def direct(hopyo: dict[str, Any]) -> dict[str, Any] | None:
|
||||
fp = empty({k: hopyo.get(k) for k in ("이름", "규격", "단위")})
|
||||
texts = [str(t) for t in hopyo.get("근거글") or []]
|
||||
texts += [f"{x.get('이름')} {x.get('규격')}" for x in lines if x.get("갈래") == "근거글"]
|
||||
fp["출처"] = hopyo_basis.sources(" ".join(texts))
|
||||
fp["출처"] = hopyo_est.sources(" ".join(texts))
|
||||
hit = False
|
||||
for x in lines:
|
||||
q = x.get("수량")
|
||||
|
||||
@@ -20,6 +20,7 @@ import hashlib
|
||||
import json
|
||||
import queue
|
||||
import threading
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
@@ -295,9 +296,21 @@ def _hp_path(folder: Path, key: str) -> Path:
|
||||
return hopyo_store._path(folder, key)
|
||||
|
||||
|
||||
@lru_cache(maxsize=64)
|
||||
def _hp_mark(path: str, stamp: tuple[int, int]) -> str:
|
||||
"""HP 지문 칸(올린 엑셀 sha256 + 읽기 판 · 776-3) — 없으면(붙여넣기) 파일 해시 · 파일이 그대로면
|
||||
(`stamp` = 바뀐 때 · 크기) 다시 안 읽음."""
|
||||
raw = Path(path).read_bytes()
|
||||
doc = json.loads(raw)
|
||||
mark = doc.get("지문") if isinstance(doc, dict) else None
|
||||
return f"{mark[:16]}{doc.get('판')}" if mark else hashlib.sha256(raw).hexdigest()[:16]
|
||||
|
||||
|
||||
def cache_path(folder: Path, key: str) -> Path:
|
||||
hp = hashlib.sha256(_hp_path(folder, key).read_bytes()).hexdigest()[:16]
|
||||
return ours.folder() / f"맞춤_{hp}_{ours.version()}_{CALC_VERSION}.json"
|
||||
hp = _hp_path(folder, key)
|
||||
got = hp.stat()
|
||||
mark = _hp_mark(str(hp), (got.st_mtime_ns, got.st_size))
|
||||
return ours.folder() / f"맞춤_{mark}_{ours.version()}_{CALC_VERSION}.json"
|
||||
|
||||
|
||||
def units(doc: dict[str, Any]) -> list[tuple[str, dict | None, dict]]:
|
||||
|
||||
@@ -343,7 +343,6 @@ def name_cands(line: dict[str, Any], got: dict[str, Any] | None = None) -> list[
|
||||
|
||||
# ── 인용 조항 · 이름 · 근거 차례(338 · 설계 2-4 B 차례) ─────────────────────
|
||||
_OLD_TEXT = re.compile(r"(20(1\d|2[0-4])|1\d년|2[0-4]년|임도품셈|임도표준품셈|사방품셈)")
|
||||
_TYPO_CLAUSE = re.compile(r"^(\d+)-(\d)(\d)(\d)$") # 13-114 → 13-11-4
|
||||
_GENERIC = frozenset(
|
||||
"인력 기계 장비 소계 합계 노무비 재료비 경비 적용 기준 별도계상 별도 인부 보통인부 특별인부 "
|
||||
"설치 해체 운반 작업 시공 사용 포함 공구손료 경장비 손료 기계경비 재료 인건비 품셈 표준품셈 "
|
||||
@@ -352,32 +351,14 @@ _GENERIC = frozenset(
|
||||
|
||||
|
||||
def fix_typo(theirs: list) -> list[list[str]]:
|
||||
"""엑셀 인용 조항 오타 — 「13-114」 → 「13-11-4」."""
|
||||
out = []
|
||||
for book, n in theirs or []:
|
||||
m = _TYPO_CLAUSE.match(str(n))
|
||||
out.append([book, f"{m.group(1)}-{m.group(2)}{m.group(3)}-{m.group(4)}" if m else n])
|
||||
return out
|
||||
"""엑셀 인용 조항 사본 — 오타(「13-114」 → 13-11-4)는 읽기(`ReadEst.sources`)가 이미 고침."""
|
||||
return [list(x) for x in theirs or []]
|
||||
|
||||
|
||||
def clause(theirs: list, our: dict[str, Any]) -> tuple[float, list[str], str]:
|
||||
"""(점수, 맞은 우리 조항 글, 꼬리표) — 같음 1 · 윗마디 0.9(엑셀 6-2 ↔ 우리 6-2-2) · 앞 마디 0.5
|
||||
·
|
||||
나 창 `Basis.clause` 가 있으면 그것."""
|
||||
if hasattr(hopyo_basis, "clause"):
|
||||
return hopyo_basis.clause(theirs, our)
|
||||
nums = [n for book, n in theirs if book == our["책"]]
|
||||
same = sorted(n for n in nums if n in our["조항"])
|
||||
if same:
|
||||
return 1.0, [f"{our['구분']} {n}" for n in same], "조항 같음"
|
||||
kids = sorted(c for c in our["조항"] for n in nums if c.startswith(n + "-"))
|
||||
if kids:
|
||||
return 0.9, [f"{our['구분']} {n}" for n in kids], "조항 같음"
|
||||
heads = {n.rsplit("-", 1)[0] for n in nums}
|
||||
near_ = sorted(n for n in our["조항"] if n.rsplit("-", 1)[0] in heads)
|
||||
if near_:
|
||||
return 0.5, [f"{our['구분']} {n}" for n in near_], "앞 마디 같음"
|
||||
return 0.0, [], ""
|
||||
"""(점수, 맞은 우리 조항 글, 꼬리표) — `M02_Hopyo_Basis.clause`(같음 1 · 윗마디 0.9 ·
|
||||
앞 마디 0.5)."""
|
||||
return hopyo_basis.clause(theirs, our)
|
||||
|
||||
|
||||
def _strong_basis(line: dict[str, Any], cand: dict[str, Any]) -> bool:
|
||||
@@ -393,9 +374,6 @@ def b_order(line: dict[str, Any], got: dict[str, Any] | None = None, text: Any =
|
||||
근거: {로직: 근거}}` — 이름 후보 + 근거 후보 합침(접힘 없음) · 「같음」도 근거 검사(인용 조항이
|
||||
다른 로직을 가리키면 후보) · 옛 판 글이면 같음 그대로 · 씨앗은 이름 같음 자리."""
|
||||
got = got or targets()
|
||||
basis_ = dict(line.get("근거") or {})
|
||||
if basis_.get("출처"):
|
||||
line = {**line, "근거": {**basis_, "출처": fix_typo(basis_["출처"])}}
|
||||
basis = hopyo_basis.candidates(line, got)
|
||||
named = candidates(line, "로직", got, None)
|
||||
merged_c = [c for c in hopyo_basis.merge(basis, named) if c.get("로직")]
|
||||
|
||||
@@ -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<name>[^\d\s:：].*?[A-Za-z가-힣)\]])\s+(?P<rhs>" + 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
|
||||
|
||||
@@ -1,45 +1,18 @@
|
||||
"""M02 일위대가 맞춤 몫(PLAN 338-1 · 설계 2-2 · 2-7) — 단가산출 블록을 맨 윗 절(1. 2. 3.)
|
||||
· 작은 절(가. 나.)로 갈라 몫마다 노임(직종 → 인) · 장비(「굴착기|0.6」 → 시간) 벡터.
|
||||
|
||||
엑셀꼴 = 「직종 : 노임 × 식 = 금액」(식을 못 풀면 금액 ÷ 노임) · 장비 이름 줄 뒤 「노무비 : 단가 ÷ Q
|
||||
× 몫」 ·
|
||||
소계 · 합계 절 뺌. STmate = 자원 L · X(절 = 자원 `절` · 없으면 한 몫). 금액 안 씀.
|
||||
규칙은 336 실험(C5 `c01_trees.sections` · `sections_stm`) 그대로 · 장비 갈래는
|
||||
`M02_Hopyo_Words.mtypes`.
|
||||
"""M02 일위대가 맞춤 몫(PLAN 338-1 · 설계 2-2 · 2-7 · 776-3) — 단가산출 블록 단위 줄을 절(맨 윗 절 ·
|
||||
작은 절)마다 묶어 노임(직종 → 인) · 장비(「굴착기|0.6」 → 시간) 벡터. 형식 모름(단위 줄만 ·
|
||||
`M02_Hopyo_UnitLine`) · 셈 밖 줄 뺌 · 금액 안 씀 · 장비 갈래 = `M02_Hopyo_Words.mtypes`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import ast
|
||||
import operator
|
||||
import re
|
||||
from typing import Any
|
||||
|
||||
from M02_MasterTemplete import M02_Hopyo_Basis as hopyo_basis
|
||||
from M02_MasterTemplete.M02_Hopyo_ReadEst import trade # 노임 이름 → 우리 인력(B09 도 씀)
|
||||
from M02_MasterTemplete.M02_Hopyo_Words import mtypes, nfkc
|
||||
|
||||
__all__ = ["eq_key", "sections", "trade"]
|
||||
_SIZE = re.compile(r"(\d+(?:\.\d+)?)\s*(㎥|m3|톤|ton|t\b|kw|hp)", re.I)
|
||||
_OPS = {
|
||||
ast.Mult: operator.mul,
|
||||
ast.Div: operator.truediv,
|
||||
ast.Add: operator.add,
|
||||
ast.Sub: operator.sub,
|
||||
}
|
||||
_TRADE = re.compile(
|
||||
r"^[\s*·\-○◇]*([가-힣][가-힣\s]*?)\s*:\s*([\d,]+(?:\.\d+)?)\s*(.*?)(?:=\s*([\d,]+(?:\.\d+)?))?\s*$"
|
||||
)
|
||||
_SECTION = re.compile(r"^\s*(\d+)\s*\.\s*(.*)$")
|
||||
_EQ_COST = re.compile(r"^\s*노\s*무\s*비\s*:\s*([\d,]+(?:\.\d+)?)\s*(.*?)(?:=\s*[\d,.]+)?\s*$")
|
||||
_SKIP_SEC = re.compile(r"^(합\s*계|소\s*계|계)")
|
||||
_SUBLABEL = re.compile(r"^\s*[가-하]\s*\.\s*(.*)$")
|
||||
_COSTLINE = re.compile(r"^\s*(노\s*무\s*비|재\s*료\s*비|경\s*비)\s*:")
|
||||
|
||||
|
||||
def trade(name: Any) -> str | None:
|
||||
"""노임 이름 → 우리 인력 이름(빈칸 · 옛이름 · 괄호 글 풀이) · 아니면 None."""
|
||||
names = hopyo_basis.trade_names()
|
||||
flat = re.sub(r"\s+", "", str(name or ""))
|
||||
return names.get(flat) or names.get(re.sub(r"\(.*?\)", "", flat))
|
||||
|
||||
|
||||
def eq_key(text: Any) -> str | None:
|
||||
@@ -54,124 +27,23 @@ def eq_key(text: Any) -> str | None:
|
||||
return f"{'+'.join(sorted(kinds))}|{size}"
|
||||
|
||||
|
||||
def _eval(node: ast.AST) -> float:
|
||||
if isinstance(node, ast.Expression):
|
||||
return _eval(node.body)
|
||||
if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
|
||||
return float(node.value)
|
||||
if isinstance(node, ast.BinOp) and type(node.op) in _OPS:
|
||||
return _OPS[type(node.op)](_eval(node.left), _eval(node.right))
|
||||
if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
|
||||
return -_eval(node.operand)
|
||||
raise ValueError("식 아님")
|
||||
|
||||
|
||||
def qty_of(expr: str) -> float | None:
|
||||
"""「273,540 × 3인 ÷ 55㎥ × 2」 → 3/55×2 · 「59,020 ÷ 23.1 × 90%」 → 1/23.1×0.9."""
|
||||
s = re.sub(r"\([^()0-9]*\)", "", str(expr)).replace(",", "")
|
||||
s = re.sub(r"(\d+(?:\.\d+)?)\s*%", r"(\1/100)", s)
|
||||
s = s.replace("×", "*").replace("÷", "/").replace("X", "*").replace("x", "*")
|
||||
s = re.sub(r"/\s*(?=[^\d(\s.])", " ", s) # 「인/㎥」 의 / 는 단위
|
||||
s = re.sub(r"[^\d.+\-*/() ]", " ", s)
|
||||
s = re.sub(r"(?<=\d)\.(?!\d)", "", s) # 「4.」 → 4
|
||||
s = re.sub(r"\(\s*\)", " ", s).strip()
|
||||
m = re.match(r"\s*\d+(?:\.\d+)?", s)
|
||||
if not m:
|
||||
return None
|
||||
s = "1" + s[m.end() :]
|
||||
s = re.sub(r"(?<=[\d)])\s+(?=[\d(])", "*", s) # 빈칸으로 붙은 수는 곱
|
||||
try:
|
||||
v = _eval(ast.parse(s, mode="eval"))
|
||||
except (SyntaxError, ValueError, ZeroDivisionError):
|
||||
return None
|
||||
return v if 0 < v < 1e4 else None
|
||||
|
||||
|
||||
def _part(title: str, parent: str) -> dict[str, Any]:
|
||||
return {"제목": title, "절": parent, "노임": {}, "장비": {}}
|
||||
|
||||
|
||||
def sections(texts: list[str]) -> list[dict[str, Any]]:
|
||||
"""블록 몸 글 → 몫마다 {제목, 절, 노임, 장비} — 노임 · 장비가 하나도 없는 몫은 뺌."""
|
||||
out: list[dict[str, Any]] = []
|
||||
cur: dict[str, Any] | None = None
|
||||
eq, parent = None, ""
|
||||
for raw in texts:
|
||||
line = str(raw).rstrip()
|
||||
sec = _SECTION.match(line)
|
||||
if sec and not re.match(r"^\s*\d+\.\d", line):
|
||||
title = sec.group(2).strip()
|
||||
if _SKIP_SEC.match(title.replace(" ", "")):
|
||||
cur = None
|
||||
continue
|
||||
parent = title
|
||||
cur = _part(title, title)
|
||||
out.append(cur)
|
||||
eq = eq_key(title)
|
||||
def sections(units: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||||
"""블록 단위 줄(`M02_Hopyo_UnitLine`) → 몫마다 {제목 = 줄 절, 절 = 윗절, 노임, 장비} — 셈 밖 ·
|
||||
매개값 없는 줄 뺌 · 장비 = 시간 50 아래 · 노임 · 장비가 하나도 없는 몫은 뺌."""
|
||||
out: dict[str, dict[str, Any]] = {}
|
||||
for one in units:
|
||||
q, kind = one.get("품"), one.get("묶음")
|
||||
if one.get("밖") or not q or kind not in ("L", "X"):
|
||||
continue
|
||||
sub = _SUBLABEL.match(line) if cur is not None else None
|
||||
if sub and not _SKIP_SEC.match(sub.group(1).replace(" ", "")):
|
||||
cur = _part(f"{parent} · {sub.group(1).strip()}", parent)
|
||||
out.append(cur)
|
||||
if cur is None:
|
||||
if out or not line.strip():
|
||||
continue
|
||||
cur = _part("", "")
|
||||
out.append(cur)
|
||||
if re.search(r"(소계|합계|인부소계)", line.replace(" ", "")):
|
||||
eq = None
|
||||
continue
|
||||
sub = _SUBLABEL.match(line)
|
||||
if sub:
|
||||
eq = eq_key(sub.group(1))
|
||||
elif not _COSTLINE.match(line) and (k := eq_key(line)):
|
||||
eq = k
|
||||
m = _EQ_COST.match(line)
|
||||
if m and eq:
|
||||
q = qty_of(f"{m.group(1)} {m.group(2)}")
|
||||
if q and q < 50:
|
||||
cur["장비"][eq] = cur["장비"].get(eq, 0) + q
|
||||
continue
|
||||
t = _TRADE.match(line)
|
||||
if t and (who := trade(t.group(1))):
|
||||
q = qty_of(f"{t.group(2)} {t.group(3)}")
|
||||
if q is None and t.group(4): # 식을 못 풀면 금액 ÷ 노임(품 되찾기만)
|
||||
q = float(t.group(4).replace(",", "")) / float(t.group(2).replace(",", ""))
|
||||
if q:
|
||||
cur["노임"][who] = cur["노임"].get(who, 0) + q
|
||||
return [s for s in out if s["노임"] or s["장비"]]
|
||||
|
||||
|
||||
def sections_stm(res: list[dict[str, Any]], texts: list[str]) -> list[dict[str, Any]]:
|
||||
"""STmate 자원(L · X) → 몫(자원 `절` = 글 줄 차례면 그 앞 맨 윗 절 · 글이면 그 제목 · 없으면 한
|
||||
몫)."""
|
||||
marks = []
|
||||
for at, t in enumerate(texts):
|
||||
sec = _SECTION.match(t)
|
||||
if sec and not re.match(r"^\s*\d+\.\d", t):
|
||||
if not _SKIP_SEC.match(sec.group(2).replace(" ", "")):
|
||||
marks.append((at, sec.group(2).strip()))
|
||||
|
||||
def which(where: Any) -> str:
|
||||
if isinstance(where, str):
|
||||
return where
|
||||
if isinstance(where, int) and not isinstance(where, bool):
|
||||
got = [m for m in marks if m[0] <= where]
|
||||
return got[-1][1] if got else ""
|
||||
return ""
|
||||
|
||||
secs: dict[str, dict[str, Any]] = {}
|
||||
seen = set()
|
||||
for x in res:
|
||||
q, kind = x.get("품"), x.get("갈래")
|
||||
if not q or kind not in ("L", "X") or (x.get("코드"), q, x.get("절")) in seen:
|
||||
continue
|
||||
seen.add((x.get("코드"), q, x.get("절")))
|
||||
title = which(x.get("절"))
|
||||
s = secs.setdefault(title, _part(title, title))
|
||||
if kind == "L" and (who := trade(x.get("이름"))):
|
||||
s["노임"][who] = s["노임"].get(who, 0) + float(q)
|
||||
elif kind == "X":
|
||||
k = eq_key(f"{x.get('이름') or ''} {x.get('규격') or ''}") or f"?{x.get('코드')}"
|
||||
s["장비"][k] = s["장비"].get(k, 0) + float(q)
|
||||
return [s for s in secs.values() if s["노임"] or s["장비"]]
|
||||
title = str(one.get("절") or "")
|
||||
part = out.setdefault(title, _part(title, str(one.get("윗절") or title)))
|
||||
if kind == "L" and (who := one.get("직종") or trade(one.get("이름"))):
|
||||
part["노임"][who] = part["노임"].get(who, 0) + float(q)
|
||||
elif kind == "X" and q < 50:
|
||||
k = eq_key(f"{one.get('이름') or ''} {one.get('규격') or ''}") or f"?{one.get('코드')}"
|
||||
part["장비"][k] = part["장비"].get(k, 0) + float(q)
|
||||
return [p for p in out.values() if p["노임"] or p["장비"]]
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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
|
||||
@@ -26,56 +26,56 @@
|
||||
}
|
||||
},
|
||||
"S2": {
|
||||
"단산:46|레미콘타설(장비사용)|철근구조물-소량타설|m3": "14b94bd44235",
|
||||
"단산:46|레미콘타설(장비사용)|철근구조물-소량타설|m3": "fe6524b2bf88",
|
||||
"단산:24|합판거푸집|4회|m2": "dc9227913b7d",
|
||||
"단산:33|기초잡석채집,운반,다짐|발파암활용,덤프15톤,l=500m|m3": "569f93218071",
|
||||
"단산:33|기초잡석채집,운반,다짐|발파암활용,덤프15톤,l=500m|m3": "53d20022ff32",
|
||||
"단산:47|철근가공조립(현장)|type-i(소량시공)|톤": "f333a56a3d0e",
|
||||
"단산:6|야면석채집및운반(계곡내)|굴삭기0.6m3,35cm,4.5톤,l=500m|m2": "06a8c10d89e7",
|
||||
"단산:3|고임돌채집및운반|굴삭기0.6m3(90%),4.5톤,l=500m|m3": "4c1b4b4cb599",
|
||||
"단산:10|야면석소운반|l=35cm|m2": "e96d400b173b",
|
||||
"단산:39|야면석찰붙임|l3=35cm적용,장비사용|m2": "e781e3163b81",
|
||||
"단산:6|야면석채집및운반(계곡내)|굴삭기0.6m3,35cm,4.5톤,l=500m|m2": "c0521e16ff75",
|
||||
"단산:3|고임돌채집및운반|굴삭기0.6m3(90%),4.5톤,l=500m|m3": "2521254f68a8",
|
||||
"단산:10|야면석소운반|l=35cm|m2": "50eb93121621",
|
||||
"단산:39|야면석찰붙임|l3=35cm적용,장비사용|m2": "cf4739ae6e8c",
|
||||
"단산:93|구조물터파기(인력100%)|토사|m3": "c523b43c617b",
|
||||
"단산:12|구조물되메우기(인력100%)||m3": "559c125ef42e",
|
||||
"단산:13|잔토처리(인력100%)||m3": "eb0395c76e02",
|
||||
"단산:22|레미콘타설(장비사용)|무근구조물|m3": "0c3cebbe76de",
|
||||
"단산:22|레미콘타설(장비사용)|무근구조물|m3": "12555a58e991",
|
||||
"단산:26|유로폼|보통,0~7m|m2": "a301adcd84cd",
|
||||
"단산:18|문양거푸집||m2": "9f4efb5510bf",
|
||||
"단산:37|p.v.c파이프설치|ø50mm|m": "a408f8e02b28",
|
||||
"단산:38|다웰바설치|ø32x1000|개": "13410747be6e",
|
||||
"단산:41|휠라설치|t=15mm,1000x1500mm|m2": "4df1b309aca4",
|
||||
"단산:41|휠라설치|t=15mm,1000x1500mm|m2": "23bf202fc7a4",
|
||||
"단산:29|철근가공조립(현장)|연결철근,type-ix30%적용|톤": "2b96b0b322d2",
|
||||
"단산:30|큰돌채집운반|공사중발생석활용50%적용|m2": "a0d7114b5599",
|
||||
"단산:32|큰돌쌓기(메쌓기)|직경40cm이상~60cm미만|m2": "06881edcaad6",
|
||||
"단산:2|뒷채움돌채집운반뒷채움(발파)|굴삭기0.6m3(90%),4.5톤,l=500m|m3": "8d60db527bae",
|
||||
"단산:31|큰돌쌓기(찰쌓기)_배수공|직경40cm이상~60cm미만|m2": "c0610580cae7",
|
||||
"단산:30|큰돌채집운반|공사중발생석활용50%적용|m2": "66cb28bdab1c",
|
||||
"단산:32|큰돌쌓기(메쌓기)|직경40cm이상~60cm미만|m2": "0d884c7f218d",
|
||||
"단산:2|뒷채움돌채집운반뒷채움(발파)|굴삭기0.6m3(90%),4.5톤,l=500m|m3": "ec132e6186ae",
|
||||
"단산:31|큰돌쌓기(찰쌓기)_배수공|직경40cm이상~60cm미만|m2": "b4e9d2ee8233",
|
||||
"단산:21|레미콘타설(인력운반)|무근구조물-소량타설|m3": "7ee6fe1e8d9d",
|
||||
"단산:25|합판거푸집|6회|m2": "b5b6ec2a0beb",
|
||||
"단산:42|도로반사경설치|d=1000(sts)|개소": "e521922cb4ba",
|
||||
"단산:88|야면석메붙임|l3=35cm내외,장비사용|m2": "91ac9e8d76f7",
|
||||
"단산:92|큰돌메붙임|직경40cm이상~60cm미만|m2": "26e6c1b118c5",
|
||||
"단산:91|큰돌찰붙임|직경40cm이상~60cm미만|m2": "bd288a8d830f",
|
||||
"단산:57|레미콘타설(장비사용)|소형구조물|m3": "b4bee2367968",
|
||||
"단산:71|야면석찰쌓기|l3=35cm적용,장비사용|m2": "1649ce3151fb",
|
||||
"단산:43|면고르기||m2": "f45d3e3af178",
|
||||
"단산:42|도로반사경설치|d=1000(sts)|개소": "3c2ee04632d3",
|
||||
"단산:88|야면석메붙임|l3=35cm내외,장비사용|m2": "fbc297bd41b0",
|
||||
"단산:92|큰돌메붙임|직경40cm이상~60cm미만|m2": "d1fad346524d",
|
||||
"단산:91|큰돌찰붙임|직경40cm이상~60cm미만|m2": "269c2c76c667",
|
||||
"단산:57|레미콘타설(장비사용)|소형구조물|m3": "9038aaf1131e",
|
||||
"단산:71|야면석찰쌓기|l3=35cm적용,장비사용|m2": "e74767626ed4",
|
||||
"단산:43|면고르기||m2": "ec9f5d99380f",
|
||||
"줄:대형브레이카|+굴착기(0.7m3)|시간": "fc11668f29eb",
|
||||
"단산:60|와이어메시바닥깔기|#6100x100|m2": "567c16874a89",
|
||||
"단산:62|원형돌망태설치및돌채움|#8,45x45cm|m2": "9ad93f86f385",
|
||||
"단산:61|조약돌채집및운반|굴삭기0.6m3(90%),4.5톤,l=500m|m3": "ab7d8e14de22",
|
||||
"단산:63|돌망태형옹벽설치|사각돌망태|m2": "6487dbf12ab6",
|
||||
"단산:65|콘크리트포장(인력)|t=20cm,종단15%미만|m3": "2c48d8cc2468",
|
||||
"단산:61|조약돌채집및운반|굴삭기0.6m3(90%),4.5톤,l=500m|m3": "b07780f6fab7",
|
||||
"단산:63|돌망태형옹벽설치|사각돌망태|m2": "61535c440543",
|
||||
"단산:65|콘크리트포장(인력)|t=20cm,종단15%미만|m3": "14fb1320b388",
|
||||
"단산:64|비탈면보호공|평떼|m2": "5d9d68fa8679",
|
||||
"단산:66|콘크리트포장(인력)|t=20cm,종단15%이상|m3": "2374789b6ae0",
|
||||
"단산:70|고화매트설치||m2": "80be3cc78047",
|
||||
"단산:90|큰돌쌓기(찰쌓기)|직경40cm이상~60cm미만|m2": "52a0f47bb751",
|
||||
"단산:23|레미콘타설(장비사용)|철근구조물|m3": "fe0d22d627da",
|
||||
"단산:66|콘크리트포장(인력)|t=20cm,종단15%이상|m3": "4739d20909b5",
|
||||
"단산:70|고화매트설치||m2": "61d7220158c9",
|
||||
"단산:90|큰돌쌓기(찰쌓기)|직경40cm이상~60cm미만|m2": "8efce35c90b3",
|
||||
"단산:23|레미콘타설(장비사용)|철근구조물|m3": "4814d3d0bb6f",
|
||||
"단산:73|강관동바리|암거용-1개월사용|공/m3": "bc3f5092d701",
|
||||
"단산:72|철근가공조립(현장)|type-ll|톤": "75dda2f569a2",
|
||||
"단산:74|강관비계|10m이하,3개월사용|m2": "90ce7f0da95c",
|
||||
"단산:49|흙깍기(토사)|굴삭기1.0m3,보통토사|m3": "f9aea56b06bf",
|
||||
"단산:56|잔토정리|굴삭기0.6m3|m3": "9f76f0e32710",
|
||||
"단산:49|흙깍기(토사)|굴삭기1.0m3,보통토사|m3": "a893fe169785",
|
||||
"단산:56|잔토정리|굴삭기0.6m3|m3": "63177d8c31eb",
|
||||
"단산:82|잡철물제작설치|규격철물설치(일반철재)|톤": "531650fd115f",
|
||||
"단산:95|도장(철재면2회)|방청1,유성2|m2": "92867210fce0",
|
||||
"단산:81|임도안전표지판설치|삼각,900mm|개소": "ee09c0727967"
|
||||
"단산:81|임도안전표지판설치|삼각,900mm|개소": "b28761e99520"
|
||||
}
|
||||
},
|
||||
"북부청사방": {
|
||||
@@ -106,8 +106,8 @@
|
||||
}
|
||||
},
|
||||
"S2": {
|
||||
"단산:22|레미콘타설(장비사용)|철근구조물|m3": "e2940f403c6c",
|
||||
"단산:20|레미콘타설(장비사용)|무근구조물|m3": "d0347d9e519e",
|
||||
"단산:22|레미콘타설(장비사용)|철근구조물|m3": "a35e3f7819d4",
|
||||
"단산:20|레미콘타설(장비사용)|무근구조물|m3": "6caceddb40b1",
|
||||
"단산:38|유로폼(euroform)|6회,보통|m2": "0cd2081fa29f",
|
||||
"단산:53|철근가공조립(현장)|type-ii|톤": "d6d92c499d78",
|
||||
"단산:4|강관비계|(10m이하)|m2": "7c1c9f2d283a",
|
||||
@@ -115,44 +115,44 @@
|
||||
"단산:37|유로폼(euroform)|6회,간단|m2": "d6ac6fccfcfd",
|
||||
"단산:52|철근가공조립(현장)|type-i(소량)|톤": "e3d8470f9851",
|
||||
"단산:49|철강재운반(할증포함)|(구역화물)|톤": "a619ce7fe816",
|
||||
"단산:51|철골설치||톤": "8e292d7859f8",
|
||||
"단산:50|철골가공조립(공장)|(대형)|톤": "b386a69202ef",
|
||||
"단산:51|철골설치||톤": "f8b5b9b49bf5",
|
||||
"단산:50|철골가공조립(공장)|(대형)|톤": "ebe8740e0a1e",
|
||||
"단산:42|잡철물제작||톤": "ef730a79e03f",
|
||||
"단산:67|합판거푸집(6회)||m2": "b3ba20147436",
|
||||
"단산:33|와이어메시바닥깔기||m2": "2f898ef1909d",
|
||||
"단산:11|구조물터파기(토사)||m3": "5b2c549e3ec2",
|
||||
"단산:8|구조물되메우기및다짐||m3": "184c85a346db",
|
||||
"단산:39|잔토처리||m3": "147afeac7acd",
|
||||
"단산:21|레미콘타설(장비사용)|무근구조물-소량타설|m3": "6b7edafbfd22",
|
||||
"단산:11|구조물터파기(토사)||m3": "d104c4f35461",
|
||||
"단산:8|구조물되메우기및다짐||m3": "4b834cdae99f",
|
||||
"단산:39|잔토처리||m3": "62e430cfb337",
|
||||
"단산:21|레미콘타설(장비사용)|무근구조물-소량타설|m3": "32bb4fda75e2",
|
||||
"단산:66|합판거푸집(4회)||m2": "39bdcddca57c",
|
||||
"단산:12|기초잡석다짐및채집운반|(9:1)(0.6m3+4.5ton)|m3": "dc7a46817506",
|
||||
"단산:26|배수관부설|(d=1000mm)|m": "e6f492785d36",
|
||||
"단산:12|기초잡석다짐및채집운반|(9:1)(0.6m3+4.5ton)|m3": "24dcf4cf1ac0",
|
||||
"단산:26|배수관부설|(d=1000mm)|m": "7c06bc3e3a91",
|
||||
"호표:7": "9238de708278",
|
||||
"단산:19|레미콘타설(인력운반)|무근구조물-소량타설|m3": "728a28bc9224",
|
||||
"단산:9|구조물터파기|인력|m3": "06855a4c159a",
|
||||
"단산:7|구조물되메우기|인력|m3": "8d23c8175496",
|
||||
"단산:40|잔토처리|인력|m3": "e62dedcec317",
|
||||
"단산:40|잔토처리|인력|m3": "e488fa518c11",
|
||||
"단산:35|원형돌망태조립설치|산림사업품셈|조": "05d490e21236",
|
||||
"단산:36|원형돌망태채움|산림사업품셈|조": "a4b290a399fd",
|
||||
"단산:43|조약돌채집운반|(9:1)(0.6m3+4.5ton)|m3": "3d10f7bb409b",
|
||||
"단산:10|구조물터파기(암)||m3": "884a1241cb59",
|
||||
"단산:27|배수관부설|(d=500mm)|m": "e00f055d8b21",
|
||||
"단산:18|레미콘타설(무근펌프카)(130m3)|41m(80-95m3/hr)|m3": "07d3e7ce5cf4",
|
||||
"단산:36|원형돌망태채움|산림사업품셈|조": "c8e1f0314e45",
|
||||
"단산:43|조약돌채집운반|(9:1)(0.6m3+4.5ton)|m3": "1cc5362dc3b4",
|
||||
"단산:10|구조물터파기(암)||m3": "0d821feb9c44",
|
||||
"단산:27|배수관부설|(d=500mm)|m": "964f47b3dd45",
|
||||
"단산:18|레미콘타설(무근펌프카)(130m3)|41m(80-95m3/hr)|m3": "6da4e3284f73",
|
||||
"줄:콘크리트펌프차|41m,80~95m3/hr|시간": "6dfaed1dd20a",
|
||||
"단산:25|문양거푸집||m2": "fba1f776a83c",
|
||||
"단산:46|지수판설치|산림사업품셈|m": "3ddb72dcd81d",
|
||||
"단산:1|p.v.c파이프설치|산림사업품셈|m": "ec1cd531e2e6",
|
||||
"단산:17|떼붙임(평떼)|산림사업품셈|m2": "fdd2e6bd02f0",
|
||||
"단산:60|큰돌메쌓기|40cm-60cm,(산림사업품셈)|m2": "b44908334fae",
|
||||
"단산:5|고임돌채집및운반|(9:1)(0.6m3+4.5ton)|m3": "6d67aa013e60",
|
||||
"단산:16|뒷채움잡석채집운반다짐|(9:1)(0.6m3+4.5ton)|m3": "2f37d4203fdc",
|
||||
"단산:62|큰돌찰쌓기|40cm-60cm,(산림사업품셈)|m2": "6b65c0b531df",
|
||||
"단산:63|큰돌채집운반|산림사업품셈|m2": "09662a8f8d36",
|
||||
"단산:13|뒷채움잡석구입운반||m3": "797df59d7756",
|
||||
"단산:15|뒷채움잡석뒷채움||m3": "012a67631d07",
|
||||
"단산:14|뒷채움잡석구입운반|(창봉기번3)(2차)|m3": "42b81776b3e4",
|
||||
"단산:59|큰돌메붙임|40cm-60cm,(산림사업품셈)|m2": "cc09e80f4533",
|
||||
"단산:61|큰돌찰붙임|40cm-60cm,(산림사업품셈)|m2": "469d3c56b621"
|
||||
"단산:17|떼붙임(평떼)|산림사업품셈|m2": "0319c3fc3b39",
|
||||
"단산:60|큰돌메쌓기|40cm-60cm,(산림사업품셈)|m2": "83f1a9a2b201",
|
||||
"단산:5|고임돌채집및운반|(9:1)(0.6m3+4.5ton)|m3": "6f841c019f4e",
|
||||
"단산:16|뒷채움잡석채집운반다짐|(9:1)(0.6m3+4.5ton)|m3": "eb182b275f99",
|
||||
"단산:62|큰돌찰쌓기|40cm-60cm,(산림사업품셈)|m2": "3045ba240634",
|
||||
"단산:63|큰돌채집운반|산림사업품셈|m2": "35a75e3957bb",
|
||||
"단산:13|뒷채움잡석구입운반||m3": "c425998ad058",
|
||||
"단산:15|뒷채움잡석뒷채움||m3": "f9d5674557e8",
|
||||
"단산:14|뒷채움잡석구입운반|(창봉기번3)(2차)|m3": "8a37a388d59a",
|
||||
"단산:59|큰돌메붙임|40cm-60cm,(산림사업품셈)|m2": "1aefe1f21b3b",
|
||||
"단산:61|큰돌찰붙임|40cm-60cm,(산림사업품셈)|m2": "b140bb188ade"
|
||||
}
|
||||
},
|
||||
"거창": {
|
||||
@@ -188,26 +188,26 @@
|
||||
"호표:1": "1f6345e0085e",
|
||||
"호표:2": "dacbaeeaa6c9",
|
||||
"호표:3": "03d873100e35",
|
||||
"단산:30|유로폼|보통,0~7m|m2": "e278a75b7213",
|
||||
"단산:38|철근가공및조립(현장)|type-ii-1|톤": "4ea51eae487f",
|
||||
"단산:39|강관비계|10m이하(3개월)|m2": "769cb5147b54",
|
||||
"단산:29|유로폼|간단,0~7m|m2": "dcf229abaa91",
|
||||
"단산:30|유로폼|보통,0~7m|m2": "8e45789b4266",
|
||||
"단산:38|철근가공및조립(현장)|type-ii-1|톤": "f65df34c4c3e",
|
||||
"단산:39|강관비계|10m이하(3개월)|m2": "a96380c10324",
|
||||
"단산:29|유로폼|간단,0~7m|m2": "cb2624477569",
|
||||
"호표:10": "fc2cc4cd2868",
|
||||
"호표:11": "998a0263fed9",
|
||||
"단산:36|레미콘타설(장비사용타설)|무근구조물|m3": "39982206412d",
|
||||
"단산:40|레미콘타설(장비사용타설)|철근구조물|m3": "41c11b60b1e1",
|
||||
"단산:41|합판거푸집|4회|m2": "dfd5ab302d05",
|
||||
"단산:36|레미콘타설(장비사용타설)|무근구조물|m3": "c0b9cfa60d77",
|
||||
"단산:40|레미콘타설(장비사용타설)|철근구조물|m3": "198ef508476c",
|
||||
"단산:41|합판거푸집|4회|m2": "965f0578c65a",
|
||||
"단산:31|철근가공및조립(현장)|type-i-1(소형)|톤": "a98e998b35c0",
|
||||
"단산:42|강관동바리|2.5m이하(1개월)|공m3": "99d65ebd3dcc",
|
||||
"단산:43|잡철물제작및설치(현장)|일반철재|톤": "71c1f965449f",
|
||||
"단산:44|안내표지판설치|단주식|개소": "38427ebd6d28",
|
||||
"단산:42|강관동바리|2.5m이하(1개월)|공m3": "15e8a1fae939",
|
||||
"단산:43|잡철물제작및설치(현장)|일반철재|톤": "9803bb826c42",
|
||||
"단산:44|안내표지판설치|단주식|개소": "3c6f75841d3b",
|
||||
"단산:37|레미콘타설(인력운반타설)|소형구조물|m3": "6c2df8e4fd6a",
|
||||
"단산:45|합판거푸집|6회,간단|m2": "85dcc3e13e28"
|
||||
"단산:45|합판거푸집|6회,간단|m2": "ec2e16734886"
|
||||
}
|
||||
},
|
||||
"봉화": {
|
||||
"S1": {
|
||||
"해시": "fcf03906734a",
|
||||
"해시": "4c3ba7796291",
|
||||
"꼴": "STmate",
|
||||
"호표": 45,
|
||||
"줄": 209,
|
||||
@@ -236,36 +236,36 @@
|
||||
"S2": {
|
||||
"줄:굴삭기(타이어)|0.6m3,(부착용집게)|시간": "7ba959ec2e9d",
|
||||
"호표:1": "ee8a116be0f0",
|
||||
"단산:96|레미콘타설(장비)|무근,소형|m3": "fcbfc0642dc2",
|
||||
"단산:96|레미콘타설(장비)|무근,소형|m3": "fed15560be74",
|
||||
"단산:102|합판거푸집(간단)|간단|m2": "70042bc48cb6",
|
||||
"단산:4|글자새김|자당6x6|자": "ff7e1309d192",
|
||||
"단산:2|구조물터파기(토사)|굴삭기0.2m3|m3": "2ce888963761",
|
||||
"단산:7|구조물되메우기|굴삭기0.2m3|m3": "c72b4a1494d6",
|
||||
"단산:49|잔토처리|굴삭기0.2m3|m3": "800b67112b8d",
|
||||
"단산:2|구조물터파기(토사)|굴삭기0.2m3|m3": "cbead3149b3c",
|
||||
"단산:7|구조물되메우기|굴삭기0.2m3|m3": "3ff7d6c09304",
|
||||
"단산:49|잔토처리|굴삭기0.2m3|m3": "bc633bad0c98",
|
||||
"호표:5": "566b3ec95fef",
|
||||
"단산:43|깬잡석채집|l=45cm내외|m2": "6c67d6e7d946",
|
||||
"단산:5|고임돌채집|기계(0.7m3,100%)|m3": "304739062d51",
|
||||
"단산:6|막자갈채집|기계(0.7m3,100%)|m3": "b149f96f7918",
|
||||
"단산:8|기초다짐및뒤채움|소형장비사용시공|m3": "d1e2a67c4989",
|
||||
"단산:43|깬잡석채집|l=45cm내외|m2": "9382675c6d66",
|
||||
"단산:5|고임돌채집|기계(0.7m3,100%)|m3": "e6a8fdb7c927",
|
||||
"단산:6|막자갈채집|기계(0.7m3,100%)|m3": "d862c41aa425",
|
||||
"단산:8|기초다짐및뒤채움|소형장비사용시공|m3": "77b469a4fd17",
|
||||
"단산:93|유로폼설치및해체|간단|m2": "5174b34972ac",
|
||||
"단산:95|레미콘타설(장비)|무근|m3": "1e45fdfca996",
|
||||
"단산:89|콘크리트믹서사용|0.45m3|m3": "71825ddc35da",
|
||||
"단산:95|레미콘타설(장비)|무근|m3": "bff32ab35cc6",
|
||||
"단산:89|콘크리트믹서사용|0.45m3|m3": "1538c2627ebb",
|
||||
"단산:94|유로폼설치및해체|보통|m2": "1985ee7ba47c",
|
||||
"단산:98|철근가공및조립|type-i-1,현장가공조립|톤": "f91f3febebf1",
|
||||
"호표:9": "992b00a50c65",
|
||||
"호표:13": "2ecc59f87b37",
|
||||
"단산:51|깬잡석채집|l=30cm내외|m2": "d23b63b9635a",
|
||||
"단산:12|콘크리트(기계비빔)|무근구조물|m3": "c9ca9357a44a",
|
||||
"단산:51|깬잡석채집|l=30cm내외|m2": "e2b6831be198",
|
||||
"단산:12|콘크리트(기계비빔)|무근구조물|m3": "c74e9c324b2c",
|
||||
"호표:17": "b50496d3f922",
|
||||
"호표:18": "d796d9bbd4bd",
|
||||
"호표:22": "2c27c0d9b1e1",
|
||||
"단산:23|구조물터파기(육상토사0~1m)|기계90%+인력10%(굴삭기0.7m3)|m3": "1e4b4e03372f",
|
||||
"단산:24|잔토처리|굴삭기0.7m3|m3": "b34905b7e0c2",
|
||||
"단산:23|구조물터파기(육상토사0~1m)|기계90%+인력10%(굴삭기0.7m3)|m3": "db3c5678df4f",
|
||||
"단산:24|잔토처리|굴삭기0.7m3|m3": "d315c818fc0f",
|
||||
"줄:굴삭기(타이어)|0.6m3|시간": "733bdb0730f2",
|
||||
"호표:24": "24b7a61d2cac",
|
||||
"단산:3|깬잡석채집|l=35cm내외|m2": "6fa38565606b",
|
||||
"단산:3|깬잡석채집|l=35cm내외|m2": "77cbf6e4a2ff",
|
||||
"호표:26": "253290e88b9f",
|
||||
"단산:52|깬잡석채집|l=60cm내외|m2": "daab119d679a",
|
||||
"단산:52|깬잡석채집|l=60cm내외|m2": "44b9b3dcffc3",
|
||||
"호표:28": "10cf341d2ca3",
|
||||
"단산:81|철근가공및조립(현장)|일반(type-i-1)|톤": "39d3a7e2e7a9",
|
||||
"호표:31": "82b74ab253f3",
|
||||
@@ -273,11 +273,11 @@
|
||||
"호표:33": "35144fc92a5c",
|
||||
"호표:34": "9b6cffd83699",
|
||||
"호표:35": "4eb05246e0c3",
|
||||
"단산:10|레미콘타설(장비사용)|소형구조물|m3": "8717ad5b8652",
|
||||
"단산:10|레미콘타설(장비사용)|소형구조물|m3": "640411e0f0a8",
|
||||
"단산:90|평떼붙임||m2": "13cce5a5166b",
|
||||
"단산:91|단끊기||m": "8701e94849ea",
|
||||
"단산:97|레미콘타설(장비)|철근|m3": "6c8931bf2865",
|
||||
"단산:103|레미콘타설(장비)|무근,버림|m3": "c99fd33aad21",
|
||||
"단산:97|레미콘타설(장비)|철근|m3": "d419cafa4932",
|
||||
"단산:103|레미콘타설(장비)|무근,버림|m3": "773debae71b8",
|
||||
"단산:99|철근가공및조립|type-ii-1,현장가공조립|톤": "e6dc6a25683b",
|
||||
"단산:113|강관동바리|암거용-3개월사용|공/m3": "55bd7c4f030a",
|
||||
"단산:112|강관비계|3개월사용|m2": "2390793aeb4b",
|
||||
@@ -320,41 +320,41 @@
|
||||
"단산:9|잔토처리|인력100%|m3": "aef7e1b84e30",
|
||||
"줄:크레인(타이어)|10톤|시간": "96a1f07e863b",
|
||||
"호표:3": "6c59b8689986",
|
||||
"단산:3|구조물터파기|토사(b/h90%+인력10%)|m3": "acefa16cc78a",
|
||||
"단산:10|잔토처리|토사(b/h100%)|m3": "c425e33125c6",
|
||||
"단산:37|콘크리트타설|임도품셈5-5|m3": "65c3e427122f",
|
||||
"단산:3|구조물터파기|토사(b/h90%+인력10%)|m3": "7953545f58b8",
|
||||
"단산:10|잔토처리|토사(b/h100%)|m3": "fa9015056847",
|
||||
"단산:37|콘크리트타설|임도품셈5-5|m3": "2d0b3ca0824f",
|
||||
"단산:59|유로폼설치,해체(복잡)|수직고7.0m이하|m2": "6b60ee0cf532",
|
||||
"단산:60|철근가공조립(현장)|typei|톤": "d1c00f23be62",
|
||||
"단산:600|기초잡석채집및운반부설|4.5톤(l=500)|m3": "91acb80ac602",
|
||||
"단산:1926|임도안전표지판설치|삼각,d=900|개소": "de7833d5056a",
|
||||
"단산:411|야면석채집운반|(25x25x35cm)장비|m2": "aeaa86e728d4",
|
||||
"단산:644|야면석찰붙임|뒷길이35cm|m2": "6771a23d197b",
|
||||
"단산:1361|고임돌채집운반|4.5톤덤프(l=500)|m3": "203a9315635b",
|
||||
"단산:1928|잡석운반및다짐||m3": "3a7b79a11b47",
|
||||
"단산:1927|면고르기||m2": "3d642227dc7b",
|
||||
"단산:600|기초잡석채집및운반부설|4.5톤(l=500)|m3": "4784bc1b14b0",
|
||||
"단산:1926|임도안전표지판설치|삼각,d=900|개소": "e05b7a689c1d",
|
||||
"단산:411|야면석채집운반|(25x25x35cm)장비|m2": "545af7826ba4",
|
||||
"단산:644|야면석찰붙임|뒷길이35cm|m2": "20cfc54d1cb3",
|
||||
"단산:1361|고임돌채집운반|4.5톤덤프(l=500)|m3": "09f75762e692",
|
||||
"단산:1928|잡석운반및다짐||m3": "7c507cfd7d53",
|
||||
"단산:1927|면고르기||m2": "5d24952044bf",
|
||||
"단산:1942|구조물터파기|인력(경질토사)|m3": "b25a97237575",
|
||||
"단산:1759|도로반사경설치|d=1000(sts)|개소": "8f206fca6ae6",
|
||||
"단산:2071|철근콘크리트타설|장비사용타설|m3": "7a4603d42158",
|
||||
"단산:2071|철근콘크리트타설|장비사용타설|m3": "998daf7e771a",
|
||||
"단산:58|유로폼설치,해체(보통)|수직고7.0m이하|m2": "de90b05e1449",
|
||||
"단산:1854|지수판설치(pvc용접)|200x5t|m": "3aec0042517c",
|
||||
"단산:1855|배수관부설및접합(p.v.c)|ø50mm-vg2일반관|m": "7200d398af99",
|
||||
"단산:1466|야면석소운반(l=35cm)|(l=20m)|m2": "79a4f66ac624",
|
||||
"단산:450|콘크리트소운반|(l=20m)|m3": "9d06f1876010",
|
||||
"단산:1843|야면석메붙임|뒷길이35cm|m2": "2e66aa2c2197",
|
||||
"단산:258|측구수로관부설|500∼700kg미만|m": "56683ae7c5bb",
|
||||
"단산:1844|콘크리트타설|장비사용타설(소형)|m3": "cdd8f38898be",
|
||||
"단산:1843|야면석메붙임|뒷길이35cm|m2": "e366c880bdb0",
|
||||
"단산:258|측구수로관부설|500∼700kg미만|m": "d7100836ca16",
|
||||
"단산:1844|콘크리트타설|장비사용타설(소형)|m3": "2d506172eebd",
|
||||
"단산:1841|합판거푸집(4회)|보통|m2": "154931aee1b7",
|
||||
"단산:2001|혼합골재부설|영월-산불|m3": "3c98157c0505",
|
||||
"단산:2001|혼합골재부설|영월-산불|m3": "64a7980290a9",
|
||||
"단산:1748|콘크리트포장(인력)|t=20cm|m3": "68e42fbf6871",
|
||||
"단산:1752|콘크리트포장절단공|임도|m": "50eb38496dbf",
|
||||
"단산:1519|뒷채움돌채집운반부설|4.5톤덤프트럭(l=500m)|m3": "17e1fe46f3c8",
|
||||
"단산:81|큰돌메쌓기|뒷길이0.6~0.8m|m2": "99f8c85542df",
|
||||
"단산:1810|큰돌채집운반(뒷길이0.6~0.8m)|장비(80%)+인력(20%)|m2": "8c9b791dab4b"
|
||||
"단산:1752|콘크리트포장절단공|임도|m": "35f09be77f1b",
|
||||
"단산:1519|뒷채움돌채집운반부설|4.5톤덤프트럭(l=500m)|m3": "4bcbbc780730",
|
||||
"단산:81|큰돌메쌓기|뒷길이0.6~0.8m|m2": "3c6626a3d944",
|
||||
"단산:1810|큰돌채집운반(뒷길이0.6~0.8m)|장비(80%)+인력(20%)|m2": "374e7a1f93a3"
|
||||
}
|
||||
},
|
||||
"울진대흥": {
|
||||
"S1": {
|
||||
"해시": "a2052e0b170c",
|
||||
"해시": "2a378597aa15",
|
||||
"꼴": "STmate",
|
||||
"호표": 34,
|
||||
"줄": 171,
|
||||
@@ -387,26 +387,26 @@
|
||||
"호표:4": "9b0429327796",
|
||||
"호표:5": "5e88ce0e4c68",
|
||||
"호표:6": "31bd5eea19c8",
|
||||
"단산:75|콘크리트믹서사용|0.45m3|m3": "bb028865ae10",
|
||||
"단산:75|콘크리트믹서사용|0.45m3|m3": "b470c79eb976",
|
||||
"호표:7": "3476f12e55bf",
|
||||
"호표:8": "b4f5087c15f6",
|
||||
"호표:9": "51afe3b087b1",
|
||||
"호표:10": "fb1dd2cf4c6a",
|
||||
"줄:굴삭기(0.7m3)||시간": "9c5792c9e5eb",
|
||||
"호표:11": "af2de3ed3f1c",
|
||||
"단산:1124|고임돌채집|기계|m3": "d92fb83f5e54",
|
||||
"단산:159|뒷채움|150m/m내외|m3": "6c3ab2cbc163",
|
||||
"단산:959|막자갈채집|기계|m3": "f84d5f824e2d",
|
||||
"단산:1124|고임돌채집|기계|m3": "ae817a2ac5a0",
|
||||
"단산:159|뒷채움|150m/m내외|m3": "08709d597e93",
|
||||
"단산:959|막자갈채집|기계|m3": "eacff8bea289",
|
||||
"단산:2200|콘크리트비빔|채움재|m3": "91472fd9fe57",
|
||||
"줄:트럭탑재형크레인|5톤|시간": "71cbed958600",
|
||||
"호표:17": "ad84568a1c33",
|
||||
"호표:18": "6f1c4c076fd4",
|
||||
"단산:1129|야면석채집|l3=45cm내외|m2": "629829a9d347",
|
||||
"단산:2119|야면석채집|l3=35cm내외|m2": "245dfe68e79f",
|
||||
"단산:1343|구조물터파기(토사)|굴삭기0.7m3|m3": "aa20475c3d30",
|
||||
"단산:2139|다지기|굴삭기0.7m3|m3": "e1a21a5a7744",
|
||||
"단산:1129|야면석채집|l3=45cm내외|m2": "a59e92e86b67",
|
||||
"단산:2119|야면석채집|l3=35cm내외|m2": "b0e17ce1bcaf",
|
||||
"단산:1343|구조물터파기(토사)|굴삭기0.7m3|m3": "72abcf573fe3",
|
||||
"단산:2139|다지기|굴삭기0.7m3|m3": "2718acaec93b",
|
||||
"단산:2195|유로폼설치및해체|간단|m2": "2ada005f71d9",
|
||||
"단산:2262|레미콘타설|무근(장비사용타설)|m3": "0011fde861d6",
|
||||
"단산:2262|레미콘타설|무근(장비사용타설)|m3": "fca8b8959999",
|
||||
"호표:28": "fd2ef8bc220b",
|
||||
"줄:굴삭기(타이어)|0.6m3,(부착용집게,0.7~0.8m3)|시간": "94a580e075dd",
|
||||
"호표:29": "02e551e5e700",
|
||||
@@ -448,7 +448,7 @@
|
||||
"호표:6": "e3b9e469607e",
|
||||
"호표:7": "1cd3bb8c5e6d",
|
||||
"호표:8": "f5f08c081e83",
|
||||
"단산:150|고임돌채집|기계|m3": "6156ce99f6a7",
|
||||
"단산:150|고임돌채집|기계|m3": "7de261f760cd",
|
||||
"호표:10": "c5b7c43c3ee1",
|
||||
"단산:1453|인력운반|기타|톤": "355f5eac9936",
|
||||
"호표:12": "c46a6d7e568f",
|
||||
@@ -457,7 +457,7 @@
|
||||
},
|
||||
"울진소광": {
|
||||
"S1": {
|
||||
"해시": "af7a97c94ed7",
|
||||
"해시": "bd1310dccd12",
|
||||
"꼴": "STmate",
|
||||
"호표": 25,
|
||||
"줄": 117,
|
||||
@@ -498,17 +498,17 @@
|
||||
"호표:12": "39f4044d3634",
|
||||
"줄:굴삭기(타이어)|0.6m3|시간": "733bdb0730f2",
|
||||
"호표:13": "af5f52dc7ecb",
|
||||
"단산:1456|구조물터파기(토사)|굴착기0.6m3|m3": "5369cb770862",
|
||||
"단산:1474|구조물되메우기|굴착기0.6m3|m3": "c42bf66f9e58",
|
||||
"단산:1475|구조물잔토처리|굴착기0.6m3|m3": "ea935c401ec0",
|
||||
"단산:492|채움콘크리트|기계비빔|m3": "76df4f4c944d",
|
||||
"단산:91|고임돌채집|굴삭기0.7m3|m3": "445470e48368",
|
||||
"단산:408|막자갈(파쇄석)채집||m3": "6f29521df826",
|
||||
"단산:867|막자갈채우기|150mm내외|m3": "f77710424c09",
|
||||
"단산:1336|레미콘타설|무근(장비)|m3": "5ff7079ff5a0",
|
||||
"단산:1456|구조물터파기(토사)|굴착기0.6m3|m3": "0973406f3e2a",
|
||||
"단산:1474|구조물되메우기|굴착기0.6m3|m3": "d7cddaa3d1ba",
|
||||
"단산:1475|구조물잔토처리|굴착기0.6m3|m3": "5827fbbcc4b8",
|
||||
"단산:492|채움콘크리트|기계비빔|m3": "07f036449ef1",
|
||||
"단산:91|고임돌채집|굴삭기0.7m3|m3": "d46bfcbe8564",
|
||||
"단산:408|막자갈(파쇄석)채집||m3": "946bdf1420ed",
|
||||
"단산:867|막자갈채우기|150mm내외|m3": "d2df9375e449",
|
||||
"단산:1336|레미콘타설|무근(장비)|m3": "9991557bff22",
|
||||
"단산:918|채움con'c|기계비빔|m3": "0c75dd9a29d2",
|
||||
"단산:1448|파쇄석채집|l3=35cm내외|m2": "5d1cf0f37342",
|
||||
"단산:1030|고임돌채집|굴삭기0.2m3|m3": "f483cf51e53b",
|
||||
"단산:1448|파쇄석채집|l3=35cm내외|m2": "8f7299995319",
|
||||
"단산:1030|고임돌채집|굴삭기0.2m3|m3": "669ef7170a82",
|
||||
"단산:1354|콘크리포장(t=20cm)포설|인력포설|m3": "ec05dd9a542f",
|
||||
"단산:794|단끊기|절취없음|m": "6aa07c8cba17",
|
||||
"단산:1329|평떼붙이기||m2": "0522e960d244",
|
||||
|
||||
@@ -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["재현"]
|
||||
@@ -1,10 +1,11 @@
|
||||
"""338-1 엑셀 지문(`M02_Hopyo_Finger` · `_Words` · `_Shares`) — 식 풀기 일곱 꼴 · 합판 지문 · 고임돌
|
||||
섞음 ·
|
||||
몫 · STmate 자원 · 기계 줄 · 직접 줄 호표. 실물 = 북부청 임도(읽기만)."""
|
||||
섞음 · 몫 · STmate 단위 줄 · 기계 줄 · 직접 줄 호표. 지문 = 블록 단위 줄 투영(776-3 · 형식 모름).
|
||||
실물 = 북부청 임도(읽기만)."""
|
||||
|
||||
import pytest
|
||||
|
||||
from M02_MasterTemplete import M02_Hopyo_Finger as finger
|
||||
from M02_MasterTemplete import M02_Hopyo_ReadEst as est
|
||||
from M02_MasterTemplete import M02_Hopyo_Shares as shares
|
||||
from M02_MasterTemplete.M02_Hopyo_Words import conds, mtypes, parse_rhs
|
||||
from resources.tester.helper_m02_hopyo_golden import line_of
|
||||
@@ -12,6 +13,11 @@ from resources.tester.helper_m02_hopyo_golden import line_of
|
||||
approx = pytest.approx
|
||||
|
||||
|
||||
def _est(text: list[str]) -> dict:
|
||||
"""EST 글 → 블록(단위 줄 = 어댑터 `ReadEst.items`)."""
|
||||
return {"번": 1, "이름": "시험", "단위": "㎥", "글": text, "항목": est.items(text)}
|
||||
|
||||
|
||||
# ── 식 풀기 ────────────────────────────────────────────────────────────
|
||||
def test_식_단가_떼고_품():
|
||||
got = parse_rhs("273,540 × 3인 ÷ 55㎥ × 2 = 29,840.7")
|
||||
@@ -44,7 +50,7 @@ def test_식_횟수_품할증():
|
||||
|
||||
def test_식_못_풀면_역산():
|
||||
assert parse_rhs("273,540 × P = 30,000") is None
|
||||
block = {"번": 1, "이름": "시험", "단위": "㎥", "글": [" 특별인부 : 273,540 × P = 27,354"]}
|
||||
block = _est([" 특별인부 : 273,540 × P = 27,354"])
|
||||
fp = finger.excel(block, {"이름": "시험", "규격": "", "단위": "㎥"})
|
||||
assert fp["인력"]["특별인부"]["품"] == approx(0.1) and fp["인력"]["특별인부"]["어떻게"] == [
|
||||
"역산"
|
||||
@@ -94,28 +100,21 @@ def test_몫_절마다_노임_장비():
|
||||
" 3. 합 계",
|
||||
" 보통인부 : 172,068 × 1 = 172,068",
|
||||
]
|
||||
parts = shares.sections(texts)
|
||||
parts = shares.sections(est.items(texts))
|
||||
assert [p["제목"] for p in parts] == ["굴착기 0.6㎥ 채집(90%)", "인력채집(10%)"]
|
||||
assert parts[0]["장비"] == {"굴착기|0.6": approx(0.9 / 23.1)}
|
||||
assert parts[1]["노임"] == {"보통인부": approx(0.03)}
|
||||
|
||||
|
||||
def test_STmate_자원_지문():
|
||||
def test_STmate_단위_줄_지문():
|
||||
qty = {"율": [], "인자": [], "어떻게": "QTY"}
|
||||
block = {
|
||||
"글": ["잔토처리 (기계100%) 건설표준품셈9-3", "q = 0.7 , K = 0.9"],
|
||||
"자원": [
|
||||
{"갈래": "L", "코드": "L00002", "이름": "보통인부", "규격": "", "품": 0.2},
|
||||
*[
|
||||
{
|
||||
"갈래": "X",
|
||||
"코드": "X00205",
|
||||
"이름": "굴삭기(무한궤도)",
|
||||
"규격": "0.7㎥",
|
||||
"품": 0.0229,
|
||||
}
|
||||
]
|
||||
* 3,
|
||||
{"갈래": "M", "코드": "M00001", "이름": "모래", "규격": "", "품": 1.2},
|
||||
"항목": [
|
||||
{"묶음": "L", "이름": "보통인부", "규격": "", "직종": "보통인부", "품": 0.2, **qty},
|
||||
{"묶음": "X", "이름": "굴삭기(무한궤도)", "규격": "0.7㎥", "품": 0.0229, **qty},
|
||||
{"묶음": "M", "이름": "모래", "규격": "", "품": 1.2, "밑품": 1.2, **qty},
|
||||
{"묶음": "L", "이름": "보통인부", "규격": "", "품": 0.5, "밖": True, **qty},
|
||||
],
|
||||
}
|
||||
fp = finger.excel(block, {"이름": "잔토처리", "규격": "토사", "단위": "M3"})
|
||||
|
||||
@@ -87,7 +87,7 @@ def test_조합_근거_안_닿은_덧은_후보(got):
|
||||
|
||||
def test_숫자_없음_옛_HP(got):
|
||||
block, line = line_of("N000")
|
||||
r = verdict.block({**block, "글": []}, line, got)
|
||||
r = verdict.block({**block, "글": [], "항목": []}, line, got) # 단위 줄 · 글 없음
|
||||
assert r["판정"]["상태"] == "후보" and r["판정"]["글"] == fit.NO_NUMBER
|
||||
assert r["차례"][0] == "GC000198" # 이름 · 근거 차례 그대로
|
||||
|
||||
|
||||
Reference in New Issue
Block a user