feat(848-1): 겹쳐 덮는 층 — SK 수식.위덮음 · 칸 단위 합침 · 위 층 대조 지움 · M01 기초 덮음 저장 · 빌더 이어받기

- 층 셈(파이썬 · TS 짝 master_doc_cover ↔ common_util_formula_doc_cover): merge 에 작업량 칸 단위(merge_work) · merge_layers · layeredCover · upper_of · sources · prune(…, upper) · prune_work_layer
- prune_doc(…, upper): 작업량 · 굳은 기계를 얹고 정본 셈 · 문서 안(선택 목록 · 따옴표 글 · 변수 기호)에 든 열쇠 고침은 안 불려도 남김
- SK: 셈 cover = ① 위덮음 + ② 문서 기계덮음(사본 셈 · 빈틈 · 연결 기록) · 프로젝트 층 밖 = 지금 기초 것 · 저장 때 굳음 · 굳히기 = 그때 기초 것 · derive 는 기초 덮음을 떼고 복사 · 읽기 답에 위덮음
- M01 저장: 기계덮음 검사 · 정본과 같은 칸 지움 · 빌더 결과와 셈 칸이 다르면 손고침 표지
- 빌더: 저장본 기계덮음 이어받음 · 손고침 문서 저장본 그대로 + 목록
- 시험 test_848_1_cover_layers(거울 36 경우 · M01 · SK · 굳힘 · A→B)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-16 20:19:31 +09:00
co-authored by Claude Opus 5.5
parent f7df6e3ca1
commit c33d200a68
12 changed files with 906 additions and 52 deletions
+41
View File
@@ -7,6 +7,8 @@
- 읽기 {키} → {문서, 셈, 연결, 파일, 새} — 문서가 없으면 빈 문서(이름 · 단위 = 로직 줄)
- 미리 셈 {문서, 입력} → {셈, 연결} — 쓰기 없음
- 저장 {문서} → {문서, 셈, 연결, 파일} — 서버가 정본으로 다시 셈 · 문서 파일에 씀(브라우저 셈 값 안 받음)
· 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) · 셈 칸이 빌더 결과와 같으면
빌더 글 + 기계덮음 · 다르면 받은 문서 + `손고침`(빌더가 안 덮음 · 같게 되돌려 저장하면 사라짐)
권한 = 라우터를 `main.py` 가 `system_admin_only` 로 붙임. M02 는 같은 꼴로 따로(802-4).
"""
@@ -20,6 +22,7 @@ from M01_MasterData import M01_MasterData_Store as store
import master_doc as md # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤
import master_doc_calc as mc # noqa: E402
import master_doc_cover as mcv # noqa: E402
import master_doc_link as ml # noqa: E402
import master_doc_record as mr # noqa: E402
import master_equation_link as link # noqa: E402
@@ -103,9 +106,47 @@ def _file_for(key: str) -> str:
return OWN_FILE
def built(key: str) -> dict | None:
"""빌더가 지을 그 키 문서(옛 로직 줄 변환 · `build_수식문서_802_2`) · 로직 줄 없음 · 변환 틀림 = None."""
import master_doc_convert as cv
files, whole = store.loaded()
for data in files.values():
if data.get("그룹") != "로직":
continue
for row in data.get("줄") or []:
if str(row.get("키")) == key:
try:
return cv.convert(whole, row)[0]
except Exception: # noqa: BLE001 — 변환 틀림 = 빌더 문서 없음(표지 안 담)
return None
return None
def layered(doc: dict, key: str) -> dict:
"""848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 ·
다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로."""
links = ml.Links(store.loaded()[1], {**docs(), key: doc})
try:
doc = mcv.prune_doc(doc, links)
except ValueError as e:
raise store.StoreError(400, str(e)) from e
cover = doc.get(mcv.COVER)
bare = {k: v for k, v in doc.items() if k not in (mcv.COVER, mcv.HAND)}
base = built(key)
hand = base is not None and ml._norm(bare) != ml._norm(base)
if base is not None and not hand:
bare = base
out = {**bare, **({mcv.HAND: True} if hand else {}), **({mcv.COVER: cover} if cover else {})}
if "쌓기" in out: # 줄 쌓기 차림 = 끝 칸(화면 `docOf` 와 같은 차례)
out["쌓기"] = out.pop("쌓기")
return out
def save(doc: dict) -> dict:
doc = _check(doc)
key = str(doc["키"]).strip()
doc = layered(doc, key)
name = _file_for(key)
path = folder() / name
data = ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []}
+18 -3
View File
@@ -6,7 +6,8 @@
{판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 자원 줄], ← 값 사본(`M02_Sangeun_Copy` 꼴)
부름 {키: 문서}(닫힌 묶음 — 연결 · [재생성] 때 새로) ·
SK 만: 문서(이 SK 문서 · 사용자 고침) · 끊음 {키: 문서}(이 사본 안에 굳힌 부름 · 고칠 수 있음) ·
따로(문서를 수식 길로 고침 — 옛 칸에서 다시 짓지 않음)}
따로(문서를 수식 길로 고침 — 옛 칸에서 다시 짓지 않음) ·
위덮음(848-1 · ① 기초 `기계덮음` 사본 — 셈 cover = ① 위에 문서 `기계덮음`(②) · `cover_of`)}
셈 = `master_doc_calc.calc`(M01 과 같은 계산기) · 연결 = `master_doc_link.Links`(값 사본 색인 위) ·
[단가 갱신] = 자원 단가 줄만 지금 M01(`skc.refresh`) · 문서 그대로 · [재생성] = 지금 M01 문서로.
부름 문서 = 값 사본 줄이 지금 M01 줄과 같으면 M01 문서(`수식문서/`) · 다르면(만든 때 옛 줄) 그 줄을
@@ -36,6 +37,7 @@ import master_auto as mau # noqa: E402
import master_doc as md # noqa: E402
import master_doc_calc as mc # noqa: E402
import master_doc_convert as cv # noqa: E402
import master_doc_cover as mcv # noqa: E402
import master_doc_link as ml # noqa: E402
import master_doc_work as mw # noqa: E402
@@ -139,10 +141,23 @@ def docs_of(copy: dict) -> dict[str, dict]:
return {**(copy.get("부름") or {}), **(copy.get("끊음") or {})}
def cover_of(copy: dict, doc: dict | None = None) -> dict:
"""셈 cover(848-1) — ① `위덮음` 위에 ② 문서 `기계덮음` · ① 없음 = 문서 칸 그대로."""
return mcv.merge_layers(
copy.get(mcv.UPPER), mcv.cover_of(copy.get("문서") if doc is None else doc)
)
def upper_calls(copy: dict) -> list[str]:
"""① 위 층 덮음의 시간당 작업량 식 · 굳은 기계 식 문서 키(부름 닫힌 묶음에 더함 · 848-1)."""
return mw.cover_calls({mcv.COVER: copy.get(mcv.UPPER) or {}})
def run(doc: dict, copy: dict, given: dict | None = None, whole: Any = None) -> dict:
"""문서 셈 — 연결 = 값 사본 · 부름 = 사본 문서(끊음 먼저)."""
"""문서 셈 — 연결 = 값 사본 · 부름 = 사본 문서(끊음 먼저) · cover = ① + ②(`cover_of`)."""
try:
return mc.calc(doc, ml.Links(whole or over(copy), docs_of(copy)), given)
links = ml.Links(whole or over(copy), docs_of(copy))
return mc.calc(doc, links, given, cover=cover_of(copy, doc))
except _ERR as e: # 계산기는 예외 없음이 원칙 — 남은 틈도 금액 「—」 로
return {"셈됨": False, "표지": [{"갈래": "셈 틀림", "글": str(e)}], **dict.fromkeys(COSTS)}
+1 -1
View File
@@ -52,7 +52,7 @@ def gaps(copy: dict) -> list[str]:
return []
seen = _Seen(dc.over(copy))
try:
dc.mc.calc(copy["문서"], dc.ml.Links(seen, dc.docs_of(copy)))
dc.mc.calc(copy["문서"], dc.ml.Links(seen, dc.docs_of(copy)), cover=dc.cover_of(copy))
except dc._ERR:
pass
have = _have(copy)
+1 -1
View File
@@ -32,7 +32,7 @@ def record(copy: dict) -> dict[str, Any]:
rec = mr.Rec(dc.ml.Links(dc.over(copy), dc.docs_of(copy)))
try:
rec.prefetch(copy["문서"])
dc.mc.calc(copy["문서"], rec)
dc.mc.calc(copy["문서"], rec, cover=dc.cover_of(copy)) # ① + ②(848-1)
except dc._ERR: # 셈 틀림 = 셈 답 표지(`dc.run`) — 기록은 모은 데까지
pass
return rec.out()
+40 -4
View File
@@ -11,6 +11,9 @@ SK `수식`(꼴 = `M02_Doc_Copy`) — `문서` = 이 SK 문서(키 = SK 키 ·
SK 금액(기준 · 1 단위 = 기준 ÷ 배) = 문서 셈 — 일위대가 · 사전조합 · 구조물 조합이 이 값을 씀.
가져온 식 SK(807-1) = `M02_Doc_Import` 문서(파생 = 가져온 줄 + SK 고침에서 지음 · 따로 =
저장본) · 셈 = 단가기준(엑셀 = 엑셀 값 · 우리 = 연결 값) · 바탕 참조 SK = 옛 길(값 사본 없음).
위 층 덮음(848-1) = `수식.위덮음`(① · 기초 문서 `기계덮음` 사본 · 문서 `기계덮음` = ② 내 고침만) —
프로젝트 층 밖 = 셈마다 지금 기초 것(`upper`) · [저장] 때 굳음 · 프로젝트 층 · 가져온 식 = 저장본 ·
파생 문서(`derive`)는 기초 문서의 `기계덮음` 을 떼고 복사(② 와 안 섞임).
"""
from __future__ import annotations
@@ -29,7 +32,10 @@ from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
import master_doc_cover as mcv # noqa: E402 — scripts 길 = dc
KEY = dc.KEY
UPPER = mcv.UPPER
OLD_FIELDS = (
"바탕", "입력값", "열린입력", "덮개", "뺀줄", "더한줄", "뺀더한줄", "상수덮개", "표값덮개",
"수식고침", "고름", "자재표시", "켜쌓기율",
@@ -88,7 +94,7 @@ def derive(sk: dict, ctx: tuple) -> dict:
same = False
plain = dc.doc_of(whole, base_key) if same else None
if plain is not None:
doc = cp.deepcopy(plain)
doc = cp.deepcopy({k: v for k, v in plain.items() if k != mcv.COVER}) # ① = `위덮음`(848-1)
_set_values(doc, given)
elif not (row.get("호표") or row.get("덧줄") or row.get("결과")):
doc = dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))
@@ -112,6 +118,30 @@ def seed(sk: dict) -> dict | None:
return {**empty, "문서": dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))}
def with_upper(sk: dict, got: dict) -> dict:
"""① 위 층 덮음을 지금 기초(`바탕.로직`) 문서 `기계덮음` 으로(848-1) — 없으면 칸 뺌 · 기초 문서 없음 = 그대로 ·
① 이 부르는 시간당 작업량 식 = 부름 닫힌 묶음에 더함."""
key = str((sk.get("바탕") or {}).get("로직") or "")
live = dc.folder().get(key) if key else None
if live is None:
return got
cover = mcv.cover_of(live)
if not cover:
return {k: v for k, v in got.items() if k != UPPER} if UPPER in got else got
out = {**got, UPPER: cp.deepcopy(cover)}
have = dc.docs_of(out)
if need := [k for k in dc.upper_calls(out) if k not in have]:
out["부름"] = {**(out.get("부름") or {}), **dc.closure(dc.over(out), need, have)}
return out
def upper(sk: dict, got: Any) -> Any:
"""셈 길의 ① — 프로젝트 층 밖 · 가져온 식 아님 = 지금 기초 것 · 그 밖 = 저장본(848-1)."""
if not isinstance(got, dict) or not renew.on() or dim.is_imported(sk):
return got
return with_upper(sk, got)
def copy_of(sk: dict, ctx: tuple | None) -> dict | None:
"""셈에 쓸 수식 사본 — 따로 = 저장본 · 파생 = 지금 옛 칸으로 다시 지은 문서(부름은 있던 것 먼저) ·
`OLD` 켬(옮기기 대조 · 시험) = 옛 길."""
@@ -120,7 +150,7 @@ def copy_of(sk: dict, ctx: tuple | None) -> dict | None:
got = sk.get(KEY) if dc.has(sk) else seed(sk)
if got is None:
return None
got = renew.form(sk, got) # M01 자동 따라옴(836-2)
got = upper(sk, renew.form(sk, got)) # M01 자동 따라옴(836-2) · ① 위 층 덮음(848-1)
if got.get("따로") or ctx is None:
return got
if dim.is_imported(sk): # 가져온 식 — 엑셀 단가 기준 줄에서 지음(우리 = 한 번 더 돎)
@@ -137,7 +167,7 @@ def copy_of(sk: dict, ctx: tuple | None) -> dict | None:
values = dc.values_of(sk[skc.KEY]) if skc.has(sk) else dc.values_of(got) # 서버가 정한 값
values = renew.rows(values) if renew.is_sk(sk) else values # 836-2
whole = dc.over(values)
calls = dc.closure(whole, dc.calls(root), got.get("부름"))
calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름"))
base = str((sk.get("바탕") or {}).get("로직") or "")
seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지)
origin = {"원본": {"키": base, "판": dc.fp(seen)}} if seen else {}
@@ -194,7 +224,9 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict:
return {**out, KEY: norm(mine["사본"])}
file = stored(out.get("키")) or {}
have = file.get(KEY) if dc.has(file) else (raw.get(KEY) if dc.has(raw) else None)
have = renew.form(out, have) if have else have # 836-2 — 바뀐 항목 고침 지움 · 저장 때 굳음
have = (
upper(out, renew.form(out, have)) if have else have
) # 836-2 · ① 위 층 덮음(848-1) — 저장 때 굳음
if have and have.get("따로") and job != skc.REGEN:
if file and old_fp(file) != old_fp(out):
raise sd.DocError(
@@ -216,6 +248,10 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict:
first = {**(dc.values_of(out[skc.KEY]) if skc.has(out) else {}), "부름": calls}
if job != skc.REGEN and (have or {}).get("끊음"): # 안 바뀐 항목 고침 = 그대로(836-2)
first["끊음"] = have["끊음"]
if (have or {}).get(
UPPER
): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1)
first[UPPER] = have[UPPER]
copy = copy_of({**out, KEY: first}, box[-1] if box else None)
if (
copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy))
+7 -2
View File
@@ -10,6 +10,8 @@ M01 수식 문서 길과 같은 꼴: 읽기 {문서, 셈} · 미리 셈 {문서}
가져온 식 SK(807-1) = 가져온 줄 문서 · 셈 = 단가기준(엑셀 값 · 연결 값) · 부름 · 끊음 없음
(형제 SK 는 셈 때 읽음) · 단가갱신 = 문서 그대로 · 바탕 참조 SK = 값 사본 없음(400).
저장 전 문서(836-5 · 불러오기 미리 보기 835-1) = 몸 `본`(그 SK 문서째) — 파일 안 읽음 · 안 씀 · 읽기 · 미리 셈만(`read_memory`).
위 층 덮음(848-1) = 답 몸 칸 `위덮음`(① · 화면 셈 cover = `layeredCover(문서, 위덮음)`) · 문서 `기계덮음` = ② ·
저장 = ② 를 ① + 정본과 견줘 같은 칸 지움(`prune_doc` 의 `upper`).
"""
from __future__ import annotations
@@ -89,6 +91,7 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]:
)
body = {
"문서": copy["문서"],
"위덮음": copy.get(dsk.UPPER) or {},
"부름": copy.get("부름") or {},
"끊음": copy.get("끊음") or {},
"셈": got,
@@ -152,8 +155,9 @@ def edited(copy: dict, body: dict, key: str, sk: dict | None = None) -> dict:
calls = [
*dc.calls(out["문서"]),
*(c for d in out.get("끊음", {}).values() for c in dc.calls(d)),
*dc.upper_calls(out), # ① 위 층 덮음 식(848-1)
]
try: # 기계 덮음(836-1) — 몸 검사 · 원본과 같은 칸 · 안 부르는 기계 뺌(가져온 식 = 검사만)
try: # 기계 덮음(836-1) — 몸 검사 · 위 층과 같은 칸 · 문서 밖 기계 뺌(가져온 식 = 검사만)
if dim.is_imported(sk):
got = mcv.clean(out["문서"].get(mcv.COVER))
rest = {k: v for k, v in out["문서"].items() if k != mcv.COVER}
@@ -163,7 +167,8 @@ def edited(copy: dict, body: dict, key: str, sk: dict | None = None) -> dict:
if not dim.is_imported(sk):
out["부름"] = dc.closure(dc.over(out), calls, copy.get("부름"))
try:
out["문서"] = mcv.prune_doc(out["문서"], dc.ml.Links(dc.over(out), dc.docs_of(out)))
links = dc.ml.Links(dc.over(out), dc.docs_of(out))
out["문서"] = mcv.prune_doc(out["문서"], links, out.get(dsk.UPPER)) # ② 대 ① + 정본
except ValueError as e:
raise _bad(str(e)) from e
out = gap.fill(out) # 셈이 읽은 줄 가운데 사본 없는 것 = 지금 값으로 박음(822-1)
+9 -1
View File
@@ -86,13 +86,21 @@ def freeze(copies: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]:
if got["켜쌓기율"] is not None:
frozen["켜쌓기율"] = prices.to_json(got["켜쌓기율"])
if isinstance(doc.get("수식"), dict): # 841-1 수식 문서(기계덮음) — 사본 셈 = M02
frozen["수식"] = doc["수식"]
frozen["수식"] = _upper(doc) # 848-1 ① 위덮음 = 굳힐 때 기초 것
out[rid] = frozen
for rid in sorted(rid for rid, doc in copies.items() if _patched(doc)):
out[rid] = _freeze_lines(rid, copies[rid], whole, read, taken)
return out
def _upper(doc: dict) -> dict:
"""SK `수식` — ① 위 층 덮음을 굳힐 때 기초 것으로(848-1 · 가져온 식 · 기초 문서 없음 = 저장본)."""
from M02_MasterTemplete import M02_Doc_Import as dim
from M02_MasterTemplete import M02_Doc_Sk as dsk
return doc["수식"] if dim.is_imported(doc) else dsk.with_upper(doc, doc["수식"])
def _patched(doc: Any) -> list[int]:
"""일위대가(SC) 사본의 덮개 줄(로직 줄 + `패치` · 740-1 SK 넣기 꼴) 차례."""
if not isinstance(doc, dict) or doc.get("종류") != refs.TITLE["precombo"]:
+172 -18
View File
@@ -8,8 +8,12 @@
* 셈 규칙(`coverDoc`) = 계산기가 기계 식을 부를 때 그 기계 덮음을 얹은 문서로 셈 — 덮음 없음 = 문서 그대로(금액 전후 같음)
* 기계 줄 목록(842-3 · `common_util_machine_crew`) = 바탕 덮음(`rowEntry` — 식 한 줄로 안 풀리는 부분만) ·
* 단가산출 덮음이 그 위에 부분별로 덮음(`mergeCover` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째)
* 겹쳐 덮는 층(848-1 · 틀 문서 10 절) = ⓪ 정본(기계 줄) → ① 위 층(M01 기초 `기계덮음` · SK `수식.위덮음`) →
* ② 내 고침(SK `수식.문서.기계덮음`) · 칸 단위 합침(`mergeCover` · `mergeLayers` · `layeredCover` — 작업량 = 방식 ·
* 식 · 변수 열쇠 · 기계 고정) · 층마다 위 층과 같은 칸 지움(`prune` · `putCover` 의 `upper`) · 위 층 값(`upperOf`) ·
* 출처(`sourcesOf`)
* 파이썬 · TS 짝 — 짝 = resources/master_data/scripts/master_doc_cover.py · 거울 시험 test_836_1_machine_cover.py ·
* test_842_3_machine_crew.py
* test_842_3_machine_crew.py · test_848_1_cover_layers.py
* · 화면 · DOM · fetch 없음
* ========================================================================== */
@@ -22,10 +26,18 @@ import {
type FormulaDoc,
type MoneyLine,
} from "./common_util_formula_doc";
import { WORK, pruneWork, type WorkCover } from "./common_util_formula_doc_work";
import { DAILY, HOURLY, WORK, type WorkCover } from "./common_util_formula_doc_work";
import { CREW, MISC, code as jobOf } from "./common_util_machine_crew";
export const COVER = "기계덮음";
/** SK `수식` 칸 — ① 위 층 고침(848-1 · 꼴 = `기계덮음`) */
export const UPPER = "위덮음";
/** M01 문서 칸 — 빌더 결과와 셈 칸이 다른 문서(빌더가 안 덮음 · 848-1) */
export const HAND = "손고침";
/** 출처(`sourcesOf`) — 없는 칸 = 정본 */
export const MINE = "나";
export const ABOVE = "위";
export type Source = typeof MINE | typeof ABOVE;
/** 값 칸에서 빼는 기계 칸 — 줄(조종원 · 잡품)로 다룸 */
export const NOT_VALUE = ["조종원", "조종원직종", "잡재료율"];
const HOUR = "Q_시간환산";
@@ -224,36 +236,174 @@ const sameVal = (a: unknown, b: unknown): boolean =>
? Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b))
: String(a) === String(b);
/** 기계 덮음 + 시간당 작업량(846-1 · `common_util_formula_doc_work`) — `MachineCover` 는 그대로(Required 꼴 지킴) */
/** 기계 덮음 + 시간당 작업량(846-1 · `common_util_formula_doc_work`) — `MachineCover` 는 그대로(Required 꼴 지킴) ·
* 848-1 한 층의 작업량은 바꾼 칸만 담을 수 있음(`방식` 없음 = 위 층 방식) — 읽을 때는 `mergeLayers` 답을 봄 */
export type CoverEntry = MachineCover & { [WORK]?: WorkCover };
/** 원본 기본값 + 작업량 기본 변수(`workDefaults` · 없으면 변수 그대로) */
export type CoverBase = Required<MachineCover> & { [WORK]?: Record<string, unknown> };
/** 위 층 값(`upperOf`) — 정본 기본 위에 ① · 작업량 = ① 층 그대로 */
export type UpperValue = Required<MachineCover> & { [WORK]?: WorkCover };
/** 작업량 한 층(848-1) — 바꾼 칸만(방식 없음 = 위 층 방식) */
export type WorkLayer = Partial<WorkCover>;
/** 원본과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 null */
export function prune(entry: CoverEntry, base: CoverBase): CoverEntry | null {
/** 위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 null —
* `base` = 정본 기본(`defaultsOf` · 작업량 = 그 식 기본 변수) · `upper` = ① 그 열쇠 칸(848-1 · 없음 = 정본 위) */
export function prune(
entry: CoverEntry,
base: CoverBase,
upper?: CoverEntry | null,
): CoverEntry | null {
const up = upperOf(base, upper);
const out: CoverEntry = {};
const vals = Object.entries(entry.값 ?? {}).filter(
([k, v]) =>
v !== null && v !== undefined && v !== "" && !(k in base.값 && sameVal(v, base.값[k])),
([k, v]) => v !== null && v !== undefined && v !== "" && !(k in up.값 && sameVal(v, up.값[k])),
);
if (vals.length) out.값 = Object.fromEntries(vals);
if (entry.조종원 && canon(entry.조종원) !== canon(base.조종원)) out.조종원 = entry.조종원;
if (entry.잡품 && canon(entry.잡품) !== canon(base.잡품)) out.잡품 = entry.잡품;
const work = pruneWork(entry[WORK], base[WORK] ?? null);
if (work) out[WORK] = work;
if (entry.조종원 && canon(entry.조종원) !== canon(up.조종원)) out.조종원 = entry.조종원;
if (entry.잡품 && canon(entry.잡품) !== canon(up.잡품)) out.잡품 = entry.잡품;
const work = pruneWorkLayer(entry[WORK], base[WORK] ?? null, upper?.[WORK] ?? null);
if (work) out[WORK] = work as WorkCover;
return Object.keys(out).length ? out : null;
}
/** 덮음 한 기계 고침 → 문서 칸(원본 대조로 정리 · 비면 칸 지움) */
// ── 층(848-1) ─────────────────────────────────────────────────────────
const FIXED = ["기계", "키", "이름"] as const;
const fixedOf = (w: WorkLayer): WorkLayer => {
const out: WorkLayer = {};
for (const k of FIXED) if (w[k]) out[k] = String(w[k]);
return out;
};
const sameNum = (a: unknown, b: unknown): boolean => {
const x = Number(a);
const y = Number(b);
return a !== "" && b !== "" && Number.isFinite(x) && Number.isFinite(y)
? Math.abs(x - y) <= 1e-9 * Math.max(1, Math.abs(x))
: String(a) === String(b);
};
/** 작업량 한 층 정리 — 위 층(`upper` = ① 작업량 칸 · 없음 = 정본 일당)과 같은 칸 뺌 · `base` = 그 식 기본 변수
* (`workDefaults`) · 일당 = 방식만 · 남는 것 없음 = null(위 층 없음 = `pruneWork` 와 같음) */
export function pruneWorkLayer(
want: WorkLayer | null | undefined,
base: Record<string, unknown> | null = null,
upper: WorkLayer | null = null,
): WorkLayer | null {
if (!want || typeof want !== "object") return null;
const up = upper ?? {};
const upWay = up.방식 || DAILY;
const way = want.방식 || upWay;
const out: WorkLayer = way !== upWay ? { 방식: way } : {};
if (way !== HOURLY) return Object.keys(out).length ? out : null;
const upForm = upWay === HOURLY ? String(up.식 ?? "") : "";
const form = String(want.식 ?? "") || upForm;
if (form !== upForm) out.식 = form;
const held = { ...(base ?? {}), ...(form === upForm ? (up.변수 ?? {}) : {}) };
const got = Object.entries(want.변수 ?? {}).filter(
([k, v]) => v !== null && v !== undefined && v !== "" && !(k in held && sameNum(v, held[k])),
);
if (got.length) out.변수 = Object.fromEntries(got);
const fix = fixedOf(want);
const upFix = upWay === HOURLY ? fixedOf(up) : {};
if (
Object.keys(fix).length &&
(!Object.keys(upFix).length || fix.기계 !== upFix.기계 || fix.키 !== upFix.키)
)
Object.assign(out, fix);
return Object.keys(out).length ? out : null;
}
/** 작업량 층 합침 — 아래 층(`low`)이 칸마다 이김(방식 · 식 · 변수 열쇠 · 기계 고정 한 덩이) ·
* 식을 바꾼 아래 층 = 위 층 변수 안 물려받음 */
export function mergeWork(
top: WorkLayer | null | undefined,
low: WorkLayer | null | undefined,
): WorkLayer | null {
if (!top || !Object.keys(top).length) return low && Object.keys(low).length ? low : null;
if (!low || !Object.keys(low).length) return top;
let out: WorkLayer = { ...top };
if (low.방식) out.방식 = low.방식;
if (low.식 && String(low.식) !== String(top.식 ?? "")) {
out.식 = low.식;
delete out.변수;
}
const vals = { ...(out.변수 ?? {}), ...(low.변수 ?? {}) };
if (Object.keys(vals).length) out.변수 = vals;
if (low.기계) {
out = Object.fromEntries(
Object.entries(out).filter(([k]) => !(FIXED as readonly string[]).includes(k)),
) as WorkLayer;
Object.assign(out, fixedOf(low));
}
return out;
}
/** ① 위 층 고침 위에 ② 내 고침(열쇠마다 `mergeCover`) — 계산기 `cover` 인자 · 위 층 없음 = ② 그대로 */
export function mergeLayers(
upper: Cover | null | undefined,
mine: Cover | null | undefined,
): Cover {
if (!upper || !Object.keys(upper).length) return mine ?? {};
if (!mine || !Object.keys(mine).length) return upper;
const out: Cover = {};
for (const k of [...Object.keys(upper), ...Object.keys(mine).filter((k) => !(k in upper))]) {
const got = mergeCover(upper[k], mine[k]);
if (got) out[k] = got;
}
return out;
}
/** 화면 셈 cover — 문서 칸 `기계덮음`(②) 을 ① 위에 얹음(SK = 읽기 답 `위덮음` · M01 = 없음) */
export const layeredCover = (doc: FormulaDoc, upper?: Cover | null): Cover =>
mergeLayers(upper, coverOf(doc));
/** 위 층 값 — 정본 기본(`defaultsOf`) 위에 ① 그 열쇠 칸 · 작업량 = ① 층 그대로(기본 변수는 `workDefaults`) */
export function upperOf(base: CoverBase, upper?: CoverEntry | null): UpperValue {
const { [WORK]: _, ...rest } = base;
const out: UpperValue = { ...rest };
if (!upper) return out;
out.값 = { ...base.값, ...(upper.값 ?? {}) };
if (upper.조종원) out.조종원 = upper.조종원;
if (upper.잡품) out.잡품 = upper.잡품;
if (upper[WORK]) out[WORK] = upper[WORK];
return out;
}
/** 칸 경로 → 출처(「위」 = ① · 「나」 = ②) · 없는 경로 = 정본 — `값.<칸>` · 조종원 · 잡품 · `작업량.방식` ·
* `작업량.식` · `작업량.변수.<열쇠>` · `작업량.기계` */
export function sourcesOf(
upper: CoverEntry | null | undefined,
mine: CoverEntry | null | undefined,
): Record<string, Source> {
let out: Record<string, Source> = {};
const upForm = String((upper?.[WORK] as WorkLayer | undefined)?.식 ?? "");
for (const [layer, tag] of [
[upper, ABOVE],
[mine, MINE],
] as const) {
const e = layer ?? {};
for (const k of Object.keys(e.값 ?? {})) out[`값.${k}`] = tag;
if (e.조종원) out.조종원 = tag;
if (e.잡품) out.잡품 = tag;
const w = (e[WORK] ?? {}) as WorkLayer;
if (tag === MINE && w.식 && String(w.식) !== upForm)
out = Object.fromEntries(Object.entries(out).filter(([k]) => !k.startsWith("작업량.변수.")));
for (const k of ["방식", "식", "기계"] as const) if (w[k]) out[`작업량.${k}`] = tag;
for (const k of Object.keys(w.변수 ?? {})) out[`작업량.변수.${k}`] = tag;
}
return out;
}
/** 덮음 한 기계 고침 → 문서 칸(위 층 대조로 정리 · 비면 칸 지움) — `upper` = ① 그 열쇠 칸(848-1 · SK) */
export function putCover(
doc: FormulaDoc,
machine: string,
entry: CoverEntry,
base: CoverBase,
upper?: CoverEntry | null,
): void {
const box = doc as Holder;
const all = { ...coverOf(doc) };
const kept = prune(entry, base);
const kept = prune(entry, base, upper);
if (kept) all[machine] = kept;
else delete all[machine];
if (Object.keys(all).length) box[COVER] = all;
@@ -388,17 +538,21 @@ export function rowEntry(doc: FormulaDoc, vals: Vals | null | undefined): Machin
return Object.keys(out).length ? out : null;
}
/** 바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) */
/** 바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) ·
* 작업량 = `mergeWork`(848-1) */
export function mergeCover(
base: MachineCover | null | undefined,
top: MachineCover | null | undefined,
): MachineCover | null {
base: CoverEntry | null | undefined,
top: CoverEntry | null | undefined,
): CoverEntry | null {
if (!base || !Object.keys(base).length) return top && Object.keys(top).length ? top : null;
if (!top || !Object.keys(top).length) return base;
const out: MachineCover = { ...base, ...top };
const out: CoverEntry = { ...base, ...top };
const 값 = { ...(base.값 ?? {}), ...(top.값 ?? {}) };
if (Object.keys(값).length) out.값 = 값;
else delete out.값;
const work = mergeWork(base[WORK], top[WORK]);
if (work) out[WORK] = work as WorkCover;
else delete out[WORK];
return out;
}
@@ -19,6 +19,8 @@
· 옛 로직 JSON 은 안 씀).
- 목록 = `docs/raw/요구_1104/_목록_802-2_변환대조.xlsx`(로직 · 옵션 · 옛 · 새 · 차이 · 까닭 + 요약).
- 이미 저장된 문서가 이번에 저장 밖(다름 · 부르는 문서 빠짐)이면 멈춤 — 안 씀 · 그 문서와 까닭을 알림(`lost`).
- 화면 고침 이어받기(848-1) — 저장본 `기계덮음`(그 기초의 ① 위 층 고침) = 키별로 새 문서에 얹음 ·
`손고침` 문서(M01 화면이 셈 칸을 고쳐 저장) = 저장본 그대로 · 실행 · `--check` 때 목록으로 알림.
"""
from __future__ import annotations
@@ -36,6 +38,7 @@ import master_cut as mcut # noqa: E402 — 옛 엔진(대조 쪽만)
import master_doc as md # noqa: E402
import master_doc_calc as mc # noqa: E402
import master_doc_convert as cv # noqa: E402
import master_doc_cover as mcv # noqa: E402
import master_doc_link as ml # noqa: E402
import master_equation as meq # noqa: E402
import master_formula as mf # noqa: E402
@@ -184,9 +187,33 @@ def build(log=print) -> dict:
"대조": runs,
"저장": keep,
"요약": summary,
"저장본": carried(),
}
def carried() -> dict[str, dict]:
"""이어받을 저장본 문서(848-1) — `기계덮음` 또는 `손고침` 이 있는 것 {키: 문서}."""
if not ml.FOLDER.exists():
return {}
return {k: d for k, d in ml.load_all().items() if d.get(mcv.COVER) or d.get(mcv.HAND)}
def hand_kept(result: dict) -> list[str]:
"""저장본 그대로 둔 `손고침` 문서 키(저장되는 것만)."""
have = result.get("저장본") or {}
return sorted(k for k, d in have.items() if d.get(mcv.HAND) and k in result["저장"])
def _out_doc(result: dict, key: str) -> dict:
"""쓸 문서 — `손고침` = 저장본 · 저장본 `기계덮음` = 새 문서에 얹음 · 그 밖 = 새 문서."""
have = (result.get("저장본") or {}).get(key)
if have and have.get(mcv.HAND):
return have
if have and have.get(mcv.COVER):
return {**result["문서"][key], mcv.COVER: have[mcv.COVER]}
return result["문서"][key]
def _calls(doc: dict) -> set[str]:
out = set()
for v in doc.get("변수") or []:
@@ -229,7 +256,7 @@ def files_of(result: dict) -> dict[str, str]:
"""저장 파일 이름 → 글."""
out = {}
for name, keys in result["파일"].items():
kept = [result["문서"][k] for k in keys if k in result["저장"]]
kept = [_out_doc(result, k) for k in keys if k in result["저장"]]
body = {"그룹": "수식문서", "로직파일": name, "줄": kept}
out[ml.file_of(name)] = ml.dump(body)
return out
@@ -323,6 +350,8 @@ def main() -> int:
parser.add_argument("--check", action="store_true", help="저장본 · 목록과 같은지만")
args = parser.parse_args()
result = build()
if hand := hand_kept(result):
print(f"손고침 {len(hand)} 장 — 저장본 그대로(빌더 안 덮음): {' · '.join(hand)}")
if args.check:
bad = check(result)
for line in bad:
+189 -21
View File
@@ -7,8 +7,11 @@
덮음 없음 = 문서 그대로(금액 전후 같음).
기계 줄 목록(842-3 · `master_machine_crew`) = 바탕 덮음(`row_entry` — 식 한 줄로 안 풀리는 부분만) ·
단가산출 덮음이 그 위에 부분별로 덮음(`merge` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째).
겹쳐 덮는 층(848-1 · 틀 문서 10 절) = ⓪ 정본(기계 줄) → ① 위 층(M01 기초 `기계덮음` · SK `수식.위덮음`) →
② 내 고침(SK `수식.문서.기계덮음`) · 칸 단위 합침(`merge` · `merge_layers` — 작업량 = 방식 · 식 · 변수 열쇠 ·
기계 고정) · 층마다 위 층과 같은 칸 지움(`prune` · `prune_doc` 의 `upper`) · 위 층 값(`upper_of`) · 출처(`sources`).
파이썬 · TS 짝 — 짝 = `common_util/common_util_formula_doc_cover.ts` · 거울 시험
`resources/tester/test_836_1_machine_cover.py` · `test_842_3_machine_crew.py`.
`resources/tester/test_836_1_machine_cover.py` · `test_842_3_machine_crew.py` · `test_848_1_cover_layers.py`.
"""
from __future__ import annotations
@@ -23,6 +26,9 @@ import master_doc_work as mw
import master_machine_crew as mcrew
COVER = "기계덮음"
UPPER = "위덮음" # SK `수식` 칸 — ① 위 층 고침(848-1)
HAND = "손고침" # M01 문서 칸 — 빌더 결과와 셈 칸이 다른 문서(빌더가 안 덮음 · 848-1)
MINE, ABOVE = "나", "위" # 출처(`sources`) — 없는 칸 = 정본
NOT_VALUE = (
"조종원",
"조종원직종",
@@ -192,24 +198,136 @@ def _same(a, b) -> bool:
return str(a) == str(b)
def prune(entry: dict, base: dict) -> dict | None:
"""원본과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 None."""
def prune(entry: dict, base: dict, upper: dict | None = None) -> dict | None:
"""위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 None —
`base` = 정본 기본(`defaults_of` · `작업량` = 그 식 기본 변수) · `upper` = ① 그 열쇠 칸(848-1 · 없음 = 정본 위)."""
up = upper_of(base, upper)
out: dict = {}
vals = {
k: v
for k, v in (entry.get("값") or {}).items()
if v not in (None, "") and not (k in base["값"] and _same(v, base["값"][k]))
if v not in (None, "") and not (k in up["값"] and _same(v, up["값"][k]))
}
if vals:
out["값"] = vals
for part in ("조종원", "잡품"):
if entry.get(part) is not None and _canon(entry[part]) != _canon(base[part]):
if entry.get(part) is not None and _canon(entry[part]) != _canon(up[part]):
out[part] = entry[part]
if work := mw.prune_work(entry.get(mw.WORK), base.get(mw.WORK)): # 846-1 시간당 작업량
work = prune_work_layer(entry.get(mw.WORK), base.get(mw.WORK), (upper or {}).get(mw.WORK))
if work: # 846-1 시간당 작업량
out[mw.WORK] = work
return out or None
# ── 층(848-1) ─────────────────────────────────────────────────────────
def _fixed(w: dict) -> dict:
return {k: str(w[k]) for k in mw.FIXED if w.get(k)}
def prune_work_layer(want, base: dict | None = None, upper: dict | None = None) -> dict | None:
"""작업량 한 층 정리 — 위 층(`upper` = ① 작업량 칸 · 없음 = 정본 일당)과 같은 칸 뺌 ·
`base` = 그 식 기본 변수(`mw.defaults`) · 일당 = 방식만 · 남는 것 없음 = None(위 층 없음 = `mw.prune_work` 와 같음)."""
if not isinstance(want, dict):
return None
up = upper if isinstance(upper, dict) else {}
up_way = up.get("방식") or mw.DAILY
way = want.get("방식") or up_way
out: dict = {"방식": way} if way != up_way else {}
if way != mw.HOURLY:
return out or None
up_form = str(up.get("식") or "") if up_way == mw.HOURLY else ""
form = str(want.get("식") or "") or up_form
if form != up_form:
out["식"] = form
held = {**(base or {}), **((up.get("변수") or {}) if form == up_form else {})}
got = {
k: v
for k, v in (want.get("변수") or {}).items()
if v not in (None, "") and not (k in held and mw._same(v, held[k]))
}
if got:
out["변수"] = got
fix, up_fix = _fixed(want), (_fixed(up) if up_way == mw.HOURLY else {})
if fix and (
not up_fix
or [fix.get(k) for k in ("기계", "키")] != [up_fix.get(k) for k in ("기계", "키")]
):
out |= fix
return out or None
def merge_work(top: dict | None, low: dict | None) -> dict | None:
"""작업량 층 합침 — 아래 층(`low`)이 칸마다 이김(방식 · 식 · 변수 열쇠 · 기계 고정 한 덩이) ·
식을 바꾼 아래 층 = 위 층 변수 안 물려받음."""
if not isinstance(top, dict) or not top:
return low if isinstance(low, dict) and low else None
if not isinstance(low, dict) or not low:
return top
out = dict(top)
if low.get("방식"):
out["방식"] = low["방식"]
if low.get("식") and str(low["식"]) != str(top.get("식") or ""):
out["식"] = low["식"]
out.pop("변수", None)
if vals := {**(out.get("변수") or {}), **(low.get("변수") or {})}:
out["변수"] = vals
if low.get("기계"):
out = {k: v for k, v in out.items() if k not in mw.FIXED} | _fixed(low)
return out
def merge_layers(upper: dict | None, mine: dict | None) -> dict:
"""① 위 층 고침 위에 ② 내 고침(열쇠마다 `merge`) — 계산기 `cover` 인자 · 위 층 없음 = ② 그대로."""
if not isinstance(upper, dict) or not upper:
return mine if isinstance(mine, dict) else {}
if not isinstance(mine, dict) or not mine:
return upper
out = {}
for k in [*upper, *(k for k in mine if k not in upper)]:
if got := merge(upper.get(k), mine.get(k)):
out[k] = got
return out
def upper_of(base: dict, upper: dict | None) -> dict:
"""위 층 값 — 정본 기본(`defaults_of`) 위에 ① 그 열쇠 칸 · 작업량 = ① 층 그대로(기본 변수는 `mw.defaults`)."""
out = {k: v for k, v in base.items() if k != mw.WORK}
if not upper:
return out
out["값"] = {**(base.get("값") or {}), **(upper.get("값") or {})}
for part in ("조종원", "잡품"):
if upper.get(part) is not None:
out[part] = upper[part]
if upper.get(mw.WORK):
out[mw.WORK] = upper[mw.WORK]
return out
def sources(upper: dict | None, mine: dict | None) -> dict[str, str]:
"""칸 경로 → 출처(「위」 = ① · 「나」 = ②) · 없는 경로 = 정본 — `값.<칸>` · 조종원 · 잡품 ·
`작업량.방식` · `작업량.식` · `작업량.변수.<열쇠>` · `작업량.기계`."""
out: dict[str, str] = {}
up_form = str(((upper or {}).get(mw.WORK) or {}).get("식") or "")
for layer, tag in ((upper, ABOVE), (mine, MINE)):
e = layer if isinstance(layer, dict) else {}
for k in e.get("값") or {}:
out[f"값.{k}"] = tag
for part in ("조종원", "잡품"):
if e.get(part) is not None:
out[part] = tag
w = e.get(mw.WORK) if isinstance(e.get(mw.WORK), dict) else {}
if (
tag == MINE and w.get("식") and str(w["식"]) != up_form
): # 식을 바꿈 = 위 층 변수 안 물려받음
out = {k: v for k, v in out.items() if not k.startswith("작업량.변수.")}
for k in ("방식", "식", "기계"):
if w.get(k):
out[f"작업량.{k}"] = tag
for k in w.get("변수") or {}:
out[f"작업량.변수.{k}"] = tag
return out
# ── 셈 규칙 ───────────────────────────────────────────────────────────
def _add_var(doc: dict, sign: str, low: str, name: str, key: str) -> str:
have = {md.var_id(v) for v in doc.get("변수") or []} | {
@@ -354,14 +472,17 @@ def row_entry(doc: dict, vals) -> dict | None:
def merge(base: dict | None, top: dict | None) -> dict | None:
"""바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만)."""
"""바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) ·
작업량 = `merge_work`(848-1)."""
if not base:
return top or None
if not top:
return base
out = {**base, **{k: v for k, v in top.items() if k != "값"}}
out = {**base, **{k: v for k, v in top.items() if k not in ("값", mw.WORK)}}
vals = {**(base.get("값") or {}), **(top.get("값") or {})}
return {**out, "값": vals} if vals else out
out = {**out, "값": vals} if vals else out
work = merge_work(base.get(mw.WORK), top.get(mw.WORK))
return {**out, mw.WORK: work} if work else out
def lists_of(links, given) -> dict:
@@ -425,32 +546,66 @@ def clean(raw) -> dict:
if part == "잡품" and not (r.get("줄") or r.get("키")):
raise ValueError(f"{COVER} 「{key}」 잡품 줄 — 재료(키) 또는 줄 필요")
one[part] = rows
if entry.get(mw.WORK) is not None:
one[mw.WORK] = mw.clean_work(entry[mw.WORK], f"{COVER} 「{key}」")
w = entry.get(mw.WORK)
if isinstance(w, dict) and not w.get("방식"): # 848-1 바꾼 칸만 담은 층(방식 = 위 층)
got = mw.clean_work({**w, "방식": mw.DAILY}, f"{COVER} 「{key}」")
got.pop("방식")
if got:
one[mw.WORK] = got
elif w is not None:
one[mw.WORK] = mw.clean_work(w, f"{COVER} 「{key}」")
if one:
out[str(key)] = one
return out
def prune_doc(doc: dict, links) -> dict:
"""서버 정리 — 덮음을 검사하고 원본과 같은 칸 · 줄 · 기계를 뺀 문서(새 문서 · 덮음 없음 = 그대로).
원본 = 덮음 뺀 문서 셈의 부름 메모(그 기계 식 · 입력 · 원본 답)."""
def _quoted(text) -> set[str]:
return set(re.findall(r"'([^']*)'", str(text or "")))
def listed(doc: dict) -> set[str]:
"""문서 안 덮음 열쇠 후보(848-1) — 선택 목록 · 입력 값 · 따옴표 글(식 · 부름 입력 · 금액) · 변수 기호."""
out: set[str] = set()
for v in doc.get("변수") or []:
out.add(md.var_id(v))
link = v.get("연결") or {}
out |= {str(x) for x in link.get("목록") or []}
if isinstance(link.get("값"), str):
out.add(link["값"])
for x in (link.get("입력") or {}).values():
out |= _quoted(x)
for x in doc.get("식") or []:
out |= _quoted(x.get("식"))
for x in doc.get("금액") or []:
out |= _quoted(x.get("수량")) | _quoted(x.get("단가"))
return out
def prune_doc(doc: dict, links, upper: dict | None = None) -> dict:
"""서버 정리 — 덮음을 검사하고 위 층과 같은 칸 · 줄 · 기계를 뺀 문서(새 문서 · 덮음 없음 = 그대로).
정본 = 덮음 뺀 문서 셈의 부름 메모(그 기계 식 · 입력 · 원본 답 · 작업량 · 굳은 기계는 얹고 셈) ·
`upper` = ① 위 층 고침(SK `수식.위덮음` · 848-1) · 이번 셈이 안 부른 열쇠 = 문서 안에 들면(`listed`) 그대로 남김."""
import master_doc_calc as mc
cover = clean(doc.get(COVER))
rest = {k: v for k, v in doc.items() if k != COVER}
if not cover:
return rest
upper = upper if isinstance(upper, dict) else {}
both = merge_layers(upper, cover)
steer = {k: {mw.WORK: e[mw.WORK]} for k, e in both.items() if (e or {}).get(mw.WORK)}
memo: dict = {}
top = mc.calc(rest, links, None, (), memo)
kept: dict = {} # 문서가 안 부르는 기계 덮음 = 뺌
top = mc.calc(rest, links, None, (), memo, steer)
kept: dict = {}
seen: set[str] = set() # 값 · 조종원 · 잡품을 견준 열쇠
for (key, given), ans in memo.items():
m = machine_key(dict(given))
sub = links.doc(key) if m in cover and m not in kept else None
if not sub or not is_machine(sub):
continue
seen.add(m)
base = defaults_of(sub, ans.get("값") or {}, row_entry(sub, lists_of(links, dict(given))))
if one := prune({k: v for k, v in cover[m].items() if k != mw.WORK}, base):
if one := prune({k: v for k, v in cover[m].items() if k != mw.WORK}, base, upper.get(m)):
kept[m] = one
works: dict = {} # 작업량(846-1) = 기계 줄 답이 읽은 작업 기계(부착 기계 포함) · 847-1 단가 기호 열쇠도
for a in (top, *memo.values()):
@@ -460,11 +615,24 @@ def prune_doc(doc: dict, links) -> dict:
if w.get("기호"):
works.setdefault(w["기호"], w["기계"])
for m in sorted(set(works) & set(cover)):
want = cover[m].get(mw.WORK)
if want and (
one := mw.prune_work(want, _work_base(links, want.get("기계") or works[m], want))
):
if not (want := cover[m].get(mw.WORK)):
continue
seen.add(f"{m}\n{mw.WORK}")
up = (upper.get(m) or {}).get(mw.WORK) or {}
eff = merge_work(up, want) or {}
if eff.get("방식") == mw.HOURLY and not eff.get("식"):
raise ValueError(f"{COVER} 「{m}」 작업량 — 시간당은 식 키 필요")
base = _work_base(links, eff.get("기계") or works[m], eff)
if one := prune_work_layer(want, base, up):
kept[m] = {**kept.get(m, {}), mw.WORK: one}
names = listed(rest) | {
str(e[mw.WORK]["기계"]) for e in steer.values() if e[mw.WORK].get("기계")
}
for m in [m for m in cover if m in names]: # 안 부른 열쇠 — 문서 안에 들면 그대로
if m not in seen and (vals := {k: v for k, v in cover[m].items() if k != mw.WORK}):
kept[m] = {**vals, **kept.get(m, {})}
if f"{m}\n{mw.WORK}" not in seen and cover[m].get(mw.WORK):
kept[m] = {**kept.get(m, {}), mw.WORK: cover[m][mw.WORK]}
return {**rest, COVER: kept} if kept else rest
@@ -0,0 +1,36 @@
/* 848-1 겹쳐 덮는 층 거울 헬퍼 — common_util_formula_doc_cover.ts 를 그 자리에서 트랜스파일해 Node 로 돌림.
* stdin = {경우: [{위, 나, 기본}]}
* stdout = {답: [{합침: mergeCover, 층: mergeLayers, 정리: prune, 위값: upperOf, 출처: sourcesOf}]} */
const fs = require("fs");
const path = require("path");
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
const cache = new Map();
function load(at) {
if (cache.has(at)) return cache.get(at);
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
}).outputText;
const box = { exports: {} };
cache.set(at, box.exports);
const need = (p) =>
p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p);
new Function("exports", "module", "require", js)(box.exports, box, need);
return box.exports;
}
const cover = load(path.join(__dirname, "..", "..", "common_util", "common_util_formula_doc_cover.ts"));
const input = JSON.parse(fs.readFileSync(0, "utf8"));
const out = { 답: [] };
for (const one of input.경우 || []) {
const up = one.위 ?? null;
const me = one.나 ?? null;
out.답.push({
합침: cover.mergeCover(up, me),
층: cover.mergeLayers(up ? { K: up } : null, me ? { K: me } : null),
정리: me ? cover.prune(me, one.기본, up) : null,
위값: cover.upperOf(one.기본, up),
출처: cover.sourcesOf(up, me),
});
}
process.stdout.write(JSON.stringify(out));
+362
View File
@@ -0,0 +1,362 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""848-1 겹쳐 덮는 층(요구 889 · 요구서_889 1 절) — 층 셈 거울 · M01 기초 고침 저장 · SK 위 층 덮음 · 빌더 이어받기.
① 거울 — 합침 · 층 합침 · 정리(위 층 대조) · 위 층 값 · 출처가 파이썬 = TS(손셈 기대값 몇 개 + 전수 대조).
㉠ M01 기초 고침(가격 · 조종원 · 작업량 시간당 + 변수) = 그 기초 셈만 바뀜 · 다른 기초 · 기계 정본 그대로 ·
문서 밖 기계 고침 뺌 · ㉥ 빌더 이어받기(덮음 얹음 · 손고침 문서 그대로 + 목록 · 같게 되돌리면 표지 없음) ·
㉣ 정본 값으로 되돌림 = 고침 0 · 문서 바이트 = 고침 전.
㉡ 그 기초로 만든 SK = 위덮음 · 금액 = 기초 금액 · SK 고침 = ② 에만 · 금액 = ① + ② 셈 · 출처 ·
㉢ ② 를 위 층 값으로 = ② 0 · ㉤ 옵션으로 기계를 바꿔 저장해도 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐 ·
㉦ 프로젝트로 굳힘 = 굳힐 때 금액(기초가 그 뒤 바뀌어도).
㉧ 기초 A 가 B 를 부를 때 A 의 고침만 A 셈에.
정본 파일 안 고침 — 수식 문서 폴더 = 임시 사본 · 층 = 임시 storage.
"""
import copy as cp
import importlib
import json
import os
import shutil
import subprocess
from decimal import Decimal as D
import pytest
from M01_MasterData import M01_MasterData_Doc as m01doc
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Item_Prices as item_prices
from M02_MasterTemplete import M02_Item_Source as source
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Labor_SkRow as skrow
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
mc = importlib.import_module("master_doc_calc")
ml = importlib.import_module("master_doc_link")
mcv = importlib.import_module("master_doc_cover")
cv = importlib.import_module("master_doc_convert")
build = importlib.import_module("build_수식문서_802_2")
HERE = os.path.dirname(os.path.abspath(__file__))
COVER = mcv.COVER
BASE = "GC000088" # 터파기(기계) 보통토사 — 굴착기 줄 하나(TypeⅠ = 1.0㎥ · TypeⅢ = 0.6㎥)
NO, NO3 = "0201-0100", "0201-0060"
SYM = "P_굴착기무한궤" # 그 줄 단가 기호 = 작업량 덮음 열쇠(847-1)
TPL = "GC001147" # 굴착기 시간당 작업량 식
# ── ① 거울 ────────────────────────────────────────────────────────────
BASE0 = {"값": {"가격": 100, "주연료": 10}, "조종원": [{"키": "LB:1", "인": 1}],
"잡품": [{"줄": "주연료", "율": 22}], "작업량": {"f": 0.7, "E": 0.5}} # fmt: skip
U1 = {"값": {"가격": 150}, "조종원": [{"키": "LB:1", "인": 2}],
"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8}}} # fmt: skip
U2 = {"작업량": {"방식": "시간당", "식": "T1", "기계": NO3, "이름": "굴착기 0.6㎥"}}
MINES = [
None,
{"값": {"가격": 150, "주연료": 20}},
{"값": {"가격": 100}},
{"조종원": [{"키": "LB:1", "인": 2}]},
{"조종원": [{"키": "LB:1", "인": 1}]},
{"잡품": []},
{"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8, "E": 0.5}}},
{"작업량": {"방식": "일당"}},
{"작업량": {"방식": "시간당", "식": "T2", "변수": {"f": 0.8}}},
{"작업량": {"변수": {"E": 0.6}}},
{"작업량": {"방식": "시간당", "식": "T1", "기계": NO3, "이름": "굴착기 0.6㎥"}},
{"작업량": {"방식": "시간당", "식": "T1", "기계": NO, "이름": "굴착기 1.0㎥"}},
]
def test_층_합침_정리_출처_손셈():
p = mcv.prune
assert p({"값": {"가격": 150, "주연료": 20}}, BASE0, U1) == {"값": {"주연료": 20}}
assert p({"값": {"가격": 100}}, BASE0, U1) == {"값": {"가격": 100}} # 정본 값 = 위 층과 다름
assert p({"값": {"가격": 100}}, BASE0) is None # 위 층 없음 = 지금과 같음
assert p({"조종원": [{"키": "LB:1", "인": 2}]}, BASE0, U1) is None
assert (
p({"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8, "E": 0.5}}}, BASE0, U1)
is None
)
assert p({"작업량": {"방식": "일당"}}, BASE0, U1) == {"작업량": {"방식": "일당"}}
assert p({"작업량": {"방식": "일당"}}, BASE0) is None
want = {"작업량": {"식": "T2", "변수": {"f": 0.8}}} # 식 바꿈 = 위 층 변수 안 물려받음
assert p({"작업량": {"방식": "시간당", "식": "T2", "변수": {"f": 0.8}}}, BASE0, U1) == want
assert p({"작업량": {"변수": {"E": 0.6}}}, BASE0, U1) == {"작업량": {"변수": {"E": 0.6}}}
assert p(U2, BASE0, U2) is None and p(U2, BASE0) == U2
assert mcv.merge(U1, {"작업량": {"식": "T2"}})["작업량"] == {"방식": "시간당", "식": "T2"}
assert mcv.merge(U1, {"작업량": {"방식": "일당"}})["작업량"]["방식"] == "일당"
assert mcv.merge(U2, {"작업량": {"기계": NO}})["작업량"] == {
"방식": "시간당",
"식": "T1",
"기계": NO,
}
got = mcv.sources(U1, {"값": {"주연료": 20}, "작업량": {"변수": {"E": 0.6}}})
assert got == {"값.가격": "위", "조종원": "위", "작업량.방식": "위", "작업량.식": "위",
"작업량.변수.f": "위", "값.주연료": "나", "작업량.변수.E": "나"} # fmt: skip
assert mcv.sources(U1, {"작업량": {"식": "T2"}})["작업량.식"] == "나"
assert "작업량.변수.f" not in mcv.sources(U1, {"작업량": {"식": "T2"}})
assert mcv.upper_of(BASE0, U1) == {"값": {"가격": 150, "주연료": 10}, "조종원": U1["조종원"],
"잡품": BASE0["잡품"], "작업량": U1["작업량"]} # fmt: skip
mine = {"개인 EQP000001": {"값": {"가격": 1}}} # 내 기계 열쇠 = 같은 꼴
assert mcv.merge_layers(None, mine) is mine and mcv.merge_layers(mine, {}) is mine
assert mcv.merge_layers({"개인 EQP000001": U1}, mine)["개인 EQP000001"]["값"] == {"가격": 1}
def _same(a, b, where=""):
if isinstance(a, dict):
assert isinstance(b, dict) and set(a) == set(b), (where, a, b)
for k in a:
_same(a[k], b[k], f"{where}.{k}")
elif isinstance(a, list):
assert isinstance(b, list) and len(a) == len(b), (where, a, b)
for i, (x, y) in enumerate(zip(a, b)):
_same(x, y, f"{where}[{i}]")
elif isinstance(a, (int, float)) and not isinstance(a, bool):
assert float(a) == pytest.approx(b), (where, a, b)
else:
assert a == b, (where, a, b)
def test_거울_파이썬_TS_같은_답():
cases = [{"위": u, "나": m, "기본": BASE0} for u in (None, U1, U2) for m in MINES]
want = [
{
"합침": mcv.merge(c["위"], c["나"]),
"층": mcv.merge_layers(
{"K": c["위"]} if c["위"] else None, {"K": c["나"]} if c["나"] else None
),
"정리": mcv.prune(c["나"], BASE0, c["위"]) if c["나"] else None,
"위값": mcv.upper_of(BASE0, c["위"]),
"출처": mcv.sources(c["위"], c["나"]),
}
for c in cases
]
proc = subprocess.run(
["node", os.path.join(HERE, "helper_848_1_cover_layers.cjs")],
input=json.dumps({"경우": cases}, ensure_ascii=False),
capture_output=True,
text=True,
encoding="utf-8",
check=True,
)
got = json.loads(proc.stdout)["답"]
assert len(got) == len(want) == 36
for i, (a, b) in enumerate(zip(want, got)):
_same(a, b, f"경우{i}")
# ── 임시 수식 문서 폴더(정본 파일 안 고침) ──────────────────────────────
@pytest.fixture
def docs_tmp(tmp_path, monkeypatch):
dst = tmp_path / "수식문서"
shutil.copytree(ml.FOLDER, dst)
load = ml.load_all
monkeypatch.setattr(ml, "FOLDER", dst)
monkeypatch.setattr(ml, "load_all", lambda folder=dst: load(folder))
m01doc._memo.clear()
dc._FOLDER["자국"] = None
yield dst
m01doc._memo.clear()
dc._FOLDER["자국"] = None
def _json(v):
"""화면 왕복(JSON 수)."""
return json.loads(json.dumps(ml._norm(v), ensure_ascii=False))
def _norm(v):
return json.loads(json.dumps(ml._norm(v), ensure_ascii=False, sort_keys=True))
def _defaults() -> dict:
"""정본 — BASE 기본 옵션 굴착기(NO)의 덮음 없는 기본값."""
links = ml.Links(m01.loaded()[1])
memo: dict = {}
doc = {k: v for k, v in links.doc(BASE).items() if k != COVER}
mc.calc(doc, links, None, (), memo)
for (key, given), ans in memo.items():
if mcv.is_machine(sub := links.doc(key)) and mcv.machine_key(dict(given)) == NO:
lists = mcv.lists_of(links, dict(given))
return mcv.defaults_of(sub, ans["값"], mcv.row_entry(sub, lists))
raise AssertionError("굴착기 부름 없음")
def _upper(d: dict, rate=D("1.5")) -> dict:
"""기초 고침 ① — 가격 · 조종원 · 작업량(시간당 + 변수 f)."""
return {NO: {"값": {"가격": float(D(str(d["값"]["가격"])) * rate)},
"조종원": [{"키": d["조종원"][0]["키"], "인": 2}]},
SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.8}}}} # fmt: skip
def _save_m01(cover: dict | None, edit=None) -> dict:
doc = _json(m01doc.read(BASE)["문서"])
doc.pop(COVER, None)
if cover:
doc[COVER] = _json(cover)
if edit:
edit(doc)
return m01doc.save(doc)
def _calls(key: str) -> bool:
return any(
(v.get("연결") or {}).get("키") == "GC000267" for v in m01doc.docs()[key].get("변수") or []
)
def _mini():
"""빌더 한 로직 파일 몫(BASE 가 든 파일) — {결과, 쓸 글, 파일}."""
files, whole = m01.loaded()
name = next(
n
for n, d in files.items()
if d.get("그룹") == "로직" and any(str(r.get("키")) == BASE for r in d.get("줄") or [])
)
rows = files[name]["줄"]
keys = [str(r["키"]) for r in rows]
result = {
"문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows},
"파일": {name: keys},
"저장": set(keys) & build.saved_keys(),
"저장본": build.carried(),
}
return result, build.files_of(result)[ml.file_of(name)], ml.FOLDER / ml.file_of(name)
def test_M01_기초_고침_빌더_이어받기_되돌림(docs_tmp):
d = _defaults()
result, text, file = _mini()
orig = file.read_bytes()
assert text == file.read_text(encoding="utf-8") # 고침 없음 = 빌더 글 = 저장본
other = next(k for k in sorted(m01doc.docs()) if k != BASE and _calls(k))
before, other_before = m01doc.read(BASE)["셈"]["계"], m01doc.read(other)["셈"]["계"]
price = m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"]
# ㉠ 고침 저장 — 문서 밖 기계(9999) = 뺌
want = _upper(d)
got = _save_m01({**want, "9999-9999": {"값": {"가격": 1}}})
saved = ml.load_all()[BASE]
assert _norm(saved[COVER]) == _norm(want) and mcv.HAND not in saved
assert got["셈"]["계"] != before and m01doc.read(BASE)["셈"]["계"] == got["셈"]["계"]
assert m01doc.read(other)["셈"]["계"] == other_before # 다른 기초 그대로
assert m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"] == price # 기계 정본 그대로
line = next(x for x in got["셈"]["줄"] if x.get("작업량"))
assert line["작업량"]["꼴"] == "시간당" and str(line["작업량"]["변수"]["f"]) == "0.8"
# ㉥ 빌더 — 덮음 얹음(글 = 저장본)
result, text, _ = _mini()
assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == []
# ㉥ 손고침 — 줄 식을 고친 문서 = 저장본 그대로 + 목록 · 같게 되돌리면 표지 없음
def qty(text_):
return lambda doc: doc["금액"][0].update({"수량": text_})
first = m01doc.read(BASE)["문서"]["금액"][0]["수량"]
_save_m01(want, qty("Q_굴착기^표 × 9 ÷ Q_시공"))
assert ml.load_all()[BASE].get(mcv.HAND) is True
result, text, _ = _mini()
assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == [BASE]
_save_m01(want, qty(first))
assert mcv.HAND not in ml.load_all()[BASE]
# ㉣ 정본 값으로 되돌림 = 고침 0 · 바이트 = 고침 전
back = {NO: {"값": {"가격": float(d["값"]["가격"])}, "조종원": d["조종원"]},
SYM: {"작업량": {"방식": "일당"}}} # fmt: skip
got = _save_m01(back)
assert COVER not in got["문서"] and file.read_bytes() == orig
assert got["셈"]["계"] == before
def _sk(me) -> str:
with store.at(me):
body = skrow.logic_doc({"로직": BASE, "입력값": {}}, {}, m01.loaded()[1])
return refs.create("sangeun", {**body, "이름": "sub2임시 848"})["이름"]
def _at(me, fn, *args):
with store.at(me):
return fn(*args)
def _mixed_sum(cover: dict) -> float:
"""기초 문서(덮음 뗌)에 cover 를 얹은 셈 계 — SK 금액 대조."""
links = ml.Links(m01.loaded()[1])
doc = {k: v for k, v in links.doc(BASE).items() if k != COVER}
return float(mc.calc(doc, links, None, (), None, cover)["계"])
def test_SK_위덮음_내고침_되돌림_옵션_굳힘(docs_tmp, world):
me = world["personal"]
d = _defaults()
upper = _upper(d)
_save_m01(upper)
base_sum = float(m01doc.read(BASE)["셈"]["계"])
key = _sk(me)
got = _at(me, path.read, key)
# ㉡ ① = 위덮음 · 금액 = 기초 금액 · 파일에 굳음
assert _norm(got["위덮음"]) == _norm(upper) and COVER not in got["문서"]
assert float(got["셈"]["계"]) == base_sum
with store.at(me):
file = store.read("sangeun", key)["문서"]["수식"]
assert _norm(file[mcv.UPPER]) == _norm(upper)
# SK 에서 한 칸 더 고침 → ② 에만(① 과 같은 가격 = 지움 · 작업량 = 바꾼 변수만)
doc = cp.deepcopy(got["문서"])
doc[COVER] = {NO: {"값": {"가격": upper[NO]["값"]["가격"], "주연료": 20}},
SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.9}}}} # fmt: skip
after = _at(me, path.save, key, {"문서": doc, "판": got["판"]})
mine = {NO: {"값": {"주연료": 20}}, SYM: {"작업량": {"변수": {"f": 0.9}}}}
assert _norm(after["문서"][COVER]) == _norm(mine) and _norm(after["위덮음"]) == _norm(upper)
assert float(after["셈"]["계"]) == _mixed_sum(mcv.merge_layers(upper, mine)) != base_sum
assert mcv.sources(upper[NO], mine[NO]) == {"값.가격": "위", "조종원": "위", "값.주연료": "나"}
assert mcv.sources(upper[SYM], mine[SYM]) == {
"작업량.방식": "위", "작업량.식": "위", "작업량.변수.f": "나"
} # fmt: skip
# ㉦ 프로젝트로 굳힘 = 굳힐 때 금액(기초가 그 뒤 바뀌어도)
with store.at(me):
here = refs.here()
ref = {"층": here[0], "주인": here[1], "키": key}
rows = source.labor_doc_rows(
{"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]}
)
bundle = source.price_bundle(rows, me)
frozen = rows["참조사본"][refs.ref_id(ref)]["수식"]
assert _norm(frozen[mcv.UPPER]) == _norm(upper)
was = float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"])
assert was == float(after["셈"]["계"])
_save_m01(_upper(d, D(2))) # 기초 고침이 바뀜
now = _at(me, path.read, key)
assert float(now["셈"]["계"]) != was # 프로젝트 밖 = 지금 기초 것
assert float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) == was # 사본 = 굳은 것
_save_m01(upper)
# ㉢ ② 를 위 층 값으로 = ② 0
now = _at(me, path.read, key)
doc = cp.deepcopy(now["문서"])
doc[COVER] = {NO: {"값": {"주연료": d["값"]["주연료"]}},
SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.8}}}} # fmt: skip
back = _at(me, path.save, key, {"문서": doc, "판": now["판"]})
assert COVER not in back["문서"] and float(back["셈"]["계"]) == base_sum
with store.at(me):
assert COVER not in store.read("sangeun", key)["문서"]["수식"]["문서"]
# ㉤ 옵션으로 기계를 바꿔 저장 = 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐
doc = cp.deepcopy(back["문서"])
next(v for v in doc["변수"] if v["열쇠"] == "Type")["연결"]["값"] = "TypeⅢ"
doc[COVER] = {NO: {"값": {"주연료": 20}}, "9999-9999": {"값": {"가격": 1}}}
moved = _at(me, path.save, key, {"문서": doc, "판": back["판"]})
assert moved["문서"][COVER] == {NO: {"값": {"주연료": 20}}}
line = next(x for x in moved["셈"]["줄"] if x.get("작업량"))
assert line["작업량"]["기계"] == NO3 # 셈은 바꾼 기계(앞 기계 고침은 안 걸림)
def test_A_가_B_를_부를_때_A_고침만():
links = ml.Links(m01.loaded()[1])
a, b, no = "GF000177", "GF000168", "0201-0070"
price = float(m01.loaded()[1].numbers["EQ"][no]["값"]["가격"])
cover = {no: {"값": {"가격": price * 2}}}
given = {"기초잡석량": D(1)} # A(날개벽) 기초잡석 1 ㎥ = B(기초잡석) 부름
plain_a = mc.calc(links.doc(a), links, given)["계"]
plain_b = mc.calc(links.doc(b), links)["계"]
assert plain_a > 0
with_b = ml.Links(m01.loaded()[1], {**links.docs, b: {**links.doc(b), COVER: cover}})
assert mc.calc(with_b.doc(a), with_b, given)["계"] == plain_a # B 의 고침 = A 셈에 안 걸림
assert mc.calc(with_b.doc(b), with_b)["계"] != plain_b # B 를 맨 위로 열면 걸림
mine = mc.calc({**links.doc(a), COVER: cover}, links, given)["계"]
assert mine > plain_a # A 고침 = B 안 기계 줄까지