auto: 2026-11-18 07:18 (ESD_LAPTOP)

This commit is contained in:
2026-11-18 07:18:04 +09:00
parent 5eb42dfbd0
commit 5dfe3761a2
8 changed files with 94 additions and 245 deletions
+58 -46
View File
@@ -1,9 +1,9 @@
"""M02 일위대가 입력 목록(39-3).
담은 단가산출 로직마다 입력 전부 · 로직마다 갈라 보이고 이름이 같아도 합치지 않음 · 입력 목록은
그 로직 줄의 `입력` 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직 입력으로만) · 자동값 =
`master_auto.values`(보기용 · 저장 안 함). 일위대가 입력 모달(`GET /api/m02/logic-lib/inputs`)이
씀. M01 은 읽기만 · 권한은 부르는 쪽 몫.
그 수식 문서의 입력 변수(갈래 입력 · 선택) 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직
입력으로만) · 자동값 = `M02_Doc_Copy.auto_of`(보기용 · 저장 안 함). 일위대가 입력 모달
(`GET /api/m02/logic-lib/inputs`)이 씀. M01 은 읽기만(수식 문서 · 855 L2 ⓑ) · 권한은 부르는 쪽 몫.
"""
from __future__ import annotations
@@ -12,10 +12,10 @@ import re
from decimal import Decimal
from typing import Any
from M01_MasterData import M01_MasterData_Doc as m01doc
from M01_MasterData import M01_MasterData_Store as m01
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
_SPEC = ("이름", "설명", "단위", "고르기", "범위")
INPUTS = ("입력", "선택") # 문서 입력 변수 갈래
_LAYERED = "골쌓기 기준" # 85-2 — 표 주문에 이 글이 있으면 켜쌓기율 대상 로직
_NUMBER = re.compile(r"(?<![\d-])\d+(?:-\d+)+(?![\d-])") # 품셈 절 번호(「12-1-3」)
@@ -31,16 +31,27 @@ def _num(value: Any) -> Any:
return value
def _logics(codes: list[str]) -> tuple[list[dict], list[str]]:
"""([로직 줄 …], 빠진 로직 키) — 키 차례 그대로."""
whole = m01.loaded()[1]
found, missing = [], []
for code in codes:
try:
found.append(whole.logic(code))
except combo_store.cm.mf.FormulaError:
missing.append(code)
return found, missing
def _docs(codes: list[str]) -> tuple[list[dict], list[str]]:
"""([수식 문서 …], 빠진 로직 키) — 키 차례 그대로."""
docs = m01doc.docs()
found = [docs[code] for code in codes if code in docs]
return found, [code for code in codes if code not in docs]
def specs(doc: dict) -> list[dict[str, Any]]:
"""문서 입력 변수 → 입력 칸 `{이름: 열쇠, 설명, 단위, 고르기?(선택 목록), 범위?}`(변수 차례)."""
out = []
for v in doc.get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") not in INPUTS or not v.get("열쇠"):
continue
one = {"이름": v["열쇠"], "설명": v.get("설명") or None, "단위": v.get("단위") or None}
if link.get("갈래") == "선택":
one["고르기"] = list(link.get("목록") or [])
if link.get("범위"):
one["범위"] = list(link["범위"])
out.append(one)
return out
def layered() -> set[str]:
@@ -65,50 +76,51 @@ def _labels(whole: Any, spec: dict) -> dict[str, str]:
return out
def sources(logic: dict) -> Any:
"""원문 출처(222-1) — 로직 `출처` + 호표 · 입력 · 중간 · 덧줄 `출처` 가운데 같은 책(번호 앞 글이
같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이 절마다 찾음 · M01
`make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로."""
main = str(logic.get("출처") or "")
def sources(doc: dict) -> Any:
"""원문 출처(222-1) — 문서 `출처` + 금액 수량 줄 · 변수 · 금액 식 줄(수량 없음) `출처`
가운데 같은 책(번호 앞 글이 같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이
절마다 찾음 · M01 `make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로."""
main = str(doc.get("출처") or "")
head = _NUMBER.search(main)
if not head:
return logic.get("출처")
return doc.get("출처")
book, seen = main[: head.start()], set(_NUMBER.findall(main))
money = [x for x in doc.get("금액") or [] if isinstance(x, dict)]
rows = [x for x in money if "수량" in x] + list(doc.get("변수") or [])
extra = []
for part in ("호표", "입력", "중간", "덧줄"):
for row in logic.get(part) or []:
src = str(row.get("출처") or "") if isinstance(row, dict) else ""
hit = _NUMBER.search(src)
if hit and src[: hit.start()] == book and hit.group() not in seen:
seen.add(hit.group())
extra.append(hit.group())
for row in rows + [x for x in money if "수량" not in x]:
src = str(row.get("출처") or "") if isinstance(row, dict) else ""
hit = _NUMBER.search(src)
if hit and src[: hit.start()] == book and hit.group() not in seen:
seen.add(hit.group())
extra.append(hit.group())
return " · ".join([main, *extra])
def _listed(logics: list[dict]) -> list[dict[str, Any]]:
"""로직 줄마다 `{로직, 이름, 결과단위, 출처, 켜쌓기, 입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`."""
def _listed(docs: list[dict]) -> list[dict[str, Any]]:
"""문서마다 `{로직, 이름, 결과단위, 출처, 켜쌓기,
입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`."""
from M02_MasterTemplete import M02_Doc_Copy as dc
whole = m01.loaded()[1]
layers = layered()
out = []
for logic in logics:
auto = m01.mau.values(whole, logic)
specs = []
for spec in logic.get("입력") or []:
one = {k: spec[k] for k in _SPEC if k in spec}
one.setdefault("설명", None)
one.setdefault("단위", None)
labels = _labels(whole, spec)
for doc in docs:
auto = dc.auto_of(doc, whole)
rows = []
for one in specs(doc):
labels = _labels(whole, one)
if labels:
one["고르기이름"] = labels
specs.append({**one, "자동값": auto.get(spec["이름"])})
rows.append({**one, "자동값": auto.get(one["이름"])})
out.append(
{
"로직": logic.get("키"),
"이름": logic.get("이름"),
"결과단위": logic.get("결과단위"),
"출처": sources(logic),
"켜쌓기": logic.get("키") in layers,
"입력": specs,
"로직": doc.get("키"),
"이름": doc.get("이름"),
"결과단위": doc.get("결과단위"),
"출처": sources(doc),
"켜쌓기": doc.get("키") in layers,
"입력": rows,
}
)
return out
@@ -116,5 +128,5 @@ def _listed(logics: list[dict]) -> list[dict[str, Any]]:
def logic_inputs(codes: list[str]) -> dict[str, Any]:
"""일위대가 입력 모달 — 로직 키들의 입력 목록 `{로직: [...], 빠진로직}`(키 차례 · 겹침 한 번)"""
found, missing = _logics(list(dict.fromkeys(c for c in codes if c)))
found, missing = _docs(list(dict.fromkeys(c for c in codes if c)))
return _num({"로직": _listed(found), "빠진로직": missing})
-115
View File
@@ -1,115 +0,0 @@
"""M02 기준 목록 · 계산서 끝수(PLAN 704-2 딸림) — B09 산근 끝수 규칙으로 셈(③ 서버 단독 ·
`B09_Estimation_Sangeun` 과 규칙 짝 · 거울 시험 `test_704_settle`).
줄 금액 = ROUNDDOWN(단가 × 수량, 1) 비목마다 · 비목 총계 = ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합 ·
작업량 Q(중간 이름 Q · Q1 …) = ROUND(식, 2) 뒤 쓰임 · % 덧줄 밑수 = 그때까지 줄 합(줄 끝수 뒤).
근거 = 지식DB `technical_info/01_임도/05_원가정보/단수처리_규칙.md`(행 금액 절사 · 관측 후보 규칙).
M01 엔진(`master_formula.run`)의 구조 그대로 — 끝수 자리만 다름(엔진은 줄 끝수 없이 계에서 한 번).
하위 로직(기계경비 포함)은 같은 규칙으로 다시 셈 · 흐름 · 결과 로직은 엔진 값 그대로.
"""
from __future__ import annotations
import re
from decimal import ROUND_DOWN, ROUND_HALF_UP, Decimal
from typing import Any
from M01_MasterData import M01_MasterData_Store as m01
mf = m01.cm.mf
_Q = re.compile(r"Q\d*")
def _down(value: Any, places: int) -> Any:
return None if value is None else mf._round(Decimal(value), places, ROUND_DOWN)
def _bundle(whole: Any, item: dict, env: dict, depth: int) -> dict:
"""로직 호표 줄이 부르는 하위 로직 — 같은 규칙으로 다시 셈(엔진 `logic` 마디 그대로)."""
node = mf.parse(item["요소"])
if node[0] != "logic":
return mf.evaluate(node, env, whole, depth)
given = {k: mf.evaluate(v, env, whole, depth) for k, v in node[2]}
got = settle(whole, mf.fill(node[1], env), given, depth + 1)
return got["결과"] if "결과" in got else {k: got[k] for k in mf.BUNDLE}
def settle(whole: Any, ref: str, given: dict, depth: int = 0) -> dict:
"""`master_formula.run` 과 같은 꼴 `{줄, 노무비, 재료비, 경비, 계, 중간}` — 끝수만 B09 규칙."""
row = whole.logic(ref)
if isinstance(row.get("흐름"), dict) or "결과" in row:
return mf.run(whole, ref, given, depth)
env = mf._inputs(row, given)
for step in row.get("중간", []):
try:
value = mf.evaluate(mf.parse(step["식"]), env, whole, depth)
except mf.EmptyInput as e:
env[step["이름"]] = mf.Blank(str(e))
continue
if _Q.fullmatch(step["이름"]) and isinstance(value, Decimal):
value = value.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
env[step["이름"]] = value
lines: list[dict] = []
for n, item in enumerate(row.get("호표", [])):
try:
qty = mf.evaluate(mf.parse(item["수량"]), env, whole, depth)
if item["종류"] == "로직":
bundle = _bundle(whole, item, env, depth)
price = bundle["계"]
split = (
{k: qty * bundle[k] for k in mf.COST_ITEMS}
if "비목" not in item
else {item["비목"]: qty * price}
)
else:
ref_ = (
{
k: mf.fill(v, env) if isinstance(v, str) else v
for k, v in item["요소"].items()
}
if isinstance(item["요소"], dict)
else mf.fill(item["요소"], env)
)
if isinstance(ref_, str) and qty != 0:
whole.get(ref_)
price = mf.mp.priced(whole, item, ref_, env, n if depth == 0 else None)[0]
if price is None and qty == 0:
price = Decimal(0)
split = {item["비목"]: None if price is None else qty * price}
except mf.EmptyInput as e:
lines.append(mf._blank_line(item, str(e)))
continue
lines.append(_line(item["이름"], split))
sums = {k: sum((x["비목"].get(k) or 0 for x in lines), Decimal(0)) for k in mf.COST_ITEMS}
env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None}
for extra in row.get("덧줄", []):
env.update(sums)
try:
value = mf.evaluate(mf.parse(extra["식"]), env, whole, depth)
env[extra["이름"]] = value
except mf.FormulaError:
value = None
sums[extra["비목"]] += _down(value, 1) or 0
lines.append(_line(extra["이름"], {extra["비목"]: value}))
if value is not None:
env["줄"][extra["이름"]] = lines[-1]["금액"]
sums = {k: mf.cut(row, _down(v, 0), "계") for k, v in sums.items()}
return {"줄": lines, **sums, "계": sum(sums.values()), "중간": mf._shown(env)}
def _line(name: str, split: dict) -> dict:
cut = {k: _down(v, 1) for k, v in split.items()}
whole_sum = None if all(v is None for v in cut.values()) else sum(v or 0 for v in cut.values())
return {"이름": name, "비목": cut, "금액": whole_sum}
def apply(groups: list[dict], engine: dict, done: dict) -> None:
"""계산서 묶음의 줄 금액 · 소계를 `settle` 값으로 바꿈 — 줄 차례는 엔진과 같음."""
seq: dict[str, list] = {k: [] for k in mf.COST_ITEMS}
for eng, mine in zip(engine["줄"], done["줄"]):
for part, _ in m01.mtx._shares(eng):
seq[part].append(mine["비목"].get(part))
for group in groups:
for line, amount in zip(group["줄"], seq.get(group["비목"], [])):
line["금액"] = amount
group["소계"] = done[group["비목"]]
+23 -32
View File
@@ -8,13 +8,12 @@
바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌).
금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) ·
계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판).
(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.)
목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본
(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` ·
같으면 안 셈 ·
셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸).
실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음.
이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫).
이름표(이름 · 구분 · 출처 · 별칭) · 기초 차례(장 차례) = 수식 문서(`M01_MasterData_Doc` · 855 L2 ⓑ).
M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인).
"""
@@ -196,8 +195,8 @@ def _spec(given: dict, ax: list) -> str:
return " · ".join(parts)
def _unit(logic: dict) -> str:
unit = str(logic.get("결과단위") or "")
def _unit(doc: dict) -> str:
unit = str(doc.get("결과단위") or "")
return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit)
@@ -223,24 +222,21 @@ def _money(doc: dict, links: Any, given: dict) -> Decimal | None:
return got.get("계") if got.get("계") is not None else got.get("결과")
def _rows_of(whole: Any, logic: dict, blocked: bool, links: Any = None) -> list[dict]:
doc = m01_doc.docs().get(str(logic.get("키")))
if doc is None:
return []
def _rows_of(whole: Any, doc: dict, blocked: bool, links: Any = None) -> list[dict]:
links = links or _links(whole)
base, ax = axes(whole, doc)
changes: list[dict] = [{}]
for name, reps in ax:
changes += [{name: v} for v, _ in reps if v != base.get(name)]
head = {
"키": logic.get("키"),
"이름": logic.get("이름") or "",
"단위": _unit(logic),
"출처": logic.get("출처") or "",
"공종": kind_of(logic),
"별칭": ", ".join(x for x in [logic.get("별칭") or "", *words_of(logic)] if x),
"구분": logic.get("구분") or "",
"상세구분": logic.get("상세구분") or "",
"키": doc.get("키"),
"이름": doc.get("이름") or "",
"단위": _unit(doc),
"출처": doc.get("출처") or "",
"공종": kind_of(doc),
"별칭": ", ".join(x for x in [doc.get("별칭") or "", *words_of(doc)] if x),
"구분": doc.get("구분") or "",
"상세구분": doc.get("상세구분") or "",
"막힘": blocked,
}
out = []
@@ -283,12 +279,12 @@ def _stamp() -> str:
def _chunk(keys: list[str], blocked: set[str]) -> list[dict]:
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음)."""
whole = m01.loaded()[1]
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터 · 수식 문서는 그 프로세스가 읽음)."""
whole, docs = m01.loaded()[1], m01_doc.docs()
links = _links(whole)
out = []
for key in keys:
out += _rows_of(whole, whole.logic(key), key in blocked, links)
out += _rows_of(whole, docs[key], key in blocked, links)
return out
@@ -296,11 +292,8 @@ def build(files: dict, workers: int = 1) -> dict:
"""기준 목록 통째 — 장 차례 · `workers` > 1 이면 로직을 나눠 프로세스 여럿이 셈(차례 그대로)."""
why_of = m01.blocks()
blocked = {k for k, why in why_of.items() if why}
keys = [
str(logic.get("키"))
for _, data in sorted(m01._logic_files(files), key=lambda f: m01.chapter_order(f[1]))
for logic in data.get("줄") or []
]
chapters = sorted(m01_doc.logic_files().values(), key=m01.chapter_order)
keys = [str(doc.get("키")) for data in chapters for doc in data.get("줄") or []]
size = max(1, len(keys) // (workers * 8))
parts = [keys[i : i + size] for i in range(0, len(keys), size)]
if workers > 1:
@@ -379,13 +372,11 @@ def _given(whole: Any, doc: dict, change: dict) -> tuple[dict, list]:
def sheet(key: str, change: dict) -> dict:
"""계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(문서 셈)."""
files, whole = m01.loaded()
doc = m01_doc.docs().get(key)
try:
logic = whole.logic(key)
m01_doc.head(key) # 없는 · 로직 아닌 키 = 옛 `Master.logic` 과 같은 까닭 글
except m01.cm.mf.FormulaError as e:
raise m01.StoreError(404, str(e)) from e
if doc is None:
raise m01.StoreError(404, f"수식 문서 없음 「{key}」")
doc = m01_doc.docs()[key]
given, ax = _given(whole, doc, change)
links = _links(whole)
got = _calc(doc, links, given) or {}
@@ -393,14 +384,14 @@ def sheet(key: str, change: dict) -> dict:
return labor_inputs._num(
{
"키": key,
"이름": logic.get("이름") or "",
"이름": doc.get("이름") or "",
"규격": _spec(given, ax),
"단위": _unit(logic),
"출처": labor_inputs.sources(logic) or "",
"단위": _unit(doc),
"출처": labor_inputs.sources(doc) or "",
"판": edition(files),
"입력": given,
"묶음": mdt.sheet_groups(doc, got, links) if got and money else [],
"계": got.get("계") if money else got.get("결과"),
"기준단위": _unit(logic) or None,
"기준단위": _unit(doc) or None,
}
)
+7 -3
View File
@@ -5,7 +5,7 @@
자동값(master_auto 「나누는 자리 = 1」)이 1 이라 838 ㎥(자료 · 기본값 몫 — 223 보고).
② 별도계상 — 로직 자재(`자재표시` · 빈 칸 = 기본 별도계상) = 기준에서 빠지고 `줄` 에서 지움 · `재료` 는
남음 · 사용자 자재 = 합에서 뺌(짝 TS `settle`) · 사전조합 안 줄 · 사본 셈 같은 길.
③ 원문 — 로직 출처 + 호표 · 입력 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」).
③ 원문 — 문서 출처 + 금액 줄 · 변수 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」).
"""
import os
@@ -13,6 +13,7 @@ from decimal import Decimal
import pytest
from M01_MasterData import M01_MasterData_Doc as m01_doc
from M01_MasterData import M01_MasterData_Store as m01
from M01_MasterData import M01_MasterData_Store_Make as make
from M02_MasterTemplete import M02_Labor_Doc as labor
@@ -132,7 +133,7 @@ def test_사전조합_안_줄도_별도계상_뺌():
# ── ③ 원문 여럿 ──────────────────────────────────────────────────────
def test_원문_출처는_같은_책_절_모두():
src = inputs.sources(_whole().logic(MIX))
src = inputs.sources(m01_doc.docs()[MIX])
assert src == "산림품셈 12-1-2 · 12-1-3"
assert inputs.logic_inputs([MIX])["로직"][0]["출처"] == src
assert [f["number"] for f in make.source(src)["found"]] == ["12-1-2", "12-1-3"]
@@ -143,6 +144,9 @@ def test_원문_출처_번호_없거나_더할_것_없으면_그대로():
assert inputs.sources({"출처": None}) is None
one = {
"출처": "산림품셈 3-1",
"호표": [{"출처": "건설품셈 공통 1-2-4 3"}, {"출처": "산림품셈 3-1"}],
"금액": [
{"수량": "1", "출처": "건설품셈 공통 1-2-4 3"},
{"수량": "1", "출처": "산림품셈 3-1"},
],
}
assert inputs.sources(one) == "산림품셈 3-1" # 다른 책 · 같은 절은 안 붙임
+1 -1
View File
@@ -27,7 +27,7 @@ THREE = ("GF000220", "GC000404", "GF000101") # 돌쌓기 메쌓기(장비) ·
def _rows(key: str) -> list[dict]:
whole = m01.loaded()[1]
return st._rows_of(whole, whole.logic(key), False)
return st._rows_of(whole, m01_doc.docs()[key], False)
def _given(key: str, change: dict) -> dict:
+2 -46
View File
@@ -1,9 +1,8 @@
"""704-2 딸림 — 기준 목록 · 계산서 끝수 = B09 산근 규칙(줄마다 ROUNDDOWN 1 · 비목마다 ROUNDDOWN 0).
"""704-2 딸림 — 계산서 끝수(줄마다 0.1 · 비목 소계 정수) · 계 = 기준 목록 금액(문서 셈).
거울: 엔진 줄(수량 · 단가)에 B09 `_money` · `block_totals` 를 그대로 씌운 값 = `settle` 값.
옛 거울(엔진 줄 + B09 끝수 = `M02_Logic_Settle`)은 부르는 곳 0 이라 그 파일과 함께 걷음(855 L2 ⓑ).
"""
import re
import sys
from decimal import Decimal
from pathlib import Path
@@ -12,53 +11,10 @@ ROOT = Path(__file__).resolve().parents[2]
if str(ROOT) not in sys.path:
sys.path.insert(0, str(ROOT))
from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402
from M01_MasterData import M01_MasterData_Doc as m01_doc # noqa: E402
from M01_MasterData import M01_MasterData_Store as m01 # noqa: E402
from M02_MasterTemplete import M02_Logic_Settle as st # noqa: E402
from M02_MasterTemplete import M02_Logic_Standard as ls # noqa: E402
mf = m01.cm.mf
PART_OF = {"노무비": "labor", "재료비": "material", "경비": "expense"}
def _plain(row: dict) -> bool:
"""로직 줄 · 덧줄 · 작업량 Q 가 없는 돈 로직 — 엔진 줄만으로 B09 값을 낼 수 있음."""
return (
str(row.get("결과단위") or "").startswith("원")
and not row.get("덧줄")
and not row.get("끝수")
and not any(i.get("종류") == "로직" for i in row.get("호표") or [])
and not any(re.fullmatch(r"Q\d*", s["이름"]) for s in row.get("중간") or [])
)
def test_줄마다_버림_비목마다_버림_B09와_같음():
files, whole = m01.loaded()
checked = 0
for _, data in m01._logic_files(files):
for row in data.get("줄") or []:
if not _plain(row) or checked >= 60:
continue
base, _ = ls.axes(whole, m01_doc.docs()[row["키"]])
given = mf.fill_empty(row, base)
got = mf.run(whole, row["키"], given)
lines = []
for line in got["줄"]:
one = dict.fromkeys(PART_OF.values(), 0.0)
for part, money in line["비목"].items():
one[PART_OF[part]] = sg._money(1.0, float(money)) if money is not None else None
lines.append(one)
if any(v is None for one in lines for v in one.values()):
continue
want = sg.block_totals(lines)
mine = st.settle(whole, row["키"], given)
for name, part in PART_OF.items():
assert float(mine[name]) == want[part], (row["키"], name)
assert float(mine["계"]) == want["sum"], row["키"]
checked += 1
assert checked >= 30
def test_계산서_줄_소계_계가_맞물림():
files, whole = m01.loaded()
+2 -1
View File
@@ -15,6 +15,7 @@ from pathlib import Path
import pytest
from M01_MasterData import M01_MasterData_Doc as m01_doc
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Ref as refs
@@ -52,7 +53,7 @@ def test_727_1_기초마다_한_줄():
whole = m01.loaded()[1]
rows = []
for key in (GF, "GC000269", "GC001109"):
rows += standard._rows_of(whole, whole.logic(key), False)
rows += standard._rows_of(whole, m01_doc.docs()[key], False)
assert sum(r["키"] == GF for r in rows) == 3 # 옵션 축 보정작업 두 값 + 바탕
got = _heads(rows)
assert [r["키"] for r in got] == [GF, "GC000269", "GC001109"]
+1 -1
View File
@@ -149,7 +149,7 @@ def test_기준_목록_금액_문서_셈():
whole = m01.loaded()[1]
docs, links, _ = world()
for key in ("GF000220", "GC000404", "GX000004"):
for row in st._rows_of(whole, whole.logic(key), False, links):
for row in st._rows_of(whole, docs[key], False, links):
given = st._given(whole, docs[key], row["바꿈"])[0]
want = mc.calc(docs[key], links, given)
assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"])