Merge branch 'sub_laptop_2' of C:/Aislo_wt/sub_laptop_2 into main_laptop_1
This commit is contained in:
@@ -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 {"그룹": "수식문서", "로직파일": "", "줄": []}
|
||||
|
||||
@@ -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)}
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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"]:
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
- 자리 = `수식문서/수식_<옛 로직 파일 꼬리>.json` — 옛 로직 파일마다 한 벌(`로직_건설품셈_08장_건설기계.json` → `수식_건설품셈_08장_건설기계.json`).
|
||||
- 머리 = `그룹`(「수식문서」) · `로직파일`(옛 로직 파일 이름) · `줄`(문서 목록 · 옛 로직 차례).
|
||||
- UTF-8 · LF · 들여쓰기 2칸 · 변수 · 식 · 금액 줄 하나 = 한 줄.
|
||||
- 옛 로직 JSON 과 따로 — 빌더만 씀(옛 로직 JSON 은 안 씀).
|
||||
- 옛 로직 JSON 과 따로 — 빌더가 씀(옛 로직 JSON 은 안 씀) · M01 화면 저장은 10 절(기계덮음 · 손고침).
|
||||
|
||||
## 2. 문서
|
||||
|
||||
@@ -129,3 +129,21 @@
|
||||
| 기계경비식 | 기계 시간당 경비 셈 방식(기계 줄이 부름) | — | M01 「기계」 기종 아래 |
|
||||
| 작업량 틀 | 기종 공식(Q = 3,600 × q × K × f × E ÷ Cm 등) | `기종` = 기계표 상세구분 목록 · `규격` = 기계 규격 수를 받는 변수 열쇠 | M01 「기계」 기종 아래 |
|
||||
| 계수식 | 기계 무관 · 돈 아닌 식 | — | M01 「계수」 아래 |
|
||||
|
||||
## 10. 겹쳐 덮는 층(848-1) — 기계 고침
|
||||
|
||||
| 층 | 자리 | 주인 |
|
||||
| --- | --- | --- |
|
||||
| ⓪ 정본 | M01 기계 한 대 파일 · 내 기계 | 시스템 관리자 · 사용자(내 기계) |
|
||||
| ① 위 층 고침 | M01 문서 칸 `기계덮음` · SK `수식.위덮음`(그 사본 · 가져온 식 = 가져온 값) | 시스템 관리자 · 불러오기 |
|
||||
| ② 내 고침 | SK `수식.문서.기계덮음` | 사용자 |
|
||||
|
||||
- 꼴 = `{열쇠: {값?: {칸: 값}, 조종원?: [줄], 잡품?: [줄], 작업량?: {방식?, 식?, 변수?, 기계?, 키?, 이름?}}}` · 열쇠 = 기계 입력 글 · 작업량은 그 줄 단가 기호.
|
||||
- 칸 단위 = 값 칸 하나 · 작업량 방식 · 식 · 변수 하나 · 기계 고정(기계 · 키 · 이름 한 덩이) · 조종원 목록 통째 · 잡품 목록 통째.
|
||||
- 합침 = ⓪ 위에 ① · 그 위에 ②(칸마다 아래 층이 이김 · 식을 바꾼 층은 위 층 변수를 안 물려받음) — `master_doc_cover.merge` · `merge_layers` ↔ `mergeCover` · `mergeLayers` · `layeredCover`.
|
||||
- 셈 = 계산기 `cover` 인자에 합친 것(맨 위 문서 하나만 · 부르는 문서의 덮음은 안 읽음).
|
||||
- 지움 = 층마다 위 층과 같은 칸을 뺌(`prune` · `prune_doc` 의 `upper`) · 문서 안(선택 목록 · 따옴표 글 · 변수 기호) · 굳은 기계에 든 열쇠의 고침은 이번 셈이 안 불러도 남김.
|
||||
- 위 층 값 = `upper_of` ↔ `upperOf` · 출처 = `sources` ↔ `sourcesOf`(칸 경로 → 「나」 · 「위」 · 없으면 정본).
|
||||
- SK `수식.위덮음` = 프로젝트 층 밖은 셈마다 지금 기초(`바탕.로직`) 문서 것 · [저장] 때 굳음 · 프로젝트 층 · 가져온 식 = 저장본.
|
||||
- M01 저장(`/logic/doc/save`) = `기계덮음` 검사 · 지움 뒤 씀 · 셈 칸이 빌더 결과와 다른 문서 = 칸 `손고침: true`.
|
||||
- 빌더 = 저장본 `기계덮음` 을 키별로 이어받음 · `손고침` 문서는 저장본 그대로(실행 때 목록) · `--check` 도 같은 규칙.
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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));
|
||||
@@ -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 안 기계 줄까지
|
||||
Reference in New Issue
Block a user