Merge remote-tracking branch 'origin/sub_laptop_4' into sub_laptop_2

This commit is contained in:
2026-11-16 20:29:19 +09:00
5 changed files with 556 additions and 107 deletions
+31 -4
View File
@@ -58,6 +58,25 @@ def fp(value: Any) -> str:
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
#: 문서 셈 칸(848-2) — 덮음 · 손고침 · 쌓기 · 이름은 안 견줌
LOGIC = ("변수", "식", "금액", "끝수", "결과단위") # fmt: skip
#: 변수 · 식 · 금액 줄의 글 칸(연결 안 `단위` 는 셈 칸)
LABEL = ("이름", "규격", "단위", "비고", "출처") # fmt: skip
def doc_fp(doc: Any) -> str:
"""문서 계산 내용 지문(848-2) — 셈 칸(`LOGIC`)만 · 줄 · 변수의 글 칸 뺌 · 서버 표지 칸 뺌 ·
`기계덮음`(②) · `위덮음`(①) · `손고침` 은 셈 칸 밖 = 바뀌어도 같은 지문."""
from M02_MasterTemplete import M02_Doc_Sk as dsk
doc = doc if isinstance(doc, dict) else {}
bare = lambda x: {k: v for k, v in x.items() if k not in LABEL} if isinstance(x, dict) else x # noqa: E731
got = {k: doc.get(k) for k in LOGIC}
for part in ("변수", "식", "금액"):
got[part] = [bare(x) for x in got[part] or []]
return fp(dsk._strip(got))
# ── M01 문서(정본 폴더) ────────────────────────────────────────────────
_FOLDER: dict[str, Any] = {"자국": None, "문서": {}}
@@ -289,10 +308,18 @@ def refresh(copy: dict) -> tuple[dict, list[dict]]:
def state(copy: dict) -> dict[str, Any]:
"""{M01새판, 지운키, 단가새값, 문서새판} — 값 줄 · 부름 문서를 지금 M01 과 대조."""
"""{M01새판, 지운키, 단가새값, 문서새판} — 값 줄 · 부름 문서를 지금 M01 과 대조
(문서 = 계산 내용만 · 848-2 `doc_fp`)."""
got = skc.state(values_of(copy), skc.whole_())
live, base = folder(), copy.get("원본") or {}
new = {k for k, d in (copy.get("부름") or {}).items() if k in live and fp(d) != fp(live[k])}
if base.get("키") in live and fp(live[base["키"]]) != base.get("판"):
new.add(base["키"]) # 이 SK 문서를 찍은 M01 문서가 바뀜
new = {
k for k, d in (copy.get("부름") or {}).items() if k in live and doc_fp(d) != doc_fp(live[k])
}
if base.get("키") in live and not same_origin(base, live[base["키"]]):
new.add(base["키"]) # 이 SK 문서를 찍은 M01 문서의 계산 내용이 바뀜
return {**got, "문서새판": sorted(new)}
def same_origin(base: dict, live: Any) -> bool:
"""`원본.판` 대 지금 M01 문서 — 계산 내용 지문(`doc_fp`) · 옛 통째 지문(`fp`) 둘 다 받음."""
return base.get("판") in (doc_fp(live), fp(live))
+3 -2
View File
@@ -310,12 +310,13 @@ def _formula_job(out: dict, job: Any) -> dict:
"""수식 사본(802-4a · `M02_Doc_Sk`) 할일 — 재생성 = 파생으로(부름 새로 · 고친 문서 버림) ·
단가갱신 = 따로 문서의 값 줄도 지금 M01."""
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
got = out.get(dc.KEY) if dc.has(out) else None
if got is None or job not in (PRICE, REGEN):
return out
if job == REGEN:
drop = ("문서", "끊음", "따로", "처음", "기계덮음")
if job == REGEN: # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2)도 버림
drop = ("문서", "끊음", "따로", "처음", *renew.KEEP)
got = {k: v for k, v in got.items() if k not in drop} | {"부름": {}}
elif got.get("따로"):
got = dc.refresh(got)[0]
+228 -97
View File
@@ -1,16 +1,22 @@
"""M02 단가산출(SK) M01 자동 따라옴(PLAN 836-2 · 요구 854) — 서버 단독.
"""M02 단가산출(SK) M01 자동 따라옴(PLAN 836-2 · 848-2 · 요구 854 · 요구서_889 3 절) — 서버 단독.
프로젝트 층 밖 SK(마스터 · 회사 · 개인) = 셈 · 열기 · 목록 · 일위대가 펼침이 모두
사본 줄 = 지금 M01(+ 층 내 기계) 줄(`rows` · 지운 키 = 사본 마지막 줄) ·
부름 문서 = 지금 M01 수식 문서(`form`)로 봄 — 묻지 않음 · [단가 갱신] · [재생성] 없음.
파일(작업본)은 [저장] · 알림 [확인](= 저장) 때만 새 것으로 씀 — 읽기 길은 안 씀 ·
저장 파일의 사본 = 마지막 저장 때 받은 M01(= 고침 판정의 「복사 당시 원본」).
고침 판정 = 내용 대조(표지 아님 · 바꿨다 되돌림 = 안 고침) — 셈에 닿는 칸(`LOGIC`)만 견줌:
끊음[키] 대 부름[키](복사 당시) · 따로 문서 대 `처음`(따로가 된 때의 문서 · 없으면 고친 것).
M01 에서 바뀐 항목에 고침이 얹혀 있으면 그 고침을 지우고 다시 복사 + 알림 `갱신` 한 줄
{키, 이름, 갈래, M01 [전 → 후], 내고침 [지워진 값]} · 고침 없는 항목 = 조용히 따라옴 ·
안 바뀐 항목의 고침 = 그대로. 따로 문서를 지우면 파생(옛 칸 + 새 M01)으로 돌아감.
가져온 식 SK = 값 줄만 따라옴(가져온 줄 문서 · 식 안 건드림 · 단가기준 「엑셀」 은 엑셀 값 그대로).
파일(작업본)은 [저장] · 알림 [확인](= 저장 · `confirm`) 때만 새 것으로 씀 — 읽기 길은 안 씀.
판정 = 칸 단위(848-2):
기계 고침(② `문서.기계덮음`) — 칸마다 「위 값」(① `위덮음` 그 칸 › ⓪ 기계 줄 그 칸)
바탕 대 지금 · 위가 바뀐 칸에 ② 가 있으면 ② 지킴 + 알림(처리 「지킴」) ·
② 없는 칸 = 조용히 따라옴(셈이 지금 줄 · 지금 ① 을 읽음) · 기계 줄 글 = 칸 아님.
바탕 = `덮음바탕`(지킨 칸만 · 알림 [확인] 까지) › 저장 사본 기계 줄 · 저장 `위덮음` ·
둘 다 없음(고르지 않아 사본 줄 없는 기계) = 바탕 모름 → 알림 없음 · ② 그대로
(다음 저장 때 지금 값이 바탕).
문서(따로 문서 · 끊음) — 계산 내용(`dc.doc_fp`)이 바뀐 것만 다시 복사 · 고쳐 둔 문서 =
옵션 값(선택 · 입력 열쇠) · ② 다시 얹고 못 얹은 것만 알림(처리 「다시복사」 · 「지워짐」).
알림 한 줄 `갱신` = {키, 이름, 갈래(기계 · 문서 · 부름), 처리(지킴 · 다시복사 · 지워짐),
M01 [전 → 후 글], 내고침 [글]} + 지킴 = {문서, 열쇠, 경로, 칸, 층(기계 · 기초), 전, 후, 내값} ·
다시복사 · 지워짐 = {다시얹음 [글]}.
가져온 식 SK = 값 줄만 따라옴(가져온 줄 문서 · 식 그대로) · 기계 고침 판정 같음(① = 저장 `위덮음`).
프로젝트 층 · B09 사본 = 그대로(사용자가 고르는 [단가 갱신] · [재생성]).
"""
@@ -28,18 +34,22 @@ from M02_MasterTemplete import M02_Sangeun_Imported as imp
import master_doc_cover as mcv # noqa: E402 — 기계 덮음(836-1 · scripts 길 = dc)
COVER = mcv.COVER # 문서 칸 기계덮음(836-1) — 따로 문서를 다시 복사할 때 `수식` 머리에 맡겨 둠
mw, mcrew = mcv.mw, mcv.mcrew # 작업량 · 인력 잡품 목록(같은 scripts 길)
COVER = mcv.COVER # 문서 칸 기계덮음(② · 836-1) — 따로 문서를 다시 복사할 때 `수식` 머리에 맡겨 둠
UPPER = getattr(mcv, "UPPER", "위덮음") # `수식` 칸 — ① 위 층 고침(848-1)
FIRST = "처음" # `수식` 칸 — 따로가 된 때의 문서(고침 판정 원본)
LOGIC = (
"변수",
"식",
"금액",
"끝수",
"결과단위",
) # 셈에 닿는 칸 — 쌓기(차림) · 이름 · 판은 안 견줌
OPTS = (
"맡긴값" # `수식` 칸 — 다시 복사한 따로 문서의 옵션 값 {변수 열쇠: 값}(파생 문서에 다시 얹음)
)
BASE = "덮음바탕" # `수식` 칸 — 지킨 ② 칸의 바탕 {열쇠: {경로: 위 값}} · 알림 [확인] 때 걷음
KEEP = (COVER, OPTS, BASE) # 파생 저장 때 `수식` 에 이어 실을 칸(`M02_Doc_Sk.settle`)
CONFIRM = "갱신확인" # 알림 [확인] 저장 할일
PICK = ("선택", "입력") # 옵션 변수 갈래
MAX_LINES = 8
_MEMO: dict[tuple, dict] = {}
_LIVE: list[Any] = [None]
_NO = object() # 바탕 모름
def on() -> bool:
@@ -64,7 +74,8 @@ def _fresh(row: dict, live: Any) -> dict:
def rows(copy: Any) -> Any:
"""값 사본(`skc` 꼴) → 줄마다 지금 M01(+ 층 내 기계) · 바뀐 몫만 판 다시 · 프로젝트 층 = 그대로."""
"""값 사본(`skc` 꼴) → 줄마다 지금 M01(+ 층 내 기계) · 바뀐 몫만 판 다시 ·
프로젝트 층 = 그대로."""
if not (isinstance(copy, dict) and isinstance(copy.get("로직"), list)) or not on():
return copy
live = skc.whole_()
@@ -88,13 +99,6 @@ def rows(copy: Any) -> Any:
# ── 수식 사본(부름 · 끊음 · 따로 문서) ──────────────────────────────────
def _logic(doc: Any) -> str:
from M02_MasterTemplete import M02_Doc_Sk as dsk
doc = doc if isinstance(doc, dict) else {}
return dc.fp(dsk._strip({k: doc.get(k) for k in LOGIC}))
def _say(v: dict) -> str:
link = v.get("연결") or {}
for slot in ("값", "식", "키"):
@@ -133,50 +137,94 @@ def diff(a: Any, b: Any) -> list[str]:
return out[:MAX_LINES] + ([f"… {len(out) - MAX_LINES}"] if len(out) > MAX_LINES else [])
def form(sk: Any, got: Any, notes: list | None = None) -> Any:
"""수식 사본 → 지금 M01 으로 본 것(값 줄 · 부름) · M01 에서 바뀐 항목의 고침(끊음 · 따로 문서)은
지우고 `notes` 에 한 줄 · 안 바뀐 항목 고침 · 프로젝트 층 = 그대로."""
def _opts(doc: Any) -> dict[str, Any]:
"""옵션 변수 {열쇠: 값}(선택 · 입력)."""
out = {}
for v in (doc or {}).get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") in PICK and v.get("열쇠"):
out[str(v["열쇠"])] = link.get("값")
return out
def put_opts(doc: dict, vals: dict) -> dict:
"""옵션 값을 얹은 새 문서(열쇠 · 갈래가 있는 변수만)."""
if not vals:
return doc
doc = cp.deepcopy(doc)
for v in doc.get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") in PICK and str(v.get("열쇠")) in vals:
link["값"] = vals[str(v["열쇠"])]
return doc
def _replay(mine: dict, first: Any, live: Any) -> tuple[dict, list[str], list[str]]:
"""고친 문서(`mine` · 원본 `first`)를 새 문서(`live`)에 다시 얹기 —
(얹을 옵션 값, 다시 얹음 글, 못 얹은 고침 글). 옵션 값 = 열쇠가 새 문서에 살아 있으면 얹음."""
was, have, now = _opts(first), _opts(mine), _opts(live)
edits = {k: v for k, v in have.items() if k in was and mcv._canon(v) != mcv._canon(was[k])}
put = {k: v for k, v in edits.items() if k in now}
rest = put_opts(mine, {k: was[k] for k in edits}) # 옵션 고침 뺀 나머지 고침
lost = diff(first, rest) if dc.doc_fp(rest) != dc.doc_fp(first) else []
lost += [f"{k} {edits[k]}(새 문서에 없음)" for k in edits if k not in put]
return put, [f"{k} {v}" for k, v in put.items()], lost
def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) -> Any:
"""수식 사본 → 지금 M01 으로 본 것(값 줄 · 부름) · 기계 고침 = 칸 단위 지킴(`_covers`) ·
계산 내용이 바뀐 고친 문서(끊음 · 따로) = 다시 복사(옵션 값 · ② 다시 얹음) ·
프로젝트 층 = 그대로 · `confirm` = 알림 [확인] 저장(바탕 걷음)."""
if not isinstance(got, dict) or not on() or not is_sk(sk):
return got
out = rows(got) if "로직" in got else dict(got)
out = _covers(got, out, notes)
out = _covers(sk, got, out, notes, confirm)
if imp.is_imported(sk):
return out # 가져온 식 = 값만(식 · 가져온 줄 그대로)
live = dc.folder()
calls = dict(out.get("부름") or {})
changed = {k for k, d in calls.items() if k in live and dc.fp(d) != dc.fp(live[k])}
if not changed and not out.get("따로"):
moved = {k for k, d in calls.items() if k in live and dc.fp(d) != dc.fp(live[k])}
if not moved and not out.get("따로"):
return out
for k in changed:
for k in moved: # 글 · 덮음만 바뀜 = 조용히 따라옴(끊음 그대로)
calls[k] = cp.deepcopy(live[k])
redo = {k for k in moved if dc.doc_fp((got.get("부름") or {}).get(k)) != dc.doc_fp(live[k])}
cut = dict(out.get("끊음") or {})
for k in sorted(changed & set(cut)):
for k in sorted(redo & set(cut)):
mine, was = cut.pop(k), (got.get("부름") or {}).get(k)
if _logic(mine) != _logic(was) and notes is not None:
notes.append(_note(k, was, live[k], diff(was, mine), "부름"))
if dc.doc_fp(mine) == dc.doc_fp(was):
continue # 안 고친 끊음 = 조용히 따라옴
put, again, lost = _replay(mine, was, live[k])
if put:
cut[k] = put_opts(cp.deepcopy(live[k]), put)
if notes is not None:
notes.append(_note(k, was, live[k], lost, "부름", again=again))
out |= {"부름": calls, "끊음": cut}
base = out.get("원본") or {}
key = str(base.get("키") or "")
if out.get("따로") and key in live and dc.fp(live[key]) != base.get("판"):
if out.get("따로") and key in live and not dc.same_origin(base, live[key]):
first = out.get(FIRST)
mine = out.get("문서") or {}
if first is None or _logic(mine) != _logic(first):
mark = (
diff(first, mine)
if first is not None
else ["수식 문서 고침(옛 저장본 — 원본 없음)"]
)
if notes is not None:
notes.append(_note(key, first, live[key], mark, "문서", mine.get("이름")))
keep = {COVER: mine[COVER]} if mine.get(COVER) else {} # 기계 덮음 = 다른 항목(그대로)
out = {k: v for k, v in out.items() if k not in ("따로", "문서", FIRST, COVER)} | keep
if changed and "문서" in out: # 새 문서가 부르는 키 = 닫힌 묶음
put: dict = {}
if first is None:
again, lost = [], ["수식 문서 고침(옛 저장본 — 원본 없음)"]
elif dc.doc_fp(mine) != dc.doc_fp(first):
put, again, lost = _replay(mine, first, live[key])
else:
again, lost = [], []
if (again or lost) and notes is not None:
notes.append(_note(key, first, live[key], lost, "문서", mine.get("이름"), again))
keep = {COVER: mine[COVER]} if mine.get(COVER) else {} # 기계 고침 = 다시 얹음(`carry`)
if put := {**(out.get(OPTS) or {}), **put}:
keep[OPTS] = put
out = {k: v for k, v in out.items() if k not in ("따로", "문서", FIRST, COVER, OPTS)} | keep
if moved and "문서" in out: # 새 문서가 부르는 키 = 닫힌 묶음
keys = [*dc.calls(out["문서"]), *(c for d in cut.values() for c in dc.calls(d))]
out["부름"] = dc.closure(dc.over(out), keys, calls)
return out
# ── 기계 덮음(836-1) — 그 기계 줄이 M01 에서 바뀌면 덮음 지움 ─────────────
# ── 기계 고침(②) — 칸 단위 지킴 ─────────────────────────────────────────
def _eq_rows(copy: dict) -> dict[str, dict]:
"""사본의 기계 줄 {원문번호 · 키: 줄}."""
out: dict[str, dict] = {}
@@ -188,78 +236,161 @@ def _eq_rows(copy: dict) -> dict[str, dict]:
return out
def _mine(entry: dict) -> list[str]:
vals = [f"{k} {v}" for k, v in (entry.get("값") or {}).items()]
crew = [f"조종원 {x.get('키')} {x.get('인')}인" for x in entry.get("조종원") or []]
misc = [
f"잡품 {x.get('이름') or x.get('키') or x.get('줄')} {x.get('율')}%"
for x in entry.get("잡품") or []
]
return [*vals, *crew, *misc] or ["덮음"]
def _live_row(text: str) -> dict | None:
whole = skc.whole_()
got = (whole.numbers.get("EQ") or {}).get(text) or (whole.index.get("EQ") or {}).get(text)
return prices.to_json(got) if got else None
def _row_diff(a: dict, b: dict) -> list[str]:
va, vb = a.get("값") or {}, b.get("값") or {}
if not isinstance(va, dict) or not isinstance(vb, dict):
return [f"{a.get('값')} → {b.get('값')}"]
keys = [*va, *(k for k in vb if k not in va)]
return [f"{k} {va.get(k, '—')} → {vb.get(k, '—')}" for k in keys if va.get(k) != vb.get(k)]
def paths(entry: Any) -> dict[str, Any]:
"""덮음 한 열쇠 → {칸 경로: 값}(848-1 계약 경로 · 조종원 · 잡품 = 목록 통째 한 칸)."""
e = entry if isinstance(entry, dict) else {}
out = {f"값.{k}": v for k, v in (e.get("값") or {}).items()}
for part in ("조종원", "잡품"):
if e.get(part) is not None:
out[part] = e[part]
w = e.get(mw.WORK) if isinstance(e.get(mw.WORK), dict) else {}
for k in ("방식", "식"):
if w.get(k) not in (None, ""):
out[f"작업량.{k}"] = w[k]
for k, v in (w.get("변수") or {}).items():
out[f"작업량.변수.{k}"] = v
if w.get("기계"):
out["작업량.기계"] = {k: w[k] for k in mw.FIXED if w.get(k)}
return out
def _same_new(a: dict, b: dict) -> bool:
"""옛 꼴 사본 줄 대 새 꼴 M01 줄(842-3 인력 · 잡품 목록 옮김) — 새 꼴로 바꿔 같으면 안 바뀜."""
import master_machine_crew as mcrew
return skc._fp(mcrew.from_old_row(a)) == skc._fp(mcrew.from_old_row(b))
def _machine(text: str, path: str, *layers: Any) -> str:
"""그 칸의 기계 열쇠 — 작업량 = 굳은 기계(② › ①) · 그 밖 = 덮음 열쇠."""
if path.startswith("작업량."):
for e in layers:
w = (e or {}).get(mw.WORK) if isinstance(e, dict) else None
if isinstance(w, dict) and w.get("기계"):
return str(w["기계"])
return text
def _covers(got: dict, out: dict, notes: list | None) -> dict:
"""문서(따로) · 맡긴 기계 덮음 가운데 그 기계 줄이 M01 에서 바뀐 것 = 지움 + 알림."""
def _up(path: str, row: dict | None, one: Any, mine: dict) -> Any:
"""그 칸 위 값 = ① 그 칸 › ⓪ 기계 줄 그 칸 · 기계 줄 없음 = `_NO`."""
have = paths(one)
if path in have:
return have[path]
if row is None:
return _NO
vals = mcrew.from_old_row(row).get("값") # 옛 꼴 사본 줄 = 새 꼴로 견줌(842-3)
vals = vals if isinstance(vals, dict) else {}
if path.startswith("값."):
return vals.get(path[2:])
if path in ("조종원", "잡품"):
return vals.get(mcrew.CREW if path == "조종원" else mcrew.MISC)
if path.startswith("작업량.변수."):
want = (mine.get(mw.WORK) or {}).get("식") or ((one or {}).get(mw.WORK) or {}).get("식")
specs = mw.specs_of(vals.get(mw.WORK))
spec = next((s for s in specs if s["식"] == want), None) if want else None
spec = spec or (specs[0] if specs and not want else None)
return ((spec or {}).get("변수") or {}).get(path[len("작업량.변수.") :])
return None # 작업량 방식 · 식 · 기계 = 기계 줄에 없음(위 층 없음 = 빈 값)
def _upper_now(sk: dict, got: dict) -> dict:
"""지금 ① — 가져온 식 = 저장본 · 그 밖 = 지금 기초(`바탕.로직`) 문서 `기계덮음` ·
기초 문서 없음 = 저장본."""
if imp.is_imported(sk):
return got.get(UPPER) or {}
key = str((sk.get("바탕") or {}).get("로직") or "")
live = dc.folder().get(key) if key else None
return mcv.cover_of(live) if live is not None else got.get(UPPER) or {}
def _same(a: Any, b: Any) -> bool:
return mcv._canon(a) == mcv._canon(b)
def _covers(sk: dict, got: dict, out: dict, notes: list | None, confirm: bool) -> dict:
"""② 칸마다 위 값 바탕 대 지금 — 바뀐 칸 = ② 지킴 + 알림 · 바탕(`덮음바탕`)은 지킨 칸만 남김 ·
`confirm` = 바탕 걷음(알림 없음)."""
doc = out.get("문서") if isinstance(out.get("문서"), dict) else None
cover = dict(mcv.cover_of(doc) if doc is not None else out.get(COVER) or {})
if not cover:
return out
was, now = _eq_rows(got), _eq_rows(out)
for text in list(cover):
a, b = was.get(text), now.get(text)
if a is None or b is None or skc._fp(a) == skc._fp(b) or _same_new(a, b):
continue
entry = cover.pop(text)
if notes is not None:
name = f"{b.get('이름') or ''} {b.get('규격') or ''}".strip() or text
notes.append(
{
"키": str(b.get("키")),
"이름": name,
"갈래": "기계",
"M01": _row_diff(a, b) or ["바뀜"],
"내고침": _mine(entry),
} # fmt: skip
cover = mcv.cover_of(doc) if doc is not None else out.get(COVER) or {}
held: dict = {} if confirm else got.get(BASE) or {}
keep: dict = {}
if cover and not confirm:
was, here = _eq_rows(got), _eq_rows(out)
up0, up1 = got.get(UPPER) or {}, _upper_now(sk, got)
for text, mine in cover.items():
for path, val in paths(mine).items():
m0 = _machine(text, path, mine, up0.get(text))
m1 = _machine(text, path, mine, up1.get(text))
before = (held.get(text) or {}).get(path, _NO)
if before is _NO:
before = _up(path, was.get(m0), up0.get(text), mine)
now = _up(path, _live_row(m1) or here.get(m1), up1.get(text), mine)
if before is _NO or now is _NO or _same(before, now) or _same(val, now):
continue
keep.setdefault(text, {})[path] = before
if notes is not None:
above = path in paths(up1.get(text))
notes.append(_kept(sk, text, path, m1, before, now, val, above))
rest = {k: v for k, v in out.items() if k != BASE}
return rest | ({BASE: keep} if keep else {})
def _txt(v: Any) -> str:
"""칸 값 글 — 인력 · 잡품 목록 = 줄 글 · 빈 값 = —."""
if isinstance(v, list):
return (
" · ".join(
f"{x.get('키') or '직종'} {x.get('인')}인"
if "인" in x
else f"{x.get('이름') or x.get('키') or x.get('줄')} {x.get('율')}%"
for x in v
if isinstance(x, dict)
)
if doc is not None:
rest = {k: v for k, v in doc.items() if k != COVER}
return {**out, "문서": {**rest, COVER: cover} if cover else rest}
return {k: v for k, v in out.items() if k != COVER} | ({COVER: cover} if cover else {})
or "없음"
)
if isinstance(v, dict):
return str(v.get("이름") or v.get("기계") or json.dumps(v, ensure_ascii=False))
return "—" if v in (None, "") else str(v)
def _label(path: str) -> str:
return {"조종원": "인력", "잡품": "잡품"}.get(path) or path.removeprefix("값.").replace(
".", " "
)
def _kept(sk, text, path, machine, before, now, mine, upper) -> dict:
row = _live_row(machine) or {}
name = f"{row.get('이름') or ''} {row.get('규격') or ''}".strip() or text
label = _label(path)
return {
"키": str(row.get("키") or text), "이름": name, "갈래": "기계", "처리": "지킴",
"문서": str(sk.get("키") or ""), "열쇠": text, "경로": path, "칸": label,
"층": "기초" if upper else "기계", "전": before, "후": now, "내값": mine,
"M01": [f"{label} {_txt(before)} → {_txt(now)}"], "내고침": [f"{label} {_txt(mine)}"],
} # fmt: skip
def carry(got: dict, root: dict) -> dict:
"""파생 문서에 맡긴 기계 덮음을 다시 얹음(따로 문서를 다시 복사한 뒤)."""
"""파생 문서에 맡긴 기계 고침 · 옵션 값을 다시 얹음(따로 문서를 다시 복사한 뒤)."""
root = put_opts(root, got.get(OPTS) or {}) if isinstance(got.get(OPTS), dict) else root
return {**root, COVER: got[COVER]} if isinstance(got.get(COVER), dict) and got[COVER] else root
def _note(key: str, was: Any, now: dict, mine: list[str], kind: str, name: Any = None) -> dict:
def _note(key, was, now, lost, kind, name=None, again=()) -> dict:
return {
"키": key,
"이름": str(name or now.get("이름") or key),
"갈래": kind,
"처리": "지워짐" if lost else "다시복사",
"M01": diff(was, now) or ["바뀜"],
"내고침": mine,
"내고침": list(lost),
"다시얹음": list(again),
}
def notes(sk: Any) -> list[dict]:
"""열 때 알림 — 이 SK 저장본에서 지울 고침(없으면 []) · 가져온 식 · 프로젝트 층 = []."""
if not is_sk(sk) or not dc.has(sk) or imp.is_imported(sk):
"""열 때 알림 — 이 SK 저장본의 지킨 칸 · 다시 복사 · 지울 고침(없으면 []) · 프로젝트 층 = []."""
if not is_sk(sk) or not dc.has(sk):
return []
out: list[dict] = []
form(sk, sk[dc.KEY], out)
+4 -4
View File
@@ -219,8 +219,8 @@ def _cover(me, key: str, cover: dict) -> None:
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
def test_machine_cover_dropped_when_machine_moves(world, monkeypatch):
"""㉢ 기계 덮음(836-1) + 그 기계 줄 M01 바뀜 = 덮음 지움 + 알림(전 · 후 · 내 고침 값)."""
def test_machine_cover_kept_when_machine_moves(world, monkeypatch):
"""㉢ 기계 덮음(836-1) + 그 칸 M01 바뀜 = 덮음 지킴(848-2 칸 단위) + 알림(전 · 후 · 내 값)."""
me = world["personal"]
key = _sk(me)
_stack(me, key, [("기계", MACHINE, "묶음")])
@@ -229,9 +229,9 @@ def test_machine_cover_dropped_when_machine_moves(world, monkeypatch):
assert _at(me, path.read, key)["문서"]["기계덮음"]
_move(monkeypatch, DIG)
got = _at(me, path.read, key)
assert "기계덮음" not in got["문서"]
assert got["문서"]["기계덮음"] == {no: {"값": {"가격": 150000}}}
[note] = got["사본"]["갱신"]
assert note["키"] == DIG and note["갈래"] == "기계"
assert note["키"] == DIG and note["갈래"] == "기계" and note["처리"] == "지킴"
assert any(x.startswith("가격 ") for x in note["M01"]) and note["내고침"] == ["가격 150000"]
+290
View File
@@ -0,0 +1,290 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""848-2 갱신 칸 단위(요구서_889 3 절) — 임시 storage + M01 메모리 사본(정본 파일 안 고침).
㉠ 기계 가격만 바뀜 + 인력 고침 = 가격 따라옴 · 인력 고침 남음 · 알림 없음
㉡ 기계 가격 바뀜 + 가격 고침 = 내 값 지킴 + 알림(전 → 후 · 내 값) · 금액 그대로
㉢ 기계 비고 · 출처 글만 바뀜 = 고침 그대로 · 알림 없음
㉣ 기초 고침(①)만 바뀜 = 따로 문서 · 끊음 안 지워짐 · ① 이 내 고침 칸을 바꾸면 지킴 알림(층 기초)
㉤ 기초에 줄이 더해짐 = 다시 복사 + 알림 자료 · 기계 고침 · 옵션 값 다시 얹힘
㉥ 확인 전 [저장] = 바탕 남아 알림 계속 · 확인 뒤 = 안 뜸
㉦ 프로젝트 사본 = 그대로 ㉧ 내 기계 · 가져온 식 = 같은 규칙.
"""
from __future__ import annotations
import copy
import shutil
import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MyMachine as mym
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
from resources.tester.test_822_1_copy_gap import DIG, DIG_NO, MACHINE, _at, _move, _sk, _stack
from resources.tester.test_836_2_sk_auto_renew import _cover, _doc_move
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
CUT = (
"GC000085" # 흙깎기(기계) 보통토사 — 굴착기 1.0㎥(0201-0100) 부름 · 옵션 규모 · 지역 · 보정작업
)
PRICE = 142069 # 굴착기 1.0㎥ M01 가격
WAIT = pytest.mark.xfail(reason="M02_Doc_Sk 세 줄(848-2 a · b · c) 붙인 뒤", strict=True)
def _eq_move(monkeypatch, key: str, fn) -> None:
"""M01 기계 줄 하나 고침(메모리 · 진짜 색인 사본)."""
files, live = m01.loaded()
fake = copy.copy(live)
fake.index, fake.numbers = dict(live.index), dict(live.numbers)
row = copy.deepcopy(live.index["EQ"][key])
fn(row)
fake.index["EQ"] = {**fake.index["EQ"], key: row}
fake.numbers["EQ"] = {**fake.numbers["EQ"], str(row["원문번호"]): row}
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
def _read(me, key):
return _at(me, path.read, key)
def _machine_sk(me, cover: dict) -> str:
key = _sk(me)
_stack(me, key, [("기계", MACHINE, "묶음")])
_cover(me, key, {DIG_NO: cover})
return key
def _cut_sk(me, size: str = "소규모", cover: dict | None = None) -> str:
"""흙깎기 바탕 SK — 규모 옵션 고침(소규모 = 굴착기 줄 셈) · ② 기계 고침 · 따로 저장."""
key = _sk(me, 바탕={"로직": CUT}, 단위="㎥")
got = _read(me, key)
doc = copy.deepcopy(got["문서"])
for v in doc["변수"]:
if v.get("열쇠") == "규모":
v["연결"]["값"] = size
if cover:
doc["기계덮음"] = {DIG_NO: cover}
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
return key
def _size(doc: dict) -> str:
return next(v["연결"]["값"] for v in doc["변수"] if v.get("열쇠") == "규모")
def test_price_follows_crew_kept(world, monkeypatch):
"""㉠ 가격만 바뀜 + 인력 고침 = 가격 따라옴 · 인력 고침 남음 · 알림 없음."""
me = world["personal"]
crew = {"조종원": [{"키": "LB:1048", "인": 2}]}
key = _machine_sk(me, crew)
was = _read(me, key)
assert was["문서"]["기계덮음"] == {DIG_NO: crew}
_move(monkeypatch, DIG)
got = _read(me, key)
assert got["문서"]["기계덮음"] == {DIG_NO: crew} and got["사본"]["갱신"] == []
assert got["셈"]["계"] > was["셈"]["계"]
def test_price_kept_with_note(world, monkeypatch):
"""㉡ 가격 바뀜 + 가격 고침 = 내 값 지킴 + 알림(전 → 후 · 내 값 · 칸 경로) · 금액 그대로 ·
읽기 = 파일 안 씀."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}})
was = _read(me, key)
file = me / "sangeun" / f"{key}.json"
before = file.read_bytes()
_move(monkeypatch, DIG)
got = _read(me, key)
assert got["문서"]["기계덮음"] == {DIG_NO: {"값": {"가격": 150000}}}
assert got["셈"]["계"] == was["셈"]["계"]
[note] = got["사본"]["갱신"]
assert {k: note[k] for k in ("키", "갈래", "처리", "열쇠", "경로", "층")} == {
"키": DIG, "갈래": "기계", "처리": "지킴", "열쇠": DIG_NO, "경로": "값.가격", "층": "기계",
} # fmt: skip
assert (note["전"], note["후"], note["내값"]) == (PRICE, PRICE * 2, 150000)
assert note["M01"] == [f"가격 {PRICE} → {PRICE * 2}"] and note["내고침"] == ["가격 150000"]
assert file.read_bytes() == before
def test_label_only(world, monkeypatch):
"""㉢ 비고 · 출처 글만 바뀜 = 고침 그대로 · 알림 없음 · 금액 같음."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}, "조종원": [{"키": "LB:1048", "인": 2}]})
was = _read(me, key)
def label(row: dict) -> None:
row["비고"] = "848-2 시험 비고"
row["출처"] = {**row["출처"], "가격": "848-2 시험 출처"}
row["이름"] = row["이름"] + " 새 이름"
_eq_move(monkeypatch, DIG, label)
got = _read(me, key)
assert got["문서"]["기계덮음"] == was["문서"]["기계덮음"] and got["사본"]["갱신"] == []
assert got["셈"]["계"] == was["셈"]["계"]
def test_crew_list_kept(world, monkeypatch):
"""㉡ 목록 칸 — 기계 인력 줄 바뀜 + 인력 고침 = 지킴 알림(목록 글) · 가격 고침 칸은 알림 없음."""
me = world["personal"]
mine = [{"키": "LB:1048", "인": 2}]
key = _machine_sk(me, {"값": {"가격": 150000}, "조종원": mine})
_eq_move(monkeypatch, DIG, lambda r: r["값"].update(인력=[{"키": "LB:1048", "인": 1.5}]))
[note] = _read(me, key)["사본"]["갱신"]
assert (note["경로"], note["처리"], note["내값"]) == ("조종원", "지킴", mine)
assert note["M01"] == ["인력 LB:1048 1인 → LB:1048 1.5인"]
@WAIT
def test_upper_only(world, monkeypatch):
"""㉣ 기초 고침(①)만 바뀜(+ 이름 글) = 따로 문서 그대로 · 내 고침 칸을 ① 이 바꾸면 지킴 알림(층 기초) ·
② 없는 칸(주연료)은 알림 없음."""
me = world["personal"]
key = _cut_sk(me, cover={"값": {"가격": 150000}})
was = _read(me, key)
assert was["사본"]["따로"] is True
def upper(d: dict) -> None:
d["기계덮음"] = {DIG_NO: {"값": {"가격": 200000, "주연료": 30}}}
d["이름"] = d["이름"] + " 새 이름"
_doc_move(monkeypatch, CUT, upper)
got = _read(me, key)
assert got["사본"]["따로"] is True and _size(got["문서"]) == "소규모"
assert got["문서"]["기계덮음"] == {DIG_NO: {"값": {"가격": 150000}}}
[note] = got["사본"]["갱신"]
assert (note["경로"], note["층"], note["전"], note["후"]) == ("값.가격", "기초", PRICE, 200000)
assert not got["사본"]["문서새판"]
def test_cut_kept_on_upper(world, monkeypatch):
"""㉣ 끊음 — 부른 문서의 ① · 글만 바뀜 = 끊음 그대로 · 계산 내용이 바뀜 = 다시 복사 + 알림."""
me = world["personal"]
key = _sk(me)
_stack(me, key, [("기계", MACHINE, "묶음")])
got = _read(me, key)
call = MACHINE["키"]
mine = copy.deepcopy(got["부름"][call])
mine["금액"][0]["수량"] = f"({mine['금액'][0].get('수량') or 1}) × 2"
_at(me, path.save, key, {"끊음": {call: mine}, "판": got["판"]})
was = _read(me, key)
assert call in was["끊음"]
_doc_move(
monkeypatch, call, lambda d: d.update(기계덮음={DIG_NO: {"값": {"가격": 1}}}, 이름="새")
)
got = _read(me, key)
assert got["끊음"][call]["금액"][0]["수량"] == mine["금액"][0]["수량"]
assert got["사본"]["갱신"] == [] and got["셈"]["계"] == was["셈"]["계"]
_doc_move(monkeypatch, call, lambda d: d["금액"].append(copy.deepcopy(d["금액"][0])))
got = _read(me, key)
assert call not in got["끊음"]
[note] = got["사본"]["갱신"]
assert (note["갈래"], note["처리"]) == ("부름", "지워짐") and note["내고침"]
def _grow(d: dict) -> None:
d["금액"].append({**copy.deepcopy(d["금액"][1]), "이름": "848-2 덧줄"})
def test_structure_recopy(world, monkeypatch):
"""㉤ 기초에 줄이 더해짐 = 다시 복사(따로 아님) · 기계 고침 · 옵션 값 다시 얹음 · 알림 다시복사."""
me = world["personal"]
cover = {"값": {"가격": 150000}}
key = _cut_sk(me, cover=cover)
_doc_move(monkeypatch, CUT, _grow)
got = _read(me, key)
assert got["사본"]["따로"] is False
assert got["문서"]["기계덮음"] == {DIG_NO: cover} and _size(got["문서"]) == "소규모"
assert any(x["이름"] == "848-2 덧줄" for x in got["문서"]["금액"])
[note] = got["사본"]["갱신"]
assert (note["갈래"], note["처리"], note["내고침"]) == ("문서", "다시복사", [])
assert note["다시얹음"] == ["규모 소규모"]
@WAIT
def test_structure_recopy_saved(world, monkeypatch):
"""㉤ 다시 복사한 뒤 알림 [확인](저장) = 기계 고침 · 옵션 값 남음 · 알림 없음."""
me = world["personal"]
cover = {"값": {"가격": 150000}}
key = _cut_sk(me, cover=cover)
_doc_move(monkeypatch, CUT, _grow)
got = _read(me, key)
_at(me, path.save, key, {"할일": renew.CONFIRM, "판": got["판"]})
after = _read(me, key)
assert after["사본"]["갱신"] == [] and after["문서"]["기계덮음"] == {DIG_NO: cover}
assert _size(after["문서"]) == "소규모" and after["셈"]["계"] == got["셈"]["계"]
def test_save_keeps_base(world, monkeypatch):
"""㉥ 확인 전 [저장](고친 문서 다시 저장) = 바탕 남아 알림 계속."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}})
_move(monkeypatch, DIG)
got = _read(me, key)
_at(me, path.save, key, {"문서": got["문서"], "판": got["판"]})
again = _read(me, key)
[note] = again["사본"]["갱신"]
assert (note["전"], note["후"]) == (PRICE, PRICE * 2)
@WAIT
def test_confirm_clears(world, monkeypatch):
"""㉥ 알림 [확인] 뒤 = 안 뜸 · 내 값 그대로 · 금액 같음."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}})
_move(monkeypatch, DIG)
got = _read(me, key)
_at(me, path.save, key, {"할일": renew.CONFIRM, "판": got["판"]})
after = _read(me, key)
assert after["사본"]["갱신"] == [] and after["셈"]["계"] == got["셈"]["계"]
assert after["문서"]["기계덮음"] == {DIG_NO: {"값": {"가격": 150000}}}
def test_project_keeps(world, monkeypatch):
"""㉦ 프로젝트 층 사본 = 그대로(금액 · 고침 · 알림 없음)."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}})
proj = me.parent / "p8482" / "templates"
(proj / "sangeun").mkdir(parents=True)
shutil.copy(me / "sangeun" / f"{key}.json", proj / "sangeun" / f"{key}.json")
with store.at(proj):
assert refs.here()[0] == "project"
was = _read(proj, key)
_move(monkeypatch, DIG)
got = _read(proj, key)
assert got["셈"]["계"] == was["셈"]["계"] and got["사본"]["갱신"] == []
assert got["문서"]["기계덮음"] == was["문서"]["기계덮음"]
def test_my_machine(world):
"""㉧ 내 기계 — 가격 고침 + 내 기계 가격 바뀜 = 지킴 알림."""
me = world["personal"]
vals = {"가격": 1000, "손료계수": 2000, "주연료": 2, "주연료종류": "경유", "잡재료율": 10,
"조종원": 1, "조종원직종": "1048"} # fmt: skip
made = _at(me, mym.create, {"이름": "sub4임시기계", "규격": "1㎾", "방식": "바로", "값": vals})
no, hourly = made["줄"]["원문번호"], made["시간당"]["로직"]
key = _sk(me)
link = {"갈래": "단가산출", "키": hourly, "입력": {"기계": f"'{no}'"}}
_stack(me, key, [("기계", link, "묶음")])
_cover(me, key, {no: {"값": {"가격": 5000}}})
assert _read(me, key)["사본"]["갱신"] == []
_at(me, mym.update, made["줄"]["키"], {"이름": "sub4임시기계", "규격": "1㎾", "방식": "바로",
"값": {**vals, "가격": 3000}}) # fmt: skip
[note] = _read(me, key)["사본"]["갱신"]
assert (note["열쇠"], note["처리"], note["전"], note["후"], note["내값"]) == (
no, "지킴", 1000, 3000, 5000,
) # fmt: skip
def test_imported_same_rule(world, monkeypatch):
"""㉧ 가져온 식 — 같은 칸 판정(① = 저장 `위덮음`) · 알림 지킴."""
me = world["personal"]
key = _machine_sk(me, {"값": {"가격": 150000}})
sk = _at(me, lambda: store.read("sangeun", key)["문서"])
sk = {**sk, "가져온": {"로직": {}}} # 가져온 식 꼴(판정만)
_move(monkeypatch, DIG)
with store.at(me):
[note] = renew.notes(sk)
assert (note["처리"], note["경로"], note["후"]) == ("지킴", "값.가격", PRICE * 2)