Merge remote-tracking branch 'origin/sub_laptop_4' into sub_laptop_2
This commit is contained in:
@@ -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))
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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"]
|
||||
|
||||
|
||||
|
||||
@@ -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)
|
||||
Reference in New Issue
Block a user