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

This commit is contained in:
2026-11-17 16:38:56 +09:00
29 changed files with 603 additions and 458 deletions
+29 -3
View File
@@ -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)
+11 -4
View File
@@ -235,7 +235,9 @@ 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]]:
@@ -246,11 +248,15 @@ def brief(keys: list[str]) -> list[dict[str, Any]]:
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:
@@ -272,7 +278,8 @@ def brief(keys: list[str]) -> list[dict[str, Any]]:
)
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}
got = {**head, "값": to_json(row.get("값")), "시간당": hour}
_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",
+11 -9
View File
@@ -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
+55 -20
View File
@@ -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)
@@ -420,9 +447,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 +457,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 +543,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["키"]),
}
+4 -1
View File
@@ -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 {
+10 -6
View File
@@ -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:
+6 -4
View File
@@ -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;
}
+4 -2
View File
@@ -2,7 +2,8 @@
GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) ·
POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) ·
PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
PUT `/{키}` 몸 {줄, 판?}(판 = 연 판 · 다르면 409 {stale, 판} · 854-1) ·
POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}.
권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404).
⚠ 등록은 `main.py`(로그인만).
@@ -30,6 +31,7 @@ class MachineBody(BaseModel):
본뜬: 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):
@@ -78,7 +80,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")
+1
View File
@@ -28,6 +28,7 @@ const TEXT = {
Back: "목록",
Close: "닫기",
Failed: "못 함",
Stale: "그 사이 다른 곳에서 바뀜 — 목록에서 다시 열어 고침",
Name_Needed: "이름 · 비어 있음",
Same: "같은 이름 · 규격 있음 — {value}",
Copied: "「{value}」 값을 복사 — 고친 뒤 [저장]",
-56
View File
@@ -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
-6
View File
@@ -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
-7
View File
@@ -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
]
+1 -1
View File
@@ -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 []
+2 -1
View File
@@ -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 -26
View File
@@ -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,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 코드는 이름만 봄(무엇을 부르는지) · 그 페이지 동작은 안 봄.
@@ -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))));
@@ -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
+9 -3
View File
@@ -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, "비목버림")
+7 -2
View File
@@ -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:
@@ -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"
-98
View File
@@ -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;