- 857-3b 부터 늘 None · 부르는 곳 0(Item_Source.row_of · Sangeun_Block 은 다른 함수) - San_MyMachine 머리 글의 옛 이름 걷음 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
681 lines
33 KiB
Python
681 lines
33 KiB
Python
"""M02 가져온 식 단가산출(SK 바탕 갈래 · PLAN 793-2 · 857-3b · 요구 649 · 652 갈래 C) — 서버 단독.
|
|
|
|
경쟁사 엑셀 · 원파일 산근 블록 = 읽기기가 낸 가져온 줄(아래 꼴 · sub4 793-2a 내보내기) → 불러올 때 한 번
|
|
수식 문서로 지음(`M02_Doc_Import.build` · `M02_San_ToDoc`) · 정본 = 그 문서(857-3b · 요구 898 · 899).
|
|
|
|
가져온 줄(만들기 몸 `로직` · 저장 안 함) = {이름, 결과단위 「원/단위」, 입력?, 중간? [{이름, 식, 표시?}],
|
|
호표 [줄], 덧줄? [{이름, 식, 비목, 번지?, 합밖?, 자리?}], 단계?, 끝전?, 조정?, 끝수?}
|
|
호표 줄 = {종류 인력|재료|기계|로직, 이름, 규격?, 단위, 수량(식 글), 비목(로직 줄은 없으면 묶음),
|
|
단가?(엑셀 단가) | 값묶음? {노무비, 재료비, 경비}(엑셀 · 로직 줄),
|
|
이음?(M01 요소 키 LB · MT · EQ … | 로직 줄 = 「로직(GC…, 이름='값')」 글 | null),
|
|
참조?(같은 엑셀의 형제 가져온 식 SK · 797-1) · 번지?, 합밖?, 자리?, 자원?}.
|
|
원본(만들기 몸 `원본`) = {파일, 시트, 행 [처음, 끝], 갈래 STmate|EST, 엑셀금액 {노..계}(1 단위),
|
|
글줄 [{행, 글, 자리?(셈 줄 cid | mid:이름), 값?}]}.
|
|
SK 문서 덧칸 `가져온` = {문서(불러온 그대로 수식 문서 · 정본), 단가기준 엑셀|우리, 원본,
|
|
검산 {같음, 까닭, 셈, 엑셀, 줄}(불러올 때 한 번 · 엑셀 단가 · 고침 없음), 연결?(소요량 이음 기록 · 797-2),
|
|
근거후보 · 바꿈(옛 문서 읽기만)} · 바탕 = null · 고침 = `수식` 따로 사본(줄 쌓기) · [초기화] = `문서`.
|
|
옛 꼴(`가져온.로직` · 857-3b 앞 저장본) = 읽지 않음 · 지우지 않음 — 셈 · 열기 = 까닭 하나(`OLD_FORM`).
|
|
단가기준 엑셀 = 연결의 엑셀 값 기억 · 우리 = 연결 값(`M02_Doc_Import.view`).
|
|
길(`M02_Sangeun_Router` · 저장 없음 = 화면 캐시):
|
|
POST …/sangeun/imported/price 몸 {문서, 기준} → {문서, 전, 후, 이음없음 [{자리, 이름}]}
|
|
POST …/sangeun/imported/link 몸 {문서, 자리(가져온 줄 `호표:i`), 이음} → {문서}(문서 연결 고침)
|
|
셈 답(`…/sangeun/calc`) 덧칸 `가져온` {단가기준, 파일, 시트, 행, 갈래, 엑셀금액, 글줄, 이음없음} · `원래` = 엑셀 금액.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import copy as cp
|
|
import json
|
|
import math
|
|
import re
|
|
from decimal import Decimal
|
|
from typing import Any
|
|
|
|
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
|
|
|
KEY = "가져온"
|
|
FIRST = "문서" # `가져온` 칸 — 불러온 그대로 문서(`M02_Doc_Import.FIRST`)
|
|
BASIS = ("엑셀", "우리")
|
|
COSTS = ("노무비", "재료비", "경비")
|
|
KINDS = ("인력", "재료", "기계", "로직")
|
|
ROW = ("이름", "결과단위", "입력", "중간", "호표", "덧줄", "단계", "끝전", "조정", "끝수")
|
|
LINE = ("종류", "이름", "규격", "단위", "수량", "비목", "단가", "값묶음", "이음", "번지", "합밖")
|
|
LINE += ("자리", "출처", "비고", "자원") # 자원 = 경쟁사 코드 · 엑셀 단가 원본(793-2a · 셈 안 씀)
|
|
LINE += ("참조", "참조비목") # 산근 속 산근 = 같은 엑셀의 형제 가져온 식 SK(797-1 · 로직 줄만)
|
|
EXTRA = ("이름", "식", "비목", "번지", "합밖", "자리", "출처", "비고")
|
|
META = ("원본", "검산", "근거후보", "바꿈", "연결")
|
|
MANY = 300 # 호표 · 덧줄 · 중간 줄 수
|
|
BIG = 400_000 # 메타 글 크기(바이트)
|
|
DOC_BIG = 4_000_000 # 불러온 그대로 문서 크기(바이트)
|
|
FROZEN = "GX9" # 굳힌 사본 바탕 로직 키 머리(`M02_Item_Sangeun.frozen_key`)
|
|
|
|
|
|
def _whole() -> Any:
|
|
"""M01 + 지금 층 내 기계(821-4 · 못 이은 기계를 이은 개인 키 `EQP…`)."""
|
|
from M02_MasterTemplete import M02_MyMachine as mym
|
|
|
|
return mym.whole()
|
|
|
|
|
|
def _dim() -> Any:
|
|
from M02_MasterTemplete import M02_Doc_Import as dim # 서로 부름 — 늦게
|
|
|
|
return dim
|
|
|
|
|
|
def is_imported(doc: Any) -> bool:
|
|
"""가져온 식 SK — 불러온 그대로 문서(857-3b) · 옛 꼴(`로직`)도 가져온 식(읽지 않음 · 까닭)."""
|
|
meta = doc.get(KEY) if isinstance(doc, dict) else None
|
|
return isinstance(meta, dict) and (
|
|
isinstance(meta.get(FIRST), dict) or isinstance(meta.get("로직"), dict)
|
|
)
|
|
|
|
|
|
def old_form(doc: Any) -> bool:
|
|
"""857-3b 앞 옛 꼴 저장본(`가져온.로직` · 문서 없음)."""
|
|
return is_imported(doc) and not isinstance(doc[KEY].get(FIRST), dict)
|
|
|
|
|
|
# ── 이음 기계 시간당 ───────────────────────────────────────────────────
|
|
_HOURLY: dict[str, Any] = {"whole": None, "rows": {}}
|
|
|
|
|
|
def hourly_of(key: str) -> dict:
|
|
"""이음 기계(EQ) 시간당 노 · 재 · 경 — M01 판이 바뀌면 다시(캐시 = M01 묶음 하나에 매임)."""
|
|
from M02_MasterTemplete import M02_Machine_Hourly as machine
|
|
|
|
whole = _whole() # 내 기계 고침 = 색인이 바뀜 → 다시
|
|
if _HOURLY["whole"] is not whole:
|
|
_HOURLY.update(whole=whole, rows={})
|
|
if key not in _HOURLY["rows"]:
|
|
_HOURLY["rows"][key] = machine.hourly(key)
|
|
return _HOURLY["rows"][key]
|
|
|
|
|
|
def base_row(doc: dict) -> dict[str, Any]:
|
|
"""바탕 없는 SK 바탕 줄(`sd.empty_row`) — 입력 · 줄 없음 · 가져온 식 결과단위 = 문서 결과단위(1 단위 배)."""
|
|
first = (doc.get(KEY) or {}).get(FIRST) if isinstance(doc.get(KEY), dict) else None
|
|
unit = (first or {}).get("결과단위") or f"원/{doc.get('단위') or ''}"
|
|
return {
|
|
"키": doc.get("키"),
|
|
"이름": doc.get("이름"),
|
|
"결과단위": unit,
|
|
**{k: [] for k in ("입력", "중간", "호표", "덧줄")},
|
|
}
|
|
|
|
|
|
# ── 가져온 줄 꼴 검사(불러올 때 · 문서 파서) ─────────────────────────────
|
|
def _formula(raw: Any, where: str) -> str:
|
|
from M02_MasterTemplete import M02_San_ToDoc as todoc
|
|
|
|
text = str(raw if raw is not None else "").strip()
|
|
if not text:
|
|
raise sd.DocError(f"{where} · 식이 빔")
|
|
if len(text) > 2000:
|
|
raise sd.DocError(f"{where} · 식이 너무 김")
|
|
try:
|
|
todoc.md.parse(text)
|
|
except todoc.md.DocError as e:
|
|
raise sd.DocError(f"{where} · {e}") from e
|
|
return text
|
|
|
|
|
|
def _link(raw: Any, kind: str, where: str, whole: Any) -> str | None:
|
|
"""이음 — 로직 줄 = 「로직(GC…)」 글(부르는 수식 문서 있음) · 그 밖 = M01 요소 키(있음)."""
|
|
from M02_MasterTemplete import M02_Doc_Copy as dc
|
|
from M02_MasterTemplete import M02_San_ToDoc as todoc
|
|
|
|
if raw in (None, ""):
|
|
return None
|
|
text = str(raw).strip()
|
|
try:
|
|
if kind == "로직":
|
|
got = todoc.logic_call(text)
|
|
if got is None:
|
|
raise ValueError("로직(…) 꼴 아님")
|
|
if dc.folder().get(got[0]) is None:
|
|
raise ValueError("없는 단가산출")
|
|
else:
|
|
whole.get(text)
|
|
except Exception as e: # noqa: BLE001
|
|
raise sd.DocError(f"{where} · 없는 이음 「{text}」 ({e})") from e
|
|
return text
|
|
|
|
|
|
def _line(raw: Any, where: str, whole: Any) -> dict:
|
|
if not isinstance(raw, dict):
|
|
raise sd.DocError(f"{where} · 묶음 아님")
|
|
kind = raw.get("종류")
|
|
if kind not in KINDS:
|
|
raise sd.DocError(f"{where} · 종류는 {' · '.join(KINDS)}")
|
|
out = {k: raw[k] for k in LINE if raw.get(k) not in (None, "")}
|
|
out["이름"] = str(raw.get("이름") or "").strip() or where
|
|
out["단위"] = str(raw.get("단위") or "")
|
|
out["수량"] = _formula(raw.get("수량"), f"{where} 수량")
|
|
out["이음"] = _link(raw.get("이음"), kind, where, whole)
|
|
if "참조" in out:
|
|
ref = out["참조"]
|
|
if kind != "로직" or not isinstance(ref, dict):
|
|
raise sd.DocError(f"{where} · 참조는 로직 줄의 {{층, 주인, 키}}")
|
|
if ref.get("층") not in ("system", "company", "personal") or not re.fullmatch(
|
|
r"SK-\d{6}", str(ref.get("키") or "")
|
|
):
|
|
raise sd.DocError(f"{where} · 참조는 단가산출(SK)만")
|
|
out["참조"] = {k: ref.get(k) for k in ("층", "주인", "키")}
|
|
if out.get("참조비목") not in (*COSTS, None):
|
|
raise sd.DocError(f"{where} · 참조비목은 노무비 · 재료비 · 경비")
|
|
if kind != "로직" and out.get("비목") not in sd.PARTS.values():
|
|
raise sd.DocError(f"{where} · 비목은 노무비 · 재료비 · 경비")
|
|
if "단가" in out:
|
|
out["단가"] = sd.plain(sd._num(out["단가"], f"{where} 단가"))
|
|
if "값묶음" in out:
|
|
pack = out["값묶음"] if isinstance(out["값묶음"], dict) else {}
|
|
out["값묶음"] = {k: sd.plain(sd._num(pack.get(k, 0), f"{where} {k}")) for k in COSTS}
|
|
if kind == "로직" and "단가" in out:
|
|
raise sd.DocError(f"{where} · 로직 줄 엑셀 값은 값묶음")
|
|
if not any(k in out for k in ("단가", "값묶음", "참조")) and not out["이음"]:
|
|
raise sd.DocError(f"{where} · 엑셀 단가 · 이음 둘 다 없음")
|
|
return out
|
|
|
|
|
|
def clean_row(raw: Any, whole: Any = None) -> dict[str, Any]:
|
|
"""가져온 줄 꼴 — 줄 수 · 식(문서 파서) · 이음 키 · 엑셀 값 · 틀리면 `DocError`."""
|
|
whole = whole or _whole()
|
|
if not isinstance(raw, dict):
|
|
raise sd.DocError("가져온 로직 · 묶음 아님")
|
|
out = {k: raw[k] for k in ROW if raw.get(k) not in (None, "", [], {})}
|
|
out["이름"] = str(raw.get("이름") or "").strip() or "가져온 식"
|
|
if not re.match(r"^원/\S+$", str(raw.get("결과단위") or "").strip()):
|
|
raise sd.DocError("가져온 로직 · 결과단위는 「원/단위」")
|
|
items, extras, mids = raw.get("호표") or [], raw.get("덧줄") or [], raw.get("중간") or []
|
|
if not all(isinstance(x, list) for x in (items, extras, mids)):
|
|
raise sd.DocError("가져온 로직 · 호표 · 덧줄 · 중간은 목록") # 빈 산근(0 원) = 받음
|
|
if max(len(items), len(extras), len(mids)) > MANY:
|
|
raise sd.DocError(f"가져온 로직 · 줄은 {MANY} 까지")
|
|
out["호표"] = [_line(x, f"호표 {n}째", whole) for n, x in enumerate(items, 1)]
|
|
if extras:
|
|
out["덧줄"] = [_extra(x, f"덧줄 {n}째") for n, x in enumerate(extras, 1)]
|
|
if mids:
|
|
out["중간"] = [
|
|
{**x, "식": _formula(x.get("식"), f"중간 「{x.get('이름')}」")}
|
|
for x in mids
|
|
if isinstance(x, dict) and str(x.get("이름") or "").strip()
|
|
]
|
|
return out
|
|
|
|
|
|
def _extra(raw: Any, where: str) -> dict:
|
|
if not isinstance(raw, dict) or raw.get("비목") not in sd.PARTS.values():
|
|
raise sd.DocError(f"{where} · 묶음 · 비목(노무비 · 재료비 · 경비)")
|
|
out = {k: raw[k] for k in EXTRA if raw.get(k) not in (None, "")}
|
|
return {**out, "이름": str(raw.get("이름") or where), "식": _formula(raw.get("식"), where)}
|
|
|
|
|
|
def _meta(raw: Any, name: str, big: int = BIG) -> Any:
|
|
try:
|
|
size = len(json.dumps(raw, ensure_ascii=False, default=str).encode("utf-8"))
|
|
except (TypeError, ValueError) as e:
|
|
raise sd.DocError(f"가져온 {name} · 글로 못 담음") from e
|
|
if size > big:
|
|
raise sd.DocError(f"가져온 {name} · {big} 바이트를 넘음")
|
|
want = list if name == "근거후보" else dict
|
|
if not isinstance(raw, want):
|
|
raise sd.DocError(f"가져온 {name} · {'목록' if want is list else '묶음'} 아님")
|
|
return raw
|
|
|
|
|
|
def clean(raw: Any, out: dict) -> dict:
|
|
"""`sd.clean` 끝(`const.clean_more`) — `가져온` 칸 · 바탕과 같이 못 둠 ·
|
|
`가져온보관` = 우리 기초 사본으로 바꾼 SK 의 원래 가져온 식 몸(810-4 되돌리기) ·
|
|
옛 꼴(`로직`) = 그대로 둠(읽지 않음 · 지우지 않음)."""
|
|
kept = raw.get("가져온보관") if isinstance(raw, dict) else None
|
|
if isinstance(kept, dict) and isinstance(kept.get(KEY), dict):
|
|
out = {**out, "가져온보관": _meta(kept, "가져온보관")}
|
|
meta = raw.get(KEY) if isinstance(raw, dict) else None
|
|
if meta in (None, {}):
|
|
return out
|
|
if not isinstance(meta, dict):
|
|
raise sd.DocError("가져온 · 묶음 아님")
|
|
got = {k: _meta(meta[k], k) for k in META if meta.get(k) not in (None, {}, [])}
|
|
if meta.get(FIRST) is not None or meta.get("로직") is not None:
|
|
if out.get("바탕") and not str((out["바탕"] or {}).get("로직") or "").startswith(FROZEN):
|
|
raise sd.DocError("가져온 식 단가산출은 바탕 없음") # 굳힌 사본(B09 · `GX9…`)만 바탕
|
|
basis = meta.get("단가기준") or "엑셀"
|
|
if basis not in BASIS:
|
|
raise sd.DocError("단가기준은 엑셀 · 우리")
|
|
got["단가기준"] = basis
|
|
if meta.get(FIRST) is not None:
|
|
first = _meta(meta[FIRST], FIRST, DOC_BIG)
|
|
for name in ("변수", "식", "금액"):
|
|
if not isinstance(first.get(name, []), list):
|
|
raise sd.DocError(f"가져온 문서 · 「{name}」 목록 아님")
|
|
got[FIRST] = first
|
|
else:
|
|
got["로직"] = meta["로직"] # 옛 꼴 — 그대로(읽지 않음)
|
|
return out | ({KEY: got} if got else {})
|
|
|
|
|
|
def _named(src: dict, row: dict) -> dict:
|
|
"""원본 글줄 `자리` · `자리들` = 셈 줄 이름(793-2a) → 줄 정체 cid(이미 cid · `mid:` · `단계:` =
|
|
그대로 · 블록 안 줄 이름은 겹치지 않음)."""
|
|
ids = sd.line_ids(_dim().bare_row(row))
|
|
by: dict[str, str] = {}
|
|
for one, cid in zip([*row["호표"], *(row.get("덧줄") or [])], ids):
|
|
by.setdefault(str(one.get("이름")), cid)
|
|
lines = []
|
|
for one in src.get("글줄") or []:
|
|
if isinstance(one, dict):
|
|
one = {**one, **({"자리": by.get(one["자리"], one["자리"])} if one.get("자리") else {})}
|
|
if isinstance(one.get("자리들"), list):
|
|
one["자리들"] = [by.get(x, x) for x in one["자리들"]]
|
|
lines.append(one)
|
|
return {**src, "글줄": lines} if "글줄" in src else src
|
|
|
|
|
|
def same_part(doc: Any) -> dict | None:
|
|
"""같은 내용 지문 몫(`M02_Library_Same`) — 불러온 그대로 문서(머리 `가져온` = 파일 · 행 · 표지 뺌) ·
|
|
단가기준(원본 · 검산 뺌)."""
|
|
if not is_imported(doc):
|
|
return None
|
|
meta = doc[KEY]
|
|
first = meta.get(FIRST)
|
|
out = {k: meta.get(k) for k in ("로직", "단가기준") if meta.get(k) is not None}
|
|
if isinstance(first, dict):
|
|
out[FIRST] = {k: v for k, v in first.items() if k != KEY}
|
|
return out
|
|
|
|
|
|
def unlinked(doc: dict) -> list[dict]:
|
|
"""이음 없는 자원 줄 `[{자리, 이름, 까닭, 견적?, 종?}]` — 불러올 때 문서 머리 목록(`Doc_Import.LIST`)
|
|
가운데 아직 이음 없는 것(자리 = 가져온 줄 `호표:i`)."""
|
|
first = (doc.get(KEY) or {}).get(FIRST)
|
|
if not isinstance(first, dict):
|
|
return []
|
|
have = {v.get(FROM) for v in first.get("변수") or [] if _bare_value(v)}
|
|
return [x for x in (first.get(KEY) or {}).get(LIST) or [] if x.get("자리") in have]
|
|
|
|
|
|
FROM = "가져온줄" # `M02_San_ToDoc.FROM`
|
|
LIST = "이음없음" # `M02_Doc_Import.LIST`
|
|
XL = "엑셀" # `M02_Doc_Import.XL`
|
|
|
|
|
|
def _bare_value(var: dict) -> bool:
|
|
"""이음 없는 가져온 값 변수 — 숫자 연결(엑셀 값 그대로)."""
|
|
return isinstance(var, dict) and (var.get("연결") or {}).get("갈래") == "숫자"
|
|
|
|
|
|
# ── 검산(불러올 때 한 번 · 엑셀 단가 · 고침 없음) ────────────────────────
|
|
def _json(value: Any) -> Any:
|
|
from M02_MasterTemplete import M02_Labor_Doc as labor
|
|
|
|
return labor._json(value)
|
|
|
|
|
|
def _doc_of(row: dict, whole: Any) -> tuple[dict, list[str], dict]:
|
|
"""검산 문서(855 2-C3 · 857-3b) — 가져온 줄(엑셀 단가 · 고침 없음)을 줄 차례 그대로 문서로
|
|
(`M02_San_ToDoc` · 다듬기 없음 · 금액 줄 k = 줄 정체 k) · 안쪽 산근 줄 = 형제 SK 연결(문서 셈 ·
|
|
부르는 쪽 단가기준) → (문서, 줄 정체, {중간 이름: 기호})."""
|
|
from M02_MasterTemplete import M02_Doc_Copy as dc
|
|
from M02_MasterTemplete import M02_San_ToDoc as todoc
|
|
|
|
bare = _dim().bare_row(row)
|
|
doc, _ = todoc.build(bare, whole, {})
|
|
by = {dc.md.var_id(v): v for v in doc.get("변수") or []}
|
|
for item, line in zip(bare["호표"], doc.get("금액") or []):
|
|
var = by.get(str(line.get("단가") or "").removesuffix(".계"))
|
|
if not item.get("참조") or var is None:
|
|
continue
|
|
ref = item["참조"]
|
|
link = {
|
|
"갈래": "단가산출",
|
|
"키": ref["키"],
|
|
"참조": {"층": ref["층"], "주인": ref.get("주인")},
|
|
}
|
|
if item.get("참조비목") in COSTS: # 안쪽 산근의 그 비목만(`Doc_Import._attach` 와 같음)
|
|
link["칸"] = item["참조비목"]
|
|
line["단가"], line["비목"] = dc.md.var_id(var), item["참조비목"]
|
|
var["연결"] = link
|
|
mids = {str(v.get("열쇠")): dc.md.var_id(v) for v in doc.get("변수") or []}
|
|
return doc, sd.line_ids(bare), mids
|
|
|
|
|
|
def _run(doc: dict, whole: Any) -> dict:
|
|
"""SK 셈(`to_price` 전 · 후 1 단위) — `Sangeun_Calc.run` 한 길(2-C1)."""
|
|
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
|
|
|
return calc.run(sd.clean(doc, None, whole), whole)
|
|
|
|
|
|
def _money(got: dict) -> dict | None:
|
|
unit = got.get("1단위")
|
|
if not unit:
|
|
return None
|
|
return {**{k: unit[k] for k in COSTS}, "계": unit["계"]}
|
|
|
|
|
|
def _same(mine: Any, excel: Any) -> bool:
|
|
"""셈 ≈ 엑셀 — 엑셀 값 끝자리 한 칸 안(엑셀 보이는 값 = 끊은 값)."""
|
|
if mine is None or excel is None:
|
|
return False
|
|
want = round(Decimal(str(excel)), 6) # 엑셀 float 꼬리(8109.000000000001) 뗌
|
|
step = Decimal(1).scaleb(min(want.normalize().as_tuple().exponent, 0))
|
|
return abs(Decimal(str(mine)) - want) < step
|
|
|
|
|
|
def check_row(row: dict, src: dict, head: dict, whole: Any = None) -> dict[str, Any]:
|
|
"""검산 — 가져온 줄(엑셀 단가 · 고침 없음)을 문서 계산기로 다시 셈(855 2-C3) → 엑셀 금액 ·
|
|
글줄마다 맞댐(글줄 `자리` = 줄 정체 cid ↔ 검산 문서 금액 줄 같은 차례 · `mid:이름` = 중간 변수 값 ·
|
|
`단계:이름` = 단계 계) · 못 셈 = {같음 False, 까닭} · `head` = SK {키, 단위, 환산}(1 단위 배)."""
|
|
from M02_MasterTemplete import M02_Doc_Copy as dc
|
|
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
|
|
|
whole = whole or _whole()
|
|
excel = src.get("엑셀금액") or {}
|
|
sk = {"키": head.get("키") or "SK-000000", KEY: {"단가기준": "엑셀"}}
|
|
try:
|
|
times = calc.ratio_of(head, {"결과단위": row.get("결과단위")}, whole) # 1 단위 = 셈 ÷ 배
|
|
except sd.DocError as e:
|
|
return {"같음": False, "까닭": str(e), "셈": None, "엑셀": excel, "줄": []}
|
|
try:
|
|
mine_doc, ids, mids = _doc_of(row, whole)
|
|
got = _dim().run(mine_doc, sk, whole)
|
|
except Exception as e: # noqa: BLE001 — 변환 · 셈 틀림 = 맞댈 값 없음
|
|
got, ids, mids, mine_doc = {"셈됨": False, "까닭": str(e)}, [], {}, None
|
|
money = dc.money(got) if got.get("셈됨") else None
|
|
if (
|
|
money is None
|
|
and mine_doc is not None
|
|
and not (mine_doc.get("금액") or mine_doc.get("결과"))
|
|
):
|
|
money = dict.fromkeys(dc.COSTS, Decimal(0)) # 빈 산근 = 엑셀 0 원(줄 없음 합)
|
|
mine = {k: Decimal(str(v)) / times for k, v in money.items()} if money else None
|
|
now = {cid: x.get("금액") for cid, x in zip(ids, got.get("줄") or [])}
|
|
values = got.get("값") or {}
|
|
now |= {f"mid:{k}": values[v] for k, v in mids.items() if isinstance(values.get(v), Decimal)}
|
|
steps = got.get("단계") or {}
|
|
steps = (
|
|
steps
|
|
if isinstance(steps, dict)
|
|
else {x.get("이름"): x for x in steps if isinstance(x, dict)}
|
|
)
|
|
now |= {f"단계:{k}": (v or {}).get("계") for k, v in steps.items()}
|
|
group = _groups(src.get("글줄"))
|
|
lines = [x for x in (_compare(one, now, group=group) for one in src.get("글줄") or []) if x]
|
|
ok = bool(mine) and excel != {} and _all_same(mine, excel)
|
|
rate = (src.get("계약") or {}).get("낙찰률")
|
|
ok = ok or bool(mine and rate and excel and _all_same(_contract(mine, rate), excel))
|
|
why = (
|
|
None
|
|
if ok
|
|
else (
|
|
(dc.why(got) if not money else "") or ("엑셀 금액 없음" if not excel else "금액 다름")
|
|
)
|
|
)
|
|
ok = ok and all(x["같음"] for x in lines)
|
|
return _json({"같음": ok, "까닭": why, "셈": mine, "엑셀": excel, "줄": lines})
|
|
|
|
|
|
def check(doc: dict, whole: Any = None) -> dict[str, Any]:
|
|
"""검산 — 불러올 때 적은 것(가져온 줄은 저장 안 함 · 857-3b) · 이미 저장된 SK = 그 파일 것(화면 값
|
|
안 받음) · 옛 꼴 = 까닭 하나."""
|
|
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
|
|
|
if old_form(doc):
|
|
return {"같음": False, "까닭": _dim().OLD_FORM, "셈": None, "엑셀": None, "줄": []}
|
|
have = skc.stored_doc(doc.get("키"))
|
|
if is_imported(have) and not old_form(have) and (have[KEY].get("검산")):
|
|
return have[KEY]["검산"]
|
|
return (doc.get(KEY) or {}).get("검산") or {
|
|
"같음": False,
|
|
"까닭": "검산 없음",
|
|
"셈": None,
|
|
"엑셀": None,
|
|
"줄": [],
|
|
}
|
|
|
|
|
|
def _all_same(mine: dict, excel: dict) -> bool:
|
|
return all(_same(mine.get(k), excel.get(k)) for k in excel)
|
|
|
|
|
|
def _contract(mine: dict, rate: float) -> dict:
|
|
"""계약단가(827-6) — 비목 × 낙찰률 원 버림 · 계 = 비목 합(`M02_San_Eval.stmate_block` 과 같음) ·
|
|
머리 금액만 있는 STmate 블록(엑셀금액 = 계약 뒤)."""
|
|
if any(mine.get(k) is None for k in COSTS):
|
|
return {}
|
|
out = {k: math.floor(round(float(mine[k]) * rate / 100, 6)) for k in COSTS}
|
|
return out | {"계": sum(out.values())}
|
|
|
|
|
|
def _groups(texts: Any) -> dict[str, Decimal]:
|
|
"""첫 자리가 같은 값 든 글줄 여럿 → 첫 자리별 값 합(814-1 기계 노 · 재 · 경 세 글줄 = 묶은
|
|
한 줄 · 노 줄만 딸린 기계까지 자리들)."""
|
|
out: dict[str, list] = {}
|
|
for one in texts or []:
|
|
if isinstance(one, dict) and one.get("값") is not None:
|
|
if spot := (one.get("자리들") or [one.get("자리")])[0]:
|
|
out.setdefault(spot, []).append(Decimal(str(one["값"])))
|
|
return {k: sum(v) for k, v in out.items() if len(v) > 1}
|
|
|
|
|
|
def _compare(one: Any, now: dict, loose: bool = False, group: dict | None = None) -> dict | None:
|
|
"""글줄 하나 맞댐 — 자리(들) 셈 합 ≈ 엑셀 `값`(또는 같은 자리 글줄들 값 합 `group`) · 맞댈 것
|
|
없음 = None · `loose` = 셈에 없는 자리면 None(화면 보기 · 단계 값 없음)."""
|
|
if not isinstance(one, dict) or one.get("값") is None:
|
|
return None
|
|
spots = one.get("자리들") or ([one["자리"]] if one.get("자리") else [])
|
|
if not spots or (loose and any(s not in now for s in spots)):
|
|
return None
|
|
want = one["값"]
|
|
vals = [now.get(s) for s in spots]
|
|
got = None if None in vals else sum(Decimal(str(v)) for v in vals)
|
|
total = (group or {}).get(spots[0])
|
|
same = _same(got, want) or (total is not None and _same(got, total))
|
|
why = None if same else ("짝 줄 없음" if got is None else f"셈 {got} · 엑셀 {want}")
|
|
out = {"자리": spots[0], "행": one.get("행"), "셈": got, "엑셀": want, "같음": same}
|
|
out |= {"묶음합": total} if total is not None else {}
|
|
return out | ({"자리들": spots} if len(spots) > 1 else {}) | ({"까닭": why} if why else {})
|
|
|
|
|
|
def more(out: dict, clean_: dict) -> dict:
|
|
"""셈 답 덧칸(`const.answer`) — 가져온 식: `원래` = 엑셀 금액 · `가져온` 원본 글 보기."""
|
|
if not is_imported(clean_):
|
|
return out
|
|
meta = clean_[KEY]
|
|
src = meta.get("원본") or {}
|
|
spots = (out.get("시트") or {}).get("자리") or {}
|
|
now = {k: v.get("지금") for k, v in spots.items()}
|
|
texts, group = [], _groups(src.get("글줄"))
|
|
for one in src.get("글줄") or []:
|
|
hit = _compare(one, now, loose=True, group=group) or {}
|
|
text = {k: one.get(k) for k in ("행", "글", "자리")}
|
|
text |= {"자리들": one["자리들"]} if one.get("자리들") else {}
|
|
text |= {"엑셀": one["값"]} if one.get("값") is not None else {}
|
|
texts.append(text | ({"지금": hit["셈"], "같음": hit["같음"]} if hit else {}))
|
|
head = {k: src.get(k) for k in ("파일", "시트", "행", "갈래", "엑셀금액")}
|
|
view = {"단가기준": meta.get("단가기준"), **head, "글줄": texts, "이음없음": unlinked(clean_)}
|
|
view |= {k: meta[k] for k in ("검산", "근거후보", "바꿈") if meta.get(k)}
|
|
excel = src.get("엑셀금액")
|
|
return out | {KEY: view} | ({"원래": excel} if excel else {})
|
|
|
|
|
|
# ── 고치기(화면 캐시 · 저장 없음) ───────────────────────────────────────
|
|
def _need(doc: Any) -> dict:
|
|
if not is_imported(doc):
|
|
raise sd.DocError("가져온 식 단가산출 아님")
|
|
if old_form(doc):
|
|
raise sd.DocError(_dim().OLD_FORM)
|
|
return doc
|
|
|
|
|
|
def _with(doc: dict, **meta: Any) -> dict:
|
|
return {**doc, KEY: {**doc[KEY], **meta}}
|
|
|
|
|
|
def to_price(doc: Any, basis: str) -> dict[str, Any]:
|
|
"""[우리 단가로] · [엑셀 단가로] — 단가기준만 바꾼 문서 · 바꾸기 전후 1 단위 금액 · 이음없음."""
|
|
doc = _need(doc)
|
|
if basis not in BASIS:
|
|
raise sd.DocError("단가기준은 엑셀 · 우리")
|
|
whole = _whole()
|
|
after = _with(doc, 단가기준=basis)
|
|
return {
|
|
"문서": after,
|
|
"전": _money(_run(doc, whole)),
|
|
"후": _money(_run(after, whole)),
|
|
"이음없음": unlinked(doc),
|
|
}
|
|
|
|
|
|
def docs_of(doc: dict) -> list[dict]:
|
|
"""가져온 줄 고침을 얹을 문서 — 불러온 그대로(`가져온.문서`) + 줄 쌓기 따로 사본(있으면 · 같은 기호)."""
|
|
from M02_MasterTemplete import M02_Doc_Copy as dc
|
|
|
|
out = [doc[KEY][FIRST]]
|
|
got = doc.get(dc.KEY) if isinstance(doc.get(dc.KEY), dict) else {}
|
|
if got.get("따로") and isinstance(got.get("문서"), dict):
|
|
out.append(got["문서"])
|
|
return out
|
|
|
|
|
|
def link(doc: Any, spot: str, key: Any) -> dict[str, Any]:
|
|
"""이음 없는 자원 줄 이음 고름(857-3b) — 그 가져온 줄 값 변수 연결 = 고른 이음(엑셀 값 기억) ·
|
|
자리 = 가져온 줄 `호표:i`(문서 머리 `이음없음`)."""
|
|
dim = _dim()
|
|
doc = cp.deepcopy(_need(doc))
|
|
first = doc[KEY][FIRST]
|
|
var = next((v for v in first.get("변수") or [] if v.get(FROM) == spot), None)
|
|
line = next((x for x in first.get("금액") or [] if x.get(FROM) == spot), None)
|
|
if var is None or line is None:
|
|
raise sd.DocError(f"없는 자원 줄 「{spot}」")
|
|
kind = str(line.get("가져온종류") or "")
|
|
code = _link(key, kind, f"「{spot}」", _whole())
|
|
if code is None:
|
|
raise sd.DocError(f"「{spot}」 · 이음 키 없음")
|
|
item = {"이음": code, "종류": kind, "비목": line.get("비목"), "단위": line.get("단위")}
|
|
got, note = dim._link_of(item)
|
|
if got is None:
|
|
raise sd.DocError(f"「{spot}」 · {note or '이을 수 없음'}")
|
|
sym, opt = dim.dc.md.var_id(var), got.pop(dim.OPTION, None)
|
|
for one in docs_of(doc):
|
|
mine = next((v for v in one.get("변수") or [] if dim.dc.md.var_id(v) == sym), None)
|
|
if mine is None or not _bare_value(mine):
|
|
continue
|
|
if opt and opt["열쇠"] not in {v.get("열쇠") for v in one["변수"]}:
|
|
one["변수"].append(opt)
|
|
mine["연결"] = {**cp.deepcopy(got), XL: mine["연결"].get("값")}
|
|
mine.pop("설명", None) if not note else mine.__setitem__("설명", note)
|
|
return {"문서": doc}
|
|
|
|
|
|
# ── 만들기(개인 층) ───────────────────────────────────────────────────
|
|
def create(
|
|
logic: Any, source: Any, name: str = "", unit: str = "", head: dict | None = None,
|
|
new: bool = False, use: str | None = None,
|
|
) -> dict[str, Any]: # fmt: skip
|
|
"""가져온 줄 + 원본 → 지금 층 새 가져온 식 SK(불러온 그대로 문서 · 검산) · 같은 층 같은 내용 = 409
|
|
(`ask` · 733-2)."""
|
|
return keep(new_doc(logic, source, name, unit, head), new, use)
|
|
|
|
|
|
def new_doc(
|
|
logic: Any, source: Any, name: str = "", unit: str = "", head: dict | None = None
|
|
) -> dict[str, Any]:
|
|
"""가져온 식 SK 문서(키 없음 · 층에 안 씀) — 불러온 그대로 문서를 한 번 지음(857-3b · 가져온 줄 안 둠)."""
|
|
whole = _whole()
|
|
row = clean_row(logic, whole)
|
|
unit = str(unit or "").strip() or row["결과단위"].split("/", 1)[1]
|
|
doc = {"키": "SK-000000", "이름": str(name or "").strip() or row["이름"], "단위": unit}
|
|
doc |= {k: str((head or {}).get(k) or "") for k in ("구분", "상세구분")}
|
|
doc |= {"바탕": None, "입력값": {}, "덮개": {}, "뺀줄": [], "더한줄": []}
|
|
raw = _meta(source, "원본") if source not in (None, {}) else {}
|
|
src = _named(raw, row) if raw else {} # 글줄 자리 = 줄 정체 cid(검산 · 셈 답 맞댐)
|
|
first = _norm(_dim().build(row, raw, whole)) # 다듬기 = 글줄 자리 이름 그대로(704) · JSON 꼴
|
|
meta = {FIRST: first, "단가기준": "엑셀", "검산": check_row(row, src, doc, whole)}
|
|
doc[KEY] = meta | ({"원본": src} if src else {})
|
|
return doc
|
|
|
|
|
|
def _norm(doc: dict) -> dict:
|
|
from M02_MasterTemplete import M02_Doc_Copy as dc
|
|
|
|
return json.loads(json.dumps(dc.ml._norm(doc), ensure_ascii=False, default=str))
|
|
|
|
|
|
def keep(doc: dict, new: bool = False, use: str | None = None) -> dict[str, Any]:
|
|
"""문서 → 지금 층 SK(같은 내용 = 409 · `use` = 그것을 씀 · 안 씀)."""
|
|
from M02_MasterTemplete import M02_Labor_Ref as refs
|
|
from M02_MasterTemplete import M02_Library_Ask as ask
|
|
|
|
key = ask.ask(sd.KIND, doc, new, use) or refs.create(sd.KIND, doc)["이름"]
|
|
meta = doc.get(KEY) or {}
|
|
return {"이름": key, "검산": check(doc), "단가기준": meta.get("단가기준") or "엑셀"}
|
|
|
|
|
|
def draft(doc: dict) -> dict[str, Any]:
|
|
"""미리 보기(835-1 · 요구 852-1) — 층에 안 씀 · 답 = {문서, 검산, 같은것(같은 내용 SK 키 | None)}."""
|
|
from M02_MasterTemplete import M02_Labor_Ref as refs
|
|
from M02_MasterTemplete import M02_Library_Ask as ask
|
|
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
|
|
|
try:
|
|
ask.ask(sd.KIND, doc)
|
|
same = None
|
|
except store.StoreError as e:
|
|
rows = (e.detail or {}).get("같은것") if isinstance(e.detail, dict) else None
|
|
if e.status != 409 or not rows:
|
|
raise
|
|
same = rows[0]["키"]
|
|
return {"문서": refs.clean_doc(sd.KIND, doc), "검산": check(doc), "같은것": same}
|
|
|
|
|
|
# ── 산근 속 산근 참조(797-1 · `M02_Labor_Ref`) ──────────────────────────
|
|
def refs_of(doc: Any) -> list[dict]:
|
|
"""가져온 식이 부르는 형제 SK 참조 `[{층, 주인, 키}]` — 불러온 그대로 · 따로 사본 문서의 단가산출 연결."""
|
|
if not is_imported(doc) or old_form(doc):
|
|
return []
|
|
out = []
|
|
for one in docs_of(doc):
|
|
for var in one.get("변수") or []:
|
|
link = var.get("연결") or {}
|
|
if link.get("갈래") == "단가산출" and isinstance(link.get("참조"), dict):
|
|
out.append({**link["참조"], "키": link.get("키")})
|
|
return out
|
|
|
|
|
|
def move_refs(doc: dict, move: Any) -> dict:
|
|
"""형제 SK 참조 자리를 `move(참조) → 새 참조` 로(층 옮김 · 복사) — 문서 사본을 고침."""
|
|
if not is_imported(doc) or old_form(doc):
|
|
return doc
|
|
doc = cp.deepcopy(doc)
|
|
for one in docs_of(doc):
|
|
for var in one.get("변수") or []:
|
|
link = var.get("연결") or {}
|
|
if link.get("갈래") == "단가산출" and isinstance(link.get("참조"), dict):
|
|
new = move({**link["참조"], "키": link.get("키")})
|
|
link["키"], link["참조"] = new["키"], {k: new.get(k) for k in ("층", "주인")}
|
|
return doc
|
|
|
|
|
|
def reach_of(doc: Any) -> tuple[list[str], list[str]]:
|
|
"""값 사본이 닿을 것(`M02_Sangeun_Copy.stamp`) — 문서 연결의 (단가산출 키, 요소 키) ·
|
|
형제 SK · 입력 든 키(유가 지역 등) 뺌."""
|
|
if not is_imported(doc) or old_form(doc):
|
|
return [], []
|
|
keys, links = [], []
|
|
for one in docs_of(doc):
|
|
for var in one.get("변수") or []:
|
|
link = var.get("연결") or {}
|
|
key = str(link.get("키") or "")
|
|
if not key or "{" in key or key.startswith("SK-"):
|
|
continue
|
|
if link.get("갈래") == "단가산출":
|
|
keys.append(key)
|
|
elif link.get("갈래") == "요소":
|
|
links.append(key)
|
|
for one_ in (one.get(KEY) or {}).get("기계") or []: # 시간당 연결 기계 = 판정 키(EQ)
|
|
if str(one_.get("키") or "")[:2] == "EQ":
|
|
links.append(str(one_["키"]))
|
|
return list(dict.fromkeys(keys)), list(dict.fromkeys(links))
|