Files
Aislo/M02_MasterTemplete/M02_Library_Same.py
T
eomsangdonandClaude Opus 5.5 c8c061bb10 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>
2026-11-18 00:48:36 +09:00

269 lines
13 KiB
Python

"""M02 서고 문서 내용 지문 · 같은 것 찾기(PLAN 733-1 · 요구서_572 3장 1 · 서버 단독).
지문 = 단가산출(SK) · 일위대가(SC) 셈에 닿는 내용만 정규화해 `derived_key` —
뺌 = 키 · 이름 · 구분 · 상세구분 · 본뜬 · 메모 · 별칭 · 바탕판 · 원값 · 계산값 · 열 · 일위대가번 · 종류 ·
날짜(수정일) · 고정 줄 출처
수 = Decimal 정규화(0.20 = 0.2 = 「0.2」) · 글 = 겹 빈칸 정리 · 빈 값 칸 뺌 · 단위 = 소문자 + m3 → ㎥
차례 무시 = 더한줄 · 담은로직 · 자재 · 뺀줄 · 열린입력 정렬 · 더한줄 요소 줄 이름 뺌(요소 키가 정체)
SC 줄 · 자재 수량(742-1 저장 수량) · SK 더한줄 수량 넣음
참조 = 가리킨 문서의 지문(깊이 `refs.DEPTH` · 층 넘어 사본도 같음)
SK 수식 사본(858-G · 셈 정본 = 수식 문서) — 따로 = 문서 셈 칸(`doc_fp`) · ② 기계 덮음 · 끊음 ·
① 위덮음(옛 줄 규칙 칸 뺌 — 셈에 안 씀) · 파생 = 줄 규칙 칸 + 맡긴 덮음 · 값 + 끊음 · ① ·
둘 다 부름 문서는 지금 M01 과 다른 것만(같으면 빠짐 = 저장 전 문서와 같은 지문 · SC 도) ·
판 · 시점 · 이름표 = 뺌.
빈 문서(SK 바탕 · 더한줄 · 셈 칸 든 따로 문서 없음 · SC 줄 · 자재 없음) = 지문 None(검사 안 함).
저장 칸 없음 — 그때그때 셈(`Same` 한 벌 = 한 요청 안 메모).
`find_same(folder, kind, doc)` = 같은 층 같은 내용 키(작은 번호 = 먼저 만든 것 먼저) ·
`find_above(folder, kind, doc)` = 위 층(회사 · 마스터) 같은 내용 참조 `[{층, 주인, 키}]`.
"""
from __future__ import annotations
import json
from decimal import Decimal, InvalidOperation
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:
text = "".join(str(value or "").split()).lower()
return UNIT.get(text, text)
def _num(text: str) -> str | None:
try:
got = Decimal(text.replace(",", ""))
except (InvalidOperation, ValueError):
return None
return format(got.normalize(), "f") if got.is_finite() else None
def norm(value: Any) -> Any:
if isinstance(value, dict):
out = {str(k): norm(x) for k, x in value.items() if k not in DROP}
return {k: x for k, x in out.items() if x not in EMPTY}
if isinstance(value, list):
return [norm(x) for x in value]
if isinstance(value, bool) or value is None:
return value
if isinstance(value, (int, float)):
return _num(str(value))
if isinstance(value, str):
text = " ".join(value.split())
got = _num(text) if text and (text[0].isdigit() or text[0] in "-.") else None
return text if got is None else got
return value
def _sorted(lines: list) -> list:
return sorted(lines, key=lambda x: json.dumps(x, ensure_ascii=False, sort_keys=True))
def _bare(cover: Any) -> dict:
return {
c: {k: v for k, v in (d or {}).items() if k != "원값"} for c, d in (cover or {}).items()
}
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:
if not isinstance(doc, dict):
return None
if not trail: # 740-1 — 옛 참조 줄 = 펼친 꼴로 대조(펼쳐 담은 문서와 같은 지문)
from M02_MasterTemplete import M02_Library_Flat as flat
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 ("바탕", "더한줄", "가져온", "문서")):
return None
if kind != "sangeun" and not body.get("담은로직") and not body.get("자재"):
return None
return f"{refs.PREFIX.get(kind, kind)}:{derived_key(body)}"
def _ref(self, ref: Any, trail: tuple) -> Any:
if not isinstance(ref, dict):
return norm(ref)
rid = refs.ref_id(ref)
if rid not in self.memo:
doc = refs.read_ref(ref) if rid not in trail and len(trail) <= refs.DEPTH else None
got = self.finger(refs.kind_of(ref.get("키")), doc, (*trail, rid)) if doc else None
self.memo[rid] = got or f"없음:{rid}"
return {"내용": self.memo[rid]}
def _line(self, one: Any, trail: tuple, qty: bool) -> Any:
if not isinstance(one, dict):
return norm(one)
line = dict(one)
if isinstance(line.get("참조"), dict):
line["참조"] = self._ref(line["참조"], trail)
if not qty and not refs.is_rate(line):
line["수량"] = None
if line.get("요소"):
line.pop("이름", None)
if isinstance(line.get("덮개"), dict):
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),
"입력값": norm(doc.get("입력값") or {}),
"환산": norm(doc.get("환산")),
"켜쌓기율": norm(doc.get("켜쌓기율")),
"열린입력": sorted(map(str, doc.get("열린입력") or [])),
"고름": norm(doc.get("고름") or {}),
"자재표시": norm(doc.get("자재표시") or {}),
"덮개": norm(_bare(doc.get("덮개"))),
"더한줄": _sorted([self._line(x, trail, True) for x in doc.get("더한줄") or []]),
"뺀줄": sorted(map(str, doc.get("뺀줄") or [])),
# 값 바꾸는 새 칸(790-2 · 792-1) — 없으면 빠짐 = 옛 지문 그대로
**{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}
def _sc(self, doc: dict, trail: tuple) -> dict:
mats = [
norm({k: v for k, v in m.items() if k != "수량"} if isinstance(m, dict) else m)
for m in doc.get("자재") or []
]
body = {
"단위": unit(doc.get("단위")),
"담은로직": _sorted([self._line(x, trail, False) for x in doc.get("담은로직") or []]),
"자재": _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}
# ── 층 훑기 ───────────────────────────────────────────────────────
def listed(self, folder: str | Path, kind: str) -> dict[str, str]:
"""층 `{키: 지문}`(빈 문서 뺌 · 키 차례)."""
at = (str(Path(folder).resolve()), kind)
if at not in self.lists:
out = {}
for path in sorted((Path(folder) / kind).glob(f"{refs.PREFIX[kind]}-*.json")):
try:
got = self.finger(kind, json.loads(path.read_bytes()))
except (OSError, ValueError):
continue
if got:
out[path.stem] = got
self.lists[at] = out
return self.lists[at]
def add(self, folder: str | Path, kind: str, key: str, doc: Any) -> None:
"""새로 쓴 문서를 메모 목록에 더함(다시 훑지 않음)."""
got = self.finger(kind, doc)
if got:
self.listed(folder, kind)[key] = got
def find_same(
self, folder: str | Path, kind: str, doc: Any, skip: str | None = None
) -> list[str]:
"""같은 층 같은 내용 키(작은 번호 먼저 · `skip` = 자기 키 뺌)."""
want = self.finger(kind, doc)
if not want:
return []
return [k for k, v in self.listed(folder, kind).items() if v == want and k != skip]
def find_above(self, folder: str | Path, kind: str, doc: Any) -> list[refs.Ref]:
"""위 층(회사 · 마스터) 같은 내용 참조 `[{층, 주인, 키}]`."""
want = self.finger(kind, doc)
out: list[refs.Ref] = []
for layer, owner in above(refs.where(folder)) if want else []:
here = refs.folder_of(layer, owner)
for key, got in self.listed(here, kind).items():
if got == want:
out.append({"층": layer, "주인": owner, "키": key})
return out
def above(at: refs.Here) -> list[refs.Here]:
"""위 층 — 개인 C/U → 회사 C · 마스터 / 회사 → 마스터 / 마스터 · 프로젝트 → 없음."""
layer, owner = at
if layer == "personal":
return [("company", str(owner).split("/")[0]), ("system", None)]
return [("system", None)] if layer == "company" else []
def finger(kind: str, doc: Any) -> str | None:
return Same().finger(kind, doc)
def find_same(folder: str | Path, kind: str, doc: Any, skip: str | None = None) -> list[str]:
return Same().find_same(folder, kind, doc, skip)
def find_above(folder: str | Path, kind: str, doc: Any) -> list[refs.Ref]:
return Same().find_above(folder, kind, doc)