diff --git a/M02_MasterTemplete/M02_Logic_Standard.py b/M02_MasterTemplete/M02_Logic_Standard.py index 71f78dc4a..953cd8ba7 100644 --- a/M02_MasterTemplete/M02_Logic_Standard.py +++ b/M02_MasterTemplete/M02_Logic_Standard.py @@ -1,17 +1,20 @@ -"""M02 기준 목록 · 계산서 보기(PLAN 704-1 · 704-2 · 요구서 4장 8) — 로직 고르기 창이 읽음. +"""M02 기준 목록 · 계산서 보기(PLAN 704-1 · 704-2 · 855-C 2-C4 · 요구서 4장 8) — 로직 고르기 창. -기준 목록 = 단가산출 로직 하나를 대표 규격으로 펼친 줄(품명 · 규격 · 단위 · 금액 · 출처 · 공종). -대표 규격 = 고르기 입력 값 전부 · 표 찾기 조건으로 쓰이는 수 입력은 그 표 줄마다 값 하나(범위 줄은 -위 끝) · 그 밖 연속 값 입력은 견본 자동값(`master_auto.values`) 한 줄 · 지역 = 자동값(전국평균). -펼침 = 바탕(자동값 · 규격 축은 첫 대표 값) 한 줄 + 규격 축마다 값 하나씩 바꾼 줄(곱하지 않음 · +기준 목록 = 단가산출 기초 하나를 대표 규격으로 펼친 줄(품명 · 규격 · 단위 · 금액 · 출처 · 공종). +대표 규격 = 수식 문서 선택 변수(`선택 목록`) 값 전부 · 표 조건으로 바로 쓰이는 입력 변수는 +그 표 줄마다 값 하나(범위 줄은 위 끝) · 지역 = 문서 기본값(전국평균) 한 벌 · +바탕 = 문서 변수 기본값(`연결.값`). +펼침 = 바탕(규격 축은 첫 대표 값) 한 줄 + 규격 축마다 값 하나씩 바꾼 줄(곱하지 않음 · 바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌). -금액 = M01 엔진 식 + B09 산근 끝수(줄마다 버림 · `M02_Logic_Settle` · 근거 지식DB -`technical_info/01_임도/05_원가정보/단수처리_규칙.md`) · 최신 판 노임(마스터 판). -목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개 · 수 분) → 프로세스 메모리 + 파생 저장본 -(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 내용 지문 + `SHAPE` · 같으면 안 셈 · +금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) · +계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판). +(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.) +목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본 +(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` · +같으면 안 셈 · 셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸). 실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음. -계산서 = `master_text.lines`(줄 「석공 | 268,908 * 0.1 = 26,891」 · 비목 소계 · 계) + 같은 끝수 값. +이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫). M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인). """ @@ -26,15 +29,18 @@ from decimal import Decimal from typing import Any from common_util.common_util_derived_store import derived_key, read_derived, write_derived +from M01_MasterData import M01_MasterData_Doc as m01_doc from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs -from M02_MasterTemplete import M02_Logic_Settle as settle from M02_MasterTemplete import M02_Template_Layers as layers mf = m01.cm.mf -import master_sheet_line as msl # noqa: E402 — 계산서 줄 덧칸(714-1) · scripts 길은 `m01` 이 둠 +import master_doc as md # noqa: E402 — scripts 길은 `m01` 이 둠 +import master_doc_calc as mc # noqa: E402 +import master_doc_link as ml # noqa: E402 +import master_doc_text as mdt # noqa: E402 — 계산서 줄 글(줄 쌓기 산출근거와 같은 규칙) -SHAPE = 3 # 줄 꼴이 바뀌면 올림 — 옛 저장본을 안 씀 +SHAPE = 4 # 줄 꼴 · 셈이 바뀌면 올림 — 옛 저장본을 안 씀(4 = 855-C 문서 셈) KIND = "m02_logic_standard" REGION = "지역" # 지역 = 자동값 한 벌(정함 8) QUIET = ("해당 없음", "없음") # 규격 글에서 뺄 값 @@ -95,7 +101,7 @@ def words_of(row: dict) -> list[str]: def _range_label(table: dict, low: Any, high: Any, unit: str) -> str: - f = m01.mtx.fmt + f = mdt.eq_text if low is None: return f"{f(high)}{unit} 이하" if high is None: @@ -118,29 +124,52 @@ def _table_reps(whole: Any, ref: str, cond: str, unit: str) -> list[tuple[Any, s continue if not ranged: if isinstance(have, Decimal): - out.setdefault(have, f"{m01.mtx.fmt(have)}{unit}") + out.setdefault(have, f"{mdt.eq_text(have)}{unit}") continue low, high = have tries = [v for v in (high, low, (low or 0) + 1) if isinstance(v, Decimal)] - got = next((v for v in tries if m01.cm.mf._match(table, r, cond, v)), None) + got = next((v for v in tries if ml._match(table, r, cond, v)), None) if got is not None: out.setdefault(got, _range_label(table, low, high, unit)) return sorted(out.items()) -def axes(whole: Any, logic: dict) -> tuple[dict, list[tuple[str, list[tuple[Any, str]]]]]: - """(바탕 입력, [(입력 이름, [(값, 글) …]) …]) — 규격 축 = 지역 뺀 고르기 · 표 찾기 수 입력.""" - base = m01.mau.values(whole, logic) - finds, _ = m01.mau._uses(logic) +def _default(var: dict) -> Any: + """문서 변수 기본값(`연결.값`) — 수 글은 수로.""" + value = (var.get("연결") or {}).get("값") + if isinstance(value, str) and value.strip(): + num = mdt._dec(value) + return value if num is None else num + return value + + +def axes(whole: Any, doc: dict) -> tuple[dict, list[tuple[str, list[tuple[Any, str]]]]]: + """(바탕 입력, [(변수 열쇠, [(값, 글) …]) …]) — 규격 축 = 지역 뺀 선택 변수(`선택 목록`) · + 표 조건으로 바로 쓰이는 입력 변수(그 표 줄마다 값 하나) · 바탕 = 문서 기본값.""" + found = [ + v for v in doc.get("변수") or [] if (v.get("연결") or {}).get("갈래") in ("선택", "입력") + ] + base = {str(v["열쇠"]): _default(v) for v in found} + ids = {md.var_id(v): str(v["열쇠"]) for v in found} + finds: dict[str, list[tuple[str, str]]] = {} + for v in doc.get("변수") or []: + link = v.get("연결") or {} + if link.get("갈래") != "표": + continue + for cond, expr in (link.get("조건") or {}).items(): + node = mdt.node_of(expr) + if node and node[0] == "var" and node[1] in ids: + finds.setdefault(ids[node[1]], []).append((str(link.get("표")), cond)) out = [] - for spec in logic.get("입력") or []: - name = spec["이름"] + for var in found: + name, link = str(var["열쇠"]), var["연결"] if name == REGION: continue - unit = str(spec.get("단위") or "") - if spec.get("고르기"): + unit = str(var.get("단위") or "") + if link["갈래"] == "선택": + spec = {"이름": name, "고르기": link.get("목록") or []} labels = labor_inputs._labels(whole, spec) - reps = [(v, str(labels.get(v, m01.mtx.fmt(v) if isinstance(v, Decimal) else v))) + reps = [(v, str(labels.get(v, mdt.eq_text(v) if isinstance(v, Decimal) else v))) for v in spec["고르기"]] # fmt: skip elif name in finds: seen: dict[Any, str] = {} @@ -172,18 +201,34 @@ def _unit(logic: dict) -> str: return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit) -def _money(whole: Any, logic: dict, given: dict) -> Decimal | None: - if not str(logic.get("결과단위") or "").startswith("원"): - return None +def _links(whole: Any) -> Any: + return ml.Links(whole, m01_doc.docs()) + + +def _calc(doc: dict, links: Any, given: dict) -> dict | None: try: - got = settle.settle(whole, str(logic["키"]), m01.cm.mf.fill_empty(logic, given)) - except (m01.cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): + got = mc.calc(doc, links, given) + except Exception: # noqa: BLE001 — 계산기는 예외 없음이 원칙 · 혹시 = 못 셈 return None - return got.get("계", got.get("결과")) + return got if got.get("셈됨") else None -def _rows_of(whole: Any, logic: dict, blocked: bool) -> list[dict]: - base, ax = axes(whole, logic) +def _money(doc: dict, links: Any, given: dict) -> Decimal | None: + """돈 기초(결과단위 「원…」)의 계(돈 아닌 결과 문서 = 결과) — 못 셈 = None.""" + if not str(doc.get("결과단위") or "").startswith("원"): + return None + got = _calc(doc, links, given) + if got is None: + return None + return got.get("계") if got.get("계") is not None else got.get("결과") + + +def _rows_of(whole: Any, logic: dict, blocked: bool, links: Any = None) -> list[dict]: + doc = m01_doc.docs().get(str(logic.get("키"))) + if doc is None: + return [] + links = links or _links(whole) + base, ax = axes(whole, doc) changes: list[dict] = [{}] for name, reps in ax: changes += [{name: v} for v, _ in reps if v != base.get(name)] @@ -201,7 +246,7 @@ def _rows_of(whole: Any, logic: dict, blocked: bool) -> list[dict]: out = [] for change in changes: given = {**base, **change} - money = _money(whole, logic, given) + money = _money(doc, links, given) if change and money == 0: # 표에 없는 규격 조합(견치돌 · 뒷길이 25 따위) — 0 원 줄은 뺌 continue out.append( @@ -231,15 +276,19 @@ def _stamp() -> str: if not name.startswith("_"): sha.update(name.encode()) sha.update(hashlib.sha1(m01.cm.mmf.raw(m01.FOLDER, name)).digest()) + for path in sorted(m01_doc.folder().glob("수식_*.json")): # 수식 문서(855-C · 셈 정본) + sha.update(path.name.encode()) + sha.update(hashlib.sha1(path.read_bytes()).digest()) return sha.hexdigest() def _chunk(keys: list[str], blocked: set[str]) -> list[dict]: """일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음).""" whole = m01.loaded()[1] + links = _links(whole) out = [] for key in keys: - out += _rows_of(whole, whole.logic(key), key in blocked) + out += _rows_of(whole, whole.logic(key), key in blocked, links) return out @@ -268,23 +317,25 @@ def _make(files: dict, whole: Any, key: str) -> None: value = build(files, WORKERS) write_derived(layers.storage_root(), KIND, key, value) with _LOCK: - if _MEMO.get("whole") is whole: + if _MEMO.get("key") == key: _MEMO.update(value=value) except Exception as e: # noqa: BLE001 — 다음 요청이 다시 셈 print(f"[M02 기준 목록] 셈 실패: {e}", file=sys.stderr) finally: with _LOCK: - if _MEMO.get("whole") is whole: + if _MEMO.get("key") == key: _MEMO["job"] = None def listing() -> dict: """기준 목록 `{판, 공종, 줄, 준비}` — 메모리 → 파생 저장본 → 뒤에서 셈(그동안 빈 줄).""" files, whole = m01.loaded() + docs = m01_doc.docs() # 수식 문서를 고치면 새 묶음(같은 내용이면 같은 묶음) with _LOCK: - if _MEMO.get("whole") is not whole: + if _MEMO.get("whole") is not whole or _MEMO.get("docs") is not docs: _MEMO.clear() - _MEMO.update(whole=whole, key=derived_key(KIND, SHAPE, _stamp()), value=None, job=None) + key = derived_key(KIND, SHAPE, _stamp()) + _MEMO.update(whole=whole, docs=docs, key=key, value=None, job=None) if _MEMO["value"] is None and _MEMO["job"] is None: got = read_derived(layers.storage_root(), KIND, _MEMO["key"]) if got: @@ -312,8 +363,8 @@ def _quiet(fn) -> None: print(f"[M02 기준 목록] 데움 실패: {e}", file=sys.stderr) -def _given(whole: Any, logic: dict, change: dict) -> tuple[dict, list]: - base, ax = axes(whole, logic) +def _given(whole: Any, doc: dict, change: dict) -> tuple[dict, list]: + base, ax = axes(whole, doc) known = {name: dict(reps) for name, reps in ax} for name, value in (change or {}).items(): if name not in known: @@ -326,28 +377,19 @@ def _given(whole: Any, logic: dict, change: dict) -> tuple[dict, list]: def sheet(key: str, change: dict) -> dict: - """계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(엔진 값).""" + """계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(문서 셈).""" files, whole = m01.loaded() + doc = m01_doc.docs().get(key) try: logic = whole.logic(key) except m01.cm.mf.FormulaError as e: raise m01.StoreError(404, str(e)) from e - given, ax = _given(whole, logic, change) - filled = m01.cm.mf.fill_empty(logic, given) - got = msl.annotate(files, key, filled, m01.mtx.lines(files, key, filled)) # 줄 덧칸(714-1) - done = settle.settle(whole, key, filled) - if "결과" not in done: # 돈 로직 — 줄마다 버림(B09 산근 규칙) - settle.apply(got.get("groups") or [], m01.cm.mf.run(whole, key, filled), done) - got["계"] = done["계"] - groups = [ - { - "비목": g["비목"], - "소계": g.get("소계"), - "끝수": g.get("끝수") or "", - "줄": [{k: line.get(k) for k in ("이름", "글", "금액", *msl.KEYS)} for line in g["줄"]], - } - for g in got.get("groups") or [] - ] + if doc is None: + raise m01.StoreError(404, f"수식 문서 없음 「{key}」") + given, ax = _given(whole, doc, change) + links = _links(whole) + got = _calc(doc, links, given) or {} + money = str(doc.get("결과단위") or "").startswith("원") and "결과" not in doc return labor_inputs._num( { "키": key, @@ -357,8 +399,8 @@ def sheet(key: str, change: dict) -> dict: "출처": labor_inputs.sources(logic) or "", "판": edition(files), "입력": given, - "묶음": groups, - "계": got.get("계"), - "기준단위": got.get("기준단위"), + "묶음": mdt.sheet_groups(doc, got, links) if got and money else [], + "계": got.get("계") if money else got.get("결과"), + "기준단위": _unit(logic) or None, } ) diff --git a/docs/raw/요구_1104/설계_858_서고한벌.md b/docs/raw/요구_1104/설계_858_서고한벌.md new file mode 100644 index 000000000..87d802543 --- /dev/null +++ b/docs/raw/요구_1104/설계_858_서고한벌.md @@ -0,0 +1,221 @@ +# 설계 858 — 걸음 5 「서고 한 벌」 + +요구 896 · 898 · 899 · 2026-11-17 · sub4 · 읽기만(코드 · 자료 · 시험 안 고침). 근거 = `파일:줄`(sub_laptop_4 · 커밋 962476e69). 세기 도구 · 결과 = `tmp/s894/m858/`(끝 절). + +## 0. 한눈 요약 + +- 층 서고 종류 아홉 가운데 **단가산출 · 일위대가 둘만 한 틀**(`Store.write` + `Library_*` + `Precombo_Folders`). 구조물 조합 · 표 · 도면은 같은 `Store.write` 를 쓰나 목록 · 나무 · 번호가 따로. 내 기계 · 내 재료 · 실무자료 · 재료 고름 · 공유 요청은 저장 · 번호 · 목록 · 쓰는 곳 찾기를 **각자** 가짐. +- 같은 일 여러 벌(지금 자리 확인): 층 폴더 찾기 **5**(진짜 몸 2) · 폴더 → 층 판정 **4** · 쓰는 곳 찾기 **10**(서고 참조 4 + 자원 키 6) · 쓰기 권한 판단 **3**(+ TS 짝 1) · 파일 판 `version_of` **M02 3**(+ M01 2) · 쓰기 잠금 **4 벌** + **잠금 없는 여러 파일 쓰기 5 곳** · 번호 체계 **7 갈래** · 목록 **8**. +- 제안 = **새 틀을 만들지 않고 가장 잘 된 것을 넓힘**: 종류 표 하나(`Template_Layers` 안 · 옵션 칸) + 부품 일곱(층 폴더 · 권한 · 판 · 여러 파일 쓰기 · 번호 장부 · 쓰는 곳 색인 · 저장). 새 파일 = 지킴 시험 1 · 쓰는 곳 색인 1(`Labor_Ref` 700 줄 경계 때문에 떼어 냄) 뿐. +- 걸음 = 5-0 지킴 → 5-1 · 5-2 · 5-3(셋 병행) → 5-4 → 5-5 → 5-6 → 5-7(공유 · 판단 뒤) → 5-8 옛 코드 지움. 어림 **서버 +250 / −450 줄**. +- **지금 바로 시작해도 되는 조각** = 5-0 · 5-1 · 5-3(855 남은 걸음 · 856 · 857 과 파일 안 겹침). 실무자료 · 재료 고름은 **857 과 같이**. + +## 1. 지금 모습 + +### 1-1 종류 · 자리 · 서버 길 + +| 종류 | 저장 자리(층 폴더 안) | 층 | 서버 길(묶음) | +| --- | --- | --- | --- | +| 단가산출 SK | `sangeun/SK-######.json` + 뿌리 `sangeun_폴더.json` · `_번호.json` | 마스터 · 회사 · 개인 · 프로젝트(굳힘) | `/layers/{층}/library/{kind}` · `{kind}-tree(/paste)` · `{kind}-same(/merge /undo)` · `-tree/delete-check` · `-flat` · `-reset` · `templates/sangeun/{키}` · `sangeun/{키}/doc/*` | +| 일위대가 SC | `precombo/SC-######.json` + `precombo_폴더.json` | 같음 | 같음(종류 인자) | +| 구조물 조합(항목 · 열) | `table/구조물집계표.json`(열 · 경로 = 나무) + 뿌리 `구조물집계표조합.json`(장부) + `structure/ area/ labor/<열id>.json` | 같음 | `/items` · `/layers/{층}/tree` · `items/paste` · `personal/items/copy` · `structures/*` · `area/*` · `{kind}/{column}/clear·copy` | +| 구조물 표 · 도면 틀(양식) | `table/*.json` · `drawing/*.json` | 같음 + 프로젝트 `_initial/` | `/layers/{층}/templates(/{kind}/{name})` GET · PUT · DELETE | +| 내 기계 | `내기계/EQP{사용자}-####.json` + `내기계/_다음.json` | 개인만 | `/layers/personal/my-machines(/{키})` · `/{키}/impact` · `my-machine-lists · -find` · `machine-sheet` | +| 내 재료 | 뿌리 `개인자재.json`(한 파일 묶음 `{그룹, 원문, 줄, 마지막}`) | 개인만 | `/layers/{층}/materials(/{키})`(**`Labor_Router` 안** · 이름 안 맞음) | +| 실무자료(불러온 것) | `실무자료/HP-######.json` · `격자/` · `산근/` · `불러옴.json{번}` | 개인만 · 하루 지나면 숨김 | `/layers/{층}/hopyo*`(층 글 무시 · 늘 개인) | +| 재료 고름 | `실무자료/재료고름/<파일 지문>.json` | 개인만 | `/layers/{층}/material-picks/{fp}` | +| 공유 요청 | 회사 층 뿌리 `올리기요청.json{줄}` | 회사 | `/share-requests(/{id}/approve·reject · /seen)` | + +서버 길 수(자기 포트 `openapi.json` 읽기 · `routes.tsv`): M02 108 가운데 단가산출 · 일위대가 28 · 구조물 조합 · 표 · 도면 12 · 내 기계 9 · 내 재료 5 · 불러오기 15 · 공유 5. + +### 1-2 일마다 하는 자리 — 저장 쪽 + +| 종류 | 층 폴더 찾기 | 목록 | 폴더(나무) | 만들기 · 번호 | 저장(잠금 · 판 · 원자) | +| --- | --- | --- | --- | --- | --- | +| SK · SC | `Router_Items._root:145`(서고 길) · `Router_Layers._layer_dir:140`(templates 길) | `Router_Layers.list_layer:229` → `Layer_Index.list_rows:90` · `summaries:152` | `Precombo_Folders.view:67` · `edit:180`(**판 대조 · 잠금 없음**) | `Labor_Ref.create:385` · `next_key:367` + `_번호.json`(854-1) | `Store.write:142`(잠금 `_LOCK:80` · 판 409 · 원자) · 프로젝트 = `layers.write_template:251`(판 · **잠금 없음**) | +| 구조물 조합 | `Router_Items._root:145` | `Items.items:62` · `get_tree:219` | 표 안 경로 `Tree.apply:233` → `Store.write`(표) | `Item_Personal.create_item:44` · `Items.copy_item:140` · 장부 키 `Book.key_head:36`(`SC{회사}-` · `SP{사용자}-` · `다음`) · 도번 `Store._serial:326`(지운 번호 `_retired:339` 셈) | `Store.write`(표 · 세 파일 · `sync_combos:629`) | +| 표 · 도면 틀 | `Router_Layers._layer_dir:140` | `Layer_Index.list_rows` · `Template_Layers.list_templates:150` | 없음 | 이름 = 파일 이름(번호 없음) | `Store.write` · 프로젝트 `write_template` | +| 내 기계 | `MyMachine_Router._folder:34`(개인 고정 감쌈) + `MyMachine._user:410`(경로로 층 판정) | `MyMachine.listing` | 없음 | `MyMachine.add`(자기 `_LOCK:60` · `_다음.json`) | `update`(자기 잠금 · 판 · 원자 — 854-1) | +| 내 재료 | `Router_Items._root` + `Material_Own._personal:236` | `Material_Own.rows` | 없음 | `add`(`store._LOCK` · **모든 개인 층 최대 + 1** `_last` + 파일 `마지막`) | `update`(`store._LOCK` · **판 없음** · 원자) | +| 실무자료 | `Hopyo_Router._root:42`(개인 고정 감쌈) | `Hopyo_Store.rows:87`(하루 지난 것 숨김) | 없음 | `Hopyo_Store.save:119`(자기 `_LOCK:37` · `불러옴.json.번`) | `save`(새 키만 · 고침 없음) | +| 재료 고름 | `Hopyo_Router._root` | 없음 | 없음 | 파일 지문이 키 | `San_MatPick.write:97`(**잠금 · 판 없음** · 원자) | +| 공유 요청 | `Share_Request._company:66` + `Router_Items._root` | `listing:145` | 없음 | `uuid` | 자기 `_LOCK:47` · 원자 · 상태 409 | + +### 1-3 일마다 하는 자리 — 고침 · 둘러싼 쪽 + +| 종류 | 지우기 | 복사 · 붙여넣기 | 쓰는 곳 찾기 | 권한 | 지문 · 캐시 | 공유 | +| --- | --- | --- | --- | --- | --- | --- | +| SK · SC | 나무 `edit` → `Library_Delete.remove:166`(쓰는 줄 지움 · `_합친것` 기록 · **잠금 없음 · 앞판 되돌림** `:189`) · `Store.delete:207` | `Precombo_Folders.paste:203` → `Labor_Ref.carry:533`(못 읽는 참조 같이) · 합치기 `Library_Same_Router.merge:206`(**잠금 없음** `:261`) | `Labor_Ref.users:459`(+ `use_files:452` · 기억 `_ids_of:473`) · `Library_Delete.users:76` · `Library_Same_Router._user_index:93` · `Layer_Index._uses:185` | `Layer_Access.require:83` + `Library_Delete.can_write:40` + `Library_Same_Router._can_write:108` · 참조 위 층 규칙 `Labor_Ref.readable:146` | 판 `Store.version_of:89` · 내용 `Library_Same.finger:208` · 캐시 `Layer_Index._MEM:34` · `Labor_Ref._IDS:470` | SC 만 요청 길 · SK 는 승인 `carry` 로 딸려 감 | +| 구조물 조합 | 나무 지움 → `Store.prune_removed_structures:489` | `Item_Paste.paste:44`(층 사이) · `Items.copy_item:140` · 열끼리 `Store.copy_from:442` · `copy_pair:471` | SK 쪽에서 열 이름 `Library_Delete._columns:64` | `Router_Items._root` | `Store.version_of` | 요청 길 있음(`item`) | +| 표 · 도면 틀 | `Router_Layers.delete_layer_template:366` → `Store.delete` · `layers.delete_template:272` | 프로젝트로 `copy_templates:345` · `seed_project:390` · `reset_project:425` | 고정 표 `Store.IN_USE:58`(네 양식) | `_layer_dir` | `Template_Layers.version_of:139` | 없음 | +| 내 기계 | `MyMachine.delete`(잠금) | 없음(층 사이 안 옮김) | `MyMachine.uses:487`(SK 글 훑기) · 영향 `MyMachine_Impact` · M01 `Machine_Uses.uses:265` | `_folder` | 판 `MyMachine.version:116` · 캐시 `_MEMO:169` | 없음 | +| 내 재료 | `Material_Own.remove`(쓰는 곳 409) | 층 사이 같은 키 `carry` · `adopt` | `Material_Own.usage:143`(층 폴더 통째 글 훑기) | `_root` + `_personal` | 캐시 `_MEMO:184` | 없음 | +| 실무자료 | `Hopyo_Store.delete:167` · `Hopyo_Forget.finish:128` · 하루 지남 `sweep:148` | 없음 | 본뜬 키로 사본 걷음 `Hopyo_Forget.forget:102` | `Hopyo_Router._root` | 올린 엑셀 `Hopyo_Store.fingerprint:71` | 없음 | +| 재료 고름 | HP 지울 때 판만 | 없음 | `San_MatPick.made:248` · `uses:333` · `tally:348` | `Hopyo_Router._root` | — | 없음 | +| 공유 요청 | 없음(상태만) | 승인 = 위 두 길 | — | `_company` | — | — | + +### 1-4 같은 일 몇 벌(분석 수 → 지금 자리) + +| 일 | 분석 | 지금 | 자리 | +| --- | --- | --- | --- | +| 층 폴더 찾기(세션 → 폴더) | 4 | **5**(몸 2 + 감쌈 2 + 프로젝트 1) | `Router_Items._root:145` · `Router_Layers._layer_dir:140` · 감쌈 `Hopyo_Router._root:42` · `MyMachine_Router._folder:34` · 프로젝트 `Project_Items_Router._root:87` | +| 폴더 → 층 판정 | — | **4** | `Labor_Ref.where:77`(몸) · `MyMachine._user:410`(경로 부모 이름) · `Material_Own._personal:236`(→ `where`) · 키 → 층 `Combo_Store.where:86` | +| 쓰는 곳 찾기 | 6 | **10** | 서고 참조 4: `Labor_Ref.users:459` · `Library_Delete.users:76` · `Library_Same_Router._user_index:93` · `Layer_Index._uses:185` / 자원 키 6: `MyMachine.uses:487` · `Material_Own.usage:143` · `Labor_Spec.users:143`(규격 열) · `San_MatPick.made:248 · uses:333` · M01 `Machine_Uses.uses:265` · M01 `Doc.users:268` | +| 쓰기 권한 판단 | 여러 곳 | **3 + TS 1** | `Layer_Access.grant:61 · require:83`(몸) · `Library_Delete.can_write:40` · `Library_Same_Router._can_write:108` · TS `M02_MasterTemplete_Layer.ts:107 accessFor`(거울 시험 없음) | +| 파일 판 `version_of` | 3 | **M02 3 + M01 2** | `Store.version_of:89`(바이트) · `Template_Layers.version_of:139`(경로 · 같은 sha256[:16]) · `Item_Source.version_of:79`(JSON 정렬 — 실은 내용 지문) · M01 `Store.version_of:56` · `Doc.version_of:46` | +| 내용 지문 | 7 | 7(855 몫) + 서고 2 | 서고 쪽 `Library_Same.finger:208` · `Hopyo_Store.fingerprint:71` | +| 쓰기 잠금 | — | **4 벌** | `Store._LOCK:80`(서고 · 표 · 재료 공용 · `Lock` = 안에서 다시 잡으면 교착) · `MyMachine._LOCK:60`(RLock) · `Hopyo_Store._LOCK:37` · `Share_Request._LOCK:47` | +| 잠금 없는 쓰기 | B 5-4 · 5-5 | **5 곳** | `Precombo_Folders.edit:180`(판 대조와 쓰기 사이 열림) · `Library_Delete.remove:166` · `Library_Same_Router.merge:206 · undo:285` · `Template_Layers.write_template:251` · `San_MatPick.write:97` | +| 번호 체계 | 9 갈래(E 4-1) | 서고 **7** | SK · SC `next_key` + `_번호.json` · 장부 `Book`(`다음`) · 도번 `Store._serial`(지운 번호) · HP `불러옴.json.번` · PM 전 층 최대 + `마지막` · EQP `_다음.json` · 요청 `uuid` | +| 목록 | — | **8** | `Layer_Index.list_rows` · `Precombo_Folders.view` · `Items.items` · `MyMachine.listing` · `Material_Own.rows` · `Hopyo_Store.rows` · `Share_Request.listing` · `Combo_Store.listing:159` | + +### 1-5 storage 실측(꼴 · 개수만 · `census_storage.tsv`) + +| 층 | 수 | 폴더별 json(층 합) | 뿌리 파일 | +| --- | --- | --- | --- | +| 마스터 | 1 | drawing 5 · table 1 · report 1 · stability 2 · 구조물정의_이력 22 | `구조물정의.json` · `구조물집계표조합.json` · `calc_sites.json` | +| 회사 | 2 | table 2 · drawing 1 · 나머지 0 | `구조물집계표조합.json` 2 · `00_template_A1.json` 1(종류 폴더 밖에 놓인 양식 — 확인 거리) | +| 개인 | 6 | sangeun 15 · precombo 6 · `_합친것` 16 · table 4 · 내기계 1(`_다음` 만) · 실무자료 7 · 빈 폴더 `area drawing inputs labor material promote structure` | `구조물집계표조합.json` 4 · `sangeun_폴더` 2 · `precombo_폴더` 2 · `개인자재.json` 1 · `manifest.json` 1 · `_번호.json` 1 | + +## 2. 한 벌 틀 제안 + +### 2-1 바탕 — 이미 잘 된 것 + +- **저장** `Store.write:142` — 잠금 · 판 409 · 원자 쓰기 · 서버 정본 다시 셈(`_server:566`) · 서고 키 = 파일 이름. 한 파일 한 문서 꼴의 정본 길. +- **나무** `Precombo_Folders` — `{종류}_폴더.json{폴더, 자리}` · 종류 인자 한 벌. +- **지우기 · 합치기 · 되돌림** `Library_Delete` · `Library_Same(_Router)` — 쓰는 줄 정리 · `_합친것` 기록 · 되돌림. +- **권한** `Layer_Access` 한 벌 · **층 폴더** `Router_Items._root` 한 벌(대부분 가져다 씀). + +### 2-2 종류 표 하나(새 파일 없음 · `Template_Layers` 안 · 어림 +40) + +지금 `KINDS · LIBRARY_KINDS`(`Template_Layers:34-35`) · `Labor_Ref.PREFIX · TITLE` · `Share_Request` `Literal`(종류 글) · TS `Api_Fetch.Kind` 로 흩어진 종류 정의를 한 표로. + +| 칸(옵션) | 뜻 | SK | SC | 내 기계 | 내 재료 | 실무자료(857) | +| --- | --- | --- | --- | --- | --- | --- | +| `폴더` | 층 안 자리 | `sangeun` | `precombo` | `내기계` | 판단 1 | `실무자료` | +| `키꼴` · `머리` | 번호 꼴 | `SK-######` | `SC-######` | `EQP{사용자}-####` | `PM######`(전 층) | `HP-######` | +| `층` | 놓일 층 | 넷 | 넷 | 개인만 | 개인만 | 개인만 | +| `번호` | 장부 자리 | 층 `_번호.json` | 같음 | 같음(`_다음.json` 걷음) | 전 층 최대 + `마지막` 그대로 | `불러옴.json.번` 그대로(857) | +| `나무` | 폴더 장부 | 있음 | 있음 | 없음 | 없음 | 없음 | +| `숨김` | 하루 지나면 | — | — | — | — | 1 일 | +| `쓰는곳` | 쓰는 곳의 뜻 | 참조 `{층 주인 키}` | 같음 | 자원 키 글(`개인 EQP…`) | 자원 키 글(`PM…`) | 본뜬 키 | +| `공유` | 회사에 올리기 | 판단 2 | 있음 | 판단 2 | 판단 2 | 없음 | +| `셈` | 저장 때 서버 정본 | `Store._server` | 같음 | 시간당(`Machine_Hourly.hour`) | 없음 | 없음 | + +구조물 조합 · 표 · 도면 틀은 이미 `Store.write` 를 쓰고 번호가 표 장부와 같이 움직임 → 표에 「양식 종류」 로만 올리고 번호 · 나무는 지금 것 그대로. + +### 2-3 부품 일곱(지금 것을 넓힘) + +| 부품 | 한 벌로 삼을 것 | 걷을 것 | 어림 | +| --- | --- | --- | --- | +| ① 층 폴더 | `Router_Items._root` + 옵션 `개인만` | `Hopyo_Router._root:42` · `MyMachine_Router._folder:34` 감쌈 · `Router_Layers._layer_dir` 는 프로젝트 · 비동기 때문에 남기되 안쪽이 `access.folder` 를 같이 씀 | −10 | +| ② 층 판정 | `Labor_Ref.where:77` | `MyMachine._user:410` 의 경로 부모 이름 판정 → `where` | −10 | +| ③ 권한 | `Layer_Access` 에 `can_write(session, here)` 하나 | `Library_Delete.can_write:40` · `Library_Same_Router._can_write:108` · TS `accessFor` 는 거울 시험 붙임 | +15 / −15 | +| ④ 판 | `Store.version_of` | `Template_Layers.version_of:139` → 그것을 부름 · `Item_Source.version_of` 는 이름만 「내용 지문」 으로(855 B9-5 때) | −5 | +| ⑤ 여러 파일 쓰기 | `Store` 에 `batch()`(잠금 하나 + 앞판 되돌림 · `Library_Delete.remove:189` 의 되돌림 꼴을 옮김) · `_LOCK` → `RLock` | `Library_Delete` 되돌림 몸 · `Library_Same_Router.merge` · `undo` · `Precombo_Folders.edit` 가 `batch` 안에서 | +40 / −40 | +| ⑥ 번호 장부 | 층 `_번호.json`(854-1 · `Labor_Ref.next_key` 꼴) 을 종류 표 `번호` 칸으로 | `MyMachine._다음.json` · `MyMachine.add` 의 번호 몸 | +10 / −20 | +| ⑦ 쓰는 곳 색인 | `Labor_Ref.use_files · users · _ids_of`(파일 판 기억) 를 새 `M02_Library_Uses.py` 로 떼어 넓힘(참조 + 자원 키 두 찾기) | `Library_Delete.users` 훑기 몸 · `_user_index` · `Layer_Index._uses` · `MyMachine.uses` · `Material_Own.usage` | +120 / −150 | + +### 2-4 새로 만드는 것(가장 적게) + +- 새 파일 2 = `M02_Library_Uses.py`(⑦ · `Labor_Ref` 675 줄이라 더 못 넣음) · 지킴 시험 `test_858_shelf_golden.py`. +- 새 저장 파일 0(층 `_번호.json` 은 이미 있음). +- 새 서버 길 0 — 내 재료 길을 `Labor_Router` 에서 내 기계와 같은 라우터 묶음으로 옮김(길 글자는 그대로). + +## 3. 걸음(두 박자 — 새 틀로 옮김 → 답 전후 같음 → 다음 묶음에서 옛 코드 지움) + +| 걸음 | 무엇 | 파일(어림 줄) | 지킴 | 위험 · 막는 법 | 화면 확인 | +| --- | --- | --- | --- | --- | --- | +| **5-0 지킴 올림** | 임시 storage 견본 층(SK · SC · 항목 · 내 기계 · 내 재료 · 공유 요청)에서 길 답 지문 — 목록 · 나무 · 만들기 · 고치기 · 지우기 · 복사 · 붙여넣기 · 합치기 · 되돌림 · 쓰는 곳 · 권한 403/404 → `858_shelf_golden.json` · 동시 쓰기 시험(854-1 꼴)을 나무 · 지우기 · 합치기로 넓힘 | 새 `resources/tester/test_858_shelf_golden.py`(+ 300) | 지금 수치 그대로 통과 | 견본 짓기가 남의 시험 견본과 겹침 → 기존 `world` 픽스처(`test_m02_labor_ref`) 재사용 | — | +| **5-1 권한 한 벌** | ③ | `M02_Layer_Access.py`(+ 15) · `M02_Library_Delete.py`(− 8) · `M02_Library_Same_Router.py`(− 5) · 거울 시험(TS `accessFor` ↔ 서버) 새 1(+ 60) | 5-0 · `test_m02_layer_access` · `test_735_1` · `test_733_3_*` | 회사 관리자 · 남의 층 경우 — 5-0 의 403 지문 | 개인 · 회사 층 나무 지우기 · 중복 합치기 단추 보임 | +| **5-2 층 폴더 · 층 판정 한 벌** | ① ② | `M02_MasterTemplete_Router_Items.py`(+ 5) · `M02_MyMachine_Router.py`(− 5) · `M02_MyMachine.py`(± 10) · `M02_Material_Own.py`(± 5) | 5-0 · `test_821_*` · `test_840_4` · `test_m02_material_own` | `Hopyo_Router._root` 는 **857 몫 파일** → 여기선 안 고침 · 857 이 같은 옵션을 씀 | 개인관리 › 기계 · 자재 열기 | +| **5-3 판 한 벌 · 프로젝트 저장 잠금** | ④ + `write_template` 을 `Store._LOCK` 안에서 | `M02_Template_Layers.py`(± 10) · `M02_MasterTemplete_Store.py`(± 3) | 5-0 · `test_826_1` · `test_204_2` · `test_572` | 프로젝트 층 저장(B05 · B07 양식) — 판 값은 같은 sha256[:16] 이라 안 바뀜 | 프로젝트 양식 저장 한 번 | +| **5-4 여러 파일 쓰기 한 꼴** | ⑤ | `M02_MasterTemplete_Store.py`(+ 40) · `M02_Library_Delete.py`(− 30) · `M02_Library_Same_Router.py`(± 20) · `M02_Precombo_Folders.py`(± 5) | 5-0 동시 시험(같은 층 지우기 · 합치기 겹침 → 하나만 이김 · 파일 앞판 그대로) · `test_735_1` · `test_733_3_*` · `test_m02_precombo_folders` | `RLock` 으로 바꿈 — `Store.write` 를 잠금 안에서 부르는 길(합치기 `_rewrite:125`)이 생김 · 늦은 쓰기(`_refresh_labor`)는 잠금 밖 그대로 | 나무 지우기 · 되돌림 · 합치기 | +| **5-5 쓰는 곳 색인 한 벌** | ⑦ | 새 `M02_Library_Uses.py`(+ 120) · `M02_Labor_Ref.py`(− 60) · `M02_Library_Delete.py`(− 30) · `M02_Library_Same_Router.py`(− 20) · `M02_Layer_Index.py`(− 15) · `M02_MyMachine.py`(− 25) · `M02_Material_Own.py`(− 20) | 5-0 쓰는 곳 지문 · `test_826_1`(목록 쓰는 곳 수) · `test_840_4` · `test_848_5` | **855 L2 ⓑ 가 `Layer_Index` 를 만짐** → L2 ⓑ 뒤 또는 `Layer_Index` 몫만 L2 ⓑ 창에 | 지우기 미리 보기 쓰는 곳 · 목록 쓰는곳수 · 내 기계 쓰는 단가산출 | +| **5-6 내 기계 · 내 재료를 서고 틀로** | 종류 표(2-2) · 내 기계 번호 = 층 `_번호.json` · 옛 `내기계.json` 옮김(`MyMachine._move:97`) 걷음 · 내 재료 판 대조(+ 판단 1) · 내 재료 길을 내 기계 라우터 묶음으로 | `M02_Template_Layers.py`(+ 40) · `M02_MyMachine.py`(− 60) · `M02_MyMachine_Router.py`(+ 40) · `M02_Material_Own.py`(± 40) · `M02_Labor_Router.py`(− 50) · TS `M02_MyMachine_Api.ts` · 내 재료 화면 Api(판 칸 · ± 20) | 5-0 · `test_854_1` · `test_821_*` · `test_840_4` · `test_m02_material_own` · `test_826_2` | **`San_MyMachine.attach` 가 `MyMachine.create` 를 부름(857 몫)** → `create` 인자 · 답 꼴 그대로 | 내 기계 만들기 · 고침 · 옛 판 막힘 · 내 재료 같은 것 | +| 5-7 공유 범위(판단 2 뒤) | `Share_Request` `Literal` → 종류 표 `공유` 칸 | `M02_Share_Request.py`(± 20) · TS `ShareRequest`(± 20) | `test_706_1` | — | [회사에 올리기] | +| **5-8 옛 코드 지움** | 감쌈 · 중복 몸 · 옛 꼴 옮김 · 잠금 없는 되돌림 몸 · 화면 0 이 된 것 · 그것만 붙드는 시험 | 위 파일들(− 150 안팎) | `/openapi.json` 길 전후(뜻한 길만) · 관련 시험 전부 | — | 한 바퀴 | + +### 3-1 같이 돌릴 수 있는 묶음(파일 안 겹침) + +| 묶음 | 걸음(창) | 겹침 확인 | 앞 조건 | +| --- | --- | --- | --- | +| ㉠ | 5-0(하나) | 새 시험 파일만 | 없음 — **지금** | +| ㉡ | 5-1 · 5-2 · 5-3(셋) | Layer_Access · Library_Delete · Library_Same_Router ↔ Router_Items · MyMachine* · Material_Own ↔ Template_Layers · Store — 다름 | ㉠ | +| ㉢ | 5-4(하나) | Store · Library_* · Precombo_Folders | ㉡(5-1 의 Library_* · 5-3 의 Store) | +| ㉣ | 5-5(하나) | Labor_Ref · Library_* · Layer_Index · MyMachine · Material_Own | ㉢ · 855 L2 ⓑ | +| ㉤ | 5-6 · 5-7(둘) | MyMachine* · Material_Own · Labor_Router · Template_Layers ↔ Share_Request — 다름 | ㉣ · 판단 1 · 2 | +| ㉥ | 5-8(하나) | 전부 | ㉤ | + +꼭 차례인 까닭: +- `Library_Delete` · `Library_Same_Router` 를 5-1 · 5-4 · 5-5 셋이 만짐 → 한 걸음씩. +- `MyMachine` · `Material_Own` 을 5-2 · 5-5 · 5-6 이 만짐 → 5-2 는 판정 몸만 · 5-6 은 마지막. +- 5-4(잠금 하나)가 5-5 앞 — 쓰는 곳 색인을 지우기 · 합치기 잠금 안에서 쓰게 되므로. + +## 4. 「다시 셈 · 새로 고침」 길 열두 가지 + +| 번호 | 길(B 4-1) | 걸음 2 뒤 | 하나로 모을 수 있나 · 정리안 | +| --- | --- | --- | --- | +| ① | 자동 따라옴 `Sk_AutoRenew`(프로젝트 층 밖) | 남음(2-D 가 옛 사본 갈래만 걷음) | ②와 「값을 새로 받기」 한 뜻 — 층 따라 자동 / 손 | +| ② | [단가 갱신] `Sangeun_Copy.PRICE:40` | 남음(프로젝트 층) | 판단 3 — 이름 가름 | +| ③ | [재생성] `REGEN` | 남음 | 그대로(고친 것 버림 · 뜻 다름) | +| ④ | 알림 [확인] `Sk_AutoRenew.CONFIRM:47` | 남음 | ① 의 짝 — ① 과 같이 | +| ⑤ | 저장 때 재계산 `Store._server:566` → … `Doc_Sk.settle` | 남음(서버 정본 원칙) · 2-D 뒤 `사본` 줄임 갈래 빠짐 | 그대로 — 모든 저장이 이미 이 한 길 | +| ⑥ | 펼침 `Library_Flat.flat_doc`(읽기 · 저장 · 복사) · 초기화 `reset_doc` | 남음 · 읽기 길 펼침(`Router_Layers:275-276` `unpromote` · `flat_doc`) = 「열 때 본 문서 ≠ 파일」 | 옛 로직 줄 꼴 올림 몫이 크면 저장본 비운 뒤 읽기 길 펼침 걷음(855 2-D 와 같이 확인) | +| ⑦ | 일위대가 계산값 다시 적기 `Labor_Doc.server` · `Store._refresh_labor:596` | 남음 | ⑦ ⑧ = 「저장 뒤 딸림 갱신」 한 목록으로(`Store.write` 끝 · 5-4 의 `batch` 안) | +| ⑧ | 도면 연결표 글 `Store._refresh_drawing:588` | 남음 | 위와 같음 | +| ⑨ | 저장 전 영향 `MyMachine_Impact` | 남음 | 내 재료에도 같은 꼴(5-6 · 판단 1 과 같이) | +| ⑩ | 파생 색인 `Layer_Index` · `Logic_Standard` · 프로젝트 [재적용] · `Item_Prices.refresh` · B09 | 색인 둘 남음 · 프로젝트 쪽은 B9 걸음 몫 | 색인 무효 규칙 = 「파일 자국」 한 꼴(`Layer_Index._stamps:49` · `Logic_Standard._stamp:227` 이 각자) — 858 범위 밖 · 메모만 | +| ⑪ | `Hopyo_Relink` | 857 몫 | — | +| ⑫ | 한 번용 `*_Migrate*` | **이미 없음**(853-2 · 지금 파일 0) | — | + +같은 단추 이름이 층 따라 다른 뜻인 자리 — **[단가 갱신]**: 프로젝트 층 = 굳힌 사본을 지금 M01 값으로 다시 씀(손) · 층 서고 = 자동 따라옴이라 단추 대신 알림 [확인]. 서버가 `Sk_AutoRenew.on:55` 로 가름 · 화면 글 `formula_doc_text.ts:54` 한 벌. 정리안 = 판단 3. + +## 5. 화면 쪽 + +| 거리 | 지금 | 제안 | +| --- | --- | --- | +| 고치는 중 값 보관 | 단가산출만 sessionStorage(`line_stack_screen.ts:185 · 197` · 열쇠 `m02_sk_doc_drafts` `Sangeun_Tabs.ts:56`) · 나머지는 메모리 + 떠날 때 `confirmLeave`(11 파일) | **858 범위 밖** 권함 — 856 이 일위대가 줄 창을 줄 쌓기로 바꾸면 SC 도 같은 보관을 얻음 · 내 기계 · 내 재료는 짧은 양식이라 메모리 그대로 · 판단 5 | +| 층 전역 `setActiveLayer` | `Api_Fetch.ts:74-92` 모든 M02 부름이 `/layers/${activeLayer}` · `UI_Page.ts:162 · 345` 가 바꿈 · 되돌림 · 섞임은 `turn` 이 막음 | **858 범위 밖** 권함(화면 부름 전부가 걸림 · 효과 작음) · 5-6 에서 내 기계 · 내 재료 Api 만 「종류 + 층」 을 인자로 받는 한 함수로 | +| 권한 짝 | TS `accessFor` ↔ 서버 `Layer_Access` 거울 시험 없음 | 5-1 에서 붙임 | + +## 6. 걸음 2 · 3 · 4 와 겹침 · 차례 조건 + +| 상대 | 겹치는 파일 | 조건 | +| --- | --- | --- | +| 855 2-C1 · 2-C5 · 2-D | `Doc_Sk` · `Sangeun_Calc` · `Labor_Copy` · `Labor_Expand` · `Copy_Slim` · `Library_Flat` · `Sangeun_Copy` · `Sk_AutoRenew` | 858 은 이 파일들을 **안 고침**(⑥ 펼침 정리는 2-D 뒤 메모만) | +| 855 L2 ⓑ | `Layer_Index` · `Labor_Inputs` | 5-5 의 `Layer_Index` 몫은 L2 ⓑ 뒤 | +| 855 B9-5 | `Item_Source.version_of` | 이름 바꿈은 B9-5 몫 · 858 은 안 고침 | +| 856 화면 하나 | `Sangeun_Detail` · `LogicLab_Ho` · `line_stack_*` · 일위대가 줄 창 TS | 겹침 없음 · 고치는 중 값 보관은 856 에 맡김 | +| 857 불러오기 | `Hopyo_Router` · `Hopyo_Store` · `Hopyo_Forget` · `San_MatPick` · `San_MyMachine`(→ `MyMachine.create`) | 실무자료 · 재료 고름의 틀 옮김은 **857 안에서**(종류 표 `숨김` 칸을 씀) · 5-6 은 `create` 꼴 그대로 | +| 854 · 855 이미 끝난 것 | `MyMachine`(854-1 잠금 · 판 · 2-B2) · `Labor_Ref.next_key`(854-1) · `Machine_Hourly` | 바탕으로 씀 | + +지금 바로 시작해도 되는 조각 = **㉠ 5-0 · ㉡ 5-1 · 5-3**(855 남은 걸음 · 856 · 857 과 파일 안 겹침). 5-2 는 `MyMachine` 을 만지는 다른 일감이 없으면 같이. + +## 7. 사용자 판단 거리 · 못 본 것 + +### 7-1 판단 거리(쉬운 말) + +1. **내 재료 저장 꼴** — 지금 한 파일에 모든 줄 · 고칠 때 판 대조 없음. ㉮ 내 기계처럼 한 줄 한 파일 + 판(서고 틀과 같음 · 지금 저장본 1 개라 옛 꼴 호환 없이 바꿈) ㉯ 한 파일 그대로 + 판만 붙임(권함 — 줄이 적고 번호가 전 층에 걸쳐 있어 파일을 나눌 득이 작음). +2. **공유 범위** — 지금 [회사에 올리기] 요청은 구조물 조합 항목 · 일위대가만. 단가산출 · 내 기계 · 내 재료도 요청 길을 둘지(지금 단가산출은 일위대가 승인 때 딸려 갈 때만 올라감). +3. **[단가 갱신] 이름** — 프로젝트 층에선 손으로 새 값 받기, 층 서고에선 저절로 따라오고 알림 [확인]만 있음. ㉮ 이름을 가름(프로젝트 = 「단가 갱신」 · 층 서고 = 「새 값 확인」 · 권함) ㉯ 그대로. +4. **내 기계 · 내 재료 저장본** — 지금 내 기계 0 대(번호 파일만) · 내 재료 1 파일. 비우고 시작해도 되는지(옛 `내기계.json` 옮김 코드도 같이 걷음). +5. **고치는 중 값 보관** — 새로고침 뒤에도 고친 값이 남아야 하는 화면(지금 단가산출만) — 858 에선 안 다루고 856 에 맡겨도 되는지. +6. **실무자료 · 재료 고름** — 857(불러오기 합침) 안에서 같은 틀로 옮김(권함). + +### 7-2 못 본 것 + +- 화면 · 서버를 조작하지 않음(코드 따라가기 · 길 목록만 읽음) — 「공유 요청 승인」 · 「합치기 되돌림」 실제 동작. +- 프로젝트 층 서고(굳힌 사본)의 목록 · 쓰는 곳 — B9 걸음 몫이라 깊게 안 봄. +- M01 `Machine_Uses` · `Doc.users` 속(M01 범위). +- 회사 층 뿌리 `00_template_A1.json`(종류 폴더 밖) 이 어느 코드가 놓은 것인지. +- `Router_Layers._layer_dir` 의 프로젝트 · 직접 SQL(B 1-4) 정리 — 858 에 넣지 않음(마스터 층 ↔ 프로젝트 경계 · B 6(다) 다른 후보). + +## 세기 도구 · 결과(`tmp/s894/m858/`) + +| 파일 | 내용 | +| --- | --- | +| `defs.py` → `defs.tsv` | 서고 관련 36 파일 함수 555 개(이름 · 줄 · 길이 · 서버 길 · 독스트링 첫 줄) | +| `count.py` → `count.tsv` · `count_summary.tsv` | 일 16 갈래 정규식 자리(`파일:줄`) — 표 1-4 는 이것을 손으로 걸러 셈(이름이 같은 다른 일 뺌 — 예 `Hopyo_Excel._columns`) | +| `census_storage.py` → `census_storage.tsv` | 층 폴더 꼴 · 폴더별 json 수 · 뿌리 파일(키 이름은 `<키>` 로 가림 · 값 안 봄) | +| `openapi.json` → `routes.tsv` | 자기 포트 8006 길 목록(읽기만) · M02 108 길 묶음 | diff --git a/resources/master_data/scripts/master_doc_text.py b/resources/master_data/scripts/master_doc_text.py new file mode 100644 index 000000000..9e1696287 --- /dev/null +++ b/resources/master_data/scripts/master_doc_text.py @@ -0,0 +1,327 @@ +# -*- coding: utf-8 -*- +"""단가산출 수식 문서 셈 답 → 산출근거 글(PLAN 855-C 2-C4 · 서버 풀이 글) — 셈 안 함(답만 읽음). + +쓰는 곳 = M02 기준 목록 계산서(`M02_Logic_Standard.sheet`) · (뒤에) B09 산출근거(855 보충 B9-4). +⚠ 짝(글 규칙) — 한쪽을 고치면 다른 쪽도 · 거울 시험 `resources/tester/test_855_c4_doc_text.py`: + `A00_Common/line_stack_out.ts`(금액 줄 · 계 줄 꼴 · 수 꼴 `one` · `won` · 비목 이름) · + `ui_template/ui_template_equation.ts`(`eqText`) · + `common_util/common_util_line_stack_unit.ts`(`unitText` · `isAtom` · `moneyUnits`) · + `common_util/common_util_formula_doc_view.ts`(`offLine` — 선택으로 꺼진 줄). +금액 줄 = 「이름 : 단가 원/단위 × 수량 단위 = 금액 원」 · 묶음 줄 = 비목마다 「노무비 : …」 · + 계 = 「노무비 : 줄 + 줄 = 금액 원」 · 「합계 : 금액 원」. +수 꼴 = 화면과 같음 — 단가 · 수량 = `eqText`(소수 여섯 자리까지 · 셈 값 그대로) · + 줄 금액 = 소수 한 자리 · 비목 · 합계 = 원(셈 답의 끝수 그대로 · 여기서 자르지 않음). +옮기지 않은 것(화면만) — 식 조판(KaTeX · 수량 식은 값 하나로) · 공식 줄 · 펼침 · + 작업량 줄(846-2) · 굳은 기계 이름(847-1) · 비목곱 인수 글(848-7 · 금액은 답 그대로) · + 계 덧셈 항 = 줄 금액(화면은 묶음 줄 있는 항목 · 항이 넷 넘으면 항목 소계 — 여기는 금액만). +""" + +from __future__ import annotations + +import re +from decimal import ROUND_FLOOR, ROUND_HALF_UP, Decimal, InvalidOperation + +import master_doc as md +import master_doc_calc as mc + +COSTS = md.COSTS # 노무비 · 재료비 · 경비 +COST_SHOW = {"노무비": "노무비", "재료비": "재료비", "경비": "경 비"} +AMOUNT_UNIT = "원" +LONG_SUM = 4 +_HIDE = ("반올림", "올림", "버림") +_SAME = (("일", "인"), ("㎏", "kg"), ("ℓ", "L")) + + +# ── 수 꼴 ───────────────────────────────────────────────────────────── +def _dec(v) -> Decimal | None: + if isinstance(v, bool) or v is None: + return None + try: + d = Decimal(str(v)) if not isinstance(v, Decimal) else v + except InvalidOperation: + return None + return d if d.is_finite() else None + + +def _group(d: Decimal, places: int, keep: bool) -> str: + q = d.quantize(Decimal(1).scaleb(-places), ROUND_HALF_UP) + sign = "-" if q.is_signed() else "" # Intl 과 같음 — 0 으로 반올림된 음수 = 「-0」 + whole, _, frac = f"{abs(q):f}".partition(".") + frac = frac if keep else frac.rstrip("0") + head = f"{int(whole):,}" + return f"{sign}{head}.{frac}" if frac else f"{sign}{head}" + + +def eq_text(v) -> str: + """`eqText` — 수 = 천 단위 쉼표 · 소수 여섯 자리까지(반올림 · 끝 0 뗌) · 그 밖 = 글 그대로.""" + if v is None or v == "": + return "" + if isinstance(v, bool): + return "true" if v else "false" + d = _dec(v) + if d is None or (isinstance(v, str) and not v.strip()): + return str(v) + return _group(d, 6, False) + + +def one(v) -> str: + """줄 금액 — 소수 한 자리 꼭(「26,890.8」 · 「0.0」).""" + return _group(_dec(v) or Decimal(0), 1, True) + + +def won(v) -> str: + """비목 · 합계 — 원(JS `Math.round` = 0.5 올림).""" + d = _dec(v) or Decimal(0) + r = (d + Decimal("0.5")).to_integral_value(ROUND_FLOOR) + return eq_text(Decimal("-0") if r == 0 and d.is_signed() else r) # JS Math.round(-0.4) = -0 + + +# ── 단위 ───────────────────────────────────────────────────────────── +def unit_text(u) -> str: + """자료 단위 글 → 화면 단위(메타 단위 = 빈 글).""" + s = str(u if u is not None else "").strip() + if not s or re.search(r"따름|원문 단위 없음", s) or re.match(r"^수(\(| 또는|$)", s): + return "" + s = re.sub(r"^%\(.*\)$", "%", s) + return s.replace("10^-7", "10⁻⁷").replace("kWh", "㎾h") + + +def _same(a: str, b: str) -> bool: + return a == b or any((a == x and b == y) or (a == y and b == x) for x, y in _SAME) + + +def is_atom(n) -> bool: + """한 덩이(기호 · 수 · 칸 · 글 — 반올림 · 올림 · 버림 감싸개 안 한 덩이 포함).""" + if not n: + return False + if n[0] == "call" and n[1] in _HIDE and 1 <= len(n[2]) <= 2: + return is_atom(n[2][0]) + return n[0] in ("var", "num", "field", "str") + + +def node_of(text): + if text is None or str(text).strip() == "": + return None + try: + return md.parse(text) + except md.DocError: + return None + + +def money_units( + line: dict, price, qty, price_var: dict | None = None, sub: dict | None = None +) -> dict: + """금액 줄 단위 자리 `{price, qty, wrap}` — 수량이 식이면 괄호 · + 단가 분모가 수량 단위와 같은 뜻이면 수량 단위 글.""" + has = line.get("수량") not in (None, "") + q = unit_text(line.get("단위")) if has else "" + wrap = bool(q) and bool(qty) and not is_atom(qty) + own = next( + ( + u + for u in ( + unit_text((sub or {}).get("결과단위")), + unit_text((price_var or {}).get("단위")), + ) + if u.startswith("원") + ), # fmt: skip + None, + ) + mine = f"{AMOUNT_UNIT}/{q}" if own and q and _same(own[2:], q) else own + fallback = f"{AMOUNT_UNIT}/{q}" if q else "" + price_unit = (mine if mine is not None else fallback) if has and is_atom(price) else "" + return {"price": price_unit, "qty": q, "wrap": wrap} + + +def price_sym(line: dict) -> str | None: + n = node_of(line.get("단가")) + if not n: + return None + if n[0] == "var": + return n[1] + if n[0] == "field" and n[1][0] == "var": + return n[1][1] + return None + + +def line_name(line: dict) -> str: + """이름에 규격이 들면 한 번만(814-1).""" + name, spec = str(line.get("이름") or ""), line.get("규격") + return f"{name} {spec}".strip() if spec and spec not in name else name + + +# ── 선택으로 꺼진 줄(`offLine`) ─────────────────────────────────────── +class _Look: + """셈 답 값으로 조건만 읽음 — 계산기 한 벌(`master_doc_calc._Run.ev`) · 값은 답에서 채움.""" + + def __init__(self, doc: dict, answer: dict, links): + self.run = mc._Run(doc, links, None, (), {}) + got = answer.get("값") or {} + names = {md.var_id(v) for v in doc.get("변수") or []} + names |= {str(x.get("기호") or "") for x in doc.get("식") or []} + for name in names: # 답에 없는 값 = 모름(다시 셈하지 않음 · 화면 `evalNode` 와 같음) + have = got.get(name) + self.run.values[name] = mc.Blank("모름") if have is None else have + self.lines = {str(x.get("기호") or ""): x.get("식") for x in doc.get("식") or []} + + def value(self, n): + try: + v = self.run.ev(n, None, "") + except Exception: # noqa: BLE001 — 그림용 값 · 모르면 없음 + return None + return None if isinstance(v, (mc.Blank, mc.Stop)) else v + + def taken(self, n) -> int: + if not (n and n[0] == "call" and n[1] == "만약" and len(n[2]) == 3): + return 0 + t = self.value(n[2][0]) + return 0 if t is None else (1 if t else 2) + + def off_zero(self, n, path: frozenset = frozenset()) -> bool: + if not n: + return False + at, hop = n, 0 + while pick := self.taken(at): + at, hop = at[2][pick], hop + 1 + if hop and at[0] == "num": + return at[1] == 0 + kind = at[0] + if kind == "var": + name = at[1] + if name not in self.lines or name in path: + return False + return self.off_zero(node_of(self.lines[name]), path | {name}) + if kind in ("neg", "pct"): + return self.off_zero(at[1], path) + if kind == "bin": + if at[1] == "*": + return self.off_zero(at[2], path) or self.off_zero(at[3], path) + if at[1] == "/": + return self.off_zero(at[2], path) + if at[1] in ("+", "-"): + return self.off_zero(at[2], path) and self.off_zero(at[3], path) + return False + + def off_line(self, line: dict) -> bool: + return any(self.off_zero(node_of(line.get(k))) for k in ("수량", "단가")) + + +# ── 줄 글 ──────────────────────────────────────────────────────────── +def _num(v) -> Decimal | None: + return _dec(v) + + +def _u(text: str, unit: str) -> str: + return f"{text} {unit}" if unit else text + + +def money_lines(doc: dict, answer: dict, links) -> list[dict]: + """금액 줄마다 산출근거 조각 `{i, 이름, 비목, 단가, 수량, 금액, 단위, 글, 꺼짐, 합밖, 까닭?}` · + 묶음 줄 = 비목마다 한 조각(`비목` = 노무비 · 재료비 · 경비 · `묶음줄` 참).""" + look = _Look(doc, answer, links) + vars_ = {md.var_id(v): v for v in doc.get("변수") or []} + rows = answer.get("줄") or [] + out: list[dict] = [] + for i, line in enumerate(doc.get("금액") or []): + got = rows[i] if i < len(rows) else {} + name = line_name(line) + ps = price_sym(line) + pv = vars_.get(ps) if ps else None + link = (pv or {}).get("연결") or {} + sub = None + if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]): + try: + sub = links.doc(str(link["키"])) + except Exception: # noqa: BLE001 — 못 읽는 부름 = 단위 없이 + sub = None + mu = money_units(line, node_of(line.get("단가")), node_of(line.get("수량")), pv, sub) + qty = got.get("수량") + base = { + "i": i, + "이름": name, + "수량": _num(qty), + "단위": mu, + "꺼짐": look.off_line(line), + "합밖": bool(got.get("합밖")), + "묶음": line.get("묶음") or "", + } + tail = "" if qty is None else " × " + _u(eq_text(qty), mu["qty"]) + if got.get("까닭") and got.get("금액") is None: + why = got["까닭"] + out.append({**base, "비목": line.get("비목"), "단가": None, "금액": None, "까닭": why, + "글": f"{name} : — {why}"}) # fmt: skip + continue + if line.get("비목") == "묶음": + bundle = got.get("단가") if isinstance(got.get("단가"), dict) else {} + for c in COSTS: + part = (got.get("비목") or {}).get(c) + if _dec(part) is None or (not part and not bundle.get(c)): + continue + price = _u(eq_text(bundle.get(c)), mu["price"]) + text = f"{COST_SHOW[c]} : {price}{tail} = {one(part)} {AMOUNT_UNIT}" + out.append({**base, "비목": c, "묶음줄": True, "단가": _num(bundle.get(c)), + "금액": _num(part), "글": text}) # fmt: skip + continue + amt, price = got.get("금액"), got.get("단가") + text = f"{name} : {_u(eq_text(price), mu['price'])}{tail} = {one(amt or 0)} {AMOUNT_UNIT}" + out.append({**base, "비목": line.get("비목"), "단가": _num(price), "금액": _num(amt), + "글": text}) # fmt: skip + return out + + +def total_lines(answer: dict, lines: list[dict]) -> list[str]: + """계 줄 — 비목마다 「노무비 : 줄 + 줄 = 금액 원」(항이 넷 넘으면 금액만) · + 「합계 : 금액 원」.""" + out = [] + for c in COSTS: + terms = [ + x["금액"] + for x in lines + if x.get("비목") == c and not x["합밖"] and not x["꺼짐"] and x.get("금액") + ] + v = answer.get(c) + if _dec(v) is None: + body = "—" + elif 1 < len(terms) <= LONG_SUM: + body = f"{' + '.join(one(t) for t in terms)} = {won(v)}" + else: + body = won(v) if terms or v else "" + unit = f" {AMOUNT_UNIT}" if _dec(v) is not None and body else "" + out.append(f"{COST_SHOW[c]} : {body}{unit}") + total = answer.get("계") + out.append(f"합계 : {_u(won(total), AMOUNT_UNIT) if _dec(total) is not None else '—'}") + return out + + +def sheet_groups(doc: dict, answer: dict, links) -> list[dict]: + """공용 계산서(`A00_Common/calc_sheet.ts`) 묶음 — 비목마다 줄 + `{이름, 글 「단가 * 수량 = 금액」, 금액, 묶음, 장비, 옵션꺼짐}` · + 소계 = 셈 답 비목 값(끝수 뒤) · + 합 밖 줄 · 비목 없는 줄 = 뺌.""" + groups: dict[str, list] = {c: [] for c in COSTS} + for x in money_lines(doc, answer, links): + c = x.get("비목") + if c not in groups or x["합밖"]: + continue + mu = x["단위"] + if x.get("까닭"): + text = f"— {x['까닭']}" + else: + price = "—" if x["단가"] is None else _u(eq_text(x["단가"]), mu["price"]) + qty = "" if x["수량"] is None else " * " + _u(eq_text(x["수량"]), mu["qty"]) + text = f"{price}{qty} = {one(x['금액'] or 0)}" + groups[c].append( + { + "이름": x["이름"], + "글": text, + "금액": x["금액"], + "묶음": x["묶음"] or None, + "장비": bool(x.get("묶음줄")) or None, + "옵션꺼짐": x["꺼짐"] or None, + } + ) + return [ + {"비목": c, "소계": _num(answer.get(c)), "끝수": "", "줄": groups[c]} + for c in COSTS + if groups[c] or _dec(answer.get(c)) + ] diff --git a/resources/tester/helper_855_c4_doc_text.cjs b/resources/tester/helper_855_c4_doc_text.cjs new file mode 100644 index 000000000..2bc68737e --- /dev/null +++ b/resources/tester/helper_855_c4_doc_text.cjs @@ -0,0 +1,71 @@ +/* 855-C 2-C4 거울 헬퍼 — 산출근거 글 규칙(TS)을 Node 로 돌림(`master_doc_text.py` 짝). + * stdin = {수: [값], 단위: [글], 금액줄: [{줄, 단가변수, 부름}], 꺼짐: [{문서, 값}], 원: [수]} + * stdout = {eq: [eqText], one: [one], won: [won], 단위: [unitText], 금액줄: [moneyUnits], + * 꺼짐: [[offLine …] …], 비목: COST_SHOW, 항: LONG_SUM} + * `one` · `won` · `COST_SHOW` · `LONG_SUM` = `line_stack_out.ts` 안 정의를 그대로 읽어 돌림(내보내지 않는 값). */ +const fs = require("fs"); +const path = require("path"); +const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript")); + +const cache = new Map(); +function load(at) { + if (cache.has(at)) return cache.get(at); + const js = ts.transpileModule(fs.readFileSync(at, "utf8"), { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText; + const box = { exports: {} }; + cache.set(at, box.exports); + const need = (p) => { + if (p.endsWith(".css")) return {}; + return p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p); + }; + new Function("exports", "module", "require", js)(box.exports, box, need); + return box.exports; +} +const ROOT = path.join(__dirname, "..", ".."); +const eq = load(path.join(ROOT, "ui_template", "ui_template_equation.ts")); +const unit = load(path.join(ROOT, "common_util", "common_util_line_stack_unit.ts")); +const view = load(path.join(ROOT, "common_util", "common_util_formula_doc_view.ts")); +const stack = load(path.join(ROOT, "common_util", "common_util_line_stack.ts")); + +// line_stack_out.ts 안 정의(내보내지 않음) — 그 줄 글을 그대로 떼어 돌림 +const out = fs.readFileSync(path.join(ROOT, "A00_Common", "line_stack_out.ts"), "utf8"); +const grab = (re) => { + const m = out.match(re); + if (!m) throw new Error(`line_stack_out.ts 에서 못 찾음: ${re}`); + return m[0]; +}; +const defs = [ + grab(/const COST_SHOW: Record = \{[^}]*\};/), + grab(/const won = \(n: number\): string => [^;]*;/), + grab(/const one = \(n: number\): string =>\s*n\.toLocaleString\([^;]*;/), + grab(/const LONG_SUM = \d+;/), +].join("\n"); +const js = ts.transpileModule(`${defs}\nreturn { COST_SHOW, won, one, LONG_SUM };`, { + compilerOptions: { target: ts.ScriptTarget.ES2020 }, +}).outputText; +const local = new Function("eqText", js)(eq.eqText); + +const input = JSON.parse(fs.readFileSync(0, "utf8")); +const res = { + eq: (input.수 || []).map((v) => eq.eqText(v)), + one: (input.원 || []).map((v) => local.one(v)), + won: (input.원 || []).map((v) => local.won(v)), + 단위: (input.단위 || []).map((u) => unit.unitText(u)), + 금액줄: (input.금액줄 || []).map((x) => + unit.moneyUnits( + x.줄, + view.tryParse(x.줄.단가), + view.tryParse(x.줄.수량), + x.단가변수 || undefined, + x.부름 || null, + ), + ), + 기호: (input.금액줄 || []).map((x) => stack.priceSym(x.줄)), + 꺼짐: (input.꺼짐 || []).map((x) => + (x.문서.금액 || []).map((line) => view.offLine(line, x.값, view.lineMap(x.문서))), + ), + 비목: local.COST_SHOW, + 항: local.LONG_SUM, +}; +process.stdout.write(JSON.stringify(res)); diff --git a/resources/tester/test_704_logic_standard.py b/resources/tester/test_704_logic_standard.py index 133ed7766..fcc306ce0 100644 --- a/resources/tester/test_704_logic_standard.py +++ b/resources/tester/test_704_logic_standard.py @@ -11,10 +11,12 @@ from __future__ import annotations +import json from pathlib import Path import pytest +from M01_MasterData import M01_MasterData_Doc as m01_doc from M01_MasterData import M01_MasterData_Store as m01 from M01_MasterData.M01_MasterData_Store_Find import hit from M02_MasterTemplete import M02_Logic_Standard as st @@ -30,18 +32,20 @@ def _rows(key: str) -> list[dict]: def _given(key: str, change: dict) -> dict: whole = m01.loaded()[1] - return st._given(whole, whole.logic(key), change)[0] + return st._given(whole, m01_doc.docs()[key], change)[0] @pytest.mark.parametrize("key", THREE) -def test_줄_금액은_M01_시험_계산에_끝수만_버림(key: str) -> None: +def test_줄_금액은_M01_수식_탭_셈과_같음(key: str) -> None: + """855-C — 기준 목록 금액 = 수식 문서 셈(M01 수식 탭 미리 셈 · M02 단가산출과 같은 계산기).""" rows = _rows(key) assert rows + doc = json.loads(json.dumps(m01_doc.docs()[key], default=float)) # 화면 JSON 꼴 문서 for row in rows: - got = m01.calc(key, _given(key, row["바꿈"])) - assert got["ok"], got - gap = float(got["sums"]["계"]) - row["금액"] # 줄 · 비목 버림(B09 산근 규칙) — 최대 3 원 - assert -0.01 <= gap < 3.2, row["규격"] + given = st.labor_inputs._num(_given(key, row["바꿈"])) + got = m01_doc.preview(doc, given)["셈"] + assert got["셈됨"], row["규격"] + assert float(got["계"]) == row["금액"], row["규격"] def test_대표_규격_펼침() -> None: diff --git a/resources/tester/test_704_settle.py b/resources/tester/test_704_settle.py index 7e85217bd..2295c13a6 100644 --- a/resources/tester/test_704_settle.py +++ b/resources/tester/test_704_settle.py @@ -13,6 +13,7 @@ if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402 +from M01_MasterData import M01_MasterData_Doc as m01_doc # noqa: E402 from M01_MasterData import M01_MasterData_Store as m01 # noqa: E402 from M02_MasterTemplete import M02_Logic_Settle as st # noqa: E402 from M02_MasterTemplete import M02_Logic_Standard as ls # noqa: E402 @@ -39,7 +40,7 @@ def test_줄마다_버림_비목마다_버림_B09와_같음(): for row in data.get("줄") or []: if not _plain(row) or checked >= 60: continue - base, _ = ls.axes(whole, row) + base, _ = ls.axes(whole, m01_doc.docs()[row["키"]]) given = mf.fill_empty(row, base) got = mf.run(whole, row["키"], given) lines = [] @@ -70,6 +71,5 @@ def test_계산서_줄_소계_계가_맞물림(): assert group["소계"] == int(group["소계"]) assert group["소계"] <= sum(lines) < group["소계"] + 1 + Decimal("0.05"), group["비목"] assert got["계"] == sum(g["소계"] for g in got["묶음"]) - assert got["계"] == ls._money( - whole, whole.logic(key), ls._given(whole, whole.logic(key), {})[0] - ) + doc = m01_doc.docs()[key] # 855-C 계산서 = 문서 셈(목록 금액과 같은 값) + assert got["계"] == ls._money(doc, ls._links(whole), ls._given(whole, doc, {})[0]) diff --git a/resources/tester/test_714_1_sheet_line.py b/resources/tester/test_714_1_sheet_line.py index a317f93e4..61cbf574f 100644 --- a/resources/tester/test_714_1_sheet_line.py +++ b/resources/tester/test_714_1_sheet_line.py @@ -1,5 +1,5 @@ -"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) · M01 `/text` 와 -M02 `/logic-lib/sheet` 가 같은 줄 꼴(`master_sheet_line`).""" +"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) — M01 `/text`. +(M02 `/logic-lib/sheet` 는 855-C 부터 문서 셈 · `master_doc_text` 글 — `test_855_c4_doc_text`.)""" from __future__ import annotations @@ -11,10 +11,8 @@ sys.path.insert(0, str(ROOT)) from M01_MasterData import M01_MasterData_Store as store # noqa: E402 from M01_MasterData import M01_MasterData_Store_Sheet as sheet # noqa: E402 -from M02_MasterTemplete import M02_Logic_Standard as standard # noqa: E402 msl = sheet.msl -num = standard.labor_inputs._num # Decimal → JSON 수(두 길 같은 규칙) def _text(key: str) -> dict: @@ -61,15 +59,3 @@ def test_basis_note_tenfold(): assert one[0]["기준단위"] == "10㎡" and one[0]["환산근거"] == "10㎡당 → 1㎡당 ÷10" ten = _text("GF000124") assert ten["기준단위"] == "10㎡" and all(not x["환산근거"] for x in _lines(ten)) - - -def test_two_routes_same_shape(): - """M01 `/text` 와 M02 계산서 — 줄 차례 · 덧칸 값이 같음(금액 끝수만 다를 수 있음).""" - for key in ("GF000169", "GF000103", "GF000219"): - m01 = _lines(_text(key)) - m02 = _lines(standard.sheet(key, {}), "묶음") - assert len(m01) == len(m02) - for a, b in zip(m01, m02): - assert set(b) == {"이름", "글", "금액", *msl.KEYS} - assert a["이름"] == b["이름"] - assert num([a.get(k) for k in msl.KEYS]) == [b.get(k) for k in msl.KEYS] diff --git a/resources/tester/test_855_c4_doc_text.py b/resources/tester/test_855_c4_doc_text.py new file mode 100644 index 000000000..b94225ef2 --- /dev/null +++ b/resources/tester/test_855_c4_doc_text.py @@ -0,0 +1,155 @@ +"""855-C 2-C4 지킴 — 서버 산출근거 글(`master_doc_text`) · 기준 목록 · 계산서가 문서 셈. + +① 거울 — 글 규칙이 화면 TS 와 같음(헬퍼 `helper_855_c4_doc_text.cjs`): + 수 꼴(`eqText` · 줄 금액 · 원) · 단위 글(`unitText`) · 금액 줄 단위 자리 · 단가 기호 + (`moneyUnits` · `priceSym`) · 선택으로 꺼진 줄(`offLine`) · 비목 이름 — 실제 M01 수식 문서 전부 + (기본 입력 셈 답)로. +② 계산서 — 줄 금액 · 소계 · 계 = 문서 셈 답 그대로 · 소계 합 = 계 · + 줄 글 「단가 원/단위 * 수량 단위 = 금액」. +③ 기준 목록 줄 금액 = 같은 입력의 문서 셈 계. +""" + +from __future__ import annotations + +import importlib +import json +import os +import subprocess +from decimal import Decimal +from functools import lru_cache + +import pytest + +from M01_MasterData import M01_MasterData_Doc as m01_doc +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Logic_Standard as st + +mc = importlib.import_module("master_doc_calc") +md = importlib.import_module("master_doc") +mdt = importlib.import_module("master_doc_text") + +HERE = os.path.dirname(os.path.abspath(__file__)) +NUMS = [0, 1, -1, 0.5, 1.5, 2.5, -2.5, 0.05, 0.15, 0.25, 0.35, 1.05, 1.15, 1.25, 2.675, 99.95, + -0.05, 0.1 + 0.2, 1e-7, 1234567.891234567, 59018.0857142857, 284.42142857142, + 123456789012.345, 26890.75, 1502.04999] # fmt: skip + + +def _js(v): + if isinstance(v, Decimal): + return float(v) + if isinstance(v, dict): + return {k: _js(x) for k, x in v.items()} + if isinstance(v, (list, tuple)): + return [_js(x) for x in v] + if isinstance(v, (mc.Blank, mc.Stop)): + return None + return v + + +@lru_cache(maxsize=1) +def world(): + """(문서들, 연결, {키: 기본 셈 답}).""" + whole = m01.loaded()[1] + docs = m01_doc.docs() + links = st._links(whole) + answers = {k: mc.calc(d, links, None) for k, d in docs.items() if d.get("금액")} + return docs, links, answers + + +def _helper(payload: dict) -> dict: + run = subprocess.run( + ["node", os.path.join(HERE, "helper_855_c4_doc_text.cjs")], + input=json.dumps(payload, ensure_ascii=False), + capture_output=True, + text=True, + encoding="utf-8", + check=True, + ) + return json.loads(run.stdout) + + +@lru_cache(maxsize=1) +def mirror(): + docs, links, answers = world() + nums, units, lines, offs, py = list(NUMS), set(), [], [], {"단위": [], "줄": [], "꺼짐": []} + for key, a in answers.items(): + doc = docs[key] + vars_ = {md.var_id(v): v for v in doc.get("변수") or []} + units |= {str(v.get("단위") or "") for v in doc.get("변수") or []} + units.add(str(doc.get("결과단위") or "")) + for row in a.get("줄") or []: + nums += [_js(row.get(k)) for k in ("단가", "수량", "금액")] + for line in doc["금액"]: + units.add(str(line.get("단위") or "")) + sym = mdt.price_sym(line) + pv = vars_.get(sym) if sym else None + link = (pv or {}).get("연결") or {} + sub = None + if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]): + got = links.doc(str(link["키"])) + sub = {"결과단위": got.get("결과단위")} if got else None + lines.append({"줄": _js(line), "단가변수": _js(pv), "부름": sub}) + nodes = (mdt.node_of(line.get("단가")), mdt.node_of(line.get("수량"))) + py["줄"].append((mdt.money_units(line, *nodes, pv, sub), sym)) + look = mdt._Look(doc, a, links) + vals = {k: v for k, v in (a.get("값") or {}).items() if v is not None} + part = {"식": _js(doc.get("식") or []), "금액": _js(doc["금액"])} + offs.append({"문서": part, "값": _js(vals)}) + py["꺼짐"].append([look.off_line(line) for line in doc["금액"]]) + nums = [x for x in nums if isinstance(x, (int, float))] + units |= {"%(인력품 대비)", "10^-7/시간", "kWh/hr", "줄 따름", "수(개)", "원문 단위 없음"} + units = sorted(units) + ts = _helper({"수": nums, "원": nums, "단위": units, "금액줄": lines, "꺼짐": offs}) + return nums, units, py, ts + + +def test_수_꼴_eqText_한자리_원(): + nums, _, _, ts = mirror() + assert len(nums) > 5000 + assert [mdt.eq_text(v) for v in nums] == ts["eq"] + assert [mdt.one(v) for v in nums] == ts["one"] + assert [mdt.won(v) for v in nums] == ts["won"] + texts = ("5401-0017", "", " ", "1048") + assert [mdt.eq_text(v) for v in texts] == ["5401-0017", "", " ", "1,048"] + + +def test_단위_글_금액줄_단위_자리_단가_기호(): + _, units, py, ts = mirror() + assert [mdt.unit_text(u) for u in units] == ts["단위"] + assert len(py["줄"]) > 5000 + assert [u for u, _ in py["줄"]] == ts["금액줄"] + assert [s for _, s in py["줄"]] == ts["기호"] + assert any(u["wrap"] for u, _ in py["줄"]) and any(u["price"] for u, _ in py["줄"]) + + +def test_선택으로_꺼진_줄_비목_이름(): + _, _, py, ts = mirror() + assert py["꺼짐"] == ts["꺼짐"] + assert sum(map(sum, py["꺼짐"])) > 0 # 꺼진 줄이 실제로 있음(판정이 일을 함) + assert mdt.COST_SHOW == ts["비목"] and mdt.LONG_SUM == ts["항"] + + +@pytest.mark.parametrize("key", ("GF000220", "GF000089", "GC000404", "GF000101")) +def test_계산서_문서_셈_답_그대로(key): + got = st.sheet(key, {}) + docs, links, _ = world() + answer = mc.calc(docs[key], links, st._given(m01.loaded()[1], docs[key], {})[0]) + assert got["계"] == float(answer["계"]) and got["계"] == sum(g["소계"] for g in got["묶음"]) + for g in got["묶음"]: + assert g["소계"] == float(answer[g["비목"]]) + for line in g["줄"]: + assert line["글"].endswith(f"= {mdt.one(line['금액'] or 0)}") + assert " * " in line["글"] or line["글"].startswith("—") + first = got["묶음"][0]["줄"][0] + if key == "GF000220": # 석공 노임 — 「268,908 원/인 * 0.1 인 = 26,890.8」 + assert first["이름"] == "석공" and first["글"].startswith("268,908 원/인 * 0.1 인 = ") + + +def test_기준_목록_금액_문서_셈(): + whole = m01.loaded()[1] + docs, links, _ = world() + for key in ("GF000220", "GC000404", "GX000004"): + for row in st._rows_of(whole, whole.logic(key), False, links): + given = st._given(whole, docs[key], row["바꿈"])[0] + want = mc.calc(docs[key], links, given) + assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"])