Files
Aislo/M02_MasterTemplete/M02_Sangeun_FromHopyo.py
T
eomsangdonandClaude Opus 5.5 ec761d0948 refactor(857-3b): 불러온 단가산출 정본 = 수식 문서 — 저장본 가져온.로직 걷음 · 고침 길 = 문서 연결 · 옛 꼴 = 까닭 하나
- 저장 꼴: SK `가져온` = {문서(불러온 그대로 수식 문서 · 정본), 원본, 단가기준, 검산, 연결?} · 가져온 줄(옛 로직 줄 꼴) 안 둠 · 다시 열기 = 저장 문서(Doc_Import.derive) · 고침 = 수식 따로 사본 · [초기화] = 가져온.문서
- 짓기: 불러올 때 한 번(Doc_Import.build · San_ToDoc · 줄 검사 = 문서 파서) · 검산 = 불러올 때 한 번(check_row · 옛 변환기 안 부름) · 뒤 저장 = 저장 파일 검산(화면 값 안 받음)
- 고침 길: 이음 고침 = 그 가져온 줄 값 변수 연결(자리 = 호표:i · 엑셀 값 기억) · 소요량 고름 = 문서 그 수 → 표 연결 변수 · 풂 = 수 되돌림(자리 = 문서 머리 가져온.자리) · [저장] 처음 = 고친 미리 보기 문서 위에 안쪽 산근 참조 · 내 기계만 얹음(FromHopyo._onto) · 재료 고름 판 = 문서 머리 재료
- 둘레: 형제 SK 참조 = 문서 연결(Labor_Ref refs_in · _move_doc → imp.refs_of · move_refs) · 값 사본 닿을 것 = 문서 연결 + 기계 판정 키(Sangeun_Copy.stamp · reach_of) · B09 굳힌 사본 = 가져온 늘 실음 · 단가 묶음에 사본 요소(Item_Sangeun) · Doc_Sk old_only 가져온 식도 · frozen 가져온 식 빼고 · old_fp 옛 꼴만 · 우리 단가 색인 = 받은 색인 위(B09 사본 단가 전파)
- 옛 꼴 저장본(가져온.로직) = 읽지 않음 · 지우지 않음 · 셈 · 검산 · 고침 = 까닭 「옛 꼴로 저장된 불러온 단가산출 — 엑셀 · 원파일을 다시 불러와 저장」 · 가져온 식 옛 칸 고침(덮개 · 더한줄 · 식 칸) = 못 셈(2-C1 과 같게)
- 857-3a 더한줄 갈래(San_ToDoc 요소 · 로직 부름) 걷음 · test_857_3a_import_adds 지움(가져온 식 옛 칸 = 죽은 길 · 대신 test_793_2 옛_칸_고침_못_셈 · 옛_꼴_저장본_까닭_하나)
- 화면: 가져온 식 판정 = 문서 | 옛 로직 · 옛 꼴 = 이음 · 소요량 안 부름(Hopyo_Imported_Model · Hopyo_Imported · Sangeun_Origin)
- 뜻한 바뀜: 불러온 문서 다듬기가 글줄 이름으로(저장 길에서도 지은 「율」 → 엑셀 글 머리 · 704 · test_809_1 · 812_3) · golden_855_b09 daega_inputs 다시 뜸 = 가져온 식 단가산출 = 수식 문서만 · 가져온.로직 없음 → 옛 굳힘 ROW 가 줄을 못 지음(B09 대가 블록 가져온 식 줄 0 · 금액 calc_user · 수요 · 산근 그대로 · B9-5 문서 셈 줄 뒤 다시 확인) · test_792_3 실무 가져온 식 대가 = 금액만(ROW 번지 · 단계 = 옛 굳힘 꼴)
- 시험 고침: 옛 꼴 SK 손으로 짓던 견본 → imp.new_doc(793_2 · 797_1 · 797_2 · 802_4b1 · 809_1 · 810_2 · 857 도우미) · 로직 줄 읽던 단언 → 문서 변수 · 머리(793_3b · 821_4 · 827_3 · 835_1) · 옛 엔진 대조 · 옛 식 칸 가져온 식 길 걷음(802_4b1 · 796_2b)
- 지킴: 857 골든 전수 같음(블록 3,241 두 판 · 검산 · 이음) · 812_1 전수 31 · 793 · 848_6 · 848_7 · 851_2 · 855 112 통과 · 관련 694 통과(실패 = 719_1 둘 · 719_2 셋 · 826_1 — 고치기 전에도 같음 · 나머지 = 이 커밋에서 고침) · typecheck 0 · 화면 8010 엑셀 · STC 저장 · 다시 열기 · 두 판 · 이음 고침 · 시간당 식 · 초기화 · 내 일위대가로(안쪽 SK 새 꼴) · 콘솔 0 · 서버 오류 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:44:45 +09:00

