Files
Aislo/M02_MasterTemplete/M02_Sk_EditCount.py
T
eomsangdonandClaude Opus 5.5 f7850e21ab feat(860-2): 서고 단가산출 목록 「고친 줄」 → 「고친 칸」 = 줄 쌓기 파란 테두리 칸 수(늘 0 이던 것)
- 서버 `M02_Sk_EditCount` — 지금 수식 문서 대 위 층 문서(읽기 답 층바탕.위) 값 칸 · 단위 · 금액 줄 칸 + 더한 · 차례 바뀐 · 빠진 줄 + 기계 고침 칸 · 따로 아님 = 0
- 짝 = `common_util_line_stack_diff.ts` docDiff(화면 파란 테두리) · 거울 시험 test_860_2_edit_count(수식 문서 전수 × 고침 갈래 · 같음)
- 열 이름 「고친 칸」(칸 수라 줄 아님) · 목록 칸 이름 고친줄수 → 고친칸수
- 옛 셈(덮개 · 더한줄 · 뺀줄 줄 수) 걷음 — 새 꼴 SK 는 옛 칸이 없어 늘 0 이었음
- test_717_2a: 칸 이름만 고침 · test_858_shelf_golden: 지문 다시 뜸 — 바뀐 갈래 다섯은 목록 줄 「고친칸수」 칸만(이름 · 값을 옛 꼴로 되돌리면 옛 지문과 같음 확인)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 10:12:17 +09:00

181 lines
6.8 KiB
Python

