refactor(855-2-C1): 옛 칸 처리 걷음 — 화면 셈 답 옛 시트 · 보기 글 · 저장 때 옛 칸 원값 적기 · 안 쓰는 셈 도구
- `M02_Sangeun_Views.py` 지움(보기 글 · 중간 — 부르는 곳 0 · 화면 보기 false 856-1) - `Sangeun_Const.answer` = 셈 답 + 머리 + 가져온 식 원본 보기만 · 옛 `원래` · `시트` 덧칸(`sheet` · `_mids` 옛 엔진 · `_finds` · `_bare` · `lost`) 지움 → 화면 셈 길(`/sangeun/calc`) 옛 엔진 부름 0 - `Sangeun_Calc`: `_detail`(둘째 기초 세부) · `_rate_text` · `_stamp_adds` · `_was` · 저장 때 덮개 `원값` 셈 지움 · `calc_doc` 옛 보기 인자 안 넘김 · 머리 글 한 길로 고침 - 남김(까닭): `resolve` · `_base_of` · `_fill` · `_gap` · `_bundles` · `_rated` · `_Over` · `_frozen`(굳힌 사본 = B9 걸음 몫 · `Doc_Import._ctx` 가 부름) · `M02_Sangeun_Formula` · `Sangeun_Doc.patched`(가져온 식 SK 고침 · B09 resolve 가 부름) · `/sangeun/calc` 길 · 머리 띠 칸(856-2 뒤 2-E2) - `Doc_Copy.doc_of` 변환 길에도 855 L1 이름표(`md.tag` — 빌더와 같게) · 받기로 들어온 L1 뒤 test_802_4a ③ 깨짐(값 사본 줄 변환 문서에 이름표 없음) 고침 - 시험: 790_2 옛 저장본 = 금액만 · 793_2 시트 덮개 단언 뺌 · 793_3b 시트 M01바뀜 시험 지움(시트 덧칸 걷음) - 여덟 군 남은 시험(715_3 · 715_store · 715_doc · 717_4 · 742_1 · 806_1) = 살아 있는 길(패치 검사 · 층 복사 · 문서 꼴 · SK 고르기 · SC 수량 · 일위대가 보기)을 봄 → 남김 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -107,7 +107,7 @@ def doc_of(whole: Any, key: str) -> dict | None:
|
||||
if live and (_live(key) is None or skc._fp(_live(key)) == skc._fp(prices.to_json(row))):
|
||||
return cp.deepcopy(live)
|
||||
try:
|
||||
return cv.convert(whole, row)[0]
|
||||
return md.tag(cv.convert(whole, row)[0], row) # 855 L1 이름표 = 빌더와 같게
|
||||
except _ERR:
|
||||
return cp.deepcopy(live) if live else None
|
||||
|
||||
|
||||
@@ -1,27 +1,15 @@
|
||||
"""M02 단가산출(SK) 셈 — 바탕 사슬 → 고친 줄 → M01 엔진 한 벌(PLAN 715-1b · 715-2).
|
||||
"""M02 단가산출(SK) 셈 — 수식 사본 문서 셈 한 길(PLAN 855 2-C1 · 715-1b · 715-2).
|
||||
|
||||
셈 = ① 바탕(M01 로직 · 바탕 SK 의 고친 줄 · 없음) ② `M02_Sangeun_Doc.patched` ③ 더한줄 참조 ·
|
||||
(SK · SC) · 고정 줄 = 먼저 셈한 1 단위 노 · 재 · 경 → `값묶음`
|
||||
④ M01 색인 위에 고친 줄을 SK 키로 얹어
|
||||
(M01 시험 계산 `_swap` 과 같은 꼴 · 메모리만 · 정본 · 캐시 안 고침) `labor.run_line` — 자동값 ·
|
||||
켜쌓기율 · 고름 · % 덧줄을 엔진이 다시 셈. 1 단위 = 기준 ÷ 배(바탕 로직 결과단위 앞 수).
|
||||
셈(`run`) = 수식 사본(`M02_Doc_Sk.copy_of` — 따로 = 저장 문서 · 파생 = 기초 문서 + 줄 규칙)을 문서 계산기로 ·
|
||||
기준 · 1 단위 · 줄 · 비목 · 끝수 = 문서 답 · 옛 엔진 안 돎 · 수식 사본 없음(바탕 참조) · 옛 칸 고침(덮개 ·
|
||||
뺀줄 · 더한줄 · 수식고침 · 식 칸) = 못 셈 + 까닭 하나 · 굳힌 사본(B09 · 구조물 사본 GX9) = 옛 길(`_frozen` ·
|
||||
`resolve` 바탕 사슬 · `_bundles` · `_rated` 율 더한줄 — B9 걸음 몫 · `Doc_Import._ctx` 도 고친 줄 도구를 씀).
|
||||
계산 자리(CLAUDE.md 5장 ③) = 서버 단독 · 화면은 셈 길(저장 안 함 · 최신 응답만).
|
||||
저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 + 서버가 `원값` · `바탕판` 적음.
|
||||
둘째 기초(727-2 · 더한줄 로직) = 세부 덮개 · 뺀줄 있으면 고친 기초 줄을 엔진으로 셈한 `값묶음` 줄
|
||||
(B09 굳힘도 그 값) · 화면 셈 길(`calc_doc`) = 그 줄 덧칸 `펼침`(세부 줄 × 수량) · `뺀세부` ·
|
||||
`바탕판` ·
|
||||
`꼬리표`(원문번호) · 답 `꼬리표` = 바탕 원문번호.
|
||||
저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 + 서버가 `바탕판` · `M01판` 적음.
|
||||
SK 단위 환산(728-2) = 배 = 바탕 기준단위(「100본」) → SK 단위(`master_unit.swap` ·
|
||||
「식」 · 빈 단위 = 앞 수 뗀 바탕 단위 = 옛 셈) ·
|
||||
다른 성격 = 문서 `환산` {계수 | 단위중량 {종별, 형상}} · 없으면 셈 막음(까닭) ·
|
||||
화면 셈 길 줄 · 계 = SK 1 단위 몫(`per_unit`).
|
||||
바탕 재료(747-1) = 별도계상 빈 칸 = 직접계산(M01 기초처럼 재료비에 듦 · 「별도계상」 고른 줄만 밖) ·
|
||||
일위대가 덮개 줄(`line` · `M02_Labor_Patch.run`)은 일위대가 기본(222-1 · 162-1) 그대로.
|
||||
보기 넷 한 답(750-1) = 화면 셈 길 답에 `글`(읽는 식) · `중간`(`M02_Sangeun_Views`) · 일위대가 줄
|
||||
모달 = 문서 `줄모드` true → `line`(일위대가 그 줄 셈과 같은 값).
|
||||
율 더한줄(778-4 · `_rated`) = 엔진 한 번 돈 줄로 밑(`M02_Labor_Fixed.rate_base` · 짝 화면
|
||||
`M02_MasterTemplete_Labor_Calc.ts` `rateBase` · 거울 시험 `test_778_4_rate_line.py`) → 율 줄 `값묶음` =
|
||||
{비목: 밑 ÷ 100} → 엔진 다시(율 줄 없는 문서 = 한 번만 · 값 그대로) · 줄 덧칸 `율` · `규격`.
|
||||
「식」 · 빈 단위 = 앞 수 뗀 바탕 단위) · 다른 성격 = 문서 `환산` {계수 | 단위중량 {종별, 형상}} ·
|
||||
없으면 셈 막음(까닭) · 화면 셈 길 줄 · 계 = SK 1 단위 몫(`per_unit`).
|
||||
바탕 재료(747-1) = 별도계상 빈 칸 = 직접계산(「별도계상」 고른 줄만 문서 금액 줄 `합밖`).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -266,46 +254,6 @@ def tag_of(whole: Any, code: str) -> str:
|
||||
return code
|
||||
|
||||
|
||||
def _detail(one: dict, at: int, whole: Any) -> dict[str, Any]:
|
||||
"""둘째 기초 세부 줄(화면) — 수량 · 금액 · 비목 = 세부 × 더한줄 수량(상자 합 몫) · `원문` =
|
||||
그 기초 1 기준단위 몫(M01 원문 품 · 744-1 화면 품 칸) · cid `add:#k/세부 cid` ·
|
||||
`바탕값` = 덮기 전 1 기준단위 품 · 단가 · `뺀세부` = 뺀 줄 이름."""
|
||||
sub = sub_run(one, whole)
|
||||
plain = sub_run(one, whole, False) if sd.sub_patched(one) else sub
|
||||
was = dict(zip(plain["정체"], plain.get("줄") or []))
|
||||
covers, times = one.get("덮개") or {}, Decimal(str(one.get("수량") or 0))
|
||||
rows = []
|
||||
for cid, line in zip(sub["정체"], sub.get("줄") or []):
|
||||
mine = covers.get(cid) or {}
|
||||
scaled = {
|
||||
k: None if line.get(k) is None else Decimal(str(line[k])) * times
|
||||
for k in ("수량", "금액")
|
||||
}
|
||||
parts = {
|
||||
k: None if v is None else Decimal(str(v)) * times
|
||||
for k, v in (line.get("비목") or {}).items()
|
||||
}
|
||||
rows.append(
|
||||
{
|
||||
**line,
|
||||
**scaled,
|
||||
"비목": parts,
|
||||
"cid": f"add:#{at}/{cid}",
|
||||
"원문": {k: line.get(k) for k in ("수량", "금액", "비목")},
|
||||
"바탕값": _was(was[cid]) if cid in was else None,
|
||||
**({"덮개": [k for k in sd.COVER_KEYS if k in mine]} if mine else {}),
|
||||
**({"원값": mine["원값"]} if "원값" in mine else {}),
|
||||
}
|
||||
)
|
||||
gone = [
|
||||
{"cid": f"add:#{at}/{c}", "이름": was[c].get("이름") or ""}
|
||||
for c in one.get("뺀줄") or []
|
||||
if c in was
|
||||
]
|
||||
tag = tag_of(whole, str(one["로직"]))
|
||||
return {"펼침": rows, "뺀세부": gone, "바탕판": sub["바탕판"], "꼬리표": tag}
|
||||
|
||||
|
||||
def _bundles(row: dict, whole: Any, expand: Any, trail: tuple) -> None:
|
||||
"""더한줄 참조 · 고정 줄 `값묶음` = 1 단위 노 · 재 · 경 — 못 셈 줄 = `_gap`(나머지 셈 계속)."""
|
||||
for at, item in enumerate(row["호표"]):
|
||||
@@ -478,12 +426,6 @@ def _rated(row: dict, eng: list, ids: list, marks: dict, stack: Any = None) -> l
|
||||
return lost
|
||||
|
||||
|
||||
def _rate_text(rate: dict) -> str:
|
||||
"""율 줄 규격 — 「인력의 %」 · 목록 = 「줄 n 개의 %」."""
|
||||
basis = rate["기준"]
|
||||
return f"줄 {len(basis)} 개의 %" if isinstance(basis, list) else f"{basis}의 %"
|
||||
|
||||
|
||||
def unit(doc: dict, whole: Any, expand: Any, trail: tuple) -> dict[str, Any]:
|
||||
"""펼침(`Expand`) 한 칸 — `{이름, 단위, 기준(1 단위), 까닭, 줄, 짝잃음}` · 못 셈 = 까닭."""
|
||||
head = {"이름": doc.get("이름"), "단위": doc.get("단위")}
|
||||
@@ -561,7 +503,8 @@ def _check_refs(doc: dict, here_: refs.Here) -> None:
|
||||
|
||||
|
||||
def clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]:
|
||||
"""저장 꼴(`Labor_Ref.clean_doc` 가 부름) — 검사 · 참조 · 순환 · 서버가 `원값` · `바탕판`."""
|
||||
"""저장 꼴(`Labor_Ref.clean_doc` 가 부름) — 검사 · 참조 · 순환 · 서버가 `바탕판` · `M01판` ·
|
||||
옛 칸 덮개 · 둘째 기초 `원값` 적기는 걷음(옛 칸 셈 은퇴 · 855 2-C1)."""
|
||||
raw, job = doc, doc.get(skc.JOB) if isinstance(doc, dict) else None # 수식 사본(802-4a)
|
||||
whole = skc.over(doc := skc.settle(doc, True), skc.whole_()) # 사본(795-1) · 내 기계(821-1)
|
||||
try:
|
||||
@@ -573,45 +516,17 @@ def clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]:
|
||||
out["바탕"], out["더한줄"] = rough["바탕"], rough["더한줄"]
|
||||
for one in out["더한줄"]: # 처음수량(744-1) = 넣을 때 수량 · 없으면 지금 수량
|
||||
one.setdefault("처음수량", one["수량"])
|
||||
if out["덮개"]:
|
||||
bare = run({**out, "덮개": {}}, whole) # 덮기 전 값 = 원값(그때 M01)
|
||||
was = {x["cid"]: x for x in bare.get("줄") or []}
|
||||
for cid, one in out["덮개"].items():
|
||||
if cid in was:
|
||||
one["원값"] = _was(was[cid])
|
||||
out |= const.stamp(base["줄"], out) # 바탕판 · M01판(790-2) · 식 칸 엔진 식(792-1)
|
||||
ratio_of(out, base["줄"], whole) # 단위 못 바꿈(계수 없음) = 저장 막음(728-2)
|
||||
_stamp_adds(out, base, whole)
|
||||
out = dsk.settle(out, whole, job, raw)
|
||||
except sd.DocError as e:
|
||||
raise _fail(e) from e
|
||||
return out
|
||||
|
||||
|
||||
def _stamp_adds(out: dict, base: dict, whole: Any) -> None:
|
||||
"""둘째 기초 저장 칸(727-2) — `바탕판` = 그 기초 지문 · 세부 덮개 `원값` = 덮기 전
|
||||
1 기준단위 값."""
|
||||
filled, _ = _fill(out, whole, {**base["입력값"], **out["입력값"]})
|
||||
for one, mine in zip(filled["더한줄"], out["더한줄"]):
|
||||
if one.get("종류") != "로직":
|
||||
continue
|
||||
plain = sub_run(one, whole, False)
|
||||
if plain["바탕판"]:
|
||||
mine["바탕판"] = plain["바탕판"]
|
||||
was = dict(zip(plain["정체"], plain.get("줄") or []))
|
||||
for cid, cover in (mine.get("덮개") or {}).items():
|
||||
if cid in was:
|
||||
cover["원값"] = _was(was[cid])
|
||||
|
||||
|
||||
def _was(line: dict) -> dict[str, Any]:
|
||||
keep = {"qty": line.get("율", line.get("수량")), "단가": line.get("단가")}
|
||||
return {k: sd.plain(Decimal(str(v))) for k, v in keep.items() if v is not None}
|
||||
|
||||
|
||||
def calc_doc(doc: Any, given: dict | None = None, seen: bool = True) -> dict[str, Any]:
|
||||
"""셈 길(`M02_Sangeun_Router`) — 지금 층 문서 · 저장 전 화면 문서 · 틀림 400 · 순환 422 ·
|
||||
`seen` = 보기 덧칸(`글` · `중간`) 지음."""
|
||||
`seen` = 옛 보기 덧칸 자리(856-1 뒤 안 지음 · 길 꼴만 · 2-E2 에서 걷음)."""
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
|
||||
with m01.cache.steady(): # 한 셈 동안 M01 파일 자국 한 번(792-2)
|
||||
@@ -620,8 +535,7 @@ def calc_doc(doc: Any, given: dict | None = None, seen: bool = True) -> dict[str
|
||||
clean = sd.clean(doc, None, whole)
|
||||
_check_refs(clean, refs.here()) # 저장 전 문서도 위 층만 · 있는 문서 · 순환 422
|
||||
me = refs.ref_id({"층": refs.here()[0], "주인": refs.here()[1], "키": clean["키"]})
|
||||
line = isinstance(doc, dict) and doc.get("줄모드") is True # 일위대가 줄 모달(750-1)
|
||||
got = run(clean, whole, given, trail=(me,), detail=True, line=line, seen=seen)
|
||||
got = run(clean, whole, given, trail=(me,))
|
||||
except sd.DocError as e:
|
||||
raise _fail(e) from e
|
||||
return skc.mark(const.answer(got, clean, doc, given, (me,)), clean) # 790-2 · 795-1
|
||||
return skc.mark(const.answer(got, clean), clean) # 795-1
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
"""M02 단가산출(SK) 숫자 넓힘(PLAN 790-2 · 요구서_652 · _분석_650-H3 E2) — 새 덮개 갈래 · 시트 답.
|
||||
"""M02 단가산출(SK) 숫자 넓힘(PLAN 790-2 · 요구서_652 · _분석_650-H3 E2) — 새 덮개 갈래.
|
||||
|
||||
시험 `resources/tester/test_790_2_sangeun_const.py` · 799-2 — 화면 짝(`Const_Model.ts` · 시트 탭)은 걷음, 서버만 남음.
|
||||
|
||||
@@ -15,8 +15,7 @@
|
||||
셈 = `M02_Sangeun_Doc.patched` 첫머리 `formulas`(바탕 줄 식을 바꾼 사본) → 모든 셈 길(화면 · 저장
|
||||
원값 · B09 · 펼침 겹침) 한 벌 · 펼침(`M02_Library_Flat._read`) = 새 덮개 SK 는 안 펼침
|
||||
(옛 참조 그대로) · [초기화](`M02_Library_Flat.reset`) = `restore` 전체.
|
||||
화면 셈 답(`answer`) 덧칸 `원래` {노무비, 재료비, 경비, 계}(1 단위) + `시트` {자리, 글줄, 짝잃음} ·
|
||||
M01 원래 = 같은 옵션 · 덮개 · 뺀줄 · 더한줄 · 새 덮개 없는 셈.
|
||||
화면 셈 답(`answer`) = 문서 셈 답 + 머리(옛 `원래` · `시트` 덧칸은 855 2-C1 에서 걷음 · 상세 몸 856-1).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -25,7 +24,6 @@ import functools
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
@@ -139,24 +137,6 @@ def _swapped(row: dict, doc: dict) -> dict:
|
||||
return out
|
||||
|
||||
|
||||
def lost(row: dict, doc: dict) -> list[dict]:
|
||||
"""짝 잃은 새 덮개 — 바탕에 없는 자리 · 없는 n 번째."""
|
||||
where, out = places(row), []
|
||||
for name, kind in (("상수덮개", "num"), ("표값덮개", "find")):
|
||||
for spot, cover in (doc.get(name) or {}).items():
|
||||
if spot not in where:
|
||||
out.append({"cid": spot, "까닭": f"{name} — 바탕에 없는 줄"})
|
||||
continue
|
||||
part, at = where[spot]
|
||||
have = len(scan(str((row[part][at] or {}).get(FIELD[part])))[kind])
|
||||
out += [
|
||||
{"cid": spot, "까닭": f"{name} — {int(n) + 1} 번째 없음"}
|
||||
for n in cover
|
||||
if int(n) >= have
|
||||
]
|
||||
return out
|
||||
|
||||
|
||||
def no_flat(doc: Any) -> None:
|
||||
"""펼침 막음 — 상수 · 표값 덮개 SK(펼친 줄에 못 옮김 · 옛 참조 그대로 = 값 그대로)."""
|
||||
keys = ("상수덮개", "표값덮개", eqm.KEY) # 수식 고침(796-2b)
|
||||
@@ -313,105 +293,9 @@ def kinds(doc: dict, spot: str) -> list[str]:
|
||||
|
||||
|
||||
# ── 화면 셈 답 ────────────────────────────────────────────────────────
|
||||
def answer(got: dict, clean: dict, raw: Any, given: dict | None, trail: tuple) -> dict:
|
||||
"""`M02_Sangeun_Calc.calc_doc` 답 — 옛 답 + `원래` · `시트`."""
|
||||
def answer(got: dict, clean: dict) -> dict:
|
||||
"""`M02_Sangeun_Calc.calc_doc` 답 — 셈 답(1 단위 몫) + 머리 · 가져온 식 원본 보기(옛 `원래` · `시트` 걷음 · 855 2-C1)."""
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
|
||||
out = {**calc.per_unit(got, clean), "머리": calc.head_of(clean)}
|
||||
return calc.labor._json(imp.more(out | sheet(out, clean, raw, given, trail), clean))
|
||||
|
||||
|
||||
def _bare(doc: dict) -> dict:
|
||||
out = {k: v for k, v in doc.items() if k not in (*NEW, *fx.FIELDS, "뺀더한줄", eqm.KEY)}
|
||||
return out | {"덮개": {}, "뺀줄": [], "더한줄": []}
|
||||
|
||||
|
||||
def _mids(whole: Any, key: str, row: dict, values: dict) -> tuple[dict, dict]:
|
||||
"""(중간 값, 엔진 입력) — 시험 계산과 같은 길(`M02_Sangeun_Views.text_of`) · 못 셈 = 빈."""
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
|
||||
over = calc._Over(whole, key, {**row, "키": key})
|
||||
m01 = calc.labor.m01
|
||||
auto = {k: v for k, v in m01.mau.values(over, over.logic(key)).items() if v is not None}
|
||||
given = {**auto, **m01._dec(values or {})}
|
||||
try:
|
||||
mid = calc.labor.mcut.engine(over, key, m01.cm.mf.run(over, key, given)).get("중간") or {}
|
||||
except Exception: # noqa: BLE001 — 엔진 FormulaError · 셈 틀림 = 값 없음
|
||||
return {}, given
|
||||
return mid, given
|
||||
|
||||
|
||||
def _finds(whole: Any, text: str, env: dict) -> list[dict]:
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
|
||||
mf, out = labor.m01.cm.mf, []
|
||||
for n, (a, b) in enumerate(scan(text)["find"]):
|
||||
try:
|
||||
value = mf.evaluate(mf.parse(text[a:b]), dict(env), whole)
|
||||
except Exception: # noqa: BLE001
|
||||
value = None
|
||||
out.append({"n": n, "글": text[a:b], "값": value})
|
||||
return out
|
||||
|
||||
|
||||
def sheet(ans: dict, clean: dict, raw: Any, given: dict | None, trail: tuple) -> dict:
|
||||
"""`원래` · `시트` — 자리마다 원래 · 지금 · 덮개 갈래 · 까닭 · M01바뀜 · 상수 · 표값."""
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
|
||||
whole = calc.skc.over(clean, calc.labor.m01.loaded()[1]) # 사본(795-1) — 중간 · 표값도
|
||||
try:
|
||||
base = calc._base_of(clean, whole, refs.read_ref, trail)["줄"]
|
||||
bare = calc.per_unit(calc.run(_bare(clean), whole, given, trail=trail), clean)
|
||||
except sd.DocError:
|
||||
return {"원래": None, "시트": {"자리": {}, "글줄": clean.get("글줄") or [], "짝잃음": []}}
|
||||
was = {x["cid"]: x for x in bare.get("줄") or [] if x.get("cid")}
|
||||
now = {x["cid"]: x for x in ans.get("줄") or [] if x.get("cid")}
|
||||
key = str(clean.get("키") or "SK-000000")
|
||||
values = {**(clean.get("입력값") or {}), **(given or {})}
|
||||
mids0, env0 = _mids(whole, key, base, values)
|
||||
mids1, _ = _mids(whole, key, formulas(base, clean), values)
|
||||
stamps = (raw.get("M01판") if isinstance(raw, dict) else None) or {}
|
||||
stamps = {} if imp.is_imported(clean) else stamps # 가져온 식 = M01 짝 없음(793-3b)
|
||||
fresh = stamp(base)["M01판"]
|
||||
why = clean.get("까닭") or {}
|
||||
nums, finds = clean.get("상수덮개") or {}, clean.get("표값덮개") or {}
|
||||
spots: dict[str, dict] = {}
|
||||
for spot, (part, at) in places(base).items():
|
||||
line = base[part][at]
|
||||
text = str(line.get(FIELD[part]))
|
||||
consts = [
|
||||
{"n": n, "값": nums.get(spot, {}).get(str(n), v), "원값": v}
|
||||
for n, v in enumerate(Decimal(text[a:b]) for a, b in scan(text)["num"])
|
||||
]
|
||||
tables = [
|
||||
{**t, "원값": t["값"], "값": finds.get(spot, {}).get(str(t["n"]), t["값"])}
|
||||
for t in _finds(whole, text, {**env0, **mids0})
|
||||
]
|
||||
if part == "중간":
|
||||
name = str(line.get("이름"))
|
||||
old, cur = mids0.get(name), mids1.get(name)
|
||||
else:
|
||||
old, cur = (was.get(spot) or {}).get("금액"), (now.get(spot) or {}).get("금액")
|
||||
spots[spot] = {
|
||||
"갈래": part,
|
||||
"이름": line.get("이름") or "",
|
||||
"식": text,
|
||||
"상수": consts,
|
||||
"표값": tables,
|
||||
"원래": old,
|
||||
"지금": cur,
|
||||
"덮개": kinds(clean, spot),
|
||||
"까닭": why.get(spot),
|
||||
"M01바뀜": spot in stamps and stamps[spot] != fresh.get(spot),
|
||||
}
|
||||
for cid, line in now.items():
|
||||
if _ADD.match(cid) and cid not in spots:
|
||||
spots[cid] = {"갈래": "더한줄", "이름": line.get("이름") or "", "원래": None}
|
||||
spots[cid] |= {"지금": line.get("금액"), "덮개": [], "까닭": why.get(cid)}
|
||||
gone = lost(base, clean) + [
|
||||
{"cid": s, "까닭": "M01 바뀜 — 바탕에 없는 줄"} for s in stamps if s not in fresh
|
||||
]
|
||||
gone += fx.sheet_more(spots, base, clean, mids1) # 식 칸(792-1) 덧칸 · 변수 줄 · 틀린 식
|
||||
top = {"글줄": clean.get("글줄") or [], "짝잃음": gone, "이름표": fx.name_table(base, clean)}
|
||||
return {"원래": bare.get("기준"), "시트": {"자리": spots, **top}}
|
||||
return calc.labor._json(imp.more(out, clean))
|
||||
|
||||
@@ -1,83 +0,0 @@
|
||||
"""M02 단가산출(SK) 보기 넷 = 셈 답 하나(PLAN 750-1 · 요구 588-1) — 화면 셈 길 답 덧칸.
|
||||
|
||||
- `글` = 읽는 식(M01 `/text` 와 같은 꼴 · `master_text.lines` + `master_sheet_line.annotate`) ·
|
||||
SK 고친 줄(`_Over`) · 같은 입력(자동값 + 입력값) · 같은 고름(`choosing`) 위에서 지음.
|
||||
줄마다 `cid` = SK 줄 cid(`annotate` 와 같은 차례 — 호표 줄 × `_shares` 비목 · 뒤 덧줄).
|
||||
금액 · 소계 · 계 = SK `줄` · `기준` 그대로(`finish` — 별도계상 뺌 · 켜쌓기율 · 단위 환산 ÷배 ·
|
||||
못 셈 줄 까닭) · 식 글(`글` · `이름글`)은 바탕 단위 셈 그대로 + 머리 `나눔`(배 ≠ 1).
|
||||
- `중간` = 시험 계산 중간값(수 · 글만) — 시험 계산 = {lines: `줄`, sums: `기준`, middle: `중간`}.
|
||||
계산 자리 = 서버 단독(CLAUDE.md 5장 ③) · 화면은 그리기만.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
|
||||
mf = labor.m01.cm.mf
|
||||
import master_sheet_line as msl # noqa: E402 — scripts 길은 `m01` 이 둠
|
||||
import master_text as mtx # noqa: E402
|
||||
|
||||
_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError)
|
||||
|
||||
|
||||
def text_of(over: Any, key: str, values: dict, picks: Any, ids: list, eng: list) -> dict:
|
||||
"""`{글, 중간}` — `eng` = `run_line` 줄(별도계상 빼기 전 · 차례 맞춤용) · 못 지음 = 까닭."""
|
||||
row = over.logic(key)
|
||||
auto = {k: v for k, v in labor.m01.mau.values(over, row).items() if v is not None}
|
||||
given = {**auto, **labor.m01._dec(values or {})}
|
||||
try:
|
||||
with mf.mp.choosing(picks or None):
|
||||
text = msl.annotate(over, key, given, mtx.lines(over, key, given))
|
||||
mid = labor.mcut.engine(over, key, mf.run(over, key, given)).get("중간") or {} # 751-3
|
||||
except _ERRORS as e:
|
||||
return {"글": {"ok": False, "reason": str(e) or type(e).__name__}, "중간": {}}
|
||||
if text.get("ok") and "groups" in text and "결과" not in row:
|
||||
_tag(row, ids, eng, text)
|
||||
keep = (Decimal, int, float, str, bool)
|
||||
return {"글": text, "중간": {k: v for k, v in mid.items() if isinstance(v, keep)}}
|
||||
|
||||
|
||||
def _tag(row: dict, ids: list, eng: list, text: dict) -> None:
|
||||
"""글 줄마다 `cid` — `annotate` 와 같은 차례(호표 줄 × 몫 비목 → 덧줄)."""
|
||||
slots = {g["비목"]: iter(g["줄"]) for g in text["groups"]}
|
||||
items, adds = row.get("호표") or [], row.get("덧줄") or []
|
||||
for n, line in enumerate(eng):
|
||||
if n < len(items):
|
||||
parts = [p for p, _ in mtx._shares(line)] if line.get("비목") else []
|
||||
else:
|
||||
parts = [adds[n - len(items)]["비목"]] if n - len(items) < len(adds) else []
|
||||
for part in parts:
|
||||
one = next(slots.get(part, iter(())), None)
|
||||
if one is not None and n < len(ids):
|
||||
one["cid"] = ids[n]
|
||||
|
||||
|
||||
def finish(ans: dict) -> dict:
|
||||
"""화면 답(`per_unit` 뒤) — 글 금액 · 소계 · 계 = SK 줄 · 기준 · SK 에 없는 줄(별도계상) 뺌."""
|
||||
text = ans.get("글") or {}
|
||||
base = ans.get("기준")
|
||||
if not text.get("ok") or "groups" not in text or not base:
|
||||
return ans
|
||||
sk = {x["cid"]: x for x in ans.get("줄") or [] if x.get("cid")}
|
||||
groups = []
|
||||
for g in text["groups"]:
|
||||
kept = []
|
||||
for one in g["줄"]:
|
||||
line = sk.get(one.get("cid"))
|
||||
if line is None and one.get("cid"):
|
||||
continue # SK 에서 빠진 줄(별도계상)
|
||||
if line is not None:
|
||||
parts = line.get("비목") or {}
|
||||
money = parts.get(g["비목"]) if len(parts) > 1 else line.get("금액")
|
||||
one = {**one, "금액": money}
|
||||
if line.get("까닭"):
|
||||
one["까닭"] = line["까닭"]
|
||||
kept.append(one)
|
||||
if kept:
|
||||
groups.append({**g, "줄": kept, "소계": base.get(g["비목"])})
|
||||
times = ans.get("화면배")
|
||||
head = {"나눔": times} if times not in (None, 1) else {}
|
||||
return {**ans, "글": {**text, "groups": groups, "계": base.get("계"), **head}}
|
||||
@@ -144,7 +144,6 @@ def _calc(folder, doc, given=None):
|
||||
|
||||
|
||||
def test_옛_저장본_셈답(world):
|
||||
"""새 칸 없는 옛 저장본(M01판 없음) = 금액 그대로 · M01바뀜 없음."""
|
||||
"""새 칸 없는 옛 저장본(M01판 없음) = 금액 그대로(옛 `원래` · `시트` 덧칸은 855 2-C1 에서 걷음)."""
|
||||
got = _calc(world["personal"], {**_doc(FORM, F211), "바탕판": "0" * 16})
|
||||
assert got["기준"]["계"] == 51419 == got["원래"]["계"]
|
||||
assert not any(x.get("M01바뀜") for x in got["시트"]["자리"].values())
|
||||
assert got["기준"]["계"] == 51419
|
||||
|
||||
@@ -176,8 +176,6 @@ def test_셈_답_원래_엑셀_원본_글(world):
|
||||
got = calc.calc_doc(doc)
|
||||
assert got["원래"] == {"노무비": 34119, "재료비": 11192, "경비": 341, "계": 45652}
|
||||
assert got["기준"]["계"] > 45652
|
||||
spot = got["시트"]["자리"]["labor:형틀목공#0"]
|
||||
assert spot["덮개"] == ["품"] and spot["까닭"] == "현장 품"
|
||||
view = got[imp.KEY]
|
||||
assert view["단가기준"] == "엑셀" and view["파일"] == "봉화.xlsx" and view["행"] == [2909, 2943]
|
||||
lines = view["글줄"]
|
||||
|
||||
@@ -138,20 +138,3 @@ def test_부품상자만_700줄_공용_안_고침():
|
||||
assert "#" not in "".join(re.findall(r"color:\s*[^;]+", text)), name
|
||||
for name in ("Labor_Rows", "Labor_SkEdit", "Sangeun_Detail", "Sangeun_Tabs"):
|
||||
assert "Hopyo_Imported" not in _src(name), name # 공용 쪽은 새 모달을 모름
|
||||
|
||||
|
||||
def test_가져온_식_시트_M01바뀜_없음(client):
|
||||
"""가져온 식 SK 는 M01 짝이 없음 — 저장 M01판이 있어도 시트 「M01 바뀜」 · 짝잃음 안 띄움."""
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
|
||||
client.app.include_router(sangeun_router.router)
|
||||
assert _post(client).status_code == 200
|
||||
name = _open(client).json()["이름"]
|
||||
folder = layers.personal_dir(7, 42)
|
||||
with store.at(folder):
|
||||
doc = store.read("sangeun", name)["문서"]
|
||||
spots = list(calc.calc_doc(doc)["시트"]["자리"])
|
||||
ans = calc.calc_doc({**doc, "M01판": {k: "다름" for k in [*spots, "x"]}})
|
||||
sheet = ans["시트"]
|
||||
assert sheet["자리"] and not any(x["M01바뀜"] for x in sheet["자리"].values())
|
||||
assert sheet["짝잃음"] == []
|
||||
|
||||
Reference in New Issue
Block a user