280 lines
14 KiB
Python

"""M02 불러오기 단산 블록 → 가져온 식 단가산출(PLAN 793-3b · 요구 646 · 647 · 652) — 서버 단독.
올림 때 경쟁사 산근 시트(`M02_San_Book.sheets` · STmate 숨은 G 열 포함)와 그 엑셀 읽기기 둘 꼴
(812-1 `M02_San_Xlsx` → `M02_Doc_FromNative.pack` · 칸 `엑셀`)을 `실무자료/산근/<HP>.json` 에 둠
(원본 엑셀은 안 둠 · HP 지울 때 같이 지움) → [가져온 식으로 열기] = 그 블록을 원파일과 같은 길
(`M02_Doc_FromNative.emit` · 원본 `엑셀` 참) → 793-2 만들기(`M02_Sangeun_Imported.create` · 개인 층 ·
엑셀 단가 그대로 · 경쟁사 로직 인정 — 근거 기초 제안 없음 · 809-1 · 요구 703) ·
같은 내용 SK 가 있으면 그것(다시씀).
열기 = 미리 보기(`draft` · 층에 안 씀 · 835-1 · 요구 852-1) → [저장] = `make`(고친 문서째).
블록 번 = 판정 블록 번(STmate = 코드 「D00102」 숫자 · EST = 단가산출 블록 번).
STmate 블록 끝전 = 파일 투표(`M02_San_Xlsx_Stmate.vote`).
원파일(.estx · .stc · 810-2 `M02_Doc_FromNative`) = 같은 자리 칸 `원파일`(둘 꼴) · 올리기 = 파일 하나
(814-1 · 요구 742-1 — 같은 공사 엑셀 · 원파일 붙이기 걷음) · 원파일 = 새 HP(단가산출표 판 격자 · 일위대가 없음 ·
`upload_native`).
"""
from __future__ import annotations
import json
from pathlib import Path
from typing import Any
from common_util.common_util_json import atomic_write_json
from common_util.common_util_time import utc_now_text
from M02_MasterTemplete import M02_Doc_FromNative as fn
from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_San_Emit as em
from M02_MasterTemplete import M02_San_MatPick as mp
from M02_MasterTemplete import M02_San_MyMachine as mm
DIRNAME = "산근"
RELOAD = "가져온 식 자료 없음 — 엑셀을 다시 올림"
MAX_INNER = 6 # 안쪽 산근 깊이 상한
def _path(folder: str | Path, key: str) -> Path:
return hopyo_store._dir(folder) / DIRNAME / f"{key}.json"
def unreadable(data: bytes) -> str | None:
"""읽기 불가 사유(797-1a) — 빈 파일 · DRM 암호(파일 머리 `DRMONE`) · 아니면 None."""
if not data:
return "빈 파일"
if b"DRMONE" in data[:16]:
return "DRM 암호 파일 — 암호 풀린 사본을 올림"
return None
def keep(
folder: str | Path, key: str, name: str, data: bytes, opened: Any = None, excel: Any = None
) -> str | None:
"""올린 엑셀 → 산근 시트 둠(STmate · EST 꼴만 · 못 읽으면 안 둠 — 올리기는 됨).
돌려줌 = 못 읽은 사유(빈 파일 · DRM 암호 · 형식 오류) · 둠 · 산근 꼴 아님 = None ·
`excel` = 올림 길이 지은 둘 꼴(857-2 · 없으면 여기서 지음)."""
from M02_MasterTemplete import M02_San_Book as book
if why := unreadable(data):
return why
try:
sheets = book.sheets(name, data, opened) # 올림 길이 한 번 연 책(857-1)
except Exception as e: # noqa: BLE001 — 산근은 덤(가져온 식 열기만 막힘) · 사유는 돌려줌
return f"엑셀 형식 오류 — {type(e).__name__}: {str(e)[:80]}"
if not book.kind_of(sheets):
return None
try:
excel = excel or _excel(name, sheets)
except Exception as e: # noqa: BLE001 — 산근 읽기 실패 = 사유(올리기는 됨)
return f"산근 시트 읽기 오류 — {type(e).__name__}: {str(e)[:80]}"
path = _path(folder, key)
path.parent.mkdir(parents=True, exist_ok=True)
atomic_write_json(path, {"파일": name, "시트": sheets, "엑셀": excel})
return None
def _excel(name: str, sheets: dict) -> dict:
"""산근 시트 → 원파일과 같은 둘 꼴(812-1 엑셀 읽기기 `M02_San_Xlsx` → `M02_Doc_FromNative.pack`)."""
from M02_MasterTemplete import M02_San_Xlsx as sx
return fn.pack(sx.read_sheets(sheets), name)
def _excel_of(path: Path, saved: dict) -> dict:
"""저장 HP 의 엑셀 둘 꼴 — 옛 저장(시트만)은 한 번 지어 그 자리에 둠."""
if not isinstance(saved.get("엑셀"), dict):
saved["엑셀"] = _excel(str(saved.get("파일") or ""), saved["시트"])
atomic_write_json(path, saved)
return saved["엑셀"]
# ── 원파일(810-2) ──────────────────────────────────────────────────────
def upload_native(folder: str | Path, name: str, data: bytes, who: Any) -> dict[str, Any]:
"""원파일 올림 — 새 HP(단가산출표 판 격자 · 산근만 · 일위대가 없음 · 814-1) · 같은 파일 다시 = 그 HP(`이어서`)."""
mark = hopyo_store.fingerprint(data)
if same := next((r for r in hopyo_store.rows(folder) if r.get("지문") == mark), None):
return {**same, "이어서": True, "원파일": True}
if why := unreadable(data):
raise store.StoreError(400, why)
try:
native = fn.read(name, data)
except fn.NativeError as e:
raise store.StoreError(400, str(e)) from e
def first(key: str) -> None: # HP 를 목록에 보이기 전에 산근 보관(814-1)
path = _path(folder, key)
path.parent.mkdir(parents=True, exist_ok=True)
atomic_write_json(path, {"파일": name, "원파일": native})
row = hopyo_store.save(folder, name, fn.hopyo(native), who, fn.grid(native), mark, first)
return {**row, "원파일": True}
def has(folder: str | Path, key: str) -> bool:
return _path(folder, key).is_file()
def emit(folder: str | Path, key: str, no: int) -> dict[str, Any]:
"""HP 단산 블록 하나 → `{로직, 원본}`(원파일 우선 · 아니면 엑셀 읽기기 같은 길 · 이음 = M01 키) ·
못 이은 기계 = 원본 `내기계예정`(821-4 · 안 만듦)."""
out, makes = _emit(folder, key, no)
mm.preview(out, makes)
return out
def _emit(folder: str | Path, key: str, no: int) -> tuple[dict[str, Any], dict]:
"""(블록 `{로직, 원본}`, 그 파일 기계 구성 — 원파일 둘 꼴 `기계구성` · 엑셀 = 둔 시트 · 821-4)."""
hopyo_store.read(folder, key) # 없는 HP = 404
path = _path(folder, key)
try:
saved = json.loads(path.read_bytes())
except (OSError, ValueError) as e:
raise store.StoreError(409, RELOAD) from e
native = saved.get("원파일")
if isinstance(native, dict) and int(no) in fn.numbers(native): # 원파일 우선(810-2)
out = fn.emit(native, int(no))
mp.apply(out["로직"]) # 827-3 그 파일 재료 고름
return out, native.get("기계구성") or {}
if not saved.get("시트"):
raise store.StoreError(404, f"없는 단산{no}")
excel = _excel_of(path, saved)
if int(no) not in fn.numbers(excel):
raise store.StoreError(404, f"없는 단산{no}")
out = fn.emit(excel, int(no))
mp.apply(out["로직"])
return out, mm.xlsx_makes(saved["시트"])
def _inner(
source: Path, key: str, logic: dict, native: bool = False
) -> list[tuple[dict, int | None, str | None]]:
"""안쪽 산근 줄 `[(호표 줄, 같은 파일 안쪽 블록 번, 못 잇는 까닭)]` — 원파일 · 엑셀 둘 꼴 같은 길
(`M02_Doc_FromNative.inner` · 줄 자원 코드 = 블록 코드)."""
path = _path(source, key)
saved = json.loads(path.read_bytes())
if native and isinstance(saved.get("원파일"), dict):
return fn.inner(saved["원파일"], logic)
return fn.inner(_excel_of(path, saved), logic)
def _link_inner(source: Path, key: str, no: int, out: dict, trail: tuple) -> None:
"""산근 속 산근(797-1) — 안쪽 블록을 먼저 같은 길로 만들어 `참조` 로 이음(안쪽이 바뀌면 따라감) ·
못 잇는 줄 = 엑셀 값묶음 얼림 + 표지."""
from M02_MasterTemplete import M02_Labor_Ref as refs
made: dict[int, dict | None] = {}
native = bool(out["원본"].get("원파일"))
for line, n, why in _inner(source, key, out["로직"], native):
if n is not None and not why and (n == no or n in trail or len(trail) >= MAX_INNER):
why = "안쪽 블록이 자기 자신을 부름"
if n is not None and not why and n not in made:
try:
made[n] = make(source, key, n, "", (*trail, no))
except Exception as e: # noqa: BLE001 — 안쪽을 못 만듦 = 얼림(바깥은 만듦)
made[n], why = None, f"안쪽 블록을 못 만듦 — {str(getattr(e, 'detail', e))[:60]}"
if n is not None and not why and made[n] is None:
why = "안쪽 블록을 못 만듦"
if why:
out["원본"]["표지"].append(
f"{em.NOTE}안쪽 산근 「{line['이름']}」 이음 못 함({why}) · 엑셀 값 얼림"
)
continue
layer, owner = refs.here()
line["참조"] = {"층": layer, "주인": owner, "키": made[n]["이름"]}
res = line["자원"]
if res.get("비목"):
line["참조비목"] = em.COMP[res["비목"]]
def _prep(source: Path, key: str, no: int) -> tuple[dict[str, Any], dict]:
"""블록 → `{로직, 원본}`(가져온때 · 지문) + 그 파일 기계 구성 — 층에 안 씀."""
out, makes = _emit(source, key, no)
out["원본"]["가져온때"] = utc_now_text() # 원문 패널 「어디서 왔나」(807-1)
if fp := hopyo_store.read(source, key).get("지문"): # 827-3 그 파일 고름 · 이미 만든 SK 찾기
out["원본"]["지문"] = fp
return out, makes
def _flag(out: dict) -> None:
"""소요량 · 계수 후보 표지(797-2 · 사람 확인) — 못 셈 = 표지 없이 만듦."""
try:
from M02_MasterTemplete import M02_Sangeun_QtyLinks as qty
out["원본"]["표지"] += qty.flags(out["로직"])
except Exception: # noqa: BLE001 — 역색인 짓기 실패가 가져온 식 만들기를 막지 않음
pass
def _title(out: dict, no: int, name: str) -> str:
return str(name or "").strip() or str(out["로직"].get("이름") or f"단산{no}")
def draft(source: Path, key: str, no: int, name: str = "") -> dict[str, Any]:
"""[가져온 식으로 열기] 미리 보기(835-1 · 요구 852-1) — `make` 와 같은 문서 · 층에 안 씀
(안쪽 산근 줄 = 엑셀 값 · 이음은 [저장] 때 · 못 이은 기계 = 원본 `내기계예정`) ·
답 = {문서, 검산, 같은것(같은 내용 SK 키 | None)}."""
from M02_MasterTemplete import M02_Sangeun_Imported as imp
out, makes = _prep(source, key, no)
_flag(out)
mm.preview(out, makes)
return imp.draft(imp.new_doc(out["로직"], out["원본"], _title(out, no, name)))
def make(
source: Path, key: str, no: int, name: str = "", _trail: tuple = (), doc: dict | None = None
) -> dict[str, Any]:
"""지금 층(만들 층)에 가져온 식 SK — 같은 내용이 있으면 그 SK(`다시씀`) ·
안쪽 산근 블록은 형제 SK 를 먼저 만들어 참조(797-1) · 못 이은 기계 = 내 기계(821-4) ·
`doc` = 미리 보기에서 고친 문서([저장] · 835-1 — 다시 읽은 가져온 줄로 안쪽 참조 · 내 기계만 그 문서에 얹음)."""
from M02_MasterTemplete import M02_Sangeun_Imported as imp
if doc is not None and (not imp.is_imported(doc) or imp.old_form(doc)):
raise store.StoreError(400, "가져온 식 문서 아님")
out, makes = _prep(source, key, no)
_link_inner(source, key, no, out, _trail)
if doc is None:
_flag(out)
made = mm.attach(out, makes) # 821-4 못 이은 기계 = 내 기계(그 층 같은 것 · 새로)
mine = {"내기계": made} if made else {}
fresh = imp.new_doc(out["로직"], out["원본"], _title(out, no, name))
doc = fresh if doc is None else _onto(doc, fresh)
try:
return {**imp.keep(doc), "다시씀": False, **mine}
except store.StoreError as e:
same = (e.detail or {}).get("같은것") if isinstance(e.detail, dict) else None
if e.status != 409 or not same:
raise
return {**imp.keep(doc, use=same[0]["키"]), "다시씀": True, **mine}
def _onto(doc: dict, fresh: dict) -> dict:
"""미리 보기에서 고친 문서 위에 [저장] 때 이은 것(안쪽 산근 참조 · 내 기계)만 — 아직 이음 없는 값
변수(같은 가져온 줄 자리)에 새 문서 연결 · 원본 · 검산 · 머리 표지 · 기계 = 새 것(857-3b)."""
import copy as cp
from M02_MasterTemplete import M02_Sangeun_Imported as imp
doc = cp.deepcopy(doc)
new = fresh[imp.KEY][imp.FIRST]
by = {v.get(imp.FROM): v for v in new.get("변수") or [] if v.get(imp.FROM)}
for one in imp.docs_of(doc):
for var in one.get("변수") or []:
got = by.get(var.get(imp.FROM))
if got is None or not imp._bare_value(var) or imp._bare_value(got):
continue
var["연결"] = cp.deepcopy(got["연결"])
var.pop("설명", None)
var |= {"설명": got["설명"]} if got.get("설명") else {}
head = one.setdefault(imp.KEY, {})
for k in ("표지", "기계"):
if (new.get(imp.KEY) or {}).get(k) is not None:
head[k] = cp.deepcopy(new[imp.KEY][k])
gaps = {x["자리"] for x in (new.get(imp.KEY) or {}).get(imp.LIST) or []}
if head.get(imp.LIST):
head[imp.LIST] = [x for x in head[imp.LIST] if x.get("자리") in gaps]
src = fresh[imp.KEY].get("원본") or {}
when = ((doc[imp.KEY].get("원본") or {}).get("가져온때")) or src.get("가져온때")
doc[imp.KEY] |= {"원본": {**src, "가져온때": when}, "검산": fresh[imp.KEY]["검산"]}
return doc