Merge remote-tracking branch 'origin/dev' into sub_laptop_1

This commit is contained in:
2026-11-18 07:20:06 +09:00
93 changed files with 1579 additions and 2504 deletions
+7 -1
View File
@@ -7,7 +7,7 @@
이 문서 셈 = 사본 줄 묶음이 이 문서 사본 안에 드는 색인(남의 SK · SC 참조 셈 = 제 사본 → 안 셈).
파일 꼴 그대로 — 옛 코드는 사본에 없는 줄을 지금 M01 로 읽음(지금 옵션에서 안 읽는 줄 = 금액 같음).
읽은 줄 없음(셈 안 돎) · 프로젝트 층 = 그대로 · 이미 저장된 파일은 다음 [저장] 때 줄어듦.
층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀) · 단가산출 빈 옛 칸 뺌.
층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀 · 단가산출 로직 줄 안 담음 855 L2 ⓑ) · 단가산출 빈 옛 칸 뺌.
"""
from __future__ import annotations
@@ -129,4 +129,10 @@ def trim(kind: str, doc: Any) -> Any:
form = out.get(dc.KEY) # 단가산출 · 일위대가 · 사전조합 같은 꼴(SC `수식` = 값 몫 + 부름)
if skc.has(out) and isinstance(form, dict) and isinstance(form.get("로직"), list):
out[dc.KEY] = {**form, **dc.values_of(out.pop(skc.KEY))}
form = out.get(dc.KEY)
if kind == "sangeun" and isinstance(form, dict) and isinstance(form.get("로직"), list):
out[dc.KEY] = {
**form,
**skc.held({"종류": "단가산출", dc.KEY: form}),
} # 로직 줄 안 씀(855 L2 ⓑ)
return out
+3 -1
View File
@@ -56,7 +56,8 @@ def gaps(copy: dict) -> list[str]:
except dc._ERR:
pass
have = _have(copy)
return sorted({*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have)
got = {*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have
return sorted(k for k in got if k[:2] not in skc.LOGIC) # 로직 줄 = 문서 사본(855 L2 ⓑ)
def fill(copy: dict) -> dict:
@@ -78,6 +79,7 @@ def fill_imported(sk: dict, doc: Any) -> dict:
seen = _Seen(dim._index(sk, None, doc))
dim.run(doc, sk, index=seen) # 셈 틀림 = 읽은 데까지(run 이 받음)
keys = sorted({*seen.keys, *mym.keys_in(doc), *own.keys_in(doc)} - _have(sk[skc.KEY]))
keys = [k for k in keys if k[:2] not in skc.LOGIC] # 로직 줄 안 담음(855 L2 ⓑ)
if not keys:
return sk
return {**sk, skc.KEY: skc.grow(sk[skc.KEY], skc.snap([], keys))}
+12 -10
View File
@@ -97,8 +97,8 @@ def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]:
if renew.on() and live is not None:
return dc.doc_of(whole, key), True
kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None
if kept:
return cp.deepcopy(kept), True
if kept: # 프로젝트 층 = 굳힐 때 문서 + 옛 자동값(855 L2 ⓑ — 전과 같은 옵션 값)
return cp.deepcopy(kept), renew.on()
if live is not None and live.get(mcv.HAND):
from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게
@@ -247,7 +247,8 @@ def copy_of(sk: dict, whole: Any = None) -> dict | None:
whole = dc.over(values)
calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름"))
base = str((sk.get("바탕") or {}).get("로직") or "")
seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지)
# 바탕 문서 판(「M01 새 판」 표지) = 셈에 쓴 기초 문서(층 = 지금 M01 · 프로젝트 = `바탕문서` · 855 L2 ⓑ)
seen = base_doc({**sk, KEY: got}, whole, base)[0] if base else None
origin = {"원본": {"키": base, "판": dc.doc_fp(seen)}} if seen else {}
return {**got, **values, "문서": root, "부름": calls, **origin}
@@ -315,17 +316,18 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict:
UPPER
): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1)
first[UPPER] = have[UPPER]
if not renew.on() and not patched(out): # 프로젝트 층 = 기초 문서 사본으로 굳힘(855 L2 ⓑ ㉣)
kept = None if job == skc.REGEN else (have or {}).get(BASE_DOC)
key = str((out.get("바탕") or {}).get("로직") or "")
if kept is None and key in dc.folder():
kept = base_doc({**out, KEY: {}}, whole, key)[0] # 굳히기 전과 같은 문서
if kept:
first[BASE_DOC] = norm(_bare_doc(kept))
copy = copy_of({**out, KEY: first}, whole)
if (
copy and skc.READS.get() is not None
): # 저장 관문 — 문서 셈 · 부름 줄이 읽은 줄을 적음(826-3)
): # 저장 관문 — 문서 셈이 읽은 줄을 적음(826-3 · 부름 = 문서 사본 · 로직 줄 안 둠 855 L2 ⓑ)
run({**out, KEY: copy}, copy, whole)
index = dc.over(copy)
for key in copy.get("부름") or {}: # 부름 문서를 가른 값 사본 줄(`dc.doc_of`)도 둠
try:
index.logic(key)
except dc._ERR:
pass
if (
copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy))
): # 파생 — 옛 로직 사본에 박음(822-1)
+2 -1
View File
@@ -271,7 +271,8 @@ def plain(mine: dict, sk: dict) -> dict:
def _rows(copy: dict) -> set[str]:
return {str(r.get("키")) for r in [*(copy.get("로직") or []), *(copy.get("단가") or [])]}
rows = [*skc.plain(copy.get("로직")), *(copy.get("단가") or [])] # 로직 줄 안 셈(855 L2 ⓑ)
return {str(r.get("키")) for r in rows}
def _basis(doc: dict, body: dict) -> dict:
+1 -32
View File
@@ -17,7 +17,7 @@ STmate 꼴(「일위대가표」 · 「단가산출근거」 시트) = `M02_Hopy
% 줄 = floor(바탕 × 율 / 100 × 10) / 10 · 호표 비목 = floor(줄 금액 합) · 총괄표 합계 —
어긋남은 글 목록(막지 않음).
행(329-1) = 호표 [제N호표 줄, 마지막 구성 줄] · 구성 줄 한 줄(엑셀 1부터) ·
근거(330-1) = 단산N참조 줄에 「단가산출」 블록 `{출처, 직종, 행}`(`M02_Hopyo_ReadEst.read`) ·
근거(330-1) = 단산N참조 줄에 「단가산출」 블록 `{출처, 직종, 행}`(`M02_Hopyo_ReadEst.from_two`) ·
`단산` = 블록마다 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`(338 · 글 = 머리 뺀 몸 줄) ·
`꼴` = 「엑셀꼴」 · 두 형식 끝에 `UnitLine.settle`(단위 줄 하위 · 재현 · 덮음 · 일위대가 줄
투영 · 778-3).
@@ -40,7 +40,6 @@ SHEET = "일위대가"
SUMMARY = "일위대가총괄표"
LISTS = ("단가산출총괄표", "일위대가목록표") # 엑셀 보기 목록 시트(779-1 격자) — 같이 읽음
COSTS = ("노무비", "재료비", "경비")
HEADS = ("호표", "품명", "규격", "수량", "단위", "비고")
NO_SHEET = "일위대가 시트 없음"
_HOPYO = re.compile(r"제\s*(\d+)\s*호표")
_REF = re.compile(r"^(?:(단산|산근|단가산출)|(일위대가|일위|대가))(\d+)(?:참조|호표)?$")
@@ -88,19 +87,6 @@ def _out(value: Decimal | None) -> int | float | None:
return int(value) if value == value.to_integral_value() else float(value)
def _columns(rows: list[list[Any]], money: tuple[str, ...]) -> tuple[int, dict[str, int]]:
"""(자료 첫 줄, {머리: 열}) — 머리 글은 앞 10 줄 안 「호표」 · 「품명」 이 든 줄."""
for at, row in enumerate(rows[:10]):
flat = [_flat(v) for v in row]
if "호표" not in flat or "품명" not in flat:
continue
cols = {head: flat.index(head) for head in (*HEADS, *money) if head in flat}
below = [_flat(v) for v in rows[at + 1]] if at + 1 < len(rows) else []
start = at + 2 if "단가" in below or "금액" in below else at + 1
return start, cols
raise ExcelError(f"{SHEET} 시트 머리 글(호표 · 품명)을 못 찾음")
def _cell(row: list[Any], col: int | None) -> Any:
return row[col] if col is not None and col < len(row) else None
@@ -200,23 +186,6 @@ def _check_hopyo(hopyo: dict[str, Any], lines: list[dict[str, Any]]) -> list[str
return bad
def _summary(rows: list[list[Any]] | None) -> dict[int, Decimal]:
"""총괄표 {호표 번: 합계} — 머리 글이 없으면 빈 것."""
if not rows:
return {}
try:
start, cols = _columns(rows, ("합계",))
except ExcelError:
return {}
out = {}
for row in rows[start:]:
hit = _HOPYO.fullmatch(_flat(_cell(row, cols.get("호표"))))
total = _num(_cell(row, cols.get("합계")))
if hit and total is not None:
out[int(hit.group(1))] = total
return out
def _by_name(raw: list[list[dict[str, Any]]], blocks: dict[int, dict[str, Any]]) -> None:
"""비고 빈 줄(노무비 · 경비 단가 있음) → 품명 + 단위가 같은 블록이 하나뿐이면 단산 이음."""
index: dict[tuple[str, str], list[int]] = {}
+3 -52
View File
@@ -8,16 +8,12 @@
걷음(742-1 · 다르면 남김 = 금액 그대로)) · SK · SC `본뜬.또` = 그 HP 몫만 뺌 ·
문서 몸(줄 · 덮개 · 더한줄 · 별칭 · 구분)과 별칭 장부는 그대로 ·
끝낸 기록 없음(같은 엑셀 다시 올림 됨 · 키 번은 `불러옴.json` 번으로 다시 안 씀).
옛 파일 정리 `tidy`(한 번 · 층 폴더마다 · 미리 보기 = 표만) — 옛 HP(지문 없음) · 하루 지난 HP 끝냄 ·
끝낸 기록 지문 비움 · HP 가 없는 SC · SK 엑셀 사본 걷음.
`python -m M02_MasterTemplete.M02_Hopyo_Forget <층 폴더>… [--apply]`(없으면 미리 보기).
"""
from __future__ import annotations
import json
import re
import sys
from collections.abc import Callable
from datetime import datetime
from pathlib import Path
@@ -30,7 +26,6 @@ from M02_MasterTemplete import M02_Labor_Ref as refs
ORIGIN = "실무자료"
KEEP = ("층", "파일", "전국자재", "복사원본")
_MEMO = re.compile(r"^실무 ")
_HP = re.compile(r"^(HP-\d{6}) ")
# ── 사본 걷음(순수) ───────────────────────────────────────────────────
@@ -99,8 +94,8 @@ def _here(got: dict[str, Any], here: refs.Here) -> bool:
return not got.get("원본") or tuple(got["원본"]) == tuple(here)
def forget(folder: str | Path, gone: Callable[[str], bool], apply: bool = True) -> list[str]:
"""`gone(본뜬 키)` 인 이 층 SC · SK 엑셀 사본 걷음 → 걷은 문서 키(`apply` 거짓 = 셈만)."""
def forget(folder: str | Path, gone: Callable[[str], bool]) -> list[str]:
"""`gone(본뜬 키)` 인 이 층 SC · SK 엑셀 사본 걷음 → 걷은 문서 키."""
folder, out = Path(folder), []
here = refs.where(folder)
@@ -120,8 +115,7 @@ def forget(folder: str | Path, gone: Callable[[str], bool], apply: bool = True)
new["본뜬"]["또"] = also # 777-1 같은 내용 SC 를 나눠 쓴 다른 불러오기 몫은 그대로
if new != doc:
out.append(path.stem)
if apply:
atomic_write_json(path, new)
atomic_write_json(path, new)
return out
@@ -150,46 +144,3 @@ def sweep(folder: str | Path, now: datetime | None = None) -> list[str]:
for key in (got := expired(folder, now)):
finish(folder, key)
return got
# ── 옛 파일 정리(한 번) ───────────────────────────────────────────────
def tidy(folder: str | Path, apply: bool = False) -> list[dict[str, str]]:
"""옛 실무자료 정리 표 `[{할일, 대상}]` — `apply` 거짓 = 미리 보기(쓰기 없음)."""
folder = Path(folder)
home = folder / hopyo_store.DIRNAME
rows: list[dict[str, str]] = []
every = sorted(p.stem for p in home.glob("HP-*.json"))
old = [k for k in every if not (hopyo_store._load(home / f"{k}.json") or {}).get("지문")]
ended = [*old, *expired(folder)]
live = set(every) - set(ended)
for key in ended:
rows.append({"할일": "HP 끝냄(옛 · 하루 지남)", "대상": f"{hopyo_store.DIRNAME}/{key}"})
if apply:
finish(folder, key)
log = hopyo_store.done(folder)
if log["지문"]:
rows.append({"할일": f"끝낸 기록 지문 {len(log['지문'])} 비움", "대상": "불러옴.json"})
if apply:
hopyo_store._put_done(folder, {"번": log["번"]})
def gone(mark: str) -> bool:
m = _HP.match(mark)
return bool(m) and m.group(1) not in live
for key in forget(folder, gone, apply):
rows.append({"할일": "엑셀 사본 걷음(출처만)", "대상": key})
return rows
def main(argv: list[str]) -> int:
apply = "--apply" in argv
for one in [a for a in argv if a != "--apply"]:
rows = tidy(one, apply)
print(f"# {one} — {'고침' if apply else '미리 보기'} {len(rows)}")
for row in rows:
print(f"{row['할일']}\t{row['대상']}")
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))
+4 -72
View File
@@ -1,14 +1,13 @@
"""M02 일위대가 실무자료 EST(엑셀꼴) 단가산출 어댑터(PLAN 776-2 · 요구 621-1 ② 정규화) —
엑셀 「단가산출」 시트 → 블록 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`.
둘 꼴 EST 산근 블록(`from_two` · 857-2) → 블록 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`.
형식(EST 글)을 아는 곳은 여기까지.
블록 = B열(머리 「산출근거」) 머리 줄 「N.이름[단위]」(앞 빈칸 없음)부터 다음 머리 앞까지 ·
블록 = 머리 「N.이름[단위]」부터 다음 머리 앞까지 ·
출처 = 「…품셈」(오타 「품줌」) 뒤 20 글자 안 절 번호 — 책 = 앞 낱말(`book_of` · 781-1: 산림 ·
임도(옛) · 사방(옛) · 건설 부문 · 그 밖 건설품셈(부문 모름)) ·
부문 풀이 · 옛 번호 대응 = `M02_Hopyo_Clause.settle` ·
직종 = 「이름 : 수」 줄의 빈칸 뺀 이름이 우리 인력(LB) 이름 · 옛이름일 때만(지금 이름으로) ·
글 = 머리 뺀 몸 줄 `GLINES` 줄 · 줄마다 `GCHARS` 자 안 · 산출근거 열이 빈 줄은 그 오른쪽 ~ 돈 머리
(맨 오른쪽 묶음) 앞 칸을 빈칸으로 이어 붙임(거창 꼴 · 돈 머리 없으면 `WIDE` 열) ·
글 = 머리 뺀 몸 줄 `GLINES` 줄 · 줄마다 `GCHARS` 자 안 ·
금액 = 머리 줄 돈 칸(1 단위).
항목(Book 블록 항목 · 778-3) = 글 줄 → 단위 줄(꼴 = `M02_Hopyo_UnitLine`) · 줄 금액 = 「= 금액」 ·
끝 점(「28,500. ×」) 뗌 · 율(호표 줄 이름 · 규격)에 기대지 않는 것만(섞음 율은 지문 몫):
@@ -34,7 +33,7 @@ from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs
from M02_MasterTemplete.M02_Hopyo_Words import mtypes, parse_rhs
SHEET = "단가산출"
GLINES, GCHARS, WIDE = 200, 300, 140
GLINES, GCHARS = 200, 300
_HEAD = re.compile(r"^(\d+)\.\s*(.*?)\s*\[([^\[\]]*)\]\s*$")
_BOOK = re.compile(r"품[셈줌]")
_TRADE = re.compile(r"^[\s*·\-]*([가-힣][가-힣\s]*?)\s*:\s*[\d,]")
@@ -46,7 +45,6 @@ _BOOK_WORDS = { # 책 낱말(781-1) — 옛 책 = 「(옛)」 · 건설 부문
}
_BOOK_WORD = re.compile(r"(" + "|".join(_BOOK_WORDS) + r")\s*(?:부문|사업|공사)?\s*(?:표준)?\s*$")
_TYPO_CLAUSE = re.compile(r"^(\d+)-(\d)(\d)(\d)$") # 「13-114」 = 13-11-4
_MONEY = {"합계": "계", "노무비": "노무비", "재료비": "재료비", "경비": "경비"}
# 항목 풀이 — 지문(`Finger`)과 같은 규칙
COST = ("노무비", "재료비", "경비")
SKIPW = frozenset(
@@ -88,12 +86,6 @@ def _flat(value: Any) -> str:
return re.sub(r"\s+", "", str(value or ""))
def _cell_text(value: Any) -> str:
if isinstance(value, float) and value == int(value):
value = int(value)
return str(value).strip() if value is not None else ""
# ── 이름 · 출처(두 어댑터 · 뒤 단계 공용) ────────────────────────────────
@lru_cache(maxsize=2)
def _trade_names(whole_id: int) -> dict[str, str]:
@@ -156,66 +148,6 @@ def rates_in(text: Any) -> set[float]:
return out
# ── 블록 읽기 ─────────────────────────────────────────────────────────
def _columns(rows: list[list[Any]]) -> tuple[int, int, dict[str, int]]:
"""(자료 첫 줄, 산출근거 열, {계 · 노무비 · 재료비 · 경비: 열}) — 머리 없으면 (0, 1, {}) ·
돈 머리가 둘 묶음이면 맨 오른쪽(거창 꼴 · 값이 든 쪽)."""
for at, row in enumerate(rows[:10]):
flat = [_flat(v) for v in row]
if "산출근거" in flat:
last = len(flat) - 1
money = {
key: last - flat[::-1].index(head) for head, key in _MONEY.items() if head in flat
}
return at + 1, flat.index("산출근거"), money
return 0, 1, {}
def read(rows: list[list[Any]] | None) -> dict[int, dict[str, Any]]:
"""단가산출 시트 줄 → `{N: {번, 이름, 단위, 행: [시작, 끝], 출처, 직종, 글, 글행, 금액, 항목,
절}}`(행 = 엑셀 1부터 · 글행 = 글 줄마다 행 · 절 = `M02_Hopyo_Formula.tree`)."""
if not rows:
return {}
start, col, money = _columns(rows)
end = min(money.values()) if money and min(money.values()) > col + 1 else WIDE
names = trade_names()
blocks: dict[int, dict[str, Any]] = {}
block: dict[str, Any] | None = None
for at, row in enumerate(rows[start:], start + 1):
text = row[col] if col < len(row) else None
head = None
if isinstance(text, str) and text.strip():
head = None if text[:1].isspace() else _HEAD.match(text)
else:
text = " ".join(_cell_text(v) for v in row[col + 1 : end] if _cell_text(v))
if not text:
continue
if head:
block = blocks.setdefault(
int(head.group(1)),
{
"번": int(head.group(1)),
"이름": head.group(2),
"단위": head.group(3).strip(),
"행": [at, at],
"출처": [],
"직종": [],
"글": [],
"금액": {
key: v
for key, c in money.items()
for v in [row[c] if c < len(row) else None]
if isinstance(v, (int, float)) and not isinstance(v, bool)
},
"_글행": [],
},
)
continue
if block is not None:
_take(block, at, text, names)
return _finish(blocks)
def _take(block: dict[str, Any], at: int, text: str, names: dict[str, str]) -> None:
"""몸 줄 하나 → 블록 끝 행 · 글(`GLINES` 줄 · 줄마다 `GCHARS` 자) · 출처 · 직종."""
block["행"][1] = at
+1 -22
View File
@@ -40,13 +40,10 @@ LISTS = ("단가산출근거목록표", "노무비목록표", "중기목록표",
SHEETS = (SHEET, CALC, *LISTS)
_CODE = ilwi.CODE
_META = re.compile(r"(?<![A-Z])COD\|([A-Z]{1,2}\d{5})") # 숨은 칸 「`COD|L00001」
_HEAD_B = re.compile(r"BDCOD\|(B\d{5})")
_HEAD_D = re.compile(r"BDCOD\|(D\d{5})")
_RES = re.compile(r"^([LMXS])(\d{5})_\d+$")
_RES_A = re.compile(r"^([LMXS]\d{5})[LMS]$") # A 열 「L00002L」
_RES_G = re.compile(r"&([LMXS]\d{5})[LMS]&") # G 열 식 「&L00002L&」
_SECTION = re.compile(r"^\s*(?:\d+\s*[.)]|[①-⑩])\s*(.*\S)")
_COLS = {"합계": 4, "노무비": 6, "재료비": 8, "경비": 10}
_CALC_AMOUNT = {"합계": 2, "노무비": 3, "재료비": 4, "경비": 5} # 단가산출근거 C~F 금액
_CALC_PRICE = {"합계": 8, "노무비": 9, "재료비": 10, "경비": 11} # I~L 단가(T · L · M · S)
NOTE, CODE_COLS, RES_COL, QTY_COL, NAME_COL = 12, range(12, 26), 12, 7, 23
@@ -293,27 +290,9 @@ def _finish(out: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]:
return out
def _blocks(rows: list[list[Any]], table: dict[str, dict[str, str]]) -> dict[str, dict[str, Any]]:
"""{D 코드: {번, 코드, 이름, 규격, 단위, 행, 출처, 직종, 글, 자원, 금액, 항목}}."""
out: dict[str, dict[str, Any]] = {}
block: dict[str, Any] | None = None
state = {"절": "", "라벨": ""} # 절 제목 · 율 행 위 라벨 줄(코드 · 금액 없는 글)
for at, row in enumerate(rows, 1):
head = next(
(hit for v in row[:8] if (hit := _HEAD_D.search(_s(v)))), None
) # 머리 = G 열(판마다 B 열 글이 다름)
if head:
block = out.setdefault(head.group(1), _new(head.group(1), at, row, table))
state = {"절": "", "라벨": ""}
continue
if block is not None and not _take(block, at, row, table, state):
block = None
return _finish(out)
def from_two(blocks: list[dict[str, Any]], table: dict[str, dict[str, str]]) -> dict[str, Any]:
"""둘 꼴 STmate 산근 블록 `칸줄`(머리 ~ 다음 머리 앞 칸 · `M02_San_Xlsx_Stmate.cells` · 857-2) →
`_blocks` 와 같은 블록 — 시트를 다시 가르지 않음 · D 코드 블록만."""
블록 — 시트를 다시 가르지 않음 · D 코드 블록만."""
out: dict[str, dict[str, Any]] = {}
for b in blocks:
code = str(b.get("코드") or "")
+3 -5
View File
@@ -6,7 +6,7 @@
층 종류(`layers.KINDS`) 밖 폴더 — 양식 목록 · 복사 · 프로젝트 씨앗에 안 섞임 · 권한은 길 몫.
한시 불러오기(718-1 · 743-1) — 파일에 `지문`(올린 엑셀 sha256) · 목록 = 지문 있고 하루 안 지난 것
(작업 중)만 · 옛 HP · 하루 지난 HP 는 목록에서 숨김(지움 = `M02_Hopyo_Forget`) ·
`실무자료/불러옴.json` `{번}` = 낸 키 가장 큰 번(지운 뒤에도 키를 다시 안 씀 · 옛 `지문` 안 읽음).
`실무자료/불러옴.json` `{번}` = 낸 키 가장 큰 번(지운 뒤에도 키를 다시 안 씀).
판(776-2) = 읽기 꼴(Book) 판 `BOOK` 을 HP 에 찍음 · 다른 판 = 지난 것(목록에서 숨김 ·
다음 올림 때 끝냄 · 작업 중 열기 = 409 「다시 올림」 · 옛 꼴 읽기 갈래 없음).
"""
@@ -95,11 +95,9 @@ def rows(folder: str | Path) -> list[dict[str, Any]]:
def done(folder: str | Path) -> dict[str, Any]:
"""키 번 기록 `{번, 지문}`(지문 = 743 전 끝낸 기록 · 안 읽음 · 정리 `Forget.tidy`)."""
"""키 번 기록 `{번}`."""
doc = _load(_dir(folder) / f"{DONE}.json")
doc = doc if isinstance(doc, dict) else {}
marks = doc.get("지문")
return {"번": int(doc.get("번") or 0), "지문": marks if isinstance(marks, dict) else {}}
return {"번": int((doc if isinstance(doc, dict) else {}).get("번") or 0)}
def _put_done(folder: str | Path, got: dict[str, Any]) -> None:
+1 -1
View File
@@ -1,6 +1,6 @@
"""M02 일위대가 실무자료 단위 줄(PLAN 778-3 · D-1 · 요구 622) — 단가산출 블록 · 일위대가 줄을 같은
「세부항목 계산 단위」 꼴로 · 자체 검산. 형식(EST · STmate)을 모름 — 읽기 어댑터
(`M02_Hopyo_ReadEst.items` · `M02_Hopyo_Stmate._blocks`)가 블록 `항목` 을 단위 줄로 냄.
(`M02_Hopyo_ReadEst.items` · `M02_Hopyo_Stmate.from_two`)가 블록 `항목` 을 단위 줄로 냄.
단위 줄 = `{묶음, 이름, 규격, 단위, 품, 밑품, 율, 인자, 계수, 단가, 금액, 밖, 기준, 기준값,
하위, 할증, 재현, 직종, 절, 절율, 코드, 어떻게, 행}`:
+58 -46
View File
@@ -1,9 +1,9 @@
"""M02 일위대가 입력 목록(39-3).
담은 단가산출 로직마다 입력 전부 · 로직마다 갈라 보이고 이름이 같아도 합치지 않음 · 입력 목록은
그 로직 줄의 `입력` 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직 입력으로만) · 자동값 =
`master_auto.values`(보기용 · 저장 안 함). 일위대가 입력 모달(`GET /api/m02/logic-lib/inputs`)이
씀. M01 은 읽기만 · 권한은 부르는 쪽 몫.
그 수식 문서의 입력 변수(갈래 입력 · 선택) 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직
입력으로만) · 자동값 = `M02_Doc_Copy.auto_of`(보기용 · 저장 안 함). 일위대가 입력 모달
(`GET /api/m02/logic-lib/inputs`)이 씀. M01 은 읽기만(수식 문서 · 855 L2 ⓑ) · 권한은 부르는 쪽 몫.
"""
from __future__ import annotations
@@ -12,10 +12,10 @@ import re
from decimal import Decimal
from typing import Any
from M01_MasterData import M01_MasterData_Doc as m01doc
from M01_MasterData import M01_MasterData_Store as m01
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
_SPEC = ("이름", "설명", "단위", "고르기", "범위")
INPUTS = ("입력", "선택") # 문서 입력 변수 갈래
_LAYERED = "골쌓기 기준" # 85-2 — 표 주문에 이 글이 있으면 켜쌓기율 대상 로직
_NUMBER = re.compile(r"(?<![\d-])\d+(?:-\d+)+(?![\d-])") # 품셈 절 번호(「12-1-3」)
@@ -31,16 +31,27 @@ def _num(value: Any) -> Any:
return value
def _logics(codes: list[str]) -> tuple[list[dict], list[str]]:
"""([로직 줄 …], 빠진 로직 키) — 키 차례 그대로."""
whole = m01.loaded()[1]
found, missing = [], []
for code in codes:
try:
found.append(whole.logic(code))
except combo_store.cm.mf.FormulaError:
missing.append(code)
return found, missing
def _docs(codes: list[str]) -> tuple[list[dict], list[str]]:
"""([수식 문서 …], 빠진 로직 키) — 키 차례 그대로."""
docs = m01doc.docs()
found = [docs[code] for code in codes if code in docs]
return found, [code for code in codes if code not in docs]
def specs(doc: dict) -> list[dict[str, Any]]:
"""문서 입력 변수 → 입력 칸 `{이름: 열쇠, 설명, 단위, 고르기?(선택 목록), 범위?}`(변수 차례)."""
out = []
for v in doc.get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") not in INPUTS or not v.get("열쇠"):
continue
one = {"이름": v["열쇠"], "설명": v.get("설명") or None, "단위": v.get("단위") or None}
if link.get("갈래") == "선택":
one["고르기"] = list(link.get("목록") or [])
if link.get("범위"):
one["범위"] = list(link["범위"])
out.append(one)
return out
def layered() -> set[str]:
@@ -65,50 +76,51 @@ def _labels(whole: Any, spec: dict) -> dict[str, str]:
return out
def sources(logic: dict) -> Any:
"""원문 출처(222-1) — 로직 `출처` + 호표 · 입력 · 중간 · 덧줄 `출처` 가운데 같은 책(번호 앞 글이
같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이 절마다 찾음 · M01
`make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로."""
main = str(logic.get("출처") or "")
def sources(doc: dict) -> Any:
"""원문 출처(222-1) — 문서 `출처` + 금액 수량 줄 · 변수 · 금액 식 줄(수량 없음) `출처`
가운데 같은 책(번호 앞 글이 같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이
절마다 찾음 · M01 `make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로."""
main = str(doc.get("출처") or "")
head = _NUMBER.search(main)
if not head:
return logic.get("출처")
return doc.get("출처")
book, seen = main[: head.start()], set(_NUMBER.findall(main))
money = [x for x in doc.get("금액") or [] if isinstance(x, dict)]
rows = [x for x in money if "수량" in x] + list(doc.get("변수") or [])
extra = []
for part in ("호표", "입력", "중간", "덧줄"):
for row in logic.get(part) or []:
src = str(row.get("출처") or "") if isinstance(row, dict) else ""
hit = _NUMBER.search(src)
if hit and src[: hit.start()] == book and hit.group() not in seen:
seen.add(hit.group())
extra.append(hit.group())
for row in rows + [x for x in money if "수량" not in x]:
src = str(row.get("출처") or "") if isinstance(row, dict) else ""
hit = _NUMBER.search(src)
if hit and src[: hit.start()] == book and hit.group() not in seen:
seen.add(hit.group())
extra.append(hit.group())
return " · ".join([main, *extra])
def _listed(logics: list[dict]) -> list[dict[str, Any]]:
"""로직 줄마다 `{로직, 이름, 결과단위, 출처, 켜쌓기, 입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`."""
def _listed(docs: list[dict]) -> list[dict[str, Any]]:
"""문서마다 `{로직, 이름, 결과단위, 출처, 켜쌓기,
입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`."""
from M02_MasterTemplete import M02_Doc_Copy as dc
whole = m01.loaded()[1]
layers = layered()
out = []
for logic in logics:
auto = m01.mau.values(whole, logic)
specs = []
for spec in logic.get("입력") or []:
one = {k: spec[k] for k in _SPEC if k in spec}
one.setdefault("설명", None)
one.setdefault("단위", None)
labels = _labels(whole, spec)
for doc in docs:
auto = dc.auto_of(doc, whole)
rows = []
for one in specs(doc):
labels = _labels(whole, one)
if labels:
one["고르기이름"] = labels
specs.append({**one, "자동값": auto.get(spec["이름"])})
rows.append({**one, "자동값": auto.get(one["이름"])})
out.append(
{
"로직": logic.get("키"),
"이름": logic.get("이름"),
"결과단위": logic.get("결과단위"),
"출처": sources(logic),
"켜쌓기": logic.get("키") in layers,
"입력": specs,
"로직": doc.get("키"),
"이름": doc.get("이름"),
"결과단위": doc.get("결과단위"),
"출처": sources(doc),
"켜쌓기": doc.get("키") in layers,
"입력": rows,
}
)
return out
@@ -116,5 +128,5 @@ def _listed(logics: list[dict]) -> list[dict[str, Any]]:
def logic_inputs(codes: list[str]) -> dict[str, Any]:
"""일위대가 입력 모달 — 로직 키들의 입력 목록 `{로직: [...], 빠진로직}`(키 차례 · 겹침 한 번)"""
found, missing = _logics(list(dict.fromkeys(c for c in codes if c)))
found, missing = _docs(list(dict.fromkeys(c for c in codes if c)))
return _num({"로직": _listed(found), "빠진로직": missing})
+17 -61
View File
@@ -398,7 +398,7 @@ def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]:
def summary(
folder: Path, kind: str, key: str, expand: Expand | None = None, files: UseFiles | None = None
folder: Path, kind: str, key: str, expand: Expand | None = None, files: list | None = None
) -> dict[str, Any]:
"""층 목록 한 줄에 붙일 것 — `{제목, 단위, 구분, 상세구분, 연결}`(51-12) · `expand` 면
1 단위 기준 계(`기준금액` · 51-4)."""
@@ -422,14 +422,16 @@ def summary(
top, (layer, owner) = doc.get("바탕") or {}, where(folder)
logic = top.get("로직")
out["바탕"] = logic or (top.get("참조") or {}).get("키")
if logic and expand is not None:
try:
out["바탕"] = f"{logic} {expand.whole.logic(logic).get('이름') or ''}".strip()
except Exception: # noqa: BLE001 — 없는 로직 = 키만(셈 때 까닭)
pass
if logic and expand is not None: # 이름 = M01 수식 문서(로직 줄 안 읽음 · 855 L2 ⓑ)
from M01_MasterData import M01_MasterData_Doc as m01doc
name = (m01doc.docs().get(str(logic)) or {}).get("이름") or ""
out["바탕"] = f"{logic} {name}".strip() # 없는 기초 = 키만(셈 때 까닭)
out["고친줄수"] = sum(len(doc.get(k) or ()) for k in ("덮개", "더한줄", "뺀줄"))
# SK 마다 모든 층 훑음(users) — 파일 읽기는 판 기억(`_ids_of`)이라 처음 한 번만 무거움
out["쓰는곳수"] = len(users({"층": layer, "주인": owner, "키": key}, files))
# SK 마다 모든 층 훑음 — 파일 읽기는 판 기억(`M02_Library_Uses.ids_of`)이라 처음 한 번만 무거움
from M02_MasterTemplete import M02_Library_Uses as uses
out["쓰는곳수"] = len(uses.users({"층": layer, "주인": owner, "키": key}, files))
return out
@@ -439,66 +441,20 @@ def summaries(folder: Path, rows: list[dict[str, Any]]) -> None:
from M02_MasterTemplete.M02_Labor_Expand import Expand
expand = Expand(m01.loaded()[1])
files = use_files() if any(row["종류"] == "sangeun" for row in rows) else None
from M02_MasterTemplete import M02_Library_Uses as uses
files = uses.files() if any(row["종류"] == "sangeun" for row in rows) else None
for row in rows:
if row["종류"] in layers.LIBRARY_KINDS:
row.update(summary(folder, row["종류"], row["이름"], expand, files))
# ── 쓰는 곳 · 지우기 ──────────────────────────────────────────────────
UseFiles = list[tuple[str, str, Path]]
def use_files() -> UseFiles:
"""쓰는 곳을 찾을 파일 — (무엇, 어디, 파일) · 목록 한 번에 한 번 찾음(818-1)."""
# 「일위대가」 = 사전조합 새 이름(내역 14 확정 1) · 구조물 조합 일위대가 = 「구조물 조합」
kinds = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출"))
return [(what, at, path) for kind, what in kinds for at, path in layers.layer_files(kind)]
def users(ref: Ref, files: UseFiles | None = None) -> list[str]:
"""`ref` 를 담은 일위대가 · 사전조합 · 단가산출(바탕 · 더한줄) — 「어디 이름」 목록(모든 층 훑음 ·
프로젝트 뺌)."""
rid, out = ref_id(ref), []
for what, at, path in use_files() if files is None else files:
got = _ids_of(path)
if got and rid in got[1]:
out.append(f"{what} {at} 「{got[0]}」")
return out
_IDS: dict[Path, tuple[tuple[int, int], tuple[str, frozenset[str]]]] = {}
def _ids_of(path: Path) -> tuple[str, frozenset[str]] | None:
"""파일 하나의 (이름, 참조 이름표들) — 판(고친 때 · 크기)이 같으면 기억한 것(818-1 · 로직 사본으로
SK 파일이 MB 단위라 목록 줄마다 모든 층을 다시 읽으면 분 단위)."""
try:
st = path.stat()
stamp = (st.st_mtime_ns, st.st_size)
if (hit := _IDS.get(path)) and hit[0] == stamp:
return hit[1]
doc = json.loads(path.read_bytes())
except (OSError, ValueError):
return None
name = (
(doc.get("일위대가번") or doc.get("이름") or path.stem)
if isinstance(doc, dict)
else path.stem
)
got = (str(name), frozenset(ref_id(one) for one in refs_in(doc)))
_IDS[path] = (stamp, got)
return got
def refuse_used(folder: Path, kind: str, key: str) -> None:
"""쓰는 곳이 있으면 409 + 이름(서고 종류만)."""
if kind not in PREFIX:
return
layer, owner = where(folder)
found = users({"층": layer, "주인": owner, "키": key})
if found:
raise _bad(f"쓰는 곳이 있어 못 지움 「{key}」 — " + " · ".join(found), 409)
"""쓰는 곳이 있으면 409 — 쓰는 곳 색인 한 벌(`M02_Library_Uses` · 858 5-5)."""
from M02_MasterTemplete import M02_Library_Uses as uses
uses.refuse_used(folder, kind, key)
# ── 층 사이 복사 ──────────────────────────────────────────────────────
+3 -1
View File
@@ -175,7 +175,9 @@ def own_materials(
return {"줄": []}
folder = _root(session, layer, owner)
rows = own.rows(folder)
used = own.usage(folder, [str(r.get("키")) for r in rows])
from M02_MasterTemplete import M02_Library_Uses as library_uses
used = library_uses.materials(folder, [str(r.get("키")) for r in rows])
return {"줄": [{**r, "쓰는곳": used[str(r.get("키"))]} for r in rows]}
+5 -45
View File
@@ -6,9 +6,9 @@
요약 서고 줄 `M02_Labor_Ref.summary`(쓰는곳수 뺌) — 자국 · 바탕 · 기댐이 모두 같을 때만 씀
바탕 셈 코드 내용 · M01 폴더 · 층 곁 파일(내 기계 등 — 항목 폴더 · manifest 뺌) 자국 지문
기댐 셈 때 읽은 참조 파일(SC · SK) 자국(`refs.SEEN`)
쓰는곳수 = 요청마다 쓰는 곳 파일을 한 번 훑어 거꾸로 셈(`refs._ids_of` 기억 · 파일당 stat 한 번).
쓰는곳수 = 요청마다 쓰는 곳 색인을 한 번 훑어 거꾸로 셈(`M02_Library_Uses.counts` · 파일당 stat 한 번).
자리 = 프로세스 메모리 + storage `_derived/m02_layer_index/`(파생 저장본 · 층마다 한 파일 ·
참조 이름표 기억 `ids.json`) — 없거나 깨지면 다시 지음 · 지워도 됨 · 다른 PC · 옛 코드는 안 읽음.
참조 이름표 기억 `ids.json` 은 `M02_Library_Uses` 몫) — 없거나 깨지면 다시 지음 · 지워도 됨.
"""
from __future__ import annotations
@@ -28,11 +28,9 @@ from M02_MasterTemplete import M02_Template_Layers as layers
KIND = "m02_layer_index"
SHAPE = 1 # 기록 꼴이 바뀌면 올림(옛 기록 = 다시 셈)
IDS = "ids"
CODE_DIRS = ("M02_MasterTemplete", "M01_MasterData", "resources/master_data/scripts", "common_util")
_LOCK = threading.RLock()
_MEM: dict[str, dict[str, Any]] = {} # 층 열쇠 → {항목: 기록}
_IDS_LOADED: list[bool] = []
@lru_cache(maxsize=1)
@@ -175,47 +173,9 @@ def summaries(folder: str | Path, rows: list[dict[str, Any]]) -> None:
_save(key, recs)
sk = [row for row in lib if row["종류"] == "sangeun" and "고친줄수" in row]
if sk:
uses, (layer, owner) = _uses(), refs.where(folder)
from M02_MasterTemplete import M02_Library_Uses as library_uses
uses, (layer, owner) = library_uses.counts(), refs.where(folder)
for row in sk:
rid = refs.ref_id({"층": layer, "주인": owner, "키": row["이름"]})
row["쓰는곳수"] = uses.get(rid, 0)
# ── 쓰는 곳 수 ────────────────────────────────────────────────────────
def _uses() -> dict[str, int]:
"""참조 이름표 → 담은 파일 수(`refs.users` 개수와 같음) — 쓰는 곳 파일 한 번 훑음."""
_load_ids()
before = {path: hit[0] for path, hit in refs._IDS.items()}
files = [path for _what, _at, path in refs.use_files()]
count: dict[str, int] = {}
for path in files:
got = refs._ids_of(path)
for rid in got[1] if got else ():
count[rid] = count.get(rid, 0) + 1
if any(before.get(path) != refs._IDS[path][0] for path in files if path in refs._IDS):
_save_ids()
return count
def _load_ids() -> None:
"""참조 이름표 기억을 파생 저장본에서 채움 — 프로세스에 한 번 · 자국은 `_ids_of` 가 다시 봄."""
if _IDS_LOADED:
return
_IDS_LOADED.append(True)
got = read_derived(layers.storage_root(), KIND, IDS)
for text, one in ((got or {}).get("value") or {}).items():
try:
mtime, size, name, ids = one
refs._IDS.setdefault(Path(text), ((int(mtime), int(size)), (str(name), frozenset(ids))))
except (TypeError, ValueError):
continue
def _save_ids() -> None:
"""지금 기억을 디스크 것에 덧씀(다른 서버 몫 유지) · 없어진 파일 뺌."""
got = read_derived(layers.storage_root(), KIND, IDS)
value = dict((got or {}).get("value") or {})
for path, ((mtime, size), (name, ids)) in list(refs._IDS.items()):
value[str(path)] = [mtime, size, name, sorted(ids)]
value = {text: one for text, one in value.items() if Path(text).is_file()}
_save(IDS, value)
+35 -34
View File
@@ -25,12 +25,11 @@ from typing import Any
from common_util.common_util_json import atomic_write_json
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Layer_Access as access
from M02_MasterTemplete import M02_Library_Uses as uses
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MasterTemplete_Tree as tree
from M02_MasterTemplete import M02_Template_Layers as layers
GONE = "_합친것"
USER_KINDS = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출"))
_ADD = re.compile(r"^add:#(\d+)(.*)$")
_PATCH = ("덮개", "고름", "자재표시")
@@ -66,42 +65,44 @@ def _columns(folder: Path, memo: dict[Path, dict[str, str]]) -> dict[str, str]:
def users(session: dict[str, Any] | None, kind: str, gone: list[str]) -> list[dict[str, Any]]:
"""지금 층(`store.at`) 지울 문서를 쓰는 줄 — 모든 층(프로젝트 뺌 · 지우는 것끼리 뺌)."""
"""지금 층(`store.at`) 지울 문서를 쓰는 줄 — 모든 층(프로젝트 뺌 · 지우는 것끼리 뺌) ·
쓰는 파일 = 쓰는 곳 색인(`M02_Library_Uses.index`)에 걸린 것만 열어 줄 자리를 셈."""
mine = refs.here()
rids = {refs.ref_id({"층": mine[0], "주인": mine[1], "키": k}): k for k in gone}
skip = {(store.root() / kind / f"{k}.json").resolve() for k in gone}
found = uses.index()
hit_files = {path for rid in rids for path, _k, _l in found.get(rid, [])}
rows, memo = [], {}
for ukind, what in USER_KINDS:
for where, path in layers.layer_files(ukind):
if path.resolve() in skip:
continue
try:
doc = json.loads(path.read_bytes())
except (OSError, ValueError):
continue
hits = _hits(doc, rids) if isinstance(doc, dict) else []
if not hits:
continue
at = refs.where(path.parent.parent)
ok = can_write(session, at)
name = doc.get("일위대가번") or doc.get("이름") or path.stem
if ukind == "labor" and (title := _columns(path.parent.parent, memo).get(path.stem)):
name = f"{title} · {name}"
for line, key in hits:
rows.append(
{
"층": at[0],
"주인": at[1],
"어디": where,
"종류": what,
"문서종류": ukind,
"문서": path.stem,
"이름": name,
"키": key,
"줄": line,
"쓰기": ok,
}
)
for ukind, what, where, path in uses.files():
if path not in hit_files or path.resolve() in skip:
continue
try:
doc = json.loads(path.read_bytes())
except (OSError, ValueError):
continue
hits = _hits(doc, rids) if isinstance(doc, dict) else []
if not hits:
continue
at = refs.where(path.parent.parent)
ok = can_write(session, at)
name = doc.get("일위대가번") or doc.get("이름") or path.stem
if ukind == "labor" and (title := _columns(path.parent.parent, memo).get(path.stem)):
name = f"{title} · {name}"
for line, key in hits:
rows.append(
{
"층": at[0],
"주인": at[1],
"어디": where,
"종류": what,
"문서종류": ukind,
"문서": path.stem,
"이름": name,
"키": key,
"줄": line,
"쓰기": ok,
}
)
return rows
+1 -1
View File
@@ -569,7 +569,7 @@ def reset(kind: str, doc: dict) -> tuple[dict, int]:
return imported.reset(doc)
if kind == "sangeun":
adds, n = _reset_adds(doc.get("더한줄") or [])
n += const.covers_n(doc) # 790-2 상수 · 표값 덮개도 걷음(까닭 같이)
n += const.covers_n(doc) # 덮개 · 뺀줄(까닭 같이)
items = formula_edits(doc)
out = {**const.restore(doc), "더한줄": adds}
if items:
+3 -19
View File
@@ -36,16 +36,15 @@ from M02_MasterTemplete import M02_Layer_Access as access
from M02_MasterTemplete import M02_Library_Delete as deleting
from M02_MasterTemplete import M02_Library_Flat as flat
from M02_MasterTemplete import M02_Library_Same as same
from M02_MasterTemplete import M02_Library_Uses as uses
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Precombo_Folders as pre_folders
from M02_MasterTemplete import M02_Template_Layers as layers
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _root
router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete Library Same"])
Kind = Literal["precombo", "sangeun"]
GONE = deleting.GONE
USER_KINDS = deleting.USER_KINDS
_ORDER = {"system": 0, "company": 1, "personal": 2}
@@ -89,21 +88,6 @@ def _docs(at: refs.Here, kind: str) -> list[tuple[str, dict[str, Any]]]:
# ── 쓰는 곳 ───────────────────────────────────────────────────────────
def _user_index() -> dict[str, list[tuple[Path, str, str]]]:
"""모든 층(프로젝트 뺌) 훑기 한 번 — {ref_id: [(파일, 종류, 「어디 이름」)]}."""
out: dict[str, list[tuple[Path, str, str]]] = {}
for kind, what in USER_KINDS:
for where, path in layers.layer_files(kind):
try:
doc = json.loads(path.read_bytes())
except (OSError, ValueError):
continue
name = doc.get("일위대가번") or doc.get("이름") or path.stem
for rid in {refs.ref_id(one) for one in refs.refs_in(doc)}:
out.setdefault(rid, []).append((path, kind, f"{what} {where} 「{name}」"))
return out
def _can_write(session: Session, at: refs.Here) -> bool:
return access.can_write(session, at)
@@ -177,7 +161,7 @@ def _gone_rows(folder: Path, kind: str) -> list[dict[str, Any]]:
def find(folder: Path, kind: str) -> dict[str, Any]:
"""이 층 + 위 층 같은 지문 묶음 — 이 층 문서가 든 묶음 · 둘 이상만."""
mine = refs.where(folder)
index = _user_index()
index = uses.index()
groups: dict[str, list[tuple[refs.Here, str, dict[str, Any]]]] = {}
marks = same.Same() # 한 요청 안 참조 지문 메모
for at in [mine, *same.above(mine)]:
@@ -235,7 +219,7 @@ def _merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[s
rids = {refs.ref_id(_ref(mine, k)): k for k in gone}
by_file: dict[Path, tuple[str, set[str]]] = {}
labels: dict[Path, str] = {}
index = _user_index()
index = uses.index()
for rid in rids:
for path, ukind, label in index.get(rid, []):
by_file.setdefault(path, (ukind, set()))[1].add(rid)
+185
View File
@@ -0,0 +1,185 @@
"""M02 서고 쓰는 곳 색인 한 벌(858 5-5 · 설계 `설계_858_서고한벌.md` 부품 ⑦) — 「이 문서를 누가 쓰나」.
참조 찾기(단가산출 · 일위대가 · 구조물 조합 · 사본 블록 안 산근 — `M02_Labor_Ref.refs_in`):
쓰는 파일 = 모든 층(마스터 · 회사 · 개인 · 프로젝트 뺌) `labor` · `precombo` · `sangeun` 파일(`files`) ·
파일마다 (이름, 참조 이름표들) 을 판(고친 때 · 크기)으로 기억(`ids_of` · 818-1) — 같은 판이면 안 엶 ·
기억은 파생 저장본 `_derived/m02_layer_index/ids.json` 에도 둠(서버를 다시 띄워도 처음부터 안 읽음 ·
지워도 다시 셈) · `users` = 「무엇 어디 「이름」」 목록 · `index` = {이름표: [(파일, 종류, 글)]} ·
`counts` = {이름표: 파일 수}(목록 쓰는곳수) · `refuse_used` = 쓰는 곳 있으면 409.
자원 키 찾기(층 안):
`machines` = 내 기계 키 → 이 층 단가산출(사본 · 수식 사본 단가 줄에 그 키) ·
`materials` = 내 재료 키 → 이 층 모든 문서(글에 그 키 · `_` `.` 폴더 · 내 재료 파일 뺌).
지우기 · 합치기는 `store.batch` 한 잠금 안에서 이 색인을 씀(`M02_Library_Delete` · `M02_Library_Same_Router`).
"""
from __future__ import annotations
import json
from pathlib import Path
from typing import Any
from common_util.common_util_derived_store import derived_dir, read_derived
from common_util.common_util_json import atomic_write_json
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
#: 쓰는 쪽 종류 — 「일위대가」 = 사전조합 새 이름(내역 14 확정 1) · 구조물 조합 일위대가 = 「구조물 조합」
KINDS = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출"))
DERIVED, IDS = "m02_layer_index", "ids" # 파생 저장본 자리(826-1 층 목록 색인과 같은 폴더)
UseFiles = list[tuple[str, str, str, Path]] # (종류, 무엇, 어디, 파일)
Ids = tuple[str, frozenset[str]]
_IDS: dict[Path, tuple[tuple[int, int], Ids]] = {}
_LOADED: list[bool] = []
# ── 참조 ──────────────────────────────────────────────────────────────
def files() -> UseFiles:
"""쓰는 곳을 찾을 파일 — 종류 차례 · 층 차례(마스터 → 회사 → 개인)."""
return [(kind, what, at, path) for kind, what in KINDS for at, path in layers.layer_files(kind)]
def ids_of(path: Path) -> Ids | None:
"""파일 하나의 (이름, 참조 이름표들) — 판이 같으면 기억한 것(로직 사본으로 SK 파일이 커서)."""
_load()
try:
st = path.stat()
stamp = (st.st_mtime_ns, st.st_size)
if (hit := _IDS.get(path)) and hit[0] == stamp:
return hit[1]
doc = json.loads(path.read_bytes())
except (OSError, ValueError):
return None
name = (
(doc.get("일위대가번") or doc.get("이름") or path.stem) if isinstance(doc, dict) else None
)
got = (str(name or path.stem), frozenset(refs.ref_id(one) for one in refs.refs_in(doc)))
_IDS[path] = (stamp, got)
return got
def _scan(found: UseFiles | None) -> list[tuple[str, str, str, Path, Ids]]:
"""쓰는 파일마다 (종류, 무엇, 어디, 파일, 이름표) — 기억이 바뀌었으면 파생 저장본에 덧씀."""
found = files() if found is None else found
_load()
before = {path: hit[0] for path, hit in _IDS.items()}
out = [(*one, got) for one in found if (got := ids_of(one[3]))]
if any(before.get(one[3]) != _IDS[one[3]][0] for one in found if one[3] in _IDS):
_save()
return out
def users(ref: refs.Ref, found: UseFiles | None = None) -> list[str]:
"""`ref` 를 담은 구조물 조합 · 일위대가 · 단가산출 — 「무엇 어디 「이름」」(프로젝트 뺌)."""
rid = refs.ref_id(ref)
return [f"{what} {at} 「{ids[0]}」" for _k, what, at, _p, ids in _scan(found) if rid in ids[1]]
def index(found: UseFiles | None = None) -> dict[str, list[tuple[Path, str, str]]]:
"""한 번 훑어 {이름표: [(파일, 종류, 「무엇 어디 「이름」」)]}."""
out: dict[str, list[tuple[Path, str, str]]] = {}
for kind, what, at, path, (name, rids) in _scan(found):
for rid in rids:
out.setdefault(rid, []).append((path, kind, f"{what} {at} 「{name}」"))
return out
def counts(found: UseFiles | None = None) -> dict[str, int]:
"""{이름표: 담은 파일 수} — `users` 개수와 같음."""
return {rid: len(hits) for rid, hits in index(found).items()}
def refuse_used(folder: Path, kind: str, key: str) -> None:
"""쓰는 곳이 있으면 409 + 이름(서고 종류만)."""
if kind not in refs.PREFIX:
return
layer, owner = refs.where(folder)
if found := users({"층": layer, "주인": owner, "키": key}):
raise store.StoreError(409, f"쓰는 곳이 있어 못 지움 「{key}」 — " + " · ".join(found))
def _load() -> None:
"""기억을 파생 저장본에서 채움 — 프로세스에 한 번 · 판은 `ids_of` 가 다시 봄."""
if _LOADED:
return
_LOADED.append(True)
got = read_derived(layers.storage_root(), DERIVED, IDS)
for text, one in ((got or {}).get("value") or {}).items():
try:
mtime, size, name, ids = one
_IDS.setdefault(Path(text), ((int(mtime), int(size)), (str(name), frozenset(ids))))
except (TypeError, ValueError):
continue
def _save() -> None:
"""지금 기억을 디스크 것에 덧씀(다른 서버 몫 유지) · 없어진 파일 뺌 · 못 써도 다음에 다시 셈."""
got = read_derived(layers.storage_root(), DERIVED, IDS)
value = dict((got or {}).get("value") or {})
for path, ((mtime, size), (name, ids)) in list(_IDS.items()):
value[str(path)] = [mtime, size, name, sorted(ids)]
value = {text: one for text, one in value.items() if Path(text).is_file()}
try:
path = derived_dir(layers.storage_root(), DERIVED) / f"{IDS}.json"
atomic_write_json(path, {"key": IDS, "value": value})
except OSError:
pass
# ── 자원 키(층 안) ─────────────────────────────────────────────────────
def machines(folder: Path | None = None) -> dict[str, list[dict[str, Any]]]:
"""{내 기계 키: [{키, 이름}]} — 이 층 단가산출 가운데 사본(옛 칸 · 수식) 단가 줄에 그 키를 가진 것."""
from M02_MasterTemplete import M02_MyMachine as mym
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
out: dict[str, list[dict[str, Any]]] = {}
for path in sorted(Path(folder or store.root()).joinpath(sd.KIND).glob("SK-*.json")):
raw = path.read_bytes()
if mym.PREFIX.encode() not in raw:
continue
try:
doc = json.loads(raw)
except ValueError:
continue
keys = { # 옛 칸 사본 · 수식 길 사본(827-1) — 한 SK 한 번
str(row["키"])
for part in (skc.KEY, "수식")
for row in (doc.get(part) or {}).get("단가") or []
if mym.mine(row.get("키"))
}
for key in sorted(keys):
out.setdefault(key, []).append({"키": doc.get("키"), "이름": doc.get("이름")})
return out
def materials(folder: str | Path, keys: list[str]) -> dict[str, list[dict[str, Any]]]:
"""{내 재료 키: [{종류, 키, 이름}]} — 그 층 문서 글에 키가 든 것(파일은 한 번씩 읽음)."""
from M02_MasterTemplete import M02_Material_Own as own
folder = Path(folder)
out: dict[str, list[dict[str, Any]]] = {k: [] for k in keys}
for path in sorted(folder.rglob("*.json")): # 종류 폴더 · 그 밑 폴더 — 내 목록 파일 뺌
if path.name == own.FILE or _aside(path, folder):
continue
try:
text = path.read_text(encoding="utf-8")
except OSError:
continue
if not (hit := [k for k in keys if k in text]):
continue
try:
doc = json.loads(text)
except ValueError:
continue
name = (doc.get("이름") if isinstance(doc, dict) else None) or path.stem
for k in hit:
out[k].append({"종류": path.parent.name, "키": path.stem, "이름": name})
return out
def _aside(path: Path, folder: Path) -> bool:
"""밑줄 · 점 폴더(「_합친것」 등 파생 · 보관) — 쓰는 곳 아님."""
return any(x.startswith(("_", ".")) for x in path.relative_to(folder).parts[:-1])
-115
View File
@@ -1,115 +0,0 @@
"""M02 기준 목록 · 계산서 끝수(PLAN 704-2 딸림) — B09 산근 끝수 규칙으로 셈(③ 서버 단독 ·
`B09_Estimation_Sangeun` 과 규칙 짝 · 거울 시험 `test_704_settle`).
줄 금액 = ROUNDDOWN(단가 × 수량, 1) 비목마다 · 비목 총계 = ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합 ·
작업량 Q(중간 이름 Q · Q1 …) = ROUND(식, 2) 뒤 쓰임 · % 덧줄 밑수 = 그때까지 줄 합(줄 끝수 뒤).
근거 = 지식DB `technical_info/01_임도/05_원가정보/단수처리_규칙.md`(행 금액 절사 · 관측 후보 규칙).
M01 엔진(`master_formula.run`)의 구조 그대로 — 끝수 자리만 다름(엔진은 줄 끝수 없이 계에서 한 번).
하위 로직(기계경비 포함)은 같은 규칙으로 다시 셈 · 흐름 · 결과 로직은 엔진 값 그대로.
"""
from __future__ import annotations
import re
from decimal import ROUND_DOWN, ROUND_HALF_UP, Decimal
from typing import Any
from M01_MasterData import M01_MasterData_Store as m01
mf = m01.cm.mf
_Q = re.compile(r"Q\d*")
def _down(value: Any, places: int) -> Any:
return None if value is None else mf._round(Decimal(value), places, ROUND_DOWN)
def _bundle(whole: Any, item: dict, env: dict, depth: int) -> dict:
"""로직 호표 줄이 부르는 하위 로직 — 같은 규칙으로 다시 셈(엔진 `logic` 마디 그대로)."""
node = mf.parse(item["요소"])
if node[0] != "logic":
return mf.evaluate(node, env, whole, depth)
given = {k: mf.evaluate(v, env, whole, depth) for k, v in node[2]}
got = settle(whole, mf.fill(node[1], env), given, depth + 1)
return got["결과"] if "결과" in got else {k: got[k] for k in mf.BUNDLE}
def settle(whole: Any, ref: str, given: dict, depth: int = 0) -> dict:
"""`master_formula.run` 과 같은 꼴 `{줄, 노무비, 재료비, 경비, 계, 중간}` — 끝수만 B09 규칙."""
row = whole.logic(ref)
if isinstance(row.get("흐름"), dict) or "결과" in row:
return mf.run(whole, ref, given, depth)
env = mf._inputs(row, given)
for step in row.get("중간", []):
try:
value = mf.evaluate(mf.parse(step["식"]), env, whole, depth)
except mf.EmptyInput as e:
env[step["이름"]] = mf.Blank(str(e))
continue
if _Q.fullmatch(step["이름"]) and isinstance(value, Decimal):
value = value.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
env[step["이름"]] = value
lines: list[dict] = []
for n, item in enumerate(row.get("호표", [])):
try:
qty = mf.evaluate(mf.parse(item["수량"]), env, whole, depth)
if item["종류"] == "로직":
bundle = _bundle(whole, item, env, depth)
price = bundle["계"]
split = (
{k: qty * bundle[k] for k in mf.COST_ITEMS}
if "비목" not in item
else {item["비목"]: qty * price}
)
else:
ref_ = (
{
k: mf.fill(v, env) if isinstance(v, str) else v
for k, v in item["요소"].items()
}
if isinstance(item["요소"], dict)
else mf.fill(item["요소"], env)
)
if isinstance(ref_, str) and qty != 0:
whole.get(ref_)
price = mf.mp.priced(whole, item, ref_, env, n if depth == 0 else None)[0]
if price is None and qty == 0:
price = Decimal(0)
split = {item["비목"]: None if price is None else qty * price}
except mf.EmptyInput as e:
lines.append(mf._blank_line(item, str(e)))
continue
lines.append(_line(item["이름"], split))
sums = {k: sum((x["비목"].get(k) or 0 for x in lines), Decimal(0)) for k in mf.COST_ITEMS}
env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None}
for extra in row.get("덧줄", []):
env.update(sums)
try:
value = mf.evaluate(mf.parse(extra["식"]), env, whole, depth)
env[extra["이름"]] = value
except mf.FormulaError:
value = None
sums[extra["비목"]] += _down(value, 1) or 0
lines.append(_line(extra["이름"], {extra["비목"]: value}))
if value is not None:
env["줄"][extra["이름"]] = lines[-1]["금액"]
sums = {k: mf.cut(row, _down(v, 0), "계") for k, v in sums.items()}
return {"줄": lines, **sums, "계": sum(sums.values()), "중간": mf._shown(env)}
def _line(name: str, split: dict) -> dict:
cut = {k: _down(v, 1) for k, v in split.items()}
whole_sum = None if all(v is None for v in cut.values()) else sum(v or 0 for v in cut.values())
return {"이름": name, "비목": cut, "금액": whole_sum}
def apply(groups: list[dict], engine: dict, done: dict) -> None:
"""계산서 묶음의 줄 금액 · 소계를 `settle` 값으로 바꿈 — 줄 차례는 엔진과 같음."""
seq: dict[str, list] = {k: [] for k in mf.COST_ITEMS}
for eng, mine in zip(engine["줄"], done["줄"]):
for part, _ in m01.mtx._shares(eng):
seq[part].append(mine["비목"].get(part))
for group in groups:
for line, amount in zip(group["줄"], seq.get(group["비목"], [])):
line["금액"] = amount
group["소계"] = done[group["비목"]]
+23 -32
View File
@@ -8,13 +8,12 @@
바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌).
금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) ·
계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판).
(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.)
목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본
(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` ·
같으면 안 셈 ·
셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸).
실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음.
이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫).
이름표(이름 · 구분 · 출처 · 별칭) · 기초 차례(장 차례) = 수식 문서(`M01_MasterData_Doc` · 855 L2 ⓑ).
M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인).
"""
@@ -196,8 +195,8 @@ def _spec(given: dict, ax: list) -> str:
return " · ".join(parts)
def _unit(logic: dict) -> str:
unit = str(logic.get("결과단위") or "")
def _unit(doc: dict) -> str:
unit = str(doc.get("결과단위") or "")
return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit)
@@ -223,24 +222,21 @@ def _money(doc: dict, links: Any, given: dict) -> Decimal | None:
return got.get("계") if got.get("계") is not None else got.get("결과")
def _rows_of(whole: Any, logic: dict, blocked: bool, links: Any = None) -> list[dict]:
doc = m01_doc.docs().get(str(logic.get("키")))
if doc is None:
return []
def _rows_of(whole: Any, doc: dict, blocked: bool, links: Any = None) -> list[dict]:
links = links or _links(whole)
base, ax = axes(whole, doc)
changes: list[dict] = [{}]
for name, reps in ax:
changes += [{name: v} for v, _ in reps if v != base.get(name)]
head = {
"키": logic.get("키"),
"이름": logic.get("이름") or "",
"단위": _unit(logic),
"출처": logic.get("출처") or "",
"공종": kind_of(logic),
"별칭": ", ".join(x for x in [logic.get("별칭") or "", *words_of(logic)] if x),
"구분": logic.get("구분") or "",
"상세구분": logic.get("상세구분") or "",
"키": doc.get("키"),
"이름": doc.get("이름") or "",
"단위": _unit(doc),
"출처": doc.get("출처") or "",
"공종": kind_of(doc),
"별칭": ", ".join(x for x in [doc.get("별칭") or "", *words_of(doc)] if x),
"구분": doc.get("구분") or "",
"상세구분": doc.get("상세구분") or "",
"막힘": blocked,
}
out = []
@@ -283,12 +279,12 @@ def _stamp() -> str:
def _chunk(keys: list[str], blocked: set[str]) -> list[dict]:
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음)."""
whole = m01.loaded()[1]
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터 · 수식 문서는 그 프로세스가 읽음)."""
whole, docs = m01.loaded()[1], m01_doc.docs()
links = _links(whole)
out = []
for key in keys:
out += _rows_of(whole, whole.logic(key), key in blocked, links)
out += _rows_of(whole, docs[key], key in blocked, links)
return out
@@ -296,11 +292,8 @@ def build(files: dict, workers: int = 1) -> dict:
"""기준 목록 통째 — 장 차례 · `workers` > 1 이면 로직을 나눠 프로세스 여럿이 셈(차례 그대로)."""
why_of = m01.blocks()
blocked = {k for k, why in why_of.items() if why}
keys = [
str(logic.get("키"))
for _, data in sorted(m01._logic_files(files), key=lambda f: m01.chapter_order(f[1]))
for logic in data.get("줄") or []
]
chapters = sorted(m01_doc.logic_files().values(), key=m01.chapter_order)
keys = [str(doc.get("키")) for data in chapters for doc in data.get("줄") or []]
size = max(1, len(keys) // (workers * 8))
parts = [keys[i : i + size] for i in range(0, len(keys), size)]
if workers > 1:
@@ -379,13 +372,11 @@ def _given(whole: Any, doc: dict, change: dict) -> tuple[dict, list]:
def sheet(key: str, change: dict) -> dict:
"""계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(문서 셈)."""
files, whole = m01.loaded()
doc = m01_doc.docs().get(key)
try:
logic = whole.logic(key)
m01_doc.head(key) # 없는 · 로직 아닌 키 = 옛 `Master.logic` 과 같은 까닭 글
except m01.cm.mf.FormulaError as e:
raise m01.StoreError(404, str(e)) from e
if doc is None:
raise m01.StoreError(404, f"수식 문서 없음 「{key}」")
doc = m01_doc.docs()[key]
given, ax = _given(whole, doc, change)
links = _links(whole)
got = _calc(doc, links, given) or {}
@@ -393,14 +384,14 @@ def sheet(key: str, change: dict) -> dict:
return labor_inputs._num(
{
"키": key,
"이름": logic.get("이름") or "",
"이름": doc.get("이름") or "",
"규격": _spec(given, ax),
"단위": _unit(logic),
"출처": labor_inputs.sources(logic) or "",
"단위": _unit(doc),
"출처": labor_inputs.sources(doc) or "",
"판": edition(files),
"입력": given,
"묶음": mdt.sheet_groups(doc, got, links) if got and money else [],
"계": got.get("계") if money else got.get("결과"),
"기준단위": _unit(logic) or None,
"기준단위": _unit(doc) or None,
}
)
@@ -333,6 +333,7 @@ export function createItemCards(opts: ItemCardsOptions): ItemCardsHandle {
? {
calc: (doc, 수량) => via.calc(at, doc, 수량),
readArea: () => src.read("area", at),
...(via.sk ? { skCopy: via.sk } : {}), // 856-3 사본 단가산출 줄 = 보기만
}
: {}),
onChanged: (dirty) => laborCard.saver.mark(dirty && laborWritable()),
@@ -12,7 +12,7 @@ import {
type Layer,
} from "./M02_MasterTemplete_Api_Fetch";
import type { LaborDoc } from "./M02_MasterTemplete_Labor_Api";
import type { LaborCalc } from "./M02_MasterTemplete_Labor_Calc";
import type { LaborCalc, LaborRef } from "./M02_MasterTemplete_Labor_Calc";
/** 집계표 열 하나에 딸린 문서 — 구조물 도면 · 면적산출 */
export type ItemPart = "structure" | "area";
@@ -34,6 +34,8 @@ export interface ItemSource {
doc: LaborDoc,
수량?: Record<string, number>,
) => Promise<LaborCalc & { 알약: unknown[] }>;
/** 프로젝트 사본(856-3) — 단가산출 줄의 굳힌 SK 문서(`참조사본`) · 줄 누름 = 줄 쌓기 보기만 */
sk?: (ref: LaborRef) => Promise<Record<string, unknown> | null>;
};
}
@@ -12,6 +12,7 @@
import type { DataColumn } from "@ui/ui_template_data_table";
import type { Layer } from "./M02_MasterTemplete_Api_Fetch";
import type { LaborCalc, LaborDoc } from "./M02_MasterTemplete_Labor_Api";
import type { LaborRef } from "./M02_MasterTemplete_Labor_Calc";
import { mountLaborTable } from "./M02_MasterTemplete_Labor_Table";
export interface LaborDetailOptions {
@@ -32,6 +33,8 @@ export interface LaborDetailOptions {
/** 셈 · 면적 자리 주입(142-1 · 고르기 모달 = 프로젝트 복사본) — 없으면 층 길 */
calc?: (doc: LaborDoc, 수량?: Record<string, number>) => Promise<LaborCalc & { 알약: unknown[] }>;
readArea?: () => Promise<{ 문서: unknown; 판?: string | null }>;
/** 프로젝트 사본(856-3) — 단가산출 줄의 굳힌 SK 문서 · 있으면 그 줄 누름 = 줄 쌓기 보기만 */
skCopy?: (ref: LaborRef) => Promise<Record<string, unknown> | null>;
}
/** 덧칸 — `cell(n, 열)` = 문서 줄 n 의 값 · `onRow(n)` 참 = 기본 줄 모달 안 엶 */
@@ -2,34 +2,19 @@
* M02_MasterTemplete_Labor_LogicMats.ts
* 자재목록 표의 로직 자재 줄(103-1) — 담은 로직 맨 위 층 재료 줄(서버 calc `줄[].재료`) · 사용자 자재 줄과 같은 칸
* (코드 · 이름 · 규격 · 수량 · 단위 · 가격 다섯 · 단가 / 금액) · 사용자 자재 앞.
* · 삭제 없음 · [바꾸기] = M01 자재품목 표에서 고름(문서 `담은로직[].고름` · 엔진 `choosing`) · 바꾼 줄만 [기본](고름 풂)
* · 금액은 로직 단가 안이라 합에 다시 안 더함(보기만) · 수량은 로직 것(누름 · 알약 없음)
* · 하위 로직 안 재료는 안 보임(엔진이 맨 위 층만 고름)
* · 줄 누름(148-1) = 그 로직 줄 [옵션] 모달(읽기만이면 보기) · [바꾸기] · [기본]은 고칠 때만
* · 보기만(856-3 — 로직 줄 창 · [바꾸기] · [기본] · 세 칸 고침 걷음 · 일위대가 면적 보기 `Labor_View` 가 씀)
* · 금액은 로직 단가 안이라 합에 다시 안 더함 · 수량은 로직 것 · 하위 로직 안 재료는 안 보임(엔진이 맨 위 층만 고름)
* ========================================================================== */
import { createButton, el } from "@ui/ui_template_elements";
import { el } from "@ui/ui_template_elements";
import { formatMoney } from "../common_util/common_util_money";
import { openPickTable } from "../M01_MasterData/M01_MasterData_UI_Logic_PickTable";
import { headWord } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Modal";
import type { LaborCalc, LaborRow, MatMarkKey } from "./M02_MasterTemplete_Labor_Api";
import type { LaborCalc, LaborRow } from "./M02_MasterTemplete_Labor_Api";
import { lineId } from "./M02_MasterTemplete_Labor_Calc";
import { markCells } from "./M02_MasterTemplete_Labor_MatMarks";
import { moneyCell, PRICE_SLOTS } from "./M02_MasterTemplete_Labor_Rows";
import { tc } from "./M02_MasterTemplete_Labor_Text";
import type { LogicMat } from "./M02_Labor_LogicMats_Model";
export interface LogicMatHandlers {
/** 줄 누름(148-1) = 그 자재를 낸 로직 줄 [옵션] 모달 — `row` = 담은 로직 차례 */
open: (row: number) => void;
/** [바꾸기]로 고른 품목 키 — `row` = 담은 로직 차례 · `at` = 호표 차례 · 없으면(읽기만) 단추 칸 없음 */
swap?: (row: number, at: number, key: string) => void;
/** [기본] — 그 줄 고름 풂 */
reset?: (row: number, at: number) => void;
/** 세 칸(148-4) — 로직 줄 `자재표시` · 없으면 글만 */
mark?: (row: number, at: number, key: MatMarkKey, v: string) => void;
}
const num = (v: number | null): string =>
v === null
? "—"
@@ -40,21 +25,14 @@ export function logicMatRows(
rows: LaborRow[],
calc: LaborCalc | null,
wait: boolean,
on?: LogicMatHandlers,
): HTMLElement[] {
return rows.flatMap((row, r) => {
return rows.flatMap((row) => {
const line = row.참조 ? undefined : calc?.줄.find((l) => lineId(l) === lineId(row));
return (line?.재료 ?? []).map((mat) => matRow(row, r, mat, wait, on));
return (line?.재료 ?? []).map((mat) => matRow(row, mat, wait));
});
}
function matRow(
row: LaborRow,
r: number,
mat: LogicMat,
wait: boolean,
on?: LogicMatHandlers,
): HTMLElement {
function matRow(row: LaborRow, mat: LogicMat, wait: boolean): HTMLElement {
const item = mat.품목;
const name = item?.이름 ?? mat.이름;
const owner = `${row.별칭 ?? row.로직} · ${mat.이름}`;
@@ -69,51 +47,8 @@ function matRow(
};
const money = moneyCell(mat.단가, mat.금액, wait, tc("Labor_AppliedSum"));
money.title = tc("LogicMat_Inside");
const swap = on?.swap;
const reset = on?.reset;
const tools = swap
? [
el("td", {
className: "m02-labrow__move",
children: [
el("div", {
className: "ui-btn-group",
children: [
createButton({
label: tc("LogicMat_Swap"),
variant: "ghost",
onClick: (e) => {
e.stopPropagation();
openPickTable({
kind: "재료",
title: `${tc("LogicMat_PickTitle")} · ${mat.이름}`,
seed: headWord(name),
alt: [headWord(mat.이름)],
isCurrent: (x) => String(x["키"]) === item?.키,
onPick: (x) => swap(r, mat.차례, String(x["키"])),
});
},
}),
...(mat.고름 && reset
? [
createButton({
label: tc("LogicMat_Reset"),
variant: "ghost",
onClick: (e) => {
e.stopPropagation();
reset(r, mat.차례);
},
}),
]
: []),
],
}),
],
}),
]
: [];
const tr = el("tr", {
className: `m02-labrow__row m02-labrow__logic-mat${mat.고름 ? " is-picked-mat" : ""}${on ? " is-open" : ""}`,
return el("tr", {
className: `m02-labrow__row m02-labrow__logic-mat${mat.고름 ? " is-picked-mat" : ""}`,
attrs: { "data-labor-logic-mat": `${row.로직}|${mat.차례}` },
children: [
el("td", { className: "m02-labrow__code", text: item?.키 ?? "—" }),
@@ -146,15 +81,9 @@ function matRow(
text: mat.단위,
attrs: { "data-label": tc("Labor_Unit") },
}),
...markCells(
row.자재표시?.[String(mat.차례)] ?? {},
on?.mark ? (k, v) => on.mark?.(r, mat.차례, k, v) : undefined,
),
...markCells(row.자재표시?.[String(mat.차례)] ?? {}),
...PRICE_SLOTS.map(priceCell),
money,
...tools,
],
});
if (on) tr.addEventListener("click", () => on.open(r));
return tr;
}
@@ -10,7 +10,6 @@ import { createSelectField, el } from "@ui/ui_template_elements";
import {
MAT_MARK_DEFAULT,
MAT_MARKS,
type LaborRow,
type MatMarkKey,
type MatMarks,
} from "./M02_MasterTemplete_Labor_Api";
@@ -60,12 +59,3 @@ export function setMark(target: MatMarks, key: MatMarkKey, v: string): void {
if (v) (target as Record<string, string>)[key] = v;
else delete target[key];
}
/** 로직 줄 `자재표시` 한 차례 한 칸 — 빈 차례 · 빈 묶음은 뺌 */
export function setLogicMark(row: LaborRow, at: number, key: MatMarkKey, v: string): void {
const all = (row.자재표시 ??= {});
const one = (all[String(at)] ??= {});
setMark(one, key, v);
if (!Object.keys(one).length) delete all[String(at)];
if (!Object.keys(all).length) delete row.자재표시;
}
@@ -1,134 +1,20 @@
/* =============================================================================
* M02_MasterTemplete_Labor_RowModal.ts
* 일위대가표 줄 누름 모달(PLAN 723-2 · 요구서_내역16 2장 4 · 5 · 856-1) — 일위대가표에서 빠진 줄 동작을 모달 안으로.
* · 로직 줄(단가산출 문서 없음) · 셈 주입 줄(프로젝트 사본) = 머리(이름 · 「1 ㎡ 당」 · 옵션 값 · 메모) + 안내 한 줄
* (856-1 — 옛 단가산출 상세 몸 · [적용] 걷음 · 고침 = 단가산출 줄 쌓기 · 856-3 에서 줄 쌓기 보기로) ·
* 로직 자재(바꾸기 · 기본 · 세 칸 · `Labor_LogicMats`)
* · 사용자 자재 줄 = 자재 모달(세 칸 · `Labor_MatTable` 한 줄)
* 일위대가표 사용자 자재 줄 누름 모달(PLAN 723-2 · 요구서_내역16 2장 4 · 5) — 세 칸(`Labor_MatTable` 한 줄) · 가격 다섯 보기.
* · 고침 = 그 줄 화면 캐시(저장은 [저장]) · 금액은 표가 다시 셈 → `watch` 로 받아 다시 그림
* · 단가산출(SK) 줄 = `Labor_SkEdit`(프로젝트 사본 = 보기만) · M01 로직 줄 창은 걷음(856-3)
* ========================================================================== */
import { createBanner } from "@ui/ui_template_banner";
import { el, showToast } from "@ui/ui_template_elements";
import { el } from "@ui/ui_template_elements";
import { openModal } from "@ui/ui_template_modal";
import { createText } from "@ui/ui_template_text";
import type { ItemLogic } from "./M02_MasterTemplete_Api_Fetch";
import type { LaborCalc, LaborMat, LaborRow, MatMarkKey } from "./M02_MasterTemplete_Labor_Api";
import { logicMatRows } from "./M02_MasterTemplete_Labor_LogicMats";
import { setLogicMark, setMark } from "./M02_MasterTemplete_Labor_MatMarks";
import type { LaborCalc, LaborMat } from "./M02_MasterTemplete_Labor_Api";
import { setMark } from "./M02_MasterTemplete_Labor_MatMarks";
import { matTable } from "./M02_MasterTemplete_Labor_MatTable";
import { tc } from "./M02_MasterTemplete_Labor_Text";
import { valueLine } from "./M02_Labor_Values_Model";
/** 표가 다시 센 답을 받음 — 돌려준 함수 = 그만 받음 */
export type CalcWatch = (fn: (calc: LaborCalc | null) => void) => () => void;
export interface RowModalOptions {
row: LaborRow;
logic: ItemLogic | null;
title: string;
/** 일위대가 머리(이름 · 「1 ㎡ 당」) */
head: string;
readOnly: boolean;
/** 셈 주입(프로젝트 복사본) — 안내 글이 다름 */
inject: boolean;
/** 사용자 자재 코드 — 로직 자재 [바꾸기]로 같은 품목 막음 */
userMats: string[];
watch: CalcWatch;
/** 고침 뒤 — `again` = 서버 다시 셈(입력 · 고름 · 별도계상) · 아니면 화면만 */
done: (again: boolean) => void;
}
const TEXT = {
NoDoc: [
"M01 로직을 바로 담은 줄 — 단가산출 화면 없음 · 고침은 단가산출로 담아(일위대가 [로직 추가]) 그 줄에서",
"Uses the M01 logic directly — add it as a build-up to edit",
],
FromSk: [
"단가산출 「{k}」 에서 담아 온 줄 — 고침은 그 단가산출에서 고쳐 다시 담음",
"Copied from build-up 「{k}」 — edit it there and re-add",
],
Inject: [
"프로젝트 사본 줄 — 단가산출 화면 없음 · 수식 고침은 M02 단가산출에서 고쳐 [재생성]",
"Project copy line — edit the build-up in M02 and regenerate",
],
} as const;
const t = (k: keyof typeof TEXT): string => TEXT[k][0];
export function openRowModal(o: RowModalOptions): void {
const row = o.row;
const edit = !o.readOnly;
const info = el("div", { attrs: { "data-row-head": "" } });
const mats = el("div", { attrs: { "data-row-mats": "" } });
let calc: LaborCalc | null = null;
const draw = (): void => {
const values = valueLine(o.logic?.입력 ?? [], row.입력값);
info.replaceChildren(
createText(o.head, "muted", 14),
...(values.text ? [createText(values.text)] : []),
...(values.empty
? [createText(tc("Labor_Empty").replace("{n}", String(values.empty)), "error")]
: []),
...(row.켜쌓기율 != null
? [createText(tc("Labor_Layer").replace("{n}", String(row.켜쌓기율)), "muted")]
: []),
...(row.메모 ? [createText(row.메모, "muted")] : []),
);
const lead = row.참조
? []
: logicMatRows([row], calc, !calc, {
open: () => undefined,
...(edit
? {
swap: (_r: number, at: number, key: string) => {
if (o.userMats.includes(key))
return showToast(tc("Labor_AlreadyMat").replace("{value}", key), "error");
row.고름 = { ...row.고름, [String(at)]: key };
o.done(true);
},
reset: (_r: number, at: number) => {
if (!row.고름) return;
delete row.고름[String(at)];
if (!Object.keys(row.고름).length) delete row.고름;
o.done(true);
},
mark: (_r: number, at: number, key: MatMarkKey, v: string) => {
setLogicMark(row, at, key, v);
o.done(key === "별도계상");
draw();
},
}
: {}),
});
mats.replaceChildren(
...(lead.length
? [el("h4", { text: tc("Labor_Mats") }), matTable({ mats: [], calc, lead })]
: []),
);
};
// 안내 한 줄(856-1) — 로직 줄 = 온 단가산출(`본뜬`) · 셈 주입 = 프로젝트 사본
const from = row.본뜬 && typeof row.본뜬.이름 === "string" ? row.본뜬.이름 : "";
const note = createBanner({
tone: "info",
text: o.inject ? t("Inject") : from ? t("FromSk").replace("{k}", from) : t("NoDoc"),
});
const stop = o.watch((c) => {
calc = c;
draw();
});
openModal({
title: o.title,
closeLabel: tc("In_Close"),
width: "1100px",
wide: true,
beforeClose: () => (stop(), true),
mount: (body) => body.append(info, note, mats),
});
draw();
}
export interface MatModalOptions {
mat: LaborMat;
watch: CalcWatch;
@@ -5,6 +5,8 @@
* · [저장] = 수식 저장(`flush`) → 그 SK 문서 저장(`saveTemplate` · 그 층 · 그 주인) → 닫음 → 부르는 쪽이 일위대가 금액을 다시 셈
* · 그 층을 못 고치면(위 층 · 남의 주인) 읽기만 · [저장] 없음 · 고친 것 있이 닫으면 물음(버리면 수식 캐시도 비움)
* · 머리(808-1 · 요구 701-4 · 5) = 단가산출 페이지 머리와 같음 — 보기 고르기 · [단가 갱신] · [재생성] · [저장] · [닫기]
* · 프로젝트 사본(856-3 · `copy`) = 사본의 굳힌 SK 문서째 줄 쌓기 보기만(`memory` · 파일 안 읽음 · 저장 없음) ·
* 고침은 M02 단가산출에서 고쳐 [재생성](요구 898 ①)
* 짝 모달 = `Labor_RefEdit`(일위조합 SC 줄).
* ========================================================================== */
@@ -23,6 +25,8 @@ export interface SkEditOptions {
/** 일위대가 머리(이름 · 「1 ㎡ 당」) */
head: string;
readOnly: boolean;
/** 프로젝트 사본(856-3) — 그 사본의 굳힌 SK 문서(있으면 보기만 · 파일 안 읽음) */
copy?: Record<string, unknown>;
/** 닫힘 — `saved` = 그 SK 문서를 저장함(부르는 쪽이 금액을 다시 셈) */
closed: (saved: boolean) => void;
}
@@ -39,12 +43,16 @@ export async function openSkEdit(opt: SkEditOptions): Promise<void> {
const at = `${layer}/${opt.ref.주인 ?? ""}/${opt.ref.키}`;
if (opened.has(at)) return;
opened.add(at);
let doc: unknown;
let version: string;
const copy = !!opt.copy;
const readOnly = copy || opt.readOnly;
let doc: unknown = opt.copy;
let version = "";
try {
const got = await readTemplate(layer, "sangeun", opt.ref.키, null, opt.ref.주인);
doc = got.문서;
version = got.판 ?? "";
if (!copy) {
const got = await readTemplate(layer, "sangeun", opt.ref.키, null, opt.ref.주인);
doc = got.문서;
version = got.판 ?? "";
}
} catch (error) {
opened.delete(at);
return void showToast(error instanceof Error ? error.message : tc("Load_Failed"), "error");
@@ -72,12 +80,13 @@ export async function openSkEdit(opt: SkEditOptions): Promise<void> {
const host = el("div", { attrs: { "data-labor-sk": opt.ref.키 } });
const slot = el("span", { className: "m02-main__tools" }); // 보기 고르기 · [단가 갱신] · [재생성](808-1 · 페이지 머리와 같음)
handle = mountSangeunDetail(host, doc, {
layer,
owner: opt.ref.주인,
readOnly: opt.readOnly,
onChanged: (d) => (dirty = d && !opt.readOnly),
// 사본 = 층 읽기 길(굳힌 문서째 셈 · 주인 층 권한 없이)
layer: copy ? "system" : layer,
owner: copy ? null : opt.ref.주인,
readOnly,
onChanged: (d) => (dirty = d && !readOnly),
onVersion: (v) => (version = v), // 수식 저장이 파일 판을 바꿈 — 문서 저장이 이어 받음
mode: "page", // 페이지와 같은 길 — 수식 저장 단추는 이 [저장] 한 번에 모임
mode: copy ? "memory" : "page", // 페이지와 같은 길 — 수식 저장 단추는 이 [저장] 한 번에 모임
slot,
});
const ok = createButton({
@@ -110,13 +119,17 @@ export async function openSkEdit(opt: SkEditOptions): Promise<void> {
body.append(
createText(opt.head, "muted", 14),
createText(
opt.readOnly ? `${tc("Ref_Shared")} · ${tc("Ref_ReadOnly")}` : tc("Ref_Shared"),
copy
? tc("Ref_Copy")
: opt.readOnly
? `${tc("Ref_Shared")} · ${tc("Ref_ReadOnly")}`
: tc("Ref_Shared"),
"hint",
),
host,
);
head.append(slot);
if (!opt.readOnly) head.append(ok); // [저장] = 머리 [닫기] 왼쪽
if (!readOnly) head.append(ok); // [저장] = 머리 [닫기] 왼쪽
},
});
}
@@ -7,15 +7,16 @@
* 금액 빠짐) → 그 줄 금액 · 합계 바로(짝 셈 `Labor_Calc.settle`) · 구조물 조합 · 공사 알약이 이어지면 그 값이 앞섬
* · 합계 열 = 「기준단위 단가」(줄 1 단위) · 「수량 반영 금액」(× 수량)
* · 머리 단추 = [항목 추가](736-1 · 자재는 찾기 창에서 고름 → 자재 목록) · 줄 우클릭 · 줄 끝 ⋯ = 위로 · 아래로 · 별칭 · 삭제
* · 줄 누름 = 줄 모달(`Labor_RowModal` — 옵션 · 메모 · 켜쌓기율 · 로직 자재 바꾸기 · 세 칸 · 안내 한 줄 · 856-1) ·
* 사전조합 참조 줄 = 서고 원본 모달(`Labor_RefEdit`) · 사용자 자재 줄 = 자재 모달(세 칸)
* · 줄 누름 = 단가산출 줄 = 줄 쌓기(`Labor_SkEdit` · 프로젝트 사본 = 굳힌 문서 보기만 · 856-3) ·
* 사전조합 참조 줄 = 서고 원본 모달(`Labor_RefEdit`) · 사용자 자재 줄 = 자재 모달(세 칸) ·
* M01 로직을 바로 담은 줄 = 안내 한 줄(창 없음 · 새로 안 생김)
* · 금액 = 서버 calc(최신 응답만 · 저장 안 함) · [저장]은 UI_Main(서버가 다시 셈)
* · 안 이은 고정 줄(729-3) = 격자 위 띠 · [연결](`Labor_Unlinked` — 이음만 · 저장은 [저장])
* 구조물 조합 일위대가(카드 · 열 상세 · PLAN 806-1)도 이 한 부품 — `mode` 없음 = 조합 갈래: 정보 칸(이름 · 구분)
* 없음 · 수량 칸 = 수량산출 모달(`Labor_Combo` — 면적산출 잇기) · 규격 열 줄(`Labor_Spec`) · 다이어그램(열 상세) ·
* 새 줄 수량 = 면적을 따름(빈 값). 단가산출(SK) 참조 줄 누름 = 그 단가산출 문서 모달(`Labor_SkEdit` — 수식 탭 · 저장 = 그 SK).
* 811-1(요구 707-1) — 단가산출 줄 = SK 참조 한 행(저장 때 안 펼침) · [로직 추가] M01 기초 = 이 층 SK 사본 · 다른 층 SK =
* 이 층 사본 뒤 참조(`Labor_SkPick`) · 프로젝트 · 셈 주입 = 옛 로직 줄.
* 이 층 사본 뒤 참조(`Labor_SkPick`) · 프로젝트 · 셈 주입 표 = 늘 보기만이라 [로직 추가] 없음(856-3).
* ========================================================================== */
import { createButton, createInputField, el, showToast } from "@ui/ui_template_elements";
@@ -49,7 +50,7 @@ import { unlinkedBar } from "./M02_MasterTemplete_Labor_Unlinked";
import { pasteInto } from "./M02_MasterTemplete_Labor_Paste";
import { openLogicPicker, withSangeun } from "./M02_MasterTemplete_Labor_Pick";
import { openRefEdit } from "./M02_MasterTemplete_Labor_RefEdit";
import { openMatModal, openRowModal } from "./M02_MasterTemplete_Labor_RowModal";
import { openMatModal } from "./M02_MasterTemplete_Labor_RowModal";
import { tc } from "./M02_MasterTemplete_Labor_Text";
import { insideKeys } from "./M02_Labor_LogicMats_Model";
import { valueLine } from "./M02_Labor_Values_Model";
@@ -333,26 +334,23 @@ export function mountLaborTable(
closed: () => alive && recalc(),
});
if (row.고정) return; // 고정 줄 = 숫자 그대로(이름 · 별칭은 우클릭)
// 단가산출(SK) 줄 = 그 단가산출 문서 모달(수식 탭 · 806-1) — 셈 주입(프로젝트 복사본)엔 줄 모달(안내 · 856-3 까지)
if (isSkRef(row.참조) && !opt.calc)
return void openSkEdit({
ref: row.참조,
title: nameOf(row),
head: head(),
readOnly: !edit || row.참조.층 !== opt.layer,
closed: (done) => alive && done && recalc(), // 저장했으면 금액을 다시 셈
});
openRowModal({
row,
logic: logics.get(row.로직) ?? null,
if (!isSkRef(row.참조)) return showToast(tc("Logic_Direct"), "info"); // M01 로직 줄 — 창 없음(856-3)
const ref = row.참조;
const sk = {
ref,
title: nameOf(row),
head: head(),
watch,
readOnly: !edit,
inject: !!opt.calc,
userMats: cur.자재.map((m) => m.코드),
done: (again) => changed(!again),
});
readOnly: !edit || ref.층 !== opt.layer,
closed: (done: boolean) => alive && done && recalc(), // 저장했으면 금액을 다시 셈
};
// 단가산출(SK) 줄 = 그 단가산출 문서 줄 쌓기(806-1) · 프로젝트 사본 = 굳힌 문서 보기만(856-3)
if (!opt.skCopy) return void openSkEdit(sk);
void opt
.skCopy(ref)
.then(
(copy) => (copy ? void openSkEdit({ ...sk, copy }) : showToast(tc("Sk_NoCopy"), "error")),
failed,
);
}
function openMat(i: number): void {
const mat = cur.자재[i];
@@ -456,7 +454,7 @@ export function mountLaborTable(
changed();
},
};
/** SK 사본 길(811-1) — M02 층 일위대가 · 조합만(프로젝트 · 셈 주입 = 옛 로직 줄) */
/** SK 사본 길(811-1) — M02 층 일위대가 · 조합만(프로젝트 · 셈 주입 = 늘 보기만 · [로직 추가] 없음 · 856-3) */
const own: SkPickScope | null =
opt.layer !== "project" && !opt.calc ? { layer: opt.layer, owner: library.owner } : null;
const addLogic = createButton({
@@ -464,16 +462,12 @@ export function mountLaborTable(
variant: "filled",
onClick: () =>
openLogicPicker((x) => {
// 811-1 — M01 기초 = 이 층 SK 사본 참조 한 행(펼치지 않음)
if (own)
// 811-1 — M01 기초 = 이 층 SK 사본 참조 한 행(펼치지 않음)
return void skFromLogic(own, x.키).then(
void skFromLogic(own, x.키).then(
(r) => r && alive && addRef(r, x.이름 || x.키, null),
failed,
);
if (cur.담은로직.some((r) => r.로직 === x.키))
return showToast(tc("Labor_Already").replace("{value}", `${x.키} ${x.이름}`), "error");
cur.담은로직.push({ 로직: x.키, 별칭: null, 메모: null, 입력값: {}, 수량: fresh() });
void loadLogics().then(() => changed());
}, withSangeun(library)),
});
@@ -538,7 +532,7 @@ export function mountLaborTable(
className: "m01-logic__section-head",
children: [
el("h3", { text: tc("Grid_Title") }),
...(edit && !(combo && opt.card)
...(edit && own && !(combo && opt.card)
? [el("div", { className: "ui-btn-group", children: [addLogic] })]
: []),
],
@@ -42,6 +42,15 @@ const TEXT = {
"Edits the library original — every structure using it follows",
],
Ref_ReadOnly: ["이 층은 고칠 수 없음 — 읽기만", "Read-only layer"],
Ref_Copy: [
"프로젝트 사본 — 보기만 · 고침은 M02 단가산출에서 고쳐 [재생성]",
"Project copy — view only · edit the build-up in M02 and regenerate",
],
Sk_NoCopy: ["사본에 이 단가산출 문서가 없음", "This copy has no build-up document"],
Logic_Direct: [
"M01 로직을 바로 담은 줄 — 단가산출 화면 없음 · 단가산출로 담아 쓰세요(일위대가 [로직 추가])",
"Uses the M01 logic directly — add it as a build-up to view or edit",
],
Lib_SaveFailed: ["저장 못 함", "Save failed"],
Ref_Discard: ["저장 안 한 고침을 버리고 닫음?", "Discard unsaved edits?"],
Labor_Source: ["원문", "Source"],
@@ -109,13 +118,9 @@ const TEXT = {
],
Labor_Code: ["코드", "Code"],
Labor_Spec: ["규격", "Spec"],
Labor_Already: ["이미 담은 단가산출 기초 — {value}", "Already added — {value}"],
Labor_AlreadyMat: ["이미 담은 자재 — {value}", "Already added — {value}"],
// 로직 자재(103-1)
Labor_InLogicMat: ["로직 자재에 있는 품목 — {value}", "Already a logic material — {value}"],
LogicMat_Swap: ["바꾸기", "Change"],
LogicMat_Reset: ["기본", "Default"],
LogicMat_PickTitle: ["로직 자재 바꾸기", "Change logic material"],
LogicMat_Inside: [
"로직 단가 안 금액 — 합계에 다시 안 더함",
"Inside the logic price — not added again",
@@ -29,6 +29,11 @@
min-width: 120px;
}
/* 856-G 환산 자리 — 머리 줄 배치에 안 끼어듦 */
.m02-sk__swap-slot {
display: contents;
}
.m02-sk__tags {
display: flex;
flex-wrap: wrap;
@@ -161,6 +161,7 @@ export function mountSangeunDetail(
};
function drawHead(): void {
// 856-G 칸 고침 = 머리를 다시 그리지 않음(Tab 으로 옮긴 다음 칸 초점 · 타자 유지) · 환산만 새로
const field = (label: string, key: "이름" | "단위"): HTMLElement => {
const box = createInputField({ label, value: doc[key] ?? "", compact: true, size: 28 });
box.input.dataset.sk = key;
@@ -168,29 +169,36 @@ export function mountSangeunDetail(
box.input.addEventListener("change", () => {
doc[key] = box.input.value.trim();
box.setError(doc[key] ? undefined : L("M02_SangeunNeed"));
touch();
report();
if (key === "단위") drawSwap();
});
return box.root;
};
const baseName = base ? `${base.logic.키} ${base.logic.이름}` : null;
const baseText = baseName ?? doc.바탕?.참조?.키 ?? L("M02_SangeunNoBase");
const swap = base
? buildUnitSwap({
result: base.logic.결과단위,
unit: doc.단위 ?? "",
how: doc.환산 as SwapHow | undefined,
edit,
onChange: (how) => {
if (how) doc.환산 = how;
else delete doc.환산;
touch();
},
})
: null;
const swapSlot = el("span", { className: "m02-sk__swap-slot" });
const drawSwap = (): void => {
const swap = base
? buildUnitSwap({
result: base.logic.결과단위,
unit: doc.단위 ?? "",
how: doc.환산 as SwapHow | undefined,
edit,
onChange: (how) => {
if (how) doc.환산 = how;
else delete doc.환산;
report();
drawSwap();
},
})
: null;
swapSlot.replaceChildren(...(swap ? [swap] : []));
};
drawSwap();
head.replaceChildren(
field(L("M02_Name"), "이름"),
field(L("M02_SangeunUnit"), "단위"),
...(swap ? [swap] : []),
swapSlot,
el("div", {
className: "m02-sk__tags",
attrs: { "data-sk-base": baseKey() ?? "" },
+4 -29
View File
@@ -135,36 +135,11 @@ def update(folder: str | Path, key: str, body: dict[str, Any]) -> dict[str, Any]
return got
def _aside(path: Path, folder: str | Path) -> bool:
"""밑줄 · 점 폴더(「_합친것」 등 파생 · 보관) — 쓰는 곳 아님."""
return any(x.startswith(("_", ".")) for x in path.relative_to(folder).parts[:-1])
def usage(folder: str | Path, keys: list[str]) -> dict[str, list[dict[str, Any]]]:
"""그 층에서 키마다 쓰는 문서(단가산출 · 일위대가 …) {키: [{종류, 키, 이름}]} — 파일은 한 번씩 읽음."""
out: dict[str, list[dict[str, Any]]] = {k: [] for k in keys}
for path in sorted(Path(folder).rglob("*.json")): # 종류 폴더 · 그 밑 폴더 — 내 목록 파일 뺌
if path.name == FILE or _aside(path, folder):
continue
try:
text = path.read_text(encoding="utf-8")
except OSError:
continue
hit = [k for k in keys if k in text]
if not hit:
continue
try:
doc = json.loads(text)
except ValueError:
continue
name = (doc.get("이름") if isinstance(doc, dict) else None) or path.stem
for k in hit:
out[k].append({"종류": path.parent.name, "키": path.stem, "이름": name})
return out
def uses(folder: str | Path, key: str) -> list[dict[str, Any]]:
return usage(folder, [key])[key]
"""쓰는 문서 — 쓰는 곳 색인 한 벌(`M02_Library_Uses.materials` · 858 5-5)."""
from M02_MasterTemplete import M02_Library_Uses as library_uses
return library_uses.materials(folder, [key])[key]
def remove(folder: str | Path, key: str) -> None:
+22 -27
View File
@@ -259,13 +259,26 @@ def hourly(row: dict, index: Any) -> dict[str, Any]:
key = logic_key(row)
if key is None:
return {"ok": False, **head, "reason": "식 없음 — 조종원직종 없음"}
logic = index.logic(key)
from M02_MasterTemplete import M02_Machine_Hourly as mh # 셈 한 길(842-3 · 855 2-B2)
got = mh.hour(row, logic, index)
got = mh.hour(row, _head(key), index)
return {"ok": got["ok"], **head, **got}
def _head(key: str) -> dict[str, Any]:
"""식 머리 {키, 입력} — M01 수식 문서에서(로직 줄 안 읽음 · 855 L2 ⓑ) · 입력 = 고르기 · 입력 변수
(옛 로직 줄 「입력」 과 1,521 문서 같음) · 문서 없음 = 빈 입력(`hour` 가 「식 문서 없음」)."""
from M01_MasterData import M01_MasterData_Doc as m01doc
doc = m01doc.docs().get(key) or {}
opens = [
{"이름": v.get("이름")}
for v in doc.get("변수") or []
if isinstance(v, dict) and (v.get("연결") or {}).get("갈래") in ("선택", "입력")
]
return {"키": key, "입력": opens}
# ── 검사 ──────────────────────────────────────────────────────────────
def _num(value: Any, name: str) -> float | None:
if value in (None, ""):
@@ -479,36 +492,18 @@ def delete(key: str) -> dict[str, Any]:
"""지움 — 이미 만든 단가산출은 사본의 마지막 값 그대로(「지운키」)."""
_user()
_old(key)
used = uses().get(key, [])
used = _uses().get(key, [])
with _LOCK:
_old(key)
(_dir() / f"{key}.json").unlink(missing_ok=True)
return {"지움": key, "쓰는곳": used}
def uses() -> dict[str, list[dict]]:
"""{내 기계 키: [{키, 이름}]} — 이 층 단가산출 가운데 사본(옛 칸 · 수식) 단가 줄에 그 키를 가진 것."""
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
def _uses() -> dict[str, list[dict]]:
"""{내 기계 키: [{키, 이름}]} — 쓰는 곳 색인 한 벌(`M02_Library_Uses.machines` · 858 5-5)."""
from M02_MasterTemplete import M02_Library_Uses as library_uses
out: dict[str, list[dict]] = {}
for path in sorted((store.root() / sd.KIND).glob("SK-*.json")):
raw = path.read_bytes()
if PREFIX.encode() not in raw:
continue
try:
doc = json.loads(raw)
except ValueError:
continue
keys = { # 옛 칸 사본 · 수식 길 사본(827-1) — 한 SK 한 번
str(row["키"])
for part in (skc.KEY, "수식")
for row in (doc.get(part) or {}).get("단가") or []
if mine(row.get("키"))
}
for key in sorted(keys):
out.setdefault(key, []).append({"키": doc.get("키"), "이름": doc.get("이름")})
return out
return library_uses.machines()
def same(name: Any, spec: Any, skip: str = "") -> list[dict]:
@@ -542,12 +537,12 @@ def one(key: str) -> dict[str, Any]:
got = next((r for r in rows() if r["키"] == key), None)
if got is None:
raise _bad(f"없는 내 기계 「{key}」", 404)
return answer(got, uses().get(key, []))
return answer(got, _uses().get(key, []))
def listing() -> dict[str, Any]:
"""목록 — 줄마다 시간당 · 쓰는곳수(넣은 차례)."""
index, used = whole(), uses()
index, used = whole(), _uses()
return {
"줄": [
{**r, "시간당": hourly(engine(r), index), "쓰는곳수": len(used.get(r["키"], []))}
+1 -1
View File
@@ -3,7 +3,7 @@
STmate(.xlsx) = 단가산출근거 시트 G 열 「BDCOD|D…」 머리 · POSS~POSE 몸(숨은 G 열 원문) ·
꼬리(계 · 계약단가 · 총계) + 목록표 단가(노무비 · 재료비 · 경비 = E 열 · 숨은 G 열 `COD` ·
중기 · 단가산출근거 = E~H 열 계 · 노 · 재 · 경 · 숨은 J 열 메타).
EST(.xls · .xlsx) = 단가산출 시트 블록 글(`M02_Hopyo_ReadEst.read`) + 노임단가 ·
EST(.xls · .xlsx) = 단가산출 시트 블록 글 + 노임단가 ·
자재단가(적용단가) · 기계경비총괄표 · 견적단가 · 단가산출총괄표(적용 칸 · 합이 안 맞으면 당초 칸).
"""
+1 -1
View File
@@ -13,7 +13,7 @@
구성 없음 → 직접(그 파일 시간당 노 · 재 · 경).
잇기(`attach` · 층 저장 길 `M02_Sangeun_FromHopyo.make` 만) = 그 층 내 기계 같은 이름 · 규격이면 그 줄 · 없으면
새로(`M02_MyMachine.create`) · 바로 = 기계 줄 이음 키 · 로직 줄 = 시간당 부름 글 / 직접 = 이음 없이 자원
`내기계` 키(셈 = 그 파일 값 · [우리 단가로] = 내 기계 시간당 · `M02_Sangeun_Imported.row_of`) ·
`내기계` 키(셈 = 그 파일 값 · [우리 단가로] = 내 기계 시간당) ·
원본 `내기계` [{키, 이름, 규격, 새로}] · 개인 층 아님 = 안 만듦(원본 `내기계예정` [{이름, 규격}] 만).
금액(엑셀 단가 그대로)은 줄 값을 안 건드려 그대로.
기계 한 대 안 여러 줄(842-4) = 구성에 `인력줄` [[직종 글, 인]] · `연료줄` [[종류, ℓ]] · `잡품줄` [율 %] · `재료줄` [[이름, 수량, 단위]]
+35 -187
View File
@@ -1,158 +1,49 @@
"""M02 단가산출(SK) 숫자 넓힘(PLAN 790-2 · 요구서_652 · _분석_650-H3 E2) — 새 덮개 갈래.
"""M02 단가산출(SK) 글 칸 · 옛 칸 막음 · [초기화] 걷기 · 셈 답(PLAN 790-2 · 855 2-E2).
시험 `resources/tester/test_790_2_sangeun_const.py` · 799-2 — 화면 짝(`Const_Model.ts` · 시트 탭)은 걷음, 서버만 남음.
문서 덧칸(없으면 안 둠 — 옛 SK 그대로 · 지문 그대로):
상수덮개 {자리: {n: 값}} 자리 식의 n 번째 숫자 상수(0 부터 · 엔진 파서 차례 · 찾기 머리 · 키 ·
따옴표 글 안 셈) → 값 · 식 구조 그대로(옵션 바꾸면 나머지 따라감)
표값덮개 {자리: {n: 값}} 자리 식의 n 번째 표 찾기 값(`찾기(…).칸`) → 값 · 그 줄만 표 연결 끊김
글줄 [{자리, 글}] 셈 없는 글 줄(근거 · ※ 조건) · 자리 뒤에 찍힘("" = 맨 위)
까닭 {열쇠: 글} 덮개 · 더한줄 · 뺀줄 · 새 덮개마다(예정가격작성기준 제2조 ②)
M01판 {자리: 지문} (옛 칸 — 읽던 시트를 2-C1 에서 걷어 855 2-D 부터 안 적음 · 옛 파일 칸은 `sd.clean` 이 버림)
자리 = 바탕 줄 cid(호표 · 덧줄 `kind:키#n`) · 중간 줄 `mid:이름` · 열쇠 = 자리 · `add:#k` ·
`add:#k/세부 cid` · 식 칸 = 중간 「식」 · 호표 「수량」 · 덧줄 「식」.
셈 = `M02_Sangeun_Doc.patched` 첫머리 `formulas`(바탕 줄 식을 바꾼 사본) → 모든 셈 길(화면 · 저장
원값 · B09 · 펼침 겹침) 한 벌 · 펼침(`M02_Library_Flat._read`) = 새 덮개 SK 는 안 펼침
(옛 참조 그대로) · [초기화](`M02_Library_Flat.reset`) = `restore` 전체.
문서 덧칸(없으면 안 둠):
글줄 [{자리, 글}] 셈 없는 글 줄(근거 · ※ 조건) · 자리 뒤에 찍힘("" = 맨 위)
까닭 {열쇠: 글} 덮개 · 더한줄 · 뺀줄마다(예정가격작성기준 제2조 ②)
자리 = 바탕 줄 cid(호표 · 덧줄 `kind:키#n`) · 중간 줄 `mid:이름` · 열쇠 = 자리 · `add:#k` · `add:#k/세부 cid`.
옛 식 칸(상수덮개 · 표값덮개 790-2 · 변수줄 · 식덮개 · 더한줄 수량식 792-1)은 셈 은퇴(855 2-C1) 뒤 받지 않음
(`clean_more` = 400 · 저장본 0 · 855 2-E2) · 셈 = 수식 사본 문서 한 길.
펼침(`M02_Library_Flat._read`) = 수식 고침 · 가져온 식 SK 는 안 펼침(옛 참조 그대로) ·
[초기화](`M02_Library_Flat.reset`) = `restore`(덮개 · 뺀줄 · 까닭).
셈 답(`answer`) = 문서 셈 답 1 단위 몫(옛 `원래` · `시트` 덧칸 855 2-C1 · 머리 띠 855 2-E2 에서 걷음).
"""
from __future__ import annotations
import functools
import re
from typing import Any
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sangeun_Equation as eqm
from M02_MasterTemplete import M02_Sangeun_Formula as fx
from M02_MasterTemplete import M02_Sangeun_Imported as imp
NEW = ("상수덮개", "표값덮개", "글줄", "까닭")
_SPOT = re.compile(r"^(mid:.+|(labor|material|machine|logic|pct):.*#\d+)$")
NEW = ("글줄", "까닭")
OLD = ("상수덮개", "표값덮개", "변수줄", "식덮개") # 옛 식 칸 — 셈 은퇴 · 받지 않음(855 2-E2)
_KEY = re.compile(r"^(mid:.+|(add:#\d+/)?(labor|material|machine|logic|pct):.*#\d+|add:#\d+)$")
_ADD = re.compile(r"^add:#(\d+)(/.*)?$")
FIELD = {"중간": "식", "호표": "수량", "덧줄": "식"}
LONG = 500 # 글 · 까닭 길이 상한
MANY = 200 # 글줄 수 상한
# ── 식 속 자리 ────────────────────────────────────────────────────────
@functools.cache
def _parser() -> type:
"""엔진 파서(`master_formula._Parser`) + 숫자 · 표 찾기 글자 자리 기록(엔진과 같은 차례)."""
from M02_MasterTemplete import M02_Labor_Doc as labor
class Spots(labor.m01.cm.mf._Parser):
def __init__(self, text: str) -> None:
super().__init__(text)
self.spots: list[tuple[str, int, int]] = []
def primary(self): # noqa: ANN202
self.ws()
at = self.i
node = super().primary()
if node[0] == "num" and self.s[at : at + 1] != "(": # 「(11)」 = 안쪽 수만
self.spots.append(("num", at, self.i))
return node
def unary(self): # noqa: ANN202
self.ws()
at = self.i
node = super().unary()
inner = node
while inner[0] == "field":
inner = inner[1]
if node[0] == "field" and inner[0] == "find":
self.spots.append(("find", at, self.i))
return node
return Spots
@functools.lru_cache(maxsize=4096)
def scan(text: str) -> dict[str, list[tuple[int, int]]]:
"""식 글 → {num: [(처음,끝)], find: [(처음, 끝)]}(왼쪽부터) · 못 읽는 식 = 빈 목록."""
p = _parser()(text)
try:
p.parse()
except Exception: # noqa: BLE001 — 엔진 FormulaError · 깊은 괄호
return {"num": [], "find": []}
spots = [(t, a, a + len(text[a:b].rstrip())) for t, a, b in p.spots] # 뒤 빈칸(`.` 엿봄) 뗌
return {k: sorted((a, b) for t, a, b in spots if t == k) for k in ("num", "find")}
def _lit(value: Any) -> str:
got = sd.text(value)
return f"({got})" if got.startswith("-") else got
def swap(text: str, nums: dict, finds: dict) -> str:
"""식 글의 n 번째 숫자 · 표 찾기를 값으로(원래 식 차례 · 바꾼 표 찾기 안 숫자는 버림)."""
spots = scan(text)
cuts = [(*spots["find"][int(n)], v) for n, v in finds.items() if int(n) < len(spots["find"])]
for n, v in nums.items():
if int(n) < len(spots["num"]):
a, b = spots["num"][int(n)]
if not any(x <= a and b <= y for x, y, _ in cuts):
cuts.append((a, b, v))
for a, b, v in sorted(cuts, reverse=True):
text = text[:a] + _lit(v) + text[b:]
return text
def places(row: dict) -> dict[str, tuple[str, int]]:
"""자리 → (갈래, 차례) — 중간 `mid:이름` · 호표 · 덧줄 cid."""
out = {f"mid:{s.get('이름')}": ("중간", at) for at, s in enumerate(row.get("중간") or [])}
n = len(row.get("호표") or [])
for at, cid in enumerate(sd.line_ids(row)):
out[cid] = ("호표", at) if at < n else ("덧줄", at - n)
return out
def formulas(row: dict, doc: dict) -> dict:
"""바탕 줄 + 식 칸(792-1) · 상수 · 표값 덮개 → 식 바꾼 사본(덮개 없음 = 그 줄 그대로 · 순수)."""
return formulas_lost(row, doc)[0]
def formulas_lost(row: dict, doc: dict) -> tuple[dict, list[dict], dict]:
"""(식 바꾼 사본, 틀린 식 자리 짝잃음, 수량식 엔진 꼴 문서) — `sd.patched` 첫머리."""
row, bad, doc = fx.settle(row, doc)
return _swapped(row, doc), bad, doc
def _swapped(row: dict, doc: dict) -> dict:
nums, finds = doc.get("상수덮개") or {}, doc.get("표값덮개") or {}
if not nums and not finds:
return row
out = {**row, **{k: list(row.get(k) or []) for k in FIELD}}
for spot, (part, at) in places(row).items():
if spot in nums or spot in finds:
line = out[part][at] = dict(out[part][at])
field = FIELD[part]
line[field] = swap(str(line.get(field)), nums.get(spot) or {}, finds.get(spot) or {})
return out
# ── 펼침 · 초기화 ─────────────────────────────────────────────────────
def no_flat(doc: Any) -> None:
"""펼침 막음 — 상수 · 표값 덮개 SK(펼친 줄에 못 옮김 · 옛 참조 그대로 = 값 그대로)."""
keys = ("상수덮개", "표값덮개", eqm.KEY) # 수식 고침(796-2b)
if isinstance(doc, dict) and (any(doc.get(k) for k in keys) or fx.has(doc)):
raise sd.DocError(
"상수 · 표값 덮개 · 식 칸 · 수식 고침 단가산출은 펼치지 않음(참조 그대로)"
)
"""펼침 막음 — 수식 고침 SK(펼친 줄에 못 옮김 · 옛 참조 그대로 = 값 그대로)."""
if isinstance(doc, dict) and doc.get(eqm.KEY): # 수식 고침(796-2b)
raise sd.DocError("수식 고침 단가산출은 펼치지 않음(참조 그대로)")
if imp.is_imported(doc): # 가져온 식(793-2) = M01 기초 없음
raise sd.DocError("가져온 식 단가산출은 펼치지 않음(참조 그대로)")
def covers_n(doc: dict) -> int:
"""[초기화] 걷힐 고침 수 — 덮개 · 뺀줄 · 상수 · 표값 덮개 칸."""
keys = ("덮개", "뺀줄", "상수덮개", "표값덮개", "식덮개")
return sum(len(doc.get(k) or ()) for k in keys)
"""[초기화] 걷힐 고침 수 — 덮개 · 뺀줄 칸."""
return sum(len(doc.get(k) or ()) for k in ("덮개", "뺀줄"))
# ── 문서 꼴 ──────────────────────────────────────────────────────────
def _key(raw: Any, where: str, pat: re.Pattern = _SPOT) -> str:
def _key(raw: Any, where: str, pat: re.Pattern = _KEY) -> str:
if not isinstance(raw, str) or not pat.match(raw):
raise sd.DocError(f"{where} · 자리 꼴 아님 「{raw}」")
return raw
@@ -165,32 +56,14 @@ def _words(raw: Any, where: str) -> str:
return got
def _covers(raw: Any, name: str) -> dict:
if raw in (None, {}):
return {}
if not isinstance(raw, dict):
raise sd.DocError(f"{name} · 묶음 아님")
out = {}
for spot, one in raw.items():
where = f"{name} 「{spot}」"
if not isinstance(one, dict):
raise sd.DocError(f"{where} · {{n: 값}} 아님")
got = {}
for n, v in one.items():
if not re.fullmatch(r"\d{1,3}", str(n)):
raise sd.DocError(f"{where} · n 은 0 부터 수 「{n}」")
got[str(int(n))] = sd.plain(sd._num(v, f"{where} {n}"))
if got:
out[_key(spot, name)] = got
return out
def clean_more(raw: Any, out: dict) -> dict:
"""`sd.clean` 끝 — 새 덮개 칸 검사 · 빈 칸은 안 둠(`M01판` · 원값은 서버 몫이라 버림)."""
"""`sd.clean` 끝 — 글 칸 검사 · 빈 칸은 안 둠(`M01판` · 원값은 서버 몫이라 버림) · 옛 식 칸 = 400."""
raw = raw if isinstance(raw, dict) else {}
for name in ("상수덮개", "표값덮개"):
if got := _covers(raw.get(name), name):
out[name] = got
old = [k for k in OLD if raw.get(k) not in (None, {}, [], "")]
adds = [x for x in raw.get("더한줄") or [] if isinstance(x, dict)]
old += ["더한줄 수량식"] if any(x.get("수량식") not in (None, "") for x in adds) else []
if old:
raise sd.DocError(f"옛 식 칸 {old} — 셈 은퇴 · 받지 않음(수식 문서로 고칠 것)")
texts = raw.get("글줄") or []
if not isinstance(texts, list) or len(texts) > MANY:
raise sd.DocError(f"글줄 · {MANY} 줄까지 목록")
@@ -200,13 +73,13 @@ def clean_more(raw: Any, out: dict) -> dict:
spot = str(one.get("자리") or "")
words = _words(one.get("글"), f"글줄 {at}째")
if words:
lines.append({"자리": spot and _key(spot, f"글줄 {at}째", _KEY), "글": words})
lines.append({"자리": spot and _key(spot, f"글줄 {at}째"), "글": words})
if lines:
out["글줄"] = lines
why = raw.get("까닭") or {}
if not isinstance(why, dict):
raise sd.DocError("까닭 · 묶음 아님")
why = {_key(k, "까닭", _KEY): _words(v, f"까닭 「{k}」") for k, v in why.items()}
why = {_key(k, "까닭"): _words(v, f"까닭 「{k}」") for k, v in why.items()}
if why := {k: v for k, v in why.items() if v}:
out["까닭"] = why
if isinstance(raw.get("사본"), dict): # 로직 사본(795-1) — 셈 · 저장 첫머리 settle 이 정함
@@ -214,17 +87,14 @@ def clean_more(raw: Any, out: dict) -> dict:
if isinstance(raw.get("수식"), dict): # 수식 사본(802-4a) — 저장 끝 `M02_Doc_Sk.settle` 이 정함
out["수식"] = raw["수식"]
out = eqm.clean(raw, out) # 수식 고침(796-2b)
return imp.clean(raw, fx.clean(raw, out)) # 식 칸(792-1) · 가져온 식(793-2)
return imp.clean(raw, out) # 가져온 식(793-2)
def stamp(row: dict, doc: dict | None = None) -> dict[str, Any]:
"""저장 때 서버 칸 — 바탕판(바탕 줄 지문 · 화면 「기초가 바뀜」) · `doc` = 식 칸(792-1)을
엔진 식으로 바꿔 넣음(제자리 · 틀린 식 = `DocError`) · 옛 `M01판`(자리마다 지문 — 읽던 시트 걷음)은 안 적음(855 2-D)."""
"""저장 때 서버 칸 — 바탕판(바탕 줄 지문 · 화면 「기초가 바뀜」) · 가져온 식 검산 ·
옛 `M01판`(자리마다 지문 — 읽던 시트 걷음)은 안 적음(855 2-D)."""
from M02_MasterTemplete import M02_Sangeun_Calc as calc
if doc is not None and fx.has(doc):
fixed = fx.settle(row, doc, strict=True)[2]
doc.update({k: fixed[k] for k in ("더한줄", *fx.FIELDS) if k in fixed})
if doc is not None and imp.is_imported(doc): # 가져온 식 검산(793-2) = 서버가 다시
doc[imp.KEY]["검산"] = imp.check(doc)
@@ -232,34 +102,12 @@ def stamp(row: dict, doc: dict | None = None) -> dict[str, Any]:
# ── 고치기 ──────────────────────────────────────
def restore(doc: dict, key: str | None = None) -> dict:
"""[M01 원래로] — 전체(None) = 덮개 · 뺀줄 · 상수 · 표값 · 식 덮개 · 그 까닭 지움(더한줄 ·
글줄 · 변수줄 · 옵션 남김) · 열쇠 하나 = 그 자리 덮개 · 뺀줄 · 새 덮개 · 까닭(세부
`add:#k/cid` = 그 더한줄 세부)."""
out = {k: v for k, v in doc.items() if k not in ("상수덮개", "표값덮개", "식덮개", "까닭")}
why = dict(doc.get("까닭") or {})
if key is None:
out |= {"덮개": {}, "뺀줄": []}
why = {k: v for k, v in why.items() if _top_add(k)}
return out | ({"까닭": why} if why else {})
hit = _ADD.match(key)
if hit and hit[2]:
k, sub = int(hit[1]), hit[2][1:]
adds = [dict(x) for x in doc.get("더한줄") or []]
if k < len(adds):
one = {n: v for n, v in adds[k].items() if n not in ("덮개", "뺀줄")}
covers = {c: v for c, v in (adds[k].get("덮개") or {}).items() if c != sub}
drop = [c for c in adds[k].get("뺀줄") or [] if c != sub]
adds[k] = one | ({"덮개": covers} if covers else {}) | ({"뺀줄": drop} if drop else {})
out["더한줄"] = adds
else:
out["덮개"] = {c: v for c, v in (doc.get("덮개") or {}).items() if c != key}
out["뺀줄"] = [c for c in doc.get("뺀줄") or [] if c != key]
for name in ("상수덮개", "표값덮개", "식덮개"):
if got := {s: v for s, v in (doc.get(name) or {}).items() if s != key}:
out[name] = got
why.pop(key, None)
return out | ({"까닭": why} if why else {})
def restore(doc: dict) -> dict:
"""[초기화] — 덮개 · 뺀줄 · 그 까닭 지움(더한줄 몫 까닭 · 더한줄 · 글줄 · 옵션 남김) ·
옛 자리 하나 [M01 원래로](상세 몸 856-1)는 걷음(855 2-E2)."""
out = {k: v for k, v in doc.items() if k != "까닭"}
why = {k: v for k, v in (doc.get("까닭") or {}).items() if _top_add(k)}
return out | {"덮개": {}, "뺀줄": []} | ({"까닭": why} if why else {})
def _top_add(key: str) -> bool:
+47 -8
View File
@@ -3,7 +3,9 @@
사본 = 저장 때 서버가 찍는 M01 닫힌 묶음(`M02_Item_Prices.collect` 다시 씀) — 셈 중 문서 칸 `사본` ·
층 저장 파일 = `수식` 의 값 몫 한 벌(`held` · 855 2-D — 파일엔 `사본` 안 씀 · 프로젝트 사본 꼴은 그대로):
{판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 줄], 빠진?}
로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직 · 찾기 표 · 그 밖 요소(요율 등)
로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직이 닿는 찾기 표 · 그 밖 요소(요율 등) —
단가산출 = 로직 줄(GF · GC · GX) 자체는 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름` · M01 바뀜 =
문서 지문) · 일위대가 · 사전조합 = 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 `Labor_Copy.stamp` 에서 뺌)
단가 = 자원 단가 줄(`RES` 노임 · 자재 · 기계 · 유가전력 · 환율) = 단가 기준 시점 묶음.
셈 = M01 색인 위에 사본 줄을 얹은 `Copy`(키 · 원문번호 찾기만 사본 먼저 · M01 색인 안 고침) —
`M02_Sangeun_Calc._base_of`(바탕 줄) · `run`(엔진 · 하위 로직 · 표 · 단가)이 `over` 로 부름 ·
@@ -67,16 +69,31 @@ def has(doc: Any) -> bool:
FORM = "수식" # 수식 사본 칸(`M02_Doc_Copy.KEY`) — 층 저장 파일의 값 사본 자리(855 2-D)
VALUES = ("판", "시점", "로직", "단가판", "단가시점", "단가")
#: M01 로직 줄 키 머리(GF · GC · GX) — 단가산출 값 사본에 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름`)
LOGIC = frozenset(t for t, g in prices.mf.mk.GROUP_OF.items() if g == "로직")
def plain(rows: Any) -> list:
"""값 사본 줄에서 로직 줄을 뺌(표 · 요율 · 자원 줄만)."""
return [r for r in rows or [] if not (isinstance(r, dict) and str(r.get("키"))[:2] in LOGIC)]
def _plain(copy: dict) -> dict:
"""단가산출 값 사본 — 로직 줄 뺀 꼴 · 판 다시(옛 저장본 = 읽을 때 뺌 · 파일은 다음 [저장] 때 새 꼴)."""
rows = plain(copy["로직"])
return copy if len(rows) == len(copy["로직"]) else {**copy, "로직": rows, "판": _fp(rows)}
def held(doc: Any) -> dict | None:
"""문서의 값 사본 — 셈 · 저장 중 `settle` 이 붙인 `사본` › 층 저장 파일 `수식` 의 값 몫(855 2-D ·
층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 없음 = None."""
층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 단가산출 = 로직 줄 뺌(855 L2 ⓑ) · 없음 = None."""
sk = isinstance(doc, dict) and doc.get("종류") == sd.TITLE
if has(doc):
return doc[KEY]
return _plain(doc[KEY]) if sk else doc[KEY]
form = doc.get(FORM) if isinstance(doc, dict) else None
if isinstance(form, dict) and isinstance(form.get("로직"), list):
return {k: form[k] for k in VALUES if k in form}
got = {k: form[k] for k in VALUES if k in form}
return _plain(got) if sk else got
return None
@@ -327,7 +344,7 @@ def settle(doc: Any, save: bool = False) -> Any:
if save and copy and READS.get() is None: # 읽은 줄만(826-3) = 저장 관문이 더함
copy = grow(copy, stamp(out))
out = _formula_job(out, job)
return {**out, KEY: copy} if copy else out
return {**out, KEY: _plain(copy)} if copy else out # 로직 줄 안 담음(855 L2 ⓑ)
def _formula_job(out: dict, job: Any) -> dict:
@@ -340,7 +357,14 @@ def _formula_job(out: dict, job: Any) -> dict:
if got is None or job not in (PRICE, REGEN):
return out
if job == REGEN: # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2)도 버림
drop = ("문서", "끊음", "따로", "처음", *renew.KEEP)
drop = (
"문서",
"끊음",
"따로",
"처음",
"바탕문서",
*renew.KEEP,
) # 바탕문서 = 프로젝트 굳힘(855 L2 ⓑ)
got = {k: v for k, v in got.items() if k not in drop} | {"부름": {}}
elif got.get("따로"):
got = dc.refresh(got)[0]
@@ -373,7 +397,22 @@ def mark(ans: dict, doc: dict) -> dict:
return ans
copy = doc[KEY]
head = {"시점": copy.get("시점"), "단가시점": copy.get("단가시점")}
return {**ans, KEY: {**head, **state(copy, whole_())}}
got = state(copy, whole_())
if not got["M01새판"] and _doc_moved(doc):
got = {**got, "M01새판": True}
return {**ans, KEY: {**head, **got}}
def _doc_moved(doc: dict) -> bool:
"""M01 바뀜 = 수식 사본 문서(부름 · 원본) 지문 ≠ 지금 M01 문서(855 L2 ⓑ · 로직 줄 값 사본 대신) ·
자동 따라옴 SK = 늘 지금 문서라 안 봄."""
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
form = doc.get(FORM)
if not dc.has(doc) or (renew.is_sk(doc) and renew.on() and not renew.frozen(form)):
return False
return bool(dc.state(form)["문서새판"])
def same_part(doc: Any) -> str | None:
@@ -382,5 +421,5 @@ def same_part(doc: Any) -> str | None:
if copy is None:
return None
seen = state(copy, whole_())
fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"])
fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"] or _doc_moved(doc))
return None if fresh else f"{copy.get('판')}:{copy.get('단가판')}"
+3 -4
View File
@@ -352,7 +352,7 @@ def clean(doc: Any, base_row: dict | None = None, whole: Any = None) -> dict[str
if len(set(drop)) != len(drop):
raise DocError("뺀줄에 같은 줄 두 번")
out |= {"뺀더한줄": gone} if (gone := _gone_adds(doc.get("뺀더한줄"), whole)) else {}
return const.clean_more(doc, out) # 새 덮개 칸(790-2)
return const.clean_more(doc, out) # 글 칸(790-2) · 옛 식 칸 막음(855 2-E2)
def is_rate(one: Any) -> bool:
@@ -440,7 +440,7 @@ def _covered(item: dict, cover: dict, extra: bool) -> tuple[dict, str | None]:
def _add_item(one: dict) -> dict:
"""더한줄 → 엔진 호표 줄 — 참조 · 고정 줄 `값묶음` 은 셈(`M02_Sangeun_Calc`)이 채움."""
head = {"이름": one.get("이름") or "", "단위": one.get("단위") or ""}
qty = one.get("수량식") or text(one["수량"]) # 수량식(792-1) = 엔진 식(`fx.settle` 이 바꿈)
qty = text(one["수량"])
if "참조" in one or "고정" in one:
kept = {k: one[k] for k in ("참조", "고정") if k in one}
if is_rate(one): # 율 줄(778-4) = 그 비목 한 칸(엔진 묶음 · 보기 상자 = 비목)
@@ -464,12 +464,11 @@ def patched(
`picks` · `shown` = 바탕 쪽 차례 열쇠 고름 · 자재표시(바탕 SK 사슬) → 새 차례로 옮김.
돌려줌 = {줄, 고름 {차례: MT}, 자재표시 {차례: 칸}, 정체 [새 줄 cid · 더한줄 = `add:#k`],
짝잃음 [{cid, 까닭}]}."""
row, bad, doc = const.formulas_lost(row, doc) # 식 칸(792-1) · 상수 · 표값 덮개(790-2)
items, extras = list(row.get("호표") or []), list(row.get("덧줄") or [])
ids = line_ids(row)
covers, drop = doc.get("덮개") or {}, set(doc.get("뺀줄") or [])
mine, marks = doc.get("고름") or {}, doc.get("자재표시") or {}
lost = bad + [
lost = [
{"cid": c, "까닭": "뺀줄 — 바탕에 없는 줄"} for c in doc.get("뺀줄") or [] if c not in ids
]
new_items, new_extras, cids, out_picks, out_marks = [], [], [], {}, {}
+5 -258
View File
@@ -1,22 +1,11 @@
"""M02 단가산출(SK) 사용자 식 칸(PLAN 792-1 · 요구서_652 1 장 3 · _분석_650-H3 E4) — 변수 줄 ·
식 덮개 · 더한줄 수량식 · 이름 꼴 ↔ 엔진 식 · 검사(「덮개 = 숫자만」 원칙을 바꿈).
"""M02 단가산출 식 글 번역(PLAN 792-1 · 855 2-E2) — 이름 꼴 ↔ 엔진 식 · 식 글 상한.
시험 `resources/tester/test_792_1_sangeun_formula.py` · 799-2 — 화면 짝(`Formula_Model.ts` · 시트 탭)은 걷음, 서버만 남음.
문서 덧칸(없으면 안 둠 — 옛 SK 그대로 · 저장 = 엔진 식 · 이름 꼴 글도 받아 서버가 번역):
변수줄 [{이름, 식, 표시?, 자리}] 엔진 중간 줄로 끼움 · 자리 = 그 뒤 중간 `mid:이름`
("" = 맨 위 · 없는 자리 = 중간 끝 + 짝잃음) · 표시 = 엔진 `표시`(0~6 반올림)
식덮개 {자리: 식} 중간 `mid:이름` 식 · 호표 cid 수량 · 덧줄 cid 식
(원래 식 = 바탕 · M01 바뀜 = 790-2 M01판)
더한줄[k].수량식 인력 · 재료 · 기계 · 참조 · 고정(율 줄 빼고) · `수량` = 보기 값
M01 수식 탭(`M01_MasterData_Equation`) · 가져온 식(`M02_Sangeun_Imported`)이 부름.
이름 꼴 — `×` `÷`(= `*` `/`) · `[노임 형틀목공]`(요소 · 겹치면 키 덧붙임) · `[별칭]`(바탕 줄
`찾기` · `로직` 부르기 = `master_copy.aliases` · 별칭표는 바탕 줄에서만 지음 = 사용자 고침에
안 흔들림) · 맨 이름 = 입력 · 중간 · 변수 · 덧줄 · 비목 · 엔진 날식도 그대로 받음.
셈 = `settle`(바탕 줄 + 식 칸 → 엔진 줄 · `M02_Sangeun_Const.formulas` 첫머리 → `patched` →
`_Over` 로 같은 엔진 한 벌 · B09 굳힘 `GX9#####` 도 그 줄) · 틀린 식 = 그 자리만 M01 식으로 +
짝잃음(셈 길) · 저장(`strict`) = 400.
보안 — eval 없음(엔진 파서만) · 식 길이 `LONG` · 괄호 깊이 `DEEP` · 변수 줄 `MANY` ·
로직 부르기 깊이 20(엔진).
옛 SK 식 칸(변수줄 · 식덮개 · 더한줄 수량식)은 셈 은퇴(855 2-C1) 뒤 받지 않음(`M02_Sangeun_Const.clean_more` · 855 2-E2).
보안 — eval 없음(엔진 파서만) · 식 길이 `LONG` · 괄호 깊이 `DEEP`.
"""
from __future__ import annotations
@@ -26,13 +15,8 @@ import json
import re
from typing import Any
from M02_MasterTemplete import M02_Sangeun_Doc as sd
FIELDS = ("변수줄", "식덮개")
LONG = 300 # 식 글 길이
DEEP = 12 # 괄호 깊이
MANY = 100 # 변수 줄 수
FIELD = {"중간": "식", "호표": "수량", "덧줄": "식"}
WORD = {
"LB": "노임",
"EQ": "기계",
@@ -42,9 +26,6 @@ WORD = {
"FX": "환율",
"RT": "요율",
}
_VAR = re.compile(r"^[A-Za-z가-힣_][\w가-힣]{0,19}$")
_ADD = re.compile(r"^add:#(\d+)$")
_SPOT = re.compile(r"^(mid:.+|(labor|material|machine|logic|pct):.*#\d+)$")
def _eng() -> Any:
@@ -59,7 +40,7 @@ def _whole() -> Any:
return m01.loaded()[1]
# ── 꼴 검사(문서 · `sd.clean` 끝) ─────────────────────────────────────
# ── 식 글 상한 ────────────────────────────────────────────────────────
def limits(text: str) -> list[str]:
"""식 글 상한 — 길이 · 괄호 깊이(파서 앞 · 깊은 괄호 = 서버 500 막음)."""
out, depth, top, quoted = [], 0, 0, False
@@ -78,75 +59,6 @@ def limits(text: str) -> list[str]:
return out
def _text(raw: Any, where: str) -> str:
got = str(raw if raw is not None else "").strip()
if not got:
raise sd.DocError(f"{where} · 식이 빔")
if bad := limits(got):
raise sd.DocError(f"{where} · {bad[0]}")
return got
def clean(raw: dict, out: dict) -> dict:
"""`sd.clean` 끝(790-2 `clean_more` 뒤) — 변수줄 · 식덮개 · 더한줄 수량식 꼴 · 상한 · 겹침."""
lines = raw.get("변수줄") or []
if not isinstance(lines, list) or len(lines) > MANY:
raise sd.DocError(f"변수줄 · {MANY} 줄까지 목록")
got, seen = [], set()
for at, one in enumerate(lines, 1):
one = one if isinstance(one, dict) else {}
name, where = str(one.get("이름") or "").strip(), f"변수줄 {at}째"
if not _VAR.match(name) or _eng().mk.KEY.fullmatch(name):
raise sd.DocError(f"{where} · 이름 꼴 아님 「{name}」(글자로 시작 · 20 자까지)")
if name in seen:
raise sd.DocError(f"{where} · 같은 이름 「{name}」")
seen.add(name)
line = {"이름": name, "식": _text(one.get("식"), f"{where} 「{name}」")}
if one.get("표시") not in (None, ""):
show = sd._num(one["표시"], f"{where} 표시")
if show != int(show) or not 0 <= show <= 6:
raise sd.DocError(f"{where} · 표시는 0~6 자리")
line["표시"] = int(show)
spot = str(one.get("자리") or "")
if spot and not spot.startswith("mid:"):
raise sd.DocError(f'{where} · 자리는 중간 `mid:이름` · 맨 위 ""')
got.append(line | {"자리": spot})
if got:
out["변수줄"] = got
covers = raw.get("식덮개") or {}
if not isinstance(covers, dict):
raise sd.DocError("식덮개 · 묶음 아님")
fx = {}
for spot, text in covers.items():
if not isinstance(spot, str) or not _SPOT.match(spot):
raise sd.DocError(f"식덮개 · 자리 꼴 아님 「{spot}」")
if spot in (out.get("상수덮개") or {}) or spot in (out.get("표값덮개") or {}):
raise sd.DocError(f"식덮개 「{spot}」 · 상수 · 표값 덮개와 같이 못 둠")
if "qty" in ((out.get("덮개") or {}).get(spot) or {}):
raise sd.DocError(f"식덮개 「{spot}」 · 품 덮개(qty)와 같이 못 둠 — 식에 넣을 것")
fx[spot] = _text(text, f"식덮개 「{spot}」")
if fx:
out["식덮개"] = fx
adds = raw.get("더한줄") or []
for k, one in enumerate(out.get("더한줄") or []):
text = adds[k].get("수량식") if k < len(adds) and isinstance(adds[k], dict) else None
if text in (None, ""):
continue
where = f"더한줄 {k + 1}째 수량식"
if sd.is_rate(one) or one.get("종류") == "로직":
raise sd.DocError(f"{where} · 율 줄 · 로직 줄은 수만")
one["수량식"] = _text(text, where)
return out
def has(doc: Any) -> bool:
"""식 칸을 쓰는 문서."""
if not isinstance(doc, dict):
return False
adds = [x for x in doc.get("더한줄") or [] if isinstance(x, dict)]
return any(doc.get(k) for k in FIELDS) or any(x.get("수량식") for x in adds)
# ── 이름 꼴 ↔ 엔진 식 ────────────────────────────────────────────────
@functools.lru_cache(maxsize=2)
def _labels(whole: Any) -> tuple[dict, dict]:
@@ -291,168 +203,3 @@ def _unmask(text: str, raw_of: dict) -> str:
def _names(row: dict) -> set[str]:
return {str(x.get("이름")) for k in ("입력", "중간", "덧줄") for x in row.get(k) or []}
# ── 바탕 줄 + 식 칸 → 엔진 줄 ──────────────────────────────────────────
def _places(row: dict) -> dict[str, tuple[str, int]]:
from M02_MasterTemplete import M02_Sangeun_Const as const
return const.places(row)
def _bad(spot: str, why: str) -> dict:
return {"cid": spot, "까닭": f"식 — {why}"}
def settle(row: dict, doc: dict, strict: bool = False) -> tuple[dict, list[dict], dict]:
"""바탕 줄 + 식 칸 → (엔진 줄, 틀린 자리 [{cid, 까닭}], 엔진 식으로 바꾼 문서) · 틀린 자리 =
M01 식(변수 = 뺌 · 수량식 = 수) · `strict` = 하나라도 틀리면 `DocError`(저장)."""
if not has(doc):
return row, [], doc
where, bad, gone = _places(row), [], []
covers, lines, adds = {}, [], [dict(x) for x in doc.get("더한줄") or []]
for spot, text in (doc.get("식덮개") or {}).items():
got, why = to_engine(text, row)
if spot not in where:
gone.append(_bad(spot, "바탕에 없는 줄"))
elif why:
bad += [_bad(spot, w) for w in why]
else:
covers[spot] = got
taken, mf = _names(row), _eng()
for one in doc.get("변수줄") or []:
spot, (got, why) = f"mid:{one['이름']}", to_engine(one["식"], row)
if one["이름"] in taken or one["이름"] in _reserved():
bad.append(
_bad(spot, f"이름 「{one['이름']}」 이 이미 있음(입력 · 중간 · 덧줄 · 예약)")
)
elif why:
bad += [_bad(spot, w) for w in why]
else:
lines.append({**one, "식": got})
for k, one in enumerate(adds):
if one.get("수량식"):
got, why = to_engine(one["수량식"], row)
bad += [_bad(f"add:#{k}", w) for w in why]
if why:
one.pop("수량식")
else:
one["수량식"] = got
while True: # 틀린 자리를 빼면 다른 자리가 틀릴 수 있음 — 더 안 틀릴 때까지
out, lost = _build(row, covers, lines)
more = _check(out, covers, lines, adds, mf)
if not more:
break
bad += more
hit = {b["cid"] for b in more}
covers = {s: v for s, v in covers.items() if s not in hit}
lines = [x for x in lines if f"mid:{x['이름']}" not in hit]
for k in [int(_ADD.match(c)[1]) for c in hit if _ADD.match(c)]:
adds[k].pop("수량식", None)
if strict and bad: # 짝 잃음(바탕에 없는 줄 · 자리)은 알림만 — [M01 원래로] 로 걷음
raise sd.DocError(f"「{bad[0]['cid']}」 {bad[0]['까닭']}")
fixed = {k: v for k, v in doc.items() if k not in FIELDS} | {"더한줄": adds}
fixed |= ({"식덮개": covers} if covers else {}) | ({"변수줄": lines} if lines else {})
return out, bad + gone + lost, fixed
@functools.cache
def _reserved() -> frozenset:
mf = _eng()
return frozenset(
(*mf.FUNCS, *mf.COST_ITEMS, "찾기", "로직", "그리고", "또는", "계", "줄", "번지", "단계")
)
def _build(row: dict, covers: dict, lines: list[dict]) -> tuple[dict, list[dict]]:
"""식 덮개를 바탕 칸에 · 변수 줄을 자리 뒤에 끼움(같은 자리 = 넣은 차례)."""
out = {**row, **{k: list(row.get(k) or []) for k in FIELD}}
for spot, (part, at) in _places(row).items():
if spot in covers:
out[part][at] = {**out[part][at], FIELD[part]: covers[spot]}
mids, after, lost = out["중간"], {}, []
for one in lines:
spot = one["자리"]
names = [f"mid:{x.get('이름')}" for x in mids]
if spot and spot not in names:
lost.append(_bad(f"mid:{one['이름']}", f"자리 「{spot}」 없음 — 중간 끝에 둠"))
at = len(mids)
else:
at = after.get(spot, names.index(spot) + 1 if spot else 0)
step = {"이름": one["이름"], "식": one["식"], "변수": True}
mids.insert(at, step | ({"표시": one["표시"]} if "표시" in one else {}))
after = {k: v + (v >= at) for k, v in after.items()} | {spot: at + 1}
return out, lost
def _uses(text: str) -> set[str] | None:
mf = _eng()
try:
return {n[1] for n in mf.walk(mf.parse(text)) if n[0] == "name"}
except (mf.FormulaError, RecursionError):
return None
def _zero(node: tuple, mf: Any) -> bool:
return any(n[0] == "bin" and n[1] == "/" and n[3] == ("num", 0) for n in mf.walk(node))
def _check(row: dict, covers: dict, lines: list, adds: list, mf: Any) -> list[dict]:
"""식 칸 자리만 검사 — 식 · 0 나눔 · 이름(엔진 `_check_node`) · 아래 줄 · 순환."""
inputs = {str(x.get("이름")) for x in row.get("입력") or []}
mids = [str(x.get("이름")) for x in row["중간"]]
deps = {n: (_uses(str(x.get("식"))) or set()) & set(mids) for n, x in zip(mids, row["중간"])}
mine = set(covers) | {f"mid:{x['이름']}" for x in lines}
full = inputs | set(mids)
tail = full | set(mf.COST_ITEMS) | {"줄"} | ({"번지", "단계"} if mf.ms.uses(row) else set())
jobs = [
(f"mid:{n}", str(x["식"]), inputs | set(mids[:i]), n)
for i, (n, x) in enumerate(zip(mids, row["중간"]))
]
jobs = [j for j in jobs if j[0] in mine]
places = _places(row)
for spot, (part, at) in places.items():
if spot in covers and part != "중간":
names = (
tail | {str(x.get("이름")) for x in row["덧줄"][:at]} if part == "덧줄" else full
)
jobs.append((spot, covers[spot], names, None))
jobs += [(f"add:#{k}", x["수량식"], full, None) for k, x in enumerate(adds) if x.get("수량식")]
out = []
for spot, text, known, me in jobs:
try:
node = mf.parse(text)
except (mf.FormulaError, RecursionError) as e:
out.append(_bad(spot, str(e)))
continue
why = ["0 으로 나눔"] if _zero(node, mf) else []
used = {n[1] for n in mf.walk(node) if n[0] == "name"}
for n in sorted(used - known):
if n == me:
why.append(f"순환 — 「{n}」 이 자기 자신을 씀")
elif me and n in deps:
loop = _path(deps, n, me)
why.append(
f"순환 — {' → '.join([me, *loop])}"
if loop
else f"「{n}」 은 아래 줄 — 위로 옮길 것"
)
found: list[str] = []
mf._check_node(row, node, known | (used & set(mids)), _whole(), "", found, set())
why += [w.lstrip(" ·") for w in found]
out += [_bad(spot, w) for w in why]
return out
def _path(deps: dict, start: str, goal: str) -> list[str] | None:
"""`start` 에서 `goal` 로 가는 의존 길(있으면 순환)."""
seen, todo = {start}, [[start]]
while todo:
path = todo.pop()
if path[-1] == goal:
return path
for nxt in sorted(deps.get(path[-1], ())):
if nxt not in seen:
seen.add(nxt)
todo.append([*path, nxt])
return None
@@ -92,11 +92,6 @@ def hourly_of(key: str) -> dict:
return _HOURLY["rows"][key]
def row_of(doc: Any) -> None:
"""옛 가져온 줄(엔진 로직 줄) — 857-3b 부터 저장 안 함 · 읽지 않음(늘 None · 2-D 가 부름 걷음)."""
return None
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
+2 -2
View File
@@ -97,9 +97,9 @@ def rows(copy: Any) -> Any:
return {**copy, **hit}
got: dict = {}
for part, mark in (("로직", "판"), ("단가", "단가판")):
old = copy.get(part) or []
old = skc.plain(copy.get(part)) # 로직 줄 = 문서 사본 · 값 사본에 안 둠(855 L2 ⓑ)
new = [_fresh(r, live) if isinstance(r, dict) else r for r in old]
if any(a is not b for a, b in zip(old, new)):
if len(old) != len(copy.get(part) or []) or any(a is not b for a, b in zip(old, new)):
got |= {part: new, mark: skc._fp(new)}
if len(_MEMO) > 64: # ponytail: 통째 비움 · SK 가 많아 느려지면 LRU 로
_MEMO.clear()