fix(858-G): 서고 같은 내용 지문이 수식 문서를 봄 — 바탕만 같고 수식을 고친 단가산출을 중복으로 안 묶음

- 까닭: 지문이 옛 칸(바탕 · 덮개 …)만 봄 → 같은 바탕 + 수식 고침 둘 = 「내용 같음」(합치면 한쪽 고침 사라짐) · 바탕 없는 수식 문서 단가산출 = 지문 없음(진짜 중복 못 찾음)
- 따로 단가산출 = 문서 셈 칸(doc_fp) · ② 기계덮음 · 끊음 · ① 위덮음 · 옛 판 부름 + 단위 · 바탕 · 환산 · 가져온 · 값 사본 새것 여부 — 옛 줄 규칙 칸 뺌(셈에 안 씀)
- 파생 단가산출(따로 아님) = 옛 지문 그대로(줄 규칙 칸이 문서를 지음) + 맡긴 기계덮음 · 맡긴값 · 끊음 · ① · 옛 판 부름 — 저장 전 새 문서와 같은 지문 유지
- 일위대가 = 참조 줄은 그 단가산출 지문을 따라감 + 수식 부름 문서 중 지금 M01 과 다른 것만 — 호표 불러오기 재사용 · 서고 golden 그대로
- 판 · 시점 · 이름표 = 지문 밖 · 화면 [중복 찾기] · [합치기] · [되돌림] 길 안 고침
- 시험: test_858_shelf_golden 에 새 시험(같은 바탕 · 다른 문서 = 안 묶임 · 같은 문서 바탕 있음 · 없음 = 묶임 · 합치기 → 되돌림 왕복 · 기계덮음 = 다름 · 옛 칸 · 판 · 시점 = 같음 · 옛 코드로는 실패) · golden 지문 다시 안 뜸
- test_735_1 견본 단가산출 = 옛 더한줄(2-C1 뒤 못 셈 · 시작 전부터 금액 5000 ≠ 11000 실패) → 따로 수식 문서(운반 3000)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 00:48:36 +09:00
co-authored by Claude Opus 5.5
parent a8dff7491b
commit c8c061bb10
3 changed files with 114 additions and 6 deletions
+53 -2
View File
@@ -7,7 +7,11 @@
차례 무시 = 더한줄 · 담은로직 · 자재 · 뺀줄 · 열린입력 정렬 · 더한줄 요소 줄 이름 뺌(요소 키가 정체)
SC 줄 · 자재 수량(742-1 저장 수량) · SK 더한줄 수량 넣음
참조 = 가리킨 문서의 지문(깊이 `refs.DEPTH` · 층 넘어 사본도 같음)
빈 문서(SK 바탕 · 더한줄 없음 · SC 줄 · 자재 없음) = 지문 None(검사 안 함).
SK 수식 사본(858-G · 셈 정본 = 수식 문서) — 따로 = 문서 셈 칸(`doc_fp`) · ② 기계 덮음 · 끊음 ·
① 위덮음(옛 줄 규칙 칸 뺌 — 셈에 안 씀) · 파생 = 줄 규칙 칸 + 맡긴 덮음 · 값 + 끊음 · ① ·
둘 다 부름 문서는 지금 M01 과 다른 것만(같으면 빠짐 = 저장 전 문서와 같은 지문 · SC 도) ·
판 · 시점 · 이름표 = 뺌.
빈 문서(SK 바탕 · 더한줄 · 셈 칸 든 따로 문서 없음 · SC 줄 · 자재 없음) = 지문 None(검사 안 함).
저장 칸 없음 — 그때그때 셈(`Same` 한 벌 = 한 요청 안 메모).
`find_same(folder, kind, doc)` = 같은 층 같은 내용 키(작은 번호 = 먼저 만든 것 먼저) ·
`find_above(folder, kind, doc)` = 위 층(회사 · 마스터) 같은 내용 참조 `[{층, 주인, 키}]`.
@@ -21,14 +25,17 @@ from pathlib import Path
from typing import Any
from common_util.common_util_derived_store import derived_key
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Sangeun_Imported as imp
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
DROP = {"키", "이름", "구분", "상세구분", "본뜬", "메모", "별칭", "바탕판", "원값", "계산값", "열"}
DROP |= {"일위대가번", "종류", "수정일", "출처", "처음수량", "뺀더한줄"} # 744-1 되돌림 기억
UNIT = {"m3": "㎥", "m2": "㎡", "m³": "㎥", "m²": "㎡"}
EMPTY = (None, "", [], {})
CELLS = ("변수", "식", "금액") # 문서 셈 줄 — 셋 다 빈 따로 문서 = 빈 문서
def unit(value: Any) -> str:
@@ -77,6 +84,7 @@ class Same:
def __init__(self) -> None:
self.memo: dict[str, str] = {}
self.lists: dict[tuple[str, str], dict[str, str]] = {}
self.live: dict[str, str] = {} # M01 문서 셈 지문(한 요청 안)
# ── 지문 ──────────────────────────────────────────────────────────
def finger(self, kind: str, doc: Any, trail: tuple = ()) -> str | None:
@@ -87,7 +95,7 @@ class Same:
doc = flat.flat_doc(kind, doc)
body = self._sk(doc, trail) if kind == "sangeun" else self._sc(doc, trail)
if kind == "sangeun" and not any(body.get(k) for k in ("바탕", "더한줄", "가져온")):
if kind == "sangeun" and not any(body.get(k) for k in ("바탕", "더한줄", "가져온", "문서")):
return None
if kind != "sangeun" and not body.get("담은로직") and not body.get("자재"):
return None
@@ -117,10 +125,51 @@ class Same:
line["덮개"] = _bare(line["덮개"])
return norm(line)
def _calls(self, copy: dict) -> dict:
"""부름 문서 셈 지문 — 지금 M01 문서와 다른 것만(만든 때 옛 판 · M01 에서 지운 키)."""
live, out = dc.folder(), {}
for key, one in (copy.get("부름") or {}).items():
if key in live and key not in self.live:
self.live[key] = dc.doc_fp(live[key])
if (got := dc.doc_fp(one)) != self.live.get(key):
out[key] = got
return out
def _formula(self, copy: dict) -> dict:
"""수식 사본 셈 몫(858-G) — 따로 = 문서 · 파생 = 맡긴 덮음 · 값(문서는 줄 규칙이 지음)."""
from M02_MasterTemplete import M02_Doc_Sk as dsk # 늦게 — 셈 묶음(돌림 import 피함)
cell = lambda d: dc.fp(dsk._strip(d)) # noqa: E731 — 덮음 · 값 칸(원값 같은 표지 뺌)
whole = lambda d: [dc.doc_fp(d), cell(dc.mcv.cover_of(d))] # noqa: E731
part = {
"부름": self._calls(copy),
"끊음": {k: whole(d) for k, d in (copy.get("끊음") or {}).items()},
"위덮음": cell(copy.get(dsk.UPPER)) if copy.get(dsk.UPPER) else None,
}
if copy.get("따로"):
doc = copy.get("문서") if isinstance(copy.get("문서"), dict) else {}
part["문서"] = whole(doc) if any(doc.get(k) for k in CELLS) else None
else:
kept = {k: copy.get(k) for k in (renew.COVER, renew.OPTS) if copy.get(k)}
part["맡긴"] = cell(kept) if kept else None
return {k: v for k, v in part.items() if v not in EMPTY}
def _sk(self, doc: dict, trail: tuple) -> dict:
base = doc.get("바탕")
if isinstance(base, dict) and isinstance(base.get("참조"), dict):
base = {"참조": self._ref(base["참조"], trail)}
copy = doc.get(dc.KEY) if dc.has(doc) else None
formula = self._formula(copy) if copy else {}
if copy and copy.get("따로"): # 따로 = 문서가 정본 · 옛 줄 규칙 칸은 셈에 안 씀
body = {
"단위": unit(doc.get("단위")),
"바탕": norm(base), # ① 위덮음 = 지금 기초 것(바탕 로직)
"환산": norm(doc.get("환산")),
"가져온": norm(imp.same_part(doc)), # 단가기준 = 셈 값
"사본": skc.same_part(doc if skc.has(doc) else {skc.KEY: dc.values_of(copy)}),
**formula,
}
return {k: v for k, v in body.items() if v not in EMPTY}
body = {
"단위": unit(doc.get("단위")),
"바탕": norm(base),
@@ -137,6 +186,7 @@ class Same:
**{k: norm(doc.get(k)) for k in ("상수덮개", "표값덮개", "식덮개", "변수줄")},
"가져온": norm(imp.same_part(doc)), # 가져온 식(793-2) = 로직 · 단가기준
"사본": skc.same_part(doc), # 로직 사본(795-1) — 지금 M01 과 다른 판만
**{f"수식{k}": v for k, v in formula.items()}, # 파생 — 맡긴 덮음 · 끊음 · ① · 옛 부름
}
return {k: v for k, v in body.items() if v not in EMPTY}
@@ -151,6 +201,7 @@ class Same:
"자재": _sorted(mats),
"규격": norm(doc.get("규격")),
"사본": skc.same_part(doc), # 로직 사본(795-2) — 지금 M01 과 다른 판만
"부름": self._calls(doc[dc.KEY]) if dc.has(doc) else None, # 옛 판 부름 문서(858-G)
}
return {k: v for k, v in body.items() if v not in EMPTY}
@@ -63,9 +63,11 @@ def _tree(api, url=TREE, **body):
def _world(world):
"""단가산출 하나(운반 3000 · 1 단위)를 구조물 조합 x1(2 단위) · 일위대가가 물게."""
me = world["personal"]
line = {"고정": {"이름": "운반", "단위": "식", "단가": {"경비": 3000}}, "수량": 1}
with store.at(me):
doc = {"이름": "임시 단가산출", "단위": "m", "바탕": None, "더한줄": [line]}
line = {"이름": "운반", "단위": "식", "비목": "경비", "수량": "1", "단가": "3000"}
form = {"꼴": "수식문서", "판": 1, "결과단위": "원/m", "변수": [], "식": [], "금액": [line]}
with store.at(me): # 855 2-C1 — 셈 = 수식 문서(「따로」) 한 길 · 옛 더한줄은 못 셈
copy = {"따로": True, "문서": form, "부름": {}}
doc = {"이름": "임시 단가산출", "단위": "m", "바탕": None, "더한줄": [], "수식": copy}
sk = refs.create("sangeun", doc)["이름"]
top = _sc(me, "위 일위대가", [{"참조": {**MINE, "키": sk}}, FIX])
_labor(me, [{"참조": {**MINE, "키": sk}, "수량": {"손": 2}}, FIX])
+56 -1
View File
@@ -145,7 +145,7 @@ def _finger(answers: list[Any]) -> str:
# ── 견본 ──────────────────────────────────────────────────────────────
# 단가산출 = 화면이 짓는 꼴(바탕 기초 + 「따로」 수식 문서 · 855 2-C1 뒤 셈 한 길) —
# 금액 = 문서 고정 줄 ·
# 같은 내용 지문은 바탕 기초를 보므로(문서 안 봄) 값마다 다른 기초(단위 m)
# 값마다 다른 기초(단위 m) — 858-G 뒤 지문이 문서를 보아도 견본 지문 그대로
BASE = dict(
zip(
(1000, 2000, 3000, 90, 91, 92, 93, 94),
@@ -491,3 +491,58 @@ def test_동시_지우기와_합치기_앞_것만_됨_뒤_합치기는_409(world
assert not (me / "sangeun" / f"{gone}.json").exists()
assert (me / "sangeun" / f"{keep}.json").is_file()
assert [p.stem for p in (me / same_router.GONE).glob("*.json")] == [gone] # 지우기 기록만
def _formula_sk(base: Any, price: int, **more: Any) -> dict[str, Any]:
doc = _doc("sangeun", "", price)
doc = {k: v for k, v in doc.items() if k != "바탕"} | ({"바탕": base} if base else {})
return {**doc, "수식": {**doc["수식"], **more}}
def test_같은_내용_지문이_수식_문서를_봄(shelf, world):
"""858-G — 같은 바탕 · 다른 문서 = 중복 아님 · 같은 문서(바탕 있음 · 없음) = 중복 ·
합치기 → 되돌림 왕복 그대로."""
from M02_MasterTemplete import M02_Library_Same as lsame
s, lib, base = shelf, f"{P}/library/sangeun", {"로직": BASE[1000]}
one = _formula_sk(base, 1000)
docs = {
"가": one,
"가2": one,
"나": _formula_sk(base, 1000, 문서=_formula(5000)), # 같은 바탕 · 수식 고침
"다": _formula_sk(None, 3000), # 바탕 없음
"다2": _formula_sk(None, 3000),
}
keys = {
name: s.go("G", "POST", lib, {"문서": {**doc, "이름": f"sub3임시{name}"}, "새로": True})[
"이름"
]
for name, doc in docs.items()
}
found = s.go("G", "GET", f"{P}/sangeun-same")
groups = sorted(sorted(r["키"] for r in g["문서"]) for g in found["묶음"])
assert groups == sorted([sorted([keys["가"], keys["가2"]]), sorted([keys["다"], keys["다2"]])])
sk = world["personal"] / "sangeun" / f"{keys['다2']}.json"
before = json.loads(sk.read_bytes())
keep = {"층": "personal", "주인": "7/42", "키": keys["다"]}
merge = {"남김": keep, "지움": [keys["다2"]], "판": found["판"]}
got = s.go("G", "POST", f"{P}/sangeun-same/merge", merge)
assert got["합침"] == [{"키": keys["다2"], "옮긴곳수": 0}] and not sk.exists()
s.go("G", "POST", f"{P}/sangeun-same/undo", {"키": keys["다2"]})
assert json.loads(sk.read_bytes()) == before
again = s.go("G", "GET", f"{P}/sangeun-same")
assert sorted(sorted(r["키"] for r in g["문서"]) for g in again["묶음"]) == groups
# 셈에 닿는 덮음 = 다름 · 따로 문서 위 옛 줄 규칙 칸 · 판 · 시점 = 같음
cover = {"기계덮음": {"EQ": {"시간당": 2}}}
assert lsame.finger("sangeun", one) != lsame.finger(
"sangeun", _formula_sk(base, 1000, 문서={**_formula(1000), **cover})
)
assert lsame.finger("sangeun", one) == lsame.finger(
"sangeun", {**one, "입력값": {"규격": "1"}, "수식": {**one["수식"], "판": "x", "시점": "y"}}
)
derived = {**one, "수식": {"부름": {}}} # 파생 — 맡긴 기계 덮음이 셈에 얹힘
assert lsame.finger("sangeun", derived) != lsame.finger(
"sangeun", {**one, "수식": {"부름": {}, **cover}}
)