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
+4
View File
@@ -22,6 +22,7 @@ import { showToast } from "@ui/ui_template_elements";
import { PART_OF, projectItems, withCopyValues } from "@ui/ui_template_item_picker_project";
import type { EditView } from "@ui/ui_template_item_picker_edit";
import type { LaborDoc } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Api";
import { lineId } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Calc";
import type { ValueDoc } from "../M02_MasterTemplete/M02_Labor_Values_Model";
import type { EditKind, ItemCardsHandle } from "../M02_MasterTemplete/M02_MasterTemplete_ItemCards";
import type { ItemSource } from "../M02_MasterTemplete/M02_MasterTemplete_ItemSource";
@@ -79,6 +80,9 @@ function sourceOf(projectId: string, folder: string): ItemSource {
return { 문서: withCopyValues(labor.줄, values, picks) };
},
calc: () => items.calcLabor(folder),
// 856-3 단가산출 줄 = 사본의 굳힌 SK 문서(`참조사본`) — 줄 쌓기 보기만
sk: async (ref) =>
((await items.read(folder, "일위대가")) as { 참조사본?: Record<string, Record<string, unknown>> } | null)?.참조사본?.[lineId({ 참조: ref }) ?? ""] ?? null, // prettier-ignore
},
};
}
+14 -9
View File
@@ -80,10 +80,16 @@ def _find(key: str, files: tuple[str, ...] | None = None) -> tuple[str, dict[str
def set_alias(key: str, text: str) -> dict[str, Any]:
"""그 줄 `별칭` 만 바꿔 M01 저장 길로(빈 글 = 칸 없음 · 별칭만이라 정본 개정 확인 안 물음)."""
file, _ = _find(key)
data, version = store.read(file)
row = dict(next(r for r in data["줄"] if str(r.get("키")) == key))
"""그 줄 `별칭` 만 바꿔 M01 저장 길로(빈 글 = 칸 없음 · 별칭만이라 정본 개정 확인 안 물음) ·
단가산출 기초 = 문서 머리(855 L3 ⓐ · `Store_Logic`)."""
doc = store._docs().docs().get(key)
if doc is not None:
file = store._docs().find(key)[0]
version, row = store._docs().file_version(file), store._docs().head_of(doc)
else:
file, _ = _find(key)
data, version = store.read(file)
row = dict(next(r for r in data["줄"] if str(r.get("키")) == key))
row[ALIAS] = text
change = {"op": "edit", "key": key, "row": row}
make.save([{"file": file, "version": version, "changes": [change]}], True)
@@ -109,11 +115,10 @@ def board() -> dict[str, Any]:
(str(v.get("키")), ma.norm(v.get(ALIAS))) for v in book.values() if v.get("상태") == "승인"
}
rows = []
logic = (
store._docs().logic_files()
) # 단가산출 기초 = 수식 문서 머리(855 L2 ⓐ) · 파일 차례는 그대로
for file, data in store.loaded()[0].items():
data = logic.get(file, {}) if data.get("그룹") == "로직" else data
every = {n: d for n, d in store.loaded()[0].items() if d.get("그룹") != "로직"}
every |= store._docs().logic_files() # 단가산출 기초 = 수식 문서 머리(855 L2 ⓐ · L3 ⓐ)
for file in sorted(every): # 파일 이름 차례(마스터 폴더 차례와 같음)
data = every[file]
kind = kind_of(file, str(data.get("그룹") or ""))
for row in data.get("줄") or []:
if not str(row.get(ALIAS) or "").strip():
+24 -37
View File
@@ -48,6 +48,12 @@ def version_of(doc: dict | None) -> str:
return "" if doc is None else store.version_of(ml.dump(doc).encode("utf-8"))
def file_version(logic_file: str) -> str:
"""기초 파일 판(855 L3 ⓐ) — 옛 로직 파일 이름에 짝인 수식 문서 파일 글의 지문 · 없음 = 빈 글."""
path = folder() / ml.file_of(logic_file)
return store.version_of(path.read_bytes()) if path.is_file() else ""
def put(path: Path, data: dict) -> None:
"""수식 문서 파일 한 벌 — 임시 파일 → 교체(원자적) · `_LOCK` 안에서 부름.
마스터만 사본으로 바꾼 시험(`Store.FOLDER` ≠ 정본)이 정본 수식 문서를 쓰지 않게 건너뜀."""
@@ -152,18 +158,15 @@ def _check(doc) -> dict:
def read(key: str) -> dict:
"""기초마다 문서가 늘 있음(855 L3 ⓐ — 만들 때 문서부터) · 없는 키 = 404."""
found = docs().get(key)
fresh = found is None
if fresh: # 로직 줄은 있고 문서가 없는 키(옛 자료 받침 — 새 로직은 `ensure` 가 문서를 둠)
row = _row(key)
if row is None:
raise store.StoreError(404, f"없는 로직 「{key}」")
found = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원"))
if found is None:
raise store.StoreError(404, f"없는 로직 「{key}」")
out = _run(found)
up = None if fresh else built(key)
up = built(key) # ponytail: 빌더 문서(층바탕) — 로직 JSON 이 없으면 None · 둘째 박자에서 걷음
more = {"층바탕": {"위": up}} if up is not None else {}
판 = version_of(None if fresh else found) # 저장 때 대조(다른 곳에서 바뀌면 409)
return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, "판": 판, **more}
판 = version_of(found) # 저장 때 대조(다른 곳에서 바뀌면 409)
return {"문서": found, **out, "파일": _where(key) or "", "새": False, "판": 판, **more}
def preview(doc: dict, given: dict | None = None) -> dict:
@@ -171,24 +174,15 @@ def preview(doc: dict, given: dict | None = None) -> dict:
def _file_for(key: str) -> str:
"""문서 파일 — 있던 파일 › 로직 줄이 든 로직 파일 짝(쓰기 짝 · L3 에서 걷음) › 자체."""
have = _where(key)
if have:
return have
for name, data in store.loaded()[0].items():
if data.get("그룹") == "로직" and any(
str(r.get("키")) == key for r in data.get("줄") or []
):
return ml.file_of(name)
return OWN_FILE
"""문서 파일 — 있던 파일 › 자체(새 기초는 자체에만 · 855 L3 ⓐ)."""
return _where(key) or OWN_FILE
def _new_file(name: str) -> dict:
"""새 문서 파일 머리 — 짝 로직 파일의 이름 · 머리(원문 · 부문 · 차례)를 그대로(목록 분류 정본)."""
"""새 문서 파일 머리 — 자체 문서 파일만 새로 생김(원문 = 자체 · 목록 분류 정본)."""
logic = "로직_" + name.split("_", 1)[1]
head = store.loaded()[0].get(logic) or {}
tags = {k: head[k] for k in md.FILE_TAGS if k in head}
return {"그룹": "수식문서", "로직파일": logic if head else "", **tags, "줄": []}
tags = {"원문": "자체"} if name == OWN_FILE else {}
return {"그룹": "수식문서", "로직파일": logic, **tags, "줄": []}
def _row(key: str) -> dict | None:
@@ -345,14 +339,14 @@ def save(doc: dict, 판: str | None = None) -> dict:
doc = _check(doc)
key = str(doc["키"]).strip()
with _LOCK:
if (row := _row(key)) is not None: # 이름표 = 로직 줄 것(화면 왕복에 안 지워짐 · 855 L1)
doc = md.tag(doc, row)
doc = layered(doc, key)
name = _file_for(key)
path = folder() / name
data = ml.load_file(path) if path.exists() else _new_file(path.name)
rows = data.setdefault("줄", [])
at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None)
if at is not None: # 이름표 = 저장된 문서 것(화면 왕복에 안 지워짐 · 고침은 기초 [저장] 길)
doc = md.tag(doc, rows[at])
doc = layered(doc, key)
if 판 is not None and version_of(None if at is None else rows[at]) != 판:
raise store.StoreError(409, STALE.format(v=f"{name} {key}"))
if at is None:
@@ -428,15 +422,8 @@ def drop(key: str) -> None:
def remove(key: str, file: str, version: str, confirmed: bool) -> dict:
"""로직 지우기 — 부르는 곳이 있으면 409 {쓰는곳} · 로직 저장 길(개정 확인 · 판 · 검사) 뒤 문서도."""
from M01_MasterData import M01_MasterData_Store_Make as make
"""로직 지우기 — 기초 저장 길(`Store_Logic` — 쓰는 곳 409 · 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기)."""
from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 그 파일이 이 파일을 부름 — 늦게
used = users(key)
if used:
raise store.StoreError(409, {"쓰는곳": used})
got = make.save(
[{"file": file, "version": version, "changes": [{"op": "delete", "key": key}]}],
confirmed,
)
drop(key)
return got
part = {"file": file, "version": version, "changes": [{"op": "delete", "key": key}]}
return logic_store.save([part], confirmed)
+9 -30
View File
@@ -11,7 +11,6 @@ M01 에서 만든 기계(출처 모두 「자체」)를 지우면 그 번호 기
from __future__ import annotations
import copy
from decimal import Decimal
from typing import Any, Callable
@@ -118,20 +117,10 @@ def formula(row: dict) -> dict:
return base | ({"키": got["키"], "이름": got.get("이름")} if got else {})
def _family_files() -> dict[str, str]:
"""기계경비식 키 → 로직 파일 이름."""
return {
str(r.get("키")): name
for name, data in store.loaded()[0].items()
if data.get("그룹") == "로직" and "건설기계" in name
for r in data.get("줄") or []
}
def register(batch: list[dict]) -> Callable[[], None]:
"""[새 기계] 저장 = 꼴 식 「기계」 목록에 그 원문번호 더함 · M01 에서 만든 기계(출처 모두 「자체」)를
지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 로직 파일 고침을 같은 저장 묶음에 붙임(정본 저장 길) ·
돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록에도 같은 더함 · 뺌(848-5 · 두 목록 한 벌)."""
지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록(정본 ·
848-5)에 더함 · 뺌 + 옛 로직 줄 고르기 같이 쓰기(`Store_Logic.mirror` · 855 L3 ⓐ)."""
from M02_MasterTemplete import M02_Machine_Hourly as mh # M02 가 M01 을 부름 — 늦게
from M02_MasterTemplete import M02_MyMachine as mym
@@ -162,23 +151,13 @@ def register(batch: list[dict]) -> Callable[[], None]:
drop.add(code)
if not add and not drop:
return lambda: None
files = _family_files()
for name in dict.fromkeys(files.values()):
changes = []
for logic in store.read(name)[0].get("줄") or []:
ins = logic.get("입력") or []
pick = next((i for i in ins if i.get("이름") == "기계" and "고르기" in i), None)
if pick is None:
continue
codes = [c for c in pick["고르기"] if str(c) not in drop]
codes += [c for c in add.get(str(logic["키"]), []) if c not in codes]
if codes != pick["고르기"]:
new = copy.deepcopy(logic)
next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes
changes.append({"op": "edit", "key": logic["키"], "row": new})
if changes:
batch.append({"file": name, "version": store.read(name)[1], "changes": changes})
after = lambda: _register_docs(add, drop) # noqa: E731
def after() -> None:
from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 늦게(서로 부름)
_register_docs(add, drop)
logic_store.mirror([], (add, drop))
after.lists = (
add,
drop,
+9 -40
View File
@@ -48,26 +48,14 @@ class SaveBody(BaseModel):
class CopyLogic(BaseModel):
"""[복사/생성](본떠 만들기) — 원본 문서를 새 자체 기초로 · 빈 글 = 원본 그대로."""
key: str
이름: str = ""
owner: str = make.OWNERS[0]
class FormulaLogic(BaseModel):
"""복사해서 만들기 — 별칭 꼴 식이 든 로직 줄과 그 별칭표(되돌릴 원문)."""
로직: dict[str, Any]
별칭: list[dict[str, Any]] = []
owner: str = make.OWNERS[0]
이름: str = ""
본뜬키: str = ""
class FormulaPreview(BaseModel):
"""저장 전 미리보기 — 별칭을 원문으로 되돌린 로직 줄만 받고 싶을 때(시험 계산 전)."""
로직: dict[str, Any]
별칭: list[dict[str, Any]] = []
원문번호: str = ""
결과단위: str = ""
출처: str = ""
def _num(v):
@@ -248,27 +236,8 @@ def post_save(body: SaveBody) -> dict:
@router.post("/logic/copy")
def post_logic_copy(body: CopyLogic) -> dict:
return _call(make.logic_copy, body.key, body.이름, body.owner)
@router.get("/logic/formula")
def get_logic_formula(key: str) -> dict:
"""복사해서 만들기 — 로직 한 줄을 별칭 꼴 식 묶음으로."""
return _call(make.logic_formula, key)
@router.post("/logic/formula/save")
def post_logic_formula_save(body: FormulaLogic) -> dict:
"""고친 식 묶음을 자체 로직(`GX`)으로 — 별칭은 원문으로 되돌려 저장."""
return _call(make.logic_from_formula, body.로직, body.별칭, body.owner, body.이름, body.본뜬키)
@router.post("/logic/formula/preview")
def post_logic_formula_preview(body: FormulaPreview) -> dict:
"""저장 전 시험 계산용 — 별칭을 원문으로 되돌린 로직 줄 + 저장하면 지을 수식 문서
{logic, 문서}(저장 안 함 · 화면은 `문서` 를 `/logic/doc/preview` 로 셈 · 855 2-B4)."""
got = _call(make.logic_formula_preview, body.로직, body.별칭)
return {**got, "문서": doc_screen.of_row(got["logic"])}
more = {"원문번호": body.원문번호, "결과단위": body.결과단위, "출처": body.출처}
return _call(make.logic_copy, body.key, body.이름, body.owner, more)
# ── 수식 문서(802-3) — 단가산출 기초 정본 · 화면은 같은 계산기로 즉시 셈 ──
@@ -280,7 +249,7 @@ class DocBody(BaseModel):
@router.get("/logic/doc")
def get_logic_doc(key: str) -> dict:
"""수식 문서 {문서, 셈, 연결, 파일, 새} — 없으면 빈 문서(쓰기 없음)."""
"""수식 문서 {문서, 셈, 연결, 파일, 새} — 없는 키 = 404(쓰기 없음)."""
return _call(doc_screen.read, key)
@@ -311,7 +280,7 @@ def get_logic_users(key: str) -> dict:
@router.post("/logic/remove")
def post_logic_remove(body: RemoveBody) -> dict:
"""로직 지우기(804-7) — 로직 줄 + 수식 문서 · 부르는 곳 있으면 409 {쓰는곳}."""
"""로직 지우기(804-7) — 수식 문서(+ 옛 로직 줄 같이 쓰기) · 부르는 곳 있으면 409 {쓰는곳}."""
return _call(doc_screen.remove, body.key, body.file, body.version, body.개정확인)
+12 -50
View File
@@ -21,7 +21,6 @@ sys.path.insert(0, str(SCRIPTS))
import check_master as cm # noqa: E402
import master_auto as mau # noqa: E402,F401 (M02 `Sangeun_Calc` · `Labor_Doc` · `Labor_Inputs` · B09 `Sangeun` 가 `store.mau` 로 씀)
import master_combo as mcb # noqa: E402,F401 (`_Store_Combo` 가 `store.mcb` 로 씀)
import master_copy as mcp # noqa: E402,F401 (`_Store_Make` 가 `store.mcp` 로 씀)
import master_keys as mk # noqa: E402
import master_text as mtx # noqa: E402,F401 (B09 `Sangeun_Text` · M02 `Logic_Settle` 가 `store.mtx` 로 씀)
@@ -116,7 +115,7 @@ def _docs():
def files_of(group: str) -> list[dict]:
"""로직 = 수식 문서 파일(855 L2 ⓐ) · 판(해) · version 은 로직 파일(저장 409 짝 · L3 에서 문서로)."""
"""로직 = 수식 문서 파일(855 L2 ⓐ) · 판 = 문서 파일 머리 · version = 문서 파일 글 지문(855 L3 ⓐ)."""
if group not in cm.mf.GROUPS:
raise StoreError(404, f"없는 그룹 「{group}」")
logic = _docs().logic_files() if group == "로직" else None
@@ -124,8 +123,12 @@ def files_of(group: str) -> list[dict]:
for name in sorted(logic) if logic is not None else cm.mmf.names(FOLDER):
if name != f"{group}.json" and not name.startswith(f"{group}_"):
continue
data, version = read(name)
head = data if logic is None else logic[name]
if logic is None:
data, version = read(name)
head = data
else:
data = head = logic[name]
version = _docs().file_version(name)
out.append(
{
"file": name,
@@ -390,21 +393,16 @@ def logics(sub: str, detail: str, q: str, blocked: int | None, owner: str = "")
def logic(key: str) -> dict:
"""로직 하나 — 키는 전체에서 하나 · 있는지 · 파일 · 이름표 = 수식 문서(855 L2 ⓐ) · 셈 칸(입력 · 호표 …)
· `prices` · `version` = 로직 파일(옛 상세 몸 · 저장 짝 — 856 · L3 에서 걷음)."""
files, whole = loaded()
"""로직 하나 — 키는 전체에서 하나 · 파일 · `logic` = 수식 문서 머리(키 · 이름표 · 이름 · 결과단위 · 출처 ·
부품 — 화면 [저장]이 이 칸만 되돌려 보냄 · 셈은 줄 쌓기 문서) · `version` = 문서 파일 판(855 L3 ⓐ)."""
name, doc = _docs().find(key)
row = next((r for r in (files.get(name) or {}).get("줄") or [] if str(r.get("키")) == key), {})
head, named = _docs().head_of(doc), (*_docs().md.TAGS, *_docs().HEAD)
row = {k: head.get(k, v) for k, v in row.items() if k in head or k not in named} | head
reasons = cache.reasons(key, whole) # 수식 문서 기준(855 2-B3)
reasons = cache.reasons(key, loaded()[1]) # 수식 문서 기준(855 2-B3)
return {
"file": name,
"version": read(name)[1],
"logic": row,
"version": _docs().file_version(name),
"logic": _docs().head_of(doc),
"blocked": bool(reasons),
"reasons": reasons,
"prices": _prices(whole, row),
}
@@ -418,42 +416,6 @@ def _brief(ref: str, row: dict) -> dict:
}
def _pick_brief(whole, cond: dict, unit: str | None = None) -> dict | None:
"""고르기 조건 줄의 단가 미리보기 — 후보 수와 시험 계산이 쓸 줄(값 열 다섯 포함).
`unit` = 호표 줄 단위 — 후보를 같은 단위 줄로만 거름."""
try:
keys = cm.mf.candidates(whole, cond, {}, unit)
brief = _market_brief(whole.get(cm.mf.pick(whole, cond, {}, unit)))
except (cm.mf.FormulaError, KeyError, TypeError):
return None
return {**brief, "조건": cond, "후보": len(keys)}
def _prices(whole, row: dict) -> dict:
"""호표 요소 → 요소 줄 요약(단가 자동 칸) · `{이름}` 낀 원문번호·하위 로직은 계산 때 정해짐.
품셈재료는 연결을 따라간 낮은 값과 출처 · 자재지역 후보는 계산 때 정해짐(값 None).
재료 고르기 조건 줄은 열쇠가 조건 글(`구분|상세구분|규격|대표`) · 값 = 시험 계산이 쓸 줄."""
out = {}
for item in row.get("호표") or []:
if isinstance(item.get("요소"), dict):
out[cm.mf.cond_text(item["요소"])] = _pick_brief(whole, item["요소"], item.get("단위"))
continue
ref = str(item.get("요소", ""))
if item.get("종류") != "로직" and "{" not in ref:
try:
out[ref] = _brief(ref, whole.get(ref))
except cm.mf.FormulaError:
out[ref] = None
continue
if ref[:2] == cm.mf.LINKED:
try:
value, source = cm.mf.element(whole, ref, {})
except (cm.mf.FormulaError, KeyError, TypeError):
value, source = None, None
out[ref].update({"값": value, "출처": source})
return out
def elements(group: str, q: str, limit: int) -> dict:
"""요소 찾기 창 — 그룹 전체에서 키·원문번호·이름 찾기 · `ref` 는 식에 그대로 넣는 키."""
if group not in cm.mf.GROUPS:
+7 -2
View File
@@ -330,10 +330,11 @@ def _labor_files() -> list[tuple[str, Path]]:
]
def labor_errors(whole, keys=None) -> list[str]:
def labor_errors(whole, keys=None, have=None) -> list[str]:
"""일위대가 · 사전조합 문서가 담은 로직 마스터에 없음(39-1d · 50-3) —
로직 지우기를 막음 · 어디서 쓰는지 알림 · 참조 줄(로직 없음)은 건너뜀. 전부터 깨진 것은
`save` 가 고치기 전 검사와 견주어 뺌. `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶)."""
`save` 가 고치기 전 검사와 견주어 뺌. `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶) ·
`have` = 있는 기초 키(저장 뒤 문서 · 855 L3 ⓐ — 주면 `whole` 대신)."""
out = []
if keys is not None and not keys:
return out
@@ -350,6 +351,10 @@ def labor_errors(whole, keys=None) -> list[str]:
key = str(one.get("로직") or "") if isinstance(one, dict) else ""
if not key or (keys is not None and key not in keys):
continue
if have is not None:
if key not in have:
out.append(f"{where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌")
continue
try:
whole.logic(key)
except cm.mf.FormulaError:
@@ -0,0 +1,267 @@
"""M01 단가산출 기초 저장 — 수식 문서가 정본(PLAN 855 L3 ⓐ · 요구 898).
화면 [저장](`/save` 의 로직 파일 몫) · [신규] · [본떠 만들기] · [복사/생성] · [삭제] · 별칭이 이 길로.
- 판 = 문서 파일 글 지문(`Doc.file_version`) — 다르면 409 {stale}
- 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`)
- 키 = 대장(`_키대장.json` · 자체 GX 다음 번호) · 검사 = 문서(쓰는 곳 · 일위대가 담은 로직 · 키 겹침 · 대장)
- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`)
화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫.
"""
from __future__ import annotations
import copy
import os
from pathlib import Path
from common_util.common_util_time import kst_today
from M01_MasterData import M01_MasterData_Doc as doc_store
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Revise as revise
from M01_MasterData.M01_MasterData_Store_Shape import dump, keep_shape
md, ml, mk, cm = doc_store.md, doc_store.ml, store.mk, store.cm
#: 로직 줄 같이 쓰기 — M02 · B09 가 로직 줄을 더 안 읽게 되면(둘째 박자) 끄고 `mirror` 를 지움
WRITE = os.environ.get("AISLO_LOGIC_WRITE", "1") != "0"
OWN = "로직_자체.json"
FIELDS = revise.FIELDS
CALC = {"입력": [], "중간": [], "호표": [], "끝수": None} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음)
def is_logic(file: str) -> bool:
return file.startswith("로직_") and file.endswith(".json")
def head(row: dict) -> dict:
"""화면이 보낸 줄에서 쓸 칸 — 키 · 이름표 · 머리."""
return {k: row[k] for k in FIELDS if k in row}
def _doc_file(file: str) -> Path:
return doc_store.folder() / ml.file_of(file)
def _rows(data: dict) -> list[dict]:
return data.setdefault("줄", [])
def _at(rows: list[dict], key: str) -> int | None:
return next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None)
def _fresh_doc(key: str, row: dict, base: dict | None) -> dict:
"""새 기초 문서 — 원본 문서 복제(본뜸) 또는 빈 문서(출처 = 결과단위 다음) · 이름표 · 머리 = 받은 줄."""
if base is None:
blank = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원"))
items = list(blank.items())
base = {**dict(items[:5]), "출처": row.get("출처"), **dict(items[5:])}
else:
base = {k: v for k, v in copy.deepcopy(base).items() if k != "손고침"}
base["키"] = key
return doc_store._headed(base, {**head(row), "키": key})
def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]:
"""고침 · 더함 · 지움을 문서 파일 사본에 — (문서 파일 → 내용, 같이 쓰기 편집, 더한 키, 지운 키)."""
plan: dict[str, dict] = {}
edits, added, gone = [], [], set()
for part in parts:
file = str(part.get("file") or "")
path = _doc_file(file)
if path.name not in plan:
plan[path.name] = (
copy.deepcopy(ml.load_file(path)) if path.is_file() else doc_store._new_file(path.name)
)
rows = _rows(plan[path.name])
for ch in part.get("changes") or []:
op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row")
if op not in ("edit", "add", "delete"):
raise store.StoreError(400, f"모르는 op 「{op}」")
at = None if op == "add" else _at(rows, key)
if op != "add" and at is None:
raise store.StoreError(404, f"{file} · 없는 키 「{key}」")
if op != "delete" and (
not isinstance(row, dict) or not str(row.get("이름") or "").strip()
):
raise store.StoreError(400, f"{file} · 줄에 「이름」 이 없음")
if op == "edit":
if str(row.get("키")) != key:
raise store.StoreError(400, f"{file} · 키는 바꾸지 않음 「{key}」")
rows[at] = doc_store._headed(rows[at], head(row))
edits.append(("머리", key, doc_store.head_of(rows[at])))
elif op == "add":
if file != OWN:
raise store.StoreError(400, f"새 기초는 {OWN} 에만")
tid = mk.table_id("로직", "자체")
number = str(row.get("원문번호") or "")
key = mk.issue(book, tid, store.ledger_label(book, tid, number, row), file)
source = str(ch.get("from") or "")
base = doc_store.docs().get(source) if source else None
rows.append(_fresh_doc(key, row, base))
edits.append(("더함", key, {"file": file, "row": head(row), "from": source}))
added.append({"file": file, "key": key})
else:
del rows[at]
gone.add(key)
edits.append(("지움", key, None))
return plan, edits, added, gone
def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]:
"""문서 검사 — 일위대가 · 사전조합이 담은 기초가 빠짐 · 키 겹침 · 대장(저장 전에 있던 흠은 뺌)."""
have = dict(doc_store.logic_files())
after = dict(have)
for name, data in plan.items():
logic = str(data.get("로직파일") or "") or "로직_" + name.split("_", 1)[1]
after[logic] = {"그룹": "로직", "줄": data.get("줄") or []}
keys = {str(d.get("키")) for f in after.values() for d in f["줄"]}
old = set(cm.duplicate_keys(have, old_book))
out = [x for x in cm.duplicate_keys(after, book) if x not in old]
return out + store.cache.labor_errors(None, gone, keys)
def save(parts: list[dict], confirmed: bool = False) -> dict:
"""로직 파일 몫 저장 — {files: [{file, version}], added: [{file, key}], warnings}."""
revise.guard(parts, confirmed)
gone_used = {
k: used
for p in parts
for c in p.get("changes") or []
if c.get("op") == "delete" and (k := str(c.get("key") or ""))
and (used := doc_store.users(k))
}
if gone_used:
raise store.StoreError(409, {"쓰는곳": [x for v in gone_used.values() for x in v]})
with doc_store._LOCK:
stale = [
str(p.get("file")) for p in parts
if doc_store.file_version(str(p.get("file"))) != (p.get("version") or "")
] # fmt: skip
if stale:
raise store.StoreError(409, {"stale": stale})
book_path = store.FOLDER / mk.BOOK.name
book = mk.load_book(book_path)
old_book = {"키": dict(book["키"]), "다음": dict(book["다음"])}
plan, edits, added, gone = _plan(parts, book)
mk.finish(book)
if bad := _errors(plan, gone, old_book, book):
raise store.StoreError(422, {"errors": bad})
paths = {n: doc_store.folder() / n for n in plan}
raw = {n: p.read_bytes() for n, p in paths.items() if p.is_file()}
book_raw = book_path.read_bytes() if book["다음"] != old_book["다음"] else None
try:
if book_raw is not None:
mk.save_book(book, book_path)
for name, data in plan.items():
doc_store.put(paths[name], data)
except BaseException:
_undo(paths, raw, book_path, book_raw)
raise
mirror(edits)
files = list(dict.fromkeys(str(p.get("file")) for p in parts))
return {
"files": [{"file": f, "version": doc_store.file_version(f)} for f in files],
"added": added,
"warnings": [],
}
def _undo(paths: dict, raw: dict, book_path: Path, book_raw: bytes | None) -> None:
"""쓰기 중간 실패 — 문서 파일 · 대장을 저장 전 글로(새로 만든 문서 파일은 지움)."""
for name, path in paths.items():
if name in raw:
_put(path, raw[name])
else:
path.unlink(missing_ok=True)
if book_raw is not None:
_put(book_path, book_raw)
doc_store._memo.clear()
def _put(path: Path, data: bytes) -> None:
tmp = path.with_name(f".{path.name}.tmp")
tmp.write_bytes(data)
os.replace(tmp, path)
# ── 옛 로직 줄 같이 쓰기 — 로직 JSON 을 쓰는 단 한 자리(둘째 박자에서 지움) ──────────
def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None:
"""문서에 한 고침을 옛 로직 줄에도 — 머리(이름표 · 이름 · 결과단위 · 출처 · 부품 덮음) ·
더함(본뜬 로직 줄 셈 칸 / 빈 셈 칸) · 지움 · 기계 고르기 목록(`picks` = 더함 · 뺌).
검사 없음(문서가 정본) · 스위치 `WRITE` 가 꺼지면 아무것도 안 함."""
if not WRITE or (not edits and not picks):
return
with store._LOCK:
files = store.loaded()[0]
logic = {n: d for n, d in files.items() if d.get("그룹") == "로직"}
where = {str(r.get("키")): n for n, d in logic.items() for r in d.get("줄") or []}
after = {n: {**d, "줄": list(d.get("줄") or [])} for n, d in logic.items()}
touched: set[str] = set()
for op, key, what in edits:
if op == "더함":
name = what["file"]
if name not in after: # 자체 로직 파일이 없으면 머리만 두고 만듦
after[name] = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []}
src = next((r for r in logic.get(where.get(what["from"], ""), {}).get("줄") or []
if str(r.get("키")) == what["from"]), None) # fmt: skip
calc = {k: copy.deepcopy(v) for k, v in (src or CALC).items() if k not in FIELDS}
after[name]["줄"].append(_ordered({**what["row"], **calc, "키": key}))
where[key] = name
elif (name := where.get(key)) is not None:
rows = after[name]["줄"]
at = _at(rows, key)
if at is None:
continue
if op == "지움":
del rows[at]
else:
rows[at] = _headed_row(rows[at], what)
else:
continue
touched.add(name)
if picks:
touched |= _picks(after, *picks)
for name in touched:
_write(name, logic.get(name), after[name])
store.cache.stale(touched)
def _ordered(row: dict) -> dict:
"""새 로직 줄 칸 차례 — `_틀.md` 2장(`mk.ROW_ORDER`) 다음 나머지."""
order = mk.ROW_ORDER["로직"]
return {**{k: row[k] for k in order if k in row}, **{k: v for k, v in row.items() if k not in order}}
def _headed_row(row: dict, head_: dict) -> dict:
"""로직 줄 머리를 문서 머리와 같게 — 있던 칸은 제자리 · 빠진 머리 칸은 뺌 · 새 칸은 끝(옛 [저장]과 같음)."""
out = {k: head_[k] if k in FIELDS else v for k, v in row.items() if k not in FIELDS or k in head_}
return {**out, **{k: v for k, v in head_.items() if k not in out}}
def _picks(after: dict, add: dict, drop: set) -> set[str]:
"""기계경비식 로직 줄 「기계」 고르기 목록에 더함 · 뺌(문서 `선택 목록` 과 같게 · 848-5)."""
touched = set()
for name, data in after.items():
if "건설기계" not in name:
continue
for at, row in enumerate(data["줄"]):
pick = next((i for i in row.get("입력") or [] if i.get("이름") == "기계" and "고르기" in i), None)
if pick is None:
continue
codes = [c for c in pick["고르기"] if str(c) not in drop]
codes += [c for c in add.get(str(row["키"]), []) if c not in codes]
if codes != pick["고르기"]:
new = copy.deepcopy(row)
next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes
data["줄"][at] = new
touched.add(name)
return touched
def _write(name: str, before: dict | None, after: dict) -> None:
path = store.FOLDER / name
text = None
if before is not None and path.is_file():
text = keep_shape(path.read_bytes().decode("utf-8"), before, after, "줄")
_put(path, (text or dump(after)).encode("utf-8"))
+52 -165
View File
@@ -1,21 +1,20 @@
"""M01 「만들기」 저장소 — 원문 절 목록 · 표 조건 값 · 자체 로직 만들기·본뜨기·고치기·지우기
· 복사해서 만들기(정본 로직을 별칭 꼴 식으로 펴 보이고 되돌려 저장).
"""M01 「만들기」 저장소 — 원문 절 목록 · 표 조건 값 · 자체 로직 만들기 · 본뜨기(= [복사/생성]) · 고치기 · 지우기.
계약: `resources/master_data/_화면_계약.md` 2장·5장·7장 · 파일 모양: `_틀.md` 7장.
자체 로직은 `로직_자체.json` 한 파일 · 키는 `_키대장.json` 의 `GX` 다음 번호(서버가 줌).
계약: `resources/master_data/_화면_계약.md` 2장·5장 · 파일 모양: `_틀.md` 7장.
기초(로직) 저장 = 수식 문서 먼저(`Store_Logic` · 855 L3 ⓐ) · 자체 기초는 `수식_자체.json` 한 파일 ·
키는 `_키대장.json` 의 `GX` 다음 번호(서버가 줌).
"""
from __future__ import annotations
import re
from pathlib import Path
from common_util.common_util_time import kst_today
from M01_MasterData import M01_MasterData_Doc as doc_store
from M01_MasterData import M01_MasterData_Machine as machine
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Logic as logic_store
from M01_MasterData import M01_MasterData_Store_Revise as revise
cm, mk, mcp = store.cm, store.mk, store.mcp
cm, mk = store.cm, store.mk
OWN = "로직_자체.json" # 자체 로직 한 자리 — 이 파일 줄만 고치고 지울 수 있음
OWNERS = ("현장", "공용")
@@ -206,97 +205,46 @@ def source(src: str) -> dict:
return {"source": src, "found": found}
# ── 자체 로직 ──────────────────────────────────────────────────────────
def _own_path() -> Path:
return store.FOLDER / OWN
def _make_file() -> None:
"""자체 로직 파일이 없으면 머리만 두고 만듦."""
path = _own_path()
if path.is_file():
return
head = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []}
path.write_text(store.dump(head), encoding="utf-8", newline="\n")
# ── 저장 ──────────────────────────────────────────────────────────────
def _alias(part: dict) -> None:
"""별칭(815-2) = 앞뒤 빈칸만 뗌 · 빈 글 = 칸 없음."""
for ch in part.get("changes") or []:
row = ch.get("row")
if isinstance(row, dict) and "별칭" in row:
text = str(row["별칭"] or "").strip()
row.update(별칭=text) if text else row.pop("별칭")
def save(batch: list[dict], confirmed: bool = False) -> dict:
"""`/save` — 로직 정본 줄 고침은 `confirmed`(「원문 개정 반영」) 없으면 409(`Store_Revise`) ·
자체 파일 새 줄(키 없음)은 서버가 칸을 잡고 GX 다음 키 — {files, added, warnings}."""
revise.guard(batch, confirmed)
"""`/save` — 기초(로직 파일 몫)는 `Store_Logic`(문서 먼저 · 정본 머리 고침은 `confirmed` 없으면 409) ·
요소 · 표는 `store.save` · 자체 새 줄(키 없음)은 서버가 칸을 잡고 GX 다음 키 — {files, added, warnings}."""
logic = [p for p in batch if logic_store.is_logic(str(p.get("file") or ""))]
rest = [p for p in batch if not logic_store.is_logic(str(p.get("file") or ""))]
revise.guard(logic, confirmed)
for part in batch:
_alias(part)
for part in logic:
for ch in part.get("changes") or []:
row = ch.get("row")
if (
isinstance(row, dict) and "별칭" in row
): # 별칭(815-2) = 앞뒤 빈칸만 뗌 · 빈 글 = 칸 없음
text = str(row["별칭"] or "").strip()
row.update(별칭=text) if text else row.pop("별칭")
machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2)
_keep_same(part)
docs_too = machine.register(
batch
) # [새 기계] = 꼴 식 목록 등록(822-2 · 개정확인 밖 — 자동 고침)
fresh = False
for part in batch:
if part.get("file") != OWN:
continue
for ch in part.get("changes") or []:
row = ch.get("row")
if isinstance(row, dict) and (ch.get("op") == "add" or not ch.get("key")):
if part.get("file") == OWN and isinstance(row, dict) and (ch.get("op") == "add" or not ch.get("key")):
ch.update(op="add", key=None, row=_clean(row, str(row.get("소유") or OWNERS[0])))
if not _own_path().is_file():
_make_file()
fresh = True
part["version"] = part.get("version") or store.read(OWN)[1]
before = {p["file"]: set(_file_keys(p["file"])) for p in batch} # 자재 3만 키 — 목록 찾기 금지
try:
files, added = [], []
if rest:
for part in rest:
machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2)
_keep_same(part)
docs_too = machine.register(rest) # [새 기계] = 꼴 식 목록 등록(822-2 · 848-5 문서 정본)
before = {p["file"]: set(_file_keys(p["file"])) for p in rest} # 자재 3만 키 — 목록 찾기 금지
with store.cache.picks(*getattr(docs_too, "lists", ({}, set()))):
files = store.save(batch)
except store.StoreError:
if fresh:
_own_path().unlink(missing_ok=True)
raise
docs_too() # 수식 문서 기계 고르기 목록도 같게(848-5)
_drop_docs(batch)
added = [
{"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old
]
_sync_tags(batch, added)
files = store.save(rest)
docs_too()
added = [{"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old]
if logic:
got = logic_store.save(logic, True)
files, added = files + got["files"], added + got["added"]
return {"files": files, "added": added, "warnings": []}
def _sync_tags(batch: list[dict], added: list[dict]) -> None:
"""고친 · 더한 로직 줄 이름표(비고 · 별칭 · 이름 · 개정 …)를 수식 문서에도(855 L1 · 두 곳 같게) ·
더한 로직 줄은 문서부터 둠(`Doc.ensure` — 목록이 문서에서 읽음 · 855 L2 ⓐ)."""
from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게
files = store.loaded()[0]
for a in added:
if (files.get(a["file"]) or {}).get("그룹") == "로직":
doc_store.ensure(a["key"])
keys = {a["key"] for a in added} | {
str(c.get("key"))
for p in batch
for c in p.get("changes") or []
if c.get("op") == "edit" and c.get("key")
}
doc_store.sync_tags(keys)
def _drop_docs(batch: list[dict]) -> None:
"""지운 로직 줄의 수식 문서도 지움(문서만 남지 않게 · `/logic/remove` 와 같은 끝)."""
from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게
files = store.loaded()[0]
for part in batch:
if (files.get(str(part.get("file"))) or {}).get("그룹") != "로직":
continue
for ch in part.get("changes") or []:
if ch.get("op") == "delete" and ch.get("key"):
doc_store.drop(str(ch["key"]))
def _keep_same(part: dict) -> None:
"""고친 줄의 값이 같은 칸 = 파일 값 그대로(화면 왕복 「9.0」 → 「9」 막음 · 그 칸만 바뀜)."""
data = store.loaded()[0].get(str(part.get("file") or "")) # 읽기만 — 기억(826-2)
@@ -315,11 +263,7 @@ def _file_keys(file: str) -> list[str]:
return [str(r.get("키")) for r in data.get(store.items_key(data)) or []]
def _find(key: str) -> tuple[str, dict]:
got = store.logic(key)
return got["file"], got["logic"]
# ── 자체 로직 ──────────────────────────────────────────────────────────
def _clean(logic: dict, owner: str, key: str | None = None) -> dict:
"""서버가 잡는 칸 — 키·소유·구분·상세구분. 화면이 보낸 것은 안 씀."""
if not isinstance(logic, dict) or not str(logic.get("이름") or "").strip():
@@ -354,80 +298,23 @@ def _chapter_of(logic: dict) -> str:
return ""
def _write(changes: list[dict]) -> dict:
"""자체 파일 한 벌 저장 — 검사는 `/save` 와 같음(422 면 아무것도 안 씀)."""
fresh = not _own_path().is_file()
_make_file()
try:
out = store.save([{"file": OWN, "version": store.read(OWN)[1], "changes": changes}])
except store.StoreError:
if fresh:
_own_path().unlink(missing_ok=True)
raise
return out[0]
def logic_new(logic: dict, owner: str = OWNERS[0], source: str = "") -> dict:
"""새 자체 기초 — 키 = 서버가 `GX` 다음 번호 · 문서 = 빈 문서 / `source` 문서 복제(본뜸) ·
옛 로직 줄은 같이 쓰기(`Store_Logic.mirror`)."""
change = {"op": "add", "row": _clean(logic, owner), "from": source}
part = {"file": OWN, "version": doc_store.file_version(OWN), "changes": [change]}
got = logic_store.save([part], True)
key = got["added"][-1]["key"]
return {**got["files"][0], "key": key, "logic": store.logic(key)["logic"], "수식문서": True}
def _keys() -> list[str]:
if not _own_path().is_file():
return []
return [str(r.get("키")) for r in store.read(OWN)[0].get("줄") or []]
def logic_new(logic: dict, owner: str = OWNERS[0]) -> dict:
"""새 자체 로직 — 키 = 서버가 `GX` 다음 번호 · 수식 문서도 같이(`Doc.make` · 요구 896)."""
from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게
before = set(_keys())
done = _write([{"op": "add", "row": _clean(logic, owner)}])
key = next((k for k in reversed(_keys()) if k not in before), "")
made = doc_store.ensure(key) if key else False
return {**done, "key": key, "logic": store.logic(key)["logic"] if key else {}, "수식문서": made}
def logic_copy(key: str, 이름: str = "", owner: str = OWNERS[0]) -> dict:
"""본떠 만들기 — 정본도 본뜰 수 있음 · 비고 끝에 본뜬 키를 적음."""
_, row = _find(key)
def logic_copy(key: str, 이름: str = "", owner: str = OWNERS[0], more: dict | None = None) -> dict:
"""본떠 만들기 = [복사/생성] — 원본 문서를 새 자체 기초로 복제(정본도 본뜸) · 비고 끝에 본뜬 키 ·
`more` = 기본정보 창에서 고친 원문번호 · 결과단위 · 출처(빈 글은 원본 그대로)."""
_, doc = doc_store.find(key)
row = doc_store.head_of(doc)
note = " · ".join(x for x in (str(row.get("비고") or ""), f"{key} 를 본뜸") if x)
copy = {**row, "비고": note}
copy = {**row, "비고": note, **{k: v for k, v in (more or {}).items() if v}}
if 이름:
copy["이름"] = 이름
return logic_new(copy, owner)
# ── 복사해서 만들기 ────────────────────────────────────────────────────
def logic_formula(key: str) -> dict:
"""로직 한 줄을 별칭 꼴 식 묶음으로 펴 보임 — 되돌릴 원문은 `별칭` 에 그대로(정본은 안 바뀜)."""
got = store.logic(key)
master = store.loaded()[1]
return {
"file": got["file"],
"version": got["version"],
"key": key,
"소유": got["logic"].get("소유") or "",
"prices": got["prices"],
**mcp.spread(master, got["logic"]),
}
def _gather(logic: dict, marks: list[dict]) -> dict:
try:
return mcp.gather(logic, marks)
except cm.mf.FormulaError as e:
raise store.StoreError(400, str(e)) from e
def logic_formula_preview(logic: dict, marks: list[dict]) -> dict:
"""별칭을 원문으로 되돌린 로직 줄만 — 저장 안 함(시험 계산 전 미리보기)."""
return {"logic": _gather(logic, marks)}
def logic_from_formula(
logic: dict, marks: list[dict], owner: str = OWNERS[0], 이름: str = "", 본뜬키: str = ""
) -> dict:
"""고친 식 묶음을 자체 로직으로 저장 — 별칭을 원문으로 되돌린 뒤 `logic_new` 를 그대로 씀."""
row = _gather(logic, marks)
if 이름:
row["이름"] = 이름
if 본뜬키:
row["비고"] = " · ".join(x for x in (str(row.get("비고") or ""), f"{본뜬키} 를 본뜸") if x)
return logic_new(row, owner)
return logic_new(copy, owner, key)
+16 -25
View File
@@ -1,23 +1,20 @@
"""M01 로직 정본 개정 확인 (PLAN 713-1 · 요구서 내역12 4장 10 · 17).
"""M01 단가산출 기초 정본 개정 확인 (PLAN 713-1 · 요구서 내역12 4장 10 · 17 · 855 L3 ⓐ 문서 기준).
- 로직 정본 파일(`로직_*.json` · 자체 `로직_자체.json` 뺌) 줄을 실제로 바꾸는 `/save`(흐름 저장 ·
지우기 포함)는 「원문 개정 반영」 확인 값(`개정확인`)이 있어야 함 — 없으면 409 + 까닭.
- 요소 파일(인력 · 재료 · 표 …) · 자체 로직 · 같은 줄 그대로 다시 보냄은 대상 밖.
- 줄 바탕 지문(`row_print`) = 계산 칸만 정렬 JSON(수는 Decimal 정규 글) sha256 앞 16 자 —
M02 덮개가 담아 두고 「M01 개정 — 확인」 배지를 띄울 값.
- 판 칸 · 옛 줄 사본은 안 둠 — 정본 이력은 git.
- 정본 기초(로직 파일 이름 `로직_*.json` · 자체 `로직_자체.json` 뺌)의 문서 머리를 실제로 바꾸는 저장
(지우기 포함)은 「원문 개정 반영」 확인 값(`개정확인`)이 있어야 함 — 없으면 409 + 까닭.
- 대조 = 문서 머리(키 · 이름표 · 이름 · 결과단위 · 출처 · 부품) — 같은 머리를 그대로 다시 보냄은 대상 밖.
- 자체 기초 · 요소 파일(인력 · 재료 · 표 …)은 대상 밖 · 판 칸 · 옛 줄 사본은 안 둠 — 정본 이력은 git.
"""
from __future__ import annotations
import hashlib
import json
from decimal import Decimal
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Doc as doc_store
OWN = "로직_자체.json"
PRINT_FIELDS = ("결과단위", "입력", "중간", "호표", "덧줄", "결과", "끝수", "흐름")
#: 기초 머리 — 화면 [저장]이 보내 문서에 쓰는 칸(셈 칸은 줄 쌓기 문서 저장 몫)
FIELDS = ("키", *doc_store.md.TAGS, *doc_store.HEAD)
WHY = "로직 정본(품셈 원문) 줄을 바꿈 — 「원문 개정 반영」 확인 뒤 저장(개정확인)"
@@ -38,30 +35,24 @@ def _norm(v):
return str(v)
def row_print(row: dict) -> str:
"""줄 바탕 지문 — 계산 칸(`PRINT_FIELDS`)만 · 이름 · 별칭 · 비고 고침은 지문을 안 바꿈."""
calc = {k: _norm(row[k]) for k in PRINT_FIELDS if row.get(k) is not None}
raw = json.dumps(calc, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
def _head(row: dict) -> dict:
return _norm({k: row[k] for k in FIELDS if k in row})
def changed(batch: list[dict]) -> list[dict]:
"""정본 줄을 바꾸는 고침 — `[{file, key, op, 이름}]` · 같은 줄을 그대로 다시 보낸 edit 은 뺌."""
"""정본 기초 머리를 바꾸는 고침 — `[{file, key, op, 이름}]` · 같은 머리를 그대로 다시 보낸 edit 은 뺌."""
have = doc_store.docs()
out = []
for part in batch:
file = str(part.get("file") or "")
if not is_canon(file):
continue
try:
rows = {str(r.get("키")): r for r in store.read(file)[0].get("줄") or []}
except store.StoreError:
continue # 없는 파일 — `store.save` 가 404
for ch in part.get("changes") or []:
op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row")
old = rows.get(key)
if op == "edit" and old is not None and store._dec(row) == old:
old = have.get(key)
if op == "edit" and old is not None and isinstance(row, dict) and _head(row) == _head(old):
continue
name = (row or {}).get("이름") if isinstance(row, dict) else None
name = row.get("이름") if isinstance(row, dict) else None
out.append(
{
"file": file,
@@ -78,4 +69,4 @@ def guard(batch: list[dict], confirmed: bool) -> None:
return
hits = changed(batch)
if hits:
raise store.StoreError(409, {"개정": hits, "까닭": WHY})
raise doc_store.store.StoreError(409, {"개정": hits, "까닭": WHY})
@@ -87,7 +87,6 @@ export interface LogicOne {
logic: LogicRow;
blocked: boolean;
reasons: string[];
prices: Record<string, ElementBrief | null>;
}
export interface CalcLine {
@@ -270,7 +269,6 @@ export interface LogicFormula {
version: string;
key: string;
소유: string;
prices: Record<string, ElementBrief | null>;
로직: LogicRow;
별칭: FormulaAlias[];
줄: FormulaLine[];
+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()
@@ -0,0 +1,175 @@
# -*- coding: utf-8 -*-
"""마스터 바탕 기반 — 요소 · 표 색인(`Master`) · 표 줄 찾기(`find`) · 오류 · 비목 이름 · 재료 고르기 이음.
옛 엔진(`master_formula` — 식 읽기 · 셈 · 끝수)과 새 계산기(`master_doc_*`) · 불러오기 · 서고가 같이 씀.
`master_formula` 는 이 이름들을 그대로 다시 내보냄(855-E 2-E4 준비 — 엔진 몸을 지워도 이 모듈은 남음).
"""
from __future__ import annotations
from decimal import Decimal
import master_keys as mk
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
TABLE_GROUPS = ("소요량", "계수")
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
COST_ITEMS = ("노무비", "재료비", "경비")
BUNDLE = (*COST_ITEMS, "계")
class FormulaError(ValueError):
pass
class EmptyInput(FormulaError):
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
class NoRow(EmptyInput):
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
def _plain(v) -> str:
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
# ── 마스터 모음 ────────────────────────────────────────────────────────
class Master:
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
def __init__(self, files: dict[str, dict]):
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
for data in files.values():
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
for row in rows or []:
key = str(row.get("키"))
self.index.setdefault(key[:2], {}).setdefault(key, row)
if row.get("원문번호"):
number = str(row["원문번호"])
slot = self.numbers.setdefault(key[:2], {})
if number in slot:
self.twice.add((key[:2], number))
slot.setdefault(number, row)
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
def get(self, ref: str) -> dict:
tid, _, number = ref.partition(":")
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
elif number:
if (tid, number) in self.twice:
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
row = self.numbers.get(tid, {}).get(number)
else:
row = self.index.get(ref[:2], {}).get(ref)
if row is None:
raise FormulaError(f"없는 요소 「{ref}」")
return row
def label(self, ref) -> str:
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
if isinstance(ref, dict):
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
try:
row = self.get(ref)
except FormulaError:
return ref
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
def value(self, ref: str):
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
row = self.get(ref)
alias = row.get("준용")
if alias not in (None, ""):
target = self.get(str(alias))
name = target.get("이름") or alias
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
return row.get("값"), f"추정(준용: {name})"
return target.get("값"), f"준용: {name}"
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
def logic(self, ref: str) -> dict:
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
raise FormulaError(f"로직 아님 「{ref}」")
return self.get(ref)
# ── 표 줄 찾기 ────────────────────────────────────────────────────────
def _match(table: dict, row: dict, cond: str, want) -> bool:
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
return True
have = row[cond]
if table.get("조건", {}).get(cond) == "범위":
low, high = have
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
if rule == "이상·이하":
return (low is None or want >= low) and (high is None or want <= high)
if rule == "초과·이하":
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·미만":
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
closed = any("이하 포함" in x for x in more) and high == top
return (low is None or want >= low) and (
high is None or want < high or (closed and want == high)
)
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
return (low is None or want >= low) and (high is None or want <= high)
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
return have == want
def _name(row: dict) -> str:
return f"{row.get('키')} {row.get('원문번호')}"
def find(table: dict, conds: dict, want: str | None = None) -> dict:
for cond in conds:
if cond not in table.get("조건", {}):
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
for c in conds:
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
if ups and None not in ups:
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
hits = [row for row in hits if want in row]
if len(hits) != 1:
where = f"표 {table.get('키')}({table.get('원문번호')})"
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
raise NoRow(
f"{where}에 {what} 인 줄이 없음"
if not hits
else f"{where}에 {what} 인 줄이 {len(hits)}개"
)
return hits[0]
# 품셈재료 단가 · 고르기 — 서로 부르는 모듈이라 끝에서 읽음
from master_material import ( # noqa: E402, F401
LINKED,
PICK_KEYS,
REGION,
SLOTS,
TARIFF,
candidates,
check_pick,
check_unit,
static,
cond_text,
element,
pick,
)
import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위
@@ -11,7 +11,7 @@
from __future__ import annotations
import master_doc as md
import master_formula as mf # 마스터 색인(`Master.get`) — 없는 키 = FormulaError
import master_base as mf # 바탕 기반 · 마스터 색인(`Master.get`) — 없는 키 = FormulaError
import master_keys as mk
import master_material as mm # 재료 고르기 조건 검사(`check_pick`)
@@ -20,7 +20,7 @@ from pathlib import Path
import master_doc as md
import master_doc_calc as mc
import master_formula as mf
import master_base as mf # 바탕 기반(색인 · 오류)
import master_machine_crew as mcrew
import master_material as mm
import master_pick as mp
@@ -13,7 +13,7 @@
from __future__ import annotations
import master_doc_calc as mc
import master_formula as mf
import master_base as mf # 바탕 기반(색인 · 오류)
class Rec:
+16 -143
View File
@@ -3,6 +3,7 @@
식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게).
`check_master.py` 가 부름.
바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄.
"""
from __future__ import annotations
@@ -12,15 +13,22 @@ import re
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
import master_keys as mk
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
from master_base import ( # noqa: F401 — 바탕 기반(855-E 2-E4 준비) · 이름은 여기서 그대로
BUNDLE,
COST_ITEMS,
GROUPS,
TABLE_GROUPS,
TABLE_IDS,
EmptyInput,
FormulaError,
Master,
NoRow,
_match,
_name,
_plain,
find,
)
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
TABLE_GROUPS = ("소요량", "계수")
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
COST_ITEMS = ("노무비", "재료비", "경비")
BUNDLE = (*COST_ITEMS, "계")
FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대")
_NAME = re.compile(r"[\w가-힣]+")
_NUMBER = re.compile(r"\d+(?:\.\d+)?")
@@ -38,18 +46,6 @@ def inputs_of(row: dict) -> list[dict]:
raise FormulaError(FLOW_GONE)
class FormulaError(ValueError):
pass
class EmptyInput(FormulaError):
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
class NoRow(EmptyInput):
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
class Blank:
"""못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움."""
@@ -57,11 +53,6 @@ class Blank:
self.why = why
def _plain(v) -> str:
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
# ── 읽기 ──────────────────────────────────────────────────────────────
class _Parser:
def __init__(self, text: str):
@@ -257,70 +248,6 @@ def walk(node):
yield from walk(item)
# ── 마스터 모음 ────────────────────────────────────────────────────────
class Master:
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
def __init__(self, files: dict[str, dict]):
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
for data in files.values():
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
for row in rows or []:
key = str(row.get("키"))
self.index.setdefault(key[:2], {}).setdefault(key, row)
if row.get("원문번호"):
number = str(row["원문번호"])
slot = self.numbers.setdefault(key[:2], {})
if number in slot:
self.twice.add((key[:2], number))
slot.setdefault(number, row)
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
def get(self, ref: str) -> dict:
tid, _, number = ref.partition(":")
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
elif number:
if (tid, number) in self.twice:
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
row = self.numbers.get(tid, {}).get(number)
else:
row = self.index.get(ref[:2], {}).get(ref)
if row is None:
raise FormulaError(f"없는 요소 「{ref}」")
return row
def label(self, ref) -> str:
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
if isinstance(ref, dict):
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
try:
row = self.get(ref)
except FormulaError:
return ref
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
def value(self, ref: str):
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
row = self.get(ref)
alias = row.get("준용")
if alias not in (None, ""):
target = self.get(str(alias))
name = target.get("이름") or alias
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
return row.get("값"), f"추정(준용: {name})"
return target.get("값"), f"준용: {name}"
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
def logic(self, ref: str) -> dict:
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
raise FormulaError(f"로직 아님 「{ref}」")
return self.get(ref)
def fill(template: str, env: dict) -> str:
def one(m):
if m.group(1) not in env:
@@ -338,60 +265,6 @@ def _round(x: Decimal, places, mode) -> Decimal:
return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode)
def _match(table: dict, row: dict, cond: str, want) -> bool:
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
return True
have = row[cond]
if table.get("조건", {}).get(cond) == "범위":
low, high = have
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
if rule == "이상·이하":
return (low is None or want >= low) and (high is None or want <= high)
if rule == "초과·이하":
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·미만":
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
closed = any("이하 포함" in x for x in more) and high == top
return (low is None or want >= low) and (
high is None or want < high or (closed and want == high)
)
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
return (low is None or want >= low) and (high is None or want <= high)
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
return have == want
def _name(row: dict) -> str:
return f"{row.get('키')} {row.get('원문번호')}"
def find(table: dict, conds: dict, want: str | None = None) -> dict:
for cond in conds:
if cond not in table.get("조건", {}):
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
for c in conds:
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
if ups and None not in ups:
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
hits = [row for row in hits if want in row]
if len(hits) != 1:
where = f"표 {table.get('키')}({table.get('원문번호')})"
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
raise NoRow(
f"{where}에 {what} 인 줄이 없음"
if not hits
else f"{where}에 {what} 인 줄이 {len(hits)}개"
)
return hits[0]
def evaluate(node, env: dict, master: Master, depth: int = 0):
kind = node[0]
if kind in ("num", "str"):
@@ -284,5 +284,5 @@ def element(
return min(offers, key=lambda x: x[0]) if offers else (None, None)
import master_formula as mf # noqa: E402 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_base as mf # noqa: E402 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_pick as mp # noqa: E402 — 검색어 찾기
+1 -1
View File
@@ -230,4 +230,4 @@ def check_warn(master, where: str, cond: dict, unit: str | None) -> list[str]:
return []
import master_formula as mf # noqa: E402, F401 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_base as mf # noqa: E402, F401 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
+80 -10
View File
@@ -40,8 +40,14 @@ class Fake {
get firstChild() {
return this.children[0] ?? null;
}
addEventListener() {}
addEventListener(t, f) {
((this.on ??= {})[t] ??= []).push(f);
}
removeEventListener() {}
/** 사건 일으킴(⑥ 머리 칸 change) */
fire(t) {
for (const f of this.on?.[t] ?? []) f({ target: this });
}
setAttribute(k, v) {
this.attrs[k] = v;
if (k.startsWith("data-")) this.dataset[camel(k.slice(5))] = v;
@@ -87,15 +93,18 @@ const button = (o = {}) => box("button", { "data-button": o.label ?? "" });
const input = (o = {}) => {
const i = box("input");
i.value = o.value ?? "";
return { root: box("label", { "data-input": o.label ?? "" }, ""), input: i, setError() {} };
const root = box("label", { "data-input": o.label ?? "" }, "");
root.append(i); // ⑥ 칸이 머리 나무에 달림
return { root, input: i, setError() {} };
};
const modals = []; // 열린 모달 — 제목 · 몸
const toasts = []; // 알림 글(856-3 M01 로직 줄 안내)
const ui = {
ui_template_elements: {
el,
createButton: button,
createInputField: input,
showToast() {},
showToast: (text, kind) => toasts.push([kind, text]),
showConfirmDialog: async () => true,
},
ui_template_button: { createButton: button },
@@ -112,7 +121,7 @@ const ui = {
const head = box("div");
const close = () => {};
o.mount?.(body, close, head);
modals.push({ title: o.title, body, head, actions: o.actions ?? [] });
modals.push({ title: o.title, body, head, actions: o.actions ?? [], shut: o.beforeClose });
return { close };
},
askConfirm: async () => true,
@@ -158,6 +167,7 @@ const screen = {
// 서버 부름 — 길 · 몸을 적고 견본 답
const calls = [];
const files = { reads: 0, saves: 0 }; // 층 파일 읽기 · 저장 수
const api = {
call: async (p, init) => {
calls.push({ path: p, body: init?.body ? JSON.parse(init.body) : null });
@@ -166,8 +176,11 @@ const api = {
return { items: [{ ref: "X1", 이름: "견본", 단위: "EA", 값: 1 }] }; // 찾아 넣기(⑤)
return {};
},
readTemplate: async (_l, _k, key) => ({ 문서: { 키: key, 이름: "견본", 단위: "㎡" }, 판: "1" }),
saveTemplate: async () => ({}),
readTemplate: async (_l, _k, key) => (
files.reads++,
{ 문서: { 키: key, 이름: "견본", 단위: "㎡" }, 판: "1" }
),
saveTemplate: async () => (files.saves++, {}),
getActiveLayer: () => "system",
getActiveOwner: () => null,
};
@@ -193,7 +206,10 @@ const stubs = {
tabOf: () => ({}),
},
M01_MasterData_UI_LogicLab_Ho: { buildHo: () => [box("div", { "data-ho": "" })] },
M02_MasterTemplete_Sangeun_Unit: { buildUnitSwap: () => null, baseUnitOf: () => "" },
M02_MasterTemplete_Sangeun_Unit: {
buildUnitSwap: () => (swaps.n++, box("div", { "data-swap": "" })), // ⑥ 환산 다시 그린 수
baseUnitOf: () => "",
},
M02_MasterTemplete_Labor_LogicMats: { logicMatRows: () => [] },
M02_Labor_Values_Model: {
valueLine: () => ({ text: "", empty: 0 }),
@@ -219,6 +235,7 @@ const stubs = {
},
};
const picked = { rows: 0 };
const swaps = { n: 0 };
const real = new Set([
"M02_MasterTemplete_Sangeun_Detail",
"M02_MasterTemplete_Sangeun_Tabs",
@@ -366,7 +383,7 @@ async function openSk(doc, opt = {}) {
);
out.bands_fail = await bandCase({ doc: null, answer: null, fail: "서버 못 닿음" }, "SK-000004");
// ② 일위대가 표 줄 누름 — SK 참조 줄 · M01 로직 줄 · 셈 주입(프로젝트 사본) SK 줄
// ② 일위대가 표 줄 누름 — SK 참조 줄 · M01 로직 줄 · 셈 주입(원본 층 카드) · 프로젝트 사본(856-3 굳힌 SK 문서)
const { mountLaborTable } = M("M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts");
const rows = [
{
@@ -377,7 +394,9 @@ async function openSk(doc, opt = {}) {
},
{ 로직: "GC001109", 별칭: null, 메모: null, 입력값: {}, 수량: { 손: 1 } },
];
const click = async (calc) => {
const copyDoc = { 키: "SK-000010", 이름: "사본", 단위: "㎡", 수식: { 따로: true, 굳힘: true } };
const asked = [];
const click = async (calc, copy) => {
const res = [];
for (let i = 0; i < rows.length; i++) {
const t = mountLaborTable(
@@ -387,16 +406,21 @@ async function openSk(doc, opt = {}) {
mode: "precombo",
layer: "system",
column: "공통",
readOnly: false,
readOnly: !!calc && !copy, // 셈 주입 카드 = 보기만 · 사본은 표가 열려 있어도 줄 쌓기는 보기만인지 봄
owner: null,
onChanged() {},
...(calc ? { calc: async () => ({ 줄: [], 자재: [] }) } : {}),
...(copy
? { skCopy: async (ref) => (asked.push(ref.키), ref.키 === copy.키 ? copy : null) }
: {}),
},
);
await settle();
modals.length = 0;
stacks.length = 0;
calls.length = 0;
toasts.length = 0;
files.reads = files.saves = 0;
grid.onRowClick(i);
await settle();
const m = modals[0];
@@ -405,16 +429,25 @@ async function openSk(doc, opt = {}) {
modal: m ? m.title : null,
skModal: m ? all(m.body, (n) => "laborSk" in n.dataset).length : 0, // 그 SK 문서 모달(806-1)
stack: s ? { shown: shown(s.root), draws: s.draws.map((d) => d.key) } : null,
memory: s ? s.draws.map((d) => d.memory) : [],
admin: s ? s.opt.admin : null, // 고침 칸(편집) 열림
save: m ? all(m.head, (n) => n.dataset.button === "Save").length : 0, // [저장] 단추
files: { ...files },
toasts: toasts.map((x) => x[0]),
body: m ? all(m.body, (n) => "skCover" in n.dataset && shown(n)).length : 0,
banners: m ? all(m.body, (n) => "banner" in n.dataset).map((n) => n.dataset.banner) : [],
calc: skCalls().length,
});
for (const one of modals) await one.shut?.(); // 닫기(같은 SK 다시 열 수 있게)
t.destroy?.();
}
return res;
};
out.labor = await click(false);
out.labor_inject = await click(true);
out.labor_copy = await click(true, copyDoc);
out.labor_copy_asked = asked.slice();
out.labor_copy_none = await click(true, { ...copyDoc, 키: "SK-999999" });
// ④ M01 로직 상세 그릇 — 기본정보 접힘 + 줄 쌓기
const { buildLabDetail } = M("M01_MasterData/M01_MasterData_UI_LogicLab_Detail.ts");
@@ -460,6 +493,43 @@ async function openSk(doc, opt = {}) {
};
}
globalThis.fetch = fetch0;
// ⑥ 머리 칸 고침(856-G) — 이름 change 뒤 머리 칸 그대로(Tab 으로 옮긴 단위 칸 = 같은 칸 · 초점 유지) ·
// 단위 change = 환산만 새로 · 문서 · 고침 알림
{
const { mountSangeunDetail } = M("M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts");
const host = box("div");
let dirty = false;
const doc = { 키: "SK-000011", 이름: "견본", 단위: "㎡", 바탕: { 로직: "GC001109" } };
const h = mountSangeunDetail(host, doc, {
layer: "system",
owner: null,
readOnly: false,
mode: "page",
onChanged: (d) => (dirty = d),
});
await settle();
const fields = () => all(host, (n) => n.dataset.sk === "이름" || n.dataset.sk === "단위");
const before = fields();
const [name, unit] = before;
const same = () => fields().length === 2 && fields().every((n, i) => n === before[i]);
let n0 = swaps.n;
name.value = " 고친 이름 ";
name.fire("change");
const afterName = { same: same(), swaps: swaps.n - n0, dirty };
n0 = swaps.n;
unit.value = "m2";
unit.fire("change");
const afterUnit = { same: same(), swaps: swaps.n - n0, shown: all(host, (n) => "swap" in n.dataset).length }; // prettier-ignore
const got = h.getDoc();
out.head = {
order: before.map((n) => n.dataset.sk),
afterName,
afterUnit,
doc: [got.이름, got.단위],
};
h.destroy();
}
console.log(JSON.stringify(out));
})().catch((e) => {
console.error(e.stack || String(e));
@@ -34,20 +34,6 @@ def _save(folder, doc):
return key, json.loads((folder / "precombo" / f"{key}.json").read_bytes())
def test_화면_서고_모드도_자재목록_세_칸_자재_저장(world): # noqa: F811
"""723-2 — 서고 = 일위대가표만(`Labor_Table`) · [항목 추가] 머리(736-1 · 자재 추가 단추 걷음) · 세 칸 = 줄 모달(`Labor_RowModal`)."""
read = lambda name: open(os.path.join(SRC, name), encoding="utf-8").read() # noqa: E731
detail, lib = (
read("M02_MasterTemplete_Labor_Detail.ts"),
read("M02_MasterTemplete_Labor_Table.ts"),
)
modal = read("M02_MasterTemplete_Labor_RowModal.ts")
assert "return mountLaborTable(host, doc, opt);" in detail # 806-1 — 조합도 같은 부품
assert 'className: "ui-btn-group", children: [addLogic]' in lib and "addMat" not in lib
assert "setLogicMark(row, at, key, v);" in modal and "setMark(o.mat, key, v);" in modal
assert "delete out.자재" not in lib and "delete out.열" in lib
def test_저장_왕복_고름_자재표시_자재_남음(world): # noqa: F811
line = {"로직": NET, "고름": {"4": NET_ITEM}, "자재표시": {"3": {"자재구분": "관급"}}}
mats = [
+7 -10
View File
@@ -5,7 +5,7 @@
자동값(master_auto 「나누는 자리 = 1」)이 1 이라 838 ㎥(자료 · 기본값 몫 — 223 보고).
② 별도계상 — 로직 자재(`자재표시` · 빈 칸 = 기본 별도계상) = 기준에서 빠지고 `줄` 에서 지움 · `재료` 는
남음 · 사용자 자재 = 합에서 뺌(짝 TS `settle`) · 사전조합 안 줄 · 사본 셈 같은 길.
③ 원문 — 로직 출처 + 호표 · 입력 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」).
③ 원문 — 문서 출처 + 금액 줄 · 변수 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」).
"""
import os
@@ -13,6 +13,7 @@ from decimal import Decimal
import pytest
from M01_MasterData import M01_MasterData_Doc as m01_doc
from M01_MasterData import M01_MasterData_Store as m01
from M01_MasterData import M01_MasterData_Store_Make as make
from M02_MasterTemplete import M02_Labor_Doc as labor
@@ -130,16 +131,9 @@ def test_사전조합_안_줄도_별도계상_뺌():
assert got["기준"]["계"] == _kept(raw)["계"]
def test_화면_별도계상_바꾸면_다시_셈():
# 806-1 — 조합 · 서고 모두 일위대가표 부품 · 세 칸은 줄 모달(`Labor_RowModal`)
modal = open(os.path.join(SRC, "M02_MasterTemplete_Labor_RowModal.ts"), encoding="utf-8").read()
assert 'o.done(key === "별도계상");' in modal # 사용자 자재 · 로직 자재 모두 별도계상만 다시 셈
assert modal.count('o.done(key === "별도계상");') == 2
# ── ③ 원문 여럿 ──────────────────────────────────────────────────────
def test_원문_출처는_같은_책_절_모두():
src = inputs.sources(_whole().logic(MIX))
src = inputs.sources(m01_doc.docs()[MIX])
assert src == "산림품셈 12-1-2 · 12-1-3"
assert inputs.logic_inputs([MIX])["로직"][0]["출처"] == src
assert [f["number"] for f in make.source(src)["found"]] == ["12-1-2", "12-1-3"]
@@ -150,6 +144,9 @@ def test_원문_출처_번호_없거나_더할_것_없으면_그대로():
assert inputs.sources({"출처": None}) is None
one = {
"출처": "산림품셈 3-1",
"호표": [{"출처": "건설품셈 공통 1-2-4 3"}, {"출처": "산림품셈 3-1"}],
"금액": [
{"수량": "1", "출처": "건설품셈 공통 1-2-4 3"},
{"수량": "1", "출처": "산림품셈 3-1"},
],
}
assert inputs.sources(one) == "산림품셈 3-1" # 다른 책 · 같은 절은 안 붙임
+4 -40
View File
@@ -3,18 +3,14 @@
서버 없이 잡음: 탭(역할) 따라 판 바꿈(일위대가표 = 호표 목록 · 단가산출 탭 = 단가산출 목록 · 칸은 처음 한 번만 지음) ·
시트 행 → 목록 강조 · 목록 줄 → 지금 탭의 블록 자리 + 개인 층 가져온 식 모달(835-1 · [내 단가산출로] 단추 걷음) ·
줄 끝 [가져온 식으로 열기](809-1 · 판정 블록 판 걷음) ·
[끝내기] = 막지 않고 물음창 글만 ·
화면 = 부품 상자만 · 700 줄.
[끝내기] = 막지 않고 물음창 글만.
"""
import json
import os
import re
import subprocess
from pathlib import Path
HERE = os.path.dirname(__file__)
M02 = Path(__file__).resolve().parents[2] / "M02_MasterTemplete"
def _node(payload: dict) -> dict:
@@ -59,7 +55,9 @@ def test_판_바꿈_목록_지음_강조_뛰기():
assert got["opened"] == [{"no": 8, "canWrite": True, "to": "personal"}] * 6
rows = {r["label"]: r for r in got["rows"]}
assert rows["단산8 거푸집"]["sub"] == "㎡ · M02_JudgeCalls 1"
assert rows["단산8 거푸집"]["tail"] == [] # 만들 층 = 개인 → [가져온 식으로 열기] 숨김 · 저장 단추 없음
assert (
rows["단산8 거푸집"]["tail"] == []
) # 만들 층 = 개인 → [가져온 식으로 열기] 숨김 · 저장 단추 없음
assert rows["단산9 잡석"]["sub"] == "㎥ · M02_JudgeOutside"
assert rows["단산10 운반"]["tail"] == ["success:M02_JudgeMade SK-000001"]
assert got["count"] == {"블록": 2, "밖": 1, "줄": 0} # 만든 SK 뺌
@@ -71,37 +69,3 @@ def test_권한_그대로_넘김():
{"no": 8, "canWrite": True, "to": "personal"},
{"no": 8, "canWrite": False, "to": "company"},
]
def _src(name: str) -> str:
return (M02 / f"M02_MasterTemplete_Hopyo_{name}.ts").read_text(encoding="utf-8")
def test_캐시_공유_알림_칠_다시():
sheet = _src("Sheet")
assert "createSheetSk(" in sheet and "sk?.at(s);" in sheet
side = _src("SheetSk")
assert "readHopyoMarks(opt.scope, opt.key, opt.target)" in side # 809-1 블록 칠 재료 목록
assert (
"createJudgeBlock" not in side and "createJudgeMove" not in side
) # 판정 블록 판 · 옮기기 걷음
nav = _src("SheetNav")
assert "blockAt(sheet: string, row: number)" in nav and "spotOf(no: number, role: Role)" in nav
wizard = _src("Import")
assert (
'L("M02_SkUnmoved")' in wizard and "leftCount" not in wizard
) # 밖 = 안 막음 · 옛 남은 줄 막음 걷음
tone = (M02 / "logic" / "M02_MasterTemplete_Hopyo_SheetMap.ts").read_text(encoding="utf-8")
assert '글: "일위대가 밖"' in tone
def test_부품_상자만_700줄():
for name in ("SheetSk", "Sheet", "SheetNav", "Import", "Side"):
src = _src(name)
assert len(src.splitlines()) <= 700, name
assert not re.search(r"#[0-9a-fA-F]{3,6}\b|rgb\(", src), name
for name in ("SheetSk", "Import"):
assert not re.search(r'el\("(button|input|select)"|<button|<input', _src(name)), name
css = (M02 / "M02_MasterTemplete_Hopyo.css").read_text(encoding="utf-8")
block = css.split(".m02-hopyo-sheet.is-sk", 1)[1].split("/*", 1)[0]
assert not re.search(r"#[0-9a-fA-F]{3,6}\b|rgb\(", block)
+1 -1
View File
@@ -27,7 +27,7 @@ THREE = ("GF000220", "GC000404", "GF000101") # 돌쌓기 메쌓기(장비) ·
def _rows(key: str) -> list[dict]:
whole = m01.loaded()[1]
return st._rows_of(whole, whole.logic(key), False)
return st._rows_of(whole, m01_doc.docs()[key], False)
def _given(key: str, change: dict) -> dict:
+2 -46
View File
@@ -1,9 +1,8 @@
"""704-2 딸림 — 기준 목록 · 계산서 끝수 = B09 산근 규칙(줄마다 ROUNDDOWN 1 · 비목마다 ROUNDDOWN 0).
"""704-2 딸림 — 계산서 끝수(줄마다 0.1 · 비목 소계 정수) · 계 = 기준 목록 금액(문서 셈).
거울: 엔진 줄(수량 · 단가)에 B09 `_money` · `block_totals` 를 그대로 씌운 값 = `settle` 값.
옛 거울(엔진 줄 + B09 끝수 = `M02_Logic_Settle`)은 부르는 곳 0 이라 그 파일과 함께 걷음(855 L2 ⓑ).
"""
import re
import sys
from decimal import Decimal
from pathlib import Path
@@ -12,53 +11,10 @@ ROOT = Path(__file__).resolve().parents[2]
if str(ROOT) not in sys.path:
sys.path.insert(0, str(ROOT))
from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402
from M01_MasterData import M01_MasterData_Doc as m01_doc # noqa: E402
from M01_MasterData import M01_MasterData_Store as m01 # noqa: E402
from M02_MasterTemplete import M02_Logic_Settle as st # noqa: E402
from M02_MasterTemplete import M02_Logic_Standard as ls # noqa: E402
mf = m01.cm.mf
PART_OF = {"노무비": "labor", "재료비": "material", "경비": "expense"}
def _plain(row: dict) -> bool:
"""로직 줄 · 덧줄 · 작업량 Q 가 없는 돈 로직 — 엔진 줄만으로 B09 값을 낼 수 있음."""
return (
str(row.get("결과단위") or "").startswith("원")
and not row.get("덧줄")
and not row.get("끝수")
and not any(i.get("종류") == "로직" for i in row.get("호표") or [])
and not any(re.fullmatch(r"Q\d*", s["이름"]) for s in row.get("중간") or [])
)
def test_줄마다_버림_비목마다_버림_B09와_같음():
files, whole = m01.loaded()
checked = 0
for _, data in m01._logic_files(files):
for row in data.get("줄") or []:
if not _plain(row) or checked >= 60:
continue
base, _ = ls.axes(whole, m01_doc.docs()[row["키"]])
given = mf.fill_empty(row, base)
got = mf.run(whole, row["키"], given)
lines = []
for line in got["줄"]:
one = dict.fromkeys(PART_OF.values(), 0.0)
for part, money in line["비목"].items():
one[PART_OF[part]] = sg._money(1.0, float(money)) if money is not None else None
lines.append(one)
if any(v is None for one in lines for v in one.values()):
continue
want = sg.block_totals(lines)
mine = st.settle(whole, row["키"], given)
for name, part in PART_OF.items():
assert float(mine[name]) == want[part], (row["키"], name)
assert float(mine["계"]) == want["sum"], row["키"]
checked += 1
assert checked >= 30
def test_계산서_줄_소계_계가_맞물림():
files, whole = m01.loaded()
+2 -1
View File
@@ -15,6 +15,7 @@ from pathlib import Path
import pytest
from M01_MasterData import M01_MasterData_Doc as m01_doc
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Ref as refs
@@ -52,7 +53,7 @@ def test_727_1_기초마다_한_줄():
whole = m01.loaded()[1]
rows = []
for key in (GF, "GC000269", "GC001109"):
rows += standard._rows_of(whole, whole.logic(key), False)
rows += standard._rows_of(whole, m01_doc.docs()[key], False)
assert sum(r["키"] == GF for r in rows) == 3 # 옵션 축 보정작업 두 값 + 바탕
got = _heads(rows)
assert [r["키"] for r in got] == [GF, "GC000269", "GC001109"]
+2 -1
View File
@@ -21,6 +21,7 @@ from fastapi.testclient import TestClient
from common_util.common_util_auth import verify_session
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Library_Same as same
from M02_MasterTemplete import M02_Library_Same_Router as same_router
from M02_MasterTemplete import M02_MasterTemplete_Store as store
@@ -112,7 +113,7 @@ def test_SC_에_SC_사본_블록_실무수량_겹침_원본_지워도(world):
assert _sc_value(me, host) == pytest.approx(before, rel=1e-9)
with store.at(me):
(me / "precombo" / f"{old}.json").unlink() # 옛 꼴 문서(참조) 치움
assert refs.users({**MINE, "키": inner}) == []
assert library_uses.users({**MINE, "키": inner}) == []
store.delete("precombo", inner)
assert _sc_value(me, host) == pytest.approx(before, rel=1e-9) # 원본 지워도 그대로
@@ -110,17 +110,3 @@ def test_B09_옛_사본_null_은_그대로_빈_줄():
def _src(name: str) -> str:
return open(os.path.join(SRC, name), encoding="utf-8").read()
def test_화면_수량_칸_저장_새_줄_1_두_칸():
table = _src("M02_MasterTemplete_Labor_Table.ts")
assert "const temp = new Map" not in table and "withTemp" not in table # 휘발 칸 걷음
assert "row.수량 = raw ? { 손: v } : null;" in table and "changed(true);" in table
assert (
table.count("수량: fresh()") == 4
) # 기초 · 참조 · 고정 · 자재 새 줄 = 서고 1 · 조합 면적 따름(806-1)
assert "const fresh = (): LaborRow" in table and "{ ...ONE }" in table
assert 'BasePrice: ["기준단위 단가"' in table and 'QtyAmount: ["수량 반영 금액"' in table
assert 'sum_price: t("BasePrice"), sum: t("QtyAmount")' in table
assert 'NeedQty: ["수량 입력"' in table
assert 'if (!edit || key !== "qty" || n === null) return false;' in table # 읽기 층 못 고침
+1 -29
View File
@@ -103,7 +103,7 @@ def test_끝내기_남는_파일_0_금액_그대로_출처만_다시_올림(clie
assert not {"키", "원본", "확인", "품셈", "갈래", "엑셀품", "못옮김", "또"} & set(got)
lines = doc.get("담은로직") or []
assert not any(str(x.get("메모", "")).startswith("실무 ") for x in lines)
assert hs.done(folder)["지문"] == {} # 끝낸 기록 없음
assert hs.done(folder) == {"번": 1} # 끝낸 기록 없음 · 번만
again = _post(client) # 같은 엑셀 다시 올림 = 새 키(409 없음)
assert again.status_code == 200 and again.json()["키"] == "HP-000002"
@@ -121,31 +121,3 @@ def test_하루_지난_HP_목록_숨김_올림_때_지움(client):
got = _post(client).json() # 같은 엑셀이어도 지난 것 = 지우고 새로(이어서 아님)
assert got["키"] == "HP-000002" and not got.get("이어서")
assert _files(folder) == ["HP-000002.json"] * 3 # 이번 것 + 격자 + 산근 시트(793-3b)
def test_옛_파일_정리_미리_보기_쓰기_0_고침(client):
folder = layers.personal_dir(7, 42)
assert _post(client).json()["키"] == "HP-000001" # 작업 중 — 그대로
home = folder / hs.DIRNAME
(home / "HP-000007.json").write_text(json.dumps({"키": "HP-000007", "호표": []}), "utf-8")
hs._put_done(folder, {"번": 7, "지문": {"ab": {"파일": "옛.xls", "만든": ["SC-000001"]}}})
(folder / "precombo").mkdir(exist_ok=True)
gone = {"이름": "옛", "단위": "개", "담은로직": [{"로직": "L", "메모": "실무 1개 × 1"}],
"본뜬": {**HEAD, "키": "HP-000005 제1호표", "확인": SURE}} # fmt: skip
live = {**gone, "본뜬": {**HEAD, "키": "HP-000001 제1호표", "확인": SURE}}
for key, doc in (("SC-000001", gone), ("SC-000002", live)):
text = json.dumps(doc, ensure_ascii=False)
(folder / "precombo" / f"{key}.json").write_text(text, "utf-8")
snap = {p: p.read_bytes() for p in folder.rglob("*.json")}
rows = forget.tidy(folder)
assert [r["대상"] for r in rows] == ["실무자료/HP-000007", "불러옴.json", "SC-000001"]
assert {p: p.read_bytes() for p in folder.rglob("*.json")} == snap # 미리 보기 = 쓰기 0
assert forget.tidy(folder, apply=True) == rows
assert _files(folder) == ["HP-000001.json"] * 3
assert hs.done(folder) == {"번": 7, "지문": {}}
docs = _docs(folder, "precombo")
assert "키" not in docs["SC-000001"]["본뜬"] and "메모" not in docs["SC-000001"]["담은로직"][0]
assert docs["SC-000002"] == live # 작업 중 HP 것 그대로
assert forget.tidy(folder) == [] # 두 번째 = 할 일 없음
@@ -118,7 +118,8 @@ def test_STmate_같은_코드_두_묶음_따로_계수_율_밖():
), # fmt: skip
_row(c0="총계"),
]
blocks = st._blocks(rows, {})
lines = [{"행": at, **{chr(65 + c): v for c, v in enumerate(r) if v is not None}} for at, r in enumerate(rows, 1)] # fmt: skip
blocks = st.from_two([{"코드": "D00001", "칸줄": lines}], {})
units = blocks["D00001"]["항목"]
xs = [u for u in units if u["묶음"] == "X"]
assert [x["품"] for x in xs] == [0.1, 0.2] # 두 묶음 따로(단가 두 배 아님)
@@ -1,75 +0,0 @@
"""785-4 불러오기 화면 껍데기 — 가운데 상세 페이지(마법사) 없음 · 왼쪽 [불러오기] → 바로 본 칸 엑셀 + 오른쪽 목록 ·
머리 막대 [끝내기] · 좁은 판 줄 판 자리 · 부품 상자만 · 700 줄(785-7 — 안 이은 줄 띠 · 마법사 단가산출 걸음 · 옛 캐시 걷음 반영).
소스 글만 읽음(서버 · 화면 없이 돎)."""
import re
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
M02 = ROOT / "M02_MasterTemplete"
def _src(name: str) -> str:
return (M02 / f"M02_MasterTemplete_Hopyo_{name}.ts").read_text(encoding="utf-8")
def test_가운데_상세_페이지_없음():
assert not (M02 / "M02_MasterTemplete_Hopyo_Wizard.ts").exists()
every = "\n".join(p.read_text(encoding="utf-8") for p in M02.glob("*.ts"))
for gone in ("buildHopyoWizard", "HopyoWizard", "wantSangeun", "M02_WizSkCheck", "STEPS"):
assert gone not in every, gone
for key in ("M02_WizSkHead", "M02_WizIlwiHead", "M02_SkHint"):
assert key not in (ROOT / "ui_template" / "ui_template_locale_m2.ts").read_text("utf-8")
def test_누름_하나_바로_엑셀():
side = _src("Side")
choose = side.split("async function choose()")[1].split("input.addEventListener")[0]
assert "input.click();" in choose # [불러오기] = 바로 파일 고르기 창
change = side.split('input.addEventListener("change"')[1].split("async function leaveOk")[0]
assert "uploadHopyo(MINE, file)" in change and "return show(got, true);" in change
show = side.split("async function show(")[1].split("async function showLedger")[0]
assert "buildHopyoImport({" in show and "opt.show(" in show # 올림 뒤 본 칸 바로
imp = _src("Import")
assert "m.buildHopyoSheet({" in imp and "headExtra: [finish]" in imp
def test_층_가르기_없음_늘_개인(): # 837-1 · 요구 855 — 예전 「결과 층 고름」 걷음
side, imp = _src("Side"), _src("Import")
for gone in ("createSegment", "writableLayers", "LAYERS", "layerText", "seg.hidden", "pick"):
assert gone not in side, gone
for gone in ("LAYERS", "layerText", "writableLayers", "layerNote", "createBadge"):
assert gone not in imp, gone
assert 'export const MINE: HopyoScope = { layer: "personal", owner: null };' in imp
def test_끝내기_머리_막대_끝냄_뒤_빈_본_칸():
imp = _src("Import")
end = imp.split("async function end()")[1]
assert (
"skCount()" in end.split("showConfirmDialog(")[0]
) # 안 만든 단가산출 = 물음 글만(막지 않음)
assert "deleteHopyo(scope, file.키)" in end and "a.onEnded();" in end
side = _src("Side")
assert "onEnded: () => {" in side and "void refresh();" in side
sheet = _src("Sheet")
assert "dropButton" not in sheet and "onDeleted" not in sheet # [삭제] 걷음
def test_부품_상자만_700줄_늘리지_않음():
for name in ("Import", "Side", "Sheet", "SheetSk"):
src = _src(name)
assert len(src.splitlines()) <= 700, name
assert not re.search(r"#[0-9a-fA-F]{3,6}\b|rgb\(", src), name # 색 = 공통 값
for name in ("Import", "SheetSk"):
assert not re.search(r'el\("(button|input|select)"|<button|<input', _src(name)), name
assert len(_src("Api").splitlines()) <= 632
css = (M02 / "M02_MasterTemplete_Hopyo.css").read_text(encoding="utf-8")
assert not re.search(r"#[0-9a-fA-F]{3,6}\b|rgb\(", css) and ".m02-hopyo-import" in css
def test_해시_캐시_열쇠_없음():
# 809-1 — 판정 고름 캐시(`Hopyo_Picks`) 걷음 · 옮기기 = [내 일위대가로]
assert not (M02 / "logic" / "M02_MasterTemplete_Hopyo_Picks.ts").exists()
assert "draftKey" not in _src("Import") and "dirty: () => body?.matDirty()" in _src("Import")
assert "location.hash" not in _src("Import") + _src("Side") # 새 해시 열쇠 없음
+3 -53
View File
@@ -1,18 +1,12 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""790-2 단가산출(SK) 숫자 넓힘 — 상수 · 표값 덮개 · 글 줄 · 까닭 · M01 원래로 · 짝잃음(요구서_652).
"""790-2 단가산출(SK) 글 줄 · 까닭 칸 꼴 · 옛 SK 셈 답(요구서_652).
- 금액 = 서버 셈 = _분석_650-H2 4 장 견본(지붕 감률 17 → 20 = 61,088 · 공구손료 1 → 2 % = 51,802 ·
인력운반 120 → 100 = 38,696 · 표값 운반량 30 = 35,764) · 옵션 바꿔도 상수 덮개 식 따라감
- 식 속 숫자 차례 = 엔진 파서(찾기 머리 · 키 · EQ: · 따옴표 글 안 셈)
- 옛 SK(새 칸 없음) = 꼴 · 금액 그대로 · 저장 = M01판 · 셈 답 `원래` · `시트`
- 799-2 — TS 거울(`Const_Model.ts`)은 시트 탭과 함께 걷음 · 서버 `M02_Sangeun_Const` 만 지킴
- 펼침 = 상수 덮개 SK 안 펼침(참조 그대로 · 값 그대로) · [초기화] = 새 덮개도 걷음
- 글줄 · 까닭 = 꼴 검사 · 빈 칸 안 둠 · 상수 · 표값 덮개 = 셈 은퇴 뒤 받지 않음(855 2-E2 · 시험 792_1)
- 옛 SK(새 칸 없음) = 꼴 · 금액 그대로 · M01판 = 서버 몫(버림)
"""
from __future__ import annotations
import json
from pathlib import Path
import pytest
@@ -24,11 +18,7 @@ from M02_MasterTemplete import M02_Sangeun_Const as const
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층
ROOT = Path(__file__).resolve().parents[2]
FORM = "GC000211" # 합판거푸집
CARRY = "GC001140" # 인력운반(지게)
ROOF = "지붕 슬래브(경사 20˚ 미만)"
TOOL = "pct:공구손료 및 경장비#0"
F211 = {
"자재지역": "포항",
"유형": "보통",
@@ -46,15 +36,6 @@ def _whole():
return m01.loaded()[1]
def _carry():
return {
**json.loads(json.dumps(_whole().logic(CARRY)["시험입력"], default=str)),
"재료종별": "암석",
"재료형상": "화강암",
"운반회수": 0,
}
def _doc(code, given, **more):
return {
"키": "SK-000001",
@@ -66,47 +47,19 @@ def _doc(code, given, **more):
}
def _sum(doc):
whole = _whole()
return float(calc.run(sd.clean(doc, None, whole), whole)["기준"]["계"])
# ── 식 속 자리 ────────────────────────────────────────────────────────
def test_scan_엔진_차례():
t = "찾기(QC000431, 유형=유형).시공량 * (1 - (높이감률 + 만약(지붕슬래브 == '아님', 0, 17)) / 100)"
got = const.scan(t)
assert [t[a:b] for a, b in got["num"]] == ["1", "0", "17", "100"]
assert [t[a:b] for a, b in got["find"]] == ["찾기(QC000431, 유형=유형).시공량"]
tool = "(형틀목공 * LB000007 + 보통인부 * LB000002) * 1 / 100"
assert [tool[a:b] for a, b in const.scan(tool)["num"]] == ["1", "100"]
assert const.scan("EQ:0201-0012.잡재료율 * 2 + '3t/㎡'")["num"] == [(20, 21)]
assert const.scan("((((") == {"num": [], "find": []} # 못 읽는 식 = 빈
assert const.swap(t, {"2": 20}, {"0": -45}).startswith("(-45) * (1 - ")
assert ", 0, 20)) / 100)" in const.swap(t, {"2": 20}, {})
# ── 금액 = 견본(서버 셈) ──────────────────────────────────────────────
# ── 문서 꼴 ──────────────────────────────────────────────────────────
def test_새_칸_꼴_검사():
whole = _whole()
doc = _doc(
FORM,
F211,
상수덮개={"mid:시공량": {"2": "20"}, TOOL: {}},
표값덮개={},
글줄=[{"자리": "", "글": " 건설표준품셈 6-3-1 "}, {"자리": "mid:시공량", "글": ""}],
까닭={"mid:시공량": "현장 경사 반영", "add:#0": " ", "add:#1/labor:LB000002#0": "x"},
)
got = sd.clean(doc, None, whole)
assert got["상수덮개"] == {"mid:시공량": {"2": 20}} and "표값덮개" not in got
assert got["글줄"] == [{"자리": "", "글": "건설표준품셈 6-3-1"}]
assert got["까닭"] == {"mid:시공량": "현장 경사 반영", "add:#1/labor:LB000002#0": "x"}
for bad in (
{"상수덮개": {"엉뚱": {"0": 1}}},
{"상수덮개": {"mid:시공량": {"a": 1}}},
{"표값덮개": {"mid:운반량": {"0": "글"}}},
{"까닭": {"x": "y"}},
{"글줄": [{"자리": "", "글": "가" * 501}]},
):
@@ -119,9 +72,6 @@ def test_옛_SK_꼴_금액_그대로():
old = _doc(FORM, F211, 덮개={"labor:LB000007#0": {"qty": 0.2}}, 뺀줄=["labor:LB000002#0"])
got = sd.clean(old, None, whole)
assert not set(got) & {*const.NEW, "M01판"}
assert const.formulas(whole.logic(FORM), got) is whole.logic(
FORM
) # 새 덮개 없음 = 그 줄 그대로
assert sd.clean({**old, "M01판": {"mid:시공량": "x"}}, None, whole) == got # M01판 = 서버 몫
+33 -80
View File
@@ -1,39 +1,27 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""792-1 단가산출(SK) 사용자 식 칸 — 변수 줄 · 식 덮개 · 더한줄 수량식 · 이름 꼴 ↔ 엔진 식 · 검사.
"""792-1 식 글 번역 · 옛 SK 식 칸 막음.
- 금액 = 서버 셈 = _분석_650-H2 4 장 견본(인력운반 「할증율 20」 변수 줄 + 보통인부 품 식
× (1 + 할증율 / 100) = 51,501) · 합판거푸집 줄 식 고침 · 공구손료 식 2 % = 51,802(790-2 같은 값)
- 이름 꼴(`×` · `[노임 형틀목공]` · `[별칭]`) ↔ 엔진 식 왕복 = M01 로직 견본 식 전부 같음
- 꼴 상한 — 변수 줄 수 · 이름 꼴 · 자리 겹침 · 괄호 깊이(식 칸 검사 길은 894 에서 걷음)
- 옛 SK(식 칸 없음) = 꼴 · 금액 그대로 · 저장 = 엔진 식 · 틀린 식 저장 400 · 셈 답 덧칸
- B09 사본 굳힘(`GX9#####`) 줄 = 식 칸 그대로 · 다시 셈 같은 금액
- 799-2 — TS 거울(`Formula_Model.ts` · `Const_Model.ts`)은 시트 탭과 함께 걷음 · 서버만 지킴
- 이름 꼴(`×` · `[노임 형틀목공]` · `[별칭]`) ↔ 엔진 식 왕복 = M01 로직 견본 식 전부 같음(M01 수식 탭 · 가져온 식이 씀)
- 식 글 상한 — 괄호 깊이 · 길이
- 옛 SK 식 칸(변수줄 · 식덮개 · 더한줄 수량식)과 상수 · 표값 덮개 = 셈 은퇴(855 2-C1) 뒤 받지 않음 400(855 2-E2)
- [초기화] = 덮개 · 뺀줄 · 그 까닭 걷음 · 빈 옛 식 칸 = 지문 그대로
"""
from __future__ import annotations
import json
from pathlib import Path
import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Flat as flat
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Const as const
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sangeun_Formula as fx
from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층
ROOT = Path(__file__).resolve().parents[2]
FORM, CARRY = "GC000211", "GC001140" # 합판거푸집 · 인력운반(지게)
MAN = "labor:LB000002#0" # 인력운반 보통인부
TOOL = "pct:공구손료 및 경장비#0"
F211 = {"자재지역": "포항", "유형": "보통", "사용횟수": "6회", "높이감률": 0, "지붕슬래브": "아님"}
F211 |= {"폼타이": "아님", "폼타이규격": "12.7㎜", "측압": "3t/㎡", "구멍땜": 0}
PLUS = "무게 / 운반량 / 일운반회수 × (1 + 할증율 / 100)"
def _whole():
@@ -59,23 +47,6 @@ def _sk_doc(code, given, **more):
return {**_doc(code, given), **more}
def _run(doc):
whole = _whole()
return calc.run(sd.clean(doc, None, whole), whole)
def _sum(doc):
return float(_run(doc)["기준"]["계"])
def _plus(**more):
var = [{"이름": "할증율", "식": "20", "자리": ""}]
return _sk_doc(CARRY, _carry(), **({"변수줄": var, "식덮개": {MAN: PLUS}} | more))
# ── 견본 금액 ─────────────────────────────────────────────────────────
# ── 이름 꼴 ↔ 엔진 식 ────────────────────────────────────────────────
def test_이름_꼴_양방향():
whole = _whole()
@@ -98,61 +69,43 @@ def test_이름_꼴_양방향():
assert fx.to_engine(fx.to_name(str(x[f]), one), one) == (str(x[f]), [])
def test_꼴_상한_겹침():
def test_식_글_상한():
assert fx.limits("(" * 13 + "1" + ")" * 13) == [f"괄호가 {fx.DEEP} 겹을 넘음"]
assert fx.limits("1" * (fx.LONG + 1)) == [f"식이 {fx.LONG} 자를 넘음"]
assert fx.limits("'((((((((((((('") == [] # 따옴표 글 안 괄호 안 셈
def test_옛_식_칸_받지_않음():
whole = _whole()
many = [{"이름": f"v{i}", "식": "1", "자리": ""} for i in range(fx.MANY + 1)]
for bad, why in (
({"변수줄": many}, "까지 목록"),
({"변수줄": [{"이름": "1가", "식": "1"}]}, "이름 꼴"),
({"변수줄": [{"이름": "가", "식": "1"}, {"이름": "가", "식": "2"}]}, "같은 이름"),
({"변수줄": [{"이름": "가", "식": "1", "표시": 7}]}, "0~6"),
({"식덮개": {"mid:시공량": "1"}, "상수덮개": {"mid:시공량": {"0": 1}}}, "같이 못 둠"),
({"식덮개": {"labor:LB000007#0": "1"}, "덮개": {"labor:LB000007#0": {"qty": 1}}}, "qty"),
({"식덮개": {"엉뚱": "1"}}, "자리 꼴"),
({"식덮개": {"mid:시공량": "(" * 13}}, "괄호"),
plain = sd.clean(_sk_doc(FORM, F211), None, whole)
for bad in (
{"변수줄": [{"이름": "할증율", "식": "20"}]},
{"식덮개": {"mid:시공량": "1"}},
{"상수덮개": {"mid:시공량": {"0": 1}}},
{"표값덮개": {"mid:운반량": {"0": 30}}},
{"더한줄": [{"종류": "인력", "요소": "LB000002", "수량": 1, "수량식": "2"}]},
):
with pytest.raises(sd.DocError, match=why):
with pytest.raises(sd.DocError, match="옛 식 칸"):
sd.clean(_sk_doc(FORM, F211, **bad), None, whole)
empty = {"변수줄": [], "식덮개": {}, "상수덮개": {}, "표값덮개": {}}
assert sd.clean(_sk_doc(FORM, F211, **empty), None, whole) == plain # 빈 칸 = 옛 SK 그대로
# ── 옛 SK · 저장 · 셈 답 · 펼침 · 초기화 ─────────────────────────────────
# ── 초기화 · 지문 ─────────────────────────────────────────────────────
def _sk(folder, **doc):
with store.at(folder):
made = refs.create("sangeun", {"이름": "내 단가산출", "단위": "식", "더한줄": [], **doc})
return made["이름"]
def test_초기화_걷음():
doc = _sk_doc(CARRY, _carry(), 덮개={MAN: {"qty": 1}}, 까닭={MAN: "할증", "add:#0": "더함"})
got, n = flat.reset("sangeun", doc)
assert n == 1 and got["덮개"] == {} and got["까닭"] == {"add:#0": "더함"} # 더한줄 몫 까닭 남김
assert const.restore(doc)["뺀줄"] == [] and const.covers_n(doc) == 1
def _read(folder, key):
with store.at(folder):
return store.read("sangeun", key)["문서"]
def _calc(folder, doc):
with store.at(folder):
return calc.calc_doc(doc)
def test_펼침_막음_초기화_걷음(world):
mine = world["personal"]
a = _sk(mine, 바탕={"로직": CARRY}, 입력값=_carry(), 변수줄=[{"이름": "할증율", "식": "20"}])
with store.at(mine), pytest.raises(sd.DocError):
const.no_flat(_read(mine, a)) # 식 칸 SK = 안 펼침(저장 · 읽기 펼침 첫머리)
doc, n = flat.reset("sangeun", {**_plus(), "까닭": {MAN: "할증"}})
assert n == 1 and "식덮개" not in doc and "까닭" not in doc and doc["변수줄"]
assert const.restore(_plus(), MAN).get("식덮개") is None
assert const.covers_n(_plus()) == 1
# ── B09 사본 굳힘 ─────────────────────────────────────────────────────
def test_같은_내용_지문_식_칸_가림():
"""식 칸만 다른 SK = 다른 내용(409 같은 것 물음 안 함) · 옛 SK 지문 그대로."""
def test_같은_내용_지문_빈_옛_칸():
"""빈 옛 식 칸 = 옛 SK 지문 그대로."""
from M02_MasterTemplete import M02_Library_Same as same
plain = _doc(CARRY, _carry())
one, two = same.finger("sangeun", plain), same.finger("sangeun", _plus())
assert one and two and one != two
assert same.finger("sangeun", {**plain, "식덮개": {}, "변수줄": []}) == one
assert same.finger("sangeun", {**plain, "식덮개": {}, "변수줄": []}) == same.finger(
"sangeun", plain
)
@@ -163,7 +163,6 @@ def test_북부청_18_줄_자리_셈_엑셀():
"more",
[
{"덮개": {"labor:형틀목공#0": {"qty": 0.2}}},
{"상수덮개": {BURN: {"0": 12}}},
{"뺀줄": [PLY]},
{"더한줄": [{"종류": "인력", "요소": MAN, "수량": 0.01}]},
],
@@ -5,16 +5,10 @@
블록 → 793-2a 내보내기 → 793-2 가져온 식 SK(만들 층 · 엑셀 단가 그대로 · 검산 = 엑셀) ·
같은 내용 = 그 SK 다시 씀 · 산근 없는 옛 HP = 409 · HP 지우면 산근도 지움 ·
STmate 블록 끝전 = 엑셀 계와 맞는 쪽
- 화면 소스 — 단가산출 탭 목록 [가져온 식으로 열기](`Hopyo_SheetSk`) · 시트 모달
(`Sangeun_Detail`) · 머리 판(검산 · [우리 단가로] / [엑셀 단가로] · [원본 글 보기] ·
[이음 고르기] · 소요량 이음) · 부품 상자만 · 700 줄
- 809-1 걷음(요구 703) — [우리 기초로 바꾸기] · 근거 세 단 · 입력 필요 · [이 줄에 잇기] · 옮기기 판정 길 없음
임시 storage(`client` 마당) · M01 원본 그대로.
"""
import re
from pathlib import Path
import helper_m02_hopyo_golden as golden
import pytest
@@ -26,15 +20,8 @@ from M02_MasterTemplete import M02_Template_Layers as layers
# ruff: noqa: F811
from resources.tester.test_m02_hopyo_excel import _post, client, master_hash # noqa: F401
ROOT = Path(__file__).resolve().parents[2]
M02 = ROOT / "M02_MasterTemplete"
API = "/api/m02/layers/personal"
KEY = "HP-000001"
MINE = ("Hopyo_Imported", "Hopyo_ImportedPanel", "Hopyo_SheetSk", "Hopyo_View")
def _src(name: str) -> str:
return (M02 / f"M02_MasterTemplete_{name}.ts").read_text(encoding="utf-8")
def _skcount() -> int:
@@ -97,44 +84,3 @@ def test_STmate_끝전_엑셀_계와_맞는_쪽(tag, code, rule):
got = sx.read(path.name, path.read_bytes())
assert got["옵션"]["SAN_TYP"] == xs.RULE[rule]
assert any(b["코드"] == code for b in got["산근"])
# ── 화면 소스 ─────────────────────────────────────────────────────────
def test_단산_줄_길_잇기():
sk, view = _src("Hopyo_SheetSk"), _src("Hopyo_View")
assert "openImported({" in sk and "dataset.skOpen" in sk # 단가산출 탭 목록 = 가져온 식 모달
assert (
'"/sangeun/from-hopyo"' not in view and "openImported({" in view
) # [수정] 단산 줄 = 가져온 식 모달(미리 보기 · 835-1)
imp = _src("Hopyo_Imported")
assert '"/sangeun/from-hopyo/preview"' in imp and '"/sangeun/from-hopyo"' in imp
assert "/sangeun/imported/${how}" in imp
assert "mountSangeunDetail(" in imp and "saveTemplate(" in imp and "openModal({" in imp
for how in ('run("price"', 'run("link"'):
assert how in imp, how
for gone in ("to-base", "toBase", "onLink", "skPick", "checkJudge", "readJudgeBlock"):
assert gone not in imp, gone # 809-1 · 요구 703
# 옛 M02 수식 나무 화면(「엑셀 원래」 위 줄) 걷음 — 수식 탭 = 공용 수식 문서 화면(802-4b-2)
assert not (M02 / "M02_MasterTemplete_Sangeun_Equation.ts").exists()
def test_머리_판_기초_없음():
panel = _src("Hopyo_ImportedPanel")
for word in ("ToOurs", "ToExcel", "Source", "Link", "Same", "Diff"):
assert f'tx("{word}")' in panel, word
for gone in ("ToBase", "PickBase", "data-basis-tiers", "우리 기초로 바꾸기", "근거 제안"):
assert gone not in panel, gone
model = (M02 / "logic/M02_Hopyo_Imported_Model.ts").read_text(encoding="utf-8")
assert "BasisCand" not in model and "skPick" not in model and "근거후보" not in model
assert not re.search(r"from \"@ui|document\.|fetch\(|sessionStorage\.", model) # 순수
def test_부품상자만_700줄_공용_안_고침():
for name in MINE:
text = _src(name)
assert len(text.splitlines()) <= 700, name
assert not re.search(r"""\bel\(\s*["'](button|input|select)["']""", text), name
assert not re.search(r"""createElement\(\s*["'](button|input|select)["']""", text), name
assert "#" not in "".join(re.findall(r"color:\s*[^;]+", text)), name
for name in ("Labor_Rows", "Labor_SkEdit", "Sangeun_Detail", "Sangeun_Tabs"):
assert "Hopyo_Imported" not in _src(name), name # 공용 쪽은 새 모달을 모름
+15 -8
View File
@@ -47,9 +47,18 @@ def _fake(monkeypatch, rows=(), drop=()):
from M02_MasterTemplete import M02_Doc_Copy as dc
files, live = m01.loaded()
fake = skc.Copy(live, [copy.deepcopy(r) for r in rows])
fake = copy.copy(
live
) # M01 꼴 그대로(값 사본 색인 `skc.Copy` 로 만들면 `dc.base` 가 벗김 · 855 L2 ⓑ)
fake.index = {t: dict(v) for t, v in live.index.items()}
fake.numbers = {t: dict(v) for t, v in live.numbers.items()}
for row in rows:
row, key = copy.deepcopy(row), str(row["키"])
fake.index.setdefault(key[:2], {})[key] = row
if row.get("원문번호"):
fake.numbers.setdefault(key[:2], {})[str(row["원문번호"])] = row
for key in drop:
skc.Copy._own(fake.index, live.index, key[:2]).pop(key, None)
fake.index.get(key[:2], {}).pop(key, None)
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
docs = {k: v for k, v in dc.folder().items() if k not in drop}
docs |= {str(r["키"]): dc.cv.convert(fake, copy.deepcopy(r))[0] for r in rows if "호표" in r}
@@ -93,7 +102,7 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch):
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
got = skc.held(_doc(me, key))
assert PCT in {r["키"] for r in got["로직"]}
assert PCT not in {r["키"] for r in got["로직"]} # 로직 줄 = 문서 사본(855 L2 ⓑ)
assert got["단가"] and all(r["키"][:2] in skc.RES for r in got["단가"])
assert not any(r["키"][:2] in skc.RES for r in got["로직"])
first = _calc(me, _doc(me, key))
@@ -130,17 +139,15 @@ def test_price_refresh_only_on_press(world, monkeypatch):
def test_deleted_keys_keep_last_value(world, monkeypatch):
"""⑤ 사본이 부르는 M01 키(바탕 로직 · 노임)가 지워져도 마지막 값 · 지운키 표지."""
"""⑤ 사본이 부르는 M01 노임이 지워져도 마지막 값 · 지운키 표지(바탕 로직 = M01 이 지우기 막음 409)."""
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
was = _sum(me, key)
lb = next(r["키"] for r in skc.held(_doc(me, key))["단가"] if r["키"].startswith("LB"))
_fake(monkeypatch, drop=[PCT, lb])
with pytest.raises(Exception):
m01.loaded()[1].logic(PCT)
_fake(monkeypatch, drop=[lb])
now = _calc(me, _doc(me, key))
assert now["기준"]["계"] == was
assert {PCT, lb} <= set(now["사본"]["지운키"])
assert {lb} <= set(now["사본"]["지운키"])
with store.at(me):
got = path.preview(key, {"할일": skc.PRICE})
assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"]
+2 -1
View File
@@ -20,6 +20,7 @@ import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Hopyo_Store as hs
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Machine_Hourly as machine
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_San_Emit as em
@@ -142,7 +143,7 @@ def test_nested_stmate_follows_inner(world) -> None:
assert made["검산"]["같음"] is True and made["검산"]["셈"]["계"] == 67383
assert _money(doc) == 67383
assert fh.make(folder, KEY, 2200)["이름"] == made["이름"] # 다시 올려도 같은 SK
assert refs.users(ref) # 쓰는 곳에 바깥 SK
assert library_uses.users(ref) # 쓰는 곳에 바깥 SK
with pytest.raises(store.StoreError) as why:
refs.refuse_used(folder, "sangeun", ref["키"])
assert why.value.status == 409
-34
View File
@@ -45,25 +45,6 @@ def test_조합_상세_카드_서고_한_부품():
assert "openQtyModal({" in combo and "linkAreaCell(" in combo and "saveTemplate(" in combo
def test_단가산출_줄은_SK_문서_모달_저장은_그_SK():
table = _src("M02_MasterTemplete_Labor_Table.ts")
modal = _src("M02_MasterTemplete_Labor_SkEdit.ts")
assert 'ref.키.startsWith("SK-")' in modal # SK 참조 줄만
assert "if (isSkRef(row.참조) && !opt.calc)" in table # 셈 주입(프로젝트 복사본)엔 옛 줄 모달
assert "readOnly: !edit || row.참조.층 !== opt.layer," in table # 위 층 SK = 읽기만
assert re.search(r'readTemplate\(layer, "sangeun", opt\.ref\.키, null, opt\.ref\.주인\)', modal)
assert re.search(
r'saveTemplate\(\s*layer,\s*"sangeun",\s*opt\.ref\.키', modal
) # 저장 = 그 SK 문서
assert (
"mountSangeunDetail(host, doc," in modal and 'mode: "page"' in modal
) # 수식 탭 부품 그대로
assert "await handle.flush();" in modal # 수식 저장 먼저 → 문서 저장
assert "if (!opt.readOnly) head.append(ok);" in modal # 읽기만 = [저장] 없음
assert "if (opened.has(at)) return;" in modal # 빨리 두 번 눌러도 하나
assert "closed: (done) => alive && done && recalc()," in table # 저장했으면 금액 다시 셈
def test_부품상자만_700줄_명사형():
for name in (
"M02_MasterTemplete_Labor_Table.ts",
@@ -119,18 +100,3 @@ def test_옛_판_저장_409(world):
with pytest.raises(store.StoreError) as why:
store.write("sangeun", key, got["판"], got["문서"])
assert why.value.status == 409
def test_808_1_모달_머리_일원화():
"""808-1(요구 701-4 · 5) — 단가산출 줄 모달 머리 = 페이지 머리(보기 고르기 · [단가 갱신] · [재생성]) ·
로직 줄 모달(저장된 일위대가 줄 = 펼친 로직 줄 · 740-1) = 옛 [옵션] · [단가산출로도 저장] · [항목 추가] · [율 줄 추가] 없음 ·
보기 고르기 없이 상세만 + 안내(온 단가산출) · 줄 문서 키 SK-000000 = 수식 문서 안 읽음(404 없음)."""
sk = _src("M02_MasterTemplete_Labor_SkEdit.ts")
assert "slot,\n" in sk and "head.append(slot);" in sk
row = _src("M02_MasterTemplete_Labor_RowModal.ts")
for gone in ("AlsoSk", "createCheckbox", "openLaborInput", "saveAsSk", "Labor_Option"):
assert gone not in row, gone
assert 't("FromSk")' in row
detail = _src("M02_MasterTemplete_Sangeun_Detail.ts")
assert "...(opt.slot ? [] : [" in detail # 머리 칸 있으면 머리 줄 없음
assert "children: [tabs.tools]" in detail and "tabs.picker" not in detail
@@ -145,16 +145,3 @@ def test_origin_card_and_clauses(world) -> None:
("임도품셈", "5-1-2", 4),
]
assert plain is None # 우리 SK = 카드 없음(원문 먼저)
def test_source_find_on_m01_and_m02_panels() -> None:
m02 = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Sangeun_Side.ts").read_text("utf-8")
m01 = (ROOT / "M01_MasterData/M01_MasterData_UI_LogicLab_Side.ts").read_text("utf-8")
assert "createSourceFind" in m02 and "createSourceFind" in m01
assert "originOf" in m02
sheet = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Hopyo_Mine.ts").read_text("utf-8")
block = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Hopyo_SheetSk.ts").read_text("utf-8")
assert "/hopyo-build-all" in sheet and "번: h.번" in sheet
assert '{ layer: "personal", owner: null }' in block and "openImported" in block
detail = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts").read_text("utf-8")
assert "], doc);" in detail # 원문 패널에 SK 문서(가져온 머리 · 810-4 가져온보관)를 넘김
-10
View File
@@ -122,16 +122,6 @@ def test_마스터_층_단가산출_로직_줄_0():
def test_화면_줄_넣기_SK_사본_참조_부품():
table = _src("M02_MasterTemplete_Labor_Table.ts")
pick = _src("M02_MasterTemplete_Labor_SkPick.ts")
assert 'opt.layer !== "project" && !opt.calc ? { layer: opt.layer' in table # 프로젝트 = 옛 길
assert "return void skFromLogic(own, x.키).then(" in table # M01 기초 = SK 사본
assert "own && isSkRef(ref)" in table and "void ownSk(own, ref)" in table # 다른 층 = 사본
assert "if (isSkRef(row.참조) && !opt.calc)" in table # 줄 누름 = SK 수식 모달
assert "/sangeun/from-logic" in pick and "{ 본뜬 }" in pick and "withSameAsk(" in pick
assert (
"fetchSessionUser()" in pick
) # 주인 null = 자기 층 → 서버 참조 꼴(같은 층 SK 를 사본으로 안 만듦)
combo = _src("M02_MasterTemplete_Labor_Combo.ts")
assert "...refCards(doc, calc)" in combo and "key: r.참조.키," in combo # 다이어그램 참조 카드
for text in (table, pick):
assert len(text.splitlines()) <= 700
assert not re.search(r"""\bel\(\s*["'](button|input|select)["']""", text)
+5 -4
View File
@@ -11,6 +11,7 @@ import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Layer_Index as index
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
@@ -26,15 +27,15 @@ LIB = ("sangeun", "precombo", "labor")
def fresh(world, monkeypatch): # noqa: F811
"""색인 기억 비움 — 시험끼리 안 섞임."""
monkeypatch.setattr(index, "_MEM", {})
monkeypatch.setattr(index, "_IDS_LOADED", [])
monkeypatch.setattr(refs, "_IDS", {})
monkeypatch.setattr(library_uses, "_LOADED", [])
monkeypatch.setattr(library_uses, "_IDS", {})
return world
def _forget():
index._MEM.clear()
index._IDS_LOADED.clear()
refs._IDS.clear()
library_uses._LOADED.clear()
library_uses._IDS.clear()
def _sk(folder, name, extra=None):
@@ -18,6 +18,7 @@ from fastapi import HTTPException
from M02_MasterTemplete import M02_Doc_Router as doc_route
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Machine_Hourly as mh
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MyMachine as mym
@@ -104,7 +105,7 @@ def test_save_creates_links_and_stamps(world):
assert f"'개인 {key}'" in text
assert key in [r["키"] for r in saved["단가"]] # 사본에 박힘
assert after["셈"]["계"] == look["셈"]["계"] and after["사본"]["단가새값"] is False
assert _at(me, mym.uses)[key] == [{"키": sk, "이름": "sub1임시"}]
assert _at(me, library_uses.machines)[key] == [{"키": sk, "이름": "sub1임시"}]
def test_same_draft_two_lines(world):
@@ -21,26 +21,3 @@ def test_불러오기_길_층_고정(monkeypatch):
hopyo._root({}, layer, owner, write=True)
hopyo._root({}, layer, owner)
assert seen == [("personal", None, True), ("personal", None, False)] * 3
def test_라우터_루트_모두_고정_함수():
src = (ROOT / "M02_MasterTemplete" / "M02_Hopyo_Router.py").read_text(encoding="utf-8")
assert "import _root as _layer_root" in src
assert "_layer_root(" in src.split("def _root(")[1].split("\n\n")[0]
assert src.count("_layer_root(") == 1 # 층 고르는 길은 이 한 곳뿐
def test_단산_블록_만들기_개인_층만():
src = (ROOT / "M02_MasterTemplete" / "M02_Sangeun_Router.py").read_text(encoding="utf-8")
for fn in ("def sangeun_from_hopyo(", "def sangeun_from_hopyo_preview("):
body = src.split(fn)[1].split("\n@router")[0]
assert "body.층" not in body and "_root(session, layer" not in body, fn
assert '_root(session, "personal", None' in body, fn
def test_화면_층_고름_없음():
m02 = ROOT / "M02_MasterTemplete"
side = (m02 / "M02_MasterTemplete_Hopyo_Side.ts").read_text(encoding="utf-8")
imp = (m02 / "M02_MasterTemplete_Hopyo_Import.ts").read_text(encoding="utf-8")
assert "createSegment" not in side and "writableLayers" not in side + imp
assert '"회사"' not in side + imp and '"마스터"' not in side + imp
+1 -1
View File
@@ -149,7 +149,7 @@ def test_기준_목록_금액_문서_셈():
whole = m01.loaded()[1]
docs, links, _ = world()
for key in ("GF000220", "GC000404", "GX000004"):
for row in st._rows_of(whole, whole.logic(key), False, links):
for row in st._rows_of(whole, docs[key], False, links):
given = st._given(whole, docs[key], row["바꿈"])[0]
want = mc.calc(docs[key], links, given)
assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"])
+111
View File
@@ -0,0 +1,111 @@
"""855-E 2-E4 준비 지킴 — 바탕 기반(`master_base`)만으로 새 계산기가 셈.
- 새 해석기(자식)가 scripts 길만 두고 `master_base` · `master_doc_link` · `master_doc_calc` 를 읽어
견본 로직(기본 + 옵션 표본)을 셈 → 옛 엔진 몸(`master_formula` 무리)이 한 번도 안 읽힘.
- 그 답 지문 = 골든(`golden_855_engine.json` · `test_855_golden` 과 같은 지문 규칙)과 같음.
"""
from __future__ import annotations
import hashlib
import json
import os
import subprocess
import sys
from decimal import Decimal
from pathlib import Path
HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[1]
SCRIPTS = ROOT / "resources" / "master_data" / "scripts"
N = 24 # 견본 로직 수(키 차례 고르게)
ENGINE = ( # 엔진 몸 — 자식에서 읽히면 실패
"master_formula",
"master_formula_check",
"master_formula_sum",
"master_cut",
"master_text",
"master_text_item",
"master_auto",
"master_combo",
"master_sheet_line",
"master_gate",
"master_equation",
"check_master",
)
def _enc(v):
if isinstance(v, Decimal):
return {"$d": str(v)}
raise TypeError(type(v).__name__)
def _dec(d: dict):
return Decimal(d["$d"]) if set(d) == {"$d"} else d
def _child() -> None:
"""자식 — 표준 입력 {키: [[옵션 글, 바뀐 입력]]} → {답: {키: [[옵션 글, 셈 답]]}, 읽힌 엔진: [...]}."""
sys.path.insert(0, str(SCRIPTS))
import master_base as mb
import master_doc_calc as mc
import master_doc_link as ml
import master_machine_files as mmf
folder = Path(os.environ.get("AISLO_MASTER_DIR") or SCRIPTS.parent).resolve()
files = {}
for name in mmf.names(folder): # `M01_MasterData_Store_Cache.loaded` 와 같은 읽기
if name == mmf.NAME and mmf.here(folder):
files[name] = mmf.table(folder)[0]
elif not name.startswith("_"):
raw = (folder / name).read_bytes()
files[name] = json.loads(raw, parse_float=Decimal, parse_int=Decimal)
docs = ml.load_all()
links = ml.Links(mb.Master(files), docs)
want = json.loads(sys.stdin.buffer.read().decode("utf-8"), object_hook=_dec)
out = {}
for key, cases in want.items():
rows = []
for label, changed in cases:
try:
got = mc.calc(docs[key], links, changed)
except Exception:
got = None
rows.append([label, got if got and got.get("셈됨") else None])
out[key] = rows
body = {"답": out, "읽힌 엔진": sorted(m for m in ENGINE if m in sys.modules)}
sys.stdout.buffer.write(json.dumps(body, ensure_ascii=False, default=str).encode("utf-8"))
def test_바탕_기반만으로_새_계산기_지문_골든과_같음():
import helper_855_engine as h
from helper_test_all import spread
rows, _, docs, _ = h.world()
rows = spread([r for r in rows if str(r["키"]) in docs], N)
want = {
str(r["키"]): [[label, changed] for label, _, changed in h.cases(r, True)] for r in rows
}
run = subprocess.run(
[sys.executable, str(Path(__file__)), "--child"],
input=json.dumps(want, ensure_ascii=False, default=_enc).encode("utf-8"),
capture_output=True,
cwd=str(ROOT),
timeout=600,
)
assert run.returncode == 0, run.stderr.decode("utf-8", "replace")[-2000:]
body = json.loads(run.stdout.decode("utf-8"))
assert body["읽힌 엔진"] == [], f"엔진 몸이 읽힘 {body['읽힌 엔진']}"
golden = json.loads((HERE / "golden_855_engine.json").read_text("utf-8"))["지문"]
diff = []
for key, cases in body["답"].items():
got = [[label, h.answer(g)] for label, g in cases]
raw = json.dumps(got, ensure_ascii=False, sort_keys=True)
if hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] != golden[key]:
diff.append(key)
assert len(body["답"]) == len(rows) and not diff, f"지문 다름 {diff}"
if __name__ == "__main__" and "--child" in sys.argv:
_child()
@@ -0,0 +1,50 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""855 L2 ⓑ-1 — 단가산출 값 사본에 M01 로직 줄(GF · GC · GX)을 안 담음 · 옛 저장본의 로직 줄은 안 읽음 ·
일위대가(SC) 값 사본은 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 뺌).
임시 storage · 개인 층. 셈 = 수식 문서 사본(`부름`) · 로직 줄 값 사본이 없어도 금액 같음.
"""
from __future__ import annotations
import copy
import json
from decimal import Decimal
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from resources.tester.test_795_1_sk_copy import _doc, _sk
from resources.tester.test_795_2_sc_copy import PCT, _read, _sc
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
def _logic_rows(doc: dict) -> list[str]:
rows = [r for slot in ("수식", "사본") for r in ((doc.get(slot) or {}).get("로직") or [])]
return [str(r["키"]) for r in rows if str(r["키"])[:2] in skc.LOGIC]
def _sum(folder, doc) -> Decimal:
with store.at(folder):
return Decimal(str(calc.run(doc, m01.loaded()[1])["기준"]["계"]))
def test_저장본에_로직줄_없음_금액_같음(world):
me = world["personal"]
sk = _doc(me, _sk(me, 바탕={"로직": PCT}))
sc = _read(me, "precombo", _sc(me, [{"로직": PCT, "수량": {"손": 1}}]))
assert _logic_rows(sk) == [] and PCT in _logic_rows(sc)
assert _sum(me, sk) > 0
def test_옛_저장본_로직줄은_안_읽음(world):
me = world["personal"]
sk = _doc(me, _sk(me, 바탕={"로직": PCT}))
was = _sum(me, sk)
old = copy.deepcopy(sk) # 옛 꼴 — 값 사본에 바탕 로직 줄(값을 틀리게 바꾼 것)
row = json.loads(json.dumps(m01.loaded()[1].logic(PCT), default=str))
row["호표"] = row["호표"][:1]
old["수식"]["로직"] = [*old["수식"]["로직"], row]
assert skc.held(old)["로직"] == skc.held(sk)["로직"]
assert _sum(me, old) == was
+37 -9
View File
@@ -2,10 +2,11 @@
"""PLAN 856-0 — 단가산출 화면 지킴(가짜 DOM · 진짜 코드 · `helper_856_0_sk_screen.cjs`).
① 단가산출 화면을 열 때 서버 `/sangeun/calc` 부름 0(856-2) · 숨은 상세 몸 DOM · 줄 쌓기 그림
② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 · 셈 주입(프로젝트 사본) 줄
② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 = 안내 · 프로젝트 사본 = 보기만(856-3)
③ 머리 띠(까닭 · M01 개정 · 빠진 줄)가 뜨는 경우 — 줄 쌓기 셈 답 · 사본 표지 견본(856-2 · 짝 잃음 = 덮개 없음)
④ M01 로직 상세 그릇 = 기본정보 접힘 + 줄 쌓기
⑤ 줄 쌓기 [+ 줄] 찾아 넣기 — 빈 낱말로 열어도 종류마다 서버 찾기 · 목록이 그려짐(856-F)
⑥ 머리 칸 고침 — 이름 · 단위 change 뒤 머리 칸 그대로(Tab 으로 옮긴 다음 칸 초점 유지 · 856-G) · 환산만 새로
"""
from __future__ import annotations
@@ -44,20 +45,37 @@ def test_sk_page_open_calls_and_hidden_body() -> None:
def test_labor_row_click() -> None:
sk, logic = _run()["labor"]
# 단가산출 참조 줄 = 그 SK 문서 모달 · 줄 쌓기가 그 키로 보임
# 단가산출 참조 줄 = 그 SK 문서 모달 · 줄 쌓기가 그 키로 보임 · 고칠 수 있음([저장] 있음)
assert sk["skModal"] == 1 and sk["stack"]["shown"] is True
assert sk["stack"]["draws"] == ["SK-000010"] and sk["calc"] == 0
# M01 로직 줄 = 줄 모달(안내 한 줄) · 상세 몸 · 줄 쌓기 · 셈 없음(856-1)
assert logic["skModal"] == 0 and logic["stack"] is None
assert logic["body"] == 0 and logic["banners"] == ["info"] and logic["calc"] == 0
assert sk["admin"] is True and sk["save"] == 1 and sk["files"] == {"reads": 1, "saves": 0}
# M01 로직 줄 = 창 없음 · 안내 알림 한 줄(856-3) · 셈 없음
assert logic["modal"] is None and logic["stack"] is None
assert logic["toasts"] == ["info"] and logic["calc"] == 0
def test_labor_row_click_inject() -> None:
sk, logic = _run()["labor_inject"]
# 셈 주입(프로젝트 사본) = 줄 모달 · 안내 한 줄(856-3 까지) · 셈 없음
for row in (sk, logic):
assert row["modal"] and row["stack"] is None
assert row["body"] == 0 and row["banners"] == ["info"] and row["calc"] == 0
# 셈 주입 원본 층 카드(보기만 표) = 그 층 SK 줄 쌓기 읽기만 · [저장] 없음
assert sk["skModal"] == 1 and sk["stack"]["draws"] == ["SK-000010"]
assert sk["admin"] is False and sk["save"] == 0 and sk["files"]["saves"] == 0
assert logic["modal"] is None and logic["toasts"] == ["info"]
def test_labor_row_click_project_copy() -> None:
got = _run()
sk, logic = got["labor_copy"]
# 856-3 프로젝트 사본 = 그 사본의 굳힌 SK 문서째 줄 쌓기 보기만 — 빈 키 + 문서째(memory) ·
# 고침 칸 잠김 · [저장] 없음 · 층 파일 읽기 · 저장 0 · 서버 셈 길 0
assert sk["skModal"] == 1 and sk["stack"]["shown"] is True
assert sk["stack"]["draws"] == [""] and sk["memory"] == [True]
assert sk["admin"] is False and sk["save"] == 0
assert sk["files"] == {"reads": 0, "saves": 0} and sk["calc"] == 0
assert got["labor_copy_asked"] == ["SK-000010"]
assert logic["modal"] is None and logic["toasts"] == ["info"]
# 사본에 그 문서가 없음 = 창 없음 · 알림(error)
none = got["labor_copy_none"][0]
assert none["modal"] is None and none["toasts"] == ["error"]
def test_head_bands() -> None:
@@ -100,3 +118,13 @@ def test_stack_find_lists_each_kind() -> None:
got = find[f"{side}_{kind}"]
assert got["paths"] == paths, (side, kind, got)
assert got["rows"] >= 1, (side, kind, got)
def test_head_edit_keeps_fields() -> None:
got = _run()["head"]
assert got["order"] == ["이름", "단위"]
# 이름 고침 → 머리를 다시 그리지 않음 = Tab 으로 간 단위 칸이 같은 칸(초점 · 타자 유지) · 고침 알림
assert got["afterName"] == {"same": True, "swaps": 0, "dirty": True}
# 단위 고침 → 칸 그대로 · 환산 자리만 새로 그림
assert got["afterUnit"] == {"same": True, "swaps": 1, "shown": 1}
assert got["doc"] == ["고친 이름", "m2"]
+1 -35
View File
@@ -258,8 +258,6 @@ def test_요소_찾기_기계는_구분_상세구분_실림(client: TestClient)
def test_단가_자동_요소_찾기_저장전_시험계산(client: TestClient) -> None:
one = _get(client, "/api/m01/logic", key=LOGIC_KEY)
labor = one["prices"][key_of("LB:1016")]
assert labor["이름"] == "화약취급공" and labor["값"] > 0
found = _get(client, "/api/m01/elements", group="인력", q="보통인부")
assert key_of("LB:1002") in [x["ref"] for x in found["items"]]
tables = _get(client, "/api/m01/elements", group="소요량", q="암발파", limit=5)
@@ -387,21 +385,11 @@ def test_구분_목록(client: TestClient) -> None:
assert steel["details"]
def test_재료_고르기_줄_단가는_검색어_첫째_자재품목의_낮은_값(client: TestClient) -> None:
"""옛 대표 키 줄이 기본 검색어로 바뀜(PLAN 8-3) — 값은 검색어 첫째(옛 대표) 줄의 낮은 값."""
one = _get(client, "/api/m01/logic", key=key_of("GC000628"))
cond = {"구분": "시멘트·골재", "상세구분": "시멘트", "검색어": "시멘트 전국"}
cement = one["prices"][store.cm.mf.cond_text(cond)]
assert cement["ref"] == "MT004176" and cement["값"] > 0 and cement["후보"] >= 1
def test_전력은_계약종별을_골라야_값이_섬(client: TestClient) -> None:
"""후보 조건 「계약종별: 입력」(PLAN 7-4b 뒤 절반 — 품셈재료 간접 없이 호표에 바로 박음) —
계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인). 화면 단가 미리보기(_pick_brief)는
구분·상세구분 자리로만 후보를 찾아 지역·계약종별 조건은 아직 못 다뤄 None — 아는 구멍."""
계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인)."""
one = _get(client, "/api/m01/logic", key=key_of("GC000893"))
cond = {"이름": "전력량요금", "계약종별": "입력"}
assert one["prices"][store.cm.mf.cond_text(cond)] is None
assert "전력 계약종별" in {x["이름"] for x in one["logic"]["입력"]}
with pytest.raises(store.cm.mf.FormulaError, match="전력 계약종별"):
store.cm.mf.element(store.cm.master(), cond, {})
@@ -531,25 +519,3 @@ def test_재료_고르기_후보_다섯_값(client: TestClient) -> None:
}
assert first["값"] == 18000 and first["관급"] is True # 조달청 100 은 낮은 값에 안 듦
assert second["ref"] == blank["키"] and second["값"] is None
def test_로직_고르기_줄_단가_미리보기(client: TestClient) -> None:
"""호표 요소가 고르기 조건인 줄 — `prices` 열쇠 = 조건 글 · 후보 수와 값 열 다섯."""
for path in sorted(store.FOLDER.glob("로직_*.json")):
rows = json.loads(path.read_text(encoding="utf-8"))["줄"]
hit = next(
(
(row, item["요소"])
for row in rows
for item in row.get("호표") or []
if isinstance(item.get("요소"), dict)
),
None,
)
if hit:
break
row, cond = hit
got = _get(client, "/api/m01/logic", key=row["키"])
brief = got["prices"][store.cm.mf.cond_text(cond)]
assert brief["조건"] == cond and brief["후보"] >= 1
assert set(brief["값들"]) == set(store.cm.mf.SLOTS)
-58
View File
@@ -1,58 +0,0 @@
"""일위대가 실무자료 화면(PLAN 324-4 · 718-1 · 785-4) — 좌측 판 자리 · 권한 · 불러오기 본 칸 · [끝내기] · 떠남.
옛 확인 창 · 고르기 창 · [로직 추가] 「실무 호표」 · 엑셀 보기 모달 시험은 785-7 에서 지움(판정 화면 = `test_642_6_screen`).
"""
import os
from pathlib import Path
HERE = os.path.dirname(os.path.abspath(__file__))
M02 = Path(HERE).parents[1] / "M02_MasterTemplete"
def _text(name: str) -> str:
return (M02 / name).read_text(encoding="utf-8")
def test_좌측_판_자리와_권한():
side = _text("M02_MasterTemplete_UI_Side.ts")
assert 'import { buildHopyoSection } from "./M02_MasterTemplete_Hopyo_Side";' in side
host = side.split('className: "m02-side__lists ui-sidebar-panel"')[1]
# 716-3 차례 — 일위대가 › 구조물 조합 › 구분선 › 일위대가 불러오기 › 도면 양식
order = ("precomboSec,", "summary,", "createDivider(),", "section(hopyo.title, hopyo.body),")
assert [host.index(k) for k in order] == sorted(host.index(k) for k in order)
assert host.index("section(hopyo.title, hopyo.body),") < host.index("drawing,")
assert "canWrite: opt.canWrite," not in side # 옛 [별칭 장부] 걷음(815-2)
assert "hopyo.paint();" in side.split("function paint(): void {")[1]
hopyo_side = _text("M02_MasterTemplete_Hopyo_Side.ts")
# 718-1 · 785-4 — 제목 = 화면 글 키 · [불러오기] = 구조물 조합 층 단추 꼴 → 바로 파일 고르기 → 본 칸 불러오기 보기
assert 'L("M02_HopyoImport")' in hopyo_side and "일위대가 실무자료" not in hopyo_side
start = hopyo_side.split("const start = createButton({")[1].split("start.title")[0]
assert 'label: "불러오기"' in start and 'start.classList.add("m02-layers__btn");' in start
assert "buildHopyoImport({" in hopyo_side and "Hopyo_Wizard" not in hopyo_side
assert not (M02 / "M02_MasterTemplete_Hopyo_Wizard.ts").exists() # 가운데 상세 페이지 없음
assert "uploadHopyo(" in hopyo_side and "openHopyoSheet" not in hopyo_side
assert "buildHopyoLedger" not in hopyo_side and "data-hopyo-ledger" not in hopyo_side
assert not (M02 / "M02_MasterTemplete_Hopyo_Ledger.ts").exists() # 옛 [별칭 장부] 걷음(815-2)
imp = _text("M02_MasterTemplete_Hopyo_Import.ts")
assert 'accept: ".xls,.xlsx,.estx,.stc"' in hopyo_side # 810-3 · 814-1 원파일도
assert "input.hidden = true;" in hopyo_side
choose = hopyo_side.split("async function choose()")[1].split("input.addEventListener")[0]
assert "input.click();" in choose # 누름 하나 — 바로 파일 고르기 창
assert "writableLayers" not in imp + hopyo_side # 837-1 층 고름 걷음 — 늘 개인 층
assert "uploadHopyo(MINE, file)" in hopyo_side
for gone in ("wantSangeun", "STEPS", "second(", "steps.set", "data-hopyo-sangeun"):
assert gone not in imp + hopyo_side, gone # 중간 걸음 · 단가산출 체크 없음
def test_372_2_저장은_개인_층에_삭제는_화면_층_권한():
"""718-1 — 만들 층 = 올린 층 · [끝내기] 로 올린 파일 지움 → 빈 본 칸(785-4: 엑셀 보기 [삭제] 걷음) ·
743-1 — 떠남(화면 바뀜 · 페이지 닫음) = 쥔 파일 지움."""
imp = _text("M02_MasterTemplete_Hopyo_Import.ts")
open_ = imp.split("m.buildHopyoSheet({")[1].split("});")[0]
assert "target: scope," in open_ and "canWrite: true," in open_
assert "onDeleted" not in imp and "dropButton" not in _text("M02_MasterTemplete_Hopyo_Sheet.ts")
assert "a.onEnded();" in imp and "held = false;" in imp
assert 'addEventListener("pagehide", leave)' in imp and " leave,\n" in imp
panel = _text("M02_MasterTemplete_Hopyo_Side.ts")
assert panel.count("open?.imp?.leave()") == 1 and panel.count("open.imp?.leave()") == 1
@@ -142,16 +142,3 @@ def test_입력이_바뀌면_걸린_고름만_풂_화면_짝():
def _src(name):
with open(os.path.join(HERE, "..", "..", "M02_MasterTemplete", name), encoding="utf-8") as f:
return f.read()
def test_로직_자재_줄_누름은_그_로직_옵션_모달_사용자_줄은_그대로():
"""148-1 — 고칠 때 · 읽기만 둘 다 `open: openRow` · 바꾸기 단추 칸은 swap 있을 때만 · 사용자 줄 = openMat."""
# 806-1 — 조합 · 서고 모두 일위대가표 부품 — 로직 자재 바꾸기 · 세 칸은 줄 모달(`Labor_RowModal`) 안
modal = _src("M02_MasterTemplete_Labor_RowModal.ts")
assert (
"open: () => undefined," in modal and "swap: (_r: number, at: number, key: string)" in modal
)
mats = _src("M02_MasterTemplete_Labor_LogicMats.ts")
assert "const tools = swap" in mats
assert 'tr.addEventListener("click", () => on.open(r))' in mats
assert '${on ? " is-open" : ""}' in mats
@@ -118,15 +118,6 @@ def _src(name):
def test_화면_칸_부품_사용자_줄_로직_줄_같은_칸():
marks = _src("M02_MasterTemplete_Labor_MatMarks.ts")
assert '"—"' not in marks # 「—」 항목 없음(162-1)
assert "e.stopPropagation()" in marks # 줄 누름과 따로
rows = _src("M02_MasterTemplete_Labor_MatTable.ts") # 717-3 자재목록 표 나눔
assert "...markCells(mat, on?.mark" in rows and "...markHeads()," in rows
assert "...markCells(" in _src("M02_MasterTemplete_Labor_LogicMats.ts")
modal = _src("M02_MasterTemplete_Labor_RowModal.ts") # 806-1 — 조합 · 서고 모두 줄 모달 안
assert "mark: (_r: number, at: number, key: MatMarkKey, v: string)" in modal
assert "mark: (_i, key, v) =>" in modal
# 서버 허용 값 = 화면 허용 값
api = _src("M02_MasterTemplete_Labor_Api.ts")
for key, allowed in labor.MARKS.items():
+5 -2
View File
@@ -13,6 +13,7 @@ import pytest
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
from resources.tester.test_m02_labor_calc_mirror import _same, _ts
@@ -324,10 +325,12 @@ def test_쓰는_곳_기억은_파일을_고치면_다시_읽음_818_1(world):
ref = {**SYS, "키": sc}
with store.at(world["personal"]):
store.write("labor", "x1", "", {"열": "x1", "담은로직": [{"참조": ref}], "자재": []})
assert len(refs.users(ref)) == 1 and refs.users(ref) == refs.users(ref, refs.use_files())
assert len(library_uses.users(ref)) == 1 and library_uses.users(ref) == library_uses.users(
ref, library_uses.files()
)
ver = store.read("labor", "x1")["판"]
store.write("labor", "x1", ver, {"열": "x1", "담은로직": [], "자재": []})
assert refs.users(ref) == []
assert library_uses.users(ref) == []
def test_복사는_못_읽는_참조를_같이_복사_본뜬(world):
@@ -18,6 +18,7 @@ import { readTemplate } from "../M02_MasterTemplete/M02_MasterTemplete_Api_Fetch
import { formatMoney } from "../common_util/common_util_money";
import { dateText } from "../common_util/common_util_time";
import { calcLabor, type LaborDoc } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Api";
import { lineId } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Calc";
import type { EditKind, ItemCardsHandle } from "../M02_MasterTemplete/M02_MasterTemplete_ItemCards";
import type { ItemSource } from "../M02_MasterTemplete/M02_MasterTemplete_ItemSource";
import type { ValueDoc } from "../M02_MasterTemplete/M02_Labor_Values_Model";
@@ -193,6 +194,13 @@ export function createItemDetail(opts: ItemDetailOptions): ItemDetail {
return { 문서: labor?.줄 ? withCopyValues(labor.줄, values, picks) : {} };
},
calc: () => calcCopy(at),
// 856-3 단가산출 줄 = 사본의 굳힌 SK 문서(`참조사본`) — 줄 쌓기 보기만
sk: async (ref) => {
const labor = (await readCopy(at, "일위대가")) as {
참조사본?: Record<string, Record<string, unknown>>;
} | null;
return labor?.참조사본?.[lineId({ 참조: ref }) ?? ""] ?? null;
},
},
};
}