eomsangdonandClaude Opus 5.5
ebd1bc0121
- M02_MyMachine — 층 뿌리 내기계.json · 줄 = M01 기계 줄 꼴 · 키 EQP{사용자}-#### · 원문번호 「개인 {키}」 · 바로 · 품셈(계수 짝) · 직접 세 꼴 · 같은 이름 알림 · 쓰는 곳
- 셈 색인 = M01 + 지금 층 내 기계(skc.Copy) — 단가산출 셈 · 저장 · 사본 찍기 · 단가 갱신 · 새값 표지 · 기계 찾기 · 시간당 · 사본 모으기가 읽음 · 층 모르는 길 = M01 만
- 시간당 식 = 채운 칸으로 고른 GC 식(268 · 272 · 276 · 273) · M01 기계 619 대 셈 방식 대조 차이 0
- 길 /api/m02/layers/personal/my-machines(목록 · 하나 · 만들기 · 고치기 · 지우기 · 본뜬)
- 지킴 시험 test_821_1_my_machine
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
365 lines
16 KiB
Python
365 lines
16 KiB
Python
"""M02 단가산출(SK) 로직 사본(PLAN 795-1 · 요구 655 · 656 · 요구서_655 0 · 1 장) — 서버 단독.
|
|
|
|
사본 = 저장 때 서버가 찍는 M01 닫힌 묶음(`M02_Item_Prices.collect` 다시 씀) — 문서 칸 `사본`:
|
|
{판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 줄], 빠진?}
|
|
로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직 · 찾기 표 · 그 밖 요소(요율 등)
|
|
단가 = 자원 단가 줄(`RES` 노임 · 자재 · 기계 · 유가전력 · 환율) = 단가 기준 시점 묶음.
|
|
셈 = M01 색인 위에 사본 줄을 얹은 `Copy`(키 · 원문번호 찾기만 사본 먼저 · M01 색인 안 고침) —
|
|
`M02_Sangeun_Calc._base_of`(바탕 줄) · `run`(엔진 · 하위 로직 · 표 · 단가)이 `over` 로 부름 ·
|
|
M01 에서 지워진 키 = 사본의 마지막 줄로 셈(표지 `지운키`) ·
|
|
사본 없는 SK(옛 SK · 바탕 참조) = 옛 길.
|
|
사본은 셈 · 저장 첫머리 `settle` 이 정함 — 저장본에 사본이 있으면 그것(화면이 보낸 것 버림) ·
|
|
없으면 받은 사본(층 복사 · 새로 · 판 다시 셈) · 그것도 없으면 저장 때 새로 찍음.
|
|
할일 칸 `사본할일`(화면 캐시 · [저장] 때 적용):
|
|
단가갱신 = 단가 줄만 지금 M01 값(지워진 키 = 그대로) ·
|
|
재생성 = 지금 M01 로 새로 찍음 — 덮개 · 식덮개 · 변수줄 · 상수 · 표값 · 까닭은 cid 열쇠라
|
|
새 사본에 그대로 얹힘 · 못 얹은 칸 = 짝잃음.
|
|
저장 때 = 사본에 없는 새 줄(더한줄 로직 더함 · 기초 바꿈)만 지금 M01 에서 더함.
|
|
길(`M02_Sangeun_Router`): POST …/sangeun/copy/{price|regen} 몸 {문서, 입력값?} →
|
|
{문서(사본할일), 전, 후, 바뀐자원 [{키, 이름, 전, 후, 지워짐?}] · 못얹은 [{cid, 까닭}]}
|
|
(저장 없음).
|
|
셈 답 덧칸 `사본` = {시점, 단가시점, M01새판, 지운키, 단가새값} · 같은 내용 지문 몫 = `same_part`.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
from datetime import datetime
|
|
from decimal import Decimal
|
|
from typing import Any
|
|
|
|
from M02_MasterTemplete import M02_Item_Prices as prices
|
|
from M02_MasterTemplete import M02_MyMachine as mym
|
|
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
|
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
|
|
|
KEY = "사본"
|
|
JOB = "사본할일"
|
|
PRICE, REGEN = "단가갱신", "재생성"
|
|
RES = ("LB", "MT", "EQ", "MO", "FX") # 자원 단가 = 단가 기준 시점 묶음
|
|
_MASTER = prices.mf.Master
|
|
|
|
|
|
def whole_() -> Any:
|
|
"""M01 색인 + 지금 층 내 기계 줄(821-1 · `M02_MyMachine.whole`)."""
|
|
from M02_MasterTemplete import M02_MyMachine as mym
|
|
|
|
return mym.whole()
|
|
|
|
|
|
def _fp(rows: Any) -> str:
|
|
raw = json.dumps(prices.to_json(rows), ensure_ascii=False, sort_keys=True)
|
|
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
|
|
|
|
|
|
def _now() -> str:
|
|
return datetime.now().isoformat(timespec="seconds")
|
|
|
|
|
|
def has(doc: Any) -> bool:
|
|
copy = doc.get(KEY) if isinstance(doc, dict) else None
|
|
return isinstance(copy, dict) and isinstance(copy.get("로직"), list)
|
|
|
|
|
|
# ── 셈 색인 ──────────────────────────────────────────────────────────
|
|
class Copy:
|
|
"""M01 색인 위 사본 줄 — `get` · `logic` · `value` · `label` = 엔진 `Master` 한 벌
|
|
(사본 줄 먼저) · 그 밖 칸(자재 색인 · 찾기 답)은 속 M01 것을 읽음."""
|
|
|
|
get, label, value, logic = _MASTER.get, _MASTER.label, _MASTER.value, _MASTER.logic
|
|
|
|
def __init__(self, whole: Any, rows: list[dict], tag: Any = None) -> None:
|
|
self._whole, self._tag, self.twice = whole, tag, whole.twice
|
|
self.index, self.numbers = dict(whole.index), dict(whole.numbers)
|
|
for row in rows:
|
|
key = str(row.get("키"))
|
|
tid = key[:2]
|
|
self._own(self.index, whole.index, tid)[key] = row
|
|
if row.get("원문번호"):
|
|
self._own(self.numbers, whole.numbers, tid)[str(row["원문번호"])] = row
|
|
|
|
@staticmethod
|
|
def _own(mine: dict, theirs: dict, tid: str) -> dict:
|
|
if mine.get(tid) is theirs.get(tid):
|
|
mine[tid] = dict(theirs.get(tid) or {})
|
|
return mine[tid]
|
|
|
|
def __getattr__(self, name: str) -> Any:
|
|
return getattr(self._whole, name)
|
|
|
|
def __copy__(self) -> Copy: # 수식 고침(796-2b · `master_equation_edit.swap`) — 얕은 사본
|
|
out = object.__new__(Copy)
|
|
out.__dict__.update(self.__dict__)
|
|
return out
|
|
|
|
|
|
def _rows(copy: dict) -> list[dict]:
|
|
raw = json.dumps(prices.to_json([*copy["로직"], *(copy.get("단가") or [])]), ensure_ascii=False)
|
|
return json.loads(raw, parse_float=Decimal, parse_int=Decimal)
|
|
|
|
|
|
_CACHE: dict[tuple, Copy] = {}
|
|
_SEEN: dict[tuple, dict] = {}
|
|
_LIVE: list[Any] = [None] # 지금 M01 색인 — 바뀌면(저장 · 다시 읽음) 메모 비움(옛 색인 안 붙잡음)
|
|
|
|
|
|
def _forget(whole: Any) -> None:
|
|
while isinstance(whole, Copy):
|
|
whole = whole._whole
|
|
if whole is not _LIVE[0]:
|
|
_CACHE.clear()
|
|
_SEEN.clear()
|
|
_LIVE[0] = whole
|
|
|
|
|
|
def over(doc: Any, whole: Any) -> Any:
|
|
"""사본 있는 문서 = 사본 색인 · 없으면 `whole` 그대로(옛 길)."""
|
|
if not has(doc):
|
|
return whole
|
|
copy = doc[KEY]
|
|
tag = (copy.get("판"), copy.get("단가판"))
|
|
if isinstance(whole, Copy) and whole._tag == tag:
|
|
return whole
|
|
_forget(whole)
|
|
got = _CACHE.get((id(whole), *tag))
|
|
if got is None or got._whole is not whole:
|
|
if len(_CACHE) > 32: # ponytail: 통째 비움 · 쓰는 SK 가 많아 느려지면 LRU 로
|
|
_CACHE.clear()
|
|
got = _CACHE[(id(whole), *tag)] = Copy(whole, _rows(copy), tag)
|
|
return got
|
|
|
|
|
|
# ── 찍기 · 단가 갱신 ──────────────────────────────────────────────────
|
|
def _split(rows: list[dict]) -> dict[str, Any]:
|
|
logic = [r for r in rows if str(r.get("키"))[:2] not in RES]
|
|
cost = [r for r in rows if str(r.get("키"))[:2] in RES]
|
|
when = _now()
|
|
return {
|
|
"판": _fp(logic),
|
|
"시점": when,
|
|
"로직": logic,
|
|
"단가판": _fp(cost),
|
|
"단가시점": when,
|
|
"단가": cost,
|
|
}
|
|
|
|
|
|
def stamp(doc: dict) -> dict | None:
|
|
"""지금 M01 로 새 사본 — 바탕 로직 · 더한줄 로직 · 고정 줄 이음 · 가져온 식 줄이 닿는
|
|
닫힌 묶음 · 바탕 참조 · 닿을 것 없음 = None."""
|
|
base = doc.get("바탕") or {}
|
|
if "참조" in base:
|
|
return None
|
|
keys, links = reach(doc.get("더한줄"))
|
|
keys = [str(base["로직"]), *keys] if base.get("로직") else keys
|
|
links += mym.keys_in(doc) # 줄 쌓기 기계 입력 「개인 EQP…」(821-1)
|
|
extra = [row] if (row := imp.row_of(doc)) else []
|
|
return snap(keys, links, extra)
|
|
|
|
|
|
def reach(adds: Any) -> tuple[list[str], list[str]]:
|
|
"""더한줄이 닿는 (로직 키, 요소 키) — 로직 줄 · 인력 · 재료 · 기계 요소 · 고정 줄 이음."""
|
|
adds = [x for x in adds or [] if isinstance(x, dict)]
|
|
keys = [str(x["로직"]) for x in adds if x.get("종류") == "로직" and x.get("로직")]
|
|
links = [str(x["요소"]) for x in adds if x.get("종류") in sd.ADD_PART and x.get("요소")]
|
|
links += [str(v) for x in adds for v in ((x.get("고정") or {}).get("이음") or {}).values() if v]
|
|
return keys, links
|
|
|
|
|
|
def snap(keys: list[str], links: list[str], extra: list[dict] | None = None) -> dict | None:
|
|
"""키 · 요소 · 마스터 밖 줄이 닿는 M01 닫힌 묶음 → 사본(닿을 것 없음 = None)."""
|
|
if not (keys or links or extra):
|
|
return None
|
|
got = prices.collect(keys, links, extra)
|
|
lost = got.pop("_빠진", None)
|
|
keys = [str(r.get("키")) for data in got.values() for r in data[prices.m01.items_key(data)]]
|
|
whole = whole_() # 줄 = 셈 색인 것(파일 묶음과 같은 판)
|
|
rows = [whole.index[k[:2]][k] for k in keys if k in whole.index.get(k[:2], {})]
|
|
out = _split(prices.to_json(rows))
|
|
return out | ({"빠진": lost} if lost else {})
|
|
|
|
|
|
def refresh(copy: dict, whole: Any) -> tuple[dict, list[dict]]:
|
|
"""[단가 갱신] — 단가 줄만 지금 M01 값 · (새 사본, 바뀐자원) · 지워진 키 = 마지막 값 그대로."""
|
|
rows, changed = [], []
|
|
for row in copy.get("단가") or []:
|
|
key = str(row.get("키"))
|
|
live = whole.index.get(key[:2], {}).get(key)
|
|
if live is None:
|
|
rows.append(row)
|
|
changed.append({"키": key, "이름": row.get("이름"), "지워짐": True})
|
|
continue
|
|
new = prices.to_json(live)
|
|
if _fp(new) != _fp(row):
|
|
changed.append(
|
|
{"키": key, "이름": new.get("이름"), "전": row.get("값"), "후": new.get("값")}
|
|
)
|
|
rows.append(new)
|
|
return {**copy, "단가": rows, "단가판": _fp(rows), "단가시점": _now()}, changed
|
|
|
|
|
|
def grow(copy: dict, fresh: dict | None) -> dict:
|
|
"""저장 때 — 사본에 없는 키 줄만 새 사본(`fresh` = 지금 M01)에서 더함(있는 줄 = 그대로)."""
|
|
have = {str(r.get("키")) for r in [*copy["로직"], *(copy.get("단가") or [])]}
|
|
new = [
|
|
r
|
|
for r in [*(fresh or {}).get("로직", []), *(fresh or {}).get("단가", [])]
|
|
if str(r.get("키")) not in have
|
|
]
|
|
if not new:
|
|
return copy
|
|
logic = [*copy["로직"], *(r for r in new if str(r.get("키"))[:2] not in RES)]
|
|
cost = [*(copy.get("단가") or []), *(r for r in new if str(r.get("키"))[:2] in RES)]
|
|
return {**copy, "로직": logic, "판": _fp(logic), "단가": cost, "단가판": _fp(cost)}
|
|
|
|
|
|
def rejoin(copy: dict, adds: list) -> dict:
|
|
"""[다시 잇기](796-2e) — 표지 낀 더한 기초가 닿는 닫힌 묶음을 지금 M01 줄로 갈음(단가 줄은 더하기만)."""
|
|
keys = [
|
|
str(x["로직"]) for x in adds if isinstance(x, dict) and x.get("다시잇기") and x.get("로직")
|
|
]
|
|
fresh = snap(keys, [])
|
|
if not fresh:
|
|
return copy
|
|
new = {str(r.get("키")): r for r in fresh["로직"]}
|
|
logic = [new.pop(str(r.get("키")), r) for r in copy["로직"]] + list(new.values())
|
|
return grow({**copy, "로직": logic, "판": _fp(logic)}, fresh)
|
|
|
|
|
|
def taken(raw: Any) -> dict | None:
|
|
"""받은 사본(층 복사 · 새로) — 줄 꼴만 보고 판은 서버가 다시 셈."""
|
|
if not has({KEY: raw}):
|
|
return None
|
|
logic = [r for r in raw["로직"] if isinstance(r, dict) and str(r.get("키"))[:2] not in RES]
|
|
cost = [r for r in raw.get("단가") or [] if isinstance(r, dict) and str(r.get("키"))[:2] in RES]
|
|
keep = {k: str(raw.get(k) or "") for k in ("시점", "단가시점")}
|
|
return {**keep, "로직": logic, "판": _fp(logic), "단가": cost, "단가판": _fp(cost)}
|
|
|
|
|
|
def _stored(key: Any) -> dict | None:
|
|
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
|
|
|
if not sd.KEY.match(str(key or "")):
|
|
return None
|
|
try:
|
|
got = json.loads((store.root() / sd.KIND / f"{key}.json").read_bytes())
|
|
except (OSError, ValueError):
|
|
return None
|
|
return got[KEY] if has(got) else None
|
|
|
|
|
|
def settle(doc: Any, save: bool = False) -> Any:
|
|
"""셈 · 저장 첫머리 — 서버가 정한 사본으로 갈음(할일 적용 · 저장 때 새 줄 더함 · 할일 칸 뗌)."""
|
|
if not isinstance(doc, dict):
|
|
return doc
|
|
job = doc.get(JOB) # 모르는 할일 = 없음
|
|
out = {k: v for k, v in doc.items() if k not in (KEY, JOB)}
|
|
if "참조" in (doc.get("바탕") or {}):
|
|
return out
|
|
copy = _stored(doc.get("키")) or taken(doc.get(KEY))
|
|
if job == REGEN or (copy is None and save):
|
|
copy = stamp(out)
|
|
elif job == PRICE and copy:
|
|
copy = refresh(copy, whole_())[0]
|
|
if copy and any(isinstance(x, dict) and x.get("다시잇기") for x in out.get("더한줄") or []):
|
|
copy = rejoin(copy, out["더한줄"])
|
|
if save and copy:
|
|
copy = grow(copy, stamp(out))
|
|
out = _formula_job(out, job)
|
|
return {**out, KEY: copy} if copy else out
|
|
|
|
|
|
def _formula_job(out: dict, job: Any) -> dict:
|
|
"""수식 사본(802-4a · `M02_Doc_Sk`) 할일 — 재생성 = 파생으로(부름 새로 · 고친 문서 버림) ·
|
|
단가갱신 = 따로 문서의 값 줄도 지금 M01."""
|
|
from M02_MasterTemplete import M02_Doc_Copy as dc
|
|
|
|
got = out.get(dc.KEY) if dc.has(out) else None
|
|
if got is None or job not in (PRICE, REGEN):
|
|
return out
|
|
if job == REGEN:
|
|
got = {k: v for k, v in got.items() if k not in ("문서", "끊음", "따로")} | {"부름": {}}
|
|
elif got.get("따로"):
|
|
got = dc.refresh(got)[0]
|
|
return {**out, dc.KEY: got}
|
|
|
|
|
|
# ── 표지 ──────────────────────────────────────────────────────────────
|
|
def state(copy: dict, whole: Any) -> dict[str, Any]:
|
|
"""{M01새판, 지운키, 단가새값} — 사본 줄과 지금 M01 줄 대조(같은 M01 · 같은 판 = 메모)."""
|
|
_forget(whole)
|
|
tag = (id(whole), copy.get("판"), copy.get("단가판"))
|
|
if tag in _SEEN and _SEEN[tag]["whole"] is whole:
|
|
return _SEEN[tag]["답"]
|
|
|
|
def live(row: dict) -> Any:
|
|
key = str(row.get("키"))
|
|
return whole.index.get(key[:2], {}).get(key)
|
|
|
|
gone = [str(r.get("키")) for r in [*copy["로직"], *(copy.get("단가") or [])] if live(r) is None]
|
|
logic = any(live(r) is None or _fp(live(r)) != _fp(r) for r in copy["로직"])
|
|
cost = any(live(r) is not None and _fp(live(r)) != _fp(r) for r in copy.get("단가") or [])
|
|
got = {"M01새판": logic, "지운키": gone, "단가새값": cost}
|
|
_SEEN[tag] = {"whole": whole, "답": got}
|
|
return got
|
|
|
|
|
|
def mark(ans: dict, doc: dict) -> dict:
|
|
"""셈 답 덧칸 `사본` — 사본 없는 문서 = 칸 없음."""
|
|
if not has(doc):
|
|
return ans
|
|
copy = doc[KEY]
|
|
head = {"시점": copy.get("시점"), "단가시점": copy.get("단가시점")}
|
|
return {**ans, KEY: {**head, **state(copy, whole_())}}
|
|
|
|
|
|
def same_part(doc: Any) -> str | None:
|
|
"""같은 내용 지문 몫 — 지금 M01 과 같은 사본 = None(새로 찍을 문서와 같음) · 다르면 판."""
|
|
if not has(doc):
|
|
return None
|
|
copy = doc[KEY]
|
|
seen = state(copy, whole_())
|
|
fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"])
|
|
return None if fresh else f"{copy.get('판')}:{copy.get('단가판')}"
|
|
|
|
|
|
# ── [단가 갱신] · [재생성] 미리 셈(저장 없음) ──────────────────────────
|
|
def _money(ans: dict) -> dict | None:
|
|
base = ans.get("기준")
|
|
return {k: base.get(k) for k in ("노무비", "재료비", "경비", "계")} if base else None
|
|
|
|
|
|
def _lost(ans: dict) -> dict[str, dict]:
|
|
rows = [*(ans.get("짝잃음") or []), *((ans.get("시트") or {}).get("짝잃음") or [])]
|
|
return {str(x.get("cid")): x for x in rows if isinstance(x, dict)}
|
|
|
|
|
|
def preview(doc: Any, job: str, given: dict | None = None) -> dict[str, Any]:
|
|
"""{문서(할일 얹음), 전, 후, 바뀐자원 · 못얹은} — 재생성은 단가갱신을 품음."""
|
|
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
|
|
|
if not isinstance(doc, dict):
|
|
raise sd.DocError("단가산출 문서가 묶음 아님")
|
|
old = doc.get(JOB)
|
|
new = REGEN if REGEN in (old, job) else job
|
|
after_doc = {**doc, JOB: new}
|
|
before = calc.calc_doc(doc, given, False)
|
|
after = calc.calc_doc(after_doc, given, False)
|
|
out: dict[str, Any] = {"문서": after_doc, "전": _money(before), "후": _money(after)}
|
|
if cut := [
|
|
str(x.get("이름") or x.get("로직")) for x in doc.get("더한줄") or [] if x.get("끊음")
|
|
]:
|
|
out["끊은기초"] = cut # 줄은 그대로 · 자원 단가만(요구 656-1)
|
|
if job == PRICE:
|
|
copy = _stored(doc.get("키")) or taken(doc.get(KEY))
|
|
out["바뀐자원"] = refresh(copy, whole_())[1] if copy else []
|
|
else:
|
|
was = _lost(before)
|
|
out["못얹은"] = [
|
|
{"cid": c, "까닭": x.get("까닭") or "새 사본에 그 줄 없음"}
|
|
for c, x in _lost(after).items()
|
|
if c not in was
|
|
]
|
|
return out
|