diff --git a/M02_MasterTemplete/M02_Doc_Copy.py b/M02_MasterTemplete/M02_Doc_Copy.py index ecd5a19a1..2e0a2a2b7 100644 --- a/M02_MasterTemplete/M02_Doc_Copy.py +++ b/M02_MasterTemplete/M02_Doc_Copy.py @@ -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)) diff --git a/M02_MasterTemplete/M02_Sangeun_Copy.py b/M02_MasterTemplete/M02_Sangeun_Copy.py index 61434f8b6..b13faf544 100644 --- a/M02_MasterTemplete/M02_Sangeun_Copy.py +++ b/M02_MasterTemplete/M02_Sangeun_Copy.py @@ -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] diff --git a/M02_MasterTemplete/M02_Sk_AutoRenew.py b/M02_MasterTemplete/M02_Sk_AutoRenew.py index 7e588fa69..eeff3a3ca 100644 --- a/M02_MasterTemplete/M02_Sk_AutoRenew.py +++ b/M02_MasterTemplete/M02_Sk_AutoRenew.py @@ -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) diff --git a/resources/tester/test_836_2_sk_auto_renew.py b/resources/tester/test_836_2_sk_auto_renew.py index 09f19c86f..4f9cb2ecf 100644 --- a/resources/tester/test_836_2_sk_auto_renew.py +++ b/resources/tester/test_836_2_sk_auto_renew.py @@ -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"] diff --git a/resources/tester/test_848_2_cover_renew.py b/resources/tester/test_848_2_cover_renew.py new file mode 100644 index 000000000..03fcf783c --- /dev/null +++ b/resources/tester/test_848_2_cover_renew.py @@ -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)