Files
Aislo/M02_MasterTemplete/M02_San_MatPick.py
T
eomsangdonandClaude Opus 5.5 0d44d6346b chore(853-3): 단가산출 계보 죽은 것 걷음 — 묶음 ③
- 길 POST sangeun/imported(만들기 · TS 0 — 화면은 from-hopyo 만) + ImportedBody 지움 · 서버 길 482 → 481
- San_Book.est_prices · applied · _hcol(부르는 곳 0 · applied · _hcol 은 est_prices 만 씀) · San_MatPick.item_key · San_Stmate.parse_block(시험만) 지움
- 남김: Sangeun_Imported.create — 길은 걷혔으나 시험 11 파일(793-2 · 792-3 · 795-1 · 796-2b · 796-2d · 802-4b1 · 822-1 · 823-1 · 836-2 …)이 가져온 식 SK 바탕을 만드는 입구로 씀(keep(new_doc) 한 줄) — 머리 글에 적음
- 시험: 793-2 san_emit · 797-1a 줄 나무 = 지금 길과 같은 parse_line 줄마다(시험 안 _nodes) · 797-1a applied → applied_how[0] · 827-3 item_key 확인 줄 뺌(바로 위 줄이 같은 값을 봄)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 15:35:24 +09:00

363 lines
16 KiB
Python

