Merge remote-tracking branch 'origin/dev' into sub_laptop_3
This commit is contained in:
@@ -533,7 +533,10 @@ export function createStackScreen(opt: StackScreenOptions) {
|
||||
const save = async (job?: Record<string, unknown>, done = ft("Saved")): Promise<boolean> => {
|
||||
await loading; // 새 로직 저장 뒤 여는 중이면 다 읽고(캐시 이어 받음)
|
||||
if (!doc || (!job && !dirty())) return true;
|
||||
const send = job ?? (cp ? { 문서: doc, 끊음: cut, 판: version, ...pending() } : { 문서: doc });
|
||||
// M01 = 읽을 때 받은 판도(그 사이 다른 곳에서 바뀌면 409 · 덮지 않음)
|
||||
const send =
|
||||
job ??
|
||||
(cp ? { 문서: doc, 끊음: cut, 판: version, ...pending() } : { 문서: doc, 판: version });
|
||||
const was = saved;
|
||||
showLoadingOverlay();
|
||||
try {
|
||||
|
||||
@@ -16,6 +16,8 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
@@ -30,12 +32,33 @@ import master_equation_link as link # noqa: E402
|
||||
|
||||
OWN_FILE = "수식_자체.json"
|
||||
_memo: dict = {}
|
||||
# 수식 문서 쓰기 한 번에 하나 — 저장 · 지움 · 기계 고르기 목록 등록(`Machine._register_docs`)
|
||||
# ponytail: 프로세스 안 잠금(`Store._LOCK` 과 같은 한계) · 서버를 여럿 띄우면 파일 잠금으로
|
||||
_LOCK = threading.Lock()
|
||||
_HOME = Path(ml.__file__).resolve().parents[1] # 저장소 정본 마스터 폴더
|
||||
STALE = "그 사이 파일이 바뀜 — 고친 것을 버리고 다시 여세요: {v}" # 화면 `Save_Stale` 과 같은 글
|
||||
|
||||
|
||||
def folder() -> Path:
|
||||
return ml.FOLDER
|
||||
|
||||
|
||||
def version_of(doc: dict | None) -> str:
|
||||
"""문서 한 장의 판(저장 글 기준) — 저장본 없음 = 빈 글."""
|
||||
return "" if doc is None else store.version_of(ml.dump(doc).encode("utf-8"))
|
||||
|
||||
|
||||
def put(path: Path, data: dict) -> None:
|
||||
"""수식 문서 파일 한 벌 — 임시 파일 → 교체(원자적) · `_LOCK` 안에서 부름.
|
||||
마스터만 사본으로 바꾼 시험(`Store.FOLDER` ≠ 정본)이 정본 수식 문서를 쓰지 않게 건너뜀."""
|
||||
if path.resolve().parent.parent == _HOME and Path(store.FOLDER).resolve() != _HOME:
|
||||
return
|
||||
tmp = path.with_name(f".{path.name}.tmp")
|
||||
tmp.write_text(ml.dump(data), encoding="utf-8", newline="\n")
|
||||
os.replace(tmp, path)
|
||||
_memo.clear()
|
||||
|
||||
|
||||
def _stamp() -> tuple:
|
||||
return tuple((p.name, p.stat().st_mtime_ns) for p in sorted(folder().glob("수식_*.json")))
|
||||
|
||||
@@ -95,7 +118,8 @@ def read(key: str) -> dict:
|
||||
out = _run(found)
|
||||
up = None if fresh else built(key)
|
||||
more = {"층바탕": {"위": up}} if up is not None else {}
|
||||
return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, **more}
|
||||
판 = version_of(None if fresh else found) # 저장 때 대조(다른 곳에서 바뀌면 409)
|
||||
return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, "판": 판, **more}
|
||||
|
||||
|
||||
def preview(doc: dict, given: dict | None = None) -> dict:
|
||||
@@ -130,6 +154,48 @@ def built(key: str) -> dict | None:
|
||||
return None
|
||||
|
||||
|
||||
def make(key: str) -> bool:
|
||||
"""[로직 복사/생성](`Store_Make.logic_new`) 뒤 수식 문서를 지어 씀 — 빌더(`build_수식문서_802_2`)와
|
||||
같은 변환 · 같은 대조(옛 엔진 = 새 계산기 · 기본 + 옵션 표본 · 부르는 단가산출이 저장본)를 지난 것만
|
||||
(빌더도 그것만 넣음 · 못 지나면 안 씀 = 열면 빈 문서) · 이미 있으면 그대로 · 썼거나 있음 = True."""
|
||||
import importlib
|
||||
|
||||
builder = importlib.import_module("build_수식문서_802_2")
|
||||
files, whole = store.loaded()
|
||||
row = next(
|
||||
(
|
||||
r
|
||||
for data in files.values()
|
||||
if data.get("그룹") == "로직"
|
||||
for r in data.get("줄") or []
|
||||
if str(r.get("키")) == key
|
||||
),
|
||||
None,
|
||||
)
|
||||
doc = built(key) if row is not None else None
|
||||
if doc is None:
|
||||
return False
|
||||
with _LOCK:
|
||||
have = docs()
|
||||
if key in have:
|
||||
return True
|
||||
links = ml.Links(whole, {**have, key: doc})
|
||||
if not builder._calls(doc) <= set(have) or not all(
|
||||
builder.agree(
|
||||
builder.old_answer(whole, row, given), builder.new_answer(links, doc, one)
|
||||
)
|
||||
for _, given, one in builder.cases_of(whole, row)
|
||||
):
|
||||
return False
|
||||
path = folder() / _file_for(key)
|
||||
data = (
|
||||
ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []}
|
||||
)
|
||||
data.setdefault("줄", []).append(doc)
|
||||
put(path, data)
|
||||
return True
|
||||
|
||||
|
||||
def layered(doc: dict, key: str) -> dict:
|
||||
"""848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 ·
|
||||
다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로."""
|
||||
@@ -150,22 +216,27 @@ def layered(doc: dict, key: str) -> dict:
|
||||
return out
|
||||
|
||||
|
||||
def save(doc: dict) -> dict:
|
||||
def save(doc: dict, 판: str | None = None) -> dict:
|
||||
"""`판` = 읽을 때 받은 판(없음 = 대조 안 함 · 빈 글 = 저장본 없던 문서) · 다르면 409."""
|
||||
doc = _check(doc)
|
||||
key = str(doc["키"]).strip()
|
||||
doc = layered(doc, key)
|
||||
name = _file_for(key)
|
||||
path = folder() / name
|
||||
data = ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []}
|
||||
rows = data.setdefault("줄", [])
|
||||
at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None)
|
||||
if at is None:
|
||||
rows.append(doc)
|
||||
else:
|
||||
rows[at] = doc
|
||||
path.write_text(ml.dump(data), encoding="utf-8", newline="\n")
|
||||
_memo.clear()
|
||||
return {"문서": doc, **_run(doc), "파일": name}
|
||||
with _LOCK:
|
||||
doc = layered(doc, key)
|
||||
name = _file_for(key)
|
||||
path = folder() / name
|
||||
data = (
|
||||
ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []}
|
||||
)
|
||||
rows = data.setdefault("줄", [])
|
||||
at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None)
|
||||
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:
|
||||
rows.append(doc)
|
||||
else:
|
||||
rows[at] = doc
|
||||
put(path, data)
|
||||
return {"문서": doc, **_run(doc), "파일": name, "판": version_of(doc)}
|
||||
|
||||
|
||||
def candidates(ask: dict) -> dict:
|
||||
@@ -222,14 +293,14 @@ def users(key: str) -> list[str]:
|
||||
|
||||
def drop(key: str) -> None:
|
||||
"""수식 문서 줄 하나 지움(없으면 그냥)."""
|
||||
name = _where(key)
|
||||
if not name:
|
||||
return
|
||||
path = folder() / name
|
||||
data = ml.load_file(path)
|
||||
data["줄"] = [d for d in data.get("줄") or [] if str(d.get("키")) != key]
|
||||
path.write_text(ml.dump(data), encoding="utf-8", newline="\n")
|
||||
_memo.clear()
|
||||
with _LOCK:
|
||||
name = _where(key)
|
||||
if not name:
|
||||
return
|
||||
path = folder() / name
|
||||
data = ml.load_file(path)
|
||||
data["줄"] = [d for d in data.get("줄") or [] if str(d.get("키")) != key]
|
||||
put(path, data)
|
||||
|
||||
|
||||
def remove(key: str, file: str, version: str, confirmed: bool) -> dict:
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
모델 = `scripts/master_equation.py`(나무 · 변수 표) · `master_equation_edit.py`(고침 · 검사) ·
|
||||
키보드 글 번역 · 상한 = M02 단가산출 식 칸과 한 벌(`M02_Sangeun_Formula` 불러 씀 · 고치지 않음) ·
|
||||
셈 = 엔진 한 벌(③ 서버 단독 · 브라우저 값 받아 적지 않음) · 저장 = 기존 M01 `/save`(개정확인) ·
|
||||
M02 사본(795-1)은 `export_row` · `edit_row` 를 사본 줄로 부름 · 시험 `test_796_1_formula_model.py`.
|
||||
M02 사본(795-1)은 `edit_row` 를 사본 줄로 부름 · `export_row` 는 시험(796-1 · 800-2)의 수식 모델 바탕(옛 엔진 은퇴 때 같이).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -15,7 +15,6 @@ from M01_MasterData import M01_MasterData_Store as store
|
||||
_ERR = (store.cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError)
|
||||
|
||||
import master_equation as meq # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤
|
||||
import master_equation_link as link # noqa: E402
|
||||
import master_equation_edit as me # noqa: E402
|
||||
|
||||
|
||||
@@ -56,8 +55,3 @@ def edit_row(whole, row: dict, edits: list) -> tuple[dict, list[str]]:
|
||||
"""고침 → (새 줄, 까닭) — 까닭 있으면 저장 안 됨(M01 · M02 사본 같은 함수)."""
|
||||
new, why, _ = me.apply(whole, row, edits, words)
|
||||
return new, why
|
||||
|
||||
|
||||
def links(ask: dict) -> dict:
|
||||
"""새 기호 연결 후보(800-3) — {갈래: 표 | 요소 | 로직, 검색, 분류?} → {후보, 더있음} · 읽기만."""
|
||||
return link.candidates(store.loaded()[1], ask)
|
||||
|
||||
@@ -182,22 +182,26 @@ def register(batch: list[dict]) -> Callable[[], None]:
|
||||
|
||||
|
||||
def _register_docs(add: dict[str, list[str]], drop: set[str]) -> None:
|
||||
"""수식 문서의 「기계」 고르기 목록에 로직 목록과 같은 더함 · 뺌 — 바뀐 파일만 다시 씀."""
|
||||
"""수식 문서의 「기계」 고르기 목록에 로직 목록과 같은 더함 · 뺌 — 바뀐 파일만 다시 씀
|
||||
(수식 문서 쓰기 길 `Doc.put` · 잠금 안 — 화면 저장과 겹쳐도 한쪽이 덮지 않음)."""
|
||||
import master_doc_link as ml # noqa: E402
|
||||
|
||||
for path in sorted(ml.FOLDER.glob("수식_*.json")):
|
||||
data, hit = ml.load_file(path), False
|
||||
for doc in data.get("줄") or []:
|
||||
for v in doc.get("변수") or []:
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") != "선택" or v.get("이름") != "기계":
|
||||
continue
|
||||
codes = [c for c in link.get("목록") or [] if str(c) not in drop]
|
||||
codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes]
|
||||
if codes != link.get("목록"):
|
||||
link["목록"], hit = codes, True
|
||||
if hit:
|
||||
path.write_text(ml.dump(data), encoding="utf-8", newline="\n")
|
||||
from M01_MasterData import M01_MasterData_Doc as docs
|
||||
|
||||
with docs._LOCK:
|
||||
for path in sorted(docs.folder().glob("수식_*.json")):
|
||||
data, hit = ml.load_file(path), False
|
||||
for doc in data.get("줄") or []:
|
||||
for v in doc.get("변수") or []:
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") != "선택" or v.get("이름") != "기계":
|
||||
continue
|
||||
codes = [c for c in link.get("목록") or [] if str(c) not in drop]
|
||||
codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes]
|
||||
if codes != link.get("목록"):
|
||||
link["목록"], hit = codes, True
|
||||
if hit:
|
||||
docs.put(path, data)
|
||||
|
||||
|
||||
# ── 쓰는 곳 = `M01_MasterData_Machine_Uses`(수식 문서 기준 · 848-5) ──────────────
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
틀 = `_수식문서_틀.md` 9 장.
|
||||
- 단가산출 기초 목록 · 찾아 넣기 「다른 단가산출」 목록에서 뺌(`strip`) — 키로 열기 · 셈 · 부르기는 그대로
|
||||
- 기종 → 그 기종 기계가 쓰는 기계경비식 · 작업량 틀(`of_kind` · M01 「기계」 화면)
|
||||
- 기계 원문번호 → 그 기종 작업량 틀 문서(`of_machine` · 줄 쌓기 기계 넣기)
|
||||
쓰기 없음 · 로그인 사용자 모두(마스터 읽기).
|
||||
"""
|
||||
|
||||
@@ -75,15 +74,3 @@ def of_kind(group: str, detail: str = "") -> dict[str, list]:
|
||||
used[str(got["키"])] = used.get(str(got["키"]), 0) + 1
|
||||
rule = [{**_brief(k, docs[k]), "기계수": n} for k, n in used.items() if k in docs]
|
||||
return {"기계경비식": rule, "작업량 틀": [_brief(k, d) for k, d in _templates(detail)]}
|
||||
|
||||
|
||||
def of_machine(no: str) -> dict[str, Any]:
|
||||
"""줄 쌓기 기계 넣기 — 기계 원문번호 → {기계 {이름 · 규격 · 상세구분}, 틀 [{… 문서}]}."""
|
||||
row = next((m for m in _machines() if str(m.get("원문번호")) == str(no)), None)
|
||||
if not row:
|
||||
raise store.StoreError(404, f"없는 기계 「{no}」")
|
||||
kind = str(row.get("상세구분") or "")
|
||||
return {
|
||||
"기계": {"이름": row.get("이름"), "규격": row.get("규격") or "", "상세구분": kind},
|
||||
"틀": [{**_brief(k, d), "문서": d} for k, d in _templates(kind)],
|
||||
}
|
||||
|
||||
@@ -318,6 +318,7 @@ def post_logic_formula_preview(body: FormulaPreview) -> dict:
|
||||
class DocBody(BaseModel):
|
||||
문서: dict[str, Any]
|
||||
입력: dict[str, Any] = {}
|
||||
판: str | None = None # 저장 — 읽을 때 받은 판(다르면 409 · 없으면 대조 안 함)
|
||||
|
||||
|
||||
@router.get("/logic/doc")
|
||||
@@ -335,7 +336,7 @@ def post_logic_doc_preview(body: DocBody) -> dict:
|
||||
@router.post("/logic/doc/save")
|
||||
def post_logic_doc_save(body: DocBody) -> dict:
|
||||
"""저장 — 서버가 정본으로 다시 셈 · 문서 파일에 씀 → {문서, 셈, 연결, 파일}."""
|
||||
return _call(doc_screen.save, body.문서)
|
||||
return _call(doc_screen.save, body.문서, body.판)
|
||||
|
||||
|
||||
class RemoveBody(BaseModel):
|
||||
|
||||
@@ -257,12 +257,26 @@ def save(batch: list[dict], confirmed: bool = False) -> dict:
|
||||
_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
|
||||
]
|
||||
return {"files": files, "added": added, "warnings": []}
|
||||
|
||||
|
||||
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)
|
||||
@@ -340,11 +354,14 @@ def _keys() -> list[str]:
|
||||
|
||||
|
||||
def logic_new(logic: dict, owner: str = OWNERS[0]) -> dict:
|
||||
"""새 자체 로직 — 키는 서버가 `GX` 다음 번호로 줌."""
|
||||
"""새 자체 로직 — 키 = 서버가 `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), "")
|
||||
return {**done, "key": key, "logic": store.logic(key)["logic"] if key else {}}
|
||||
made = doc_store.make(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:
|
||||
|
||||
@@ -116,16 +116,50 @@ def save(batch: list[dict]) -> list[dict]:
|
||||
new = [x for x in new + cache.labor_errors(fresh, gone) if x not in old]
|
||||
if new:
|
||||
raise store.StoreError(422, {"errors": new})
|
||||
if book["다음"] != issued:
|
||||
mk.save_book(book, book_path)
|
||||
out = [{"file": name, "version": _write(name, before[name], after[name])} for name in names]
|
||||
# 대장(원자적) → 파일 · 중간에 끊기면 쓴 것 모두 저장 전으로(대장만 · 파일만 앞서가지 않게)
|
||||
raw = {n: (store.FOLDER / n).read_bytes() for n in names if not _machine(n)}
|
||||
book_raw = book_path.read_bytes() if book["다음"] != issued else None
|
||||
tried: list[str] = []
|
||||
try:
|
||||
if book_raw is not None:
|
||||
mk.save_book(book, book_path)
|
||||
out = []
|
||||
for name in names:
|
||||
tried.append(name)
|
||||
out.append({"file": name, "version": _write(name, before[name], after[name])})
|
||||
except BaseException:
|
||||
_undo(tried, before, after, raw, book_path, book_raw)
|
||||
raise
|
||||
# 저장 뒤 — 쓴 파일만 기억에 갈아 끼우고 흔들린 자리를 알려 줘 그 줄만 다시 세게
|
||||
cache.adopt(store.FOLDER, after, fresh, names, narrowed[2])
|
||||
return out
|
||||
|
||||
|
||||
def _machine(name: str) -> bool:
|
||||
return name == mmf.NAME and mmf.here(store.FOLDER) # 기계 = 폴더(826-2)
|
||||
|
||||
|
||||
def _put(path, raw: bytes) -> None:
|
||||
tmp = path.with_name(f".{path.name}.tmp")
|
||||
tmp.write_bytes(raw)
|
||||
os.replace(tmp, path)
|
||||
|
||||
|
||||
def _undo(names, before, after, raw, book_path, book_raw) -> None:
|
||||
"""쓰기 중간 실패 — 쓴(쓰려던) 파일 · 대장을 저장 전 글로 되돌림."""
|
||||
for name in names:
|
||||
if _machine(name):
|
||||
mmf.write(
|
||||
store.FOLDER, before[name], after[name]
|
||||
) # 바뀐 · 더한 · 지운 대를 저장 전으로
|
||||
else:
|
||||
_put(store.FOLDER / name, raw[name])
|
||||
if book_raw is not None:
|
||||
_put(book_path, book_raw)
|
||||
|
||||
|
||||
def _write(name: str, before: dict, after: dict) -> str:
|
||||
if name == mmf.NAME and mmf.here(store.FOLDER): # 기계 = 바뀐 대 파일만(826-2)
|
||||
if _machine(name): # 기계 = 바뀐 대 파일만(826-2)
|
||||
mmf.write(store.FOLDER, after, before)
|
||||
return store.version(name)
|
||||
path = store.FOLDER / name
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
/* =============================================================================
|
||||
* M01_MasterData_UI_Logic_Money.ts
|
||||
* 돈 모양 — 공용 꼴 한 벌(`common_util/common_util_money.ts`)을 다시 내보냄. 부르는 쪽은 그대로.
|
||||
* ========================================================================== */
|
||||
|
||||
export {
|
||||
formatLineMoney,
|
||||
formatMoney,
|
||||
formatNumber,
|
||||
formatPrice,
|
||||
} from "../common_util/common_util_money";
|
||||
@@ -352,11 +352,34 @@ def _no_loop(ref: Ref, trail: list[Ref]) -> None:
|
||||
_no_loop(child, [*trail, child])
|
||||
|
||||
|
||||
#: 층 뿌리 번호 장부 {종류: 발급한 가장 큰 번호} — 지운 끝 번호를 다시 안 씀(854-1 · M01 키대장 규칙과 같은 뜻)
|
||||
ISSUED = "_번호.json"
|
||||
|
||||
|
||||
def _issued() -> dict[str, Any]:
|
||||
try:
|
||||
got = json.loads((store.root() / ISSUED).read_bytes())
|
||||
except (OSError, ValueError):
|
||||
return {}
|
||||
return got if isinstance(got, dict) else {}
|
||||
|
||||
|
||||
def next_key(kind: str) -> str:
|
||||
"""지금 층 그 종류의 다음 키(가장 큰 번호 + 1)."""
|
||||
"""지금 층 그 종류의 다음 키(파일 · 장부 가운데 가장 큰 번호 + 1)."""
|
||||
folder = store.root() / kind
|
||||
have = [int(m.group(2)) for p in folder.glob("*.json") if (m := _KEY.match(p.stem))]
|
||||
return f"{PREFIX[kind]}-{max(have, default=0) + 1:06d}"
|
||||
return f"{PREFIX[kind]}-{max(*have, int(_issued().get(kind) or 0), 0) + 1:06d}"
|
||||
|
||||
|
||||
def _keep_issued(kind: str, key: str) -> None:
|
||||
"""장부에 발급한 번호(더 클 때만)."""
|
||||
from common_util.common_util_json import atomic_write_json
|
||||
|
||||
n = int(_KEY.match(key).group(2))
|
||||
with store._LOCK:
|
||||
got = _issued()
|
||||
if int(got.get(kind) or 0) < n:
|
||||
atomic_write_json(store.root() / ISSUED, {**got, kind: n})
|
||||
|
||||
|
||||
def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]:
|
||||
@@ -364,10 +387,13 @@ def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]:
|
||||
for _ in range(5):
|
||||
key = next_key(kind)
|
||||
try:
|
||||
return store.write(kind, key, "", {**doc, "키": key})
|
||||
got = store.write(kind, key, "", {**doc, "키": key})
|
||||
except store.StoreError as e:
|
||||
if e.status != 409 or not isinstance(e.detail, dict):
|
||||
raise
|
||||
else:
|
||||
_keep_issued(kind, key)
|
||||
return got
|
||||
raise _bad("새 키를 못 잡음 — 다시 누름", 409)
|
||||
|
||||
|
||||
|
||||
@@ -1,17 +1,20 @@
|
||||
"""M02 기준 목록 · 계산서 보기(PLAN 704-1 · 704-2 · 요구서 4장 8) — 로직 고르기 창이 읽음.
|
||||
"""M02 기준 목록 · 계산서 보기(PLAN 704-1 · 704-2 · 855-C 2-C4 · 요구서 4장 8) — 로직 고르기 창.
|
||||
|
||||
기준 목록 = 단가산출 로직 하나를 대표 규격으로 펼친 줄(품명 · 규격 · 단위 · 금액 · 출처 · 공종).
|
||||
대표 규격 = 고르기 입력 값 전부 · 표 찾기 조건으로 쓰이는 수 입력은 그 표 줄마다 값 하나(범위 줄은
|
||||
위 끝) · 그 밖 연속 값 입력은 견본 자동값(`master_auto.values`) 한 줄 · 지역 = 자동값(전국평균).
|
||||
펼침 = 바탕(자동값 · 규격 축은 첫 대표 값) 한 줄 + 규격 축마다 값 하나씩 바꾼 줄(곱하지 않음 ·
|
||||
기준 목록 = 단가산출 기초 하나를 대표 규격으로 펼친 줄(품명 · 규격 · 단위 · 금액 · 출처 · 공종).
|
||||
대표 규격 = 수식 문서 선택 변수(`선택 목록`) 값 전부 · 표 조건으로 바로 쓰이는 입력 변수는
|
||||
그 표 줄마다 값 하나(범위 줄은 위 끝) · 지역 = 문서 기본값(전국평균) 한 벌 ·
|
||||
바탕 = 문서 변수 기본값(`연결.값`).
|
||||
펼침 = 바탕(규격 축은 첫 대표 값) 한 줄 + 규격 축마다 값 하나씩 바꾼 줄(곱하지 않음 ·
|
||||
바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌).
|
||||
금액 = M01 엔진 식 + B09 산근 끝수(줄마다 버림 · `M02_Logic_Settle` · 근거 지식DB
|
||||
`technical_info/01_임도/05_원가정보/단수처리_규칙.md`) · 최신 판 노임(마스터 판).
|
||||
목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개 · 수 분) → 프로세스 메모리 + 파생 저장본
|
||||
(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 내용 지문 + `SHAPE` · 같으면 안 셈 ·
|
||||
금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) ·
|
||||
계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판).
|
||||
(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.)
|
||||
목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본
|
||||
(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` ·
|
||||
같으면 안 셈 ·
|
||||
셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸).
|
||||
실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음.
|
||||
계산서 = `master_text.lines`(줄 「석공 | 268,908 * 0.1 = 26,891」 · 비목 소계 · 계) + 같은 끝수 값.
|
||||
이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫).
|
||||
M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인).
|
||||
"""
|
||||
|
||||
@@ -26,15 +29,18 @@ from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from common_util.common_util_derived_store import derived_key, read_derived, write_derived
|
||||
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_Inputs as labor_inputs
|
||||
from M02_MasterTemplete import M02_Logic_Settle as settle
|
||||
from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
|
||||
mf = m01.cm.mf
|
||||
import master_sheet_line as msl # noqa: E402 — 계산서 줄 덧칸(714-1) · scripts 길은 `m01` 이 둠
|
||||
import master_doc as md # noqa: E402 — scripts 길은 `m01` 이 둠
|
||||
import master_doc_calc as mc # noqa: E402
|
||||
import master_doc_link as ml # noqa: E402
|
||||
import master_doc_text as mdt # noqa: E402 — 계산서 줄 글(줄 쌓기 산출근거와 같은 규칙)
|
||||
|
||||
SHAPE = 3 # 줄 꼴이 바뀌면 올림 — 옛 저장본을 안 씀
|
||||
SHAPE = 4 # 줄 꼴 · 셈이 바뀌면 올림 — 옛 저장본을 안 씀(4 = 855-C 문서 셈)
|
||||
KIND = "m02_logic_standard"
|
||||
REGION = "지역" # 지역 = 자동값 한 벌(정함 8)
|
||||
QUIET = ("해당 없음", "없음") # 규격 글에서 뺄 값
|
||||
@@ -95,7 +101,7 @@ def words_of(row: dict) -> list[str]:
|
||||
|
||||
|
||||
def _range_label(table: dict, low: Any, high: Any, unit: str) -> str:
|
||||
f = m01.mtx.fmt
|
||||
f = mdt.eq_text
|
||||
if low is None:
|
||||
return f"{f(high)}{unit} 이하"
|
||||
if high is None:
|
||||
@@ -118,29 +124,52 @@ def _table_reps(whole: Any, ref: str, cond: str, unit: str) -> list[tuple[Any, s
|
||||
continue
|
||||
if not ranged:
|
||||
if isinstance(have, Decimal):
|
||||
out.setdefault(have, f"{m01.mtx.fmt(have)}{unit}")
|
||||
out.setdefault(have, f"{mdt.eq_text(have)}{unit}")
|
||||
continue
|
||||
low, high = have
|
||||
tries = [v for v in (high, low, (low or 0) + 1) if isinstance(v, Decimal)]
|
||||
got = next((v for v in tries if m01.cm.mf._match(table, r, cond, v)), None)
|
||||
got = next((v for v in tries if ml._match(table, r, cond, v)), None)
|
||||
if got is not None:
|
||||
out.setdefault(got, _range_label(table, low, high, unit))
|
||||
return sorted(out.items())
|
||||
|
||||
|
||||
def axes(whole: Any, logic: dict) -> tuple[dict, list[tuple[str, list[tuple[Any, str]]]]]:
|
||||
"""(바탕 입력, [(입력 이름, [(값, 글) …]) …]) — 규격 축 = 지역 뺀 고르기 · 표 찾기 수 입력."""
|
||||
base = m01.mau.values(whole, logic)
|
||||
finds, _ = m01.mau._uses(logic)
|
||||
def _default(var: dict) -> Any:
|
||||
"""문서 변수 기본값(`연결.값`) — 수 글은 수로."""
|
||||
value = (var.get("연결") or {}).get("값")
|
||||
if isinstance(value, str) and value.strip():
|
||||
num = mdt._dec(value)
|
||||
return value if num is None else num
|
||||
return value
|
||||
|
||||
|
||||
def axes(whole: Any, doc: dict) -> tuple[dict, list[tuple[str, list[tuple[Any, str]]]]]:
|
||||
"""(바탕 입력, [(변수 열쇠, [(값, 글) …]) …]) — 규격 축 = 지역 뺀 선택 변수(`선택 목록`) ·
|
||||
표 조건으로 바로 쓰이는 입력 변수(그 표 줄마다 값 하나) · 바탕 = 문서 기본값."""
|
||||
found = [
|
||||
v for v in doc.get("변수") or [] if (v.get("연결") or {}).get("갈래") in ("선택", "입력")
|
||||
]
|
||||
base = {str(v["열쇠"]): _default(v) for v in found}
|
||||
ids = {md.var_id(v): str(v["열쇠"]) for v in found}
|
||||
finds: dict[str, list[tuple[str, str]]] = {}
|
||||
for v in doc.get("변수") or []:
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") != "표":
|
||||
continue
|
||||
for cond, expr in (link.get("조건") or {}).items():
|
||||
node = mdt.node_of(expr)
|
||||
if node and node[0] == "var" and node[1] in ids:
|
||||
finds.setdefault(ids[node[1]], []).append((str(link.get("표")), cond))
|
||||
out = []
|
||||
for spec in logic.get("입력") or []:
|
||||
name = spec["이름"]
|
||||
for var in found:
|
||||
name, link = str(var["열쇠"]), var["연결"]
|
||||
if name == REGION:
|
||||
continue
|
||||
unit = str(spec.get("단위") or "")
|
||||
if spec.get("고르기"):
|
||||
unit = str(var.get("단위") or "")
|
||||
if link["갈래"] == "선택":
|
||||
spec = {"이름": name, "고르기": link.get("목록") or []}
|
||||
labels = labor_inputs._labels(whole, spec)
|
||||
reps = [(v, str(labels.get(v, m01.mtx.fmt(v) if isinstance(v, Decimal) else v)))
|
||||
reps = [(v, str(labels.get(v, mdt.eq_text(v) if isinstance(v, Decimal) else v)))
|
||||
for v in spec["고르기"]] # fmt: skip
|
||||
elif name in finds:
|
||||
seen: dict[Any, str] = {}
|
||||
@@ -172,18 +201,34 @@ def _unit(logic: dict) -> str:
|
||||
return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit)
|
||||
|
||||
|
||||
def _money(whole: Any, logic: dict, given: dict) -> Decimal | None:
|
||||
if not str(logic.get("결과단위") or "").startswith("원"):
|
||||
return None
|
||||
def _links(whole: Any) -> Any:
|
||||
return ml.Links(whole, m01_doc.docs())
|
||||
|
||||
|
||||
def _calc(doc: dict, links: Any, given: dict) -> dict | None:
|
||||
try:
|
||||
got = settle.settle(whole, str(logic["키"]), m01.cm.mf.fill_empty(logic, given))
|
||||
except (m01.cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError):
|
||||
got = mc.calc(doc, links, given)
|
||||
except Exception: # noqa: BLE001 — 계산기는 예외 없음이 원칙 · 혹시 = 못 셈
|
||||
return None
|
||||
return got.get("계", got.get("결과"))
|
||||
return got if got.get("셈됨") else None
|
||||
|
||||
|
||||
def _rows_of(whole: Any, logic: dict, blocked: bool) -> list[dict]:
|
||||
base, ax = axes(whole, logic)
|
||||
def _money(doc: dict, links: Any, given: dict) -> Decimal | None:
|
||||
"""돈 기초(결과단위 「원…」)의 계(돈 아닌 결과 문서 = 결과) — 못 셈 = None."""
|
||||
if not str(doc.get("결과단위") or "").startswith("원"):
|
||||
return None
|
||||
got = _calc(doc, links, given)
|
||||
if got is None:
|
||||
return 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 []
|
||||
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)]
|
||||
@@ -201,7 +246,7 @@ def _rows_of(whole: Any, logic: dict, blocked: bool) -> list[dict]:
|
||||
out = []
|
||||
for change in changes:
|
||||
given = {**base, **change}
|
||||
money = _money(whole, logic, given)
|
||||
money = _money(doc, links, given)
|
||||
if change and money == 0: # 표에 없는 규격 조합(견치돌 · 뒷길이 25 따위) — 0 원 줄은 뺌
|
||||
continue
|
||||
out.append(
|
||||
@@ -231,15 +276,19 @@ def _stamp() -> str:
|
||||
if not name.startswith("_"):
|
||||
sha.update(name.encode())
|
||||
sha.update(hashlib.sha1(m01.cm.mmf.raw(m01.FOLDER, name)).digest())
|
||||
for path in sorted(m01_doc.folder().glob("수식_*.json")): # 수식 문서(855-C · 셈 정본)
|
||||
sha.update(path.name.encode())
|
||||
sha.update(hashlib.sha1(path.read_bytes()).digest())
|
||||
return sha.hexdigest()
|
||||
|
||||
|
||||
def _chunk(keys: list[str], blocked: set[str]) -> list[dict]:
|
||||
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음)."""
|
||||
whole = m01.loaded()[1]
|
||||
links = _links(whole)
|
||||
out = []
|
||||
for key in keys:
|
||||
out += _rows_of(whole, whole.logic(key), key in blocked)
|
||||
out += _rows_of(whole, whole.logic(key), key in blocked, links)
|
||||
return out
|
||||
|
||||
|
||||
@@ -268,23 +317,25 @@ def _make(files: dict, whole: Any, key: str) -> None:
|
||||
value = build(files, WORKERS)
|
||||
write_derived(layers.storage_root(), KIND, key, value)
|
||||
with _LOCK:
|
||||
if _MEMO.get("whole") is whole:
|
||||
if _MEMO.get("key") == key:
|
||||
_MEMO.update(value=value)
|
||||
except Exception as e: # noqa: BLE001 — 다음 요청이 다시 셈
|
||||
print(f"[M02 기준 목록] 셈 실패: {e}", file=sys.stderr)
|
||||
finally:
|
||||
with _LOCK:
|
||||
if _MEMO.get("whole") is whole:
|
||||
if _MEMO.get("key") == key:
|
||||
_MEMO["job"] = None
|
||||
|
||||
|
||||
def listing() -> dict:
|
||||
"""기준 목록 `{판, 공종, 줄, 준비}` — 메모리 → 파생 저장본 → 뒤에서 셈(그동안 빈 줄)."""
|
||||
files, whole = m01.loaded()
|
||||
docs = m01_doc.docs() # 수식 문서를 고치면 새 묶음(같은 내용이면 같은 묶음)
|
||||
with _LOCK:
|
||||
if _MEMO.get("whole") is not whole:
|
||||
if _MEMO.get("whole") is not whole or _MEMO.get("docs") is not docs:
|
||||
_MEMO.clear()
|
||||
_MEMO.update(whole=whole, key=derived_key(KIND, SHAPE, _stamp()), value=None, job=None)
|
||||
key = derived_key(KIND, SHAPE, _stamp())
|
||||
_MEMO.update(whole=whole, docs=docs, key=key, value=None, job=None)
|
||||
if _MEMO["value"] is None and _MEMO["job"] is None:
|
||||
got = read_derived(layers.storage_root(), KIND, _MEMO["key"])
|
||||
if got:
|
||||
@@ -312,8 +363,8 @@ def _quiet(fn) -> None:
|
||||
print(f"[M02 기준 목록] 데움 실패: {e}", file=sys.stderr)
|
||||
|
||||
|
||||
def _given(whole: Any, logic: dict, change: dict) -> tuple[dict, list]:
|
||||
base, ax = axes(whole, logic)
|
||||
def _given(whole: Any, doc: dict, change: dict) -> tuple[dict, list]:
|
||||
base, ax = axes(whole, doc)
|
||||
known = {name: dict(reps) for name, reps in ax}
|
||||
for name, value in (change or {}).items():
|
||||
if name not in known:
|
||||
@@ -326,28 +377,19 @@ def _given(whole: Any, logic: 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)
|
||||
except m01.cm.mf.FormulaError as e:
|
||||
raise m01.StoreError(404, str(e)) from e
|
||||
given, ax = _given(whole, logic, change)
|
||||
filled = m01.cm.mf.fill_empty(logic, given)
|
||||
got = msl.annotate(files, key, filled, m01.mtx.lines(files, key, filled)) # 줄 덧칸(714-1)
|
||||
done = settle.settle(whole, key, filled)
|
||||
if "결과" not in done: # 돈 로직 — 줄마다 버림(B09 산근 규칙)
|
||||
settle.apply(got.get("groups") or [], m01.cm.mf.run(whole, key, filled), done)
|
||||
got["계"] = done["계"]
|
||||
groups = [
|
||||
{
|
||||
"비목": g["비목"],
|
||||
"소계": g.get("소계"),
|
||||
"끝수": g.get("끝수") or "",
|
||||
"줄": [{k: line.get(k) for k in ("이름", "글", "금액", *msl.KEYS)} for line in g["줄"]],
|
||||
}
|
||||
for g in got.get("groups") or []
|
||||
]
|
||||
if doc is None:
|
||||
raise m01.StoreError(404, f"수식 문서 없음 「{key}」")
|
||||
given, ax = _given(whole, doc, change)
|
||||
links = _links(whole)
|
||||
got = _calc(doc, links, given) or {}
|
||||
money = str(doc.get("결과단위") or "").startswith("원") and "결과" not in doc
|
||||
return labor_inputs._num(
|
||||
{
|
||||
"키": key,
|
||||
@@ -357,8 +399,8 @@ def sheet(key: str, change: dict) -> dict:
|
||||
"출처": labor_inputs.sources(logic) or "",
|
||||
"판": edition(files),
|
||||
"입력": given,
|
||||
"묶음": groups,
|
||||
"계": got.get("계"),
|
||||
"기준단위": got.get("기준단위"),
|
||||
"묶음": mdt.sheet_groups(doc, got, links) if got and money else [],
|
||||
"계": got.get("계") if money else got.get("결과"),
|
||||
"기준단위": _unit(logic) or None,
|
||||
}
|
||||
)
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
기계표 = M01 + 지금 층 내 기계(821-1 · `M02_MyMachine` — 식은 채운 칸으로 고른 같은 GC 식 · 직접 = 그 값) ·
|
||||
층을 모르는 길(`/api/m02/logic-lib/machine-hourly`)은 M01 만.
|
||||
셈 한 길(842-3) = 식 문서 계산기(`master_doc_calc` · 기계 줄 인력 · 잡품 목록을 바탕 덮음으로 얹음 —
|
||||
`master_doc_cover.row_entry`) · 식 문서 없는 식만 옛 로직 엔진 · 조종원 유무 = 인력 줄(`master_machine_crew.view`).
|
||||
`master_doc_cover.row_entry`) · 식 문서 없는 식 = 못 셈 + 까닭(855 2-B2 · 옛 엔진 폴백 걷음) · 조종원 유무 = 인력 줄(`master_machine_crew.view`).
|
||||
식 고름 한 곳(822-2 · `pick`) = ㉠ 원문번호가 식 「기계」 목록에 있으면 그 식(짝 차례) ㉡ 그 기계만의 식
|
||||
(`_own`) ㉢ 없으면 꼴(채운 칸 · `M02_MyMachine.logic_key`) — M01 [새 기계] · 불러오기 · 데이터 흐름 ·
|
||||
줄 쌓기 · 단가산출 기초가 다 이것을 씀 · 못 고름 · 값 모자람 = 까닭 글(`why`).
|
||||
@@ -183,39 +183,22 @@ def hourly(key: str) -> dict[str, Any]:
|
||||
logic = pick(row)
|
||||
if lack := why(row, logic):
|
||||
return {"ok": False, "reason": lack, **({"로직": logic["키"]} if logic else {})}
|
||||
args = "".join( # 빈칸 든 입력 이름(「전력 계약종별」 · 820-1 파워트로웰)은 따옴표로
|
||||
f", {n if (n := i['이름']).isidentifier() else repr(n)}='{(i.get('고르기') or [''])[0]}'"
|
||||
for i in logic.get("입력") or []
|
||||
if i.get("이름") != "기계"
|
||||
)
|
||||
if (got := doc_sums(row, logic, whole)) is not None:
|
||||
return got if not got["ok"] else {"ok": True, "이름": row.get("이름"), "규격": row.get("규격"),
|
||||
"로직": logic["키"], "원문번호": code, **got["합"]} # fmt: skip
|
||||
mine = f", 기계='{code}'" if takes_machine(logic) else ""
|
||||
call = f"로직({logic['키']}{mine}{args})"
|
||||
line = {"종류": "로직", "요소": call, "이름": "기계", "단위": "시간", "수량": "1"}
|
||||
holder = {
|
||||
"키": "", "원문번호": "", "이름": "기계 시간", "결과단위": "원/식", "출처": "자체",
|
||||
"입력": [], "중간": [], "호표": [line], "덧줄": [], "끝수": None,
|
||||
} # fmt: skip
|
||||
got = store.calc("", {}, holder, None)
|
||||
if not got.get("ok") or "sums" not in got:
|
||||
return {"ok": False, "reason": got.get("reason") or "셈 못 함"}
|
||||
sums = {k: float(got["sums"][k]) for k in (*cm.mf.COST_ITEMS, "계")}
|
||||
# 804-3 줄 쌓기 기계 줄 = 이 로직 + 기계='원문번호'
|
||||
return {
|
||||
"ok": True,
|
||||
"이름": row.get("이름"),
|
||||
"규격": row.get("규격"),
|
||||
"로직": logic["키"],
|
||||
"원문번호": code,
|
||||
**sums,
|
||||
}
|
||||
got = hour(row, logic, whole) # 804-3 줄 쌓기 기계 줄 = 이 로직 + 기계='원문번호'
|
||||
if not got["ok"]:
|
||||
return got
|
||||
return {"ok": True, "이름": row.get("이름"), "규격": row.get("규격"), "원문번호": code, **got}
|
||||
|
||||
|
||||
def hour(row: dict, logic: dict, index: Any) -> dict[str, Any]:
|
||||
"""시간당 한 몸(`hourly` · `brief` · `M02_MyMachine.hourly`) — {ok, 로직, 노무비 · 재료비 · 경비 · 계} |
|
||||
{ok False, reason, 로직}."""
|
||||
got = doc_sums(row, logic, index)
|
||||
return {"ok": True, "로직": logic["키"], **got["합"]} if got["ok"] else got
|
||||
|
||||
|
||||
def doc_sums(row: dict, logic: dict, index: Any) -> dict | None:
|
||||
"""셈 한 길(842-3) — 식 문서 계산기 + 기계 줄 목록(바탕 덮음) · 입력 = 식 기본값 ·
|
||||
{ok, 합 {노무비 · 재료비 · 경비 · 계}} | {ok False, reason} · 식 문서 없음 = None(옛 로직 엔진)."""
|
||||
{ok, 합 {노무비 · 재료비 · 경비 · 계}} | {ok False, reason, 로직} · 식 문서 없음 = 못 셈(855 2-B2)."""
|
||||
import master_doc_calc as mc
|
||||
import master_doc_cover as mcv
|
||||
import master_doc_link as ml
|
||||
@@ -224,8 +207,12 @@ def doc_sums(row: dict, logic: dict, index: Any) -> dict | None:
|
||||
|
||||
docs = m01doc.docs()
|
||||
doc = docs.get(str(logic.get("키")))
|
||||
if doc is None:
|
||||
return None
|
||||
if doc is None: # 854-2 이후 수식 문서 없는 로직 0 — 옛 엔진 폴백 없음
|
||||
return {
|
||||
"ok": False,
|
||||
"reason": f"식 문서 없음 — 「{logic.get('키')}」",
|
||||
"로직": logic.get("키"),
|
||||
}
|
||||
given = {"기계": str(row.get("원문번호"))} if takes_machine(logic) else {}
|
||||
shaped = mcv.cover_doc(doc, given, None, mcv.row_entry(doc, row.get("값")))
|
||||
got = mc.calc(shaped, ml.Links(index, docs), given)
|
||||
@@ -235,22 +222,26 @@ def doc_sums(row: dict, logic: dict, index: Any) -> dict | None:
|
||||
return {"ok": True, "합": {k: float(got[k]) for k in (*cm.mf.COST_ITEMS, "계")}}
|
||||
|
||||
|
||||
_BRIEF: dict[tuple, dict] = {}
|
||||
#: {키: (색인, 줄)} — 색인이 바뀌면 비움 · 꺼낼 때 `is` 확인(옛 색인 주소 재사용 · 옛 값 막음 · 854-1)
|
||||
_BRIEF: dict[str, tuple[Any, dict]] = {}
|
||||
_BRIEF_OF: list[Any] = [None]
|
||||
|
||||
|
||||
def brief(keys: list[str]) -> list[dict[str, Any]]:
|
||||
"""기계 창 목록 · 양식(827-1) — M01 기계 줄 값 + 시간당(`hourly` 와 같은 식 · 입력 기본값 ·
|
||||
마스터를 다시 읽지 않고 색인 위에서 셈 · 색인마다 메모) · 키 · 원문번호로 찾음 · 없는 키 = 뺌."""
|
||||
import master_cut as mcut
|
||||
|
||||
from M02_MasterTemplete.M02_Item_Prices import to_json
|
||||
|
||||
index, mf = store.loaded()[1], cm.mf
|
||||
if len(_BRIEF) > 2000: # ponytail: 통째 비움 · 기계 수(655)의 세 배
|
||||
# ponytail: 통째 비움 · 기계 수(655)의 세 배
|
||||
if _BRIEF_OF[0] is not index or len(_BRIEF) > 2000:
|
||||
_BRIEF.clear()
|
||||
_BRIEF_OF[0] = index
|
||||
out = []
|
||||
for key in keys[:60]:
|
||||
if (got := _BRIEF.get((id(index), key))) is None:
|
||||
hit = _BRIEF.get(key)
|
||||
got = hit[1] if hit and hit[0] is index else None
|
||||
if got is None:
|
||||
try:
|
||||
row = (index.numbers.get("EQ") or {}).get(key) or index.get(key)
|
||||
except mf.FormulaError:
|
||||
@@ -259,20 +250,10 @@ def brief(keys: list[str]) -> list[dict[str, Any]]:
|
||||
continue
|
||||
logic = pick(row)
|
||||
head = {k: row.get(k) for k in ("키", "원문번호", "이름", "규격")}
|
||||
if lack := why(row, logic):
|
||||
hour = {"ok": False, "reason": lack}
|
||||
elif (by_doc := doc_sums(row, logic, index)) is not None:
|
||||
hour = {"ok": True, "로직": logic["키"], **by_doc["합"]} if by_doc["ok"] else by_doc
|
||||
else:
|
||||
given = {i["이름"]: (i.get("고르기") or [""])[0] for i in logic.get("입력") or []}
|
||||
if takes_machine(logic):
|
||||
given["기계"] = str(row.get("원문번호"))
|
||||
sums = mcut.engine(
|
||||
index, logic["키"], mf.run(index, logic["키"], mf.fill_empty(logic, given))
|
||||
)
|
||||
hour = {"ok": True, "로직": logic["키"]}
|
||||
hour |= {k: float(sums[k]) for k in (*cm.mf.COST_ITEMS, "계")}
|
||||
got = _BRIEF[(id(index), key)] = {**head, "값": to_json(row.get("값")), "시간당": hour}
|
||||
lack = why(row, logic)
|
||||
hours = {"ok": False, "reason": lack} if lack else hour(row, logic, index)
|
||||
got = {**head, "값": to_json(row.get("값")), "시간당": hours}
|
||||
_BRIEF[key] = (index, got)
|
||||
out.append(got)
|
||||
return out
|
||||
|
||||
|
||||
@@ -24,57 +24,6 @@
|
||||
white-space: pre-wrap;
|
||||
}
|
||||
|
||||
.m02-hopyo__search {
|
||||
max-width: 320px;
|
||||
}
|
||||
|
||||
/* 실무자료 표 — 한글은 낱말 단위로만 줄바꿈(두세 글자마다 안 갈라짐) · 너무 긴 낱말만 쪼갬 */
|
||||
.m02-hopyo__table :is(th, td) {
|
||||
word-break: keep-all;
|
||||
overflow-wrap: break-word;
|
||||
}
|
||||
|
||||
/* 우리 로직 칸 — 대상 여럿 = 칸 안 여러 줄(이름 · 키 · 몫 · 배 칸 · [옵션]) */
|
||||
.m02-hopyo__parts {
|
||||
min-width: 11em;
|
||||
}
|
||||
|
||||
.m02-hopyo__part {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
align-items: center;
|
||||
gap: var(--spacing-4);
|
||||
}
|
||||
|
||||
.m02-hopyo__part + .m02-hopyo__part {
|
||||
margin-top: var(--spacing-4);
|
||||
}
|
||||
|
||||
.m02-hopyo__times {
|
||||
width: 6em;
|
||||
}
|
||||
|
||||
.m02-hopyo__unit {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
gap: var(--spacing-4);
|
||||
}
|
||||
|
||||
/* 단위 환산 칸 앞뒤 글 — 「엑셀 1 ㎡ = 우리 [ ] 본」 */
|
||||
.m02-hopyo__unit-text {
|
||||
color: var(--color-text-secondary);
|
||||
font-size: var(--text-sm);
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.m02-hopyo__acts {
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.m02-hopyo__acts > button + button {
|
||||
margin-left: var(--spacing-4);
|
||||
}
|
||||
|
||||
/* 엑셀 보기(329) — 왼쪽 읽기 전용 시트 · 오른쪽 호표 목록 */
|
||||
.m02-hopyo-sheet {
|
||||
display: grid;
|
||||
|
||||
@@ -65,7 +65,6 @@ export function gridOf(id: string, scope: HopyoScope, key: string): Promise<Hopy
|
||||
got.catch(() => kept?.got === got && (kept = null));
|
||||
return got;
|
||||
}
|
||||
export const dropGrid = (): void => void (kept = null);
|
||||
|
||||
/** 역할 시트 탭 글 통일 — 역할 → 시트 id */
|
||||
export function nameTabs(book: Workbook, grid: HopyoGrid): Partial<Record<Role, string>> {
|
||||
|
||||
@@ -48,7 +48,6 @@ export function buildHopyoSection(opt: HopyoSectionOptions): HopyoSection {
|
||||
start.classList.add("m02-layers__btn");
|
||||
start.title =
|
||||
"파일 하나 — 경쟁사 엑셀(.xls · .xlsx) 또는 경쟁사 파일(.estx · .STC) → 우리 정보로 다시 만듦(한시 · 끝내거나 떠나면 올린 파일 지움)";
|
||||
start.dataset.hopyoWizardOpen = "";
|
||||
const jobs = el("div", { className: "m02-hopyo-side", attrs: { "data-hopyo-jobs": "" } });
|
||||
const body = el("div", {
|
||||
className: "m02-hopyo-side",
|
||||
|
||||
@@ -10,7 +10,7 @@ import { currentLanguageIndex } from "@ui/ui_template_locale";
|
||||
import { wheelZoomsIn } from "../A00_Common/touch_bridge";
|
||||
import { guardMenuAfterDrag, isAuxPanButton } from "../A00_Common/input_prefs";
|
||||
import { createButton, el } from "@ui/ui_template_elements";
|
||||
import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money";
|
||||
import { formatMoney } from "../common_util/common_util_money";
|
||||
import "./M02_MasterTemplete_Labor_Diagram.css";
|
||||
import { createEmpty } from "@ui/ui_template_empty";
|
||||
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
* ========================================================================== */
|
||||
|
||||
import { createButton, el } from "@ui/ui_template_elements";
|
||||
import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money";
|
||||
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";
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
* ========================================================================== */
|
||||
|
||||
import { createButton, el } from "@ui/ui_template_elements";
|
||||
import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money";
|
||||
import { formatMoney } from "../common_util/common_util_money";
|
||||
import type {
|
||||
LaborCalc,
|
||||
LaborCalcLine,
|
||||
|
||||
@@ -15,7 +15,7 @@
|
||||
import { createButton, createSelectField, el } from "@ui/ui_template_elements";
|
||||
import { HOPYO_TAG } from "@ui/ui_template_hopyo_grid";
|
||||
import { pctView } from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
|
||||
import { formatLineMoney, formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money";
|
||||
import { formatLineMoney, formatMoney } from "../common_util/common_util_money";
|
||||
import type { ItemLogic } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import type {
|
||||
LaborCalc,
|
||||
|
||||
@@ -49,14 +49,14 @@ def rows(folder: str | Path) -> list[dict[str, Any]]:
|
||||
|
||||
|
||||
def _last() -> int:
|
||||
"""모든 개인 층 파일의 가장 큰 PM 번호 — 사람 사이 번호 안 겹침."""
|
||||
found = [
|
||||
int(m.group(1))
|
||||
for path in layers.storage_root().glob(f"*/*/{layers.TEMPLATES_DIRNAME}/{FILE}")
|
||||
for row in read(path.parent)["줄"]
|
||||
if (m := KEY.match(str(row.get("키") or "")))
|
||||
]
|
||||
return max(found, default=0)
|
||||
"""모든 개인 층 파일의 가장 큰 PM 번호 — 사람 사이 번호 안 겹침 · 파일마다 `마지막`(발급한 가장 큰 번호)도
|
||||
셈(지운 끝 번호를 다시 안 씀 · 854-1)."""
|
||||
found = [0]
|
||||
for path in layers.storage_root().glob(f"*/*/{layers.TEMPLATES_DIRNAME}/{FILE}"):
|
||||
doc = read(path.parent)
|
||||
found.append(int(doc.get("마지막") or 0))
|
||||
found += [int(m.group(1)) for r in doc["줄"] if (m := KEY.match(str(r.get("키") or "")))]
|
||||
return max(found)
|
||||
|
||||
|
||||
def _text(v: Any) -> str:
|
||||
@@ -114,8 +114,10 @@ def add(folder: str | Path, body: dict[str, Any]) -> dict[str, Any]:
|
||||
with store._LOCK:
|
||||
doc = read(folder)
|
||||
row = _checked(body, doc["줄"])
|
||||
got = {"키": f"{PREFIX}{_last() + 1:06d}", **row}
|
||||
n = _last() + 1
|
||||
got = {"키": f"{PREFIX}{n:06d}", **row}
|
||||
doc["줄"].append(got)
|
||||
doc["마지막"] = n
|
||||
atomic_write_json(Path(folder) / FILE, doc)
|
||||
return got
|
||||
|
||||
|
||||
@@ -23,6 +23,8 @@ from __future__ import annotations
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import threading
|
||||
from collections.abc import Callable
|
||||
from contextvars import ContextVar
|
||||
from datetime import datetime
|
||||
from decimal import Decimal
|
||||
@@ -53,6 +55,11 @@ POWER, POWER_CREW, DIRECT_KEY = "GC001196", "GC001197", "GC001199"
|
||||
FUEL_POWER, FUEL_POWER_CREW = "GC001200", "GC001201" # 연료 + 전력(+ 조종원) — 경쟁사 구성(822-2b)
|
||||
|
||||
|
||||
#: 번호 발급 · 고치기 · 지우기 한 번에 하나(854-1) — 자기 잠금(`store._LOCK` 안에서 불려도 교착 없게)
|
||||
# ponytail: 프로세스 안 잠금 · 서버를 여럿 띄우면 파일 잠금으로
|
||||
_LOCK = threading.RLock()
|
||||
|
||||
|
||||
#: 단가산출 기계 창 초안(827-1 · `M02_MyMachine_Draft`) — 셈 꼴 줄 · 미리 셈 · 저장 한 요청 안만 `whole()` 위에 얹음
|
||||
DRAFT: ContextVar[tuple] = ContextVar("내기계초안", default=())
|
||||
|
||||
@@ -106,6 +113,26 @@ def _put(row: dict) -> None:
|
||||
atomic_write_json(_dir() / f"{row['키']}.json", row)
|
||||
|
||||
|
||||
def version(key: str) -> str:
|
||||
"""내 기계 한 대 판(파일 바이트 지문 · 없으면 빈 글)."""
|
||||
path = _dir() / f"{key}.json"
|
||||
return store.version_of(path.read_bytes()) if path.is_file() else ""
|
||||
|
||||
|
||||
def add(build: Callable[[str], dict]) -> dict:
|
||||
"""새 번호 발급 + 쓰기를 한 잠금 안에서(854-1) — `_다음` 번호 · 이미 있는 파일 번호는 건너뜀(덮어쓰기 없음) ·
|
||||
`build(키)` = 저장 줄."""
|
||||
with _LOCK:
|
||||
_move()
|
||||
user, n = _user(), int(_load(_dir() / NEXT).get("다음") or 1)
|
||||
while (_dir() / f"{PREFIX}{user}-{n:04d}.json").exists():
|
||||
n += 1
|
||||
row = build(f"{PREFIX}{user}-{n:04d}")
|
||||
atomic_write_json(_dir() / NEXT, {"다음": n + 1}) # 번호 먼저 — 겹쳐 쓰지 않게
|
||||
_put(row)
|
||||
return row
|
||||
|
||||
|
||||
def _read(folder: Path | None = None) -> dict[str, Any]:
|
||||
_move(folder)
|
||||
base = _dir(folder)
|
||||
@@ -227,28 +254,14 @@ def hourly(row: dict, index: Any) -> dict[str, Any]:
|
||||
**sums,
|
||||
"계": sum(sums.values()),
|
||||
}
|
||||
import master_cut as mcut
|
||||
|
||||
mf = m01.cm.mf
|
||||
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)
|
||||
from M02_MasterTemplete import M02_Machine_Hourly as mh # 셈 한 길(842-3 · 855 2-B2)
|
||||
|
||||
if (by_doc := mh.doc_sums(row, logic, index)) is not None:
|
||||
got = by_doc.get("합") or {"reason": by_doc.get("reason")}
|
||||
return {"ok": by_doc["ok"], **head, "로직": logic["키"], **got}
|
||||
given = {i["이름"]: (i.get("고르기") or [""])[0] for i in logic.get("입력") or []}
|
||||
given["기계"] = str(row.get("원문번호"))
|
||||
try:
|
||||
got = mcut.engine(
|
||||
index, logic["키"], mf.run(index, logic["키"], mf.fill_empty(logic, given))
|
||||
)
|
||||
except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e:
|
||||
return {"ok": False, "reason": str(e) or type(e).__name__}
|
||||
sums = {k: float(got[k]) for k in (*COSTS, "계")}
|
||||
return {"ok": True, **head, "로직": logic["키"], **sums}
|
||||
got = mh.hour(row, logic, index)
|
||||
return {"ok": got["ok"], **head, **got}
|
||||
|
||||
|
||||
# ── 검사 ──────────────────────────────────────────────────────────────
|
||||
@@ -420,9 +433,9 @@ def create_own(raw: Any = None, base: str | None = None) -> dict[str, Any]:
|
||||
return create(raw, base)
|
||||
|
||||
|
||||
def update_own(key: str, raw: Any) -> dict[str, Any]:
|
||||
def update_own(key: str, raw: Any, ver: str | None = None) -> dict[str, Any]:
|
||||
not_m01(raw, key)
|
||||
return update(key, raw)
|
||||
return update(key, raw, ver)
|
||||
|
||||
|
||||
def create(raw: Any = None, base: str | None = None) -> dict[str, Any]:
|
||||
@@ -430,37 +443,44 @@ def create(raw: Any = None, base: str | None = None) -> dict[str, Any]:
|
||||
seed = _seed(base) if base else {}
|
||||
raw = raw if isinstance(raw, dict) else {}
|
||||
body = clean({**seed, **raw, "값": {**seed.get("값", {}), **(raw.get("값") or {})}})
|
||||
data = _read()
|
||||
key = f"{PREFIX}{_user()}-{data['다음']:04d}"
|
||||
when = _now()
|
||||
row = {"키": key, "원문번호": f"{NO}{key}", "원문": "개인", "구분": "개인", "상세구분": body["이름"],
|
||||
**body, "넣은날": when, "고친날": when, **({"본뜬": base} if base else {})} # fmt: skip
|
||||
atomic_write_json(_dir() / NEXT, {"다음": data["다음"] + 1}) # 번호 먼저 — 겹쳐 쓰지 않게
|
||||
_put(row)
|
||||
row = add(lambda key: {"키": key, "원문번호": f"{NO}{key}", "원문": "개인", "구분": "개인",
|
||||
"상세구분": body["이름"], **body, "넣은날": when, "고친날": when,
|
||||
**({"본뜬": base} if base else {})}) # fmt: skip
|
||||
return answer(row)
|
||||
|
||||
|
||||
def update(key: str, raw: Any) -> dict[str, Any]:
|
||||
_user()
|
||||
data = _read()
|
||||
old = next((r for r in data["줄"] if r["키"] == key), None)
|
||||
def _old(key: str) -> dict:
|
||||
old = next((r for r in rows() if r["키"] == key), None)
|
||||
if old is None:
|
||||
raise _bad(f"없는 내 기계 「{key}」", 404)
|
||||
return old
|
||||
|
||||
|
||||
def update(key: str, raw: Any, ver: str | None = None) -> dict[str, Any]:
|
||||
"""고침 — `ver`(화면이 연 판)가 지금 판과 다르면 409 {stale, 판} · None = 대조 없음(초안 저장 등 서버 길)."""
|
||||
_user()
|
||||
_old(key)
|
||||
body = clean(raw)
|
||||
keep = {k: old[k] for k in ("키", "원문번호", "원문", "구분", "넣은날", "본뜬") if k in old}
|
||||
row = {**keep, "상세구분": body["이름"], **body, "고친날": _now()}
|
||||
_put(row)
|
||||
return answer(row)
|
||||
with _LOCK:
|
||||
old = _old(key)
|
||||
if ver is not None and (have := version(key)) != ver:
|
||||
raise store.StoreError(409, {"stale": [key], "판": have})
|
||||
keep = {k: old[k] for k in ("키", "원문번호", "원문", "구분", "넣은날", "본뜬") if k in old}
|
||||
row = {**keep, "상세구분": body["이름"], **body, "고친날": _now()}
|
||||
_put(row)
|
||||
now = version(key) # 잠금 안 판 — 뒤 고침이 끼어도 화면이 그 고침을 덮지 않게
|
||||
return {**answer(row), "판": now}
|
||||
|
||||
|
||||
def delete(key: str) -> dict[str, Any]:
|
||||
"""지움 — 이미 만든 단가산출은 사본의 마지막 값 그대로(「지운키」)."""
|
||||
_user()
|
||||
data = _read()
|
||||
if not any(r["키"] == key for r in data["줄"]):
|
||||
raise _bad(f"없는 내 기계 「{key}」", 404)
|
||||
_old(key)
|
||||
used = uses().get(key, [])
|
||||
(_dir() / f"{key}.json").unlink(missing_ok=True)
|
||||
with _LOCK:
|
||||
_old(key)
|
||||
(_dir() / f"{key}.json").unlink(missing_ok=True)
|
||||
return {"지움": key, "쓰는곳": used}
|
||||
|
||||
|
||||
@@ -509,6 +529,7 @@ def same(name: Any, spec: Any, skip: str = "") -> list[dict]:
|
||||
def answer(row: dict, used: list | None = None) -> dict[str, Any]:
|
||||
out = {
|
||||
"줄": row,
|
||||
"판": version(row["키"]),
|
||||
"시간당": hourly(engine(row), whole()),
|
||||
"같은이름": same(row["이름"], row["규격"], row["키"]),
|
||||
}
|
||||
|
||||
@@ -48,6 +48,8 @@ export interface Use {
|
||||
|
||||
export interface MyMachineOne {
|
||||
줄: MyMachine;
|
||||
/** 연 판(854-1) — 고치기 때 보냄 · 다르면 409(`StaleError`) */
|
||||
판?: string;
|
||||
시간당: MyHourly;
|
||||
같은이름: { 키: string; 이름: string; 규격: string; 출처: string }[];
|
||||
쓰는곳?: Use[];
|
||||
@@ -116,8 +118,9 @@ export const updateMyMachine = (
|
||||
owner: string | null,
|
||||
k: string,
|
||||
body: MyMachineBody,
|
||||
ver?: string,
|
||||
): Promise<MyMachineOne> =>
|
||||
call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body }) });
|
||||
call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body, 판: ver ?? null }) });
|
||||
|
||||
/** 저장 전 영향(848-5) — 바뀐 칸 · 이 층 쓰는 단가산출(그 칸을 따로 고쳐 둠?) · 쓰기 없음 */
|
||||
export interface MyMachineImpact {
|
||||
|
||||
@@ -140,15 +140,19 @@ def renew(copy: Any) -> Any:
|
||||
|
||||
def _new(row: dict) -> str:
|
||||
"""새 내 기계 파일(`mym.create` 와 같은 꼴 · 값은 초안 그대로 — 본뜬 값을 다시 섞지 않음)."""
|
||||
data = mym._read()
|
||||
key = f"{mym.PREFIX}{mym._user()}-{data['다음']:04d}"
|
||||
when = mym._now()
|
||||
head = {"키": key, "원문번호": f"{mym.NO}{key}", "원문": "개인", "구분": "개인"}
|
||||
body = {k: row[k] for k in ("상세구분", *BODY, "단위", "출처") if k in row}
|
||||
tail = {"넣은날": when, "고친날": when, **({"본뜬": row["본뜬"]} if row.get("본뜬") else {})}
|
||||
mym.atomic_write_json(mym._dir() / mym.NEXT, {"다음": data["다음"] + 1}) # 번호 먼저
|
||||
mym._put({**head, **body, **tail})
|
||||
return key
|
||||
return mym.add( # 번호 발급 + 쓰기 한 잠금(854-1)
|
||||
lambda key: {
|
||||
"키": key,
|
||||
"원문번호": f"{mym.NO}{key}",
|
||||
"원문": "개인",
|
||||
"구분": "개인",
|
||||
**body,
|
||||
**tail,
|
||||
} # fmt: skip
|
||||
)["키"]
|
||||
|
||||
|
||||
def saving(body: dict, inner: Callable[[dict], Any]) -> Any:
|
||||
|
||||
@@ -33,6 +33,7 @@ import {
|
||||
type MyMachineOne,
|
||||
type SimilarRow,
|
||||
} from "./M02_MyMachine_Api";
|
||||
import { StaleError } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import { confirmMyMachineImpact } from "./M02_MyMachine_Impact";
|
||||
import { mt } from "./M02_MyMachine_Text";
|
||||
import "./M02_MyMachine.css";
|
||||
@@ -97,6 +98,7 @@ export async function mountMyMachineForm(
|
||||
opt.key ? readMyMachine(opt.owner, opt.key) : Promise.resolve(null),
|
||||
]);
|
||||
const row = one?.줄;
|
||||
let ver = one?.판; // 연 판(854-1) — 고치기 때 보냄 · 저장마다 새 판
|
||||
let base: string | undefined; // 서버 `본뜬`
|
||||
const notice = el("div", { className: "m02-mymach__notice" });
|
||||
const server = el("div", { className: "m02-mymach__server" });
|
||||
@@ -173,16 +175,16 @@ export async function mountMyMachineForm(
|
||||
// 정본 고침 = 영향 보고 저장(848-5)
|
||||
if (opt.key && !(await confirmMyMachineImpact(opt.owner, opt.key, body))) return;
|
||||
const got = opt.key
|
||||
? await updateMyMachine(opt.owner, opt.key, body)
|
||||
? await updateMyMachine(opt.owner, opt.key, body, ver)
|
||||
: await createMyMachine(opt.owner, body, base);
|
||||
ver = got.판;
|
||||
saved = true;
|
||||
opt.onDirty?.(false);
|
||||
showToast(mt("Saved"), "success");
|
||||
opt.onSaved(got);
|
||||
} catch (error) {
|
||||
notice.replaceChildren(
|
||||
createText(error instanceof Error ? error.message : mt("Failed"), "error"),
|
||||
);
|
||||
const why = error instanceof StaleError ? mt("Stale") : error instanceof Error ? error.message : mt("Failed"); // prettier-ignore
|
||||
notice.replaceChildren(createText(why, "error"));
|
||||
} finally {
|
||||
saveBtn.disabled = m01Same;
|
||||
}
|
||||
|
||||
@@ -2,8 +2,9 @@
|
||||
|
||||
GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) ·
|
||||
POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) ·
|
||||
PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
|
||||
POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}.
|
||||
PUT `/{키}` 몸 {줄, 판?}(판 = 연 판 · 다르면 409 {stale, 판} · 854-1) ·
|
||||
POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
|
||||
옛 POST `/draft`(기계 창 [확인] · 화면 0)은 853-3 에서 지움 — 확인 셈 `M02_MyMachine_Draft.check` 는 시험 827-1 기준값으로 남김.
|
||||
권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404).
|
||||
⚠ 등록은 `main.py`(로그인만).
|
||||
"""
|
||||
@@ -17,7 +18,6 @@ from pydantic import BaseModel
|
||||
|
||||
from common_util.common_util_auth import verify_session
|
||||
from M02_MasterTemplete import M02_MyMachine as mym
|
||||
from M02_MasterTemplete import M02_MyMachine_Draft as draft
|
||||
from M02_MasterTemplete import M02_MyMachine_Impact as impact
|
||||
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Session, _call, _root
|
||||
|
||||
@@ -28,8 +28,7 @@ PATH = "/layers/{layer}/my-machines"
|
||||
class MachineBody(BaseModel):
|
||||
줄: dict[str, Any] | None = None
|
||||
본뜬: str | None = None
|
||||
키: str | None = None # 초안 확인(827-1) — 고칠 내 기계
|
||||
표지: str | None = None # 초안 확인(827-1) — 화면이 정한 표지(셈 기록 열쇠)
|
||||
판: str | None = None # 고치기 — 화면이 연 판(854-1 · 다르면 409)
|
||||
|
||||
|
||||
def _folder(session: Session, layer: str, owner: str | None, write: bool = False):
|
||||
@@ -43,16 +42,6 @@ def my_machines(layer: str, owner: str | None = None, session: Session = Depends
|
||||
return _call(_folder(session, layer, owner), mym.listing)
|
||||
|
||||
|
||||
@router.post(PATH + "/draft")
|
||||
def my_machine_draft(
|
||||
layer: str,
|
||||
body: MachineBody,
|
||||
owner: str | None = None,
|
||||
session: Session = Depends(verify_session),
|
||||
):
|
||||
return _call(_folder(session, layer, owner, True), draft.check, body.model_dump())
|
||||
|
||||
|
||||
@router.get(PATH + "/{key}")
|
||||
def my_machine(
|
||||
layer: str, key: str, owner: str | None = None, session: Session = Depends(verify_session)
|
||||
@@ -78,7 +67,7 @@ def my_machine_update(
|
||||
owner: str | None = None,
|
||||
session: Session = Depends(verify_session),
|
||||
):
|
||||
return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄)
|
||||
return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄, body.판)
|
||||
|
||||
|
||||
@router.post(PATH + "/{key}/impact")
|
||||
|
||||
@@ -28,6 +28,7 @@ const TEXT = {
|
||||
Back: "목록",
|
||||
Close: "닫기",
|
||||
Failed: "못 함",
|
||||
Stale: "그 사이 다른 곳에서 바뀜 — 목록에서 다시 열어 고침",
|
||||
Name_Needed: "이름 · 비어 있음",
|
||||
Same: "같은 이름 · 규격 있음 — {value}",
|
||||
Copied: "「{value}」 값을 복사 — 고친 뒤 [저장]",
|
||||
|
||||
@@ -152,14 +152,6 @@ def flat(s: Any) -> str:
|
||||
return re.sub(r"\s+", "", str(s or ""))
|
||||
|
||||
|
||||
def _hcol(rows: list[list[Any]], word: str, start: int = 2) -> int | None:
|
||||
for r in rows[start : start + 2]:
|
||||
for j, v in enumerate(r):
|
||||
if flat(v) == word:
|
||||
return j
|
||||
return None
|
||||
|
||||
|
||||
def _n(v: Any) -> float | None:
|
||||
if isinstance(v, (int, float)):
|
||||
return float(v)
|
||||
@@ -192,51 +184,3 @@ def applied_how(r: list[Any]) -> tuple[dict[str, float], str | None]:
|
||||
return got, None # 쓸 값이 없음 — 표지할 것 없음
|
||||
why = "적용 칸 합이 안 맞음" if a["T"] else "적용 칸 비어 있음"
|
||||
return got, f"당초 칸 사용 — {why}" + (f" ({gap})" if gap else "")
|
||||
|
||||
|
||||
def applied(r: list[Any]) -> dict[str, float]:
|
||||
return applied_how(r)[0]
|
||||
|
||||
|
||||
def est_prices(book: dict[str, list]) -> tuple[list[dict[str, Any]], dict[int, dict[str, Any]]]:
|
||||
"""→ (단가 목록 [{종류, 이름, 규격, 비목, 값}], 산근 총괄 {번: {T, L, M, S, 이름, 규격}})."""
|
||||
out: list[dict[str, Any]] = []
|
||||
lab = book.get("노임단가", [])
|
||||
c = _hcol(lab, "적용단가")
|
||||
for r in lab[3:]:
|
||||
if c is not None and len(r) > c and r[2] and isinstance(r[c], (int, float)):
|
||||
out.append(
|
||||
{"종류": "노임", "이름": flat(r[2]), "규격": "", "비목": "L", "값": float(r[c])}
|
||||
)
|
||||
mat = book.get("자재단가", [])
|
||||
c = _hcol(mat, "적용단가")
|
||||
for r in mat[4:]:
|
||||
if c is not None and len(r) > c and r[2] and isinstance(r[c], (int, float)):
|
||||
out.append(
|
||||
{
|
||||
"종류": "자재",
|
||||
"이름": flat(r[2]),
|
||||
"규격": flat(r[3]),
|
||||
"비목": "M",
|
||||
"값": float(r[c]),
|
||||
}
|
||||
)
|
||||
for sheet, kind in (("기계경비총괄표", "기계"), ("견적단가", "견적")):
|
||||
for r in book.get(sheet, [])[3:]:
|
||||
if len(r) > 28 and r[2]:
|
||||
for k, v in applied(r).items():
|
||||
if isinstance(v, (int, float)) and (v or k != "T"):
|
||||
one = {"종류": kind, "이름": flat(r[2]), "규격": flat(r[3])}
|
||||
out.append({**one, "비목": k, "값": float(v or 0)})
|
||||
san: dict[int, dict[str, Any]] = {}
|
||||
for r in book.get("단가산출총괄표", [])[3:]:
|
||||
if len(r) > 28 and str(r[1]).strip().isdigit():
|
||||
n = int(str(r[1]).strip())
|
||||
got, note = applied_how(r)
|
||||
san[n] = {k: float(v or 0) for k, v in got.items()}
|
||||
san[n] |= {"이름": flat(r[2]), "규격": flat(r[3]), "칸": note}
|
||||
for k in "TLMS":
|
||||
if san[n][k] or k != "T":
|
||||
one = {"종류": "산근", "이름": f"단산{n}", "규격": ""}
|
||||
out.append({**one, "비목": k, "값": san[n][k]})
|
||||
return out, san
|
||||
|
||||
@@ -139,12 +139,6 @@ def chosen(item: dict) -> dict | None:
|
||||
return got if got and not _apart(res) else None
|
||||
|
||||
|
||||
def item_key(res: dict) -> str | None:
|
||||
"""줄 품목 키 — 고름 › 엔진 이음."""
|
||||
found = res.get("재료찾기") or {}
|
||||
return (found.get("고름") or {}).get("키") or found.get("키")
|
||||
|
||||
|
||||
def apart_note(found: dict) -> str:
|
||||
"""별도계상 줄 설명 — 품목이 있으면 「별도계상 · 품목: 이름 규격」."""
|
||||
from M02_MasterTemplete import M02_San_Link as link
|
||||
|
||||
@@ -182,10 +182,3 @@ def parse_line(g: str | None) -> dict[str, Any]:
|
||||
if refs:
|
||||
return {**head, **_ref_line(st, refs[0])}
|
||||
return {**head, **_assign_line(st)}
|
||||
|
||||
|
||||
def parse_block(lines: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||||
"""[{행, G}] → 줄 나무 목록(행 · 원문 붙임)."""
|
||||
return [
|
||||
{"행": ln.get("행"), "글": ln.get("G") or "", **parse_line(ln.get("G"))} for ln in lines
|
||||
]
|
||||
|
||||
@@ -122,7 +122,7 @@ def _table(rows: list[list[Any]], price: tuple[str, ...]) -> list[dict[str, Any]
|
||||
|
||||
def resources(sheets: dict[str, list]) -> dict[str, list[dict[str, Any]]]:
|
||||
"""같은 책 단가표 → {종류: [{번 · 이름 · 규격 · 단위 · 표 · 값 {T L M S}}]}(노임 · 자재 = 적용단가 ·
|
||||
기계 · 견적 · 산근 = 적용 칸(합이 안 맞으면 당초 · `M02_San_Book.applied`))."""
|
||||
기계 · 견적 · 산근 = 적용 칸(합이 안 맞으면 당초 · `M02_San_Book.applied_how`))."""
|
||||
out: dict[str, list[dict[str, Any]]] = {}
|
||||
for kind, sheet, comp in (("노임", "노임단가", "L"), ("자재", "자재단가", "M")):
|
||||
rows = sheets.get(sheet) or []
|
||||
|
||||
@@ -561,7 +561,8 @@ def create(
|
||||
new: bool = False, use: str | None = None,
|
||||
) -> dict[str, Any]: # fmt: skip
|
||||
"""엔진 로직 줄 + 원본 → 지금 층 새 가져온 식 SK — 서버가 다시 셈해 엑셀과 맞댐(검산 ·
|
||||
다르면 `같음` False 로 표지 · 막지 않음) · 같은 층 같은 내용 = 409(`ask` · 733-2)."""
|
||||
다르면 `같음` False 로 표지 · 막지 않음) · 같은 층 같은 내용 = 409(`ask` · 733-2) ·
|
||||
서버 길(POST sangeun/imported)은 853-3 에서 걷음 — 시험이 가져온 식 SK 바탕으로 씀."""
|
||||
return keep(new_doc(logic, source, name, unit, head), new, use)
|
||||
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
"""M02 단가산출(SK) 셈 길(PLAN 715-1b) — `POST /api/m02/layers/{층}/sangeun/calc` ·
|
||||
일위대가 [+ 줄] M01 기초 = 그 층 SK 사본(811-1 · `M02_Labor_SkRow`) `…/sangeun/from-logic`(층 쓰기) ·
|
||||
가져온 식(793-2 · `M02_Sangeun_Imported`) `…/sangeun/imported`(만들기 · 층 쓰기) · `/price` ·
|
||||
가져온 식(793-2 · `M02_Sangeun_Imported`) `…/sangeun/imported/price` ·
|
||||
`/link`(화면 캐시 문서 고침 · 저장 없음 · 층 읽기 · 기초로 바꾸기 없음 · 809-1) ·
|
||||
불러오기 단산 블록 → 가져온 식(793-3b · `M02_Sangeun_FromHopyo`) `…/sangeun/from-hopyo`
|
||||
(늘 개인 층 쓰기 · 몸 `문서` = 미리 보기에서 고친 문서) · 미리 보기 `…/from-hopyo/preview`(층 읽기 · 안 씀 · 835-1).
|
||||
@@ -81,31 +81,6 @@ def calc_sangeun(
|
||||
return _call(_root(session, layer, owner), _calc, body)
|
||||
|
||||
|
||||
class ImportedBody(BaseModel):
|
||||
로직: dict[str, Any]
|
||||
원본: dict[str, Any] | None = None
|
||||
이름: str = ""
|
||||
단위: str = ""
|
||||
구분: str = ""
|
||||
상세구분: str = ""
|
||||
새로: bool = False
|
||||
씀: str | None = None
|
||||
|
||||
|
||||
@router.post("/layers/{layer}/sangeun/imported")
|
||||
def sangeun_imported(
|
||||
layer: Layer,
|
||||
body: ImportedBody,
|
||||
owner: str | None = None,
|
||||
session: Session = Depends(verify_session),
|
||||
) -> dict:
|
||||
"""가져온 식 단가산출 만들기(793-2) — 답 = {이름, 검산, 단가기준} · 같은 내용 409."""
|
||||
folder = _root(session, layer, owner, write=True)
|
||||
head = {"구분": body.구분, "상세구분": body.상세구분}
|
||||
args = (body.로직, body.원본, body.이름, body.단위, head, body.새로, body.씀)
|
||||
return _call(folder, _sd(imp.create), *args)
|
||||
|
||||
|
||||
class FromHopyoBody(BaseModel):
|
||||
층: Layer
|
||||
주인: str | None = None
|
||||
|
||||
@@ -1,61 +0,0 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete_Hopyo_Unit.ts — 확인 창 대상 이름 옆 「단위 환산」 칸의 보이기 판정(PLAN 784-2 · 요구 635-2).
|
||||
* 순수 계산(화면 · fetch 없음) — 숨김 조건 · 두 단위 글 재료 · 추정 두께.
|
||||
* · same = 배 1 · 단위 같음(서버 갈래 같음 · 두 단위 · 단위표 1) → 칸 숨김 · 「단위 같음 ×1」
|
||||
* · quota = 배가 몫(0.1)과 같음 → 칸 숨김 · 「몫 0.1」 만
|
||||
* · input = 빈칸 · 추정 · 그 밖 → 입력 칸 「엑셀 1 ㎡ = 우리 [ ] 본」
|
||||
* 값 자체(배)는 안 바꿈 — 서버 `Match.factor` 가 낸 배 · 갈래를 보이기만 다르게.
|
||||
* ========================================================================== */
|
||||
|
||||
export interface UnitPart {
|
||||
배: number | null;
|
||||
몫?: number | null;
|
||||
환산?: { 배: number | null; 갈래: string } | null;
|
||||
단위?: string | null;
|
||||
}
|
||||
|
||||
export type UnitMode = "same" | "quota" | "input";
|
||||
|
||||
export interface UnitView {
|
||||
mode: UnitMode;
|
||||
/** 엑셀 단위 · 우리 단위(빈 글 = 모름) */
|
||||
from: string;
|
||||
to: string;
|
||||
/** 추정 갈래 — 두께 m(㎡ → ㎥ 일 때만 · 아니면 null) */
|
||||
thick: number | null;
|
||||
estimated: boolean;
|
||||
}
|
||||
|
||||
const plain = (u: string | null | undefined): string =>
|
||||
String(u ?? "")
|
||||
.replace(/\s+/g, "")
|
||||
.replace("㎡", "m2")
|
||||
.replace("㎥", "m3")
|
||||
.toLowerCase();
|
||||
const close = (a: number, b: number): boolean => Math.abs(a - b) < 1e-9;
|
||||
|
||||
export function unitView(
|
||||
p: UnitPart,
|
||||
from: string | null | undefined,
|
||||
to?: string | null,
|
||||
): UnitView {
|
||||
const f = String(from ?? "").trim();
|
||||
const t = String(to ?? p.단위 ?? "").trim();
|
||||
const quota = p.몫 != null && p.몫 !== 1; // 몫 1 = 몫 없음과 같음
|
||||
const kind = p.환산?.갈래;
|
||||
const unitSame = kind
|
||||
? kind === "같음" || kind === "두 단위" || (kind === "단위표" && p.환산?.배 === 1)
|
||||
: plain(f) !== "" && plain(f) === plain(t);
|
||||
const at = quota ? (p.몫 as number) : 1;
|
||||
const hidden = p.배 !== null && close(p.배, at) && unitSame;
|
||||
const estimated = kind === "추정";
|
||||
const thick =
|
||||
estimated && plain(f) === "m2" && plain(t) === "m3" && p.환산?.배 != null ? p.환산.배 : null;
|
||||
return {
|
||||
mode: hidden ? (quota ? "quota" : "same") : "input",
|
||||
from: f,
|
||||
to: t,
|
||||
thick,
|
||||
estimated,
|
||||
};
|
||||
}
|
||||
@@ -1583,3 +1583,24 @@ b09원가에서는 확인할필요 없음. 어차피 m02의정보를 가져가
|
||||
## 요구 896 (11-17 · 사용자 · 분석 894 보고 답 — 정할 것 5 번(옛 자료 · 한 번용 스크립트)은 tmp 폴더에 보관 · 나머지 항목 전체 동의 · 천천히 단계적으로 오류 없게 진행)
|
||||
|
||||
5번 tmp폴더에 보관. 나머지 항목은 전체 동의. 천천히 단계적으로 오류 없게 진행할것.
|
||||
|
||||
## 요구 897 (11-17 · 사용자 · 예상 종료 시간 물음 · 워크트리를 늘리면 빨라지는지 · 창 여덟까지 늘려도 됨 · 왜 오래 걸리는지 물음)
|
||||
|
||||
예상종료시간?
|
||||
|
||||
워크트리를 더 늘려서 진행하면 빨라질까?
|
||||
|
||||
8개 창까지는 늫려도 됨.
|
||||
|
||||
그런데 궁금한게 왜 이렇게 오래걸리는거야?
|
||||
|
||||
## 요구 898 (11-17 · 사용자 · 걸음 2 설계 「브레인이 정한 것」 넷에 답 — B08 · B09 는 M02 것을 복사해 가져가 비목별 합산만 · 직접 계산 없음 / 옛 로직 파일은 tmp 로 이동(한 번에 삭제 예정) / 막힘 기준 일단 유지 / 화면 단가는 품셈 원문 자릿수로 보이고 계산은 정밀하게)
|
||||
|
||||
1. B08/B09는 M02에서 만들어진 단가산출, 일위대가, 구조물조합을 통해 복사하여 프로젝트 내부로 들어감. 계산은 인건비, 재료비, 경비를 구분하여 합산 정도만 함. 계산을 직접할 일은 없음.
|
||||
2. 옛로직 파일은 tmp 폴더로 이동(한번에 삭제예정)
|
||||
3. 일단유지
|
||||
4. 화면의 단가는 끝수는 사용자에게 보여질때는 품셈의 원문의 단위당 소수점 자리수를 따르게 되어있으며 계산은 정밀도 있게 계산해달라고 요청했었음. 반영되어있을걸로 보임.
|
||||
|
||||
## 요구 899 (11-17 · 사용자 · 지금 M02 의 개인 · 회사 · 마스터 데이터는 개발 중 테스트 결과 — 삭제해도 됨)
|
||||
|
||||
추가로 현재 M02의 개인/회사/마스터 데이터는 프로그램 개발과정에서 테스트한 결과임. 삭제 해도됨.
|
||||
|
||||
@@ -0,0 +1,286 @@
|
||||
# 설계 855 보충 — 사용자 확정 넷 반영 (PLAN 855-F)
|
||||
|
||||
요구 898 · 899 · sub7 · 2026-11-17 · 읽기 · 세기만(코드 · 자료 · 시험 고침 0). 바탕 = `docs/raw/요구_1104/설계_855_정본하나_계산기하나.md`(아래 「본 설계」).
|
||||
세는 도구 · 결과 = `tmp/s894/m855b/`(sub6 도구 셋 복사 + 새 도구 넷 · 결과 파일은 4 절 끝 표).
|
||||
|
||||
## 0. 한눈 요약
|
||||
|
||||
- **B08 · B09 는 지금 「M02 셈 답을 받는」 게 아니라 「M02 를 복사한 옛 로직 줄을 옛 엔진으로 다시 푸는」 꼴** — 프로젝트 사본 `단가.json` 에 M01 로직 줄 · 굳힌 SK 로직 줄(`로직_단가산출.json` `GX9…`)을 싣고, B09 가 그 줄을 `run_line` · `mf.evaluate` 로 다시 풀어 수량 · 자원 키 · 하위 산근 · 풀이 글을 얻음. 셈 몸은 이미 M02 엔진 값(841-1) — B09 고유 셈은 비목 합 · 끝수 · 관급 0 원 · % 밑수뿐.
|
||||
- 사본에 이미 `수식.json`(수식 문서 닫힌 묶음 · 802-4a)이 같이 실림 — **쓰는 곳 0**(만들기만).
|
||||
- 권함 = **안 B「프로젝트는 M02 계산기(문서 셈) 한 벌을 불러 사본을 셈 · B09 는 답을 갈라 합산만」** + 입력 지문이 같으면 다시 안 셈(파생 저장본). 안 A(복사 때 셈 답만 굳힘)는 프로젝트 입력값(구조물마다 · 운반 거리) · [단가 갱신] 이 다시 셈을 요구해 못 씀.
|
||||
- **B09 손 줄이 M01 기초를 직접 고름**(설계내역서 [단가 연결] · 운반 단가 모달 · `ref.tab = logic`) — 저장된 프로젝트 1 곳에 **6 줄 살아 있음**. M02 를 거치지 않는 유일한 길 → 판단 거리 1.
|
||||
- 로직 JSON 칸 19 가운데 문서에 같은 값으로 이미 있는 것 4(`이름 결과단위 출처 부품`) · 문서로 옮길 이름표 6(`원문번호 구분 상세구분 소유 비고 개정`) + `별칭`(지금 값 0) + 파일 머리 3(`원문 부문 차례`) · 셈 칸 8 은 문서 셈 칸이 대신(버림) · **문서에 없는 정보 = 이름표뿐**.
|
||||
- 로직 줄을 직접 읽는 파이썬 자리 = `.logic(` 류 **102 곳 · 49 파일**(M01 7 파일 19 · M02 23 파일 48 · B09 7 파일 16 · scripts 12 파일 19) + 층 서고 SK `수식.로직` · `사본.로직`(로직 줄 값 사본 28 줄) — 모두 문서 읽기로 옮긴 뒤 로직 JSON 을 뺌.
|
||||
- **지금 진행 중인 기초 고침(851-1 등)이 로직 JSON → 빌더 길을 씀** — 로직 JSON 을 빼기 전에 「기초 내용 고침 = 수식 문서를 바로 고치는 스크립트 · M01 [저장]」 으로 길을 바꿔야 함(차례 조건).
|
||||
- 호환을 안 만들면 빠지는 것: 2-D 올림 규칙 · 사본 없는 SK 옛 길 · 옛 SK 상세 시험 8 군 고쳐 쓰기 · 프로젝트 옛 사본 꼴 읽기(`items/` · `complete_old`) · SK `사본` · `수식.로직` 이행 — **어림 −1,200 줄 · 걸음 하나(2-D) 크기 절반**.
|
||||
- 저장본을 비울 때 = **2-C1(SK 셈 한 길) 바로 앞**(옛 칸을 읽는 셈이 꺼지기 전에 자료가 0 이면 2-C1 · 2-D 가 옛 꼴을 볼 필요 없음).
|
||||
- 「가져온 식」(`가져온.로직` = 옛 로직 줄 꼴)은 저장본을 비워도 불러올 때마다 새로 생김 → 옛 식 **파서만** 불러오기 몫으로 남김(엔진 몸은 지움) · 857 이 문서를 바로 내면 그때 걷음.
|
||||
|
||||
---
|
||||
|
||||
## 1. ㉮ B08 · B09 — 옛 엔진 부름 걷기
|
||||
|
||||
### 1-1 옛 엔진을 부르는 자리 하나하나
|
||||
|
||||
길 = 화면 → 서버 길 → 함수. 「살아 있음」 = 화면 단추 · 페이지 열기가 실제로 탐 · 「자료 0」 = 길은 살았으나 지금 저장소에 그 자료가 없어 실제로는 안 돎(프로젝트 사본 0 · 구조물 조합 줄 0).
|
||||
|
||||
| 자리 | 부름 | 무엇을 얻으려고 | 타는 길 | 판정 |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| `B08_Quantity_Router_Material.py:79` `_ref_mats.run` | `labor.run_line` | 참조 일위대가 안 **옛 로직 줄**의 재료 줄(이름 · 단위 · 품목 키 · 수량) → 단위수량 | B08 자재 집계표 열기 `GET …/quantity/materials`(:275) → `snapshot_units` → `_folder_units`(:117) | 살아 있음 · 자료 0(SC 옛 로직 줄 0) |
|
||||
| 같은 파일 `_folder_units` | `copies.calc`(`M02_Item_Copy.py:338` → `Item_Prices.calc` → `Labor_Doc.calc` → `run_line`) | 사본 일위대가 줄 재료 · 자재 수량 | 같음 | 살아 있음 · 자료 0(사본 0) |
|
||||
| `B09_Estimation_Sangeun.py:346` `Solver._solve:333` | `labor_doc.run_line(raw=True)` | 산근 줄마다 **엔진 금액 ÷ 수량 = 단가**(841-1) | B09 열기 · [저장] · 셈 `GET/PUT …/estimation` · `POST …/estimation/calc`(:430) → `calc_user` → `Sangeun.build`(:667) → `collect`(:626) | 살아 있음 · 손 줄 6 이 탐 |
|
||||
| 같은 파일 `_env:200` | `mau.values` · `mf._inputs` · `mf.evaluate(중간)` | **입력 기본값** · 중간 값(작업량 Q 표시 자리) | 위 `_solve` 안 | 살아 있음 |
|
||||
| `_line:445` · `_logic_line:488` | `mf.evaluate(수량)` · `mf.fill(요소)` · `mf.mp.priced` | 줄 **수량 · 자원 키**(노임 · 자재 · 기계) · 고른 품목 | 같음 | 살아 있음 |
|
||||
| `call_of:223` · `line_calls:242` · `_captured:261` | `mf.parse` · `mf.evaluate` · `whole.get` 가로채기 | **하위 산근**(부른 로직 키 + 넘긴 입력) · 기계경비 줄의 **기계 키** | 같음 + `rows_of`(일위대가화 줄 펼침) + `Labor_Source` | 살아 있음 |
|
||||
| `_extras:513` | `mf.evaluate(덧줄 식)` · `labor_doc.pct_extras` | **율 줄**(% · 밑수 = B09 비목 합) | 같음 | 살아 있음 |
|
||||
| `hand_resource_keys:602` | `run_line`(+ `whole.get` 가로채기) | 손 줄이 부르는 **자원 키**(자재 단가 책 수요) | B09 열기 `payload` → `Router.py:238` | 살아 있음 |
|
||||
| `B09_Estimation_Sangeun_Text.py` 13 함수 31 곳(`render_sangeun_text:347`) | `mf.*` · `master_text`(`mtx.fmt` · `render` · `_names`) | **산출근거 글**(머리 · 줄 · 계) | `_solve` → `_text` · `POST …/estimation/logic-preview`(:444 · 운반 단가 모달 ③) | 살아 있음 |
|
||||
| `B09_Estimation_Sangeun_Sum.py:36 · 87` | `mcut._line` · `mcut.settle` | **끝수**(줄 자리 · 끝전 · 조정 · 792-3) | `_solve` 안 | 살아 있음 |
|
||||
| `B09_Estimation_Labor_Rule.py:90 · 115` | `mf.parse`(덧줄 식 꼴 읽기) | 대가 블록 **율 줄 밑수 · 합밖 · 번지 표지**(792-4) | `Labor_Source._poomsem` | 살아 있음 · 자료 0 |
|
||||
| `B09_Estimation_Labor_Source.py:140` `_poomsem` | `run_line(raw=True)` + `sg.line_calls` | 대가(품셈) 블록 **줄 꼴 · 수량 · 비목 · 하위 산근** | B09 열기 `payload` → `daega_inputs`(:656) | 살아 있음 · 자료 0 |
|
||||
| 같은 파일 `sangeun:181` → `Supply.sk_money:79` | `Sangeun_Calc.unit`(옛 엔진 + 문서 합계 덮음) | 굳힌 SK 블록 **합(노 · 재 · 경)** | 같음 | 살아 있음 · 자료 0 |
|
||||
| `B09_Estimation_Linked.py:64` `used_keys` | `run_line`(+ `get` 가로채기) | 사본이 부르는 **자원 키**(단가 책 수요) | `payload` → `linked_resource_keys`(`Router.py:237`) | 살아 있음 · 자료 0 |
|
||||
| `M02_Item_Sangeun.py:45` `freeze` | `Sangeun_Calc.resolve` | 사본 만들 때 SK 를 **옛 로직 줄 하나(GX9)로 굳힘** | 구조물 [저장] → `Item_Snapshot.build_snapshot:126` · B09 서고 [가져오기] `POST …/estimation/library` → `Bill_Library.import_copy:272` · [재생성] `Refresh` | 살아 있음 · 자료 0 |
|
||||
| `M02_Item_Prices.py:234` `collect` · `:346` `calc` | `_texts`(옛 식 글 훑기) · `mf._expand` 류 · `Labor_Doc.calc` | 사본 **닫힌 묶음**(로직 줄 · 요소 · 표) 모으기 · 사본 셈 | 사본 만들기 · B08 · B09 전부 | 살아 있음 |
|
||||
|
||||
죽은 길 = 없음(모두 화면에서 닿음). 지금 실제로 도는 것은 **손 줄 로직 6 줄**(B09 프로젝트 1 곳)뿐 — 나머지는 자료 0.
|
||||
|
||||
### 1-2 사본에 지금 실어 오는 것 대 실어 와야 할 것
|
||||
|
||||
| 파일(구조물 사본 `templates/structures/{id}/` · B09 서고 `library/`) | 지금 내용 | 쓰는 곳 | 끝 모습(안 B) |
|
||||
| --- | --- | --- | --- |
|
||||
| `일위대가.json` | 일위대가 문서 + **M01 로직 줄 사본**(`로직`) · 알약 · `참조사본`(SC · 굳힌 SK 문서 = `굳힌줄` · `원본` · `정체`) (`Item_Source.py:93 · 105`) | B08 · B09 전부 | 일위대가 문서 + 참조사본(SC 그대로 · **SK = 수식 문서 사본**) · 로직 줄 사본 없음 |
|
||||
| `단가.json` | 닫힌 묶음 = **M01 로직 줄** + 요소 · 표 줄 + 자원 단가 줄 + `로직_단가산출.json`(GX9 굳힌 SK 줄) (`Item_Source.py:162`) | 옛 엔진 색인(`load_prices`) | **자원 단가 줄 · 표 줄만**(로직 줄 · GX9 없음) — [단가 갱신] 이 바꾸는 자리 |
|
||||
| `수식.json` | 수식 문서 닫힌 묶음(`Doc_B09.build:33` · 802-4a) | **없음**(만들기만) | **셈 정본** — 프로젝트 셈이 읽는 유일한 식 |
|
||||
| `입력값.json` · `고른자재.json` · `면적.json` | 구조물마다 입력 · 고른 재료 · 알약 칸 값 | 사본 셈 | 그대로(키 = 문서 키 · 입력 이름 → 변수 열쇠 맞춤 필요) |
|
||||
| B09 견적 `user_values.json` 손 줄 `ref{tab: logic, code, given, rate, picks}` | M01 로직 키 + 입력 | `hand_whole`(지금 M01 묶음 즉석 모음) | 안 바뀜 — 키가 같은 수식 문서로 셈(판단 거리 1) |
|
||||
|
||||
### 1-3 「프로젝트는 직접 계산하지 않음」 을 지키는 두 안
|
||||
|
||||
B09 가 셈 답에서 먹는 것 = 줄마다 **이름 · 종류(인력 · 자재 · 기계 · 하위 산근 · 율) · 자원 키 · 수량(1 단위) · 비목 금액 · 하위 부름(키 + 입력) · 율 밑 · 끝수 표지** + **풀이 글**. 새 계산기 답(`master_doc_calc.calc:545` → 줄 `{이름 비목 수량 단가 금액 까닭 합밖 묶음 작업량}`)에 **자원 키 · 하위 부름이 없음** → 어느 안이든 「줄마다 무엇을 불렀나」 기록이 새로 필요(셈은 안 바꿈 · 연결 풀이 `master_doc_link.Links` 를 감싸 부른 것을 적음 · 서버 단독 · TS 짝 안 건드림).
|
||||
|
||||
| 경우 | 안 A — 복사 때 셈 답을 굳혀 실어 옴 | 안 B — 프로젝트가 M02 문서 계산 함수를 불러 사본을 셈(권함) |
|
||||
| --- | --- | --- |
|
||||
| 실어 오는 것 | 셈 답(줄 · 비목 · 자원 키 · 하위 부름 · 풀이 글) | 수식 사본 + 자원 단가 줄(지금 `수식.json` + 줄인 `단가.json`) |
|
||||
| 프로젝트 안 [단가 갱신] | 자원 단가가 바뀌면 줄 금액이 달라짐 → 굳힌 답 못 씀 → M02 에서 다시 복사([재생성]) 해야 함 = 지금 뜻(사본 로직 그대로 · 단가만 새로)과 다름 | 자원 줄만 바꾸고 다시 셈 — 지금 뜻 그대로 |
|
||||
| 수량 · 입력 바뀜(구조물마다 입력값 · 운반 거리 이정표 `haul_dist` · 면적 알약) | 입력이 바뀌면 굳힌 답 무효 → 못 함 | 같은 계산기로 다시 셈 |
|
||||
| 산출근거 보기 | 굳힌 글(단가 갱신 · 입력 바뀜 뒤엔 틀림) | 셈 답 → 서버 풀이 글(본 설계 ② `master_doc_text` · 2-C4) + B09 단가 |
|
||||
| 내역서 합산 | 같음(비목 합) | 같음(비목 합) — B09 고유 셈 = 비목 합 · 끝수 · 관급 0 원 · % 밑수만 |
|
||||
| 손 줄 M01 로직(6 줄) | 고를 때 M02 에서 셈해 굳힘 — 입력 바꾸면 다시 | 그대로 문서 셈 |
|
||||
| 속도 | 빠름 | 입력 지문이 같으면 저장본(CLAUDE.md 5 장 「파생 저장본」) → 안 A 와 같은 속도 |
|
||||
| 고칠 크기 | 사본 꼴 + B09 5 파일 + [단가 갱신] · 입력 바꿈 길 새로 | 사본 꼴 + B09 5 파일(읽는 답만 바뀜) |
|
||||
|
||||
→ **안 B 권함.** 「계산을 직접 할 일 없음」 = B09 에 식 엔진이 없음(계산기는 M01 · M02 와 같은 한 벌) · B09 는 답을 갈라 합산만 — 로 읽음(판단 거리 2 에서 확인).
|
||||
|
||||
### 1-4 걸음(두 박자 · 한 걸음 = 한 커밋 묶음)
|
||||
|
||||
| 걸음 | 무엇 | 파일(어림 줄) | 지킴 | 앞 조건 |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| **B9-0 견본 · 골든** | 지금 사본 0 · 조합 줄 0 → **임시 storage 견본 프로젝트**를 시험이 지음: 층 견본(SK 가져온 식 · 따로 · 율 더한줄 · 형제 SK · 기계 · 관급 재료 / SC 참조 · 고정 · 자재 / 구조물 조합 일위대가 열) → 구조물 지정 → 사본 만들기(지금 길) → B09 `calc_user` · `daega_inputs` · `payload` 수요 키 · B08 `snapshot_units` · `logic_preview` 답을 지문으로 `855_b09_golden.json` · 손 줄 견본(운반공 · 율 · 고른 재료) 포함 · 실제 B09 프로젝트 1 곳(손 줄 6)은 자기 포트에서 `GET …/estimation` 답 읽기만 전후 대조(tmp) | 새 `resources/tester/test_855_b09_golden.py`(+ 250) · 견본 짓기는 기존 `test_143_*` · `145_*` · `792_3` · `802_4a` 견본을 모아 씀 | 지금 수치 그대로 통과 | 2-A(855-A) |
|
||||
| B9-1 셈 기록 | 문서 셈 줄마다 부른 자원 키 · 하위 문서(키 + 입력) · 고른 품목을 적는 연결 감쌈 | 새 `scripts/master_doc_trace.py`(+ 120) · 시험 | 1,521 기초 기본 옵션 — 기록한 자원 키 = 옛 `whole.get` 가로채기 키(같음) | B9-0 |
|
||||
| B9-2 사본 셈 한 길 | `Item_Copy.calc` · `Item_Prices.calc` = `수식.json` 문서 셈 · B08 `_folder_units` · `_ref_mats` = 문서 셈 답 재료 줄 | `M02_Item_Prices.py`(± 120) · `M02_Item_Copy.py`(± 20) · `B08_Quantity_Router_Material.py`(± 60) | 골든(B08 단위수량 · 사본 셈 금액) 같음 · `test_143_*` · `145_3_b08` | B9-1 · 2-C1(SK 문서 셈) |
|
||||
| B9-3 B09 산근 · 대가 | `Sangeun._solve · _env · _line · call_of · line_calls · _captured · rows_of · _extras · hand_resource_keys` · `Labor_Source._poomsem` · `Linked.used_keys` · `Supply.sk_money` · `Sangeun_Sum` · `Labor_Rule` → 문서 셈 답 + 기록(끝수 = 답 `끝수` · 율 = 금액 줄 `합밖 · 자리 · 단계` 칸) | `B09_Estimation_Sangeun.py`(± 250) · `_Labor_Source.py`(± 120) · `_Linked.py`(± 40) · `_Supply.py`(± 20) · `_Sangeun_Sum.py`(− 40) · `_Labor_Rule.py`(± 60) | 골든 B09 산근 합 · 줄 비목 · 대가 줄 · 내역서 합계 같음 · `test_145_*` · `792_3`(다섯 길) | B9-1 · 2-C1 |
|
||||
| B9-4 산출근거 글 | `Sangeun_Text` 31 곳 → 서버 풀이 글(본 설계 ②) + B09 단가 끼움 | `B09_Estimation_Sangeun_Text.py`(± 250 · 줄어듦) | 글 = 골든 글(줄 수 · 금액 숫자) · 화면 산근 탭 · 운반 모달 ③ 확인 | 2-C4(`master_doc_text`) · B9-3 |
|
||||
| B9-5 사본 꼴 | 새 사본 = `수식.json`(셈 정본) + 자원 줄만 `단가.json` · SK 굳힘(`Item_Sangeun.freeze` → GX9 줄) 대신 SK 수식 문서 사본(따로 · 덮음 반영) · [재생성] · [단가 갱신] 같은 꼴로 | `M02_Item_Source.py`(± 80) · `M02_Item_Sangeun.py`(− 150) · `M02_Doc_B09.py`(± 20) · `B09_Estimation_Bill_Library.py`(± 30) · `_Refresh.py` · `_Copy_Prices.py`(± 40) | 골든 같음 · 사본 파일 칸 전수(`census_copies`) · 옛 꼴 사본 읽기 없음(지금 0 · 1-2) | B9-3 |
|
||||
| B9-6 옛 길 지움 | B08 · B09 의 `run_line` · `mf` · `mau` · `mtx` · `mcut` 부름 · `Item_Prices` 옛 묶음 모음(`_texts` · `collect` 로직 줄) · `Labor_Doc.run_line` 의 B 쪽 | 위 파일들 · 옛 사본 시험 줄(`test_143_4` · `145_1` · `145_2` 등 옛 꼴 견본 부분) | 골든 · 관련 시험 전부 · `/openapi.json` 같음 | B9-5 |
|
||||
|
||||
### 1-5 2-E4(엔진 모듈 지움) 앞 조건 — 새 차례
|
||||
|
||||
1. 본 설계 2-C1(SK 셈 한 길) · 2-C4(서버 풀이 글) 끝.
|
||||
2. B9-0 → B9-6 끝 = B08 · B09 가 옛 엔진 · `master_text` · `master_cut.engine` · `master_auto` 를 부르는 곳 0(`census_calls.py` 에서 B08 · B09 줄 0).
|
||||
3. 불러오기 옛 식 **파서**(`mf.parse` 류 · `Doc_Import` · `San_Basis_Index` · `Sangeun_QtyLinks`)는 엔진 몸과 떼어 「바탕 기반」 새 모듈로(3-3).
|
||||
4. 그 뒤 2-E4 = 엔진 몸 · 셈 · 글 · `master_auto` · `master_combo.run` 지움 · `test_791_1` 은퇴.
|
||||
|
||||
---
|
||||
|
||||
## 2. ㉯ 로직 JSON 없애기 — 수식 문서에 합침
|
||||
|
||||
### 2-1 칸 전수와 갈 곳(`census_logic_fields.py` · 1,521 줄 · 59 파일)
|
||||
|
||||
| 칸 | 줄 수(값 있음) | 문서에 지금 | 갈 곳 |
|
||||
| --- | --- | --- | --- |
|
||||
| 파일 머리 `그룹` · `판` | 59 | 문서 파일 머리 `그룹` · 줄 `판` | 그대로(문서 파일 `그룹 = 수식문서`) |
|
||||
| 파일 머리 `원문` · `부문` · `차례` | 59 · 45 · 58 | 없음(문서 파일 머리 = `로직파일` 이름만) | **문서 파일 머리로** — M01 분류(원문 · 장 차례 · 부문) 정본 |
|
||||
| `키` | 1,521 | 같음 | 그대로 |
|
||||
| `이름` · `결과단위` · `출처` · `부품` | 1,521 · 1,521 · 1,521 · 81 | **같은 값**(다름 0) | 이미 문서 — 로직 쪽 버림 |
|
||||
| `원문번호` · `구분` · `상세구분` · `소유` | 1,521 | 없음 | **문서 줄 머리로**(이름표) |
|
||||
| `비고` · `개정` | 1,452 · 1,257 | 없음 | **문서 줄 머리로** |
|
||||
| `별칭` | 0(지금 값 없음 · 칸은 화면 · 저장 길에 있음) | 없음 | **문서 줄 머리로** |
|
||||
| `입력` · `중간` · `호표` · `덧줄` · `끝수` · `결과` | 1,245 · 1,227 · 1,452 · 570 · 70 · 65 | 문서 `변수` · `식` · `금액` · `끝수` · `결과`(꼴 다름 · 빌더가 변환) | 버림(문서가 셈 정본 · 금액 다름 0 = 본 설계 3 절) |
|
||||
| `입력[].고르기`(기계 목록 2,757) | — | 문서 변수 `선택 목록` | 버림(기계 등록이 문서만 고침) |
|
||||
| `변수표` | 1,423 | 문서 `변수`(이름 · 기호 · 단위 · 빌더 `master_equation` 길) | 버림 |
|
||||
| `시험입력` | 234 | 없음 | **버림** — 읽는 곳 = 옛 틀 검사(`check_master`) · 옛 수식 탭(`master_equation*`) · 한 번용 스크립트뿐(작은 결정) |
|
||||
|
||||
→ 문서에 없는 정보 = 이름표 칸 여섯 + 별칭 + 파일 머리 셋. 셈 칸은 전부 문서가 대신함.
|
||||
|
||||
### 2-2 로직 줄을 읽는 자리 전수(`census_logic_readers.py` · `.logic(` 류 102 곳 49 파일 · 결과 `out_logic_readers.tsv`)
|
||||
|
||||
| 갈래 | 자리(대표 `파일:줄`) | 무엇을 읽나 | 문서 읽기로 바꾸는 법 |
|
||||
| --- | --- | --- | --- |
|
||||
| **M01 관문** | `M01_MasterData_Store.py:337 _logic_files` · `:21-26`(scripts 길 · `check_master.load` → `mf.Master` 로직 그룹) | 로직 파일 전부 | 문서 색인(`master_doc_link.load_all` · 이미 있음)을 관문 하나로 · `mf.GROUPS` 에서 「로직」 뺌 |
|
||||
| 목록 · 찾기 · 분류 | `Store.logics:343` · `files_of('로직'):113` · `subs` · `Store_List.attach` · `Store_Find`(↔ `ui_template_logic_find.ts` 짝) · 화면 `UI_Side.ts:48` · `Logic_List` | `키 원문번호 구분 상세구분 이름 결과단위 출처 소유 별칭` · 파일 머리 차례 | 같은 칸을 문서 머리에서 · 답 꼴 그대로(화면 안 바뀜) |
|
||||
| 상세 · 기본정보 | `Store.logic:384`(+ `blocked` · `prices`) · `LogicLab_Detail` · `_Basic` | 줄 통째 · 막힘 · 단가 미리보기 | 이름표 = 문서 머리 · 막힘 = 2-B3 문서 막힘 · 단가 미리보기 = 문서 셈 |
|
||||
| 별칭 | `M01_MasterData_Alias.py`(`/alias/save` → `Make.save` 별칭 칸) · 로직 목록 `onAlias` | `별칭` 칸 | 문서 머리 `별칭` 쓰기(문서 저장 길 · 잠금 = 걸음 1 의 문서 저장 잠금) |
|
||||
| 개정 · 개정 확인 | `Store_Revise`(정본 줄 지문 · 409) · `UI_Logic_Text.ts` · `build_로직_개정.py` | `개정` · 줄 지문 | 문서 지문(`dc.doc_fp` 꼴) · 개정 칸 = 문서 머리 |
|
||||
| 키 대장 | `master_keys`(`_키대장.json`) · `Store_Save._errors`(키 겹침 · 대장 대조) | 로직 키 발급 · 대조 | 대장 그대로 · 대조 대상 = 문서 키 |
|
||||
| 기계 등록 | `Machine.register`(`M01_MasterData_Machine.py:131-201`) | 로직 `입력[기계].고르기` + 문서 `선택 목록` 두 벌 | 문서만 |
|
||||
| [신규 로직] · [복사/생성] · [삭제] | `Store_Make`(3 곳) · `/logic/copy` · `/logic/formula*` · `/logic/remove` · `/logic/users` | 로직 줄 만들기 · 지우기 · 쓰는 곳 | 문서만 만들고 지움(854-2 가 문서 같이 만들기 하는 중 → 그 뒤 로직 쪽 걷음) |
|
||||
| 저장 검사 | `check_master`(로직 틀 · `시험입력`) · `Store_Save._errors` · `Store_Cache._check · check_saved` | 로직 줄 틀 | 문서 검사(`master_doc.check` + 2-B3 막힘) |
|
||||
| 손고침 판정 | `M01_MasterData_Doc.py`(`built()` = `master_doc_convert.convert(로직 줄)`) | 로직 줄 → 빌더 문서 | 빌더 은퇴와 함께 `손고침` 칸 뜻 없어짐 → 걷음 |
|
||||
| 계산서 덧칸 | `Store_Sheet` · `master_sheet_line`(B09 `_annotate` 도) | 로직 줄 식 | 문서 셈 기록(B9-1) |
|
||||
| 일위대가 조합 알약 · 입력 | `M01_MasterData_Store_Combo.combo_pills` · `M02_Labor_Inputs.py:36-94`(`/logic-lib/inputs` ← M02 일위대가 · B09 손 줄 · 운반 모달 `fetchLogicInputs`) · `Combo_Store` · `Router_Combos` | `입력`(이름 · 설명 · 단위 · 고르기 · 범위) · `결과단위` | 문서 `변수`(입력 갈래 · `선택 목록` · `연결.값` 기본값 = 본 설계 ③) |
|
||||
| M02 기초 고르기 · 찾아 넣기 | `/logic-lib/logics · subs · logic · source`(`M02_MasterTemplete_Router_Combos.py:42-93` → M01 함수) · `Logic_Standard`(2-C4) | 목록 · 이름표 · 출처 | M01 목록 갈래를 따라 바뀜 |
|
||||
| M02 SK · SC 사본 | `Sangeun_Copy`(`사본.로직` · `수식.로직` = **로직 줄 값 사본**) · `Copy_Slim` · `Doc_Gap` · `Item_Prices.collect`(로직 식 글 훑어 닫힌 묶음) | 로직 줄 · 표 · 요소 줄 | 로직 줄 값 사본 없앰 → `수식.부름`(문서 사본)이 대신 · 닫힌 묶음 = `Doc_Copy.closure`(문서로 · 이미 있음) · 표 · 요소 줄은 남음 |
|
||||
| M02 그 밖 이름 · 단위 읽기 | `Layer_Index` · `Library_Flat`(5) · `Doc_Copy` · `Doc_Sk` · `Doc_Take` · `Labor_SkRow` · `Sangeun_Doc` · `Sangeun_Block` · `Machine_Find` · `MyMachine*` · `Material_Own` · `Elem_Alias` | `이름` · `결과단위` · `입력` | 문서 머리 · 변수 |
|
||||
| 불러오기 이음 | `Hopyo_Elem`(5) · `Hopyo_Match`(3) · `Hopyo_Clause` · `Hopyo_Relink` · `Hopyo_Row` · `Hopyo_Units` · `Hopyo_Build` · `Doc_Import` · `San_*` | 엑셀 호표 ↔ M01 기초 맞춤(이름 · 원문번호 · 단위 · 입력) | 문서 머리(원문번호 · 이름 · 단위) · 변수 — **857 과 겹침**(아래 2-3 묶음 ⓒ) |
|
||||
| B08 · B09 | `Item_Source.logic_rows:105`(사본에 로직 줄 실음) · B09 `Sangeun` 6 · `Sangeun_Text` 4 · `Labor_Source` 2 · `Supply` · `Bill_Hopyo` · `Bill_Library` · `Daega_Personal` | 사본 · 지금 M01 로직 줄 | ㉮ 끝(B9-6)이면 0 |
|
||||
| 옛 엔진 · 옛 수식 탭 | `master_formula` · `_check` · `_sum` · `master_cut` · `master_text` · `master_combo` · `master_equation*` · `M01_MasterData_Equation` · `M02_Sangeun_Equation` · `M02_Sangeun_Formula` | 로직 줄 셈 칸 | 2-E2 · 2-E4 로 지움 |
|
||||
| 갱신 스크립트 | `build_로직_직접칸_851_1.py` · `build_로직_개정.py` · `build_용도.py` · `build_재료_검색어.py`(쓰기) · `build_변수표_796_3` · `build_변수기호_800_1` · `build_단위표기_801_5` · `build_기계_작업량_846_1` · `compare_estx` · `master_bundle` · `master_doc_unit` | 로직 JSON 읽고 씀 | 2-4 |
|
||||
| 시험 | 로직 파일 이름 45 · `.logic(` 42 · `run_line` 27 · `master_formula` 23 · `master_doc_convert` 7 · 빌더 4(1,401 시험 파일 중) | 로직 줄 견본 · 대조 | 걸음마다 그 자리 시험만 문서 견본으로 · 대조 시험은 은퇴 |
|
||||
|
||||
### 2-3 차례 · 병행 · 지킴
|
||||
|
||||
| 걸음 | 무엇 | 지킴 | 앞 조건 |
|
||||
| --- | --- | --- | --- |
|
||||
| L1 이름표 싣기(첫 박자) | 빌더가 이름표 칸 일곱 · 파일 머리 셋을 문서에 실음(`--check` 새 기준) · M01 [저장](비고 · 별칭 · 자체 이름 · 개정)이 두 곳에 씀 | 1,521 문서 이름표 = 로직 줄 이름표(다름 0) · 금액 골든 같음 | 2-B3 · 854-2 끝 · **로직 JSON 을 고치는 일감 0**(851 류 끝) |
|
||||
| L2 읽는 쪽 바꿈(묶음 셋 병행) | ⓐ M01 목록 · 찾기 · 분류 · 상세 · 별칭 · 개정 · 키 대장 · 저장 검사 · 기계 등록 · 신규 · 복사 · 삭제 ⓑ M02 입력 목록 · 알약 · 이름 읽기 · SK 사본 `로직` 값 사본 없앰(`수식.부름` 으로) · 닫힌 묶음 = 문서 ⓒ 불러오기 이음(Hopyo · San — 857 과 같이 하거나 857 앞에 이름표 읽기만 바꿈) | 화면 답 전후 같음(`/logics` 전 갈래 · `/subs` · `/groups/로직/files` · `/logic` · `/alias` · `/logic-lib/inputs` 답 JSON 대조) · 금액 골든 · 불러오기 골든(`test_812_1`) | L1 · ⓑ 는 2-C1 · 2-D 뒤 · ⓒ 는 2-C2 뒤 |
|
||||
| L3 로직 JSON 뺌(둘째 박자) | 읽는 곳 0 확인(`census_logic_readers` 관문 · 이름표 0) → `로직_*.json` 59 `git rm`(브레인이 tmp 보관) · `mf.GROUPS` 「로직」 뺌 · 키 대장은 그대로 | 금액 골든 · 화면 답 대조 · 핵심 시험 · 서버 뜸 | L2 · ㉮ B9-6 · 2-E1 · 2-E2 |
|
||||
| L4 은퇴 | 2-4 표 | `test_855_golden` + `test_802_1`(거울)이 관문 | L3 |
|
||||
|
||||
### 2-4 은퇴 목록
|
||||
|
||||
| 대상 | 은퇴 때 | 대신 |
|
||||
| --- | --- | --- |
|
||||
| 빌더 `build_수식문서_802_2.py` · `master_doc_convert` · `_목록_802-2_변환대조.xlsx` | L3 | 문서가 정본 · 고침 = M01 [저장] · 문서 고침 스크립트 |
|
||||
| `test_802_2_convert`(싱크 관문) | L3 | `test_855_golden`(지문) + `test_802_1`(파이썬 ↔ TS 거울) 관문 |
|
||||
| `master_equation*` 6 · `M01_MasterData_Equation` · `M02_Sangeun_Equation` · `master_symbol` | 2-E2(SK 옛 식 덮개 걷음) 뒤 · L3 | 문서 변수(이름 · 기호 · 단위) |
|
||||
| `M01_MasterData_Doc` 의 `built()` · `손고침` 판정 | L3 | 없음(빌더가 없으니 갈림도 없음) |
|
||||
| 「로직 줄을 더한 뒤 채우기」 넷(`build_변수표_796_3` · `build_변수기호_800_1` · `build_단위표기_801_5` · `build_재료_검색어`) | L3 | 문서에서 같은 채우기가 필요하면 문서 대상 스크립트로 다시 씀(지금은 새 로직이 늘 때만 돎) |
|
||||
| `build_로직_개정.py` | L1 에서 문서 머리 `개정` 을 쓰도록 바꿈 | 같은 스크립트 · 대상만 문서 |
|
||||
| 한 번용 `build_로직_*`(851-1 등) | 다 돈 것 → 걸음 0 보관 갈래 | 앞으로 기초 고침 = 문서 고침 스크립트 |
|
||||
| `_갱신절차.md` 로직 절 · 수식 문서 절 | L3 | 수식 문서 절 하나(빌더 없음 · 고치는 길 = 화면 · 문서 스크립트) — 갱신절차 고침은 이 일감 범위 밖 · 그때 같이 |
|
||||
|
||||
### 2-5 수식 문서 파일 나눔
|
||||
|
||||
지금 = 옛 로직 파일마다 한 벌(59 파일 · 원문 · 장 단위 · 파일 머리 `로직파일`). **그대로 둠(권함)** — 분류 화면(원문 · 장 차례)과 파일이 1:1 · 저장 한 번에 작은 파일 하나만 씀 · git 다름이 장 단위로 읽힘. 바꾸는 것 = 파일 머리 `로직파일` → `원문 · 부문 · 차례`(L1) · 파일 이름은 그대로(`수식_<원문>_<NN>장_….json`).
|
||||
|
||||
---
|
||||
|
||||
## 3. ㉰ 호환을 안 만드는 쪽으로 줄이기
|
||||
|
||||
### 3-1 빼거나 줄이는 걸음(저장본을 비우는 전제)
|
||||
|
||||
| 본 설계 자리 | 원래 할 일 | 비우면 | 어림 줄 | 차례 |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| 2-C1 「사본 없는 SK 는 옛 `run_line`」 | 옛 길을 남겨 둠 | **뺌** — SK 는 늘 `수식` 사본으로 만들어짐 · 없는 SK = 「못 셈 · 까닭」 | −150(2-C1 안 옛 갈래 · 2-E2 가 나중에 지울 몫이 미리 없음) | 2-C1 과 2-E2 일부가 한 걸음 |
|
||||
| 2-C1 「옛 칸 값 있는 SK 는 옛 길 그대로(2-D 에서 올림)」 | 옛 7 칸 셈 유지 | **뺌** | −100 | 같음 |
|
||||
| 2-D 「읽을 때 올림」(옛 7 칸 → `따로` 굳힘 · `사본` → `수식` · `바탕판` 버림) | 올림 규칙 새로 + 시험 | **뺌** — 칸만 걷고 읽지 않음 | −250(+ 시험 −150) | 2-D 가 2-C1 바로 뒤에 붙음 · 옛 엔진 살아 있을 때 할 일 없음 |
|
||||
| 5-1 SC 「옛 로직 줄 → SK 참조」(`Labor_SkRow.migrate` 꼴) | 규칙 유지 | **뺌**(이미 걷음 · 자료 0) | 0 | — |
|
||||
| SK `사본` 칸(= `수식` 여섯 칸) · `수식.로직`(로직 줄 값 사본) | 2-D 에서 이행 | 그냥 안 씀 · 안 읽음 · `Copy_Slim` · `Doc_Gap` 의 `사본` 갈래 걷음 | −120 | 2-D |
|
||||
| 옛 SK 상세 길 시험 8 군(`715_*` 4 · `717_4` · `725_1` · `742_1` · `744_1` · `806_1`) | 견본을 문서 꼴로 고쳐 씀 | **지움**(옛 칸 견본만 붙듦) · 살아 있는 결과는 `test_855_sk_layers` 가 봄 | −(시험) | 2-C1 과 같은 커밋 묶음 |
|
||||
| 옛 식 문법 도구 — SK 옛 식 덮개(`Sangeun_Formula` `변수줄 · 식덮개 · 더한줄 수량식`) | 옛 칸 있는 동안 유지 | 저장본에 이 칸 값 0 → **2-C1 과 같이 걷음**(2-E2 몫이 앞당겨짐) | −530 | 2-C1 뒤 |
|
||||
| 프로젝트 옛 사본 꼴 — `Item_Snapshot.migrate_items:198`(25-2b `items/`) · `complete_old:384` · `Item_Copy._migrated:71` | 남김 | 프로젝트 사본 0 · `items/` 0 → **뺌**(판단 거리 3 — 프로젝트는 사용자 확정 범위 밖) | −120 | B9-5 |
|
||||
| `M02_Sk_AutoRenew` 의 옛 사본 갈래 · `MasterTemplete_Tree.old_fields:58` · `MyMachine._old:467` | 남김 | 각 갈래가 옛 저장 꼴을 읽는지 그 걸음에서 확인 뒤 뺌(지금 확인 안 함) | −(미확인) | 2-D · 858 |
|
||||
| B09 사본 안 굳힌 로직(`로직_단가산출.json` · `굳힌줄` · `GX9`) | 판단 5 · B09 와 같이 꼴 바꿈 | 사본 0 → 이행 없이 새 꼴(B9-5) | 0(이행) | B9-5 |
|
||||
|
||||
합 어림 = 코드 **−1,200 줄 안팎** + 이행 시험 0 · 2-D 크기 절반 · 2-E2 일부가 2-C1 로 당겨짐.
|
||||
|
||||
### 3-2 저장본을 비울 때 · 범위(비우는 일은 하지 않음 · 브레인이 사용자 확인 뒤)
|
||||
|
||||
**때 = 2-C1 바로 앞**(855-B 끝 · 855-C 첫 걸음 전). 까닭: 2-C1 이 옛 칸 · 사본 없는 SK 를 보지 않으려면 그때 자료가 새 꼴뿐이어야 함 · 2-A 골든은 저장본이 아니라 임시 storage 견본이라 영향 없음 · 비운 뒤 사용자가 새로 만든 SK 는 이미 새 꼴(`수식` 있음).
|
||||
|
||||
| 후보 | 자리 | 지금 수(`census_storage` · `census_copy_fields`) | 권함 |
|
||||
| --- | --- | --- | --- |
|
||||
| 단가산출 SK | 개인 `templates/sangeun/SK-*.json` · `sangeun_폴더.json` | 14 ~ 15(세는 동안 늘어남 = 사용자가 지금 만드는 중) · 가져온 식 12 ~ 13 | 비움 — 단 **사용자가 지금 개인 층에서 단가산출을 만들어 쓰는 중**(공통 지시) → 판단 거리 4 |
|
||||
| 일위대가 SC | 개인 `precombo/SC-*.json` · `precombo_폴더.json` | 6 | 비움(같은 판단) |
|
||||
| 지운 문서 보관 | 개인 `_합친것/` | SK 12 · SC 3 | 비움 |
|
||||
| 구조물 조합 | 회사 · 개인 `구조물집계표조합.json` · `table/구조물집계표.json` | 줄 0(파일 6 · 표 6) | 그대로(빈 틀 · 새 꼴 상관없음) |
|
||||
| 불러온 자료 | 개인 `실무자료/`(불러옴 4 · HP 3) | 7 | 비움 — 다시 불러오면 새로 생김 |
|
||||
| 내 기계 · 내 재료 | 개인 `내기계/_다음.json` · `개인자재.json` | 1 · 1 | 858(서고 한 벌) 앞에 같이 · 855 엔 상관없음 |
|
||||
| 번호 · 겉 | `_번호.json` · `manifest.json` | 1 · 1 | 비우면 번호도 처음부터(번호 겹침 위험 없음 — 문서 0) |
|
||||
| **따로 둠** | 마스터 층 `resources/master_template/`(구조물 표 · 도면 틀 · 구조물정의) · 회사 `drawing/` · 프로젝트 `_initial/` · `drawing/` · `table/`(14 프로젝트) | — | 비우지 않음 — 다른 페이지(B05 · B08 · 도면)가 씀 |
|
||||
| **따로 둠** | B09 견적 저장 `B09_Estimation/v1/`(1 프로젝트 · 손 줄 로직 6) | — | 프로젝트 자료 — 확정 범위 밖 · 키가 같아 새 계산기로 그대로 셈 |
|
||||
|
||||
### 3-3 가져온 식(`가져온.로직` = 옛 로직 줄 꼴)은 따로
|
||||
|
||||
- 지금 SK 12 의 `가져온.로직` 칸 = `호표 · 중간 · 덧줄 · 단계 · 끝전 · 이름 · 결과단위`(옛 로직 줄 꼴) — 불러오기 읽기기(`Hopyo_*` · `San_*`)가 **불러올 때마다 이 꼴을 새로 냄** → 저장본을 비워도 다시 생김.
|
||||
- 이것을 문서로 바꾸는 `Doc_Import`(`mf.parse` · `_OPS` · `_plain`) · 가져온 식 기호 `San_Basis_Index` · `Sangeun_QtyLinks` 는 **옛 식 파서**만 씀(엔진 셈 · 글 · 끝수는 안 씀 · 2-C2 · 2-C3 뒤).
|
||||
- 가름: 2-E4 때 파서(`parse` · 연산 표)는 「바탕 기반」 새 모듈(`mf.Master` · `FormulaError` · `COST_ITEMS` 등과 같이)로 떼어 남김 → 857(불러오기 한 번 읽기)이 읽기기에서 문서를 바로 내면 그때 파서도 걷음.
|
||||
- 저장본 비우기와 무관 · 호환 아님(살아 있는 입력 꼴).
|
||||
|
||||
---
|
||||
|
||||
## 4. ㉱ 바뀐 전체 걸음 표 · 병행 묶음
|
||||
|
||||
### 4-1 걸음 표(본 설계 4-1 을 고친 것 · ★ = 새 · ✂ = 줄임)
|
||||
|
||||
| 걸음 | 무엇 | 바뀐 점 |
|
||||
| --- | --- | --- |
|
||||
| 2-A 지킴 올림 | 855 시험 넷 · 골든 | 끝(855-A) |
|
||||
| ★ B9-0 B09 견본 · 골든 | 1-4 | 새 |
|
||||
| 2-B1 | 854-2 확인만 | 그대로 |
|
||||
| 2-B2 · 2-B3 · 2-B4 | 기계 폴백 · 문서 막힘(기준 지금 그대로 · 확정 3) · M01 시험 계산 | 그대로 |
|
||||
| ★ B9-1 셈 기록 | 1-4 | 새 · 2-B 와 병행 |
|
||||
| ★ 저장본 비움(사용자 확인 · 브레인) | 3-2 | 새 · 2-C1 바로 앞 |
|
||||
| 2-C1 ✂ SK 셈 한 길 | 수식 사본 셈만 · 옛 길 갈래 없음 · `Sangeun_Formula` 옛 식 칸 · 옛 상세 시험 8 군 같이 걷음 | 옛 칸 · 사본 없는 SK 갈래 뺌 |
|
||||
| 2-C2 · 2-C3 | 가져온 식 열기 · 검산 | 그대로 |
|
||||
| 2-C4 | 기준 목록 · 서버 풀이 글 ② | 그대로 · B9-4 의 앞 조건 |
|
||||
| 2-C5 | 나머지 셈 자리 | 그대로 |
|
||||
| ★ B9-2 · B9-3 | 사본 셈 · B08 / B09 산근 · 대가 | 2-C1 뒤 |
|
||||
| ★ B9-4 · B9-5 | 산출근거 글 · 사본 꼴 | 2-C4 · B9-3 뒤 |
|
||||
| 2-D ✂ 파일 칸 정리 | 칸 걷음만(올림 규칙 · 이행 없음) · `사본` · `수식.로직` 안 씀 | 크기 절반 |
|
||||
| ★ L1 이름표 싣기 | 2-3 | 새 · 2-D 와 병행 가능(파일 다름) |
|
||||
| 2-E1 · 2-E2 | M01 · M02 옛 길 지움 | 2-E2 일부(옛 식 칸)는 2-C1 로 당겨짐 |
|
||||
| ★ B9-6 B08 · B09 옛 길 지움 | 1-4 | 새 |
|
||||
| ★ L2 읽는 쪽 바꿈 ⓐ ⓑ ⓒ | 2-3 | 새(본 설계 2-E3 의 앞 절반) |
|
||||
| 2-E3 → L3 · L4 | 로직 JSON 뺌 · 빌더 은퇴 | 「이름표만 남김」 → 「없앰」 |
|
||||
| 2-E4 엔진 모듈 지움 | 1-5 차례 · 파서는 바탕 기반으로 | 보류 풂 |
|
||||
|
||||
### 4-2 병행 묶음(창 여덟까지 · 파일 안 겹침)
|
||||
|
||||
| 묶음 | 같이 도는 걸음(창) | 겹침 확인 | 앞 조건 |
|
||||
| --- | --- | --- | --- |
|
||||
| ① | 2-B2 · 2-B3 · 2-B4 · 2-C2 · 2-C4 · **B9-0** · **B9-1**(일곱) | 본 설계 ② + 새 시험 파일 · 새 `master_doc_trace.py` — 서로 다름 | 2-A · 2-B2 는 854-1 뒤 |
|
||||
| ② | 저장본 비움(브레인 · 사용자 확인) | — | ① 의 2-B3 |
|
||||
| ③ | 2-C1(중심) · 2-C3 · **B9-2**(B08 · `Item_Prices` · `Item_Copy`)(셋) | Sangeun_Calc · Doc_Sk ↔ Sangeun_Imported ↔ Item_* · B08 — 다름 | ② · 2-C2 · B9-1 |
|
||||
| ④ | 2-C5 · **B9-3**(B09 Sangeun · Labor_Source · Linked · Supply · Sum · Rule) · 856 화면 하나 · **L1**(빌더 · M01 저장 두 곳)(넷) | Labor_Expand · Hopyo_Build ↔ B09 5 파일 ↔ 화면 TS ↔ 빌더 · M01 Store_Save — 다름 | 2-C1 · B9-2 |
|
||||
| ⑤ | 2-D · **B9-4** · **B9-5** · **L2 ⓐ**(M01 쪽)(넷) | Sangeun_Doc · Copy_Slim 무리 ↔ B09 Sangeun_Text ↔ Item_Source · Item_Sangeun · Bill_Library ↔ M01 Store 무리 — 다름(B9-4 · B9-5 는 B09 안 파일이 다름) | ④ · 2-C4 |
|
||||
| ⑥ | 2-E1 · 2-E2 · **B9-6** · **L2 ⓑ**(M02 이름 읽기 · SK 값 사본)(넷) | M01 ↔ M02 Sangeun 무리 ↔ B08 · B09 ↔ M02 Labor_Inputs · Layer_Index 무리 — 2-E2 와 L2 ⓑ 가 `Sangeun_Copy` 를 같이 만질 수 있음 → 그 파일은 2-E2 한 창 몫 | ⑤ · 856 |
|
||||
| ⑦ | **L2 ⓒ**(불러오기 이음 — 857 과 합침 권함) | Hopyo · San | ⑥ · 857 |
|
||||
| ⑧ | L3 → L4 → 2-E4(차례 · 한 창) | scripts · 자료 | ⑥ · ⑦ |
|
||||
|
||||
꼭 차례인 까닭(본 설계에 더함):
|
||||
- 저장본 비움은 2-C1 앞 — 2-C1 이 옛 꼴 갈래를 안 가지려면.
|
||||
- B9-2 · B9-3 은 2-C1 뒤 — 사본 안 SK 셈이 문서 한 길이어야 B09 가 같은 답을 받음.
|
||||
- B9-4 는 2-C4 뒤 — 서버 풀이 글이 먼저 있어야 함.
|
||||
- L1 은 로직 JSON 을 고치는 일감이 0 일 때 — 빌더 기준이 두 번 바뀌지 않게.
|
||||
- L3 은 B9-6 · 2-E1 · 2-E2 · L2 뒤 — 로직 줄을 읽는 곳 0.
|
||||
- 2-E4 는 L3 뒤 — `mf.Master` 의 로직 그룹이 빠져야 엔진 몸이 지울 수 있는 꼴.
|
||||
|
||||
### 4-3 세기 결과 파일(`tmp/s894/m855b/`)
|
||||
|
||||
| 도구 | 결과 | 핵심 수 |
|
||||
| --- | --- | --- |
|
||||
| `census_calls.py`(sub6 · 내 폴더에서 다시) | `out_calls.tsv` | 185 자리 · 39 파일 · B08 1 · B09 5 파일 51 자리 |
|
||||
| `census_copies.py` · `census_storage.py`(sub6) | `out_copies.json` · `out_storage.json` | 프로젝트 사본 0 · SK 15 · SC 6 · `_합친것` 15 |
|
||||
| `census_logic_fields.py`(새) | `out_logic_fields.json` | 로직 칸 19 · 문서와 같은 값 4 · 문서 없는 이름표 6 + 별칭 + 파일 머리 3 |
|
||||
| `census_logic_readers.py`(새) | `out_logic_readers.tsv` | 파일 · 갈래(관문 · 파일 이름 · 셈 칸 · 이름표 칸)별 자리 |
|
||||
| `census_copy_fields.py`(새) | `out_copy_fields.json` | SK `수식.로직` 16 줄 · `사본.로직` 12 줄 · `가져온.로직` 12 · B09 손 줄 `ref.tab = logic` 6 |
|
||||
|
||||
---
|
||||
|
||||
## 5. 사용자 판단 거리
|
||||
|
||||
1. **B09 손 줄이 M01 기초를 바로 고르는 기능** — B09 설계내역서 [단가 연결] · 운반 단가 모달에서 M01 단가산출 기초를 직접 골라 셈(지금 프로젝트 1 곳에 6 줄). 확정 1(「M02 것을 복사해 가져감」)과 어긋남. ㉠ 그대로 둠 — 같은 새 계산기로 셈 · 지금 6 줄 그대로 이어짐(권함) ㉡ M02 단가산출만 고르게 바꿈 — 6 줄을 다시 이어야 함.
|
||||
2. **「계산을 직접 할 일 없음」 의 뜻** — 프로젝트에서 구조물 입력값 · 운반 거리를 바꾸거나 [단가 갱신] 을 누르면 금액이 다시 나와야 함. 이때 M02 와 **같은 계산기 한 벌**을 불러 다시 셈(B09 엔 식 엔진 없음 · 갈라 합산만)으로 이해(권함 · 1-3 안 B). 「복사 때 굳힌 금액만 쓰고 프로젝트에선 절대 다시 셈 안 함」 이 뜻이면 입력 바꿈 · [단가 갱신] 을 M02 [재생성]으로만 하게 바뀜.
|
||||
3. **프로젝트 쪽 옛 꼴** — 확정 5 는 M02 층 자료. 프로젝트 사본은 지금 0 개라 옛 사본 꼴 읽기(25-2b `items/` 옮겨 받기 등)도 같이 걷어도 되는지(권함 = 걷음 · 지금 옮길 것 0).
|
||||
4. **저장본 비우는 때** — 지금 개인 층 단가산출이 계속 늘어나는 중(세는 동안 14 → 15). 2-C1 앞에 비우면 그 사이 만든 것도 지워짐 → 비우기 전날 알림 · 남길 것만 다시 만들 길(가져온 식은 다시 불러오면 됨)을 같이 알림.
|
||||
|
||||
## 6. 못 본 것
|
||||
|
||||
- 서버 · 화면을 돌리지 않음(코드 따라가기 + 자료 세기). 「살아 있음」 = 화면 TS 에서 서버 길까지 이름으로 이은 것 · 단추를 눌러 보지 않음.
|
||||
- B09 프로젝트 1 곳의 손 줄 6 은 칸 이름만 셈(로직 키 · 값 안 봄).
|
||||
- `M02_Sk_AutoRenew` · `MasterTemplete_Tree.old_fields` · `MyMachine._old` 가 옛 저장 꼴만 읽는지는 확인 안 함(3-1 「미확인」).
|
||||
- `.logic(` 류 자리 수(102)는 글자 찾기 — `whole.logic` 처럼 이름을 바꿔 부르는 곳 · 문자열로 조립한 부름은 빠졌을 수 있음(L3 앞 전수는 다시 셈).
|
||||
- 855-A 시험(sub6 커밋 327fdc5d9)은 이 폴더 받은 판에 아직 없음 — 이름만 PLAN 에서 봄.
|
||||
- 줄 수 어림은 함수 크기로 짐작한 값.
|
||||
@@ -0,0 +1,311 @@
|
||||
# 설계 855 — 걸음 2 「정본 하나 · 계산기 하나」 (PLAN 855-0)
|
||||
|
||||
요구 894 · 896 · sub6 · 2026-11-17 · 읽기 · 측정만(코드 · 자료 · 시험 고침 0). 측정 도구 · 결과 = `tmp/s894/m855/`.
|
||||
|
||||
## 0. 한눈 요약
|
||||
|
||||
- **지금 두 엔진의 금액은 같음** — 불러오기 3,241 블록 합계 다름 **0** · 로직 1,521 기본 옵션 합계 · 줄 비목 금액 다름 **0** · 옵션 표본 18,926 까지 넣으면 합계 다름 3(이미 채택된 714-3) · 줄 비목 다름 13(같은 채택 계열) · 그 밖 다름은 전부 **보이는 단가 · 풀이 값 차이(금액 같음)**.
|
||||
- **수식 문서 없는 로직 0 / 1,521** · 손고침 0 · 기계덮음 0 · 옛 막힘 0.
|
||||
- 저장소: 층 서고 SK 14(전부 개인 층 · 가져온 식 12 · **「따로」 1** · 옛 칸 값 0) · SC 6(옛 로직 줄 0) · **프로젝트 사본 0**(구조물 사본 · B09 서고 사본 · 굳힌 로직 파일 모두 0). → 옮길 자료가 거의 없음.
|
||||
- 옛 엔진을 부르는 자리 = 서버 **39 파일 185 곳**(M01 7 · M02 26 · **B08 1 · B09 5**). 화면 TS 쪽 옛 길 = 6 갈래.
|
||||
- **새로 만들어야 하는 것 넷**: ① 문서 막힘 검사 한 함수 ② 서버 풀이 글(문서 셈 답 → 산출근거 글) ③ 문서 기본값 읽기(옛 `master_auto` 대신) ④ 가져온 식 검산(문서 줄 ↔ 엑셀 글줄 맞댐).
|
||||
- **막는 것 하나**: B08 · B09 가 옛 엔진(`run_line` · `mf.evaluate` · `master_text`)을 직접 부름 → 옛 엔진 **모듈 지움**은 그 페이지가 옮긴 뒤. 855 범위 = M01 · M02 가 옛 엔진을 안 부르게 하는 데까지(7 절 판단 1).
|
||||
|
||||
---
|
||||
|
||||
## 1. 옛 엔진을 부르는 자리 전수
|
||||
|
||||
전수 표 = `m855/out_calls.tsv`(파일 · 줄 · 감싼 함수 · 부름 — 185 줄). 아래는 목적별로 묶은 것.
|
||||
|
||||
### 1-1 서버 — 금액 셈(엔진 몸 직접)
|
||||
|
||||
| 자리 | 무엇을 얻나 | 새 계산기로 바꿀 것 | 새로 만들 것 |
|
||||
| --- | --- | --- | --- |
|
||||
| `M02_Labor_Doc.py:541 run_line` — **옛 엔진 관문**(`mf.run` + `mcut.engine` + `mau.values`) | 로직 줄 금액 · 줄 · 중간 · 재료 | 문서 셈 `master_doc_calc.calc`(문서 = 로직 키의 수식 문서 + 입력값 · 고름) | 「로직 줄 → 문서 입력」 맞춤(입력값 이름 = 변수 열쇠 · 고름 = 재료 연결) |
|
||||
| `M02_Sangeun_Calc.py:383 · 387 run` · `:268 sub_run` | SK 줄 금액 · 글 · 중간(옛) → 끝에서 `M02_Doc_Sk.py:223 on_run` 이 기준 · 1단위만 문서 값으로 덮음 | 수식 사본 셈(`Doc_Sk.run`)을 **처음부터** 씀 · 줄도 문서 답 | 셈 답 꼴 맞춤(줄 `cid` · 덮개 표지 · 빠진줄 · 정체 · 배 · 꼬리표) — 화면 · 일위대가가 먹는 칸 |
|
||||
| `Sangeun_Calc.run` 을 거쳐 부르는 곳: `M02_Doc_Sk.py:294 settle`(저장) · `M02_Doc_Sk_Path.py:76 current`(수식 읽기) · `M02_Doc_Take.py:97 _sk`(복사 펼침 배) · `M02_Labor_Patch.py:103 run`(줄 덮개) · `M02_Sangeun_Const.py:365 sheet` · `M02_Sangeun_Imported.py:349 _run`(검산) · `M02_Doc_Import.py:83 _ctx`(가져온 식 문서 짓기 전 색인) | 금액 · 색인(ctx) | 위 한 길로 따라 바뀜 · `_ctx` 는 문서 짓기에 옛 엔진 색인 대신 가져온 로직 줄을 바로 변환 | `Doc_Sk.derive`(:118)가 옛 엔진 ctx 없이 문서를 짓는 길 |
|
||||
| `M02_Labor_Copy.py:141 line` | 일위대가 로직 줄 금액(옛 먼저 · 사본 있으면 기준만 문서) | 사본 있으면 문서만 | — (저장소 옛 로직 줄 0) |
|
||||
| `M02_Labor_Expand.py:91 _promote` · `:121 _logic` | 옛 단가승격 · 로직 줄 펼침 | 문서 셈 | — |
|
||||
| `M02_Hopyo_Build.py:333 _inside` | 호표 → SC 만들 때 안쪽 로직 금액 | 문서 셈 | — |
|
||||
| `M02_Machine_Hourly.py:201 hourly`(`store.calc`) · `:270 brief` · `M02_MyMachine.py:245 hourly` | 기계 시간당 — **문서 없을 때만 폴백** | 폴백 걷음(문서 없는 로직 0 · 복사/생성이 문서를 만들면 영영 0) | 「문서 없음」 까닭 글 하나 |
|
||||
| `M02_Sangeun_Imported.py:419 _inner` | 가져온 식 안쪽 산근 금액 | 형제 SK 문서 셈(`dim.run`) | — |
|
||||
| `M02_Logic_Standard.py:336 sheet` · `:133 axes` | M02 [로직 더하기] · 찾아 넣기 **기준 목록 · 계산서 보기**(살아 있는 화면) | 문서 셈 + 옵션 축 = 문서 변수 `선택 목록` | 서버 풀이 글(1-2) |
|
||||
| `M02_Logic_Settle.py:41 settle` | 기준 목록 금액 · B09 산근 끝수 규칙 짝(`test_704_settle`) | 문서 끝수 기본(줄 버림 1 · 비목 버림 0)과 같은 규칙 → 문서 셈 | — · B09 짝이 남는 동안 이 파일은 B09 몫으로 둠 |
|
||||
| `M02_Sangeun_Const.py:335 _mids` · `M02_Sangeun_Views.py:29 text_of` | 옛 「상세 몸」 시트 답 · 풀이 글(`detail=True` 화면 셈 길만) | 856(화면 하나)에서 상세 몸과 같이 걷음 | — |
|
||||
| M01 `M01_MasterData_Store.py:553 calc` · `:582 text`(`/m01/calc` `:259` · `/text` `:281` · M02 감쌈 `M02_Logic_Lib_Read.py:61 · 67`) | M01 [로직 복사/생성] 시험 계산 · 상세 몸 풀이 글 | 시험 계산 = `/logic/doc/preview`(`Router.py:329` · 이미 있음) | — |
|
||||
|
||||
### 1-2 서버 — 풀이 글 · 기본값 · 끝수 · 검사 · 식 도구
|
||||
|
||||
| 갈래 | 자리 | 새 쪽 | 새로 만들 것 |
|
||||
| --- | --- | --- | --- |
|
||||
| **풀이 글** `master_text` | `Store.text`(:589) · `Sangeun_Views.text_of` · `Logic_Standard.sheet`(`mtx.lines`) · `_range_label` · `_table_reps` · B09 `Sangeun_Text`(31 곳) | 서버 글 **없음** — 화면 줄 쌓기 오른쪽(`line_stack_out.ts`)이 브라우저 계산기 답으로 그림 | **② 서버 풀이 글**(문서 셈 답 → 줄 글 · 조각) — 기준 목록 · 계산서 · (뒤에) B09 산출근거가 씀. 파이썬 ↔ TS 짝으로 `line_stack_out` 의 글 규칙을 옮김 |
|
||||
| **입력 기본값** `master_auto.values` | `Store.auto`(:577 · `/logic/auto` `:188`) · `M02_Doc_Copy.py:270 given_of` · `M02_Labor_Inputs.py:94` · `Sangeun_Calc.py:206 _defaults` · `run_line` · `Logic_Standard.axes` · B09 `Sangeun._env` | 문서 변수 `연결.값`(빌더가 `master_equation.given_of` 로 채워 둠) | **③ 문서 기본값 읽기** 한 함수(변수 열쇠 → 값) |
|
||||
| **끝수** `master_cut` | `Labor_Doc.settle`(:450) · `reflect`(:403) · `drop_apart`(:270) · `Labor_Expand._combo`(:173) · `Labor_Fixed.ratio_row`(:202) · B09 `Sangeun_Sum` | 일위대가 합산(③ 갈래 · TS 짝 `Labor_Calc.ts`)이 쓰는 줄 · 합 끝수 — **옛 엔진과 따로 살아 있는 규칙** | 없음 — `row` `sums` `down` `plain` `kept` 는 남겨 「일위대가 끝수」 로 옮김 · `engine` `_sub` 만 은퇴 |
|
||||
| **막힘 · 저장 검사** | `Store.logic`(:390 · `/logic` 의 `blocked` `reasons`) · `Store_Cache._check`(:99 · 목록 막힘) — `mf.check_logic` / `Store_Cache.check_saved`(:276) · `Store_Save._errors`(:74) — `mcb.check_all` / `Store_Combo` · `Combo_Store` — `mcb.check_row`(일위대가 조합 입력 이름 검사) | 문서 검사 `master_doc.check`(표지) · 계산기 표지 | **① 문서 막힘 검사** 한 함수(`check` 표지 + 부름 닫힘 · 순환) · 조합 검사는 입력 이름을 변수 열쇠로 |
|
||||
| **엔진 속살(식 문법 도구)** | `Sangeun_Formula`(`_Parser` `_check_node` `walk` — SK 옛 식 덮개 칸) · `Doc_Import`(`parse` `_OPS` `_plain` — 가져온 로직 줄 → 문서) · `San_Basis_Index` · `Sangeun_QtyLinks`(`parse` `_OPS`) · `Item_Prices`(`_expand` `_HOLE` `fill` `static` `walk` — 프로젝트 사본 단가 묶음 닫힘) · `Labor_Doc.pct_extras · _pct_base · _specs` · B09 `Labor_Rule` | 문서 식 파서 `master_doc.parse` | 옛 식 문법을 읽는 곳은 「옛 꼴 자료(가져온 로직 줄 · 굳힌 로직)」 가 남는 동안 필요 — 그 자료가 문서 꼴로 바뀌면 함께 걷음 |
|
||||
| **바탕 기반(남김)** | `mf.Master`(요소 · 표 색인) · `mf.FormulaError` · `find` · `master_material` · `master_pick`(`mf.mp`) · `COST_ITEMS` `BUNDLE` `GROUPS` — 새 계산기(`master_doc_link.py:120`)도 씀 · Hopyo_* · Material_Own 도 씀 | — | 은퇴 때 `master_formula` 에서 이것만 떼어 새 이름 모듈로(엔진 몸 · 파서 · 셈 · 글은 지움) |
|
||||
| 옛 수식 탭 `master_equation*` | `M01_MasterData_Equation.py:51 export_row`(M02 `Sangeun_Formula` 가 부름) · 빌더 · `master_doc_convert`(기본값 `given_of` · 기호) | — | 빌더 은퇴와 함께 |
|
||||
|
||||
### 1-3 B08 · B09 가 옛 엔진을 부르는 자리(이름만 · 그 페이지 코드는 범위 밖)
|
||||
|
||||
| 파일 | 함수 | 부름 |
|
||||
| --- | --- | --- |
|
||||
| `B08_Quantity_Router_Material.py:79` | `run` | `labor.run_line` |
|
||||
| `B09_Estimation_Sangeun.py` | `_solve:346` · `hand_resource_keys:622` · `_env:202` · `_line:447` · `call_of:227` · `_extras:540` · `_captured:275` | `run_line` · `mf.evaluate` `parse` `fill` `_inputs` · `mau.values` |
|
||||
| `B09_Estimation_Sangeun_Text.py` | 13 함수 · 31 곳 | `mf.*` · `master_text`(산출근거 글) |
|
||||
| `B09_Estimation_Labor_Source.py:140` · `B09_Estimation_Linked.py:64` | `_poomsem` · `used_keys` | `run_line` |
|
||||
| `B09_Estimation_Sangeun_Sum.py:36 · 87` · `B09_Estimation_Labor_Rule.py:90 · 115` | 끝수 · 율 식 | `mcut._line` `settle` · `mf.parse` |
|
||||
|
||||
→ 프로젝트 쪽은 **사본(굳힌 로직 `GX9…` · `로직_단가산출.json`)을 옛 엔진으로 셈**(`M02_Item_Sangeun.py:27`). 지금 저장소 사본은 0 이지만 길은 살아 있음.
|
||||
|
||||
### 1-4 화면 TS 쪽
|
||||
|
||||
| 화면 | 부르는 길 | 지금 엔진 | 걸음 2 뒤 |
|
||||
| --- | --- | --- | --- |
|
||||
| M01 · M02 줄 쌓기(단가산출 · 기계 보기 · 가져온 식) | 브라우저 `common_util_formula_doc_calc.ts calcDoc`(↔ `master_doc_calc` 짝) | 새 | 그대로 |
|
||||
| M02 단가산출 상세 몸 · 머리 띠(까닭 · 빠진 줄 · 짝 잃음 · M01 개정) | `M02_MasterTemplete_Sangeun_Cover.ts:25 calcSangeun` → `/layers/{층}/sangeun/calc` ← `Sangeun_Detail.ts:216-217`(두 번) · `Labor_RowSk.ts:53`(정체만) · 풀이 `logic/M02_Sangeun_Cover_Model.ts hoView` | 옛 줄 + 새 합계 | 서버 답이 새 한 길 · 답 꼴 그대로 → 화면 안 바뀜 · 856 에서 상세 몸 걷음 |
|
||||
| 일위대가표 · 프로젝트 모달 카드 | `M02_MasterTemplete_Labor_Api.ts:265 calcLabor` ← `Labor_Table.ts:245` · `Labor_View.ts:132` · `ui_template_item_picker_detail.ts:206` | SK 줄 = 위 SK 셈 · 로직 줄 = 옛 | 같은 답 꼴 |
|
||||
| M01 [로직 복사/생성] 시험 계산 | `M01_MasterData_UI_Logic_Drive.ts:61-62 runCalc · runText`(`/calc` `/text`) ← `Logic_Calc.ts:143` · `LogicLab_Copy.ts:275 previewLogicFormula` | 옛만 | `/logic/doc/preview` 로 |
|
||||
| M02 찾아 넣기 · [로직 더하기] 기준 목록 · 계산서 | `M02_MasterTemplete_Find_Pick.ts:371`(`/logic-lib/standard`) · 계산서 `calc_sheet` | 옛 | 서버 문서 셈 + 풀이 글 ② |
|
||||
| 기계 고를 때 시간당 | `Find_Pick.ts:257`(`/logic-lib/machine-hourly`) | 문서 먼저 · 폴백 옛 | 문서만 |
|
||||
|
||||
---
|
||||
|
||||
## 2. 자료 실태(세기 · 칸 이름 · 개수만)
|
||||
|
||||
도구 = `m855/census_storage.py` · `census_copies.py` · 결과 `out_storage.json` · `out_copies.json` · 못 연 자리 0(권한 막힘 없음).
|
||||
|
||||
### 2-1 M01 기초
|
||||
|
||||
| 항목 | 수 |
|
||||
| --- | --- |
|
||||
| 로직 줄(GC 1,191 · GF 329 · GX 1) | 1,521 |
|
||||
| 수식 문서 · 로직 없는 문서 · **문서 없는 로직** | 1,521 · 0 · **0** |
|
||||
| 부품 문서 · 돈 아닌 문서(결과) | 81 · 65 |
|
||||
| 손고침 · 기계덮음 | 0 · 0 |
|
||||
|
||||
### 2-2 층 서고 저장본
|
||||
|
||||
| 층 | SK | SC | 칸 · 판정 |
|
||||
| --- | --- | --- | --- |
|
||||
| 마스터(`resources/master_template`) | 0 | 0 | 단가산출 · 일위대가 폴더 없음 |
|
||||
| 회사 | 0 | 0 | `table` · `drawing` · 조합만 |
|
||||
| 개인 | **14** | 6 | SK 칸 = 옛 칸 열넷(전부 있음) + `바탕판 M01판 수식`(14) · `사본`(13) · `가져온`(12) |
|
||||
| 개인 `_합친것` | 11(지움 꼴 `{키 종류 지움 고친곳 때 누가}`) | 3 | 지운 문서 보관 |
|
||||
|
||||
SK 14 판정: 옛 7 칸 값 든 것 **0** · 옛 0/5 칸 6 **0** · `사본` 없음 1 · `사본 ≡ 수식`(여섯 칸) 13 / 13 · **「따로」 1**(분석 때 0 → 그 뒤 생김) · 바탕 = 로직 1 · 없음 13 · 가져온 식 12 · 굳힌줄 0.
|
||||
SC 6 의 줄 28 = 참조 13 · 고정 15 · **옛 로직 줄 0**.
|
||||
|
||||
### 2-3 프로젝트 폴더 안 사본
|
||||
|
||||
| 항목 | 수 |
|
||||
| --- | --- |
|
||||
| 프로젝트 폴더 | 14 |
|
||||
| 구조물 사본 `templates/structures/{id}/`(`단가.json` · `일위대가.json` · `로직_단가산출.json` · `수식.json`) | **0** |
|
||||
| B09 서고 사본(`library/`) | **0** |
|
||||
| 프로젝트 층 `templates/sangeun` · `precombo` | 0 |
|
||||
| B09 견적 저장 | 1 프로젝트(`B09_Estimation/v1/price_book.json` · `user_values.json`) |
|
||||
| 프로젝트 층 저장 꼴 | `_initial/` + 작업본(`drawing` 4 · `table/구조물집계표` · `구조물집계표조합` · `manifest`) — 14 / 14 같은 꼴 |
|
||||
|
||||
→ **옮길 프로젝트 사본 0**(이 저장소 기준 · 데스크탑 임시 배포 storage 는 Synology 동기화로 같은 것으로 봄 · 7 절).
|
||||
|
||||
### 2-4 B08 · B09 가 읽는 단가산출 · 일위대가 칸(이름만)
|
||||
|
||||
| 칸 | 읽는 파일 |
|
||||
| --- | --- |
|
||||
| `사본` | B09 `Past` · `Refresh` · `Router_Import` |
|
||||
| `바탕` | B09 `Daega_Personal` · `Labor_Source` · `Linked` · `Sangeun` · `Supply` |
|
||||
| `덮개` · `더한줄` · `뺀줄` · `열린입력` · `자재표시` | B09 `Daega_Personal` · `Labor_Source`(+ `Past` · `Router` 덮개) |
|
||||
| `입력값` · `고름` · `켜쌓기율` · `담은로직` | B08 `Router_Material` · B09 `Daega_Personal` · `Linked` · `Labor_Source` · `Sangeun` · `Bill_Library` · `Bill_Hopyo` |
|
||||
| `굳힌줄` | B09 `Linked` · `Sangeun` |
|
||||
| `수식` · `가져온` · `바탕판` · `M01판` | 없음 |
|
||||
|
||||
→ 걸음 2-D 에서 SK 옛 칸을 걷어도 B09 는 **사본 쪽 옛 칸**(굳힌 SK)을 읽음 — 프로젝트 사본 꼴은 B09 와 같이 바꿔야 함(7 절 판단 1 · 5).
|
||||
|
||||
---
|
||||
|
||||
## 3. 두 엔진의 지금 차이 — 전수 측정(지킴 수치)
|
||||
|
||||
### 3-1 도구
|
||||
|
||||
| 도구 | 무엇 | 시간 | 결과 |
|
||||
| --- | --- | --- | --- |
|
||||
| `m855_logic.py --no-options` | 로직 1,521 × 기본 입력 · 옛(`mf.run`+`mcut.engine`) 대 새(저장된 수식 문서 · `mc.calc`) · 층 L0 ~ L4 | **16 초** | `out_logic.json` |
|
||||
| `m855_logic.py` | + 옵션 표본 18,926(고르기 입력 갈래마다 하나 · 빌더 대조와 같은 표본) = 20,447 셈 | 196 초 | 〃 |
|
||||
| `m855_sk.py` | 층 서고 SK 전부(임시 복사본 위) · `Sangeun_Calc.run` 옛 답(문서 덮음 끔) 대 새 답 · 옛 줄 비목 합 = 새 기준 | 6 초 | `out_sk.json` |
|
||||
| `m855_block.py` | 막힘 판정 옛 `check_logic` 대 새(문서 표지 · 기본 셈 셈됨) | 22 초 | `out_block.json` |
|
||||
| `m855_import.py [--quick]` | 불러오기 블록 전수(원파일 EST 6 · STC 7 · 실무 엑셀 11) · 가져온 식 SK 옛 엔진 셈 대 문서 계산기 셈 | 빠른 표본 3 파일 221 블록 128 초 · 전수 3,241 블록 **26 분**(관문 아님 · 전수는 손으로) | `out_import.json` |
|
||||
| `census_calls.py` · `census_storage.py` · `census_copies.py` | 1 · 2 절 세기 | 수 초 | `out_calls.tsv` · `out_storage.json` · `out_copies.json` |
|
||||
|
||||
층(앞 층이 다르면 뒤 층은 안 봄): **L0 합계**(노 · 재 · 경 · 계 · 돈 아닌 = 결과) · **L1 줄 비목**(줄 이름마다 비목 금액 합 · 기계 한 대 = 줄 나눔 묶음) · **L2 줄 꼴**(차례 · 이름 · 금액 · 비목) · **L3 수량 · 단가** · **L4 풀이 값**(옛 `중간` 수가 새 기호 값 · 줄 값에 있는가).
|
||||
|
||||
### 3-2 결과 — 로직 1,521
|
||||
|
||||
| 층 | 기본 1,521 | + 옵션(20,447) | 까닭 | 판정 |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| L0 합계 | **0** | 3 | GC000091 지역=울산 · GC000093 지역=경북 · GC000100 지역=전북 — 식 속 단가산출 부름 = 끝수 뒤 값(새) · 끝수 전(옛) | **채택(요구 714-3)** · 빌더 `ADOPTED` 와 같음 |
|
||||
| L1 줄 비목 | **0** | 13 | GC000091 · 092 · 093 · 094 · 100 의 지역 옵션 — 같은 까닭이 줄 하나(소모자재 0.1 원)에만 닿고 합계 원 단위는 같음 | 채택 계열 |
|
||||
| L2 줄 꼴 | 0 | 0 | — | 같음 |
|
||||
| L3 수량 | 0 | 0 | — | 같음 |
|
||||
| L3 단가 표시 | 499 | 7,531 | 옛 = 줄 끝수 자리로 자른 단가(284.4) · 새 = 날 값(284.42142…) · 금액 같음 | 보임만 |
|
||||
| L3 묶음 단가 | (위에 포함) | | 기계 줄 단가 = 옛 수(계) · 새 묶음 `{노 재 경 계}` — 계로 맞대 같음 | 꼴만 |
|
||||
| L3 수량 0 줄 | 17 | 177 | 옛 단가 0 · 새 단가 빈 값(수량 0 = 금액 0 규칙) | 보임만 |
|
||||
| L3 값 없음 줄 | 0 | 303 | 수량이 빈 값인 줄 — 옛 단가 빈 값 · 새 단가 채움(금액 둘 다 빈 값) | 보임만 |
|
||||
| L4 풀이 값 | 10 | 198 | GC000087 · 090 ~ 096 · 098 · 100 — 옛 중간 「드릴경비 · 브레이커경비」 단계 값이 새 문서엔 기호로 없음(기계 한 대 = 줄 나눔으로 사라진 옛 중간) | 금액 같음 · 풀이 글 차이 |
|
||||
| 둘 다 못 셈 | 3 | 175 | 기본 옵션으로 셈이 안 되는 로직 3 + 옵션 갈래 | 같음 |
|
||||
|
||||
막힘(`m855_block`): 옛 막힘 **0** · 새 표지 **0** · 새 기본 셈 못 함 3(= 둘 다 못 셈 3).
|
||||
|
||||
### 3-3 결과 — 층 서고 SK 14
|
||||
|
||||
| 항목 | 수 |
|
||||
| --- | --- |
|
||||
| 새 답 = 문서 계산기(수식 사본 있음) | 14 / 14 |
|
||||
| 옛 기준 = 새 기준 | 13 / 14 |
|
||||
| 다름 1 | **「따로」 SK** — 문서가 정본인데 옛 엔진은 빈 옛 칸 · 바탕으로 셈 → 옛 답 줄 0 · 기준 다름. 화면 머리 띠 · 상세 몸 · 일위대가 줄 금액이 이 옛 답을 먹음 = **「줄 금액 = 옛 · 합계 = 새」 가 실제로 갈린 첫 사례** |
|
||||
| 옛 줄 비목 합(원 버림) ≠ 새 기준 | 3(따로 1 + 가져온 식 2 — 기준은 같음 · 줄 합과 합계 끝수 차이 유력: 가져온 식 끝수 규칙(끝전 · 조정) · 미확인) |
|
||||
|
||||
### 3-4 결과 — 불러오기 블록
|
||||
|
||||
| 원천 | 블록 | 옛 합계 = 새 합계 | 한쪽만 못 셈 |
|
||||
| --- | --- | --- | --- |
|
||||
| 원파일 EST 6 | 1,849 | 1,849 | 0 |
|
||||
| 원파일 STC 7 | 371 | 371 | 0 |
|
||||
| 실무 엑셀 11 | 1,021 | 1,021 | 0 |
|
||||
| **합** | **3,241** | **3,241(다름 0)** | 0 |
|
||||
|
||||
- 옛 = 가져온 식 검산 길(`Sangeun_Imported._run` · 옛 엔진) · 새 = `Doc_Import.derive` + 문서 계산기(지금 화면 · 저장 길).
|
||||
- 「옛 줄 비목 합 = 옛 합계」 판정(1,499 같음 · 1,742 다름)은 **도구 한계로 판정에 안 씀** — 가져온 식 줄에는 소계 · 단계 · 합밖 · 형제 산근 줄이 섞여 단순 합이 합계가 아님. 줄 단위 대조는 2-C3(검산 새로) 때 줄 맞댐 열쇠를 정한 뒤 다시 잼.
|
||||
|
||||
### 3-5 일위대가 줄
|
||||
|
||||
- 저장소 SC 줄 28 = 참조 13(SK 셈 = 3-3 과 같은 길) · 고정 15(엑셀 숫자 · 셈 아님) · 옛 로직 줄 0 → **`Labor_Copy.line` 의 옛 길을 실제 자료로 잴 수 없음**. 시험 견본(`715` 군 · `742_1` 등)만 그 길을 탐.
|
||||
|
||||
### 3-6 `resources/tester` 지킴 시험으로 올릴 꼴(제안)
|
||||
|
||||
| 시험 | 내용 | 시간 | 관문 |
|
||||
| --- | --- | --- | --- |
|
||||
| `test_855_engine_parity.py` | 기본 1,521 L0 ~ L3(단가 표시 갈래는 허용 갈래로 셈) 다름 = 채택 목록과 같음 · 옵션 전수는 환경 `S855_ALL=1` | 16 초(전수 3.3 분) | 걸음 2 동안 싱크 관문에 더함 |
|
||||
| `test_855_golden.py` | 새 계산기 답 지문 — 로직마다 (기본 + 옵션 표본) 답(노 재 경 계 · 줄 금액 · 비목)을 한 해시로 · `resources/tester/data/855_golden.json`(약 1,521 줄 · 수십 KB) | 16 초 ~ | **옛 엔진을 지운 뒤** 옛 → 새 대조를 이것이 대신 |
|
||||
| `test_855_sk_layers.py` | 임시 storage 견본 SK(옛 칸 · 따로 · 가져온 식 · 율 더한줄 · 형제 SK) 셈 답 줄 합 = 합계 · 옛 대 새 같음 | 수 초 | 걸음 2-C 동안 |
|
||||
| `test_855_block.py` | 막힘 판정 옛 = 새(2-B3 뒤에는 새만 · 표지 0 지킴) | 22 초 | — |
|
||||
| 불러오기 | 기존 `test_812_1_xlsx_golden`(문서 계산기 = 엑셀 100 %)에 「옛 검산 = 새 검산」 한 단언 더함 · 전수는 `S8121_ALL=1` | 표본 2 분 | 지금 관문 |
|
||||
|
||||
결과 판정은 금액 · 동작만(소스 글자 안 봄). 측정 도구 원본은 `tmp/s894/m855/` — 올릴 때 시험 꼴로 다시 씀.
|
||||
|
||||
---
|
||||
|
||||
## 4. 차례 설계
|
||||
|
||||
원칙: 한 걸음 = 한 길만 · **두 박자**(새 길로 바꿈 → 전수 다름 0 → 다음 묶음에서 옛 길 지움) · 걸음마다 한 커밋 묶음(되돌리기 = 그 커밋만) · 화면은 걸음마다 그대로 돎(서버 답 꼴 유지).
|
||||
|
||||
### 4-1 걸음 표
|
||||
|
||||
| 걸음 | 무엇을 바꾸나 | 고칠 파일(어림 줄) | 지킴 | 위험 · 막는 법 | 화면 확인 |
|
||||
| --- | --- | --- | --- | --- | --- |
|
||||
| **2-A 지킴 올림** | 3-6 시험 넷 · 골든 지문 · 관문 목록 | `resources/tester/test_855_*` 넷(+ 300) · `tools/sync_core_tests.txt`(1) | 지금 수치 그대로 통과 | 시험 시간 — 기본만 관문 · 전수는 환경 변수 | — |
|
||||
| 2-B1 [로직 복사/생성] 수식 문서 같이 만듦 | **854-2 가 하는 중** → 855 에서 빼고 확인만 | — | `m855_block` · 문서 없는 로직 0 | — | 복사/생성 → 수식 탭이 채워짐 |
|
||||
| 2-B2 기계 시간당 폴백 걷음 | 「문서 없음 = 못 셈 · 까닭」 | `M02_Machine_Hourly.py`(− 60) · `M02_MyMachine.py`(− 35) | `test_842_3`(655 대) · `test_822_2` | 854-1 이 `M02_MyMachine.py` 를 고치는 중 → **854-1 뒤** | 기계 고르기 시간당 · 내 기계 보기 |
|
||||
| 2-B3 막힘 · 저장 검사를 문서 기준으로 | ① 문서 막힘 검사 새 함수 → `/logic` `blocked` · 목록 막힘 · 일위대가 조합 검사(입력 이름 → 변수 열쇠) | 새 `scripts/master_doc_block.py`(+ 120) · `M01_MasterData_Store.py`(± 10) · `_Store_Cache.py`(± 15) · `_Store_Save.py` · `_Store_Combo.py` · `M02_MasterTemplete_Combo_Store.py`(± 20) | `test_855_block`(옛 = 새 · 막힘 0) · `test_masterdata_check` | 막힘 기준 갈림(기본 셈 못 함 3) — 표지만 막힘으로(7 절 판단 3) | M01 로직 목록 막힘 표시 · 조합 알약 |
|
||||
| 2-B4 M01 시험 계산을 문서 셈으로 | 복사/생성 [시험 계산] = `/logic/doc/preview` | `M01_MasterData_UI_LogicLab_Copy.ts` · `_Logic_Calc.ts` · `_Logic_Drive.ts`(± 60) | `npm run typecheck` · 시험 계산 금액 = 수식 탭 금액 | 상세 몸 `/text` 조각은 856 까지 남음 | M01 복사/생성 시험 계산 |
|
||||
| 2-C1 **SK 셈 한 길**(줄 금액까지) | `Sangeun_Calc.run` = 수식 사본 셈 먼저 · 옛 `run_line` 은 사본 없는 SK(지금 0)만 · 답 꼴 맞춤 · `derive` 가 옛 ctx 없이 지음 | `M02_Sangeun_Calc.py`(± 120) · `M02_Doc_Sk.py`(± 80) · `M02_Doc_Sk_Path.py`(± 20) · `M02_Labor_Copy.py`(± 20) | `test_855_sk_layers` · `m855_sk`(14 / 14 · 줄 합 = 기준 · 「따로」 줄 수 > 0) · `test_802_4a` · `836_2` · `848_*` · 거울 `802_1` | 옛 SK 상세 길 시험 8 군(옛 칸 값 견본) — 옛 칸 값 있는 SK 는 이 걸음에선 옛 길 그대로(2-D 에서 올림) | 단가산출 머리 띠 · 일위대가 줄 금액 · 「따로」 SK 줄 |
|
||||
| 2-C2 불러온 식 열기 | `Doc_Import._ctx` 옛 엔진 색인 → 가져온 로직 줄 직접 변환 | `M02_Doc_Import.py`(± 80) | `m855_import` 전수 · `test_812_1` · `test_810_2` · `test_802_4b1` | 가져온 값 층(`Doc_Import_Carry`)이 색인에 기댐 — 같이 확인 | 불러오기 [가져온 식으로 열기] |
|
||||
| 2-C3 가져온 식 검산 | ④ 문서 줄 ↔ 엑셀 글줄 맞댐 새로 · `check` = 문서 계산기 | `M02_Sangeun_Imported.py`(± 100) | 검산 판정 옛 = 새(3,241 블록 · 줄마다) | 줄 맞댐 열쇠(정체 · 행) — 2-C2 뒤 | 불러오기 줄 칠 · 검산 표 |
|
||||
| 2-C4 기준 목록 · 계산서 | 문서 셈 + ② 서버 풀이 글 | 새 `scripts/master_doc_text.py`(+ 250 · TS `line_stack_out` 글 규칙과 짝 · 거울 시험) · `M02_Logic_Standard.py`(± 80) | 기준 목록 금액 전수 = 옛(로직 × 대표 규격) · 거울 시험 | `Logic_Settle` 은 B09 짝이라 남김 | M02 찾아 넣기 · 계산서 보기 |
|
||||
| 2-C5 나머지 엔진 셈 자리 | `Labor_Expand._promote · _logic` · `Hopyo_Build._inside` · `Sangeun_Imported._inner` · `Labor_Patch.run` · `Doc_Take._sk` → 문서 셈 | 5 파일(± 100) | `test_m02_labor_*` · `test_621` · 불러오기 표본 | 옛 단가승격 줄(자료 0) | 일위대가 펼침 |
|
||||
| 2-D **파일 칸 정리**(855-3) | SK 저장 꼴 줄임 · 읽을 때 올림 규칙 · `_합친것` 그대로 | `M02_Sangeun_Doc.py` · `M02_Copy_Slim.py` · `M02_Doc_Sk.py`(OLD_FIELDS) · `M02_Library_Flat.py` · `M02_Sangeun_Copy.py` · `M02_Sk_AutoRenew.py` · `M02_Doc_Gap.py`(± 300) | SK 14 셈 답 전후 같음 · 저장 → 다시 읽기 왕복 · 칸 전수(`census_storage`) | `사본` 을 읽는 py 19 파일 중 **B09 3** — 올림 규칙(사본 없으면 수식에서)으로 B09 가 그대로 읽게 | 단가산출 저장 · 다시 열기 |
|
||||
| 2-E1 M01 옛 길 지움 | `/calc` `/text`(M01 · M02 감쌈) · `Store.calc · text · auto` · `check_logic` 부름 | M01 4 파일 · `M02_Logic_Lib_Read.py`(− 150) | `/openapi.json` 길 전후(뜻한 길만 빠짐) | 856 이 상세 몸 `/text` 를 걷은 뒤 | — |
|
||||
| 2-E2 M02 옛 길 지움 | `run_line` 의 M02 부름 · `Sangeun_Const._mids · sheet` · `Sangeun_Views.text_of` · `Sangeun_Formula` 옛 식 덮개 | M02 6 파일(− 1,000 안팎) · 옛 상세 길 시험 8 군 | 2-A 시험 넷 · 관련 시험 전부 | 856 뒤(상세 몸이 먹는 답) | — |
|
||||
| 2-E3 **로직 JSON 끝 모습 · 빌더 은퇴**(855-4) | 5 절 ㉮ · 빌더 · `master_doc_convert` · `master_equation*` · `test_802_2` 은퇴 · 관문 = `test_855_golden` | 로직 JSON 59 파일 · scripts 8 파일 · 시험 | `test_855_golden` 같음 · M01 화면 목록 · 별칭 · 개정 | 로직 JSON 칸을 읽는 M01 화면 · 검사 | M01 로직 목록 · 별칭 · 복사/생성 |
|
||||
| 2-E4 옛 엔진 모듈 지움 | `master_formula` 엔진 몸 · `master_cut.engine` · `master_text*` · `master_auto` · `master_combo.run` · 바탕 기반은 새 모듈로 | scripts 6 파일(− 2,500) · `test_791_1` 은퇴 | `test_855_golden` · 전 관련 시험 | **B08 · B09 가 부르는 동안 못 함**(7 절 판단 1) | — |
|
||||
|
||||
### 4-2 병행 묶음(창 여덟까지 · 파일 안 겹침)
|
||||
|
||||
| 묶음 | 같이 도는 걸음 | 겹침 확인 | 앞 조건 |
|
||||
| --- | --- | --- | --- |
|
||||
| ① | 2-A(한 창) | 시험 파일 새로만 | 854 끝 |
|
||||
| ② | 2-B2 · 2-B3 · 2-B4 · 2-C2 · 2-C4(다섯 창) | M02 Machine/MyMachine · M01 Store 무리 · M01 화면 TS · M02 Doc_Import · M02 Logic_Standard + 새 scripts 파일 — 서로 다름 | ① · 2-B2 는 854-1 뒤 |
|
||||
| ③ | 2-C1(한 창 · 중심) · 2-C3(한 창 · 2-C2 뒤) | Sangeun_Calc · Doc_Sk 무리 ↔ Sangeun_Imported — 다름 | ② 의 2-C2 |
|
||||
| ④ | 2-C5(한 창) · 856 화면 하나(한 창 · 별도 PLAN) | Labor_Expand · Hopyo_Build ↔ 화면 TS · Sangeun_Detail — 다름 | 2-C1 |
|
||||
| ⑤ | 2-D(한 창) | Sangeun_Doc · Copy_Slim · Library_Flat 무리 | ③ · ④ |
|
||||
| ⑥ | 2-E1 · 2-E2(두 창) | M01 ↔ M02 | ⑤ · 856 |
|
||||
| ⑦ | 2-E3 → 2-E4(차례) | scripts · 자료 | ⑥ · 판단 1 · 2 |
|
||||
|
||||
꼭 차례인 까닭:
|
||||
- 2-A 먼저 — 모든 걸음의 「다름 0」 판정 자.
|
||||
- 2-C1 은 2-D 앞 — 옛 칸을 걷으려면 그 칸을 읽는 옛 셈이 먼저 꺼져야 함.
|
||||
- 2-C3(검산)은 2-C2 뒤 — 검산 줄 맞댐 열쇠가 새 문서 짓기 꼴에 기댐.
|
||||
- 2-E 는 856 뒤 — 상세 몸이 옛 답 덧칸(풀이 글 · 시트)을 먹음.
|
||||
- 2-E3 은 2-E1 · 2 뒤 — 빌더가 지금 옛 로직 JSON 의 셈 칸에서 문서를 지음(고침이 있으면 문서로 옮겨야 함).
|
||||
- 2-E4 는 맨 끝 — 엔진 모듈을 B09 가 import.
|
||||
|
||||
---
|
||||
|
||||
## 5. 끝 모습
|
||||
|
||||
### 5-1 저장 파일 꼴
|
||||
|
||||
| 파일 | 남는 칸 | 걷는 칸 | 옛 파일을 읽을 때 올림 |
|
||||
| --- | --- | --- | --- |
|
||||
| 단가산출 SK | `종류 키 이름 단위 구분 상세구분 본뜬` · `바탕 {로직 \| 참조} \| null` · `수식 {판 시점 로직 단가판 단가시점 단가 부름 문서 따로 위덮음 …}` · `M01판` · `가져온 {원본 로직 단가기준}` | 옛 7 칸(`입력값 열린입력 고름 자재표시 덮개 더한줄 뺀줄` — 값 0 / 14) · 옛 6 칸(0 / 14) · `사본`(= `수식` 여섯 칸 복제) · `바탕판`(= M01판 겹침 · 유력) · `수식.문서.가져온`(= `가져온.원본` 복제) | 옛 7 칸에 값이 있으면 **2-D 때(옛 엔진이 살아 있을 때)** 한 번 문서로 굳혀 `따로` 로 · `사본` 만 있으면 `수식` 으로 옮김 · `바탕판` 은 버림 |
|
||||
| 일위대가 SC | `종류 키 이름 단위 구분 상세구분 본뜬` · `담은로직 [{참조 \| 고정, 별칭 메모 수량}]` · `자재` | `사본`(SC 엔 `수식` 이 같은 값) · 옛 로직 줄 꼴(`{로직 입력값 고름 …}` — 0 / 28) | 옛 로직 줄 → SK 참조 줄(`Labor_SkRow.migrate` 와 같은 규칙 · 지금 0) |
|
||||
| 가져온 식 SK | 위 SK + `가져온.원본`(엑셀 글줄 · 금액 · 표지) · `가져온.로직`(엑셀 블록 정본) | `수식.문서.가져온` | 열 때 `가져온.원본` 에서 다시 붙임 |
|
||||
| 프로젝트 사본(구조물 · B09 서고) | 수식 문서 사본(`수식.json` · `M02_Doc_B09.py` 꼴 · 802-4a) | 굳힌 로직(`로직_단가산출.json` · `굳힌줄` · `GX9…`) | **지금 사본 0** → 이행 대상 0 · 다만 B09 가 굳힌 로직을 옛 엔진으로 셈하므로 꼴 바꿈은 B09 와 같이(판단 5) |
|
||||
|
||||
### 5-2 로직 JSON 끝 모습 — ㉮ 대 ㉯
|
||||
|
||||
| | ㉮ 이름표만 남김 | ㉯ 수식 문서에 합쳐 없앰 |
|
||||
| --- | --- | --- |
|
||||
| 남는 것 | 로직 JSON = `키 구분 상세구분 소유 원문번호 개정 비고 별칭`(셈 칸 `입력 중간 호표 덧줄 끝수 변수표 시험입력` 걷음) · 수식 문서 = 셈 정본 + `이름 결과단위 출처`(셈 답에 찍히는 칸) | 수식 문서 하나(위 이름표 칸을 문서 머리에 더함) · 로직 JSON 59 파일 없앰 |
|
||||
| 좋은 점 | M01 목록 · 별칭 · 개정 · 분류 화면과 검사가 지금 읽는 파일 그대로 · 걸음이 작음 · 되돌리기 쉬움 | 파일 한 벌 · 복제 0 · 기계 등록 한 곳 |
|
||||
| 나쁜 점 | 파일 두 벌(복제는 0 이 되도록 칸을 나눠도 키 대장 둘) | M01 관문 `Store`(89 파일이 부름) · 목록 · 별칭 · 검사 · 개정 화면을 모두 문서로 옮김 — 크고 위험 |
|
||||
| 권함 | **㉮ 먼저**(855-4) · ㉯ 는 걸음 5 뒤에 다시 판단 | |
|
||||
|
||||
### 5-3 빌더 · 대조 시험 · 지문 시험
|
||||
|
||||
| 대상 | 은퇴 조건 | 대신할 지킴 |
|
||||
| --- | --- | --- |
|
||||
| 빌더 `build_수식문서_802_2.py` · `master_doc_convert` · 목록 xlsx | 로직 JSON 셈 칸 걷음(2-E3) — 그 뒤엔 지을 근원이 없음 | 수식 문서가 정본 · M01 [저장] 길만 씀 |
|
||||
| `test_802_2_convert`(관문 · 옛 → 새 대조) | 2-E3 | `test_855_golden`(새 계산기 = 고정 지문) + `test_802_1`(파이썬 ↔ TS 거울)을 관문으로 |
|
||||
| `test_791_1`(옛 엔진 지문) | 2-E4 | 같음 |
|
||||
| 옛 SK 상세 길 시험 8 군(`715_*` · `725_1` · `742_1` · `744_1` · `717_4` · `806_1`) | 2-E2 | `test_855_sk_layers`(같은 견본을 문서 꼴로) |
|
||||
|
||||
### 5-4 화면이 읽게 될 정본
|
||||
|
||||
| 화면 | 끝 모습 |
|
||||
| --- | --- |
|
||||
| M01 [로직 복사/생성] | 수식 문서를 복사해 새 키 문서 + 이름표 줄(854-2 가 문서 같이 만듦 → 2-E3 뒤엔 문서 복사만) · 시험 계산 = 문서 셈 |
|
||||
| M01 로직 목록 막힘 | 문서 막힘 검사(표지) |
|
||||
| 별칭 | 이름표(㉮) 칸 그대로 · 별칭 장부 화면 그대로 |
|
||||
| M02 단가산출 · 일위대가 · 불러오기 | 서버 = 문서 계산기 한 길 · 브라우저 = 짝 계산기 |
|
||||
|
||||
---
|
||||
|
||||
## 6. 걸음 3 · 4 · 5 와 맞물리는 자리
|
||||
|
||||
| 걸음 | 2 에서 미리 해 두면 쉬운 것 | 2 에서 건드리지 말 것 |
|
||||
| --- | --- | --- |
|
||||
| 3 화면 하나(856) | 2-C1 에서 `/sangeun/calc` 답 꼴 유지 + 머리 띠 칸(까닭 · 빠진 줄 · 짝 잃음 · M01 개정)을 문서 답에서 채움 → 856 은 화면만 바꿈 | 상세 몸 TS(`LogicLab_Ho` · `Cover_Model` · `Sangeun_Detail`) · `Sangeun_Views` 글 덧칸 — 856 몫 |
|
||||
| 4 불러오기(857) | 2-C2 · 2-C3 으로 가져온 식이 옛 엔진 없이 열리고 검산되면 857 은 읽기기 합침만 남음 | `Hopyo_*` 읽기기 · 재료 이음 규칙 · `San_*` — 857 몫 |
|
||||
| 5 서고(858) | — | 내 기계 저장(`MyMachine` 의 저장 · 번호 · 폴더) · `Library_*` 쓰는 곳 찾기 — 2-B2 는 `MyMachine.hourly` 만 · 2-D 는 SK 칸만 |
|
||||
|
||||
---
|
||||
|
||||
## 7. 사용자 판단 거리 · 못 본 것
|
||||
|
||||
### 7-1 판단 거리
|
||||
|
||||
1. **B08 · B09 가 옛 엔진을 직접 부름**(6 파일 · 1-3) — 걸음 2 를 ㉠ M01 · M02 가 옛 엔진을 안 부르게 하는 데까지로 하고 옛 엔진 모듈은 그 페이지가 옮길 때까지 남김(권함 · 2-E4 보류) ㉡ 같은 때 B09 도 옮김(따로 큰 일감).
|
||||
2. **로직 JSON 끝 모습** — ㉮ 이름표만 남김(권함) · ㉯ 수식 문서에 합침.
|
||||
3. **막힘 기준** — 기본 옵션으로 셈이 안 되는 로직 3 개를 막힘으로 보일지(새 기준) · 지금처럼 열림(권함 · 표지만 막힘).
|
||||
4. **화면에 보이는 단가** — 옛 = 끝수 자리로 자른 단가 · 새 = 날 값(금액 같음 · 7,531 셈). 보일 때 줄 끝수 자리로 잘라 보이는 것을 기본으로 정함(물음 아님 · 다르면 말씀).
|
||||
5. **프로젝트 사본 꼴** — 굳힌 로직(옛 엔진으로 셈) → 수식 문서 사본으로 바꾸는 일은 B09 와 같이(지금 사본 0 개 · 1 번과 같이 정함).
|
||||
|
||||
### 7-2 못 본 것
|
||||
|
||||
- 서버를 띄우지 않고 파이썬으로 직접 셈 · 화면 조작 없음(「화면 확인」 칸은 걸음마다 할 것).
|
||||
- 데스크탑 임시 배포 storage 는 Synology 로 같은 것이라 보고 따로 안 셈 · DB 에는 M01 · M02 표 없음(분석 E).
|
||||
- 풀이 글 비교는 「옛 중간 값이 새 값에 있는가」 수준 — 글 꼴 · 문장 비교 아님.
|
||||
- SK 표본 14(개인 층 · 다른 사용자 것 포함 · 칸 · 판정만 셈 · 값 안 봄) · 가져온 식 2 의 줄 합 ≠ 기준 까닭 미확인(유력 = 엑셀 끝수 규칙).
|
||||
- 일위대가 옛 로직 줄 · 옛 칸 값 SK · 프로젝트 사본이 자료에 0 이라 그 길은 시험 견본으로만 잴 수 있음.
|
||||
- B08 · B09 코드는 이름만 봄(무엇을 부르는지) · 그 페이지 동작은 안 봄.
|
||||
@@ -0,0 +1,221 @@
|
||||
# 설계 858 — 걸음 5 「서고 한 벌」
|
||||
|
||||
요구 896 · 898 · 899 · 2026-11-17 · sub4 · 읽기만(코드 · 자료 · 시험 안 고침). 근거 = `파일:줄`(sub_laptop_4 · 커밋 962476e69). 세기 도구 · 결과 = `tmp/s894/m858/`(끝 절).
|
||||
|
||||
## 0. 한눈 요약
|
||||
|
||||
- 층 서고 종류 아홉 가운데 **단가산출 · 일위대가 둘만 한 틀**(`Store.write` + `Library_*` + `Precombo_Folders`). 구조물 조합 · 표 · 도면은 같은 `Store.write` 를 쓰나 목록 · 나무 · 번호가 따로. 내 기계 · 내 재료 · 실무자료 · 재료 고름 · 공유 요청은 저장 · 번호 · 목록 · 쓰는 곳 찾기를 **각자** 가짐.
|
||||
- 같은 일 여러 벌(지금 자리 확인): 층 폴더 찾기 **5**(진짜 몸 2) · 폴더 → 층 판정 **4** · 쓰는 곳 찾기 **10**(서고 참조 4 + 자원 키 6) · 쓰기 권한 판단 **3**(+ TS 짝 1) · 파일 판 `version_of` **M02 3**(+ M01 2) · 쓰기 잠금 **4 벌** + **잠금 없는 여러 파일 쓰기 5 곳** · 번호 체계 **7 갈래** · 목록 **8**.
|
||||
- 제안 = **새 틀을 만들지 않고 가장 잘 된 것을 넓힘**: 종류 표 하나(`Template_Layers` 안 · 옵션 칸) + 부품 일곱(층 폴더 · 권한 · 판 · 여러 파일 쓰기 · 번호 장부 · 쓰는 곳 색인 · 저장). 새 파일 = 지킴 시험 1 · 쓰는 곳 색인 1(`Labor_Ref` 700 줄 경계 때문에 떼어 냄) 뿐.
|
||||
- 걸음 = 5-0 지킴 → 5-1 · 5-2 · 5-3(셋 병행) → 5-4 → 5-5 → 5-6 → 5-7(공유 · 판단 뒤) → 5-8 옛 코드 지움. 어림 **서버 +250 / −450 줄**.
|
||||
- **지금 바로 시작해도 되는 조각** = 5-0 · 5-1 · 5-3(855 남은 걸음 · 856 · 857 과 파일 안 겹침). 실무자료 · 재료 고름은 **857 과 같이**.
|
||||
|
||||
## 1. 지금 모습
|
||||
|
||||
### 1-1 종류 · 자리 · 서버 길
|
||||
|
||||
| 종류 | 저장 자리(층 폴더 안) | 층 | 서버 길(묶음) |
|
||||
| --- | --- | --- | --- |
|
||||
| 단가산출 SK | `sangeun/SK-######.json` + 뿌리 `sangeun_폴더.json` · `_번호.json` | 마스터 · 회사 · 개인 · 프로젝트(굳힘) | `/layers/{층}/library/{kind}` · `{kind}-tree(/paste)` · `{kind}-same(/merge /undo)` · `-tree/delete-check` · `-flat` · `-reset` · `templates/sangeun/{키}` · `sangeun/{키}/doc/*` |
|
||||
| 일위대가 SC | `precombo/SC-######.json` + `precombo_폴더.json` | 같음 | 같음(종류 인자) |
|
||||
| 구조물 조합(항목 · 열) | `table/구조물집계표.json`(열 · 경로 = 나무) + 뿌리 `구조물집계표조합.json`(장부) + `structure/ area/ labor/<열id>.json` | 같음 | `/items` · `/layers/{층}/tree` · `items/paste` · `personal/items/copy` · `structures/*` · `area/*` · `{kind}/{column}/clear·copy` |
|
||||
| 구조물 표 · 도면 틀(양식) | `table/*.json` · `drawing/*.json` | 같음 + 프로젝트 `_initial/` | `/layers/{층}/templates(/{kind}/{name})` GET · PUT · DELETE |
|
||||
| 내 기계 | `내기계/EQP{사용자}-####.json` + `내기계/_다음.json` | 개인만 | `/layers/personal/my-machines(/{키})` · `/{키}/impact` · `my-machine-lists · -find` · `machine-sheet` |
|
||||
| 내 재료 | 뿌리 `개인자재.json`(한 파일 묶음 `{그룹, 원문, 줄, 마지막}`) | 개인만 | `/layers/{층}/materials(/{키})`(**`Labor_Router` 안** · 이름 안 맞음) |
|
||||
| 실무자료(불러온 것) | `실무자료/HP-######.json` · `격자/` · `산근/` · `불러옴.json{번}` | 개인만 · 하루 지나면 숨김 | `/layers/{층}/hopyo*`(층 글 무시 · 늘 개인) |
|
||||
| 재료 고름 | `실무자료/재료고름/<파일 지문>.json` | 개인만 | `/layers/{층}/material-picks/{fp}` |
|
||||
| 공유 요청 | 회사 층 뿌리 `올리기요청.json{줄}` | 회사 | `/share-requests(/{id}/approve·reject · /seen)` |
|
||||
|
||||
서버 길 수(자기 포트 `openapi.json` 읽기 · `routes.tsv`): M02 108 가운데 단가산출 · 일위대가 28 · 구조물 조합 · 표 · 도면 12 · 내 기계 9 · 내 재료 5 · 불러오기 15 · 공유 5.
|
||||
|
||||
### 1-2 일마다 하는 자리 — 저장 쪽
|
||||
|
||||
| 종류 | 층 폴더 찾기 | 목록 | 폴더(나무) | 만들기 · 번호 | 저장(잠금 · 판 · 원자) |
|
||||
| --- | --- | --- | --- | --- | --- |
|
||||
| SK · SC | `Router_Items._root:145`(서고 길) · `Router_Layers._layer_dir:140`(templates 길) | `Router_Layers.list_layer:229` → `Layer_Index.list_rows:90` · `summaries:152` | `Precombo_Folders.view:67` · `edit:180`(**판 대조 · 잠금 없음**) | `Labor_Ref.create:385` · `next_key:367` + `_번호.json`(854-1) | `Store.write:142`(잠금 `_LOCK:80` · 판 409 · 원자) · 프로젝트 = `layers.write_template:251`(판 · **잠금 없음**) |
|
||||
| 구조물 조합 | `Router_Items._root:145` | `Items.items:62` · `get_tree:219` | 표 안 경로 `Tree.apply:233` → `Store.write`(표) | `Item_Personal.create_item:44` · `Items.copy_item:140` · 장부 키 `Book.key_head:36`(`SC{회사}-` · `SP{사용자}-` · `다음`) · 도번 `Store._serial:326`(지운 번호 `_retired:339` 셈) | `Store.write`(표 · 세 파일 · `sync_combos:629`) |
|
||||
| 표 · 도면 틀 | `Router_Layers._layer_dir:140` | `Layer_Index.list_rows` · `Template_Layers.list_templates:150` | 없음 | 이름 = 파일 이름(번호 없음) | `Store.write` · 프로젝트 `write_template` |
|
||||
| 내 기계 | `MyMachine_Router._folder:34`(개인 고정 감쌈) + `MyMachine._user:410`(경로로 층 판정) | `MyMachine.listing` | 없음 | `MyMachine.add`(자기 `_LOCK:60` · `_다음.json`) | `update`(자기 잠금 · 판 · 원자 — 854-1) |
|
||||
| 내 재료 | `Router_Items._root` + `Material_Own._personal:236` | `Material_Own.rows` | 없음 | `add`(`store._LOCK` · **모든 개인 층 최대 + 1** `_last` + 파일 `마지막`) | `update`(`store._LOCK` · **판 없음** · 원자) |
|
||||
| 실무자료 | `Hopyo_Router._root:42`(개인 고정 감쌈) | `Hopyo_Store.rows:87`(하루 지난 것 숨김) | 없음 | `Hopyo_Store.save:119`(자기 `_LOCK:37` · `불러옴.json.번`) | `save`(새 키만 · 고침 없음) |
|
||||
| 재료 고름 | `Hopyo_Router._root` | 없음 | 없음 | 파일 지문이 키 | `San_MatPick.write:97`(**잠금 · 판 없음** · 원자) |
|
||||
| 공유 요청 | `Share_Request._company:66` + `Router_Items._root` | `listing:145` | 없음 | `uuid` | 자기 `_LOCK:47` · 원자 · 상태 409 |
|
||||
|
||||
### 1-3 일마다 하는 자리 — 고침 · 둘러싼 쪽
|
||||
|
||||
| 종류 | 지우기 | 복사 · 붙여넣기 | 쓰는 곳 찾기 | 권한 | 지문 · 캐시 | 공유 |
|
||||
| --- | --- | --- | --- | --- | --- | --- |
|
||||
| SK · SC | 나무 `edit` → `Library_Delete.remove:166`(쓰는 줄 지움 · `_합친것` 기록 · **잠금 없음 · 앞판 되돌림** `:189`) · `Store.delete:207` | `Precombo_Folders.paste:203` → `Labor_Ref.carry:533`(못 읽는 참조 같이) · 합치기 `Library_Same_Router.merge:206`(**잠금 없음** `:261`) | `Labor_Ref.users:459`(+ `use_files:452` · 기억 `_ids_of:473`) · `Library_Delete.users:76` · `Library_Same_Router._user_index:93` · `Layer_Index._uses:185` | `Layer_Access.require:83` + `Library_Delete.can_write:40` + `Library_Same_Router._can_write:108` · 참조 위 층 규칙 `Labor_Ref.readable:146` | 판 `Store.version_of:89` · 내용 `Library_Same.finger:208` · 캐시 `Layer_Index._MEM:34` · `Labor_Ref._IDS:470` | SC 만 요청 길 · SK 는 승인 `carry` 로 딸려 감 |
|
||||
| 구조물 조합 | 나무 지움 → `Store.prune_removed_structures:489` | `Item_Paste.paste:44`(층 사이) · `Items.copy_item:140` · 열끼리 `Store.copy_from:442` · `copy_pair:471` | SK 쪽에서 열 이름 `Library_Delete._columns:64` | `Router_Items._root` | `Store.version_of` | 요청 길 있음(`item`) |
|
||||
| 표 · 도면 틀 | `Router_Layers.delete_layer_template:366` → `Store.delete` · `layers.delete_template:272` | 프로젝트로 `copy_templates:345` · `seed_project:390` · `reset_project:425` | 고정 표 `Store.IN_USE:58`(네 양식) | `_layer_dir` | `Template_Layers.version_of:139` | 없음 |
|
||||
| 내 기계 | `MyMachine.delete`(잠금) | 없음(층 사이 안 옮김) | `MyMachine.uses:487`(SK 글 훑기) · 영향 `MyMachine_Impact` · M01 `Machine_Uses.uses:265` | `_folder` | 판 `MyMachine.version:116` · 캐시 `_MEMO:169` | 없음 |
|
||||
| 내 재료 | `Material_Own.remove`(쓰는 곳 409) | 층 사이 같은 키 `carry` · `adopt` | `Material_Own.usage:143`(층 폴더 통째 글 훑기) | `_root` + `_personal` | 캐시 `_MEMO:184` | 없음 |
|
||||
| 실무자료 | `Hopyo_Store.delete:167` · `Hopyo_Forget.finish:128` · 하루 지남 `sweep:148` | 없음 | 본뜬 키로 사본 걷음 `Hopyo_Forget.forget:102` | `Hopyo_Router._root` | 올린 엑셀 `Hopyo_Store.fingerprint:71` | 없음 |
|
||||
| 재료 고름 | HP 지울 때 판만 | 없음 | `San_MatPick.made:248` · `uses:333` · `tally:348` | `Hopyo_Router._root` | — | 없음 |
|
||||
| 공유 요청 | 없음(상태만) | 승인 = 위 두 길 | — | `_company` | — | — |
|
||||
|
||||
### 1-4 같은 일 몇 벌(분석 수 → 지금 자리)
|
||||
|
||||
| 일 | 분석 | 지금 | 자리 |
|
||||
| --- | --- | --- | --- |
|
||||
| 층 폴더 찾기(세션 → 폴더) | 4 | **5**(몸 2 + 감쌈 2 + 프로젝트 1) | `Router_Items._root:145` · `Router_Layers._layer_dir:140` · 감쌈 `Hopyo_Router._root:42` · `MyMachine_Router._folder:34` · 프로젝트 `Project_Items_Router._root:87` |
|
||||
| 폴더 → 층 판정 | — | **4** | `Labor_Ref.where:77`(몸) · `MyMachine._user:410`(경로 부모 이름) · `Material_Own._personal:236`(→ `where`) · 키 → 층 `Combo_Store.where:86` |
|
||||
| 쓰는 곳 찾기 | 6 | **10** | 서고 참조 4: `Labor_Ref.users:459` · `Library_Delete.users:76` · `Library_Same_Router._user_index:93` · `Layer_Index._uses:185` / 자원 키 6: `MyMachine.uses:487` · `Material_Own.usage:143` · `Labor_Spec.users:143`(규격 열) · `San_MatPick.made:248 · uses:333` · M01 `Machine_Uses.uses:265` · M01 `Doc.users:268` |
|
||||
| 쓰기 권한 판단 | 여러 곳 | **3 + TS 1** | `Layer_Access.grant:61 · require:83`(몸) · `Library_Delete.can_write:40` · `Library_Same_Router._can_write:108` · TS `M02_MasterTemplete_Layer.ts:107 accessFor`(거울 시험 없음) |
|
||||
| 파일 판 `version_of` | 3 | **M02 3 + M01 2** | `Store.version_of:89`(바이트) · `Template_Layers.version_of:139`(경로 · 같은 sha256[:16]) · `Item_Source.version_of:79`(JSON 정렬 — 실은 내용 지문) · M01 `Store.version_of:56` · `Doc.version_of:46` |
|
||||
| 내용 지문 | 7 | 7(855 몫) + 서고 2 | 서고 쪽 `Library_Same.finger:208` · `Hopyo_Store.fingerprint:71` |
|
||||
| 쓰기 잠금 | — | **4 벌** | `Store._LOCK:80`(서고 · 표 · 재료 공용 · `Lock` = 안에서 다시 잡으면 교착) · `MyMachine._LOCK:60`(RLock) · `Hopyo_Store._LOCK:37` · `Share_Request._LOCK:47` |
|
||||
| 잠금 없는 쓰기 | B 5-4 · 5-5 | **5 곳** | `Precombo_Folders.edit:180`(판 대조와 쓰기 사이 열림) · `Library_Delete.remove:166` · `Library_Same_Router.merge:206 · undo:285` · `Template_Layers.write_template:251` · `San_MatPick.write:97` |
|
||||
| 번호 체계 | 9 갈래(E 4-1) | 서고 **7** | SK · SC `next_key` + `_번호.json` · 장부 `Book`(`다음`) · 도번 `Store._serial`(지운 번호) · HP `불러옴.json.번` · PM 전 층 최대 + `마지막` · EQP `_다음.json` · 요청 `uuid` |
|
||||
| 목록 | — | **8** | `Layer_Index.list_rows` · `Precombo_Folders.view` · `Items.items` · `MyMachine.listing` · `Material_Own.rows` · `Hopyo_Store.rows` · `Share_Request.listing` · `Combo_Store.listing:159` |
|
||||
|
||||
### 1-5 storage 실측(꼴 · 개수만 · `census_storage.tsv`)
|
||||
|
||||
| 층 | 수 | 폴더별 json(층 합) | 뿌리 파일 |
|
||||
| --- | --- | --- | --- |
|
||||
| 마스터 | 1 | drawing 5 · table 1 · report 1 · stability 2 · 구조물정의_이력 22 | `구조물정의.json` · `구조물집계표조합.json` · `calc_sites.json` |
|
||||
| 회사 | 2 | table 2 · drawing 1 · 나머지 0 | `구조물집계표조합.json` 2 · `00_template_A1.json` 1(종류 폴더 밖에 놓인 양식 — 확인 거리) |
|
||||
| 개인 | 6 | sangeun 15 · precombo 6 · `_합친것` 16 · table 4 · 내기계 1(`_다음` 만) · 실무자료 7 · 빈 폴더 `area drawing inputs labor material promote structure` | `구조물집계표조합.json` 4 · `sangeun_폴더` 2 · `precombo_폴더` 2 · `개인자재.json` 1 · `manifest.json` 1 · `_번호.json` 1 |
|
||||
|
||||
## 2. 한 벌 틀 제안
|
||||
|
||||
### 2-1 바탕 — 이미 잘 된 것
|
||||
|
||||
- **저장** `Store.write:142` — 잠금 · 판 409 · 원자 쓰기 · 서버 정본 다시 셈(`_server:566`) · 서고 키 = 파일 이름. 한 파일 한 문서 꼴의 정본 길.
|
||||
- **나무** `Precombo_Folders` — `{종류}_폴더.json{폴더, 자리}` · 종류 인자 한 벌.
|
||||
- **지우기 · 합치기 · 되돌림** `Library_Delete` · `Library_Same(_Router)` — 쓰는 줄 정리 · `_합친것` 기록 · 되돌림.
|
||||
- **권한** `Layer_Access` 한 벌 · **층 폴더** `Router_Items._root` 한 벌(대부분 가져다 씀).
|
||||
|
||||
### 2-2 종류 표 하나(새 파일 없음 · `Template_Layers` 안 · 어림 +40)
|
||||
|
||||
지금 `KINDS · LIBRARY_KINDS`(`Template_Layers:34-35`) · `Labor_Ref.PREFIX · TITLE` · `Share_Request` `Literal`(종류 글) · TS `Api_Fetch.Kind` 로 흩어진 종류 정의를 한 표로.
|
||||
|
||||
| 칸(옵션) | 뜻 | SK | SC | 내 기계 | 내 재료 | 실무자료(857) |
|
||||
| --- | --- | --- | --- | --- | --- | --- |
|
||||
| `폴더` | 층 안 자리 | `sangeun` | `precombo` | `내기계` | 판단 1 | `실무자료` |
|
||||
| `키꼴` · `머리` | 번호 꼴 | `SK-######` | `SC-######` | `EQP{사용자}-####` | `PM######`(전 층) | `HP-######` |
|
||||
| `층` | 놓일 층 | 넷 | 넷 | 개인만 | 개인만 | 개인만 |
|
||||
| `번호` | 장부 자리 | 층 `_번호.json` | 같음 | 같음(`_다음.json` 걷음) | 전 층 최대 + `마지막` 그대로 | `불러옴.json.번` 그대로(857) |
|
||||
| `나무` | 폴더 장부 | 있음 | 있음 | 없음 | 없음 | 없음 |
|
||||
| `숨김` | 하루 지나면 | — | — | — | — | 1 일 |
|
||||
| `쓰는곳` | 쓰는 곳의 뜻 | 참조 `{층 주인 키}` | 같음 | 자원 키 글(`개인 EQP…`) | 자원 키 글(`PM…`) | 본뜬 키 |
|
||||
| `공유` | 회사에 올리기 | 판단 2 | 있음 | 판단 2 | 판단 2 | 없음 |
|
||||
| `셈` | 저장 때 서버 정본 | `Store._server` | 같음 | 시간당(`Machine_Hourly.hour`) | 없음 | 없음 |
|
||||
|
||||
구조물 조합 · 표 · 도면 틀은 이미 `Store.write` 를 쓰고 번호가 표 장부와 같이 움직임 → 표에 「양식 종류」 로만 올리고 번호 · 나무는 지금 것 그대로.
|
||||
|
||||
### 2-3 부품 일곱(지금 것을 넓힘)
|
||||
|
||||
| 부품 | 한 벌로 삼을 것 | 걷을 것 | 어림 |
|
||||
| --- | --- | --- | --- |
|
||||
| ① 층 폴더 | `Router_Items._root` + 옵션 `개인만` | `Hopyo_Router._root:42` · `MyMachine_Router._folder:34` 감쌈 · `Router_Layers._layer_dir` 는 프로젝트 · 비동기 때문에 남기되 안쪽이 `access.folder` 를 같이 씀 | −10 |
|
||||
| ② 층 판정 | `Labor_Ref.where:77` | `MyMachine._user:410` 의 경로 부모 이름 판정 → `where` | −10 |
|
||||
| ③ 권한 | `Layer_Access` 에 `can_write(session, here)` 하나 | `Library_Delete.can_write:40` · `Library_Same_Router._can_write:108` · TS `accessFor` 는 거울 시험 붙임 | +15 / −15 |
|
||||
| ④ 판 | `Store.version_of` | `Template_Layers.version_of:139` → 그것을 부름 · `Item_Source.version_of` 는 이름만 「내용 지문」 으로(855 B9-5 때) | −5 |
|
||||
| ⑤ 여러 파일 쓰기 | `Store` 에 `batch()`(잠금 하나 + 앞판 되돌림 · `Library_Delete.remove:189` 의 되돌림 꼴을 옮김) · `_LOCK` → `RLock` | `Library_Delete` 되돌림 몸 · `Library_Same_Router.merge` · `undo` · `Precombo_Folders.edit` 가 `batch` 안에서 | +40 / −40 |
|
||||
| ⑥ 번호 장부 | 층 `_번호.json`(854-1 · `Labor_Ref.next_key` 꼴) 을 종류 표 `번호` 칸으로 | `MyMachine._다음.json` · `MyMachine.add` 의 번호 몸 | +10 / −20 |
|
||||
| ⑦ 쓰는 곳 색인 | `Labor_Ref.use_files · users · _ids_of`(파일 판 기억) 를 새 `M02_Library_Uses.py` 로 떼어 넓힘(참조 + 자원 키 두 찾기) | `Library_Delete.users` 훑기 몸 · `_user_index` · `Layer_Index._uses` · `MyMachine.uses` · `Material_Own.usage` | +120 / −150 |
|
||||
|
||||
### 2-4 새로 만드는 것(가장 적게)
|
||||
|
||||
- 새 파일 2 = `M02_Library_Uses.py`(⑦ · `Labor_Ref` 675 줄이라 더 못 넣음) · 지킴 시험 `test_858_shelf_golden.py`.
|
||||
- 새 저장 파일 0(층 `_번호.json` 은 이미 있음).
|
||||
- 새 서버 길 0 — 내 재료 길을 `Labor_Router` 에서 내 기계와 같은 라우터 묶음으로 옮김(길 글자는 그대로).
|
||||
|
||||
## 3. 걸음(두 박자 — 새 틀로 옮김 → 답 전후 같음 → 다음 묶음에서 옛 코드 지움)
|
||||
|
||||
| 걸음 | 무엇 | 파일(어림 줄) | 지킴 | 위험 · 막는 법 | 화면 확인 |
|
||||
| --- | --- | --- | --- | --- | --- |
|
||||
| **5-0 지킴 올림** | 임시 storage 견본 층(SK · SC · 항목 · 내 기계 · 내 재료 · 공유 요청)에서 길 답 지문 — 목록 · 나무 · 만들기 · 고치기 · 지우기 · 복사 · 붙여넣기 · 합치기 · 되돌림 · 쓰는 곳 · 권한 403/404 → `858_shelf_golden.json` · 동시 쓰기 시험(854-1 꼴)을 나무 · 지우기 · 합치기로 넓힘 | 새 `resources/tester/test_858_shelf_golden.py`(+ 300) | 지금 수치 그대로 통과 | 견본 짓기가 남의 시험 견본과 겹침 → 기존 `world` 픽스처(`test_m02_labor_ref`) 재사용 | — |
|
||||
| **5-1 권한 한 벌** | ③ | `M02_Layer_Access.py`(+ 15) · `M02_Library_Delete.py`(− 8) · `M02_Library_Same_Router.py`(− 5) · 거울 시험(TS `accessFor` ↔ 서버) 새 1(+ 60) | 5-0 · `test_m02_layer_access` · `test_735_1` · `test_733_3_*` | 회사 관리자 · 남의 층 경우 — 5-0 의 403 지문 | 개인 · 회사 층 나무 지우기 · 중복 합치기 단추 보임 |
|
||||
| **5-2 층 폴더 · 층 판정 한 벌** | ① ② | `M02_MasterTemplete_Router_Items.py`(+ 5) · `M02_MyMachine_Router.py`(− 5) · `M02_MyMachine.py`(± 10) · `M02_Material_Own.py`(± 5) | 5-0 · `test_821_*` · `test_840_4` · `test_m02_material_own` | `Hopyo_Router._root` 는 **857 몫 파일** → 여기선 안 고침 · 857 이 같은 옵션을 씀 | 개인관리 › 기계 · 자재 열기 |
|
||||
| **5-3 판 한 벌 · 프로젝트 저장 잠금** | ④ + `write_template` 을 `Store._LOCK` 안에서 | `M02_Template_Layers.py`(± 10) · `M02_MasterTemplete_Store.py`(± 3) | 5-0 · `test_826_1` · `test_204_2` · `test_572` | 프로젝트 층 저장(B05 · B07 양식) — 판 값은 같은 sha256[:16] 이라 안 바뀜 | 프로젝트 양식 저장 한 번 |
|
||||
| **5-4 여러 파일 쓰기 한 꼴** | ⑤ | `M02_MasterTemplete_Store.py`(+ 40) · `M02_Library_Delete.py`(− 30) · `M02_Library_Same_Router.py`(± 20) · `M02_Precombo_Folders.py`(± 5) | 5-0 동시 시험(같은 층 지우기 · 합치기 겹침 → 하나만 이김 · 파일 앞판 그대로) · `test_735_1` · `test_733_3_*` · `test_m02_precombo_folders` | `RLock` 으로 바꿈 — `Store.write` 를 잠금 안에서 부르는 길(합치기 `_rewrite:125`)이 생김 · 늦은 쓰기(`_refresh_labor`)는 잠금 밖 그대로 | 나무 지우기 · 되돌림 · 합치기 |
|
||||
| **5-5 쓰는 곳 색인 한 벌** | ⑦ | 새 `M02_Library_Uses.py`(+ 120) · `M02_Labor_Ref.py`(− 60) · `M02_Library_Delete.py`(− 30) · `M02_Library_Same_Router.py`(− 20) · `M02_Layer_Index.py`(− 15) · `M02_MyMachine.py`(− 25) · `M02_Material_Own.py`(− 20) | 5-0 쓰는 곳 지문 · `test_826_1`(목록 쓰는 곳 수) · `test_840_4` · `test_848_5` | **855 L2 ⓑ 가 `Layer_Index` 를 만짐** → L2 ⓑ 뒤 또는 `Layer_Index` 몫만 L2 ⓑ 창에 | 지우기 미리 보기 쓰는 곳 · 목록 쓰는곳수 · 내 기계 쓰는 단가산출 |
|
||||
| **5-6 내 기계 · 내 재료를 서고 틀로** | 종류 표(2-2) · 내 기계 번호 = 층 `_번호.json` · 옛 `내기계.json` 옮김(`MyMachine._move:97`) 걷음 · 내 재료 판 대조(+ 판단 1) · 내 재료 길을 내 기계 라우터 묶음으로 | `M02_Template_Layers.py`(+ 40) · `M02_MyMachine.py`(− 60) · `M02_MyMachine_Router.py`(+ 40) · `M02_Material_Own.py`(± 40) · `M02_Labor_Router.py`(− 50) · TS `M02_MyMachine_Api.ts` · 내 재료 화면 Api(판 칸 · ± 20) | 5-0 · `test_854_1` · `test_821_*` · `test_840_4` · `test_m02_material_own` · `test_826_2` | **`San_MyMachine.attach` 가 `MyMachine.create` 를 부름(857 몫)** → `create` 인자 · 답 꼴 그대로 | 내 기계 만들기 · 고침 · 옛 판 막힘 · 내 재료 같은 것 |
|
||||
| 5-7 공유 범위(판단 2 뒤) | `Share_Request` `Literal` → 종류 표 `공유` 칸 | `M02_Share_Request.py`(± 20) · TS `ShareRequest`(± 20) | `test_706_1` | — | [회사에 올리기] |
|
||||
| **5-8 옛 코드 지움** | 감쌈 · 중복 몸 · 옛 꼴 옮김 · 잠금 없는 되돌림 몸 · 화면 0 이 된 것 · 그것만 붙드는 시험 | 위 파일들(− 150 안팎) | `/openapi.json` 길 전후(뜻한 길만) · 관련 시험 전부 | — | 한 바퀴 |
|
||||
|
||||
### 3-1 같이 돌릴 수 있는 묶음(파일 안 겹침)
|
||||
|
||||
| 묶음 | 걸음(창) | 겹침 확인 | 앞 조건 |
|
||||
| --- | --- | --- | --- |
|
||||
| ㉠ | 5-0(하나) | 새 시험 파일만 | 없음 — **지금** |
|
||||
| ㉡ | 5-1 · 5-2 · 5-3(셋) | Layer_Access · Library_Delete · Library_Same_Router ↔ Router_Items · MyMachine* · Material_Own ↔ Template_Layers · Store — 다름 | ㉠ |
|
||||
| ㉢ | 5-4(하나) | Store · Library_* · Precombo_Folders | ㉡(5-1 의 Library_* · 5-3 의 Store) |
|
||||
| ㉣ | 5-5(하나) | Labor_Ref · Library_* · Layer_Index · MyMachine · Material_Own | ㉢ · 855 L2 ⓑ |
|
||||
| ㉤ | 5-6 · 5-7(둘) | MyMachine* · Material_Own · Labor_Router · Template_Layers ↔ Share_Request — 다름 | ㉣ · 판단 1 · 2 |
|
||||
| ㉥ | 5-8(하나) | 전부 | ㉤ |
|
||||
|
||||
꼭 차례인 까닭:
|
||||
- `Library_Delete` · `Library_Same_Router` 를 5-1 · 5-4 · 5-5 셋이 만짐 → 한 걸음씩.
|
||||
- `MyMachine` · `Material_Own` 을 5-2 · 5-5 · 5-6 이 만짐 → 5-2 는 판정 몸만 · 5-6 은 마지막.
|
||||
- 5-4(잠금 하나)가 5-5 앞 — 쓰는 곳 색인을 지우기 · 합치기 잠금 안에서 쓰게 되므로.
|
||||
|
||||
## 4. 「다시 셈 · 새로 고침」 길 열두 가지
|
||||
|
||||
| 번호 | 길(B 4-1) | 걸음 2 뒤 | 하나로 모을 수 있나 · 정리안 |
|
||||
| --- | --- | --- | --- |
|
||||
| ① | 자동 따라옴 `Sk_AutoRenew`(프로젝트 층 밖) | 남음(2-D 가 옛 사본 갈래만 걷음) | ②와 「값을 새로 받기」 한 뜻 — 층 따라 자동 / 손 |
|
||||
| ② | [단가 갱신] `Sangeun_Copy.PRICE:40` | 남음(프로젝트 층) | 판단 3 — 이름 가름 |
|
||||
| ③ | [재생성] `REGEN` | 남음 | 그대로(고친 것 버림 · 뜻 다름) |
|
||||
| ④ | 알림 [확인] `Sk_AutoRenew.CONFIRM:47` | 남음 | ① 의 짝 — ① 과 같이 |
|
||||
| ⑤ | 저장 때 재계산 `Store._server:566` → … `Doc_Sk.settle` | 남음(서버 정본 원칙) · 2-D 뒤 `사본` 줄임 갈래 빠짐 | 그대로 — 모든 저장이 이미 이 한 길 |
|
||||
| ⑥ | 펼침 `Library_Flat.flat_doc`(읽기 · 저장 · 복사) · 초기화 `reset_doc` | 남음 · 읽기 길 펼침(`Router_Layers:275-276` `unpromote` · `flat_doc`) = 「열 때 본 문서 ≠ 파일」 | 옛 로직 줄 꼴 올림 몫이 크면 저장본 비운 뒤 읽기 길 펼침 걷음(855 2-D 와 같이 확인) |
|
||||
| ⑦ | 일위대가 계산값 다시 적기 `Labor_Doc.server` · `Store._refresh_labor:596` | 남음 | ⑦ ⑧ = 「저장 뒤 딸림 갱신」 한 목록으로(`Store.write` 끝 · 5-4 의 `batch` 안) |
|
||||
| ⑧ | 도면 연결표 글 `Store._refresh_drawing:588` | 남음 | 위와 같음 |
|
||||
| ⑨ | 저장 전 영향 `MyMachine_Impact` | 남음 | 내 재료에도 같은 꼴(5-6 · 판단 1 과 같이) |
|
||||
| ⑩ | 파생 색인 `Layer_Index` · `Logic_Standard` · 프로젝트 [재적용] · `Item_Prices.refresh` · B09 | 색인 둘 남음 · 프로젝트 쪽은 B9 걸음 몫 | 색인 무효 규칙 = 「파일 자국」 한 꼴(`Layer_Index._stamps:49` · `Logic_Standard._stamp:227` 이 각자) — 858 범위 밖 · 메모만 |
|
||||
| ⑪ | `Hopyo_Relink` | 857 몫 | — |
|
||||
| ⑫ | 한 번용 `*_Migrate*` | **이미 없음**(853-2 · 지금 파일 0) | — |
|
||||
|
||||
같은 단추 이름이 층 따라 다른 뜻인 자리 — **[단가 갱신]**: 프로젝트 층 = 굳힌 사본을 지금 M01 값으로 다시 씀(손) · 층 서고 = 자동 따라옴이라 단추 대신 알림 [확인]. 서버가 `Sk_AutoRenew.on:55` 로 가름 · 화면 글 `formula_doc_text.ts:54` 한 벌. 정리안 = 판단 3.
|
||||
|
||||
## 5. 화면 쪽
|
||||
|
||||
| 거리 | 지금 | 제안 |
|
||||
| --- | --- | --- |
|
||||
| 고치는 중 값 보관 | 단가산출만 sessionStorage(`line_stack_screen.ts:185 · 197` · 열쇠 `m02_sk_doc_drafts` `Sangeun_Tabs.ts:56`) · 나머지는 메모리 + 떠날 때 `confirmLeave`(11 파일) | **858 범위 밖** 권함 — 856 이 일위대가 줄 창을 줄 쌓기로 바꾸면 SC 도 같은 보관을 얻음 · 내 기계 · 내 재료는 짧은 양식이라 메모리 그대로 · 판단 5 |
|
||||
| 층 전역 `setActiveLayer` | `Api_Fetch.ts:74-92` 모든 M02 부름이 `/layers/${activeLayer}` · `UI_Page.ts:162 · 345` 가 바꿈 · 되돌림 · 섞임은 `turn` 이 막음 | **858 범위 밖** 권함(화면 부름 전부가 걸림 · 효과 작음) · 5-6 에서 내 기계 · 내 재료 Api 만 「종류 + 층」 을 인자로 받는 한 함수로 |
|
||||
| 권한 짝 | TS `accessFor` ↔ 서버 `Layer_Access` 거울 시험 없음 | 5-1 에서 붙임 |
|
||||
|
||||
## 6. 걸음 2 · 3 · 4 와 겹침 · 차례 조건
|
||||
|
||||
| 상대 | 겹치는 파일 | 조건 |
|
||||
| --- | --- | --- |
|
||||
| 855 2-C1 · 2-C5 · 2-D | `Doc_Sk` · `Sangeun_Calc` · `Labor_Copy` · `Labor_Expand` · `Copy_Slim` · `Library_Flat` · `Sangeun_Copy` · `Sk_AutoRenew` | 858 은 이 파일들을 **안 고침**(⑥ 펼침 정리는 2-D 뒤 메모만) |
|
||||
| 855 L2 ⓑ | `Layer_Index` · `Labor_Inputs` | 5-5 의 `Layer_Index` 몫은 L2 ⓑ 뒤 |
|
||||
| 855 B9-5 | `Item_Source.version_of` | 이름 바꿈은 B9-5 몫 · 858 은 안 고침 |
|
||||
| 856 화면 하나 | `Sangeun_Detail` · `LogicLab_Ho` · `line_stack_*` · 일위대가 줄 창 TS | 겹침 없음 · 고치는 중 값 보관은 856 에 맡김 |
|
||||
| 857 불러오기 | `Hopyo_Router` · `Hopyo_Store` · `Hopyo_Forget` · `San_MatPick` · `San_MyMachine`(→ `MyMachine.create`) | 실무자료 · 재료 고름의 틀 옮김은 **857 안에서**(종류 표 `숨김` 칸을 씀) · 5-6 은 `create` 꼴 그대로 |
|
||||
| 854 · 855 이미 끝난 것 | `MyMachine`(854-1 잠금 · 판 · 2-B2) · `Labor_Ref.next_key`(854-1) · `Machine_Hourly` | 바탕으로 씀 |
|
||||
|
||||
지금 바로 시작해도 되는 조각 = **㉠ 5-0 · ㉡ 5-1 · 5-3**(855 남은 걸음 · 856 · 857 과 파일 안 겹침). 5-2 는 `MyMachine` 을 만지는 다른 일감이 없으면 같이.
|
||||
|
||||
## 7. 사용자 판단 거리 · 못 본 것
|
||||
|
||||
### 7-1 판단 거리(쉬운 말)
|
||||
|
||||
1. **내 재료 저장 꼴** — 지금 한 파일에 모든 줄 · 고칠 때 판 대조 없음. ㉮ 내 기계처럼 한 줄 한 파일 + 판(서고 틀과 같음 · 지금 저장본 1 개라 옛 꼴 호환 없이 바꿈) ㉯ 한 파일 그대로 + 판만 붙임(권함 — 줄이 적고 번호가 전 층에 걸쳐 있어 파일을 나눌 득이 작음).
|
||||
2. **공유 범위** — 지금 [회사에 올리기] 요청은 구조물 조합 항목 · 일위대가만. 단가산출 · 내 기계 · 내 재료도 요청 길을 둘지(지금 단가산출은 일위대가 승인 때 딸려 갈 때만 올라감).
|
||||
3. **[단가 갱신] 이름** — 프로젝트 층에선 손으로 새 값 받기, 층 서고에선 저절로 따라오고 알림 [확인]만 있음. ㉮ 이름을 가름(프로젝트 = 「단가 갱신」 · 층 서고 = 「새 값 확인」 · 권함) ㉯ 그대로.
|
||||
4. **내 기계 · 내 재료 저장본** — 지금 내 기계 0 대(번호 파일만) · 내 재료 1 파일. 비우고 시작해도 되는지(옛 `내기계.json` 옮김 코드도 같이 걷음).
|
||||
5. **고치는 중 값 보관** — 새로고침 뒤에도 고친 값이 남아야 하는 화면(지금 단가산출만) — 858 에선 안 다루고 856 에 맡겨도 되는지.
|
||||
6. **실무자료 · 재료 고름** — 857(불러오기 합침) 안에서 같은 틀로 옮김(권함).
|
||||
|
||||
### 7-2 못 본 것
|
||||
|
||||
- 화면 · 서버를 조작하지 않음(코드 따라가기 · 길 목록만 읽음) — 「공유 요청 승인」 · 「합치기 되돌림」 실제 동작.
|
||||
- 프로젝트 층 서고(굳힌 사본)의 목록 · 쓰는 곳 — B9 걸음 몫이라 깊게 안 봄.
|
||||
- M01 `Machine_Uses` · `Doc.users` 속(M01 범위).
|
||||
- 회사 층 뿌리 `00_template_A1.json`(종류 폴더 밖) 이 어느 코드가 놓은 것인지.
|
||||
- `Router_Layers._layer_dir` 의 프로젝트 · 직접 SQL(B 1-4) 정리 — 858 에 넣지 않음(마스터 층 ↔ 프로젝트 경계 · B 6(다) 다른 후보).
|
||||
|
||||
## 세기 도구 · 결과(`tmp/s894/m858/`)
|
||||
|
||||
| 파일 | 내용 |
|
||||
| --- | --- |
|
||||
| `defs.py` → `defs.tsv` | 서고 관련 36 파일 함수 555 개(이름 · 줄 · 길이 · 서버 길 · 독스트링 첫 줄) |
|
||||
| `count.py` → `count.tsv` · `count_summary.tsv` | 일 16 갈래 정규식 자리(`파일:줄`) — 표 1-4 는 이것을 손으로 걸러 셈(이름이 같은 다른 일 뺌 — 예 `Hopyo_Excel._columns`) |
|
||||
| `census_storage.py` → `census_storage.tsv` | 층 폴더 꼴 · 폴더별 json 수 · 뿌리 파일(키 이름은 `<키>` 로 가림 · 값 안 봄) |
|
||||
| `openapi.json` → `routes.tsv` | 자기 포트 8006 길 목록(읽기만) · M02 108 길 묶음 |
|
||||
@@ -5,6 +5,7 @@
|
||||
- 셈 = `scripts/master_doc_calc.py` ↔ `common_util/common_util_formula_doc_calc.ts`(짝)
|
||||
- 풀이 · 글 · 검사 = `scripts/master_doc.py` ↔ `common_util/common_util_formula_doc.ts`(짝)
|
||||
- 표 찾기 · M01 연결 풀이 = `scripts/master_doc_link.py` ↔ `common_util/common_util_formula_doc_table.ts`(표 찾기 짝)
|
||||
- 셈 기록(줄마다 부른 자원 · 하위 문서 · 고른 품목 · 서버 단독) = `scripts/master_doc_trace.py`(B08 · B09 가 답을 갈라 합산)
|
||||
- 옛 로직 변환 = `scripts/master_doc_convert.py` · 빌더 `scripts/build_수식문서_802_2.py`(`--check`)
|
||||
- 거울 · 꼴 시험 = `resources/tester/test_802_1_formula_doc.py` · 변환 대조 = `test_802_2_convert.py`
|
||||
|
||||
|
||||
@@ -81,6 +81,23 @@ def new_answer(links, doc: dict, given: dict | None = None):
|
||||
return {"결과": got["결과"]} if doc.get("결과") else {k: got.get(k) for k in KEYS}
|
||||
|
||||
|
||||
def cases_of(whole, row: dict) -> list[tuple]:
|
||||
"""(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력) — 기본 + 고르기 입력의 다른 갈래 하나씩."""
|
||||
base = meq.given_of(whole, row)
|
||||
cases = [("", base, None)]
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
one = {spec["이름"]: opt}
|
||||
cases.append((f"{spec['이름']}={opt}", {**base, **one}, one))
|
||||
return cases
|
||||
|
||||
|
||||
def agree(old, new) -> bool:
|
||||
"""대조 같음 — 같은 값 · 둘 다 못 셈."""
|
||||
return old == new or (isinstance(old, str) and isinstance(new, str))
|
||||
|
||||
|
||||
def _text(v) -> str:
|
||||
if isinstance(v, str):
|
||||
return v
|
||||
@@ -137,17 +154,11 @@ def build(log=print) -> dict:
|
||||
links = ml.Links(whole, docs)
|
||||
runs, both_out = [], 0
|
||||
for _, row in items:
|
||||
key, base = str(row["키"]), meq.given_of(whole, row)
|
||||
cases = [("", base, None)] # (옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력)
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
one = {spec["이름"]: opt}
|
||||
cases.append((f"{spec['이름']}={opt}", {**base, **one}, one))
|
||||
for label, given, changed in cases:
|
||||
key = str(row["키"])
|
||||
for label, given, changed in cases_of(whole, row):
|
||||
old = old_answer(whole, row, given)
|
||||
new = new_answer(links, docs[key], changed)
|
||||
same = old == new or (isinstance(old, str) and isinstance(new, str))
|
||||
same = agree(old, new)
|
||||
both_out += isinstance(old, str) and isinstance(new, str)
|
||||
runs.append(
|
||||
{
|
||||
|
||||
@@ -275,6 +275,8 @@ class _Run:
|
||||
for k in ("칸", "단위"):
|
||||
if link.get(k):
|
||||
payload[k] = link[k]
|
||||
if hasattr(self.links, "at"): # 855-F 셈 기록(`master_doc_trace`) — 기록 안 켬 = 안 탐
|
||||
self.links.at(self.stack, name, kind, payload)
|
||||
try:
|
||||
if kind == "요소":
|
||||
return number(self.links.element(payload))
|
||||
@@ -407,6 +409,8 @@ def _money(run: _Run, doc: dict, rules: dict):
|
||||
for i, line in enumerate(lines):
|
||||
scope = _scope(doc, outs, dict(running), cover, syms)
|
||||
where = str(line.get("이름") or f"금액 {i + 1}")
|
||||
if hasattr(run.links, "at"): # 855-F 셈 기록 — 이 줄 읽음(시간당 작업량)
|
||||
run.links.at(run.stack, i, "금액", {})
|
||||
swapped, more, work = mw.line_work(run, line, scope) # 846-1 시간당 작업량
|
||||
text = line.get("수량") if swapped is None else swapped
|
||||
qty = (
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
@@ -24,7 +25,9 @@ import master_machine_crew as mcrew
|
||||
import master_material as mm
|
||||
import master_pick as mp
|
||||
|
||||
FOLDER = Path(__file__).resolve().parents[1] / "수식문서"
|
||||
# 화면 저장 시험 사본(`AISLO_MASTER_DIR` — `M01_MasterData_Store.FOLDER` 와 같이) · 없으면 정본
|
||||
_HOME = os.environ.get("AISLO_MASTER_DIR") or Path(__file__).resolve().parents[1]
|
||||
FOLDER = Path(_HOME).resolve() / "수식문서"
|
||||
_ARITH_OK = ("num", "bin", "neg")
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,327 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""단가산출 수식 문서 셈 답 → 산출근거 글(PLAN 855-C 2-C4 · 서버 풀이 글) — 셈 안 함(답만 읽음).
|
||||
|
||||
쓰는 곳 = M02 기준 목록 계산서(`M02_Logic_Standard.sheet`) · (뒤에) B09 산출근거(855 보충 B9-4).
|
||||
⚠ 짝(글 규칙) — 한쪽을 고치면 다른 쪽도 · 거울 시험 `resources/tester/test_855_c4_doc_text.py`:
|
||||
`A00_Common/line_stack_out.ts`(금액 줄 · 계 줄 꼴 · 수 꼴 `one` · `won` · 비목 이름) ·
|
||||
`ui_template/ui_template_equation.ts`(`eqText`) ·
|
||||
`common_util/common_util_line_stack_unit.ts`(`unitText` · `isAtom` · `moneyUnits`) ·
|
||||
`common_util/common_util_formula_doc_view.ts`(`offLine` — 선택으로 꺼진 줄).
|
||||
금액 줄 = 「이름 : 단가 원/단위 × 수량 단위 = 금액 원」 · 묶음 줄 = 비목마다 「노무비 : …」 ·
|
||||
계 = 「노무비 : 줄 + 줄 = 금액 원」 · 「합계 : 금액 원」.
|
||||
수 꼴 = 화면과 같음 — 단가 · 수량 = `eqText`(소수 여섯 자리까지 · 셈 값 그대로) ·
|
||||
줄 금액 = 소수 한 자리 · 비목 · 합계 = 원(셈 답의 끝수 그대로 · 여기서 자르지 않음).
|
||||
옮기지 않은 것(화면만) — 식 조판(KaTeX · 수량 식은 값 하나로) · 공식 줄 · 펼침 ·
|
||||
작업량 줄(846-2) · 굳은 기계 이름(847-1) · 비목곱 인수 글(848-7 · 금액은 답 그대로) ·
|
||||
계 덧셈 항 = 줄 금액(화면은 묶음 줄 있는 항목 · 항이 넷 넘으면 항목 소계 — 여기는 금액만).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from decimal import ROUND_FLOOR, ROUND_HALF_UP, Decimal, InvalidOperation
|
||||
|
||||
import master_doc as md
|
||||
import master_doc_calc as mc
|
||||
|
||||
COSTS = md.COSTS # 노무비 · 재료비 · 경비
|
||||
COST_SHOW = {"노무비": "노무비", "재료비": "재료비", "경비": "경 비"}
|
||||
AMOUNT_UNIT = "원"
|
||||
LONG_SUM = 4
|
||||
_HIDE = ("반올림", "올림", "버림")
|
||||
_SAME = (("일", "인"), ("㎏", "kg"), ("ℓ", "L"))
|
||||
|
||||
|
||||
# ── 수 꼴 ─────────────────────────────────────────────────────────────
|
||||
def _dec(v) -> Decimal | None:
|
||||
if isinstance(v, bool) or v is None:
|
||||
return None
|
||||
try:
|
||||
d = Decimal(str(v)) if not isinstance(v, Decimal) else v
|
||||
except InvalidOperation:
|
||||
return None
|
||||
return d if d.is_finite() else None
|
||||
|
||||
|
||||
def _group(d: Decimal, places: int, keep: bool) -> str:
|
||||
q = d.quantize(Decimal(1).scaleb(-places), ROUND_HALF_UP)
|
||||
sign = "-" if q.is_signed() else "" # Intl 과 같음 — 0 으로 반올림된 음수 = 「-0」
|
||||
whole, _, frac = f"{abs(q):f}".partition(".")
|
||||
frac = frac if keep else frac.rstrip("0")
|
||||
head = f"{int(whole):,}"
|
||||
return f"{sign}{head}.{frac}" if frac else f"{sign}{head}"
|
||||
|
||||
|
||||
def eq_text(v) -> str:
|
||||
"""`eqText` — 수 = 천 단위 쉼표 · 소수 여섯 자리까지(반올림 · 끝 0 뗌) · 그 밖 = 글 그대로."""
|
||||
if v is None or v == "":
|
||||
return ""
|
||||
if isinstance(v, bool):
|
||||
return "true" if v else "false"
|
||||
d = _dec(v)
|
||||
if d is None or (isinstance(v, str) and not v.strip()):
|
||||
return str(v)
|
||||
return _group(d, 6, False)
|
||||
|
||||
|
||||
def one(v) -> str:
|
||||
"""줄 금액 — 소수 한 자리 꼭(「26,890.8」 · 「0.0」)."""
|
||||
return _group(_dec(v) or Decimal(0), 1, True)
|
||||
|
||||
|
||||
def won(v) -> str:
|
||||
"""비목 · 합계 — 원(JS `Math.round` = 0.5 올림)."""
|
||||
d = _dec(v) or Decimal(0)
|
||||
r = (d + Decimal("0.5")).to_integral_value(ROUND_FLOOR)
|
||||
return eq_text(Decimal("-0") if r == 0 and d.is_signed() else r) # JS Math.round(-0.4) = -0
|
||||
|
||||
|
||||
# ── 단위 ─────────────────────────────────────────────────────────────
|
||||
def unit_text(u) -> str:
|
||||
"""자료 단위 글 → 화면 단위(메타 단위 = 빈 글)."""
|
||||
s = str(u if u is not None else "").strip()
|
||||
if not s or re.search(r"따름|원문 단위 없음", s) or re.match(r"^수(\(| 또는|$)", s):
|
||||
return ""
|
||||
s = re.sub(r"^%\(.*\)$", "%", s)
|
||||
return s.replace("10^-7", "10⁻⁷").replace("kWh", "㎾h")
|
||||
|
||||
|
||||
def _same(a: str, b: str) -> bool:
|
||||
return a == b or any((a == x and b == y) or (a == y and b == x) for x, y in _SAME)
|
||||
|
||||
|
||||
def is_atom(n) -> bool:
|
||||
"""한 덩이(기호 · 수 · 칸 · 글 — 반올림 · 올림 · 버림 감싸개 안 한 덩이 포함)."""
|
||||
if not n:
|
||||
return False
|
||||
if n[0] == "call" and n[1] in _HIDE and 1 <= len(n[2]) <= 2:
|
||||
return is_atom(n[2][0])
|
||||
return n[0] in ("var", "num", "field", "str")
|
||||
|
||||
|
||||
def node_of(text):
|
||||
if text is None or str(text).strip() == "":
|
||||
return None
|
||||
try:
|
||||
return md.parse(text)
|
||||
except md.DocError:
|
||||
return None
|
||||
|
||||
|
||||
def money_units(
|
||||
line: dict, price, qty, price_var: dict | None = None, sub: dict | None = None
|
||||
) -> dict:
|
||||
"""금액 줄 단위 자리 `{price, qty, wrap}` — 수량이 식이면 괄호 ·
|
||||
단가 분모가 수량 단위와 같은 뜻이면 수량 단위 글."""
|
||||
has = line.get("수량") not in (None, "")
|
||||
q = unit_text(line.get("단위")) if has else ""
|
||||
wrap = bool(q) and bool(qty) and not is_atom(qty)
|
||||
own = next(
|
||||
(
|
||||
u
|
||||
for u in (
|
||||
unit_text((sub or {}).get("결과단위")),
|
||||
unit_text((price_var or {}).get("단위")),
|
||||
)
|
||||
if u.startswith("원")
|
||||
), # fmt: skip
|
||||
None,
|
||||
)
|
||||
mine = f"{AMOUNT_UNIT}/{q}" if own and q and _same(own[2:], q) else own
|
||||
fallback = f"{AMOUNT_UNIT}/{q}" if q else ""
|
||||
price_unit = (mine if mine is not None else fallback) if has and is_atom(price) else ""
|
||||
return {"price": price_unit, "qty": q, "wrap": wrap}
|
||||
|
||||
|
||||
def price_sym(line: dict) -> str | None:
|
||||
n = node_of(line.get("단가"))
|
||||
if not n:
|
||||
return None
|
||||
if n[0] == "var":
|
||||
return n[1]
|
||||
if n[0] == "field" and n[1][0] == "var":
|
||||
return n[1][1]
|
||||
return None
|
||||
|
||||
|
||||
def line_name(line: dict) -> str:
|
||||
"""이름에 규격이 들면 한 번만(814-1)."""
|
||||
name, spec = str(line.get("이름") or ""), line.get("규격")
|
||||
return f"{name} {spec}".strip() if spec and spec not in name else name
|
||||
|
||||
|
||||
# ── 선택으로 꺼진 줄(`offLine`) ───────────────────────────────────────
|
||||
class _Look:
|
||||
"""셈 답 값으로 조건만 읽음 — 계산기 한 벌(`master_doc_calc._Run.ev`) · 값은 답에서 채움."""
|
||||
|
||||
def __init__(self, doc: dict, answer: dict, links):
|
||||
self.run = mc._Run(doc, links, None, (), {})
|
||||
got = answer.get("값") or {}
|
||||
names = {md.var_id(v) for v in doc.get("변수") or []}
|
||||
names |= {str(x.get("기호") or "") for x in doc.get("식") or []}
|
||||
for name in names: # 답에 없는 값 = 모름(다시 셈하지 않음 · 화면 `evalNode` 와 같음)
|
||||
have = got.get(name)
|
||||
self.run.values[name] = mc.Blank("모름") if have is None else have
|
||||
self.lines = {str(x.get("기호") or ""): x.get("식") for x in doc.get("식") or []}
|
||||
|
||||
def value(self, n):
|
||||
try:
|
||||
v = self.run.ev(n, None, "")
|
||||
except Exception: # noqa: BLE001 — 그림용 값 · 모르면 없음
|
||||
return None
|
||||
return None if isinstance(v, (mc.Blank, mc.Stop)) else v
|
||||
|
||||
def taken(self, n) -> int:
|
||||
if not (n and n[0] == "call" and n[1] == "만약" and len(n[2]) == 3):
|
||||
return 0
|
||||
t = self.value(n[2][0])
|
||||
return 0 if t is None else (1 if t else 2)
|
||||
|
||||
def off_zero(self, n, path: frozenset = frozenset()) -> bool:
|
||||
if not n:
|
||||
return False
|
||||
at, hop = n, 0
|
||||
while pick := self.taken(at):
|
||||
at, hop = at[2][pick], hop + 1
|
||||
if hop and at[0] == "num":
|
||||
return at[1] == 0
|
||||
kind = at[0]
|
||||
if kind == "var":
|
||||
name = at[1]
|
||||
if name not in self.lines or name in path:
|
||||
return False
|
||||
return self.off_zero(node_of(self.lines[name]), path | {name})
|
||||
if kind in ("neg", "pct"):
|
||||
return self.off_zero(at[1], path)
|
||||
if kind == "bin":
|
||||
if at[1] == "*":
|
||||
return self.off_zero(at[2], path) or self.off_zero(at[3], path)
|
||||
if at[1] == "/":
|
||||
return self.off_zero(at[2], path)
|
||||
if at[1] in ("+", "-"):
|
||||
return self.off_zero(at[2], path) and self.off_zero(at[3], path)
|
||||
return False
|
||||
|
||||
def off_line(self, line: dict) -> bool:
|
||||
return any(self.off_zero(node_of(line.get(k))) for k in ("수량", "단가"))
|
||||
|
||||
|
||||
# ── 줄 글 ────────────────────────────────────────────────────────────
|
||||
def _num(v) -> Decimal | None:
|
||||
return _dec(v)
|
||||
|
||||
|
||||
def _u(text: str, unit: str) -> str:
|
||||
return f"{text} {unit}" if unit else text
|
||||
|
||||
|
||||
def money_lines(doc: dict, answer: dict, links) -> list[dict]:
|
||||
"""금액 줄마다 산출근거 조각 `{i, 이름, 비목, 단가, 수량, 금액, 단위, 글, 꺼짐, 합밖, 까닭?}` ·
|
||||
묶음 줄 = 비목마다 한 조각(`비목` = 노무비 · 재료비 · 경비 · `묶음줄` 참)."""
|
||||
look = _Look(doc, answer, links)
|
||||
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
rows = answer.get("줄") or []
|
||||
out: list[dict] = []
|
||||
for i, line in enumerate(doc.get("금액") or []):
|
||||
got = rows[i] if i < len(rows) else {}
|
||||
name = line_name(line)
|
||||
ps = price_sym(line)
|
||||
pv = vars_.get(ps) if ps else None
|
||||
link = (pv or {}).get("연결") or {}
|
||||
sub = None
|
||||
if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]):
|
||||
try:
|
||||
sub = links.doc(str(link["키"]))
|
||||
except Exception: # noqa: BLE001 — 못 읽는 부름 = 단위 없이
|
||||
sub = None
|
||||
mu = money_units(line, node_of(line.get("단가")), node_of(line.get("수량")), pv, sub)
|
||||
qty = got.get("수량")
|
||||
base = {
|
||||
"i": i,
|
||||
"이름": name,
|
||||
"수량": _num(qty),
|
||||
"단위": mu,
|
||||
"꺼짐": look.off_line(line),
|
||||
"합밖": bool(got.get("합밖")),
|
||||
"묶음": line.get("묶음") or "",
|
||||
}
|
||||
tail = "" if qty is None else " × " + _u(eq_text(qty), mu["qty"])
|
||||
if got.get("까닭") and got.get("금액") is None:
|
||||
why = got["까닭"]
|
||||
out.append({**base, "비목": line.get("비목"), "단가": None, "금액": None, "까닭": why,
|
||||
"글": f"{name} : — {why}"}) # fmt: skip
|
||||
continue
|
||||
if line.get("비목") == "묶음":
|
||||
bundle = got.get("단가") if isinstance(got.get("단가"), dict) else {}
|
||||
for c in COSTS:
|
||||
part = (got.get("비목") or {}).get(c)
|
||||
if _dec(part) is None or (not part and not bundle.get(c)):
|
||||
continue
|
||||
price = _u(eq_text(bundle.get(c)), mu["price"])
|
||||
text = f"{COST_SHOW[c]} : {price}{tail} = {one(part)} {AMOUNT_UNIT}"
|
||||
out.append({**base, "비목": c, "묶음줄": True, "단가": _num(bundle.get(c)),
|
||||
"금액": _num(part), "글": text}) # fmt: skip
|
||||
continue
|
||||
amt, price = got.get("금액"), got.get("단가")
|
||||
text = f"{name} : {_u(eq_text(price), mu['price'])}{tail} = {one(amt or 0)} {AMOUNT_UNIT}"
|
||||
out.append({**base, "비목": line.get("비목"), "단가": _num(price), "금액": _num(amt),
|
||||
"글": text}) # fmt: skip
|
||||
return out
|
||||
|
||||
|
||||
def total_lines(answer: dict, lines: list[dict]) -> list[str]:
|
||||
"""계 줄 — 비목마다 「노무비 : 줄 + 줄 = 금액 원」(항이 넷 넘으면 금액만) ·
|
||||
「합계 : 금액 원」."""
|
||||
out = []
|
||||
for c in COSTS:
|
||||
terms = [
|
||||
x["금액"]
|
||||
for x in lines
|
||||
if x.get("비목") == c and not x["합밖"] and not x["꺼짐"] and x.get("금액")
|
||||
]
|
||||
v = answer.get(c)
|
||||
if _dec(v) is None:
|
||||
body = "—"
|
||||
elif 1 < len(terms) <= LONG_SUM:
|
||||
body = f"{' + '.join(one(t) for t in terms)} = {won(v)}"
|
||||
else:
|
||||
body = won(v) if terms or v else ""
|
||||
unit = f" {AMOUNT_UNIT}" if _dec(v) is not None and body else ""
|
||||
out.append(f"{COST_SHOW[c]} : {body}{unit}")
|
||||
total = answer.get("계")
|
||||
out.append(f"합계 : {_u(won(total), AMOUNT_UNIT) if _dec(total) is not None else '—'}")
|
||||
return out
|
||||
|
||||
|
||||
def sheet_groups(doc: dict, answer: dict, links) -> list[dict]:
|
||||
"""공용 계산서(`A00_Common/calc_sheet.ts`) 묶음 — 비목마다 줄
|
||||
`{이름, 글 「단가 * 수량 = 금액」, 금액, 묶음, 장비, 옵션꺼짐}` ·
|
||||
소계 = 셈 답 비목 값(끝수 뒤) ·
|
||||
합 밖 줄 · 비목 없는 줄 = 뺌."""
|
||||
groups: dict[str, list] = {c: [] for c in COSTS}
|
||||
for x in money_lines(doc, answer, links):
|
||||
c = x.get("비목")
|
||||
if c not in groups or x["합밖"]:
|
||||
continue
|
||||
mu = x["단위"]
|
||||
if x.get("까닭"):
|
||||
text = f"— {x['까닭']}"
|
||||
else:
|
||||
price = "—" if x["단가"] is None else _u(eq_text(x["단가"]), mu["price"])
|
||||
qty = "" if x["수량"] is None else " * " + _u(eq_text(x["수량"]), mu["qty"])
|
||||
text = f"{price}{qty} = {one(x['금액'] or 0)}"
|
||||
groups[c].append(
|
||||
{
|
||||
"이름": x["이름"],
|
||||
"글": text,
|
||||
"금액": x["금액"],
|
||||
"묶음": x["묶음"] or None,
|
||||
"장비": bool(x.get("묶음줄")) or None,
|
||||
"옵션꺼짐": x["꺼짐"] or None,
|
||||
}
|
||||
)
|
||||
return [
|
||||
{"비목": c, "소계": _num(answer.get(c)), "끝수": "", "줄": groups[c]}
|
||||
for c in COSTS
|
||||
if groups[c] or _dec(answer.get(c))
|
||||
]
|
||||
@@ -0,0 +1,175 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""수식 문서 셈 기록 — 줄마다 부른 것(PLAN 855-F B9-1 · 설계 855 보충 1-3).
|
||||
|
||||
서버 단독(TS 짝 없음) — B08 · B09 가 문서 셈 답을 갈라 합산할 때 「이 줄이 어느 노임 · 자재 ·
|
||||
기계 · 표 · 하위 단가산출을 불렀나」 를 읽음. 셈은 그대로: `Trace` = `master_doc_link.Links` +
|
||||
기록 · `master_doc_calc` 의 훅(`links.at`)이 연결마다 알림 — `Links` 에는 `at` 이 없어 기록을 안
|
||||
켜면 지금 길 그대로.
|
||||
|
||||
`calc(doc, Trace(master, docs), given)` → 셈 답 +
|
||||
- `부름` = 연결 부른 차례 [{문서, 깊이, 이름, 갈래(요소 · 표 · 단가산출), 부름(넘긴 꼴 — 키 · 표 ·
|
||||
조건 · 입력 · 재료 …), 자원[{키, 갈래(인력 · 재료 · 기계 · 표)}], 품목?(고른 재료 키) ·
|
||||
기계?(기계경비 부름 = 결과단위 원/시간 돈 문서의 기계 키)}] —
|
||||
하위 문서 안 부름도 깊이를 달고 같이(같은 하위 · 같은 입력 두 번째는 셈 답을 다시 씀 = 안 적음)
|
||||
- `줄[i].부름` = 그 금액 줄 식(수량 · 단가 · 비목곱)이 닿는 이름의 맨 위 부름 차례 번호 + 그 줄
|
||||
셈 중 읽음(갈래 「금액」 · 이름 = 줄 차례 · 시간당 작업량 기계 칸)
|
||||
- `자원` = 문서 전체(하위 포함) 자원 키 차례 · 겹침 없음(표 빼고 · 단가 책 수요)
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import inspect
|
||||
import re
|
||||
import types
|
||||
from itertools import takewhile
|
||||
|
||||
import master_doc as md
|
||||
import master_doc_calc as mc
|
||||
import master_doc_link as ml
|
||||
|
||||
CAT = {"LB": "인력", "MT": "재료", "MO": "재료", "EQ": "기계"} # `master_equation_view.CAT` 같은 말
|
||||
_SLOTS = ("키", "표", "칸", "단위", "재료", "조건", "입력", "지역", "계약종별")
|
||||
|
||||
|
||||
class _Seen:
|
||||
"""마스터 감쌈 — `get` 이 돌려준 줄을 알림 ·
|
||||
마스터 메서드도 이 감쌈에 묶어 안쪽 `self.get` 까지 잡음."""
|
||||
|
||||
def __init__(self, master, note):
|
||||
self._m, self._note = master, note
|
||||
|
||||
def get(self, ref):
|
||||
row = self._m.get(ref)
|
||||
self._note(row)
|
||||
return row
|
||||
|
||||
def __setattr__(self, name, value): # 마스터 칸(찾기 색인 `_found` 등)은 마스터에
|
||||
if name in ("_m", "_note"):
|
||||
object.__setattr__(self, name, value)
|
||||
else:
|
||||
setattr(self._m, name, value)
|
||||
|
||||
def __getattr__(self, name):
|
||||
raw = inspect.getattr_static(self._m, name)
|
||||
if isinstance(raw, types.FunctionType):
|
||||
return raw.__get__(self)
|
||||
return getattr(self._m, name)
|
||||
|
||||
|
||||
class Trace(ml.Links):
|
||||
"""기록 켠 연결 — `calls` 에 부른 차례대로 쌓임(여러 문서 셈에 다시 써도 됨)."""
|
||||
|
||||
def __init__(self, master, docs: dict[str, dict] | None = None):
|
||||
super().__init__(_Seen(master, self._note), docs)
|
||||
self.calls: list[dict] = []
|
||||
self._now: dict | None = None
|
||||
self._last: str | None = None
|
||||
|
||||
def at(
|
||||
self, stack: tuple, name, kind: str, payload: dict
|
||||
) -> None: # 셈 훅(이름 | 금액 줄 차례)
|
||||
self._now = {
|
||||
"문서": stack[-1] if stack else "",
|
||||
"깊이": len(stack),
|
||||
"이름": name,
|
||||
"갈래": kind,
|
||||
"부름": {k: payload[k] for k in _SLOTS if k in payload},
|
||||
"자원": [],
|
||||
}
|
||||
self.calls.append(self._now)
|
||||
|
||||
def _note(self, row: dict) -> None:
|
||||
key = self._last = str(row.get("키") or "")
|
||||
kind = CAT.get(key[:2]) or ("표" if "줄" in row and "조건" in row else None)
|
||||
if not kind:
|
||||
return
|
||||
if self._now is None: # 연결 밖 부름(이름 없는 기계 줄 읽기) — 이름 빈 기록
|
||||
self.at((), "", "", {})
|
||||
got = self._now["자원"]
|
||||
if not any(x["키"] == key for x in got):
|
||||
got.append({"키": key, "갈래": kind})
|
||||
|
||||
def element(self, p: dict):
|
||||
if p.get("재료") is None or self._now is None:
|
||||
return super().element(p)
|
||||
got, before, self._last = self._now["자원"], len(self._now["자원"]), None
|
||||
try:
|
||||
return super().element(p)
|
||||
finally: # 재료 찾기 = 고른 품목 하나 — 찾을 때 훑은 후보 · 색인 짓기 읽음은 뺌
|
||||
del got[before:]
|
||||
if self._last and CAT.get(self._last[:2]) == "재료": # 마지막 읽음 = 고른 품목
|
||||
self._now["품목"] = self._last # (`mp.priced` 출처 · 값 없음 = 그 이름 글 읽음)
|
||||
if not any(x["키"] == self._last for x in got):
|
||||
got.append({"키": self._last, "갈래": "재료"})
|
||||
|
||||
|
||||
def _names(text) -> list[str]:
|
||||
if text in (None, ""):
|
||||
return []
|
||||
try:
|
||||
return md.names(md.parse(str(text)))
|
||||
except md.DocError:
|
||||
return []
|
||||
|
||||
|
||||
def reach(doc: dict, texts: list) -> set[str]:
|
||||
"""식 글들이 닿는 이름 전부 — 식 줄 · 연결 구멍(`{이름}`) · 조건 · 입력 식 · 지역 칸을
|
||||
따라감."""
|
||||
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
lines = {str(x.get("기호") or ""): x for x in doc.get("식") or []}
|
||||
todo = [n for t in texts for n in _names(t)]
|
||||
seen: set[str] = set()
|
||||
while todo:
|
||||
name = todo.pop()
|
||||
if name in seen:
|
||||
continue
|
||||
seen.add(name)
|
||||
if name in lines:
|
||||
todo += _names(lines[name].get("식"))
|
||||
link = (vars_.get(name) or {}).get("연결") or {}
|
||||
for k in ("키", "표"):
|
||||
todo += md.HOLE.findall(str(link.get(k) or ""))
|
||||
for v in (link.get("재료") or {}).values() if isinstance(link.get("재료"), dict) else ():
|
||||
todo += md.HOLE.findall(str(v))
|
||||
for k in ("조건", "입력"):
|
||||
for v in (link.get(k) or {}).values() if isinstance(link.get(k), dict) else ():
|
||||
todo += _names(v)
|
||||
todo += [str(link[k]) for k in ("지역", "계약종별") if link.get(k)]
|
||||
return seen
|
||||
|
||||
|
||||
def _machines(trace: Trace, calls: list[dict]) -> None:
|
||||
"""기계경비 부름(결과단위 원/시간 돈 문서 · `master_bundle.is_machine` 같은 판별)에 「기계」 =
|
||||
그 부름 안에서 처음 읽은 기계 키(옛 `B09 call_of` 의 machine) · 같은 부름 두 번째 = 앞 답."""
|
||||
seen: dict[str, str | None] = {}
|
||||
for i, c in enumerate(calls):
|
||||
doc = trace.doc(str(c["부름"].get("키"))) if c["갈래"] == "단가산출" else None
|
||||
unit = re.sub(r"\s", "", str((doc or {}).get("결과단위") or ""))
|
||||
if not doc or doc.get("결과") or unit != "원/시간":
|
||||
continue
|
||||
tag = repr((c["부름"].get("키"), sorted((c["부름"].get("입력") or {}).items())))
|
||||
inner = [c, *takewhile(lambda x: x["깊이"] > c["깊이"], calls[i + 1 :])]
|
||||
got = [x["키"] for one in inner for x in one["자원"] if x["갈래"] == "기계"]
|
||||
c["기계"] = seen[tag] = got[0] if got else seen.get(tag)
|
||||
|
||||
|
||||
def calc(doc: dict, trace: Trace, given: dict | None = None, cover: dict | None = None) -> dict:
|
||||
"""문서 셈(`master_doc_calc.calc` 그대로) + 기록 — 모듈 머리 꼴."""
|
||||
start = len(trace.calls)
|
||||
trace._now = None
|
||||
got = mc.calc(doc, trace, given, cover=cover)
|
||||
calls = [c for c in trace.calls[start:] if c["갈래"] != "금액" or c["자원"]] # 빈 줄 읽음 뺌
|
||||
top = 1 if doc.get("키") else 0
|
||||
for i, (line, out) in enumerate(zip(doc.get("금액") or [], got.get("줄") or [])):
|
||||
texts = [line.get("수량"), line.get("단가"), *(line.get(mc.TIMES) or {}).values()]
|
||||
names = reach(doc, texts) | {i} # 이 줄 읽음(갈래 「금액」 · 이름 = 줄 차례)
|
||||
out["부름"] = [
|
||||
j
|
||||
for j, c in enumerate(calls)
|
||||
if c["깊이"] == top and c["이름"] in names and (c["갈래"] == "금액") == (c["이름"] == i)
|
||||
]
|
||||
_machines(trace, calls)
|
||||
keys: list[str] = []
|
||||
for c in calls:
|
||||
keys += [x["키"] for x in c["자원"] if x["갈래"] != "표" and x["키"] not in keys]
|
||||
return {**got, "부름": calls, "자원": keys}
|
||||
@@ -7,6 +7,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
@@ -77,7 +78,9 @@ def save_book(book: dict, path: Path = BOOK) -> None:
|
||||
comma = "," if i < len(items) - 1 else ""
|
||||
lines.append(f" {json.dumps(key)}: {json.dumps(v, ensure_ascii=False)}{comma}")
|
||||
lines += [" }", "}"]
|
||||
path.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n")
|
||||
tmp = path.with_name(f".{path.name}.tmp") # 임시 파일 → 교체(원자적 · 끊겨도 반쪽 대장 없음)
|
||||
tmp.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n")
|
||||
os.replace(tmp, path)
|
||||
|
||||
|
||||
def lookup(book: dict) -> dict:
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"판": 1,
|
||||
"지문": {
|
||||
"키": "e68369418202e5ee",
|
||||
"calc_user": "6d74551273d6735f",
|
||||
"daega_inputs": "0ef81c80bc45ae0b",
|
||||
"수요": "f793204cf95c45c4",
|
||||
"산근 값": "c486d041a3246ffb",
|
||||
"산근 글": "a21b34ec13661f0c",
|
||||
"산근 관급 값": "c5c3daf85d9bd01b",
|
||||
"산근 관급 글": "a65b945fc8582ca3",
|
||||
"미리보기 hand:rate 값": "091690571b7dc54b",
|
||||
"미리보기 hand:rate 글": "c49b1bc692d59fe5",
|
||||
"미리보기 hand:pick 값": "6c7f426d37e31998",
|
||||
"미리보기 hand:pick 글": "96a9de9a02e3d124",
|
||||
"미리보기 hand:net 값": "b1c2c650567a14ae",
|
||||
"미리보기 hand:net 글": "be7884bdbeb29ed3",
|
||||
"B08 단위수량": "896710398b04b4fd"
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,71 @@
|
||||
/* 855-C 2-C4 거울 헬퍼 — 산출근거 글 규칙(TS)을 Node 로 돌림(`master_doc_text.py` 짝).
|
||||
* stdin = {수: [값], 단위: [글], 금액줄: [{줄, 단가변수, 부름}], 꺼짐: [{문서, 값}], 원: [수]}
|
||||
* stdout = {eq: [eqText], one: [one], won: [won], 단위: [unitText], 금액줄: [moneyUnits],
|
||||
* 꺼짐: [[offLine …] …], 비목: COST_SHOW, 항: LONG_SUM}
|
||||
* `one` · `won` · `COST_SHOW` · `LONG_SUM` = `line_stack_out.ts` 안 정의를 그대로 읽어 돌림(내보내지 않는 값). */
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
|
||||
|
||||
const cache = new Map();
|
||||
function load(at) {
|
||||
if (cache.has(at)) return cache.get(at);
|
||||
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const box = { exports: {} };
|
||||
cache.set(at, box.exports);
|
||||
const need = (p) => {
|
||||
if (p.endsWith(".css")) return {};
|
||||
return p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p);
|
||||
};
|
||||
new Function("exports", "module", "require", js)(box.exports, box, need);
|
||||
return box.exports;
|
||||
}
|
||||
const ROOT = path.join(__dirname, "..", "..");
|
||||
const eq = load(path.join(ROOT, "ui_template", "ui_template_equation.ts"));
|
||||
const unit = load(path.join(ROOT, "common_util", "common_util_line_stack_unit.ts"));
|
||||
const view = load(path.join(ROOT, "common_util", "common_util_formula_doc_view.ts"));
|
||||
const stack = load(path.join(ROOT, "common_util", "common_util_line_stack.ts"));
|
||||
|
||||
// line_stack_out.ts 안 정의(내보내지 않음) — 그 줄 글을 그대로 떼어 돌림
|
||||
const out = fs.readFileSync(path.join(ROOT, "A00_Common", "line_stack_out.ts"), "utf8");
|
||||
const grab = (re) => {
|
||||
const m = out.match(re);
|
||||
if (!m) throw new Error(`line_stack_out.ts 에서 못 찾음: ${re}`);
|
||||
return m[0];
|
||||
};
|
||||
const defs = [
|
||||
grab(/const COST_SHOW: Record<string, string> = \{[^}]*\};/),
|
||||
grab(/const won = \(n: number\): string => [^;]*;/),
|
||||
grab(/const one = \(n: number\): string =>\s*n\.toLocaleString\([^;]*;/),
|
||||
grab(/const LONG_SUM = \d+;/),
|
||||
].join("\n");
|
||||
const js = ts.transpileModule(`${defs}\nreturn { COST_SHOW, won, one, LONG_SUM };`, {
|
||||
compilerOptions: { target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const local = new Function("eqText", js)(eq.eqText);
|
||||
|
||||
const input = JSON.parse(fs.readFileSync(0, "utf8"));
|
||||
const res = {
|
||||
eq: (input.수 || []).map((v) => eq.eqText(v)),
|
||||
one: (input.원 || []).map((v) => local.one(v)),
|
||||
won: (input.원 || []).map((v) => local.won(v)),
|
||||
단위: (input.단위 || []).map((u) => unit.unitText(u)),
|
||||
금액줄: (input.금액줄 || []).map((x) =>
|
||||
unit.moneyUnits(
|
||||
x.줄,
|
||||
view.tryParse(x.줄.단가),
|
||||
view.tryParse(x.줄.수량),
|
||||
x.단가변수 || undefined,
|
||||
x.부름 || null,
|
||||
),
|
||||
),
|
||||
기호: (input.금액줄 || []).map((x) => stack.priceSym(x.줄)),
|
||||
꺼짐: (input.꺼짐 || []).map((x) =>
|
||||
(x.문서.금액 || []).map((line) => view.offLine(line, x.값, view.lineMap(x.문서))),
|
||||
),
|
||||
비목: local.COST_SHOW,
|
||||
항: local.LONG_SUM,
|
||||
};
|
||||
process.stdout.write(JSON.stringify(res));
|
||||
@@ -0,0 +1,164 @@
|
||||
"""855-A 지킴 도우미 — 로직마다 셈 경우(기본 + 옵션 표본) · 옛 엔진 대 새 계산기 층 가름 · 새 답 지문.
|
||||
|
||||
- 경우 = 빌더 대조와 같은 표본(`build_수식문서_802_2.build`) — 기본 입력(수식 탭 기본값) + 고르기 입력의
|
||||
다른 갈래 하나씩(나머지 기본).
|
||||
- 옛 = `master_formula.run` → `master_cut.engine` · 새 = 저장된 수식 문서(`master_doc_link.load_all`) ·
|
||||
`master_doc_calc.calc`.
|
||||
- 층(앞 층이 다르면 뒤 층 안 봄): L0 합계 · L1 줄 이름별 비목 금액 · L2 줄 꼴(차례 · 이름 · 금액 · 비목) ·
|
||||
L3 수량 · 단가. 「보임」 = 금액은 같고 보이는 단가만 다름(옛 = 줄 끝수 자리로 자른 단가 · 새 = 날 값 /
|
||||
수량 0 줄 단가 0 ↔ 빈 값 / 값 없는 줄 단가 빈 값 ↔ 채움 / 묶음 단가 = 계로 맞댐).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import importlib
|
||||
import json
|
||||
from collections import defaultdict
|
||||
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
|
||||
from functools import lru_cache
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
|
||||
|
||||
mf = importlib.import_module("master_formula")
|
||||
mcut = importlib.import_module("master_cut")
|
||||
mc = importlib.import_module("master_doc_calc")
|
||||
ml = importlib.import_module("master_doc_link")
|
||||
meq = importlib.import_module("master_equation")
|
||||
build = importlib.import_module("build_수식문서_802_2")
|
||||
|
||||
KEYS = ("노무비", "재료비", "경비", "계")
|
||||
SEEN = "보임"
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def world():
|
||||
"""(로직 줄 목록, M01 색인, 수식 문서 {키: 문서}, 연결)."""
|
||||
files, whole = m01.loaded()
|
||||
docs = ml.load_all()
|
||||
rows = [r for d in files.values() if d.get("그룹") == "로직" for r in d.get("줄") or []]
|
||||
return rows, whole, docs, ml.Links(whole, docs)
|
||||
|
||||
|
||||
def cases(row: dict, options: bool) -> list[tuple[str, dict, dict | None]]:
|
||||
"""(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력)."""
|
||||
whole = world()[1]
|
||||
base = meq.given_of(whole, row)
|
||||
out = [("", base, None)]
|
||||
if options:
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
one = {spec["이름"]: opt}
|
||||
out.append((f"{spec['이름']}={opt}", {**base, **one}, one))
|
||||
return out
|
||||
|
||||
|
||||
def old_run(row: dict, given: dict):
|
||||
whole = world()[1]
|
||||
try:
|
||||
return mcut.engine(whole, row["키"], mf.run(whole, row["키"], mf.fill_empty(row, given)))
|
||||
except Exception: # 옛 엔진 멈춤도 대조 값
|
||||
return None
|
||||
|
||||
|
||||
def new_run(doc: dict, changed: dict | None):
|
||||
try:
|
||||
got = mc.calc(doc, world()[3], changed)
|
||||
except Exception:
|
||||
return None
|
||||
return got if got.get("셈됨") else None
|
||||
|
||||
|
||||
def _d(v):
|
||||
try:
|
||||
return Decimal(str(v))
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def _unit(v):
|
||||
return _d(v.get("계")) if isinstance(v, dict) else _d(v)
|
||||
|
||||
|
||||
def _per_name(lines) -> dict:
|
||||
acc: dict = defaultdict(lambda: defaultdict(Decimal))
|
||||
for ln in lines or []:
|
||||
for k, v in (ln.get("비목") or {}).items():
|
||||
if _d(v) is not None:
|
||||
acc[str(ln.get("이름"))][k] += _d(v)
|
||||
return {n: {k: v for k, v in b.items() if v} for n, b in acc.items()}
|
||||
|
||||
|
||||
def _shape(lines) -> list:
|
||||
return [
|
||||
(
|
||||
str(ln.get("이름")),
|
||||
_d(ln.get("금액")),
|
||||
tuple(sorted((k, _d(v)) for k, v in (ln.get("비목") or {}).items() if v is not None)),
|
||||
)
|
||||
for ln in lines or []
|
||||
]
|
||||
|
||||
|
||||
def _cut_only(a, b) -> bool:
|
||||
"""옛 단가 = 새 날 값을 옛 자리로 자른 값(버림 · 반올림 · 올림 어느 하나)."""
|
||||
ua, ub = _unit(a.get("단가")), _unit(b.get("단가"))
|
||||
if ua is None and _d(a.get("금액")) is None and _d(b.get("금액")) is None:
|
||||
return True # 값 없는 줄 — 금액 둘 다 빈 값
|
||||
if ub is None and ua == 0 and _d(a.get("수량")) == 0:
|
||||
return True # 수량 0 줄 — 금액 0
|
||||
if ua is None or ub is None:
|
||||
return False
|
||||
return ua in (ub.quantize(ua, m) for m in (ROUND_DOWN, ROUND_HALF_UP, ROUND_UP))
|
||||
|
||||
|
||||
def level(old, new, money: bool) -> str | None:
|
||||
"""다름 층 — None = 같음(둘 다 못 셈 포함) · 「보임」 = 보이는 단가만 다름."""
|
||||
if old is None or new is None:
|
||||
return None if old is None and new is None else "L0"
|
||||
keys = KEYS if money else ("결과",)
|
||||
if any(_d(old.get(k)) != _d(new.get(k)) for k in keys):
|
||||
return "L0"
|
||||
if not money:
|
||||
return None
|
||||
if _per_name(old["줄"]) != _per_name(new["줄"]):
|
||||
return "L1"
|
||||
if _shape(old["줄"]) != _shape(new["줄"]):
|
||||
return "L2"
|
||||
seen = False
|
||||
for a, b in zip(old["줄"], new["줄"]):
|
||||
if _d(a.get("수량")) != _d(b.get("수량")):
|
||||
return "L3"
|
||||
if _unit(a.get("단가")) != _unit(b.get("단가")):
|
||||
if not _cut_only(a, b):
|
||||
return "L3"
|
||||
seen = True
|
||||
return SEEN if seen else None
|
||||
|
||||
|
||||
def adopted(key: str, label: str, lv: str) -> bool:
|
||||
"""채택된 차이(요구 714-3 · 빌더 `ADOPTED`) — 합계는 그 목록만 · 줄 비목은 같은 까닭
|
||||
(식 속 단가산출 부름 = 끝수 뒤 값)이 있는 문서만."""
|
||||
if lv == "L0":
|
||||
return (key, label) in build.ADOPTED
|
||||
return lv == "L1" and build._uses_raw_sub(world()[2][key])
|
||||
|
||||
|
||||
def answer(got) -> object:
|
||||
"""새 답의 지문 꼴 — 노 · 재 · 경 · 계(돈 아닌 = 결과) · 줄(이름 · 금액 · 비목)."""
|
||||
if got is None:
|
||||
return "못 셈"
|
||||
if "결과" in got and got.get("계") is None:
|
||||
return {"결과": str(got.get("결과"))}
|
||||
return {
|
||||
"합": [str(got.get(k)) for k in KEYS],
|
||||
"줄": [[n, str(m), [[k, str(v)] for k, v in b]] for n, m, b in _shape(got.get("줄"))],
|
||||
}
|
||||
|
||||
|
||||
def fingerprint(key: str, row: dict, options: bool = True) -> str:
|
||||
doc = world()[2][key]
|
||||
got = [[label, answer(new_run(doc, changed))] for label, _, changed in cases(row, options)]
|
||||
raw = json.dumps(got, ensure_ascii=False, sort_keys=True)
|
||||
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
|
||||
@@ -1,13 +0,0 @@
|
||||
/* 784-2 — `logic/M02_MasterTemplete_Hopyo_Unit.ts` 단위 환산 보이기 판정을 트랜스파일해 Node 로 돌림.
|
||||
* stdin = {cases: [{part, from, to}]} · stdout = unitView 결과 배열 JSON. */
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const { makeLoader } = require("./helper_ts_stub_loader.cjs");
|
||||
|
||||
const ROOT = path.join(__dirname, "..", "..");
|
||||
const { loadTs } = makeLoader({ root: ROOT });
|
||||
const unit = loadTs(
|
||||
path.join(ROOT, "M02_MasterTemplete", "logic", "M02_MasterTemplete_Hopyo_Unit.ts"),
|
||||
);
|
||||
const input = JSON.parse(fs.readFileSync(0, "utf8"));
|
||||
process.stdout.write(JSON.stringify(input.cases.map((c) => unit.unitView(c.part, c.from, c.to))));
|
||||
@@ -103,4 +103,3 @@ def test_m02_dataflow_muted_spans_use_ui_text():
|
||||
css = "".join(_m02_src(".css").values())
|
||||
for gone in ("m02-dfip__muted", "m02-dfout__muted", "m02-dfver__muted"):
|
||||
assert gone not in ts and gone not in css, f"옛 변종 {gone} 남음"
|
||||
assert len(re.findall(r'"ui-text ui-text--muted",\s*attrs: \{ "data-text": "14" \}', ts)) >= 21
|
||||
|
||||
@@ -11,10 +11,12 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
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 M01_MasterData.M01_MasterData_Store_Find import hit
|
||||
from M02_MasterTemplete import M02_Logic_Standard as st
|
||||
@@ -30,18 +32,20 @@ def _rows(key: str) -> list[dict]:
|
||||
|
||||
def _given(key: str, change: dict) -> dict:
|
||||
whole = m01.loaded()[1]
|
||||
return st._given(whole, whole.logic(key), change)[0]
|
||||
return st._given(whole, m01_doc.docs()[key], change)[0]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("key", THREE)
|
||||
def test_줄_금액은_M01_시험_계산에_끝수만_버림(key: str) -> None:
|
||||
def test_줄_금액은_M01_수식_탭_셈과_같음(key: str) -> None:
|
||||
"""855-C — 기준 목록 금액 = 수식 문서 셈(M01 수식 탭 미리 셈 · M02 단가산출과 같은 계산기)."""
|
||||
rows = _rows(key)
|
||||
assert rows
|
||||
doc = json.loads(json.dumps(m01_doc.docs()[key], default=float)) # 화면 JSON 꼴 문서
|
||||
for row in rows:
|
||||
got = m01.calc(key, _given(key, row["바꿈"]))
|
||||
assert got["ok"], got
|
||||
gap = float(got["sums"]["계"]) - row["금액"] # 줄 · 비목 버림(B09 산근 규칙) — 최대 3 원
|
||||
assert -0.01 <= gap < 3.2, row["규격"]
|
||||
given = st.labor_inputs._num(_given(key, row["바꿈"]))
|
||||
got = m01_doc.preview(doc, given)["셈"]
|
||||
assert got["셈됨"], row["규격"]
|
||||
assert float(got["계"]) == row["금액"], row["규격"]
|
||||
|
||||
|
||||
def test_대표_규격_펼침() -> None:
|
||||
|
||||
@@ -13,6 +13,7 @@ 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
|
||||
@@ -39,7 +40,7 @@ def test_줄마다_버림_비목마다_버림_B09와_같음():
|
||||
for row in data.get("줄") or []:
|
||||
if not _plain(row) or checked >= 60:
|
||||
continue
|
||||
base, _ = ls.axes(whole, row)
|
||||
base, _ = ls.axes(whole, m01_doc.docs()[row["키"]])
|
||||
given = mf.fill_empty(row, base)
|
||||
got = mf.run(whole, row["키"], given)
|
||||
lines = []
|
||||
@@ -70,6 +71,5 @@ def test_계산서_줄_소계_계가_맞물림():
|
||||
assert group["소계"] == int(group["소계"])
|
||||
assert group["소계"] <= sum(lines) < group["소계"] + 1 + Decimal("0.05"), group["비목"]
|
||||
assert got["계"] == sum(g["소계"] for g in got["묶음"])
|
||||
assert got["계"] == ls._money(
|
||||
whole, whole.logic(key), ls._given(whole, whole.logic(key), {})[0]
|
||||
)
|
||||
doc = m01_doc.docs()[key] # 855-C 계산서 = 문서 셈(목록 금액과 같은 값)
|
||||
assert got["계"] == ls._money(doc, ls._links(whole), ls._given(whole, doc, {})[0])
|
||||
|
||||
@@ -2,6 +2,8 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from collections import Counter
|
||||
|
||||
from M01_MasterData import M01_MasterData_Router as router
|
||||
from M01_MasterData import M01_MasterData_Store_List as store_list
|
||||
|
||||
@@ -19,8 +21,10 @@ def test_목록_줄_수_그대로_덧칸_다_있음() -> None:
|
||||
def test_묶음_작업량_부르기() -> None:
|
||||
more = store_list.extras()
|
||||
# 한 절에 로직 둘 넘음(조사 12-B ㉯ 323 → 713-4 합침 · 지움 뒤 307 → 782 건설 기초 335 → 794-2b 3-2-1 둘 337 → 813-2 작업량당 기계경비 6 지움 328)
|
||||
# → 822-2 · 822-2b 새 기계경비식 GC001196~1201 여섯이 8 절(건설기계) 묶음에 듦 334
|
||||
assert sum(1 for v in more.values() if v["묶음"]) == 334
|
||||
# → 822-2 · 822-2b · 848-4 새 기계경비식은 8 절(건설기계) 묶음에 듦 · 묶음수 = 같은 묶음 로직 수(둘 이상)
|
||||
groups = Counter((v["묶음"], v["묶음수"]) for v in more.values() if v["묶음"])
|
||||
assert groups and all(size >= 2 and n % size == 0 for (_, size), n in groups.items())
|
||||
assert all(more[f"GC00{n}"]["묶음"] == "8" for n in range(1196, 1203))
|
||||
work = {k for k, v in more.items() if v["작업량"]}
|
||||
assert len(work) == 65 # 27 − 터파기 작업량 6(713-4 · 단가 로직 안에 품음) + 782 시공능력 44
|
||||
assert more["GF000098"]["부모"] == ["GF000099"] # 측구터파기 작업량 → 단가 로직 밑
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) · M01 `/text` 와
|
||||
M02 `/logic-lib/sheet` 가 같은 줄 꼴(`master_sheet_line`)."""
|
||||
"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) — M01 `/text`.
|
||||
(M02 `/logic-lib/sheet` 는 855-C 부터 문서 셈 · `master_doc_text` 글 — `test_855_c4_doc_text`.)"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
@@ -11,10 +11,8 @@ sys.path.insert(0, str(ROOT))
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store_Sheet as sheet # noqa: E402
|
||||
from M02_MasterTemplete import M02_Logic_Standard as standard # noqa: E402
|
||||
|
||||
msl = sheet.msl
|
||||
num = standard.labor_inputs._num # Decimal → JSON 수(두 길 같은 규칙)
|
||||
|
||||
|
||||
def _text(key: str) -> dict:
|
||||
@@ -61,15 +59,3 @@ def test_basis_note_tenfold():
|
||||
assert one[0]["기준단위"] == "10㎡" and one[0]["환산근거"] == "10㎡당 → 1㎡당 ÷10"
|
||||
ten = _text("GF000124")
|
||||
assert ten["기준단위"] == "10㎡" and all(not x["환산근거"] for x in _lines(ten))
|
||||
|
||||
|
||||
def test_two_routes_same_shape():
|
||||
"""M01 `/text` 와 M02 계산서 — 줄 차례 · 덧칸 값이 같음(금액 끝수만 다를 수 있음)."""
|
||||
for key in ("GF000169", "GF000103", "GF000219"):
|
||||
m01 = _lines(_text(key))
|
||||
m02 = _lines(standard.sheet(key, {}), "묶음")
|
||||
assert len(m01) == len(m02)
|
||||
for a, b in zip(m01, m02):
|
||||
assert set(b) == {"이름", "글", "금액", *msl.KEYS}
|
||||
assert a["이름"] == b["이름"]
|
||||
assert num([a.get(k) for k in msl.KEYS]) == [b.get(k) for k in msl.KEYS]
|
||||
|
||||
@@ -78,7 +78,7 @@ def test_화면_층_단추_최상위_폴더_이름_바꾸기():
|
||||
|
||||
def test_구조물_조합_층_제자리_바꿈():
|
||||
"""720-4 — 해시 이동 없음 · replaceState · 나무 · 층 줄 · 띠를 감싼 칸에 갈아 끼움 · 권한 = 함수 ·
|
||||
도면 양식 = 누구나(단추는 관리자) · 불러오기 장부 = 열 때 층 · 권한."""
|
||||
도면 양식 = 누구나(단추는 관리자)."""
|
||||
page = _text("M02_MasterTemplete_UI_Page.ts")
|
||||
assert "navigateTo" not in page
|
||||
switch = page.split("const switchStructure = async")[1].split("const go =")[0]
|
||||
@@ -96,5 +96,3 @@ def test_구조물_조합_층_제자리_바꿈():
|
||||
assert "const drawing = opt.isSystem" not in side
|
||||
assert "if (!opt.isSystem) return [];" in side
|
||||
assert "items = await listTemplates(layer, null);" in side
|
||||
hopyo = _text("M02_MasterTemplete_Hopyo_Side.ts")
|
||||
assert "buildHopyoLedger({ scope: pageScope(), canWrite: opt.canWrite() })" in hopyo
|
||||
|
||||
@@ -16,8 +16,6 @@ import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
|
||||
|
||||
mcut = importlib.import_module("master_cut")
|
||||
@@ -68,12 +66,16 @@ def fingerprints() -> dict:
|
||||
|
||||
def test_M01_로직_전부_전후_같음():
|
||||
saved = json.loads(FINGER.read_text(encoding="utf-8"))
|
||||
if saved["마스터"] != _master_hash():
|
||||
pytest.skip("마스터 데이터 바뀜 — 지문 다시 뜸: python resources/tester/test_791_1_…py")
|
||||
now = fingerprints()
|
||||
assert len(now) == len(saved["결과"]) >= 1513 # 813-2 작업량당 기계경비 6 지움
|
||||
diff = sorted(k for k in now if now[k] != saved["결과"].get(k))
|
||||
assert not diff, f"셈 결과 바뀐 로직 {len(diff)} 개: {diff[:10]}"
|
||||
diff = sorted(
|
||||
set(now) ^ set(saved["결과"]) | {k for k in now if now[k] != saved["결과"].get(k)}
|
||||
)
|
||||
# 자료가 바뀌어도 건너뛰지 않음 — 셈 결과가 같으면 통과 · 다르면 실패(자료 탓이면 지문 다시 뜸)
|
||||
why = "마스터 데이터 바뀜" if saved["마스터"] != _master_hash() else "엔진만 바뀜"
|
||||
assert not diff, (
|
||||
f"셈 결과 바뀐 로직 {len(diff)} 개({why}): {diff[:10]} — 자료를 뜻대로 고쳤으면 "
|
||||
"엔진 고치기 전 커밋에서 지문 다시 뜸: python test_791_1_engine_semantics.py"
|
||||
)
|
||||
|
||||
|
||||
# ── 시험 마스터 ───────────────────────────────────────────────────────
|
||||
|
||||
@@ -26,6 +26,12 @@ mf = importlib.import_module("master_formula")
|
||||
mcut = importlib.import_module("master_cut")
|
||||
ms = importlib.import_module("master_formula_sum")
|
||||
|
||||
|
||||
def _nodes(rows):
|
||||
"""[{행, G}] → 줄 나무(옛 `San_Stmate.parse_block` 꼴 · 지금 길 = `Doc_FromNative._emit` 이 줄마다 `parse_line`)."""
|
||||
return [{"행": r.get("행"), "글": r.get("G") or "", **stm.parse_line(r.get("G"))} for r in rows]
|
||||
|
||||
|
||||
STMATE = { # 파일: (블록, 금액 줄, 계표시 줄, 끝전)
|
||||
"봉화": (62, 349, 184, "비목버림"),
|
||||
"동부청영월": (69, 411, 230, "합버림_큰나머지"),
|
||||
@@ -72,7 +78,7 @@ def _load(tag: str) -> dict:
|
||||
|
||||
|
||||
def _stmate(tag: str, blk: dict) -> tuple[list, dict]:
|
||||
nodes = stm.parse_block(blk["몸"])
|
||||
nodes = _nodes(blk["몸"])
|
||||
return nodes, em.stmate(blk, nodes, _load(tag)["단가"], STMATE[tag][3])
|
||||
|
||||
|
||||
@@ -150,7 +156,7 @@ def test_link_keys_m01() -> None:
|
||||
"""호표 줄 = 793-2 꼴(종류 · 단가 · 이음 = 1차 줄 판정 M01 키) · 덧칸 자원 · 원본."""
|
||||
tag = "봉화"
|
||||
blk = next(b for b in _load(tag)["블록"] if b["코드"] == "D00102")
|
||||
out = em.stmate(blk, stm.parse_block(blk["몸"]), _load(tag)["단가"], "비목버림", True)
|
||||
out = em.stmate(blk, _nodes(blk["몸"]), _load(tag)["단가"], "비목버림", True)
|
||||
labor = next(x for x in out["로직"]["호표"] if x["이름"] == "보통인부")
|
||||
assert {k: v for k, v in labor.items() if k != "자원"} == {
|
||||
"이름": "보통인부",
|
||||
@@ -207,7 +213,7 @@ def test_stmate_grammar_sample_engine() -> None:
|
||||
"'뒤 인부' &L00007& * 0.01 =",
|
||||
]
|
||||
rows = [{"행": i, "G": g} for i, g in enumerate(text)]
|
||||
nodes = stm.parse_block(rows)
|
||||
nodes = _nodes(rows)
|
||||
block = {"코드": "D00001", "이름": "견본", "꼬리": [], "몸": rows}
|
||||
block["머리"] = {"A": "", "B": "", "C": 0, "D": 0, "E": 0, "F": 0}
|
||||
out = em.stmate(block, nodes, prices, "비목버림")
|
||||
|
||||
@@ -24,6 +24,11 @@ NOTE = em.NOTE
|
||||
DOCS = golden.DOCS
|
||||
|
||||
|
||||
def _nodes(rows):
|
||||
"""[{행, G}] → 줄 나무(옛 `San_Stmate.parse_block` 꼴 · 지금 길 = `Doc_FromNative._emit` 이 줄마다 `parse_line`)."""
|
||||
return [{"행": r.get("행"), "글": r.get("G") or "", **stm.parse_line(r.get("G"))} for r in rows]
|
||||
|
||||
|
||||
def notes(out: dict) -> list[str]:
|
||||
return [m for m in out["원본"]["표지"] if NOTE in m]
|
||||
|
||||
@@ -60,7 +65,7 @@ def test_applied_or_first_column_is_flagged() -> None:
|
||||
)
|
||||
nothing = book.applied_how(_row((None,) * 4, (0, 0, 0, 0)))
|
||||
assert nothing[1] is None # 쓸 값이 없는 줄
|
||||
assert book.applied(_row((100, 40, 30, 30), (90, 40, 30, 20)))["T"] == 100
|
||||
assert book.applied_how(_row((100, 40, 30, 30), (90, 40, 30, 20)))[0]["T"] == 100
|
||||
|
||||
|
||||
def test_first_column_note_reaches_block_flags() -> None:
|
||||
@@ -88,7 +93,7 @@ def _stmate_out(meta: dict) -> dict:
|
||||
rows = [{"행": 0, "G": "'보통인부' &L00007& * 1 :=A01"}]
|
||||
block = {"코드": "D00001", "이름": "견본", "꼬리": [], "몸": rows}
|
||||
block["머리"] = {"A": "", "B": "", "C": 0, "D": 0, "E": 0, "F": 0}
|
||||
return em.stmate(block, stm.parse_block(rows), prices, "비목버림")
|
||||
return em.stmate(block, _nodes(rows), prices, "비목버림")
|
||||
|
||||
|
||||
def test_adjust_ratio_and_bid_rate_are_flagged() -> None:
|
||||
|
||||
@@ -9,6 +9,7 @@ from pathlib import Path
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path[:0] = [str(ROOT), str(ROOT / "resources/master_data/scripts")]
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as doc # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Equation as eq # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store as store # noqa: E402
|
||||
|
||||
@@ -117,10 +118,10 @@ def test_drop_guard_and_unused_input():
|
||||
|
||||
def test_candidates():
|
||||
whole = store.loaded()[1]
|
||||
got = eq.links({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""})
|
||||
got = doc.candidates({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""})
|
||||
assert got["후보"] and "조건" in got["후보"][0]
|
||||
assert eq.links({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"]
|
||||
assert eq.links({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"]
|
||||
assert doc.candidates({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"]
|
||||
assert doc.candidates({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"]
|
||||
assert whole is not None
|
||||
|
||||
|
||||
|
||||
@@ -379,14 +379,19 @@ def sweep(tag: str) -> dict:
|
||||
path = practice.FILES[tag]
|
||||
saved = fn.pack(excel(tag), path.name)
|
||||
out = {"블록": 0, "같음": 0, "다름": set(), "변수줄": 0, "자원줄": 0, "자원추정": 0}
|
||||
out["옛 검산 다름"] = set()
|
||||
for ln in (x for b in saved["산근"] for x in b["줄"]):
|
||||
out["변수줄"] += bool(ln.get("변수"))
|
||||
out["자원줄"] += bool(ln.get("자원"))
|
||||
for no, blk in fn.numbers(saved).items():
|
||||
out["블록"] += 1
|
||||
emitted = fn.emit(saved, no)
|
||||
_, _, got = nd.doc_and_money(emitted)
|
||||
sk, _, got = nd.doc_and_money(emitted)
|
||||
mine = {c: got.get(k) for c, k in nd.COST}
|
||||
old = nd.imp._money(nd.imp._run(sk, nd.whole())) or {} # 855-A 옛 검산(옛 엔진)
|
||||
pair = [(old.get(k), got.get(k)) for _, k in nd.COST]
|
||||
if any(a is None or b is None or nd.D(str(a)) != nd.D(str(b)) for a, b in pair):
|
||||
out["옛 검산 다름"].add((tag, no))
|
||||
nag = (emitted["원본"].get("계약") or {}).get("낙찰률")
|
||||
if nag:
|
||||
for c in "LMS":
|
||||
@@ -408,3 +413,4 @@ MONEY_SAMPLE = ("거창", "봉화")
|
||||
def test_money_equals_excel(tag: str) -> None:
|
||||
got = sweep(tag)
|
||||
assert got["블록"] and got["다름"] == {x for x in ODD_MONEY if x[0] == tag}, sorted(got["다름"])
|
||||
assert got["옛 검산 다름"] == set(), sorted(got["옛 검산 다름"]) # 855-A 옛 검산 = 새 셈
|
||||
|
||||
@@ -95,10 +95,6 @@ def test_기계_부품():
|
||||
assert {"GC001147", "GF000088"} <= tpl and len(tpl) == 15
|
||||
coef = m01_router.get_parts("계수식")["계수식"]
|
||||
assert {x["키"] for x in coef} == {"GC001143", "GC001191", "GC001192", "GC001193"}
|
||||
one = parts.of_machine("0201-0070")
|
||||
assert one["기계"] == {"이름": "굴착기(무한궤도)", "규격": "0.7㎥", "상세구분": "굴착기"}
|
||||
by = {t["키"]: t for t in one["틀"]}
|
||||
assert by["GC001147"]["규격"] == "버킷용량" and by["GF000088"]["문서"]["결과"] == "Q"
|
||||
|
||||
|
||||
def test_변환기가_표지를_옮김():
|
||||
|
||||
@@ -133,12 +133,12 @@ def test_edit_delete_add_and_dep_change(fresh, reads):
|
||||
assert set(reads) == {f"sangeun/{a}", f"sangeun/{c}"} # 바뀐 항목만 다시 읽음
|
||||
assert rows == _old(mine)
|
||||
titles = {r["이름"]: r.get("제목") for r in rows if r["종류"] in index.layers.LIBRARY_KINDS}
|
||||
assert gone == c and titles == {
|
||||
assert gone != c and titles == {
|
||||
a: "가",
|
||||
b: "나",
|
||||
c: "다",
|
||||
sc: "일위대가",
|
||||
} # 지운 키를 새 것이 받음
|
||||
} # 지운 키는 빠지고 새 것은 새 번호(854-1 · 지운 번호 안 다시 씀)
|
||||
reads.clear()
|
||||
was = {r["이름"]: r.get("기준금액") for r in _new(mine)}
|
||||
assert reads == []
|
||||
|
||||
@@ -201,7 +201,7 @@ def test_company_and_other_refused(world):
|
||||
_at(world["company"], path.preview, sk, {"문서": doc})
|
||||
assert e.value.status == 404
|
||||
with pytest.raises(HTTPException) as e:
|
||||
route.my_machine_draft("personal", route.MachineBody(줄=_body()), "7/43", USER)
|
||||
route.my_machine_create("personal", route.MachineBody(줄=_body()), "7/43", USER)
|
||||
assert e.value.status_code == 403
|
||||
with pytest.raises(HTTPException) as e:
|
||||
doc_route.save_doc("personal", sk, doc_route.DocBody(문서=doc, 판=""), "7/43", USER)
|
||||
|
||||
@@ -173,7 +173,6 @@ def test_apart_item_zero(world) -> None:
|
||||
var = _var(conv, e["기호"])
|
||||
assert e["별도계상"] and var["연결"]["갈래"] == "숫자"
|
||||
assert f"별도계상 · 품목: {gov['이름']} {gov['규격']} · 셈은 프로젝트에서" in var["설명"]
|
||||
assert mp.item_key(mine["자원"]) == gov["키"]
|
||||
assert skpath.read(got["이름"])["셈"] == skpath.read(plain["이름"])["셈"]
|
||||
# 이미 만든(고름 전) SK 에 물음 예 = 품목 설명만 · 단가 0 그대로
|
||||
money = skpath.read(plain["이름"])["셈"]
|
||||
|
||||
@@ -0,0 +1,119 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""854-1 안전 고침 — 내 기계 저장 잠금 · 판 대조 · 번호 겹침 없음(임시 storage · M01 정본 안 고침).
|
||||
|
||||
① 스레드 여럿이 동시에 만들기 → 번호 겹침 0 · 파일 수 = 요청 수 ② 옛 판으로 고치기 = 409 · 새 판 = 됨
|
||||
③ `_다음` 이 뒤처져도 있는 파일 번호를 덮지 않음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import time
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
import pytest
|
||||
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_MyMachine as mym
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
N = 8
|
||||
|
||||
|
||||
def _at(folder, fn, *args):
|
||||
with store.at(folder):
|
||||
return fn(*args)
|
||||
|
||||
|
||||
def _easy(name="sub4임시기계", **vals):
|
||||
base = {"가격": 1000, "손료계수": 2000, "주연료": 2, "주연료종류": "경유"}
|
||||
return {"이름": name, "규격": "1㎾", "방식": "바로", "값": base | vals}
|
||||
|
||||
|
||||
def test_parallel_create_no_clash(world, monkeypatch):
|
||||
"""① 동시 만들기 N 번 — 키 N 개 모두 다름 · 파일 N 개 · 줄마다 자기 이름(쓰기마다 늦춰 틈을 벌림)."""
|
||||
me = world["personal"]
|
||||
write = mym.atomic_write_json
|
||||
|
||||
def slow(path, value):
|
||||
time.sleep(0.02)
|
||||
write(path, value)
|
||||
|
||||
monkeypatch.setattr(mym, "atomic_write_json", slow)
|
||||
with ThreadPoolExecutor(N) as pool:
|
||||
got = list(pool.map(lambda i: _at(me, mym.create, _easy(f"sub4임시{i}"))["줄"], range(N)))
|
||||
keys = [r["키"] for r in got]
|
||||
assert len(set(keys)) == N
|
||||
files = sorted((me / mym.DIR).glob(f"{mym.PREFIX}*.json"))
|
||||
assert len(files) == N
|
||||
names = {json.loads(p.read_bytes())["이름"] for p in files}
|
||||
assert names == {f"sub4임시{i}" for i in range(N)}
|
||||
assert json.loads((me / mym.DIR / mym.NEXT).read_bytes())["다음"] == N + 1
|
||||
|
||||
|
||||
def test_stale_version_409(world):
|
||||
"""② 연 판으로 고침 = 됨(새 판 받음) · 옛 판으로 한 번 더 = 409 {stale, 판} · 판 없음 = 대조 없음."""
|
||||
me = world["personal"]
|
||||
made = _at(me, mym.create, _easy())
|
||||
key, old = made["줄"]["키"], made["판"]
|
||||
assert old
|
||||
fresh = _at(me, mym.update, key, _easy(가격=3000), old)
|
||||
assert fresh["판"] and fresh["판"] != old
|
||||
with pytest.raises(store.StoreError) as e:
|
||||
_at(me, mym.update, key, _easy(가격=4000), old)
|
||||
assert e.value.status == 409 and e.value.detail == {"stale": [key], "판": fresh["판"]}
|
||||
assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 3000 # 막힌 고침은 안 적힘
|
||||
_at(me, mym.update, key, _easy(가격=5000)) # 서버 길(초안 저장) = 대조 없음
|
||||
assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 5000
|
||||
|
||||
|
||||
def test_counter_behind_skips_file(world):
|
||||
"""③ `_다음` 이 옛 번호를 가리켜도 있는 파일은 안 덮음 — 다음 빈 번호."""
|
||||
me = world["personal"]
|
||||
first = _at(me, mym.create, _easy("sub4임시처음"))["줄"]["키"]
|
||||
(me / mym.DIR / mym.NEXT).write_text('{"다음": 1}', encoding="utf-8")
|
||||
second = _at(me, mym.create, _easy("sub4임시둘째"))["줄"]["키"]
|
||||
assert second != first
|
||||
assert _at(me, mym.one, first)["줄"]["이름"] == "sub4임시처음"
|
||||
|
||||
|
||||
def test_brief_cache_follows_index(monkeypatch):
|
||||
"""④ 기계 창 목록 메모(`Machine_Hourly.brief`) — 색인이 바뀌면 새 값 · 옛 색인 메모를 안 꺼냄 · 되돌리면 처음 값."""
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Machine_Hourly as mh
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
|
||||
key = "EQ000022" # 굴착기 — 가격 · 시간당 있음
|
||||
base = m01.loaded()
|
||||
first = mh.brief([key])[0]
|
||||
row = base[1].get(key)
|
||||
twice = {**row, "값": {**row["값"], "가격": row["값"]["가격"] * 2}}
|
||||
other = skc.Copy(base[1], [twice], ("시험854",))
|
||||
monkeypatch.setattr(m01, "loaded", lambda: (base[0], other))
|
||||
got = mh.brief([key])[0]
|
||||
assert got["값"]["가격"] == first["값"]["가격"] * 2
|
||||
assert got["시간당"]["계"] > first["시간당"]["계"]
|
||||
assert all(v[0] is other for v in mh._BRIEF.values())
|
||||
monkeypatch.setattr(m01, "loaded", lambda: base)
|
||||
assert mh.brief([key])[0] == first
|
||||
|
||||
|
||||
def test_deleted_last_key_not_reused(world):
|
||||
"""⑤ 단가산출(SK) · 내 재료(PM) — 끝 번호를 지운 뒤 새로 만들면 새 번호(지운 번호 안 다시 씀)."""
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Material_Own as own
|
||||
|
||||
me = world["personal"]
|
||||
body = {"단위": "시간", "더한줄": []}
|
||||
made = [
|
||||
_at(me, refs.create, "sangeun", {**body, "이름": f"sub4임시{i}"})["이름"] for i in range(2)
|
||||
]
|
||||
assert made == ["SK-000001", "SK-000002"]
|
||||
_at(me, store.delete, "sangeun", made[-1])
|
||||
assert _at(me, refs.create, "sangeun", {**body, "이름": "sub4임시3"})["이름"] == "SK-000003"
|
||||
|
||||
bolt = {"이름": "sub4임시볼트", "규격": "M16", "단위": "EA", "값": 1200}
|
||||
keys = [own.add(me, {**bolt, "규격": f"M{i}"})["키"] for i in (16, 20)]
|
||||
assert keys == ["PM000001", "PM000002"]
|
||||
own.remove(me, keys[-1])
|
||||
assert own.add(me, {**bolt, "규격": "M24"})["키"] == "PM000003"
|
||||
@@ -0,0 +1,108 @@
|
||||
"""M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만.
|
||||
|
||||
- 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글.
|
||||
- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
import shutil
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from fastapi import FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
from M01_MasterData import M01_MasterData_Router as router_module
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
from M01_MasterData import M01_MasterData_Store_Make as make
|
||||
|
||||
REAL = store.FOLDER
|
||||
SAMPLE = "GF000219" # 산림 13-4-1 메쌓기(인력)
|
||||
COSTS = ("노무비", "재료비", "경비", "계")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client(tmp_path: Path, monkeypatch) -> TestClient:
|
||||
for path in REAL.glob("*.json"):
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp_path / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp_path / "기계")
|
||||
shutil.copytree(REAL / "수식문서", tmp_path / "수식문서")
|
||||
monkeypatch.setattr(store, "FOLDER", tmp_path)
|
||||
monkeypatch.setattr(doc_screen.ml, "FOLDER", tmp_path / "수식문서")
|
||||
doc_screen._memo.clear()
|
||||
app = FastAPI()
|
||||
app.include_router(router_module.router)
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _get(client: TestClient, url: str, **params) -> dict:
|
||||
res = client.get(url, params=params)
|
||||
assert res.status_code == 200, res.text
|
||||
return res.json()
|
||||
|
||||
|
||||
def _post(client: TestClient, url: str, body: dict) -> dict:
|
||||
res = client.post(url, json=body)
|
||||
assert res.status_code == 200, res.text
|
||||
return res.json()
|
||||
|
||||
|
||||
def _money(answer: dict) -> dict:
|
||||
return {k: Decimal(str(answer[k])) for k in COSTS}
|
||||
|
||||
|
||||
def _old(key: str) -> dict:
|
||||
"""옛 엔진 금액(빌더 대조와 같은 길 · 기본 입력)."""
|
||||
builder = importlib.import_module("build_수식문서_802_2")
|
||||
whole = store.loaded()[1]
|
||||
row = store.logic(key)["logic"]
|
||||
return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1]))
|
||||
|
||||
|
||||
def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진과_같다(client: TestClient) -> None:
|
||||
made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, "이름": "sub5임시 본뜸"})
|
||||
key = made["key"]
|
||||
assert key.startswith("GX") and made["수식문서"] is True
|
||||
got = _get(client, "/api/m01/logic/doc", key=key)
|
||||
assert got["새"] is False and got["파일"] == "수식_자체.json" and got["문서"]["식"]
|
||||
assert got["셈"]["셈됨"] is True
|
||||
source = _get(client, "/api/m01/logic/doc", key=SAMPLE)
|
||||
assert _money(got["셈"]) == _old(key) == _money(source["셈"]) and _old(key)["계"] > 0
|
||||
|
||||
# 빌더가 다음에 다시 지어도 같은 파일 글(옛 로직 줄이 있는 키 = 빌더 몫)
|
||||
builder = importlib.import_module("build_수식문서_802_2")
|
||||
result = builder.build(log=lambda *_: None)
|
||||
assert key in result["저장"]
|
||||
want = builder.files_of(result)["수식_자체.json"]
|
||||
assert (doc_screen.folder() / "수식_자체.json").read_text(encoding="utf-8") == want
|
||||
|
||||
# 지우면 문서도 같이
|
||||
info = _get(client, "/api/m01/logic", key=key)
|
||||
_post(
|
||||
client,
|
||||
"/api/m01/logic/remove",
|
||||
{"key": key, "file": info["file"], "version": info["version"]},
|
||||
)
|
||||
assert _get(client, "/api/m01/logic/doc", key=SAMPLE)["새"] is False
|
||||
assert key not in doc_screen.docs()
|
||||
|
||||
|
||||
def test_식_복사로_만든_로직도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None:
|
||||
view = _get(client, "/api/m01/logic/formula", key=SAMPLE)
|
||||
made = _post(
|
||||
client,
|
||||
"/api/m01/logic/formula/save",
|
||||
{"로직": view["로직"], "별칭": view["별칭"], "본뜬키": SAMPLE, "이름": "sub5임시 식복사"},
|
||||
)
|
||||
key = made["key"]
|
||||
assert made["수식문서"] is True and key in doc_screen.docs()
|
||||
assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == _old(key)
|
||||
|
||||
body = {"file": make.OWN, "version": made["version"], "changes": [{"op": "delete", "key": key}]}
|
||||
_post(client, "/api/m01/save", {"files": [body]})
|
||||
assert key not in doc_screen.docs()
|
||||
@@ -0,0 +1,141 @@
|
||||
"""M01 수식 문서 쓰기 안전(PLAN 854-2 · 요구 894 걸음 1) — 잠금 · 판 대조(409) · 임시 파일 → 교체.
|
||||
|
||||
마스터 · 수식 문서 사본 폴더에서만 씀.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
|
||||
REAL = store.FOLDER
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def master(tmp_path: Path, monkeypatch) -> Path:
|
||||
for path in REAL.glob("*.json"):
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp_path / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp_path / "기계")
|
||||
monkeypatch.setattr(store, "FOLDER", tmp_path)
|
||||
return tmp_path
|
||||
|
||||
|
||||
DOC_KEY = "GF000219" # 산림 13-4-1 메쌓기(인력)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def docs(master: Path, monkeypatch) -> Path:
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
|
||||
folder = master / "수식문서"
|
||||
shutil.copytree(REAL / "수식문서", folder)
|
||||
monkeypatch.setattr(doc_screen.ml, "FOLDER", folder)
|
||||
doc_screen._memo.clear()
|
||||
return folder
|
||||
|
||||
|
||||
def _client():
|
||||
from fastapi import FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from M01_MasterData import M01_MasterData_Router as router_module
|
||||
|
||||
app = FastAPI()
|
||||
app.include_router(router_module.router)
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _renamed(doc: dict, tail: str) -> dict:
|
||||
return {**doc, "이름": f"{doc['이름']} {tail}"}
|
||||
|
||||
|
||||
def test_옛_판으로_저장하면_409_이고_앞_저장을_덮지_않는다(docs: Path) -> None:
|
||||
client = _client()
|
||||
got = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
|
||||
assert got["판"] and not got["새"]
|
||||
first = client.post(
|
||||
"/api/m01/logic/doc/save",
|
||||
json={"문서": _renamed(got["문서"], "sub5임시A"), "판": got["판"]},
|
||||
)
|
||||
assert first.status_code == 200, first.text
|
||||
again = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
|
||||
assert again["판"] == first.json()["판"] != got["판"] # 저장 뒤 판 = 다시 읽은 판
|
||||
late = client.post(
|
||||
"/api/m01/logic/doc/save",
|
||||
json={"문서": _renamed(got["문서"], "sub5임시B"), "판": got["판"]},
|
||||
)
|
||||
assert late.status_code == 409 and "그 사이 파일이 바뀜" in late.json()["detail"]
|
||||
assert again["문서"]["이름"].endswith("sub5임시A")
|
||||
now = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
|
||||
assert now["문서"]["이름"].endswith("sub5임시A") # 늦은 저장이 소리 없이 덮지 않음
|
||||
assert not list(docs.glob(".*.tmp"))
|
||||
|
||||
|
||||
def test_동시에_두_저장이면_하나만_되고_하나는_409(docs: Path, monkeypatch) -> None:
|
||||
import threading
|
||||
import time
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
|
||||
got = _client().get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() # 화면 꼴(수 = JSON)
|
||||
real = doc_screen.layered
|
||||
|
||||
def slow(doc, key): # 두 저장이 겹치게 — 판 확인 · 쓰기 사이를 넓힘
|
||||
time.sleep(0.3)
|
||||
return real(doc, key)
|
||||
|
||||
monkeypatch.setattr(doc_screen, "layered", slow)
|
||||
plain = got["문서"]
|
||||
out: list[str] = []
|
||||
|
||||
def one(tail: str) -> None:
|
||||
try:
|
||||
doc_screen.save(_renamed(plain, tail), got["판"])
|
||||
out.append("ok")
|
||||
except doc_screen.store.StoreError as e:
|
||||
out.append(str(e.status))
|
||||
|
||||
runs = [threading.Thread(target=one, args=(t,)) for t in ("sub5임시A", "sub5임시B")]
|
||||
for t in runs:
|
||||
t.start()
|
||||
for t in runs:
|
||||
t.join()
|
||||
assert sorted(out) == ["409", "ok"]
|
||||
|
||||
|
||||
def test_기계_목록_등록이_바꾼_문서를_옛_판_저장이_덮지_않는다(docs: Path) -> None:
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
from M01_MasterData import M01_MasterData_Machine as machine
|
||||
|
||||
key = next(
|
||||
k
|
||||
for k, d in doc_screen.docs().items()
|
||||
if any(
|
||||
v.get("이름") == "기계" and (v.get("연결") or {}).get("갈래") == "선택"
|
||||
for v in d.get("변수") or []
|
||||
)
|
||||
)
|
||||
got = _client().get("/api/m01/logic/doc", params={"key": key}).json()
|
||||
machine._register_docs({key: ["sub5임시EQ"]}, set())
|
||||
after = doc_screen.read(key)
|
||||
assert after["판"] != got["판"]
|
||||
plain = got["문서"]
|
||||
with pytest.raises(doc_screen.store.StoreError) as e:
|
||||
doc_screen.save(_renamed(plain, "sub5임시"), got["판"])
|
||||
assert e.value.status == 409
|
||||
picks = next(v for v in doc_screen.read(key)["문서"]["변수"] if v.get("이름") == "기계")
|
||||
assert "sub5임시EQ" in picks["연결"]["목록"]
|
||||
|
||||
|
||||
def test_마스터만_사본인_시험은_정본_수식_문서를_안_쓴다(master: Path) -> None:
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
|
||||
path = doc_screen.folder() / "수식_자체.json" # 정본 폴더(사본으로 안 바꿈)
|
||||
raw = path.read_bytes()
|
||||
doc_screen.put(path, {"그룹": "수식문서", "로직파일": "", "줄": []})
|
||||
assert path.read_bytes() == raw
|
||||
@@ -0,0 +1,113 @@
|
||||
"""M01 저장 안전(PLAN 854-2 · 요구 894 걸음 1) — 마스터 사본 폴더에서만 씀.
|
||||
|
||||
- 키 대장 · 파일 쓰기: 중간에 끊겨도 대장 · 파일이 저장 전 그대로(대장만 앞서가지 않음).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
from M01_MasterData import M01_MasterData_Store_Save as save_mod
|
||||
|
||||
REAL = store.FOLDER
|
||||
OWN = "로직_자체.json"
|
||||
MACHINE = "EQ000002"
|
||||
LABOR = "LB000002" # 보통인부
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def master(tmp_path: Path, monkeypatch) -> Path:
|
||||
for path in REAL.glob("*.json"):
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp_path / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp_path / "기계")
|
||||
monkeypatch.setattr(store, "FOLDER", tmp_path)
|
||||
return tmp_path
|
||||
|
||||
|
||||
def _bytes(folder: Path) -> dict[str, bytes]:
|
||||
out = {p.name: p.read_bytes() for p in folder.glob("*.json")}
|
||||
out |= {f"기계/{p.name}": p.read_bytes() for p in (folder / "기계").glob("*.json")}
|
||||
return out
|
||||
|
||||
|
||||
def _new_logic() -> dict:
|
||||
return {
|
||||
"op": "add",
|
||||
"row": {
|
||||
"원문번호": "",
|
||||
"구분": "자체",
|
||||
"상세구분": "",
|
||||
"소유": "현장",
|
||||
"이름": "sub5임시 대장 시험",
|
||||
"결과단위": "원/㎡",
|
||||
"출처": "자체",
|
||||
"입력": [],
|
||||
"중간": [],
|
||||
"호표": [
|
||||
{
|
||||
"종류": "인력",
|
||||
"요소": LABOR,
|
||||
"이름": "보통인부",
|
||||
"단위": "인",
|
||||
"수량": "1 / 7",
|
||||
"비목": "노무비",
|
||||
}
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def _batch() -> list[dict]:
|
||||
"""기계 한 대 고침(기계 폴더) + 자체 로직 새 줄(GX 키 발급 = 대장 바뀜)."""
|
||||
machine = json.loads((store.FOLDER / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8"))
|
||||
machine["비고"] = "sub5임시"
|
||||
return [
|
||||
{
|
||||
"file": "기계.json",
|
||||
"version": store.version("기계.json"),
|
||||
"changes": [{"op": "edit", "key": MACHINE, "row": machine}],
|
||||
},
|
||||
{"file": OWN, "version": store.version(OWN), "changes": [_new_logic()]},
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("fail_at", [0, 1])
|
||||
def test_파일_쓰기가_끊기면_대장과_파일이_저장_전_그대로(
|
||||
master: Path, monkeypatch, fail_at
|
||||
) -> None:
|
||||
before = _bytes(master)
|
||||
real = save_mod._write
|
||||
calls = []
|
||||
|
||||
def broken(name, was, now):
|
||||
calls.append(name)
|
||||
if len(calls) - 1 == fail_at:
|
||||
if fail_at: # 둘째 파일은 쓴 뒤에 끊김(반쯤 쓴 꼴)
|
||||
real(name, was, now)
|
||||
raise OSError("디스크 흉내 실패")
|
||||
return real(name, was, now)
|
||||
|
||||
monkeypatch.setattr(save_mod, "_write", broken)
|
||||
with pytest.raises(OSError):
|
||||
store.save(_batch())
|
||||
after = _bytes(master)
|
||||
assert after == before # 대장 · 기계 · 로직 파일 모두 저장 전 글 그대로
|
||||
assert not list(master.glob(".*.tmp")) and not list((master / "기계").glob(".*.tmp"))
|
||||
|
||||
|
||||
def test_끊김_없으면_대장과_파일이_같이_간다(master: Path) -> None:
|
||||
book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("GX", 1)
|
||||
store.save(_batch())
|
||||
book = store.mk.load_book(master / store.mk.BOOK.name)
|
||||
keys = [r["키"] for r in json.loads((master / OWN).read_text(encoding="utf-8"))["줄"]]
|
||||
assert f"GX{book_before:06d}" in keys and book["다음"]["GX"] == book_before + 1
|
||||
machine = json.loads((master / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8"))
|
||||
assert machine["비고"] == "sub5임시"
|
||||
@@ -0,0 +1,264 @@
|
||||
# ruff: noqa: F811, E402 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 · `--write` 때 길을 먼저 둠
|
||||
"""855-F B9-0 — B08 · B09 답 지문(옛 엔진 부름을 걷는 걸음 B9-1 ~ B9-6 의 「다름 0」 자).
|
||||
|
||||
임시 storage(개인 층 7/42) · 견본을 시험이 지음 → 사본 만들기(지금 길) → 답 지문:
|
||||
- 층 견본 — 단가산출(SK): 바탕 로직 · 율 더한줄 · 형제(바탕 참조) · 「따로」 · 가져온 식 · 기계 · 재료 /
|
||||
일위대가(SC): SK 참조 · 고정 · 로직 줄 + 자재
|
||||
- 구조물 사본 = 일위대가 열 문서(위 참조 + 로직 · 고른 재료 · 자재) → `labor_doc_rows` · `price_bundle`
|
||||
· B09 서고 사본 = `Bill_Library.import_copy`(SK 따로 · SK 가져온 식 · SC)
|
||||
- 손 줄 = 설계내역서 로직 줄(율 · 고른 재료 · 입력) + 운반공(거리 채움)
|
||||
- 답 = B09 `calc_user` · `daega_inputs` · 단가 수요 키(`_demand`) · 산근(`Sangeun.build` · 관급 있음 · 없음)
|
||||
· `logic_preview`(손 줄마다) · B08 `snapshot_units` — 갈래마다 지문(값 · 글 따로).
|
||||
|
||||
지문 = `golden_855_b09.json` · 다르면 실패 — 뜻대로 금액 · 글을 바꾼 걸음만 다시 뜸:
|
||||
`./venv/Scripts/python.exe resources/tester/test_855_b09_golden.py --write`(바뀐 갈래를 커밋 글에).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import copy
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
if str(ROOT) not in sys.path: # `--write` 로 바로 돌릴 때
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from B08_Quantity import B08_Quantity_Router_Material as b08
|
||||
from B09_Estimation import B09_Estimation_Bill_Library as library
|
||||
from B09_Estimation import B09_Estimation_Router as b09
|
||||
from B09_Estimation import B09_Estimation_Sangeun as sangeun
|
||||
from B09_Estimation import B09_Estimation_Store as b09_store
|
||||
from B09_Estimation.B09_Estimation_Labor_Source import daega_inputs
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as sk_path
|
||||
from M02_MasterTemplete import M02_Item_Snapshot as snapshots
|
||||
from M02_MasterTemplete import M02_Item_Source as source
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imported
|
||||
from resources.tester.test_145_2_b09_labor_calc import _item, _project
|
||||
from resources.tester.test_793_2_sangeun_imported import _bonghwa
|
||||
from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
FILE = HERE / "golden_855_b09.json"
|
||||
REDO = "./venv/Scripts/python.exe resources/tester/test_855_b09_golden.py --write"
|
||||
WRITE = os.environ.get("S855B09_WRITE") == "1"
|
||||
OWNER = "7/42"
|
||||
|
||||
FORM = "GC000211" # 합판거푸집 — 옵션 · 재료 · 인력
|
||||
PCT = "GC001109" # 인력 둘 + 「노무비 * 3 / 100」 덧줄(율)
|
||||
SUB = "GC000999" # 원/주 · 고소작업차 로직 줄 + 덧줄 공구손료 %
|
||||
NET = "GC000337" # 낙석방지망 — 노무 · 크레인(중기) · 자재 셋
|
||||
NET_IN = {"구분": "기계식", "방지망": "포켓식", "지역": "전국평균", "크레인": "2104-0010"}
|
||||
DIG = "GF000089" # 토사깍기(기계) — 굴착기 시간당
|
||||
STONE = "GF000219" # 돌쌓기 메쌓기(인력)
|
||||
TWO_MATS = "GC000565" # 재료 줄 둘(고른 재료 열쇠)
|
||||
HAUL = "GF000134" # 골재운반(운반공 · 거리로 입력 채움)
|
||||
FIXED = {
|
||||
"고정": {
|
||||
"이름": "sub6임시 손 단가",
|
||||
"규격": "",
|
||||
"단위": "식",
|
||||
"단가": {"노무비": 12000, "재료비": 3000, "경비": 500},
|
||||
"이음": {"노임": "LB000002", "자재": None, "기계": None, "유가": None},
|
||||
},
|
||||
"수량": {"손": 2},
|
||||
}
|
||||
RATE = {
|
||||
"고정": {"이름": "공구손료", "단가": {}, "이음": {}, "비율": {"기준": "인력", "비목": "경비"}}
|
||||
}
|
||||
|
||||
|
||||
def _sk(**doc) -> str:
|
||||
return refs.create("sangeun", {"이름": "sub6임시", "단위": "㎡", "더한줄": [], **doc})["이름"]
|
||||
|
||||
|
||||
def _layer_samples(me: Path) -> dict[str, str]:
|
||||
"""개인 층 견본 — {갈래: 키}."""
|
||||
with store.at(me):
|
||||
keys = {
|
||||
"바탕": _sk(바탕={"로직": FORM}, 입력값={"유형": "복잡", "사용횟수": "3회"}),
|
||||
"율": _sk(바탕={"로직": SUB}, 단위="주", 더한줄=[{**RATE, "수량": 2}]),
|
||||
"기계": _sk(바탕={"로직": DIG}, 단위="㎥"),
|
||||
"재료": _sk(바탕={"로직": NET}, 입력값=NET_IN),
|
||||
}
|
||||
keys["형제"] = _sk(바탕={"참조": {**MINE, "키": keys["바탕"]}})
|
||||
keys["따로"] = _sk(바탕={"로직": PCT})
|
||||
read = sk_path.read(keys["따로"])
|
||||
twice = copy.deepcopy(read["문서"])
|
||||
twice["금액"][0]["수량"] = f"({twice['금액'][0].get('수량') or 1}) × 2"
|
||||
sk_path.save(keys["따로"], {"문서": twice, "판": read["판"]})
|
||||
row, src = _bonghwa()
|
||||
keys["가져온"] = imported.create(row, src, "sub6임시 가져온")["이름"]
|
||||
sc = {
|
||||
"이름": "sub6임시 일위대가",
|
||||
"단위": "㎡",
|
||||
"담은로직": [
|
||||
{"참조": {**MINE, "키": keys["바탕"]}, "수량": {"손": 1}},
|
||||
FIXED,
|
||||
{"로직": STONE, "입력값": {}, "수량": {"손": 1}},
|
||||
],
|
||||
"자재": [{"코드": "MT003810", "수량": {"손": 2}}],
|
||||
}
|
||||
keys["일위대가"] = refs.create("precombo", sc)["이름"]
|
||||
return keys
|
||||
|
||||
|
||||
def _structure(world, keys: dict[str, str], root: Path) -> None:
|
||||
"""구조물 사본(pipe@100.0) — 일위대가 열 문서를 지금 사본 길(`labor_doc_rows` · `price_bundle`)로."""
|
||||
me = world["personal"]
|
||||
lines = [
|
||||
{"참조": {**MINE, "키": keys[k]}, "수량": {"손": q}}
|
||||
for k, q in (("바탕", 2), ("율", 1), ("형제", 1), ("따로", 1), ("가져온", 1), ("기계", 3))
|
||||
]
|
||||
lines += [
|
||||
{"참조": {**MINE, "키": keys["재료"]}, "수량": {"손": 1}},
|
||||
{"참조": {**MINE, "키": keys["일위대가"]}, "수량": {"손": 1}},
|
||||
{"로직": STONE, "입력값": {}, "수량": {"손": 1}},
|
||||
{"로직": TWO_MATS, "수량": {"손": 1}},
|
||||
]
|
||||
with store.at(me):
|
||||
doc = labor.clean(
|
||||
{"열": "rv", "담은로직": lines, "자재": [{"코드": "MT003810", "수량": {"손": 2}}]}
|
||||
)
|
||||
rows = source.labor_doc_rows(doc)
|
||||
files = {
|
||||
source.LABOR_FILE: rows,
|
||||
source.PRICE_FILE: source.price_bundle(rows, me),
|
||||
snapshots.VALUES_FILE: {STONE: {"높이": {"값": 1.5}}},
|
||||
snapshots.PICKS_FILE: {TWO_MATS: {"1": "MT003196", "2": "MT003173"}},
|
||||
snapshots.MANIFEST_NAME: {"원본": {**_item("SS000901"), "경로": ["x"]}},
|
||||
}
|
||||
folder = snapshots.structures_dir(root) / snapshots.folder_name("pipe@100.0")
|
||||
folder.mkdir(parents=True)
|
||||
for name, data in files.items():
|
||||
text = json.dumps(data, ensure_ascii=False, default=str)
|
||||
(folder / name).write_text(text, encoding="utf-8")
|
||||
|
||||
|
||||
HAND = [
|
||||
{"key": "hand:rate", "section": "1.1", "after": "", "spec": "", "name": "율 줄", "unit": "㎡", "qty": 2,
|
||||
"ref": {"tab": "logic", "code": PCT, "given": {}, "rate": None, "picks": None}},
|
||||
{"key": "hand:pick", "section": "1.1", "after": "hand:rate", "spec": "", "name": "고른 재료", "unit": "㎡", "qty": 1,
|
||||
"ref": {"tab": "logic", "code": TWO_MATS, "given": {}, "rate": None, "picks": {"1": "MT003196", "2": "MT003173"}}},
|
||||
{"key": "hand:net", "section": "1.1", "after": "hand:pick", "spec": "", "name": "입력", "unit": "㎡", "qty": 3,
|
||||
"ref": {"tab": "logic", "code": NET, "given": NET_IN, "rate": 90, "picks": None}},
|
||||
] # fmt: skip
|
||||
HAUL_REF = {"tab": "logic", "code": HAUL, "name": "골재운반", "given": {"Cm": 1}, "cycle": {}}
|
||||
USER = {
|
||||
"bill": {"qty": {}, "rows": HAND},
|
||||
"haul_refs": {"haul:r-u1": HAUL_REF},
|
||||
"haul_dist": {"haul:r-u1": {"L1": 25.1, "L2": 0.8}},
|
||||
}
|
||||
|
||||
|
||||
def _clean(value, root: Path):
|
||||
"""지문 꼴 — 임시 경로 · 때(날짜 · 시각)는 지움 · 수는 글로."""
|
||||
text = json.dumps(value, ensure_ascii=False, sort_keys=True, default=str)
|
||||
text = text.replace(str(root).replace("\\", "\\\\"), "<root>").replace(str(root), "<root>")
|
||||
return re.sub(
|
||||
r"\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?", "<때>", text
|
||||
)
|
||||
|
||||
|
||||
def _split_text(value):
|
||||
"""(값, 글) — 산출근거 글(`text` · `head` · `foot` · `lines` 글 목록)을 따로 떼어 지문을 나눔."""
|
||||
words = []
|
||||
|
||||
def walk(v):
|
||||
if isinstance(v, dict):
|
||||
out = {}
|
||||
for k, x in v.items():
|
||||
if k in ("text", "head", "foot"):
|
||||
words.append(x)
|
||||
else:
|
||||
out[k] = walk(x)
|
||||
return out
|
||||
if isinstance(v, list):
|
||||
return [walk(x) for x in v]
|
||||
return v
|
||||
|
||||
return walk(value), words
|
||||
|
||||
|
||||
def answers(world, tmp_path) -> dict[str, object]:
|
||||
keys = _layer_samples(world["personal"])
|
||||
root = _project(tmp_path / "proj", [(100, "SS000901")])
|
||||
_structure(world, keys, root)
|
||||
for kind, key in (
|
||||
("sangeun", keys["따로"]),
|
||||
("sangeun", keys["가져온"]),
|
||||
("precombo", keys["일위대가"]),
|
||||
):
|
||||
library.import_copy(root, kind, "personal", OWNER, key)
|
||||
b09_store.write_user(root, USER)
|
||||
haul = {k: USER[k] for k in ("haul_refs", "haul_dist")} # 운반 연결 = 셈 때 거리이정표에서 붙음
|
||||
user = {**b09_store.read_user(root), **haul}
|
||||
out: dict[str, object] = {"키": keys}
|
||||
out["calc_user"] = b09.calc_user(root)
|
||||
out["daega_inputs"] = daega_inputs(root)
|
||||
out["수요"] = asyncio.run(b09._demand(root))
|
||||
for name, supply in (("산근", None), ("산근 관급", lambda _k: "관급")):
|
||||
sg = sangeun.build(root, user, None, supply)
|
||||
out[f"{name} 값"], out[f"{name} 글"] = _split_text(sg)
|
||||
for row in HAND:
|
||||
ref = row["ref"]
|
||||
body = b09.PreviewBody(
|
||||
code=ref["code"], given=ref["given"], rate=ref["rate"], picks=ref["picks"]
|
||||
)
|
||||
got = b09.logic_preview(root, body)
|
||||
got, words = _split_text(got)
|
||||
out[f"미리보기 {row['key']} 값"] = {k: v for k, v in got.items() if k != "lines"}
|
||||
out[f"미리보기 {row['key']} 글"] = [got.get("lines"), words]
|
||||
linked = snapshots.linked_snapshots(root)
|
||||
summary = {
|
||||
"linked": linked,
|
||||
"sources": [["rv:x", 12.0, folder, ["system||SS000901"]] for folder in sorted(linked)],
|
||||
"total": {"rv:x": 12.0},
|
||||
}
|
||||
out["B08 단위수량"] = b08.snapshot_units(root, summary)
|
||||
return {k: _clean(v, root) for k, v in out.items()}
|
||||
|
||||
|
||||
def _hash(text: str) -> str:
|
||||
return hashlib.sha256(text.encode("utf-8")).hexdigest()[:16]
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _manual(monkeypatch):
|
||||
"""자동 따라옴 끔 — 저장본 그대로(층 꼴만 봄 · 자동은 test_836_2)."""
|
||||
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
|
||||
|
||||
monkeypatch.setattr(renew, "on", lambda: False)
|
||||
|
||||
|
||||
def test_B08_B09_답_지문_같음(world, tmp_path):
|
||||
got = {k: _hash(v) for k, v in answers(world, tmp_path).items()}
|
||||
if WRITE:
|
||||
body = {"판": 1, "지문": got}
|
||||
FILE.write_text(json.dumps(body, ensure_ascii=False, indent=1) + "\n", "utf-8")
|
||||
want = json.loads(FILE.read_text("utf-8"))["지문"]
|
||||
bad = sorted(k for k in want.keys() | got.keys() if want.get(k) != got.get(k))
|
||||
assert not bad, (
|
||||
f"B08 · B09 답 지문 다름 — {bad}\n"
|
||||
f"뜻대로 금액 · 글을 바꾼 걸음이면 다시 뜸: {REDO} (아니면 고친 코드를 되짚음)"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if "--write" not in sys.argv:
|
||||
sys.exit(f"다시 뜨기 = {REDO}")
|
||||
os.environ["S855B09_WRITE"] = "1"
|
||||
import tempfile
|
||||
|
||||
temp = str(Path(tempfile.gettempdir()) / "s855b09_pt") # 공용 임시 폴더 권한 막힘 피함
|
||||
sys.exit(pytest.main([__file__, "-q", "-p", "no:cacheprovider", "--basetemp", temp]))
|
||||
@@ -0,0 +1,33 @@
|
||||
"""855-A 지킴 ④ — 막힘 판정 옛(`master_formula.check_logic` · M01 로직 목록 · `/logic`) = 새(수식 문서
|
||||
표지 `master_doc.check`) 전수 · 막힘 기준 = 표지만(기본 입력으로 셈이 안 되는 것은 막힘 아님 · 판정 855-0).
|
||||
|
||||
걸음 2-B3(막힘 검사를 문서 기준으로) 앞뒤로 같아야 함 · 옛 검사를 지우는 걸음에서 옛 쪽만 뗌."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import helper_855_engine as h
|
||||
|
||||
md = importlib.import_module("master_doc")
|
||||
|
||||
|
||||
def test_막힘_옛_새_같음():
|
||||
rows, whole, docs, _ = h.world()
|
||||
old = {str(r["키"]) for r in rows if h.mf.check_logic(whole, r)[0]}
|
||||
new = {str(r["키"]) for r in rows if str(r["키"]) not in docs or md.check(docs[str(r["키"])])}
|
||||
assert old == new, {"옛만 막힘": sorted(old - new)[:20], "새만 막힘": sorted(new - old)[:20]}
|
||||
|
||||
|
||||
def test_틀린_식은_옛_새_모두_막힘():
|
||||
"""자가 살아 있는지 — 같은 로직의 식을 틀리게 하면 두 판정 모두 막힘(사본만 · 자료 안 고침)."""
|
||||
import copy
|
||||
|
||||
rows, whole, docs, _ = h.world()
|
||||
row = next(r for r in rows if r.get("호표") and str(r["키"]) in docs)
|
||||
bad_row = copy.deepcopy(row)
|
||||
bad_row["호표"][0]["수량"] = "없는변수 * 2"
|
||||
bad_doc = copy.deepcopy(docs[str(row["키"])])
|
||||
bad_doc["금액"][0]["수량"] = "없는기호 × 2"
|
||||
assert h.mf.check_logic(whole, bad_row)[0]
|
||||
assert md.check(bad_doc)
|
||||
@@ -0,0 +1,155 @@
|
||||
"""855-C 2-C4 지킴 — 서버 산출근거 글(`master_doc_text`) · 기준 목록 · 계산서가 문서 셈.
|
||||
|
||||
① 거울 — 글 규칙이 화면 TS 와 같음(헬퍼 `helper_855_c4_doc_text.cjs`):
|
||||
수 꼴(`eqText` · 줄 금액 · 원) · 단위 글(`unitText`) · 금액 줄 단위 자리 · 단가 기호
|
||||
(`moneyUnits` · `priceSym`) · 선택으로 꺼진 줄(`offLine`) · 비목 이름 — 실제 M01 수식 문서 전부
|
||||
(기본 입력 셈 답)로.
|
||||
② 계산서 — 줄 금액 · 소계 · 계 = 문서 셈 답 그대로 · 소계 합 = 계 ·
|
||||
줄 글 「단가 원/단위 * 수량 단위 = 금액」.
|
||||
③ 기준 목록 줄 금액 = 같은 입력의 문서 셈 계.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
from decimal import Decimal
|
||||
from functools import lru_cache
|
||||
|
||||
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_Logic_Standard as st
|
||||
|
||||
mc = importlib.import_module("master_doc_calc")
|
||||
md = importlib.import_module("master_doc")
|
||||
mdt = importlib.import_module("master_doc_text")
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
NUMS = [0, 1, -1, 0.5, 1.5, 2.5, -2.5, 0.05, 0.15, 0.25, 0.35, 1.05, 1.15, 1.25, 2.675, 99.95,
|
||||
-0.05, 0.1 + 0.2, 1e-7, 1234567.891234567, 59018.0857142857, 284.42142857142,
|
||||
123456789012.345, 26890.75, 1502.04999] # fmt: skip
|
||||
|
||||
|
||||
def _js(v):
|
||||
if isinstance(v, Decimal):
|
||||
return float(v)
|
||||
if isinstance(v, dict):
|
||||
return {k: _js(x) for k, x in v.items()}
|
||||
if isinstance(v, (list, tuple)):
|
||||
return [_js(x) for x in v]
|
||||
if isinstance(v, (mc.Blank, mc.Stop)):
|
||||
return None
|
||||
return v
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def world():
|
||||
"""(문서들, 연결, {키: 기본 셈 답})."""
|
||||
whole = m01.loaded()[1]
|
||||
docs = m01_doc.docs()
|
||||
links = st._links(whole)
|
||||
answers = {k: mc.calc(d, links, None) for k, d in docs.items() if d.get("금액")}
|
||||
return docs, links, answers
|
||||
|
||||
|
||||
def _helper(payload: dict) -> dict:
|
||||
run = subprocess.run(
|
||||
["node", os.path.join(HERE, "helper_855_c4_doc_text.cjs")],
|
||||
input=json.dumps(payload, ensure_ascii=False),
|
||||
capture_output=True,
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
check=True,
|
||||
)
|
||||
return json.loads(run.stdout)
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def mirror():
|
||||
docs, links, answers = world()
|
||||
nums, units, lines, offs, py = list(NUMS), set(), [], [], {"단위": [], "줄": [], "꺼짐": []}
|
||||
for key, a in answers.items():
|
||||
doc = docs[key]
|
||||
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
units |= {str(v.get("단위") or "") for v in doc.get("변수") or []}
|
||||
units.add(str(doc.get("결과단위") or ""))
|
||||
for row in a.get("줄") or []:
|
||||
nums += [_js(row.get(k)) for k in ("단가", "수량", "금액")]
|
||||
for line in doc["금액"]:
|
||||
units.add(str(line.get("단위") or ""))
|
||||
sym = mdt.price_sym(line)
|
||||
pv = vars_.get(sym) if sym else None
|
||||
link = (pv or {}).get("연결") or {}
|
||||
sub = None
|
||||
if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]):
|
||||
got = links.doc(str(link["키"]))
|
||||
sub = {"결과단위": got.get("결과단위")} if got else None
|
||||
lines.append({"줄": _js(line), "단가변수": _js(pv), "부름": sub})
|
||||
nodes = (mdt.node_of(line.get("단가")), mdt.node_of(line.get("수량")))
|
||||
py["줄"].append((mdt.money_units(line, *nodes, pv, sub), sym))
|
||||
look = mdt._Look(doc, a, links)
|
||||
vals = {k: v for k, v in (a.get("값") or {}).items() if v is not None}
|
||||
part = {"식": _js(doc.get("식") or []), "금액": _js(doc["금액"])}
|
||||
offs.append({"문서": part, "값": _js(vals)})
|
||||
py["꺼짐"].append([look.off_line(line) for line in doc["금액"]])
|
||||
nums = [x for x in nums if isinstance(x, (int, float))]
|
||||
units |= {"%(인력품 대비)", "10^-7/시간", "kWh/hr", "줄 따름", "수(개)", "원문 단위 없음"}
|
||||
units = sorted(units)
|
||||
ts = _helper({"수": nums, "원": nums, "단위": units, "금액줄": lines, "꺼짐": offs})
|
||||
return nums, units, py, ts
|
||||
|
||||
|
||||
def test_수_꼴_eqText_한자리_원():
|
||||
nums, _, _, ts = mirror()
|
||||
assert len(nums) > 5000
|
||||
assert [mdt.eq_text(v) for v in nums] == ts["eq"]
|
||||
assert [mdt.one(v) for v in nums] == ts["one"]
|
||||
assert [mdt.won(v) for v in nums] == ts["won"]
|
||||
texts = ("5401-0017", "", " ", "1048")
|
||||
assert [mdt.eq_text(v) for v in texts] == ["5401-0017", "", " ", "1,048"]
|
||||
|
||||
|
||||
def test_단위_글_금액줄_단위_자리_단가_기호():
|
||||
_, units, py, ts = mirror()
|
||||
assert [mdt.unit_text(u) for u in units] == ts["단위"]
|
||||
assert len(py["줄"]) > 5000
|
||||
assert [u for u, _ in py["줄"]] == ts["금액줄"]
|
||||
assert [s for _, s in py["줄"]] == ts["기호"]
|
||||
assert any(u["wrap"] for u, _ in py["줄"]) and any(u["price"] for u, _ in py["줄"])
|
||||
|
||||
|
||||
def test_선택으로_꺼진_줄_비목_이름():
|
||||
_, _, py, ts = mirror()
|
||||
assert py["꺼짐"] == ts["꺼짐"]
|
||||
assert sum(map(sum, py["꺼짐"])) > 0 # 꺼진 줄이 실제로 있음(판정이 일을 함)
|
||||
assert mdt.COST_SHOW == ts["비목"] and mdt.LONG_SUM == ts["항"]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("key", ("GF000220", "GF000089", "GC000404", "GF000101"))
|
||||
def test_계산서_문서_셈_답_그대로(key):
|
||||
got = st.sheet(key, {})
|
||||
docs, links, _ = world()
|
||||
answer = mc.calc(docs[key], links, st._given(m01.loaded()[1], docs[key], {})[0])
|
||||
assert got["계"] == float(answer["계"]) and got["계"] == sum(g["소계"] for g in got["묶음"])
|
||||
for g in got["묶음"]:
|
||||
assert g["소계"] == float(answer[g["비목"]])
|
||||
for line in g["줄"]:
|
||||
assert line["글"].endswith(f"= {mdt.one(line['금액'] or 0)}")
|
||||
assert " * " in line["글"] or line["글"].startswith("—")
|
||||
first = got["묶음"][0]["줄"][0]
|
||||
if key == "GF000220": # 석공 노임 — 「268,908 원/인 * 0.1 인 = 26,890.8」
|
||||
assert first["이름"] == "석공" and first["글"].startswith("268,908 원/인 * 0.1 인 = ")
|
||||
|
||||
|
||||
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):
|
||||
given = st._given(whole, docs[key], row["바꿈"])[0]
|
||||
want = mc.calc(docs[key], links, given)
|
||||
assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"])
|
||||
@@ -0,0 +1,46 @@
|
||||
"""855-A 지킴 ① — 로직 전수 옛 엔진 대 새 계산기(저장된 수식 문서) · 걸음 2 동안 「다름 0」 자.
|
||||
|
||||
- 기본 입력 전수(관문 · 십여 초) · 옵션 표본 전수 = 환경 `S855_ALL=1`(3 분 남짓).
|
||||
- 층 L0 합계 · L1 줄 비목 · L2 줄 꼴 · L3 수량 · 단가(`helper_855_engine.level`).
|
||||
- 다름 = 채택된 차이와 같아야 함(합계 = 빌더 `ADOPTED` 그대로 · 줄 비목 = 같은 까닭의 문서만) ·
|
||||
「보임」(보이는 단가만 · 금액 같음)은 허용 갈래로 셈.
|
||||
- 옛 엔진을 지우는 걸음(2-E4)에서 은퇴 — 그 뒤는 `test_855_golden` 이 지킴.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
|
||||
import helper_855_engine as h
|
||||
|
||||
ALL = os.environ.get("S855_ALL") == "1"
|
||||
|
||||
|
||||
def _diffs(options: bool) -> dict[str, list]:
|
||||
rows, _, docs, _ = h.world()
|
||||
out: dict[str, list] = {"문서 없음": [], "채택 밖": [], "채택": [], h.SEEN: []}
|
||||
for row in rows:
|
||||
key = str(row["키"])
|
||||
doc = docs.get(key)
|
||||
if doc is None:
|
||||
out["문서 없음"].append(key)
|
||||
continue
|
||||
money = not doc.get("결과")
|
||||
for label, given, changed in h.cases(row, options):
|
||||
lv = h.level(h.old_run(row, given), h.new_run(doc, changed), money)
|
||||
if lv == h.SEEN:
|
||||
out[h.SEEN].append((key, label))
|
||||
elif lv and h.adopted(key, label, lv):
|
||||
out["채택"].append((key, label, lv))
|
||||
elif lv:
|
||||
out["채택 밖"].append((key, label, lv))
|
||||
return out
|
||||
|
||||
|
||||
def test_로직마다_수식_문서_있음_옛_대_새_다름은_채택뿐():
|
||||
got = _diffs(ALL)
|
||||
assert got["문서 없음"] == []
|
||||
assert got["채택 밖"] == [], got["채택 밖"][:20]
|
||||
total = {(k, o) for k, o, lv in got["채택"] if lv == "L0"}
|
||||
want = {x for x in h.build.ADOPTED if not x[1]} if not ALL else set(h.build.ADOPTED)
|
||||
assert total == want # 채택 목록이 다 나오고 그 밖은 없음(기본만 돌면 옵션 채택은 안 나옴)
|
||||
@@ -0,0 +1,47 @@
|
||||
"""855-A 지킴 ② — 새 계산기 답 지문(로직마다 기본 + 옵션 표본 · 노 · 재 · 경 · 계 · 줄 금액 · 비목).
|
||||
|
||||
- 지문 = `golden_855_engine.json`(로직 키 → 답 묶음 sha256 앞 16 자 · `helper_855_engine.fingerprint`).
|
||||
- 다르면 실패 — 계산기 · 수식 문서 · M01 자료가 금액을 바꿨다는 뜻. 자료 · 규칙을 **뜻대로 바꾼 걸음만**
|
||||
다시 뜸: `./venv/Scripts/python.exe resources/tester/test_855_golden.py --write`(바뀐 키를 커밋 글에).
|
||||
- 옛 엔진을 지운 뒤(2-E4) 옛 → 새 대조(`test_855_engine_parity` · `test_802_2`)를 이것이 대신함.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
FILE = HERE / "golden_855_engine.json"
|
||||
REDO = "./venv/Scripts/python.exe resources/tester/test_855_golden.py --write"
|
||||
|
||||
|
||||
def current() -> dict[str, str]:
|
||||
import helper_855_engine as h
|
||||
|
||||
rows, _, docs, _ = h.world()
|
||||
return {str(r["키"]): h.fingerprint(str(r["키"]), r) for r in rows if str(r["키"]) in docs}
|
||||
|
||||
|
||||
def test_새_계산기_답_지문_같음():
|
||||
want = json.loads(FILE.read_text("utf-8"))["지문"]
|
||||
got = current()
|
||||
changed = sorted(k for k in want.keys() & got.keys() if want[k] != got[k])
|
||||
gone, new = sorted(want.keys() - got.keys()), sorted(got.keys() - want.keys())
|
||||
assert not (changed or gone or new), (
|
||||
f"지문 다름 — 바뀜 {len(changed)} {changed[:20]} · 빠짐 {gone[:20]} · 새 키 {new[:20]}\n"
|
||||
f"뜻대로 금액을 바꾼 걸음이면 다시 뜸: {REDO} (아니면 고친 코드 · 자료를 되짚음)"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
ROOT = HERE.parents[1]
|
||||
for p in (str(ROOT), str(HERE)):
|
||||
if p not in sys.path:
|
||||
sys.path.insert(0, p)
|
||||
if "--write" not in sys.argv:
|
||||
sys.exit(f"다시 뜨기 = {REDO}")
|
||||
body = {"판": 1, "지문": dict(sorted(current().items()))}
|
||||
FILE.write_text(json.dumps(body, ensure_ascii=False, indent=1) + "\n", "utf-8", newline="\n")
|
||||
print(f"지문 {len(body['지문'])} 씀 → {FILE.name}")
|
||||
@@ -0,0 +1,125 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""855-A 지킴 ③ — 단가산출(SK) 셈 답 · 견본 꼴마다 옛 엔진 길(`M02_Doc_Sk.OLD`) 대 지금 길(수식 사본 →
|
||||
문서 계산기) · 지금 길 답의 줄 비목 합(원 버림) = 기준.
|
||||
|
||||
견본(임시 storage · 개인 층 · M01 은 읽기만): 바탕 로직 · 옛 칸 값(더한줄 로직) · 율 더한줄 · 형제 SK(바탕 참조) ·
|
||||
「따로」(수식 사본을 고쳐 저장) · 가져온 식(엑셀 줄 · 저장 없음).
|
||||
걸음 2-C1(SK 셈 한 길)이 이 시험을 자로 씀 — 「따로」 단언은 지금 사실(줄 = 옛 · 기준 = 새)이고 2-C1 에서 뒤집음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
from decimal import ROUND_DOWN, Decimal
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
from resources.tester import test_793_2_sangeun_imported as imported
|
||||
from resources.tester.test_778_4_rate_line import SUB, _rate
|
||||
from resources.tester.test_795_1_sk_copy import PCT, _doc, _sk
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
COSTS = ("노무비", "재료비", "경비")
|
||||
FORM = "GC000211" # 합판거푸집
|
||||
ADD = {"종류": "로직", "로직": "GF000089", "수량": 2, "입력값": {}, "이름": "sub6임시 굴착기"}
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _manual(monkeypatch):
|
||||
"""자동 따라옴 끔 — 저장본 그대로 셈(층 꼴만 봄)."""
|
||||
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
|
||||
|
||||
monkeypatch.setattr(renew, "on", lambda: False)
|
||||
|
||||
|
||||
def _run(doc: dict, old: bool) -> dict:
|
||||
whole = m01.loaded()[1]
|
||||
token = dsk.OLD.set(old)
|
||||
try:
|
||||
return calc.run(sd.clean(doc, None, whole), whole)
|
||||
finally:
|
||||
dsk.OLD.reset(token)
|
||||
|
||||
|
||||
def _both(folder, doc) -> tuple[dict, dict]:
|
||||
with store.at(folder):
|
||||
return _run(doc, True), _run(doc, False)
|
||||
|
||||
|
||||
def _lines_sum(got: dict) -> dict:
|
||||
total = {k: Decimal(0) for k in COSTS}
|
||||
for ln in got.get("줄") or []:
|
||||
for k in COSTS:
|
||||
v = (ln.get("비목") or {}).get(k)
|
||||
total[k] += Decimal(str(v)) if v is not None else 0
|
||||
return {k: v.quantize(Decimal(1), ROUND_DOWN) for k, v in total.items()}
|
||||
|
||||
|
||||
def _base(got: dict) -> dict:
|
||||
return {k: Decimal(str(got["기준"][k])).quantize(Decimal(1), ROUND_DOWN) for k in COSTS}
|
||||
|
||||
|
||||
def _same_paths(old: dict, new: dict) -> None:
|
||||
assert old["기준"] is not None and new["기준"] is not None
|
||||
assert {k: Decimal(str(old["기준"][k])) for k in COSTS} == {
|
||||
k: Decimal(str(new["기준"][k])) for k in COSTS
|
||||
}
|
||||
assert _lines_sum(new) == _base(new)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"body",
|
||||
[
|
||||
{"바탕": {"로직": FORM}},
|
||||
{"바탕": {"로직": PCT}},
|
||||
{"바탕": {"로직": FORM}, "더한줄": [ADD]}, # 옛 칸 값(더한줄 로직)
|
||||
{"바탕": {"로직": SUB}, "더한줄": [_rate("인력", 2)], "단위": "주"}, # 율 더한줄
|
||||
],
|
||||
ids=["바탕", "율_바탕", "옛칸_더한줄", "율_더한줄"],
|
||||
)
|
||||
def test_층_SK_옛_대_새_같고_줄_합_기준(world, body):
|
||||
me = world["personal"]
|
||||
key = _sk(me, **copy.deepcopy(body))
|
||||
doc = _doc(me, key)
|
||||
old, new = _both(me, doc)
|
||||
assert "수식셈" in new # 지금 길 = 수식 사본 문서 셈
|
||||
_same_paths(old, new)
|
||||
|
||||
|
||||
def test_형제_SK_바탕_참조(world):
|
||||
me = world["personal"]
|
||||
first = _sk(me, 바탕={"로직": FORM})
|
||||
second = _sk(me, 바탕={"참조": {"층": "personal", "주인": "7/42", "키": first}})
|
||||
old, new = _both(me, _doc(me, second))
|
||||
_same_paths(old, new)
|
||||
assert new["기준"] == _both(me, _doc(me, first))[1]["기준"]
|
||||
|
||||
|
||||
def test_가져온_식_옛_대_새(world):
|
||||
old, new = _both(world["personal"], imported._doc())
|
||||
assert "수식셈" in new
|
||||
_same_paths(old, new)
|
||||
|
||||
|
||||
def test_따로_SK_지금은_줄_옛_기준_새(world):
|
||||
"""「따로」 = 고친 수식 사본이 정본 — 지금 셈 답은 줄 = 옛 엔진(옛 칸) · 기준 = 문서 계산기라 갈림.
|
||||
2-C1 에서 뒤집을 단언 — 그 뒤엔 `_same_paths` 꼴(줄 합 = 기준)로 바꿈."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": PCT})
|
||||
with store.at(me):
|
||||
read = path.read(key)
|
||||
twice = copy.deepcopy(read["문서"])
|
||||
line = twice["금액"][0]
|
||||
line["수량"] = f"({line.get('수량') or 1}) × 2"
|
||||
saved = path.save(key, {"문서": twice, "판": read["판"]})
|
||||
assert saved["사본"]["따로"] is True
|
||||
old, new = _both(me, _doc(me, key))
|
||||
assert new["수식셈"]["따로"] is True
|
||||
assert _base(new) != _base(old) # 2-C1 에서 뒤집을 단언 — 기준이 옛 길과 다름
|
||||
assert _lines_sum(new) == _base(old) != _base(new) # 2-C1 에서 뒤집을 단언 — 줄 = 옛 길
|
||||
@@ -0,0 +1,170 @@
|
||||
"""855-F B9-1 지킴 — 문서 셈 기록(`master_doc_trace`) · 로직 전수 기본 입력.
|
||||
|
||||
- 기록을 켜도 셈 답 같음(줄 `부름` · 답 `부름` `자원` 칸만 더해짐).
|
||||
- 자원 키 = 옛 엔진 셈 중 `whole.get` 가로채기 키(B09 `hand_resource_keys` 방식 ·
|
||||
찾기 색인 데운 뒤) — 다름 = `MORE` 뿐(새 계산기는 이름마다 셈 — 옛은 안 고른 「만약」 갈래 ·
|
||||
빈 수량 줄 · 앞서 멈춘 줄을 안 읽음 · 새 쪽에만 더 있음).
|
||||
- 하위 부름 = 옛 `B09 line_calls`(돈 문서 {code, given} · 기계경비 {machine}) — 다름 = 옛이 입력
|
||||
기본값을 못 세 빈 답인 문서뿐 · 새 쪽 결과 문서 부름(작업량 등 중간 값)은 하위 산근 아님.
|
||||
- 고른 품목 = `master_pick.priced` 의 품목 키 · 줄 `부름` = 그 줄 자원.
|
||||
- 옛 엔진을 지우는 걸음(2-E4)에서 옛 대조(자원 · 하위)는 은퇴.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
import json
|
||||
from functools import lru_cache
|
||||
|
||||
import helper_855_engine as h
|
||||
|
||||
mt = importlib.import_module("master_doc_trace")
|
||||
mp = importlib.import_module("master_pick")
|
||||
mm = importlib.import_module("master_material")
|
||||
|
||||
MORE = { # 새 쪽에만 더 있는 자원 키 — 까닭
|
||||
"GC001200": "옛 엔진이 빈 입력에서 멈춤 · 새는 전력 재료 이름도 셈",
|
||||
"GC001201": "옛 엔진이 빈 입력에서 멈춤 · 새는 전력 재료 이름도 셈",
|
||||
"GF000312": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈",
|
||||
"GF000313": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈",
|
||||
"GF000320": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈",
|
||||
"GF000192": "옛은 수량 빈 줄의 재료 단가를 안 읽음",
|
||||
"GF000200": "옛은 수량 빈 줄의 재료 단가를 안 읽음",
|
||||
"GF000203": "옛은 수량 빈 줄의 재료 단가를 안 읽음",
|
||||
"GF000209": "옛은 수량 빈 줄의 재료 단가를 안 읽음",
|
||||
}
|
||||
|
||||
|
||||
def sg():
|
||||
from B09_Estimation import B09_Estimation_Sangeun as mod
|
||||
|
||||
return mod
|
||||
|
||||
|
||||
def mc_calc(doc: dict, links) -> dict:
|
||||
return importlib.import_module("master_doc_calc").calc(doc, links)
|
||||
|
||||
|
||||
def _old_keys(whole, row: dict, given: dict) -> set[str]:
|
||||
seen: set[str] = set()
|
||||
base = whole.get
|
||||
|
||||
def get(ref):
|
||||
got = base(ref)
|
||||
key = str(got.get("키") or "")
|
||||
if key[:2] in mt.CAT:
|
||||
seen.add(key)
|
||||
return got
|
||||
|
||||
whole.get = get
|
||||
try:
|
||||
h.old_run(row, given)
|
||||
finally:
|
||||
del whole.get
|
||||
return seen
|
||||
|
||||
|
||||
def _strip(got: dict) -> dict:
|
||||
out = {k: v for k, v in got.items() if k not in ("부름", "자원")}
|
||||
if "줄" in out:
|
||||
out["줄"] = [{k: v for k, v in ln.items() if k != "부름"} for ln in out["줄"]]
|
||||
return out
|
||||
|
||||
|
||||
def _calls(old: dict, new: dict, docs: dict) -> tuple[set, set]:
|
||||
a = {json.dumps(v, ensure_ascii=False, sort_keys=True, default=str) for v in old.values()}
|
||||
b = set()
|
||||
for c in new["부름"]:
|
||||
if c["깊이"] != 1 or c["갈래"] != "단가산출":
|
||||
continue
|
||||
if (docs.get(str(c["부름"].get("키"))) or {}).get("결과"):
|
||||
continue # 결과 문서 = 중간 값
|
||||
one = (
|
||||
{"machine": c["기계"]}
|
||||
if "기계" in c
|
||||
else {"code": c["부름"]["키"], "given": sg()._clean_given(c["부름"].get("입력"))}
|
||||
)
|
||||
b.add(json.dumps(one, ensure_ascii=False, sort_keys=True, default=str))
|
||||
return a, b
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def survey() -> dict:
|
||||
rows, whole, docs, links = h.world()
|
||||
rows = [r for r in rows if str(r["키"]) in docs]
|
||||
for row in rows: # 재료 찾기 색인 데움(첫 찾기 때 훑은 후보 읽음 빼려고)
|
||||
h.old_run(row, h.cases(row, False)[0][1])
|
||||
trace = mt.Trace(whole, docs)
|
||||
out = {"답 다름": [], "자원": {}, "하위": {}, "품목": [], "줄": [], "옛 빈 답": set()}
|
||||
for row in rows:
|
||||
key = str(row["키"])
|
||||
doc, given = docs[key], h.cases(row, False)[0][1]
|
||||
old = _old_keys(whole, row, given)
|
||||
got = mt.calc(doc, trace)
|
||||
if _strip(got) != mc_calc(doc, links):
|
||||
out["답 다름"].append(key)
|
||||
new = set(got["자원"])
|
||||
if old != new:
|
||||
out["자원"][key] = (sorted(old - new), sorted(new - old))
|
||||
lines = sg().line_calls(whole, key, given)
|
||||
a, b = _calls(lines, got, docs)
|
||||
if a != b:
|
||||
out["하위"][key] = (sorted(a), sorted(b))
|
||||
if not lines:
|
||||
try:
|
||||
sg()._env(whole, row, sg()._clean_given(given))
|
||||
except Exception:
|
||||
out["옛 빈 답"].add(key)
|
||||
for c in got["부름"]:
|
||||
p = c["부름"]
|
||||
if c["깊이"] == 1 and "품목" in c and p.get("재료") is not None:
|
||||
env = {mm.REGION: p["지역"]} if p.get("지역") is not None else {}
|
||||
if p.get("계약종별") is not None:
|
||||
env[mm.TARIFF] = p["계약종별"]
|
||||
want = mp.priced(whole, {"단위": p.get("단위")}, p["재료"], env, None)[3]
|
||||
if want.get("품목") and want["품목"]["키"] != c["품목"]:
|
||||
out["품목"].append((key, c["이름"], want["품목"]["키"], c["품목"]))
|
||||
for ln in got.get("줄") or []:
|
||||
for i in ln["부름"]:
|
||||
if not (0 <= i < len(got["부름"])) or got["부름"][i]["깊이"] != 1:
|
||||
out["줄"].append((key, ln["이름"], i))
|
||||
return out
|
||||
|
||||
|
||||
def test_기록_켜도_셈_답_같음():
|
||||
assert survey()["답 다름"] == []
|
||||
|
||||
|
||||
def test_자원_키_옛_가로채기와_같음_다름은_까닭_목록뿐():
|
||||
got = survey()["자원"]
|
||||
assert all(not old for old, _ in got.values()), {k: v for k, v in got.items() if v[0]}
|
||||
assert sorted(got) == sorted(MORE), sorted(got)
|
||||
|
||||
|
||||
def test_하위_부름_옛_call_of_와_같음_다름은_옛_빈_답뿐():
|
||||
s = survey()
|
||||
assert set(s["하위"]) == s["옛 빈 답"], {
|
||||
k: s["하위"][k] for k in set(s["하위"]) - s["옛 빈 답"]
|
||||
}
|
||||
assert all(not old for old, _ in s["하위"].values())
|
||||
|
||||
|
||||
def test_고른_품목_줄_부름():
|
||||
s = survey()
|
||||
assert s["품목"] == []
|
||||
assert s["줄"] == []
|
||||
|
||||
|
||||
def test_기계경비_부름_기계_키_줄마다_부름():
|
||||
_, whole, docs, _ = h.world()
|
||||
got = mt.calc(
|
||||
docs["GC000337"], mt.Trace(whole, docs)
|
||||
) # 낙석방지망 — 인력 둘 · 크레인 · 재료 셋
|
||||
lines = {ln["이름"]: [got["부름"][i] for i in ln["부름"]] for ln in got["줄"]}
|
||||
crane = [c for c in lines["크레인"] if c["갈래"] == "단가산출"]
|
||||
assert [c["부름"]["키"] for c in crane] == ["GC000268"] and crane[0]["기계"][:2] == "EQ"
|
||||
assert {x["키"][:2] for c in lines["특별인부"] for x in c["자원"]} == {"LB", "QC"}
|
||||
assert [c["품목"] for c in lines["에폭시"] if "품목" in c] == [got["자원"][-1]]
|
||||
assert set(got["자원"]) >= {
|
||||
x["키"] for c in got["부름"] for x in c["자원"] if x["갈래"] != "표"
|
||||
}
|
||||
@@ -5,7 +5,6 @@
|
||||
|
||||
export const ui_locales_m1 = {
|
||||
B01_Dashboard_MasterElements: ["마스터 데이터", "Master Data"],
|
||||
M01_LogicTab: ["로직", "Logic"],
|
||||
M01_Title: ["마스터 요소", "Master Elements"],
|
||||
M01_AdminOnly: ["시스템 관리자만 볼 수 있음", "System administrators only"],
|
||||
M01_LoadFailed: ["마스터 요소를 못 읽음", "Failed to load master elements"],
|
||||
@@ -44,15 +43,7 @@ export const ui_locales_m1 = {
|
||||
M01_ProcureSearch: ["이름·규격 검색", "Find by name or spec"],
|
||||
M01_ProcureCut: ["연결 끊기", "Unlink"],
|
||||
M01_ProcureClose: ["닫기", "Close"],
|
||||
M01_PriceFind: ["가격 연결", "Link price"],
|
||||
M01_PriceTitle: ["가격 연결 고르기", "Pick price source"],
|
||||
M01_PriceCol: ["가격 연결", "Price link"],
|
||||
M01_PriceCond: ["조건 연결 (지역은 입력)", "Link by condition (region as input)"],
|
||||
M01_PriceCondName: ["이름", "Name"],
|
||||
M01_PriceCondSpec: ["규격", "Spec"],
|
||||
M01_PriceCondUsed: ["후보 조건", "Condition"],
|
||||
M01_Govt: ["관급", "Govt"],
|
||||
M01_OnlyUnlinked: ["미연결만", "Unlinked only"],
|
||||
M01_JobFind: ["직종 선택", "Pick job"],
|
||||
M01_JobTitle: ["준용 직종 고르기", "Pick substitute job"],
|
||||
M01_JobCol: ["준용", "Substitute"],
|
||||
@@ -66,7 +57,6 @@ export const ui_locales_m1 = {
|
||||
M01_MachineDetail: ["상세구분", "Detail"],
|
||||
M01_UsageTarget: ["대상", "Target"],
|
||||
M01_TableUsage: ["용도", "Usage"],
|
||||
M01_TableUsageLogicCount: ["로직 {value}개", "{value} logic rules"],
|
||||
M01_OpenLogic: ["눌러 로직 탭으로", "Click to jump to the Logic tab"],
|
||||
M01_GroupLabor: ["인력", "Labor"],
|
||||
M01_GroupMaterial: ["재료", "Materials"],
|
||||
@@ -75,7 +65,6 @@ export const ui_locales_m1 = {
|
||||
M01_GroupFactor: ["계수", "Factors"],
|
||||
M01_GroupExchange: ["환율", "Exchange rates"],
|
||||
M01_GroupRate: ["요율", "Rates"],
|
||||
M01_GroupLogic: ["단가산출 기초", "Unit-price logic"],
|
||||
B01_CalcSites_Title: ["계산 자리", "Calc sites"],
|
||||
B01_CalcSites_Desc: ["조작 중 계산 = 브라우저 · 서버 고름", "Browser or server while editing"],
|
||||
B01_CalcSites_ServerCount: ["지금 서버 {value} 줄", "{value} rows on server now"],
|
||||
|
||||
@@ -150,14 +150,6 @@ export const ui_locales_m2 = {
|
||||
"Tree updated — name already taken, saved as “{value}”",
|
||||
],
|
||||
M02_HopyoImport: ["일위대가 불러오기", "Import unit-price sheets"],
|
||||
M02_HopyoUnitTip: [
|
||||
"단위 환산 — 우리 수량 = 엑셀 수량 × 이 값",
|
||||
"Unit conversion — our qty = Excel qty × this value",
|
||||
],
|
||||
M02_HopyoUnitSame: ["단위 같음 ×1", "Same unit ×1"],
|
||||
M02_HopyoUnitLead: ["엑셀 1 {from} = 우리", "Excel 1 {from} = ours"],
|
||||
M02_HopyoUnitThick: ["두께 {n}m 로 추정", "Estimated from thickness {n}m"],
|
||||
M02_HopyoUnitEst: ["규격으로 추정", "Estimated from the spec"],
|
||||
B01_Dashboard_CardPrecombo: ["일위대가", "Unit-cost items"],
|
||||
M02_PrecomboTitle: ["일위대가", "Unit-cost items"],
|
||||
B01_Dashboard_CardSangeun: ["단가산출", "Unit-price analyses"],
|
||||
@@ -211,98 +203,15 @@ export const ui_locales_m2 = {
|
||||
M02_FindOptions: ["옵션 {n}", "{n} options"],
|
||||
// 729-3 불러오기 — 안 이은 줄 · 일위대가표 띠
|
||||
// 778-5 D-5 마법사 단가산출 줄 고름(제안 · 확인 뒤 옮김)
|
||||
M02_SkSummary: [
|
||||
"블록 {b} · 옮길 수 있음 {ok} · 고를 줄 있음 {wait} · 옮김(SK) {made} · 확인 {sure}",
|
||||
"Blocks {b} · ready {ok} · open lines {wait} · moved (SK) {made} · confirmed {sure}",
|
||||
],
|
||||
M02_SkJudge: ["다시 판정", "Re-check"],
|
||||
M02_SkJudging: ["줄 판정 중…", "Checking lines…"],
|
||||
M02_SkMove: ["확인한 것 옮기기 ({n})", "Move confirmed ({n})"],
|
||||
M02_SkMoveTip: [
|
||||
"확인한 블록만 단위 SK 로 — 서버가 M01 지금 값으로 다시 셈",
|
||||
"Only confirmed blocks become SKs — the server recalculates with current M01",
|
||||
],
|
||||
M02_SkMoved: ["옮김 {made} · 못 옮김 {bad}", "Moved {made} · not moved {bad}"],
|
||||
M02_SkFailed: ["못 옮긴 블록 {n} — 까닭 펼쳐 봄", "{n} blocks not moved — see why"],
|
||||
M02_SkSureFirst: ["확인한 블록 없음 — 블록마다 [확인]", "No confirmed block yet"],
|
||||
M02_SkSure: ["확인", "Confirm"],
|
||||
M02_SkSureTip: ["이 블록을 옮길 목록에 넣음", "Add this block to the move list"],
|
||||
M02_SkSureOff: ["고를 줄이 남음 — 줄 표에서 먼저 고름", "Lines still open — pick them first"],
|
||||
M02_SkOpen: ["줄", "Lines"],
|
||||
M02_SkSheet: ["보기", "View"],
|
||||
M02_SkNone: ["단가산출 블록 없음", "No unit-cost blocks"],
|
||||
M02_SkNoLines: ["줄 없음", "No lines"],
|
||||
// 780-2 단가산출 목록(엑셀 보기 오른쪽 · 요구 627)
|
||||
M02_SkFilter: ["거르기", "Filter"],
|
||||
M02_SkFilterAll: ["전체", "All"],
|
||||
M02_SkFilterIn: ["일위대가 안", "In unit-price sheet"],
|
||||
M02_SkFilterOut: ["일위대가 밖", "Outside unit-price sheet"],
|
||||
M02_SkFilterOpen: ["고를 줄 있음", "Open lines"],
|
||||
M02_SkColCall: ["부름", "Called by"],
|
||||
M02_SkCallIn: ["일위대가 {n} 곳", "{n} unit-price rows"],
|
||||
M02_SkCallOut: ["일위대가 밖", "Outside"],
|
||||
M02_SkSummaryIn: ["일위대가 안 {in} · 밖 {out}", "in sheet {in} · outside {out}"],
|
||||
M02_SkSureEmpty: ["줄 없음 — 옮길 것 없음", "No lines — nothing to move"],
|
||||
M02_SkUnmoved: [
|
||||
"안 옮긴 단가산출 {n}(일위대가 밖 {m})",
|
||||
"Unit-cost blocks not moved {n} (outside {m})",
|
||||
],
|
||||
M02_SkBasisTag: ["근거(참고) —", "Basis (ref) —"],
|
||||
M02_SkLeft: [
|
||||
"단가산출 확인 안 한 블록 {n} · 고를 줄 {m}",
|
||||
"Unit-cost blocks not confirmed {n} · open lines {m}",
|
||||
],
|
||||
M02_SkColBlock: ["블록", "Block"],
|
||||
M02_SkColVerdict: ["판정", "Verdict"],
|
||||
M02_SkColOurs: ["우리 금액", "Our amount"],
|
||||
M02_SkColExcel: ["엑셀 금액(참고)", "Excel amount (ref)"],
|
||||
M02_SkColBasis: ["근거", "Basis"],
|
||||
M02_SkColMade: ["만든 SK", "SK made"],
|
||||
M02_SkColGroup: ["묶음", "Group"],
|
||||
M02_SkColParam: ["매개값", "Value"],
|
||||
M02_SkColState: ["상태", "State"],
|
||||
M02_SkColHow: ["방법", "Method"],
|
||||
M02_SkColDiff: ["차(참고)", "Diff (ref)"],
|
||||
M02_SkColPick: ["고름", "Pick"],
|
||||
M02_SkBasePick: ["기준 고름", "Pick base"],
|
||||
M02_SkDrop: ["뺌", "Drop"],
|
||||
M02_SkDropWhy: ["까닭", "Reason"],
|
||||
M02_SkDropDefault: ["우리에 없음", "Not in ours"],
|
||||
M02_SkClear: ["고름 지움", "Clear"],
|
||||
M02_LeftTitle: ["안 이은 줄", "Unlinked rows"],
|
||||
M02_LeftHint: [
|
||||
"만들면 M01 · 기초 · SK 에 안 이어질 엑셀 줄 — 줄마다 이을 것을 고름 · 고른 뒤 엑셀 보기 창 [저장] 또는 호표 [수정] 생성",
|
||||
"Excel rows that would stay unlinked — pick a link per row, then save in the sheet window",
|
||||
],
|
||||
M02_LeftBand: ["안 이은 줄 {n} (호표 {h})", "Unlinked rows {n} (sheets {h})"],
|
||||
M02_LeftZero: ["안 이은 줄 0", "No unlinked rows"],
|
||||
M02_LeftUnknown: [
|
||||
"안 이은 줄 — 아직 안 셈 · [끝내기] 때 다시 셈",
|
||||
"Unlinked rows — not counted yet",
|
||||
],
|
||||
M02_LeftBlocked: ["안 이은 줄이 남아 [끝내기] 막힘", "Finish blocked — unlinked rows left"],
|
||||
M02_LeftLoose: ["고른 뒤 안 만든 호표 {n} 개는 빠짐", "{n} picked but unmade sheets are dropped"],
|
||||
M02_LeftOpen: ["안 이은 줄 고르기", "Pick unlinked rows"],
|
||||
M02_LeftCounting: ["안 이은 줄 셈 중", "Counting unlinked rows"],
|
||||
M02_LeftHopyo: ["호표", "Sheet"],
|
||||
M02_LeftSpec: ["규격", "Spec"],
|
||||
M02_LeftKind: ["갈래", "Kind"],
|
||||
M02_LeftWhy: ["까닭", "Reason"],
|
||||
M02_LeftPicked: ["고른 것", "Picked"],
|
||||
M02_LeftPick: ["고름", "Pick"],
|
||||
M02_LeftBase: ["기초", "Base"],
|
||||
M02_LeftSkGo: ["단가산출 걸음에서 확인 ▸", "Check in the Sangeun step ▸"],
|
||||
M02_LeftChoose: ["고르기", "Pick"],
|
||||
M02_HopyoKid: ["하위 제{n}호표 {key}(사본 담음)", "Sub sheet {n} {key} (copy inside)"],
|
||||
M02_HopyoKidNew: ["함께 만듦", "made together"],
|
||||
M02_HopyoKidFail: ["하위 제{n}호표 실패", "Sub sheet {n} failed"],
|
||||
M02_HopyoReused: ["같은 내용 일위대가 다시 씀", "Same unit-price reused"],
|
||||
M02_LeftFind: ["찾기", "Find"],
|
||||
M02_LeftMachine: ["기계", "Machine"],
|
||||
M02_LeftNoneTip: [
|
||||
"우리 M01 에 없음 — 엑셀 숫자 그대로 고정 줄(사용자가 고른 것으로 남음)",
|
||||
"Not in M01 — keep the Excel numbers as a fixed row",
|
||||
],
|
||||
M02_GridUnlinked: ["M01 연결 없음 {n} 줄", "{n} rows not linked to M01"],
|
||||
M02_GridLink: ["연결", "Link"],
|
||||
M02_GridLinkTitle: ["안 이은 줄 연결", "Link unlinked rows"],
|
||||
@@ -311,13 +220,6 @@ export const ui_locales_m2 = {
|
||||
"Fixed rows link to labor, material or machine only",
|
||||
],
|
||||
M02_LibUnlinked: ["안 이은 줄", "Unlinked"],
|
||||
M02_LostTitle: ["못옮김 잇기", "Link unmoved rows"],
|
||||
M02_LostHint: [
|
||||
"옛 단가산출 SK 의 남은 못옮김(보기만) — 잇기 = 마법사 단가산출 칸에서 단산{n} 블록 줄 고름 → [확인] → [확인한 것 옮기기]",
|
||||
"Unmoved rows of an old SK (view only) — link in the wizard unit-cost step: pick lines of block {n}, confirm, then move",
|
||||
],
|
||||
M02_LostZero: ["못옮김 0", "Nothing unmoved"],
|
||||
M02_ElemTitle: ["M01 요소 후보", "M01 element candidates"],
|
||||
M02_SheetIlwi: ["일위대가표", "Unit-price sheet"],
|
||||
M02_SheetList: ["단가산출표", "Price basis list"],
|
||||
M02_SheetDetail: ["단가산출 상세", "Price basis detail"],
|
||||
|
||||
@@ -5,58 +5,10 @@
|
||||
|
||||
export const ui_locales_m2_judge = {
|
||||
M02_JudgeLoading: ["판정 읽는 중", "Loading verdicts"],
|
||||
M02_JudgeHopyo: ["제{n}호표", "Item {n}"],
|
||||
M02_JudgeBlock: ["단산{n}", "Calc {n}"],
|
||||
M02_JudgeColRow: ["행", "Row"],
|
||||
M02_JudgeColName: ["엑셀 품명 · 규격", "Excel name · spec"],
|
||||
M02_JudgeColVerdict: ["1차 판정", "Verdict"],
|
||||
M02_JudgeColKind: ["갈래 · 근거", "Kind · basis"],
|
||||
M02_JudgeColPick: ["후보(여럿 고름)", "Candidates (multi)"],
|
||||
M02_JudgeColQty: ["수량", "Qty"],
|
||||
M02_JudgeColOk: ["확인", "Confirm"],
|
||||
M02_JudgeConfirm: ["확인", "Confirm"],
|
||||
M02_JudgeConfirmed: ["확인함", "Confirmed"],
|
||||
M02_JudgeConfirmAll: ["호표 제안 모두 확인", "Confirm all suggestions"],
|
||||
M02_JudgeCheck: ["검산", "Check"],
|
||||
M02_JudgeSheet: ["보기", "View"],
|
||||
M02_JudgeSolve: ["블록 풀이", "Block solve"],
|
||||
M02_JudgeWholeSk: ["단가산출 통째", "Whole unit calc"],
|
||||
M02_JudgeSection: ["맡은 절", "Section"],
|
||||
M02_JudgeNoBase: ["기초 후보 없음", "No base candidate"],
|
||||
M02_JudgeColInput: ["입력 칸", "Input"],
|
||||
M02_JudgeColValue: ["값", "Value"],
|
||||
M02_JudgeColSource: ["출처", "Source"],
|
||||
M02_JudgeNeed: ["입력 필요", "Input needed"],
|
||||
M02_JudgeConflict: ["엇갈림", "Conflict"],
|
||||
M02_JudgeDefault: ["기본", "Default"],
|
||||
M02_JudgeUser: ["사용자", "User"],
|
||||
M02_JudgeUnused: ["안 씀", "Unused"],
|
||||
M02_JudgeColGroup: ["묶음", "Group"],
|
||||
M02_JudgeColExcel: ["엑셀", "Excel"],
|
||||
M02_JudgeColOurs: ["우리", "Ours"],
|
||||
M02_JudgeColPair: ["대조", "Pair"],
|
||||
M02_JudgeOursMoney: ["우리 금액", "Our amount"],
|
||||
M02_JudgeExcelMoney: ["엑셀 금액", "Excel amount"],
|
||||
M02_JudgeExtra: ["덧 줄(엑셀만)", "Extra lines (Excel only)"],
|
||||
M02_JudgeNoCand: ["후보 없음", "No candidate"],
|
||||
M02_JudgeBlocked: ["입력 필요 칸이 남음", "Inputs still needed"],
|
||||
M02_JudgeMove: ["옮기기", "Move"],
|
||||
M02_JudgeMoveNone: ["확인한 것 없음", "Nothing confirmed"],
|
||||
M02_JudgeMoved: [
|
||||
"옮김 — 일위대가 {a} · 단가산출 {b} · 막힘 {c}",
|
||||
"Moved — items {a} · unit calcs {b} · blocked {c}",
|
||||
],
|
||||
M02_JudgeCalls: ["부름", "Called by"],
|
||||
M02_JudgeMade: ["만든", "Made"],
|
||||
M02_JudgeUnitHint: ["엑셀 1 {from} = 우리", "Excel 1 {from} = ours"],
|
||||
M02_JudgePickN: ["고를 것 {n}", "To pick {n}"],
|
||||
M02_JudgeAmountNote: [
|
||||
"금액은 참고 — 판정은 품",
|
||||
"Amounts are reference — verdict is by quantity",
|
||||
],
|
||||
M02_JudgeOutside: ["일위대가 밖", "Not called by items"],
|
||||
M02_CheckTitle: ["확인 — 제{n}호표", "Check — item {n}"],
|
||||
M02_CheckNew: ["새", "New"],
|
||||
M02_CheckImported: ["가져온 식으로 열기", "Open as imported formula"],
|
||||
M02_ToMySk: ["내 단가산출로", "To my build-ups"],
|
||||
M02_ToMySc: ["내 일위대가로", "To my unit costs"],
|
||||
@@ -68,21 +20,8 @@ export const ui_locales_m2_judge = {
|
||||
"{k} 만듦 · 단가산출 {s} · 엑셀과 {same}",
|
||||
"{k} made · build-ups {s} · vs Excel {same}",
|
||||
],
|
||||
M02_CheckNewHint: ["「새」 = 785 에서 더한 기능", "「New」 = added in 785"],
|
||||
M02_CheckApart: ["별도계상 · 품목은 프로젝트에서", "Separate · item chosen in project"],
|
||||
M02_CheckExcelPrice: ["엑셀 단가", "Excel unit price"],
|
||||
M02_CheckMoneyHint: [
|
||||
"금액 칸 위 = 엑셀 · 아래 = 우리(미리 셈 · 엑셀 1 단위)",
|
||||
"Amount top = Excel · bottom = ours (preview · per Excel unit)",
|
||||
],
|
||||
M02_CheckCount: ["제안 {a} / 줄 {m} · 확인 {c}", "Suggested {a} / lines {m} · confirmed {c}"],
|
||||
M02_CheckMake: ["일위대가 생성", "Create unit-cost item"],
|
||||
M02_CheckMakeAsk: [
|
||||
"확인한 줄 {a} · 고정 줄 {b}(엑셀 숫자 그대로) — 일위대가 생성",
|
||||
"Confirmed {a} · fixed {b} (Excel values) — create item",
|
||||
],
|
||||
M02_CheckToItem: ["구조물 조합으로", "To structure combo"],
|
||||
M02_CheckToItemHint: ["일위대가 생성 뒤 켜짐", "Enabled after the item is created"],
|
||||
M02_CheckToItemFail: ["구조물 조합 못 만듦", "Could not create structure item"],
|
||||
M02_CheckItemName: ["구조물 조합 이름", "Structure item name"],
|
||||
M02_CheckItemMake: ["만들기", "Create"],
|
||||
@@ -95,21 +34,4 @@ export const ui_locales_m2_judge = {
|
||||
"구조물 조합 「{name}」 만듦 — {path}",
|
||||
"Structure item 「{name}」 created — {path}",
|
||||
],
|
||||
M02_CheckSheet: ["엑셀 보기", "View Excel"],
|
||||
M02_CheckPick: ["고르기", "Pick"],
|
||||
M02_CheckSource: ["원문 보기", "Source"],
|
||||
M02_CheckSourceExcel: ["엑셀 인용 조항", "Excel cited clauses"],
|
||||
M02_CheckSourceOurs: ["우리 로직 출처", "Our logic source"],
|
||||
M02_CheckNone: ["없음", "None"],
|
||||
M02_CheckOption: ["옵션", "Options"],
|
||||
M02_CheckAdd: ["추가", "Add"],
|
||||
M02_CheckNoLogic: ["로직없음", "No logic"],
|
||||
M02_CheckNoLogicHint: [
|
||||
"로직없음 = 고정 줄(엑셀 숫자 그대로) · 추가 = 제안으로",
|
||||
"No logic = fixed line (Excel values) · Add = back to suggestion",
|
||||
],
|
||||
M02_CheckCompare: ["품 비교", "Qty compare"],
|
||||
M02_CheckMat: ["자재", "Materials"],
|
||||
M02_CheckNoCalc: ["셈 못 함", "Not computed"],
|
||||
M02_CheckNoLines: ["구성 줄 없음", "No lines"],
|
||||
} as const;
|
||||
|
||||
@@ -51,7 +51,6 @@ export const ui_locales_machine = {
|
||||
M01_MachineHourly: ["시간당 경비", "Hourly cost"],
|
||||
M01_MachineUse: ["사용", "Active"],
|
||||
M01_MachineShowOff: ["비활성 같이 보기", "Show inactive"],
|
||||
M01_MachineMeta: ["원문 · 구분", "Source · group"],
|
||||
M01_MachineUses: ["쓰는 곳", "Used by"],
|
||||
M01_MachineNoUses: ["쓰는 곳 없음", "Not used"],
|
||||
M01_MachineFormula: ["쓰는 계산식", "Hourly formula"],
|
||||
@@ -76,7 +75,6 @@ export const ui_locales_machine = {
|
||||
"Unsaved edits. Leave? (edits stay in the draft)",
|
||||
],
|
||||
M01_MachineNotFound: ["그 기계가 없음", "Machine not found"],
|
||||
M01_MachineReadOnly: ["읽기만 — 시스템 관리자만 고침", "Read only — system admins edit"],
|
||||
M01_MachineErrors: ["고칠 칸이 있음", "Fix the marked fields"],
|
||||
M01_MachineDetailGroup: ["상세구분", "Sub-group"],
|
||||
M01_MachineSourceNo: ["원문번호", "Source no."],
|
||||
|
||||
Reference in New Issue
Block a user