- 서버 `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>
181 lines
6.8 KiB
Python
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)
|