"""불러오기 재료 고름(PLAN 827-3 · 요구 811-2 · 812-1) — 서버 단독.
고름 = 사람이 그 파일 안 한 종(이름 · 규격 · 단위 · 단서 — `kind_of`)에 고른 우리 자재 · 별칭 아님
(마스터 · M01 · 별칭 칸 · 다른 파일에 안 씀 · 다른 것으로 바뀔 수 있음).
자리 = 개인 층 `실무자료/재료고름/<파일 지문>.json` {파일, 고름 {종: {키, 이름, 규격, 단위}}} — [끝내기] 뒤에도 남음 ·
같은 파일(지문)을 다시 올리면 그대로 보임.
판(`census`) = 그 HP 블록마다 재료 줄 판정(`자원["재료찾기"]` · 827-2)을 종으로 묶음 —
첫 판 열 때 한 번 셈 → 산근 저장본 칸 `재료판`(HP 지울 때 같이 지움).
만들기(`using` → `M02_Sangeun_FromHopyo._emit` 이 `apply`) = 고른 종 줄: 이음 = 고른 키 · `재료찾기.고름`
(문서 셈 = 우리 값 · 엑셀 값 기억 없음 · `M02_Doc_Import._attach`) · 별도계상 줄 = `고름` 만(줄 이음 · 단가 0 그대로).
문서 머리 `가져온.재료` = [{기호, 종, 원래, 판정, 방법, 키, 후보, 단서, 별도계상?, 고름?, 처음}](`entry` ·
처음 = 가져온 그대로의 연결 — 고름 풀기 · 사람이 따로 바꾼 줄 가름).
이미 만든 SK(`apply_made`) = 원본 지문이 같은 SK 문서 — 가져온 그대로인 줄만(「바꿈」 · 사람이 고른 줄 · 고친 값 뺌) →
수식 길 저장(서버가 다시 셈).
"""
from __future__ import annotations
import copy as cp
import json
from contextlib import contextmanager
from contextvars import ContextVar
from pathlib import Path
from typing import Any
from common_util.common_util_json import atomic_write_json
from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store
from M02_MasterTemplete import M02_MasterTemplete_Store as store
DIRNAME = "재료고름"
CENSUS = "재료판"
KINDS = (
"규격 없음 — 고르기",
"단위 다름 — 고르기", # 840-3
"후보 여럿",
"우리 표에 없음",
"이어짐",
) # 판 차례(`M02_San_MatFind`)
MAX_PICKS = 2000
_PICKS: ContextVar[dict | None] = ContextVar("재료고름", default=None)
def _text(v: Any) -> str:
return " ".join(str(v or "").split())
def kind_of(res: dict) -> str:
"""종 열쇠 — 가져온 자원 이름 · 규격 · 단위 + 판정 단서(같은 이름이라도 산근 머리 Φ800 · Φ1000 은 다른 종)."""
found = res.get("재료찾기") or {}
head = "|".join(_text(res.get(k)) for k in ("이름", "규격", "단위"))
return head + "|" + ";".join(_text(x) for x in found.get("단서") or [])
def _apart(res: dict) -> bool:
from M02_MasterTemplete import M02_San_Link as link
return link.apart({"이름": res.get("이름") or "", "규격": res.get("규격") or ""})
def _pick(raw: Any) -> dict | None:
if not isinstance(raw, dict) or not str(raw.get("키") or "").strip():
return None
return {k: _text(raw.get(k)) for k in ("키", "이름", "규격", "단위")}
# ── 고름 자리(개인 층) ────────────────────────────────────────────────────
def _path(folder: str | Path, fp: str) -> Path:
if not fp or not fp.isalnum() or len(fp) > 128:
raise store.StoreError(400, "파일 지문")
return hopyo_store._dir(folder) / DIRNAME / f"{fp}.json"
def read(folder: str | Path, fp: str) -> dict[str, Any]:
"""{파일, 고름 {종: 고른 것}} — 없으면 빈 것."""
try:
got = json.loads(_path(folder, fp).read_bytes())
except (OSError, ValueError):
return {"파일": "", "고름": {}}
picks = got.get("고름") if isinstance(got.get("고름"), dict) else {}
return {
"파일": str(got.get("파일") or ""),
"고름": {k: p for k, v in picks.items() if (p := _pick(v))},
}
def merge(now: dict, picks: dict | None) -> dict[str, dict]:
"""있던 고름 + 새 고름(None = 풀기) — 안 씀(미리 보기 · 835-1)."""
mine = dict(now)
for k, v in (picks or {}).items():
if (p := _pick(v)) is None:
mine.pop(str(k), None)
else:
mine[str(k)] = p
return mine
def write(folder: str | Path, fp: str, name: str, picks: dict) -> dict[str, dict]:
"""종마다 고른 것(None = 고름 풀기)을 얹어 씀 → 지금 고름 전부."""
now = read(folder, fp)
mine = merge(now["고름"], picks)
if len(mine) > MAX_PICKS:
raise store.StoreError(400, "고름이 너무 많음")
path = _path(folder, fp)
path.parent.mkdir(parents=True, exist_ok=True)
atomic_write_json(path, {"파일": name or now["파일"], "고름": mine})
return mine
# ── 만들기 ───────────────────────────────────────────────────────────────
@contextmanager
def using(picks: dict | None):
"""이 안에서 만드는 가져온 식 SK(안쪽 블록 포함)에 그 파일 고름을 얹음."""
token = _PICKS.set(picks or None)
try:
yield
finally:
_PICKS.reset(token)
def apply(logic: dict) -> int:
"""만들 로직 줄에 고름 얹음 → 얹은 줄 수(고름 없으면 0 · 엔진 판정 그대로)."""
picks, n = _PICKS.get(), 0
for item in (logic or {}).get("호표") or [] if picks else []:
res = item.get("자원") or {}
found = res.get("재료찾기")
if not found or not (p := picks.get(kind_of(res))):
continue
res["재료찾기"] = {**found, "고름": p}
if not _apart(res):
item["이음"] = p["키"]
n += 1
return n
def chosen(item: dict) -> dict | None:
"""그 줄 고름(별도계상 아님) — 문서 셈 = 우리 값."""
res = item.get("자원") or {}
got = (res.get("재료찾기") or {}).get("고름")
return got if got and not _apart(res) else None
def apart_note(found: dict) -> str:
"""별도계상 줄 설명 — 품목이 있으면 「별도계상 · 품목: 이름 규격」."""
from M02_MasterTemplete import M02_San_Link as link
key = (found.get("고름") or {}).get("키") or found.get("키")
if not key:
return link.APART
one = found.get("고름") or next(
(c for c in found.get("후보") or [] if c.get("키") == key), None
)
if one is None: # 엔진이 이은 품목 = 우리 자재표 줄
from M02_MasterTemplete import M02_San_MatFind as mf
one = ((mf._row(key) or {}).get("row") or {}).get("one") or {}
what = f"{_text(one.get('이름'))} {_text(one.get('규격'))}".strip() or key
return f"별도계상 · 품목: {what} · 셈은 프로젝트에서"
def entry(item: dict, sym: str, excel: Any) -> dict | None:
"""문서 머리 `가져온.재료` 한 칸(재료 찾기 판정 있는 줄만)."""
res = item.get("자원") or {}
found = res.get("재료찾기")
if not found:
return None
one = {
"기호": sym,
"종": kind_of(res),
"원래": {k: _text(res.get(k)) for k in ("이름", "규격", "단위")},
}
one |= {k: found.get(k) for k in ("판정", "방법", "키", "후보", "단서")}
if _apart(res):
one["별도계상"] = True
elif found.get("키"):
one["처음"] = {"갈래": "요소", "키": found["키"], "엑셀": excel}
else:
one["처음"] = {"갈래": "숫자", "값": excel}
return one | ({"고름": found["고름"]} if found.get("고름") else {})
# ── 판(그 파일 재료 종) ──────────────────────────────────────────────────
def census(folder: str | Path, key: str) -> list[dict]:
"""HP 블록마다 재료 줄 판정 → 종 [{종, 이름, 규격, 단위, 판정, 방법, 키, 후보, 단서, 별도계상, 블록, 줄,
호표?(828-1 일위 구성 줄 · 코드 숫자)}]."""
from M02_MasterTemplete import M02_Doc_FromNative as fn
from M02_MasterTemplete import M02_Sangeun_FromHopyo as fh
hopyo_store.read(folder, key) # 없는 HP = 404
path = fh._path(folder, key)
try:
saved = json.loads(path.read_bytes())
except (OSError, ValueError) as e:
raise store.StoreError(409, fh.RELOAD) from e
if isinstance(saved.get(CENSUS), list):
return saved[CENSUS]
native = saved.get("원파일")
src = native if isinstance(native, dict) else fh._excel_of(path, saved) if saved.get("시트") else {} # fmt: skip
groups: dict[str, dict] = {}
# ponytail: 블록마다 셈 전부(기계 찾기 포함 · 70 블록 10~20 초) — 첫 판 한 번 · 느리면 재료 줄만 도는 길
for no in sorted(fn.numbers(src)) if src else []:
with using(None):
try:
out = fn.emit(src, no)
except Exception: # noqa: BLE001 — 못 옮기는 블록 = 판에서 뺌(만들기 때 그 까닭이 보임)
continue
for item in out["로직"].get("호표") or []:
res = item.get("자원") or {}
found = res.get("재료찾기")
if not found:
continue
k = kind_of(res)
g = groups.setdefault(
k,
{"종": k, **{x: _text(res.get(x)) for x in ("이름", "규격", "단위")},
**{x: found.get(x) for x in ("판정", "방법", "키", "후보", "단서")},
"별도계상": _apart(res), "블록": [], "줄": 0},
) # fmt: skip
g["줄"] += 1
if no not in g["블록"]:
g["블록"].append(no)
from M02_MasterTemplete import M02_San_Ilwi as il
for b, _, res in il.materials(src) if src else (): # 828-1 일위 구성 줄(호표 = 코드 숫자)
if not (found := res.get("재료찾기")):
continue
k = kind_of(res)
g = groups.setdefault(
k,
{"종": k, **{x: _text(res.get(x)) for x in ("이름", "규격", "단위")},
**{x: found.get(x) for x in ("판정", "방법", "키", "후보", "단서")},
"별도계상": _apart(res), "블록": [], "줄": 0},
) # fmt: skip
g["줄"] += 1
hp = g.setdefault("호표", [])
if (n := int(str(b["코드"])[1:])) not in hp:
hp.append(n)
out_ = sorted(groups.values(), key=lambda g: (KINDS.index(g["판정"]) if g["판정"] in KINDS else 9, -len(g["블록"]), g["이름"])) # fmt: skip
atomic_write_json(path, {**saved, CENSUS: out_})
return out_
def fingerprint(folder: str | Path, key: str) -> tuple[str, str]:
hp = hopyo_store.read(folder, key)
return str(hp.get("지문") or ""), str(hp.get("파일") or "")
# ── 이미 만든 SK ─────────────────────────────────────────────────────────
def made(folder: str | Path, fp: str) -> list[str]:
"""그 층 가져온 식 SK 가운데 원본 지문이 같은 것."""
out = []
for path in sorted((Path(folder) / "sangeun").glob("SK-*.json")):
try:
doc = json.loads(path.read_bytes())
except (OSError, ValueError):
continue
src = ((doc.get("가져온") or {}).get("원본") or {}) if isinstance(doc, dict) else {}
if fp and src.get("지문") == fp:
out.append(path.stem)
return out
def _same(a: Any, b: Any) -> bool:
"""연결이 가져온 그대로(갈래 · 키 · 숫자 값)."""
if not isinstance(a, dict) or not isinstance(b, dict) or a.get("바꿈"):
return False
if a.get("갈래") != b.get("갈래") or a.get("키") != b.get("키"):
return False
if a.get("갈래") == "숫자":
return json.dumps(a.get("값"), default=str) == json.dumps(b.get("값"), default=str) or _num(a.get("값")) == _num(b.get("값")) # fmt: skip
return a.get("갈래") != "요소" or "엑셀" in a
def _num(v: Any) -> Any:
try:
return round(float(v), 6)
except (TypeError, ValueError):
return v
def patch(doc: dict, picks: dict, kinds: set | None = None) -> int:
"""문서 `가져온.재료` 줄에 고름 얹음 · 풂 → 고친 줄 수(사람이 따로 바꾼 줄 · 「바꿈」 줄 그대로)."""
import master_doc as md # `M02_Doc_Copy` 가 scripts 를 길에 둔 뒤
by = {md.var_id(v): v for v in doc.get("변수") or []}
n = 0
for e in (doc.get("가져온") or {}).get("재료") or []:
if kinds is not None and e.get("종") not in kinds:
continue
p, was = picks.get(e.get("종")), e.get("고름")
var = by.get(e.get("기호"))
if (p or {}).get("키") == (was or {}).get("키") or var is None:
continue
link = var.get("연결") or {}
if e.get("별도계상"):
e.pop("고름", None) if p is None else e.__setitem__("고름", p)
var["설명"] = (
f"이음 없음 — {apart_note(e)} · 엑셀 단가 그대로" # `Doc_Import._attach` 꼴
)
n += 1
continue
mine = was and link.get("갈래") == "요소" and link.get("키") == was.get("키") and "엑셀" not in link and not link.get("바꿈") # fmt: skip
if not (mine or _same(link, e.get("처음"))):
continue
if p:
var["연결"] = {"갈래": "요소", "키": p["키"]}
e["고름"] = p
else:
var["연결"] = cp.deepcopy(e.get("처음"))
e.pop("고름", None)
n += 1
return n
def apply_made(fp: str, picks: dict, kinds: set | None = None, skip: tuple = ()) -> dict[str, list]:
"""지금 층(`store.root`) 그 파일 SK 에 고름 얹어 저장 → {고침, 그대로}(가져온 그대로인 줄만 바뀜)."""
from M02_MasterTemplete import M02_Doc_Sk_Path as skpath
from M02_MasterTemplete import M02_Sangeun_Doc as sd
fixed, kept = [], []
for key in made(store.root(), fp):
if key in skip:
continue
got = store.read(sd.KIND, key)
doc = cp.deepcopy(skpath.current(got["문서"])["문서"])
if not patch(doc, picks, kinds):
kept.append(key)
continue
skpath.save(key, {"문서": doc, "판": got["판"]})
fixed.append(key)
return {"고침": fixed, "그대로": kept}
def uses(fp: str, kind: str, skip: tuple = ()) -> list[str]:
"""지금 층 그 파일 SK 가운데 그 종 줄이 있는 것(SK 상세 물음 · 저장 없음)."""
from M02_MasterTemplete import M02_Sangeun_Doc as sd
out = []
for key in made(store.root(), fp):
if key in skip:
continue
doc = json.loads((store.root() / sd.KIND / f"{key}.json").read_bytes())
lines = ((doc.get("가져온") or {}).get("로직") or {}).get("호표") or []
if any(kind_of(x.get("자원") or {}) == kind for x in lines if (x.get("자원") or {}).get("재료찾기")): # fmt: skip
out.append(key)
return out
def tally(folder: str | Path, fp: str, kind: str) -> dict | None:
"""그 층 작업 중 HP(같은 지문) 판에서 그 종 {블록, 줄} 수 — 판을 아직 안 셈 · HP 없음 = None."""
from M02_MasterTemplete import M02_Sangeun_FromHopyo as fh
for row in hopyo_store.rows(folder):
if row.get("지문") != fp:
continue
try:
got = json.loads(fh._path(folder, row["키"]).read_bytes()).get(CENSUS)
except (OSError, ValueError):
continue
for g in got or []:
if g.get("종") == kind:
return {"블록": len(g.get("블록") or []), "줄": g.get("줄") or 0}
return None