Merge remote-tracking branches 'origin/main_laptop_1' and 'origin/sub_laptop_1' into sub_laptop_6
This commit is contained in:
@@ -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",
|
||||
|
||||
@@ -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,13 @@ b09원가에서는 확인할필요 없음. 어차피 m02의정보를 가져가
|
||||
## 요구 896 (11-17 · 사용자 · 분석 894 보고 답 — 정할 것 5 번(옛 자료 · 한 번용 스크립트)은 tmp 폴더에 보관 · 나머지 항목 전체 동의 · 천천히 단계적으로 오류 없게 진행)
|
||||
|
||||
5번 tmp폴더에 보관. 나머지 항목은 전체 동의. 천천히 단계적으로 오류 없게 진행할것.
|
||||
|
||||
## 요구 897 (11-17 · 사용자 · 예상 종료 시간 물음 · 워크트리를 늘리면 빨라지는지 · 창 여덟까지 늘려도 됨 · 왜 오래 걸리는지 물음)
|
||||
|
||||
예상종료시간?
|
||||
|
||||
워크트리를 더 늘려서 진행하면 빨라질까?
|
||||
|
||||
8개 창까지는 늫려도 됨.
|
||||
|
||||
그런데 궁금한게 왜 이렇게 오래걸리는거야?
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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["이름"])["셈"]
|
||||
|
||||
@@ -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;
|
||||
|
||||
Reference in New Issue
Block a user