- 새 M02_San_Workbook — 올린 엑셀을 한 번만 엶(시트 목록 합집합 · xls 서식 책 · 종류 가름 한 말 kind_of) - Hopyo_Excel.read_book · Hopyo_Grid.read · San_Book.sheets · Sangeun_FromHopyo.keep 이 같은 책을 받음 · 전역 _OPENED · _open · opened · _sheets 걷음 - 종류 가름 한 말 — Hopyo_Stmate.is_stmate · San_Book.kind_of 가 Workbook.kind_of 를 씀(단가산출근거 = STmate · 단가산출 = EST) - 올림 길(Router._upload) = 단가산출 시트가 있으면 일위대가 시트 · 호표 없음도 받음(호표 빈 목록 · 단산 목록 보임) · B09 내역서 길(read_book 기본)은 그대로 거절 - 「고를 재료」 판 = 재료판지문(M01 지문 · 별칭 · 자재 칸 포함)이 다르면 다시 셈 · 판 셈 동안 M01 한 벌(M01_MasterData_Store_Cache.steady · M01 파일 안 고침) - 수치: 올림 때 책 열기 2 → 1 · 거창 xlsx 올림 18.0 → 9.0 초 · 판 첫 셈 거창 21.9 → 4.2 · 북부청임도 31.3 → 1.0 · 봉화 34.9 → 1.6 초(재료 종 수 같음) - 지킴: 857-0 블록 전수 3,241 다름 0 · 올림 지문 = 뜻한 바뀜만(2016사방 · 2026수목 거절 → 올라감 · 그 갈래만 다시 뜸 · 재료표 같음) - 시험: 새 test_857_1_workbook(책 한 번 · 종류 · 빈 호표 올림 · 판 무효 · 자국 횟수) · test_857_import_golden 「--write 올림」 갈래 하나 다시 뜨기 - 낡은 시험 고침: test_m02_hopyo_excel(일위대가 · 단가산출 둘 다 없는 책 = 400 · 단가산출만 = 200 호표 0) · test_m02_hopyo_stmate · test_741(옛 _sheets · _xlsx 부름 → 책 한 벌) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
381 lines
16 KiB
Python
381 lines
16 KiB
Python
"""불러오기 재료 고름(PLAN 827-3 · 요구 811-2 · 812-1) — 서버 단독.
|
|
|
|
고름 = 사람이 그 파일 안 한 종(이름 · 규격 · 단위 · 단서 — `kind_of`)에 고른 우리 자재 · 별칭 아님
|
|
(마스터 · M01 · 별칭 칸 · 다른 파일에 안 씀 · 다른 것으로 바뀔 수 있음).
|
|
자리 = 개인 층 `실무자료/재료고름/<파일 지문>.json` {파일, 고름 {종: {키, 이름, 규격, 단위}}} — [끝내기] 뒤에도 남음 ·
|
|
같은 파일(지문)을 다시 올리면 그대로 보임.
|
|
판(`census`) = 그 HP 블록마다 재료 줄 판정(`자원["재료찾기"]` · 827-2)을 종으로 묶음 —
|
|
첫 판 열 때 한 번 셈 → 산근 저장본 칸 `재료판` + `재료판지문`(M01 지문 · 다르면 다시 셈 ·
|
|
857-1) · 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 = "재료판"
|
|
MARK = "재료판지문" # 판을 셀 때 M01 지문(857-1 · 별칭 · 자재가 바뀌면 다시 셈)
|
|
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 _mark() -> str:
|
|
"""판 무효 지문 = M01 지문(첫 층 파일 내용 · 기계 폴더 — 별칭 · 자재 칸 포함 ·
|
|
`San_Basis_Index.stamp`)."""
|
|
from M02_MasterTemplete import M02_San_Basis_Index as basis
|
|
|
|
return basis.stamp()
|
|
|
|
|
|
def census(folder: str | Path, key: str) -> list[dict]:
|
|
"""HP 블록마다 재료 줄 판정 → 종 [{종, 이름, 규격, 단위, 판정, 방법, 키, 후보, 단서, 별도계상, 블록, 줄,
|
|
호표?(828-1 일위 구성 줄 · 코드 숫자)}] — 셈 동안 M01 한 벌(857-1 · 파일 자국 한 번)."""
|
|
from M01_MasterData import M01_MasterData_Store as m01
|
|
|
|
with m01.cache.steady():
|
|
return _census(folder, key)
|
|
|
|
|
|
def _census(folder: str | Path, key: str) -> list[dict]:
|
|
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
|
|
mark = _mark()
|
|
if isinstance(saved.get(CENSUS), list) and saved.get(MARK) == mark:
|
|
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: 블록마다 셈 전부(기계 찾기 포함) — 첫 판 한 번 · 더 느리면 재료 줄만 도는 길
|
|
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_, MARK: mark})
|
|
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
|