"""M02 단가산출(SK) 내가 고친 칸 수(PLAN 860-2 ② · 요구 910) — 서고 › 단가산출 목록 「고친 칸」 열.
파이썬 · TS 짝 — 짝 = `common_util/common_util_line_stack_diff.ts` `docDiff`
(줄 쌓기 파란 테두리 · 위 층 없이 = 나만) · 거울 시험 `resources/tester/test_860_2_edit_count.py`.
셈 = 지금 수식 문서(`수식.문서`) 대 위 층 문서(읽기 답 `층바탕.위` · `M02_Doc_Sk_Path.layers`) —
값 칸(`v:` 값 정의 · `u:` 단위 · `m:` 금액 줄 이름 · 단가 · 수량 · 단위 · 비목) +
줄 틀(더한 줄 · 차례 바뀐 줄) + 빠진 줄 +
기계 고침(`기계덮음` — 기계마다 값 칸 수 · 조종원 · 잡품 목록 하나씩).
줄 쌓기 차림(항목 제목 `t:` · 글 줄 `g:`)은 값이 아니라 안 셈.
따로 아닌 SK(파생 = 고침 없음) = 0 · 위 층 문서를 모름 = 기계 고침만.
"""
from __future__ import annotations
import json
import re
from typing import Any
from M02_MasterTemplete import M02_Doc_Copy as dc # 수식 문서 기호 열쇠 `dc.md.var_id`
LINE_FIELDS = ("이름", "단가", "수량", "단위", "비목")
COVER = "기계덮음"
_NO = object() # TS undefined
_NUM = re.compile(r"^-?[\d,]*\.?\d+$")
def canon(x: Any) -> Any:
"""견줌 꼴(TS `canon`) — 수 글 = 수 · 빈 값 = 없음 · 글 띄어쓰기 뺌 · 묶음 칸 차례 무시."""
if x is None or x is _NO:
return _NO
if isinstance(x, str):
t = re.sub(r"\s+", "", x)
if not t:
return _NO
if _NUM.match(t):
try:
return _num(float(t.replace(",", "")))
except ValueError:
return t
return t
if isinstance(x, list):
return [None if (v := canon(y)) is _NO else v for y in x] if x else _NO
if isinstance(x, dict):
out = {k: v for k in sorted(x) if (v := canon(x[k])) is not _NO}
return out or _NO
if isinstance(x, float):
return _num(x)
return x
def _num(v: float) -> Any:
return int(v) if v.is_integer() else v
def same(a: Any, b: Any) -> bool:
return canon(a) == canon(b)
def _key(x: Any) -> str:
"""금액 줄 짝 열쇠(TS `JSON.stringify(canon(단가))`)."""
got = canon(x)
return "∅" if got is _NO else json.dumps(got, ensure_ascii=False, sort_keys=True)
def _vars(doc: dict) -> dict[str, dict]:
return {dc.md.var_id(v): v for v in doc.get("변수") or [] if isinstance(v, dict)}
def _steps(doc: dict) -> dict[str, str]:
return {
str(x.get("기호") if x.get("기호") is not None else ""): str(
x.get("식") if x.get("식") is not None else ""
)
for x in doc.get("식") or []
if isinstance(x, dict)
}
def _value_at(vars_: dict, steps: dict, vid: str) -> Any:
v, s = vars_.get(vid), steps.get(vid, _NO)
if not v and s is _NO:
return _NO
v = v or {}
return {"변수": True if v else _NO, "연결": v.get("연결"), "식": s, "이름": v.get("이름")}
def _line_val(line: Any, field: str) -> Any:
if not isinstance(line, dict):
return _NO
if field == "이름":
return {"이름": line.get("이름"), "규격": line.get("규격")}
return line.get(field)
def match_lines(now: list, up: list) -> list[int]:
"""금액 줄 짝(TS `matchLines`) — 지금 차례 → 위 층 차례(-1 = 없음)."""
pool: dict[str, list[int]] = {}
for j, line in enumerate(up):
pool.setdefault(_key(line.get("단가")), []).append(j)
out = []
for line in now:
hit = pool.get(_key(line.get("단가")))
out.append(hit.pop(0) if hit else -1)
free = [j for j in range(len(up)) if j not in out]
for i, line in enumerate(now):
if out[i] >= 0 or canon(line.get("이름")) is _NO:
continue
at = next((n for n, j in enumerate(free) if same(up[j].get("이름"), line.get("이름"))), -1)
if at >= 0:
out[i] = free.pop(at)
return out
def _moved(match: list[int]) -> set[int]:
"""차례 바뀐 짝 줄 — 가장 긴 오름 차례에 안 든 것(TS `movedOf`)."""
at = [(b, i) for i, b in enumerate(match) if b >= 0]
size, prev = [], []
for k, (b, _) in enumerate(at):
size.append(1)
prev.append(-1)
for p in range(k):
if at[p][0] < b and size[p] + 1 > size[k]:
size[k], prev[k] = size[p] + 1, p
keep: set[int] = set()
k = size.index(max(size)) if size else -1
while k >= 0:
keep.add(at[k][1])
k = prev[k]
return {i for _, i in at if i not in keep}
def count(now: Any, up: Any) -> int:
"""지금 문서 대 위 층 — 내가 고친 값 칸 + 줄 틀 + 빠진 줄(기계 고침 뺌 · `covers`)."""
now, up = (x if isinstance(x, dict) else {} for x in (now, up))
nv, uv, ns, us = _vars(now), _vars(up), _steps(now), _steps(up)
marks = 0
for vid in {*nv, *ns}:
marks += not same(_value_at(nv, ns, vid), _value_at(uv, us, vid))
if vid in uv or (nv.get(vid) or {}).get("단위"):
marks += not same((nv.get(vid) or {}).get("단위"), (uv.get(vid) or {}).get("단위"))
nl = [x if isinstance(x, dict) else {} for x in now.get("금액") or []]
ul = [x if isinstance(x, dict) else {} for x in up.get("금액") or []]
match = match_lines(nl, ul)
for i, b in enumerate(match):
if b >= 0:
marks += sum(not same(_line_val(nl[i], f), _line_val(ul[b], f)) for f in LINE_FIELDS)
lines = sum(b < 0 for b in match) + len(_moved(match))
has_items = any(now.get(k) for k in ("쌓기", "금액", "변수", "식"))
gone = sum(j not in match for j in range(len(ul))) if has_items else 0
return marks + lines + gone
def covers(doc: Any) -> int:
"""기계 고침 칸 — 기계마다 값 칸 수 + 조종원 · 잡품 목록 하나씩."""
cover = doc.get(COVER) if isinstance(doc, dict) else None
if not isinstance(cover, dict):
return 0
return sum(
len(one.get("값") or {}) + bool(one.get("조종원")) + bool(one.get("잡품"))
for one in cover.values()
if isinstance(one, dict)
)
def of_sk(sk: Any) -> int:
"""SK 문서 → 내가 고친 칸 수(목록 「고친 칸」) · 따로 아님 = 0 · 못 셈 = 0."""
from M02_MasterTemplete import M02_Doc_Sk as dsk
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_MasterTemplete_Store as store
held = sk.get(dsk.KEY) if isinstance(sk, dict) else None
if not (isinstance(held, dict) and held.get("따로")) or not dsk.own(sk):
return 0
try:
copy = path.current(sk)
up = path.layers(copy, sk).get("위")
except (store.StoreError, ArithmeticError, KeyError, TypeError, ValueError):
return 0
doc = copy.get("문서") or {}
return (count(doc, up) if up else 0) + covers(doc)