From ba6f25b9712e6a53de864831c09a36c71809e782 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:00:36 +0900 Subject: [PATCH 1/6] =?UTF-8?q?fix(854-2):=20M01=20=ED=82=A4=20=EB=8C=80?= =?UTF-8?q?=EC=9E=A5=20=EC=93=B0=EA=B8=B0=20=EC=9B=90=EC=9E=90=EC=A0=81=20?= =?UTF-8?q?=C2=B7=20=ED=8C=8C=EC=9D=BC=20=EC=93=B0=EA=B8=B0=20=EC=A4=91?= =?UTF-8?q?=EA=B0=84=20=EC=8B=A4=ED=8C=A8=20=EB=95=8C=20=EB=8C=80=EC=9E=A5?= =?UTF-8?q?=20=C2=B7=20=ED=8C=8C=EC=9D=BC=20=EC=A0=80=EC=9E=A5=20=EC=A0=84?= =?UTF-8?q?=EC=9C=BC=EB=A1=9C=20=EB=90=98=EB=8F=8C=EB=A6=BC=20=E2=80=94=20?= =?UTF-8?q?=EB=AC=B6=EC=9D=8C=20=E2=91=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - master_keys.save_book = 임시 파일 → 교체(반쪽 대장 없음 · 빌더도 같은 길) - Store_Save.save = 대장 → 파일 차례 그대로 · 파일 쓰기가 끊기면 쓴(쓰려던) 파일 · 기계 대 · 대장을 저장 전 글로(대장만 앞서가지 않음) - 시험 test_854_2_m01_key_book — 첫 파일 · 둘째 파일(반쯤 쓴 뒤) 끊김 = 바이트 그대로 · 끊김 없음 = 대장 · 파일 같이 감 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Store_Save.py | 42 ++++++- resources/master_data/scripts/master_keys.py | 5 +- resources/tester/test_854_2_m01_key_book.py | 113 +++++++++++++++++++ 3 files changed, 155 insertions(+), 5 deletions(-) create mode 100644 resources/tester/test_854_2_m01_key_book.py diff --git a/M01_MasterData/M01_MasterData_Store_Save.py b/M01_MasterData/M01_MasterData_Store_Save.py index 9adb408a7..877a96b9d 100644 --- a/M01_MasterData/M01_MasterData_Store_Save.py +++ b/M01_MasterData/M01_MasterData_Store_Save.py @@ -116,16 +116,50 @@ def save(batch: list[dict]) -> list[dict]: new = [x for x in new + cache.labor_errors(fresh, gone) if x not in old] if new: raise store.StoreError(422, {"errors": new}) - if book["다음"] != issued: - mk.save_book(book, book_path) - out = [{"file": name, "version": _write(name, before[name], after[name])} for name in names] + # 대장(원자적) → 파일 · 중간에 끊기면 쓴 것 모두 저장 전으로(대장만 · 파일만 앞서가지 않게) + raw = {n: (store.FOLDER / n).read_bytes() for n in names if not _machine(n)} + book_raw = book_path.read_bytes() if book["다음"] != issued else None + tried: list[str] = [] + try: + if book_raw is not None: + mk.save_book(book, book_path) + out = [] + for name in names: + tried.append(name) + out.append({"file": name, "version": _write(name, before[name], after[name])}) + except BaseException: + _undo(tried, before, after, raw, book_path, book_raw) + raise # 저장 뒤 — 쓴 파일만 기억에 갈아 끼우고 흔들린 자리를 알려 줘 그 줄만 다시 세게 cache.adopt(store.FOLDER, after, fresh, names, narrowed[2]) return out +def _machine(name: str) -> bool: + return name == mmf.NAME and mmf.here(store.FOLDER) # 기계 = 폴더(826-2) + + +def _put(path, raw: bytes) -> None: + tmp = path.with_name(f".{path.name}.tmp") + tmp.write_bytes(raw) + os.replace(tmp, path) + + +def _undo(names, before, after, raw, book_path, book_raw) -> None: + """쓰기 중간 실패 — 쓴(쓰려던) 파일 · 대장을 저장 전 글로 되돌림.""" + for name in names: + if _machine(name): + mmf.write( + store.FOLDER, before[name], after[name] + ) # 바뀐 · 더한 · 지운 대를 저장 전으로 + else: + _put(store.FOLDER / name, raw[name]) + if book_raw is not None: + _put(book_path, book_raw) + + def _write(name: str, before: dict, after: dict) -> str: - if name == mmf.NAME and mmf.here(store.FOLDER): # 기계 = 바뀐 대 파일만(826-2) + if _machine(name): # 기계 = 바뀐 대 파일만(826-2) mmf.write(store.FOLDER, after, before) return store.version(name) path = store.FOLDER / name diff --git a/resources/master_data/scripts/master_keys.py b/resources/master_data/scripts/master_keys.py index f8511f70b..e0c205ee6 100644 --- a/resources/master_data/scripts/master_keys.py +++ b/resources/master_data/scripts/master_keys.py @@ -7,6 +7,7 @@ from __future__ import annotations import json +import os import re from decimal import Decimal from pathlib import Path @@ -77,7 +78,9 @@ def save_book(book: dict, path: Path = BOOK) -> None: comma = "," if i < len(items) - 1 else "" lines.append(f" {json.dumps(key)}: {json.dumps(v, ensure_ascii=False)}{comma}") lines += [" }", "}"] - path.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n") + tmp = path.with_name(f".{path.name}.tmp") # 임시 파일 → 교체(원자적 · 끊겨도 반쪽 대장 없음) + tmp.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n") + os.replace(tmp, path) def lookup(book: dict) -> dict: diff --git a/resources/tester/test_854_2_m01_key_book.py b/resources/tester/test_854_2_m01_key_book.py new file mode 100644 index 000000000..aa3c1a97a --- /dev/null +++ b/resources/tester/test_854_2_m01_key_book.py @@ -0,0 +1,113 @@ +"""M01 저장 안전(PLAN 854-2 · 요구 894 걸음 1) — 마스터 사본 폴더에서만 씀. + +- 키 대장 · 파일 쓰기: 중간에 끊겨도 대장 · 파일이 저장 전 그대로(대장만 앞서가지 않음). +""" + +from __future__ import annotations + +import json +import shutil +from pathlib import Path + +import pytest + +from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Save as save_mod + +REAL = store.FOLDER +OWN = "로직_자체.json" +MACHINE = "EQ000002" +LABOR = "LB000002" # 보통인부 + + +@pytest.fixture +def master(tmp_path: Path, monkeypatch) -> Path: + for path in REAL.glob("*.json"): + if not path.name.startswith("_") or path.name == store.mk.BOOK.name: + shutil.copy(path, tmp_path / path.name) + shutil.copytree(REAL / "기계", tmp_path / "기계") + monkeypatch.setattr(store, "FOLDER", tmp_path) + return tmp_path + + +def _bytes(folder: Path) -> dict[str, bytes]: + out = {p.name: p.read_bytes() for p in folder.glob("*.json")} + out |= {f"기계/{p.name}": p.read_bytes() for p in (folder / "기계").glob("*.json")} + return out + + +def _new_logic() -> dict: + return { + "op": "add", + "row": { + "원문번호": "", + "구분": "자체", + "상세구분": "", + "소유": "현장", + "이름": "sub5임시 대장 시험", + "결과단위": "원/㎡", + "출처": "자체", + "입력": [], + "중간": [], + "호표": [ + { + "종류": "인력", + "요소": LABOR, + "이름": "보통인부", + "단위": "인", + "수량": "1 / 7", + "비목": "노무비", + } + ], + "덧줄": [], + "끝수": None, + }, + } + + +def _batch() -> list[dict]: + """기계 한 대 고침(기계 폴더) + 자체 로직 새 줄(GX 키 발급 = 대장 바뀜).""" + machine = json.loads((store.FOLDER / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8")) + machine["비고"] = "sub5임시" + return [ + { + "file": "기계.json", + "version": store.version("기계.json"), + "changes": [{"op": "edit", "key": MACHINE, "row": machine}], + }, + {"file": OWN, "version": store.version(OWN), "changes": [_new_logic()]}, + ] + + +@pytest.mark.parametrize("fail_at", [0, 1]) +def test_파일_쓰기가_끊기면_대장과_파일이_저장_전_그대로( + master: Path, monkeypatch, fail_at +) -> None: + before = _bytes(master) + real = save_mod._write + calls = [] + + def broken(name, was, now): + calls.append(name) + if len(calls) - 1 == fail_at: + if fail_at: # 둘째 파일은 쓴 뒤에 끊김(반쯤 쓴 꼴) + real(name, was, now) + raise OSError("디스크 흉내 실패") + return real(name, was, now) + + monkeypatch.setattr(save_mod, "_write", broken) + with pytest.raises(OSError): + store.save(_batch()) + after = _bytes(master) + assert after == before # 대장 · 기계 · 로직 파일 모두 저장 전 글 그대로 + assert not list(master.glob(".*.tmp")) and not list((master / "기계").glob(".*.tmp")) + + +def test_끊김_없으면_대장과_파일이_같이_간다(master: Path) -> None: + book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("GX", 1) + store.save(_batch()) + book = store.mk.load_book(master / store.mk.BOOK.name) + keys = [r["키"] for r in json.loads((master / OWN).read_text(encoding="utf-8"))["줄"]] + assert f"GX{book_before:06d}" in keys and book["다음"]["GX"] == book_before + 1 + machine = json.loads((master / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8")) + assert machine["비고"] == "sub5임시" From e371b431654f7763e41646299c877177e5f1ff27 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:31:55 +0900 Subject: [PATCH 2/6] =?UTF-8?q?chore(853-3):=20853-1=20=C2=B7=20853-2=20?= =?UTF-8?q?=EA=B0=80=20=EB=84=98=EA=B8=B4=20=EA=B2=83=20=EA=B1=B7=EC=9D=8C?= =?UTF-8?q?=20=E2=80=94=20=EB=AC=B6=EC=9D=8C=20=E2=91=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 껍데기 M01_MasterData_UI_Logic_Money.ts 지움 — M02 네 파일(Labor_Diagram · LogicMats · MatTable · Rows) import 를 공용 common_util_money 로 - M01 Parts.of_machine(비시험 0) · Equation.links(비시험 0 · Doc.candidates 와 같은 함수) 지움 · 시험 813-2 해당 줄 뺌 · 800-2 = Doc.candidates 로 - 공용 사전 죽은 M01_ 키 13(locale_m1 11 · locale_machine 2 — 저장소 전체 낱말 0 · 조립 키 0) 지움 - 길 POST /layers/{층}/my-machines/draft(화면 0) + 몸 칸 키 · 표지 지움 · 서버 길 481 → 480 · 시험 827-1 남의 층 403 = 만들기 길로 봄 - 남김: Equation.export_row — 비시험 0 이나 시험 796-1 · 800-2 의 수식 모델(옛 엔진 · edit_row 왕복) 바탕 → 옛 엔진 은퇴(걸음 2)와 같이 · MyMachine_Draft.check — 시험 827-1 이 미리 셈 · 저장 셈과 맞대는 기준값 - typecheck 0 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Equation.py | 8 +------- M01_MasterData/M01_MasterData_Parts.py | 13 ------------- M01_MasterData/M01_MasterData_UI_Logic_Money.ts | 11 ----------- .../M02_MasterTemplete_Labor_Diagram.ts | 2 +- .../M02_MasterTemplete_Labor_LogicMats.ts | 2 +- .../M02_MasterTemplete_Labor_MatTable.ts | 2 +- .../M02_MasterTemplete_Labor_Rows.ts | 2 +- M02_MasterTemplete/M02_MyMachine_Router.py | 15 +-------------- resources/tester/test_800_2_equation_layout.py | 7 ++++--- resources/tester/test_813_2_parts.py | 4 ---- resources/tester/test_827_1_machine_window.py | 2 +- ui_template/ui_template_locale_m1.ts | 11 ----------- ui_template/ui_template_locale_machine.ts | 2 -- 13 files changed, 11 insertions(+), 70 deletions(-) delete mode 100644 M01_MasterData/M01_MasterData_UI_Logic_Money.ts diff --git a/M01_MasterData/M01_MasterData_Equation.py b/M01_MasterData/M01_MasterData_Equation.py index 53906fd4a..2e67c9895 100644 --- a/M01_MasterData/M01_MasterData_Equation.py +++ b/M01_MasterData/M01_MasterData_Equation.py @@ -3,7 +3,7 @@ 모델 = `scripts/master_equation.py`(나무 · 변수 표) · `master_equation_edit.py`(고침 · 검사) · 키보드 글 번역 · 상한 = M02 단가산출 식 칸과 한 벌(`M02_Sangeun_Formula` 불러 씀 · 고치지 않음) · 셈 = 엔진 한 벌(③ 서버 단독 · 브라우저 값 받아 적지 않음) · 저장 = 기존 M01 `/save`(개정확인) · -M02 사본(795-1)은 `export_row` · `edit_row` 를 사본 줄로 부름 · 시험 `test_796_1_formula_model.py`. +M02 사본(795-1)은 `edit_row` 를 사본 줄로 부름 · `export_row` 는 시험(796-1 · 800-2)의 수식 모델 바탕(옛 엔진 은퇴 때 같이). """ from __future__ import annotations @@ -15,7 +15,6 @@ from M01_MasterData import M01_MasterData_Store as store _ERR = (store.cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) import master_equation as meq # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤 -import master_equation_link as link # noqa: E402 import master_equation_edit as me # noqa: E402 @@ -56,8 +55,3 @@ def edit_row(whole, row: dict, edits: list) -> tuple[dict, list[str]]: """고침 → (새 줄, 까닭) — 까닭 있으면 저장 안 됨(M01 · M02 사본 같은 함수).""" new, why, _ = me.apply(whole, row, edits, words) return new, why - - -def links(ask: dict) -> dict: - """새 기호 연결 후보(800-3) — {갈래: 표 | 요소 | 로직, 검색, 분류?} → {후보, 더있음} · 읽기만.""" - return link.candidates(store.loaded()[1], ask) diff --git a/M01_MasterData/M01_MasterData_Parts.py b/M01_MasterData/M01_MasterData_Parts.py index d3267715c..451fba9c8 100644 --- a/M01_MasterData/M01_MasterData_Parts.py +++ b/M01_MasterData/M01_MasterData_Parts.py @@ -5,7 +5,6 @@ 틀 = `_수식문서_틀.md` 9 장. - 단가산출 기초 목록 · 찾아 넣기 「다른 단가산출」 목록에서 뺌(`strip`) — 키로 열기 · 셈 · 부르기는 그대로 - 기종 → 그 기종 기계가 쓰는 기계경비식 · 작업량 틀(`of_kind` · M01 「기계」 화면) -- 기계 원문번호 → 그 기종 작업량 틀 문서(`of_machine` · 줄 쌓기 기계 넣기) 쓰기 없음 · 로그인 사용자 모두(마스터 읽기). """ @@ -75,15 +74,3 @@ def of_kind(group: str, detail: str = "") -> dict[str, list]: used[str(got["키"])] = used.get(str(got["키"]), 0) + 1 rule = [{**_brief(k, docs[k]), "기계수": n} for k, n in used.items() if k in docs] return {"기계경비식": rule, "작업량 틀": [_brief(k, d) for k, d in _templates(detail)]} - - -def of_machine(no: str) -> dict[str, Any]: - """줄 쌓기 기계 넣기 — 기계 원문번호 → {기계 {이름 · 규격 · 상세구분}, 틀 [{… 문서}]}.""" - row = next((m for m in _machines() if str(m.get("원문번호")) == str(no)), None) - if not row: - raise store.StoreError(404, f"없는 기계 「{no}」") - kind = str(row.get("상세구분") or "") - return { - "기계": {"이름": row.get("이름"), "규격": row.get("규격") or "", "상세구분": kind}, - "틀": [{**_brief(k, d), "문서": d} for k, d in _templates(kind)], - } diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Money.ts b/M01_MasterData/M01_MasterData_UI_Logic_Money.ts deleted file mode 100644 index a5e53dc8f..000000000 --- a/M01_MasterData/M01_MasterData_UI_Logic_Money.ts +++ /dev/null @@ -1,11 +0,0 @@ -/* ============================================================================= - * M01_MasterData_UI_Logic_Money.ts - * 돈 모양 — 공용 꼴 한 벌(`common_util/common_util_money.ts`)을 다시 내보냄. 부르는 쪽은 그대로. - * ========================================================================== */ - -export { - formatLineMoney, - formatMoney, - formatNumber, - formatPrice, -} from "../common_util/common_util_money"; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Diagram.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Diagram.ts index d0eedf3a9..0e508bc0c 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Diagram.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Diagram.ts @@ -10,7 +10,7 @@ import { currentLanguageIndex } from "@ui/ui_template_locale"; import { wheelZoomsIn } from "../A00_Common/touch_bridge"; import { guardMenuAfterDrag, isAuxPanButton } from "../A00_Common/input_prefs"; import { createButton, el } from "@ui/ui_template_elements"; -import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money"; +import { formatMoney } from "../common_util/common_util_money"; import "./M02_MasterTemplete_Labor_Diagram.css"; import { createEmpty } from "@ui/ui_template_empty"; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts index 4c9548b3e..4b9d04872 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_LogicMats.ts @@ -9,7 +9,7 @@ * ========================================================================== */ import { createButton, el } from "@ui/ui_template_elements"; -import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money"; +import { formatMoney } from "../common_util/common_util_money"; import { openPickTable } from "../M01_MasterData/M01_MasterData_UI_Logic_PickTable"; import { headWord } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Modal"; import type { LaborCalc, LaborRow, MatMarkKey } from "./M02_MasterTemplete_Labor_Api"; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts index 7c6be0e7d..73bd86f45 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts @@ -6,7 +6,7 @@ * ========================================================================== */ import { createButton, el } from "@ui/ui_template_elements"; -import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money"; +import { formatMoney } from "../common_util/common_util_money"; import type { LaborCalc, LaborCalcLine, diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts index 2865c41dd..293af59e2 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts @@ -15,7 +15,7 @@ import { createButton, createSelectField, el } from "@ui/ui_template_elements"; import { HOPYO_TAG } from "@ui/ui_template_hopyo_grid"; import { pctView } from "../M01_MasterData/M01_MasterData_UI_Logic_Api"; -import { formatLineMoney, formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money"; +import { formatLineMoney, formatMoney } from "../common_util/common_util_money"; import type { ItemLogic } from "./M02_MasterTemplete_Api_Fetch"; import type { LaborCalc, diff --git a/M02_MasterTemplete/M02_MyMachine_Router.py b/M02_MasterTemplete/M02_MyMachine_Router.py index 31ee23219..ceb71b437 100644 --- a/M02_MasterTemplete/M02_MyMachine_Router.py +++ b/M02_MasterTemplete/M02_MyMachine_Router.py @@ -3,7 +3,7 @@ GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) · POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) · PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · -POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}. +옛 POST `/draft`(기계 창 [확인] · 화면 0)은 853-3 에서 지움 — 확인 셈 `M02_MyMachine_Draft.check` 는 시험 827-1 기준값으로 남김. 권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404). ⚠ 등록은 `main.py`(로그인만). """ @@ -17,7 +17,6 @@ from pydantic import BaseModel from common_util.common_util_auth import verify_session from M02_MasterTemplete import M02_MyMachine as mym -from M02_MasterTemplete import M02_MyMachine_Draft as draft from M02_MasterTemplete import M02_MyMachine_Impact as impact from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Session, _call, _root @@ -28,8 +27,6 @@ PATH = "/layers/{layer}/my-machines" class MachineBody(BaseModel): 줄: dict[str, Any] | None = None 본뜬: str | None = None - 키: str | None = None # 초안 확인(827-1) — 고칠 내 기계 - 표지: str | None = None # 초안 확인(827-1) — 화면이 정한 표지(셈 기록 열쇠) def _folder(session: Session, layer: str, owner: str | None, write: bool = False): @@ -43,16 +40,6 @@ def my_machines(layer: str, owner: str | None = None, session: Session = Depends return _call(_folder(session, layer, owner), mym.listing) -@router.post(PATH + "/draft") -def my_machine_draft( - layer: str, - body: MachineBody, - owner: str | None = None, - session: Session = Depends(verify_session), -): - return _call(_folder(session, layer, owner, True), draft.check, body.model_dump()) - - @router.get(PATH + "/{key}") def my_machine( layer: str, key: str, owner: str | None = None, session: Session = Depends(verify_session) diff --git a/resources/tester/test_800_2_equation_layout.py b/resources/tester/test_800_2_equation_layout.py index 65fb20dff..079c35b7e 100644 --- a/resources/tester/test_800_2_equation_layout.py +++ b/resources/tester/test_800_2_equation_layout.py @@ -9,6 +9,7 @@ from pathlib import Path ROOT = Path(__file__).resolve().parents[2] sys.path[:0] = [str(ROOT), str(ROOT / "resources/master_data/scripts")] +from M01_MasterData import M01_MasterData_Doc as doc # noqa: E402 from M01_MasterData import M01_MasterData_Equation as eq # noqa: E402 from M01_MasterData import M01_MasterData_Store as store # noqa: E402 @@ -117,10 +118,10 @@ def test_drop_guard_and_unused_input(): def test_candidates(): whole = store.loaded()[1] - got = eq.links({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""}) + got = doc.candidates({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""}) assert got["후보"] and "조건" in got["후보"][0] - assert eq.links({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"] - assert eq.links({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"] + assert doc.candidates({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"] + assert doc.candidates({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"] assert whole is not None diff --git a/resources/tester/test_813_2_parts.py b/resources/tester/test_813_2_parts.py index bb8997c32..017bf00dc 100644 --- a/resources/tester/test_813_2_parts.py +++ b/resources/tester/test_813_2_parts.py @@ -95,10 +95,6 @@ def test_기계_부품(): assert {"GC001147", "GF000088"} <= tpl and len(tpl) == 15 coef = m01_router.get_parts("계수식")["계수식"] assert {x["키"] for x in coef} == {"GC001143", "GC001191", "GC001192", "GC001193"} - one = parts.of_machine("0201-0070") - assert one["기계"] == {"이름": "굴착기(무한궤도)", "규격": "0.7㎥", "상세구분": "굴착기"} - by = {t["키"]: t for t in one["틀"]} - assert by["GC001147"]["규격"] == "버킷용량" and by["GF000088"]["문서"]["결과"] == "Q" def test_변환기가_표지를_옮김(): diff --git a/resources/tester/test_827_1_machine_window.py b/resources/tester/test_827_1_machine_window.py index a3259c05d..4532bd602 100644 --- a/resources/tester/test_827_1_machine_window.py +++ b/resources/tester/test_827_1_machine_window.py @@ -201,7 +201,7 @@ def test_company_and_other_refused(world): _at(world["company"], path.preview, sk, {"문서": doc}) assert e.value.status == 404 with pytest.raises(HTTPException) as e: - route.my_machine_draft("personal", route.MachineBody(줄=_body()), "7/43", USER) + route.my_machine_create("personal", route.MachineBody(줄=_body()), "7/43", USER) assert e.value.status_code == 403 with pytest.raises(HTTPException) as e: doc_route.save_doc("personal", sk, doc_route.DocBody(문서=doc, 판=""), "7/43", USER) diff --git a/ui_template/ui_template_locale_m1.ts b/ui_template/ui_template_locale_m1.ts index 5b0f36726..36fc7bbe3 100644 --- a/ui_template/ui_template_locale_m1.ts +++ b/ui_template/ui_template_locale_m1.ts @@ -5,7 +5,6 @@ export const ui_locales_m1 = { B01_Dashboard_MasterElements: ["마스터 데이터", "Master Data"], - M01_LogicTab: ["로직", "Logic"], M01_Title: ["마스터 요소", "Master Elements"], M01_AdminOnly: ["시스템 관리자만 볼 수 있음", "System administrators only"], M01_LoadFailed: ["마스터 요소를 못 읽음", "Failed to load master elements"], @@ -44,15 +43,7 @@ export const ui_locales_m1 = { M01_ProcureSearch: ["이름·규격 검색", "Find by name or spec"], M01_ProcureCut: ["연결 끊기", "Unlink"], M01_ProcureClose: ["닫기", "Close"], - M01_PriceFind: ["가격 연결", "Link price"], - M01_PriceTitle: ["가격 연결 고르기", "Pick price source"], - M01_PriceCol: ["가격 연결", "Price link"], - M01_PriceCond: ["조건 연결 (지역은 입력)", "Link by condition (region as input)"], - M01_PriceCondName: ["이름", "Name"], - M01_PriceCondSpec: ["규격", "Spec"], - M01_PriceCondUsed: ["후보 조건", "Condition"], M01_Govt: ["관급", "Govt"], - M01_OnlyUnlinked: ["미연결만", "Unlinked only"], M01_JobFind: ["직종 선택", "Pick job"], M01_JobTitle: ["준용 직종 고르기", "Pick substitute job"], M01_JobCol: ["준용", "Substitute"], @@ -66,7 +57,6 @@ export const ui_locales_m1 = { M01_MachineDetail: ["상세구분", "Detail"], M01_UsageTarget: ["대상", "Target"], M01_TableUsage: ["용도", "Usage"], - M01_TableUsageLogicCount: ["로직 {value}개", "{value} logic rules"], M01_OpenLogic: ["눌러 로직 탭으로", "Click to jump to the Logic tab"], M01_GroupLabor: ["인력", "Labor"], M01_GroupMaterial: ["재료", "Materials"], @@ -75,7 +65,6 @@ export const ui_locales_m1 = { M01_GroupFactor: ["계수", "Factors"], M01_GroupExchange: ["환율", "Exchange rates"], M01_GroupRate: ["요율", "Rates"], - M01_GroupLogic: ["단가산출 기초", "Unit-price logic"], B01_CalcSites_Title: ["계산 자리", "Calc sites"], B01_CalcSites_Desc: ["조작 중 계산 = 브라우저 · 서버 고름", "Browser or server while editing"], B01_CalcSites_ServerCount: ["지금 서버 {value} 줄", "{value} rows on server now"], diff --git a/ui_template/ui_template_locale_machine.ts b/ui_template/ui_template_locale_machine.ts index 4bf5609e8..625811d26 100644 --- a/ui_template/ui_template_locale_machine.ts +++ b/ui_template/ui_template_locale_machine.ts @@ -51,7 +51,6 @@ export const ui_locales_machine = { M01_MachineHourly: ["시간당 경비", "Hourly cost"], M01_MachineUse: ["사용", "Active"], M01_MachineShowOff: ["비활성 같이 보기", "Show inactive"], - M01_MachineMeta: ["원문 · 구분", "Source · group"], M01_MachineUses: ["쓰는 곳", "Used by"], M01_MachineNoUses: ["쓰는 곳 없음", "Not used"], M01_MachineFormula: ["쓰는 계산식", "Hourly formula"], @@ -76,7 +75,6 @@ export const ui_locales_machine = { "Unsaved edits. Leave? (edits stay in the draft)", ], M01_MachineNotFound: ["그 기계가 없음", "Machine not found"], - M01_MachineReadOnly: ["읽기만 — 시스템 관리자만 고침", "Read only — system admins edit"], M01_MachineErrors: ["고칠 칸이 있음", "Fix the marked fields"], M01_MachineDetailGroup: ["상세구분", "Sub-group"], M01_MachineSourceNo: ["원문번호", "Source no."], From fe9920851cf8d63f385a85250be0d99548483ef2 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:43:09 +0900 Subject: [PATCH 3/6] =?UTF-8?q?fix(854-2):=20M01=20=EC=88=98=EC=8B=9D=20?= =?UTF-8?q?=EB=AC=B8=EC=84=9C=20=EC=93=B0=EA=B8=B0=20=EC=95=88=EC=A0=84=20?= =?UTF-8?q?=EA=B8=B8=20=E2=80=94=20=EC=9E=A0=EA=B8=88=20=C2=B7=20=EC=9E=84?= =?UTF-8?q?=EC=8B=9C=20=ED=8C=8C=EC=9D=BC=20=E2=86=92=20=EA=B5=90=EC=B2=B4?= =?UTF-8?q?=20=C2=B7=20=EB=AC=B8=EC=84=9C=EB=B3=84=20=ED=8C=90=20=EB=8C=80?= =?UTF-8?q?=EC=A1=B0=20409=20=E2=80=94=20=EB=AC=B6=EC=9D=8C=20=E2=91=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Doc.put 한 곳으로 씀(save · drop · Machine._register_docs) · Doc._LOCK 안 · 임시 파일 → os.replace - 판 = 문서 한 장 저장 글 지문 · 읽기가 「판」 을 줌 · /logic/doc/save 가 받은 판과 다르면 409(화면 Save_Stale 과 같은 글) · 판 없음 = 대조 안 함(옛 부름 · 시험) - M01 줄 쌓기 [저장]이 판을 보냄(M02 사본 길은 그대로) — 기계 목록 등록이 바꾼 문서를 옛 화면이 덮지 않음 - 수식 문서 폴더가 AISLO_MASTER_DIR 사본을 따름(마스터 사본 · 문서 정본이 갈리던 것) · 마스터만 사본인 시험은 정본 문서를 안 씀 - 시험 test_854_2_m01_doc_write — 옛 판 409 · 동시 두 저장 = 하나 ok 하나 409 · 기계 등록 뒤 옛 판 409 · 정본 안 씀 Co-Authored-By: Claude Opus 5.5 --- A00_Common/line_stack_screen.ts | 5 +- M01_MasterData/M01_MasterData_Doc.py | 75 +++++++--- M01_MasterData/M01_MasterData_Machine.py | 32 ++-- M01_MasterData/M01_MasterData_Router.py | 3 +- .../master_data/scripts/master_doc_link.py | 5 +- resources/tester/test_854_2_m01_doc_write.py | 141 ++++++++++++++++++ 6 files changed, 221 insertions(+), 40 deletions(-) create mode 100644 resources/tester/test_854_2_m01_doc_write.py diff --git a/A00_Common/line_stack_screen.ts b/A00_Common/line_stack_screen.ts index 10bb90115..d37ca76ef 100644 --- a/A00_Common/line_stack_screen.ts +++ b/A00_Common/line_stack_screen.ts @@ -533,7 +533,10 @@ export function createStackScreen(opt: StackScreenOptions) { const save = async (job?: Record, done = ft("Saved")): Promise => { await loading; // 새 로직 저장 뒤 여는 중이면 다 읽고(캐시 이어 받음) if (!doc || (!job && !dirty())) return true; - const send = job ?? (cp ? { 문서: doc, 끊음: cut, 판: version, ...pending() } : { 문서: doc }); + // M01 = 읽을 때 받은 판도(그 사이 다른 곳에서 바뀌면 409 · 덮지 않음) + const send = + job ?? + (cp ? { 문서: doc, 끊음: cut, 판: version, ...pending() } : { 문서: doc, 판: version }); const was = saved; showLoadingOverlay(); try { diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index e273dd7af..3627779db 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -16,6 +16,8 @@ from __future__ import annotations import json +import os +import threading from decimal import Decimal from pathlib import Path @@ -30,12 +32,33 @@ import master_equation_link as link # noqa: E402 OWN_FILE = "수식_자체.json" _memo: dict = {} +# 수식 문서 쓰기 한 번에 하나 — 저장 · 지움 · 기계 고르기 목록 등록(`Machine._register_docs`) +# ponytail: 프로세스 안 잠금(`Store._LOCK` 과 같은 한계) · 서버를 여럿 띄우면 파일 잠금으로 +_LOCK = threading.Lock() +_HOME = Path(ml.__file__).resolve().parents[1] # 저장소 정본 마스터 폴더 +STALE = "그 사이 파일이 바뀜 — 고친 것을 버리고 다시 여세요: {v}" # 화면 `Save_Stale` 과 같은 글 def folder() -> Path: return ml.FOLDER +def version_of(doc: dict | None) -> str: + """문서 한 장의 판(저장 글 기준) — 저장본 없음 = 빈 글.""" + return "" if doc is None else store.version_of(ml.dump(doc).encode("utf-8")) + + +def put(path: Path, data: dict) -> None: + """수식 문서 파일 한 벌 — 임시 파일 → 교체(원자적) · `_LOCK` 안에서 부름. + 마스터만 사본으로 바꾼 시험(`Store.FOLDER` ≠ 정본)이 정본 수식 문서를 쓰지 않게 건너뜀.""" + if path.resolve().parent.parent == _HOME and Path(store.FOLDER).resolve() != _HOME: + return + tmp = path.with_name(f".{path.name}.tmp") + tmp.write_text(ml.dump(data), encoding="utf-8", newline="\n") + os.replace(tmp, path) + _memo.clear() + + def _stamp() -> tuple: return tuple((p.name, p.stat().st_mtime_ns) for p in sorted(folder().glob("수식_*.json"))) @@ -95,7 +118,8 @@ def read(key: str) -> dict: out = _run(found) up = None if fresh else built(key) more = {"층바탕": {"위": up}} if up is not None else {} - return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, **more} + 판 = version_of(None if fresh else found) # 저장 때 대조(다른 곳에서 바뀌면 409) + return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, "판": 판, **more} def preview(doc: dict, given: dict | None = None) -> dict: @@ -150,22 +174,27 @@ def layered(doc: dict, key: str) -> dict: return out -def save(doc: dict) -> dict: +def save(doc: dict, 판: str | None = None) -> dict: + """`판` = 읽을 때 받은 판(없음 = 대조 안 함 · 빈 글 = 저장본 없던 문서) · 다르면 409.""" doc = _check(doc) key = str(doc["키"]).strip() - doc = layered(doc, key) - name = _file_for(key) - path = folder() / name - data = ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []} - rows = data.setdefault("줄", []) - at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None) - if at is None: - rows.append(doc) - else: - rows[at] = doc - path.write_text(ml.dump(data), encoding="utf-8", newline="\n") - _memo.clear() - return {"문서": doc, **_run(doc), "파일": name} + with _LOCK: + doc = layered(doc, key) + name = _file_for(key) + path = folder() / name + data = ( + ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []} + ) + rows = data.setdefault("줄", []) + at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None) + if 판 is not None and version_of(None if at is None else rows[at]) != 판: + raise store.StoreError(409, STALE.format(v=f"{name} {key}")) + if at is None: + rows.append(doc) + else: + rows[at] = doc + put(path, data) + return {"문서": doc, **_run(doc), "파일": name, "판": version_of(doc)} def candidates(ask: dict) -> dict: @@ -222,14 +251,14 @@ def users(key: str) -> list[str]: def drop(key: str) -> None: """수식 문서 줄 하나 지움(없으면 그냥).""" - name = _where(key) - if not name: - return - path = folder() / name - data = ml.load_file(path) - data["줄"] = [d for d in data.get("줄") or [] if str(d.get("키")) != key] - path.write_text(ml.dump(data), encoding="utf-8", newline="\n") - _memo.clear() + with _LOCK: + name = _where(key) + if not name: + return + path = folder() / name + data = ml.load_file(path) + data["줄"] = [d for d in data.get("줄") or [] if str(d.get("키")) != key] + put(path, data) def remove(key: str, file: str, version: str, confirmed: bool) -> dict: diff --git a/M01_MasterData/M01_MasterData_Machine.py b/M01_MasterData/M01_MasterData_Machine.py index 769fa2b7f..dd37efe64 100644 --- a/M01_MasterData/M01_MasterData_Machine.py +++ b/M01_MasterData/M01_MasterData_Machine.py @@ -182,22 +182,26 @@ def register(batch: list[dict]) -> Callable[[], None]: def _register_docs(add: dict[str, list[str]], drop: set[str]) -> None: - """수식 문서의 「기계」 고르기 목록에 로직 목록과 같은 더함 · 뺌 — 바뀐 파일만 다시 씀.""" + """수식 문서의 「기계」 고르기 목록에 로직 목록과 같은 더함 · 뺌 — 바뀐 파일만 다시 씀 + (수식 문서 쓰기 길 `Doc.put` · 잠금 안 — 화면 저장과 겹쳐도 한쪽이 덮지 않음).""" import master_doc_link as ml # noqa: E402 - for path in sorted(ml.FOLDER.glob("수식_*.json")): - data, hit = ml.load_file(path), False - for doc in data.get("줄") or []: - for v in doc.get("변수") or []: - link = v.get("연결") or {} - if link.get("갈래") != "선택" or v.get("이름") != "기계": - continue - codes = [c for c in link.get("목록") or [] if str(c) not in drop] - codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes] - if codes != link.get("목록"): - link["목록"], hit = codes, True - if hit: - path.write_text(ml.dump(data), encoding="utf-8", newline="\n") + from M01_MasterData import M01_MasterData_Doc as docs + + with docs._LOCK: + for path in sorted(docs.folder().glob("수식_*.json")): + data, hit = ml.load_file(path), False + for doc in data.get("줄") or []: + for v in doc.get("변수") or []: + link = v.get("연결") or {} + if link.get("갈래") != "선택" or v.get("이름") != "기계": + continue + codes = [c for c in link.get("목록") or [] if str(c) not in drop] + codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes] + if codes != link.get("목록"): + link["목록"], hit = codes, True + if hit: + docs.put(path, data) # ── 쓰는 곳 = `M01_MasterData_Machine_Uses`(수식 문서 기준 · 848-5) ────────────── diff --git a/M01_MasterData/M01_MasterData_Router.py b/M01_MasterData/M01_MasterData_Router.py index bc9d0f1d2..b56a2cf07 100644 --- a/M01_MasterData/M01_MasterData_Router.py +++ b/M01_MasterData/M01_MasterData_Router.py @@ -318,6 +318,7 @@ def post_logic_formula_preview(body: FormulaPreview) -> dict: class DocBody(BaseModel): 문서: dict[str, Any] 입력: dict[str, Any] = {} + 판: str | None = None # 저장 — 읽을 때 받은 판(다르면 409 · 없으면 대조 안 함) @router.get("/logic/doc") @@ -335,7 +336,7 @@ def post_logic_doc_preview(body: DocBody) -> dict: @router.post("/logic/doc/save") def post_logic_doc_save(body: DocBody) -> dict: """저장 — 서버가 정본으로 다시 셈 · 문서 파일에 씀 → {문서, 셈, 연결, 파일}.""" - return _call(doc_screen.save, body.문서) + return _call(doc_screen.save, body.문서, body.판) class RemoveBody(BaseModel): diff --git a/resources/master_data/scripts/master_doc_link.py b/resources/master_data/scripts/master_doc_link.py index 72facfb2a..6cc42b297 100644 --- a/resources/master_data/scripts/master_doc_link.py +++ b/resources/master_data/scripts/master_doc_link.py @@ -14,6 +14,7 @@ from __future__ import annotations import json +import os from decimal import Decimal from pathlib import Path @@ -24,7 +25,9 @@ import master_machine_crew as mcrew import master_material as mm import master_pick as mp -FOLDER = Path(__file__).resolve().parents[1] / "수식문서" +# 화면 저장 시험 사본(`AISLO_MASTER_DIR` — `M01_MasterData_Store.FOLDER` 와 같이) · 없으면 정본 +_HOME = os.environ.get("AISLO_MASTER_DIR") or Path(__file__).resolve().parents[1] +FOLDER = Path(_HOME).resolve() / "수식문서" _ARITH_OK = ("num", "bin", "neg") diff --git a/resources/tester/test_854_2_m01_doc_write.py b/resources/tester/test_854_2_m01_doc_write.py new file mode 100644 index 000000000..581e379ce --- /dev/null +++ b/resources/tester/test_854_2_m01_doc_write.py @@ -0,0 +1,141 @@ +"""M01 수식 문서 쓰기 안전(PLAN 854-2 · 요구 894 걸음 1) — 잠금 · 판 대조(409) · 임시 파일 → 교체. + +마스터 · 수식 문서 사본 폴더에서만 씀. +""" + +from __future__ import annotations + +import shutil +from pathlib import Path + +import pytest + +from M01_MasterData import M01_MasterData_Store as store + +REAL = store.FOLDER + + +@pytest.fixture +def master(tmp_path: Path, monkeypatch) -> Path: + for path in REAL.glob("*.json"): + if not path.name.startswith("_") or path.name == store.mk.BOOK.name: + shutil.copy(path, tmp_path / path.name) + shutil.copytree(REAL / "기계", tmp_path / "기계") + monkeypatch.setattr(store, "FOLDER", tmp_path) + return tmp_path + + +DOC_KEY = "GF000219" # 산림 13-4-1 메쌓기(인력) + + +@pytest.fixture +def docs(master: Path, monkeypatch) -> Path: + from M01_MasterData import M01_MasterData_Doc as doc_screen + + folder = master / "수식문서" + shutil.copytree(REAL / "수식문서", folder) + monkeypatch.setattr(doc_screen.ml, "FOLDER", folder) + doc_screen._memo.clear() + return folder + + +def _client(): + from fastapi import FastAPI + from fastapi.testclient import TestClient + + from M01_MasterData import M01_MasterData_Router as router_module + + app = FastAPI() + app.include_router(router_module.router) + return TestClient(app) + + +def _renamed(doc: dict, tail: str) -> dict: + return {**doc, "이름": f"{doc['이름']} {tail}"} + + +def test_옛_판으로_저장하면_409_이고_앞_저장을_덮지_않는다(docs: Path) -> None: + client = _client() + got = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() + assert got["판"] and not got["새"] + first = client.post( + "/api/m01/logic/doc/save", + json={"문서": _renamed(got["문서"], "sub5임시A"), "판": got["판"]}, + ) + assert first.status_code == 200, first.text + again = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() + assert again["판"] == first.json()["판"] != got["판"] # 저장 뒤 판 = 다시 읽은 판 + late = client.post( + "/api/m01/logic/doc/save", + json={"문서": _renamed(got["문서"], "sub5임시B"), "판": got["판"]}, + ) + assert late.status_code == 409 and "그 사이 파일이 바뀜" in late.json()["detail"] + assert again["문서"]["이름"].endswith("sub5임시A") + now = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() + assert now["문서"]["이름"].endswith("sub5임시A") # 늦은 저장이 소리 없이 덮지 않음 + assert not list(docs.glob(".*.tmp")) + + +def test_동시에_두_저장이면_하나만_되고_하나는_409(docs: Path, monkeypatch) -> None: + import threading + import time + + from M01_MasterData import M01_MasterData_Doc as doc_screen + + got = _client().get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() # 화면 꼴(수 = JSON) + real = doc_screen.layered + + def slow(doc, key): # 두 저장이 겹치게 — 판 확인 · 쓰기 사이를 넓힘 + time.sleep(0.3) + return real(doc, key) + + monkeypatch.setattr(doc_screen, "layered", slow) + plain = got["문서"] + out: list[str] = [] + + def one(tail: str) -> None: + try: + doc_screen.save(_renamed(plain, tail), got["판"]) + out.append("ok") + except doc_screen.store.StoreError as e: + out.append(str(e.status)) + + runs = [threading.Thread(target=one, args=(t,)) for t in ("sub5임시A", "sub5임시B")] + for t in runs: + t.start() + for t in runs: + t.join() + assert sorted(out) == ["409", "ok"] + + +def test_기계_목록_등록이_바꾼_문서를_옛_판_저장이_덮지_않는다(docs: Path) -> None: + from M01_MasterData import M01_MasterData_Doc as doc_screen + from M01_MasterData import M01_MasterData_Machine as machine + + key = next( + k + for k, d in doc_screen.docs().items() + if any( + v.get("이름") == "기계" and (v.get("연결") or {}).get("갈래") == "선택" + for v in d.get("변수") or [] + ) + ) + got = _client().get("/api/m01/logic/doc", params={"key": key}).json() + machine._register_docs({key: ["sub5임시EQ"]}, set()) + after = doc_screen.read(key) + assert after["판"] != got["판"] + plain = got["문서"] + with pytest.raises(doc_screen.store.StoreError) as e: + doc_screen.save(_renamed(plain, "sub5임시"), got["판"]) + assert e.value.status == 409 + picks = next(v for v in doc_screen.read(key)["문서"]["변수"] if v.get("이름") == "기계") + assert "sub5임시EQ" in picks["연결"]["목록"] + + +def test_마스터만_사본인_시험은_정본_수식_문서를_안_쓴다(master: Path) -> None: + from M01_MasterData import M01_MasterData_Doc as doc_screen + + path = doc_screen.folder() / "수식_자체.json" # 정본 폴더(사본으로 안 바꿈) + raw = path.read_bytes() + doc_screen.put(path, {"그룹": "수식문서", "로직파일": "", "줄": []}) + assert path.read_bytes() == raw From 327fdc5d9b0f417a6a95076d60035a676fdab3f3 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:45:14 +0900 Subject: [PATCH 4/6] =?UTF-8?q?test(855-A):=20=EA=B1=B8=EC=9D=8C=202=20?= =?UTF-8?q?=EC=A7=80=ED=82=B4=20=EC=8B=9C=ED=97=98=20=EB=8B=A4=EC=84=AF=20?= =?UTF-8?q?=E2=80=94=20=EC=98=9B=20=EC=97=94=EC=A7=84=20=EB=8C=80=20?= =?UTF-8?q?=EC=83=88=20=EA=B3=84=EC=82=B0=EA=B8=B0=20=C2=B7=20=EC=83=88=20?= =?UTF-8?q?=EB=8B=B5=20=EC=A7=80=EB=AC=B8=20=C2=B7=20SK=20=EA=B2=AC?= =?UTF-8?q?=EB=B3=B8=20=C2=B7=20=EB=A7=89=ED=9E=98=20=C2=B7=20=EB=B6=88?= =?UTF-8?q?=EB=9F=AC=EC=98=A4=EA=B8=B0=20=EC=98=9B=20=EA=B2=80=EC=82=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - test_855_engine_parity: 로직 전수 기본 입력 L0 ~ L3 옛 대 새 · 다름 = 채택 목록(빌더 ADOPTED)과 같음 · 보이는 단가만 다름은 허용 갈래 · 옵션 전수 = S855_ALL=1 - test_855_golden + golden_855_engine.json: 새 계산기 답 지문(로직마다 기본 + 옵션 표본) · 다르면 실패 · 다시 뜨기 = --write(자료를 뜻대로 바꾼 걸음만) - test_855_sk_layers: 임시 층 SK 견본(바탕 · 옛 칸 더한줄 · 율 더한줄 · 형제 SK · 가져온 식) 옛 = 새 · 줄 합 = 기준 · 「따로」 는 지금 사실(줄 = 옛 · 기준 = 새)을 단언 — 2-C1 에서 뒤집음 - test_855_block: 막힘 옛(check_logic) = 새(문서 표지) · 틀린 식은 둘 다 막힘 - test_812_1_xlsx_golden: 금액 표본 sweep 에 옛 검산(옛 엔진) = 새 셈 단언 하나 - 도우미 helper_855_engine(경우 · 층 가름 · 지문) · 제품 코드 고침 0 - 싱크 관문에는 안 넣음 — 기존 관문 넷이 이미 약 7 분(5 분 넘음) Co-Authored-By: Claude Opus 5.5 --- resources/tester/golden_855_engine.json | 1526 ++++++++++++++++++++ resources/tester/helper_855_engine.py | 164 +++ resources/tester/test_812_1_xlsx_golden.py | 8 +- resources/tester/test_855_block.py | 33 + resources/tester/test_855_engine_parity.py | 46 + resources/tester/test_855_golden.py | 47 + resources/tester/test_855_sk_layers.py | 125 ++ 7 files changed, 1948 insertions(+), 1 deletion(-) create mode 100644 resources/tester/golden_855_engine.json create mode 100644 resources/tester/helper_855_engine.py create mode 100644 resources/tester/test_855_block.py create mode 100644 resources/tester/test_855_engine_parity.py create mode 100644 resources/tester/test_855_golden.py create mode 100644 resources/tester/test_855_sk_layers.py diff --git a/resources/tester/golden_855_engine.json b/resources/tester/golden_855_engine.json new file mode 100644 index 000000000..eda1f7eb3 --- /dev/null +++ b/resources/tester/golden_855_engine.json @@ -0,0 +1,1526 @@ +{ + "판": 1, + "지문": { + "GC000001": "7668cb27f4257ba3", + "GC000002": "2bff277c6b2c6b75", + "GC000003": "be53e60464a18a08", + "GC000004": "30ad72a73f9ed7c8", + "GC000005": "f64f19781ecefdbe", + "GC000006": "58dd823ed0b4ac26", + "GC000007": "b5a8656070d7c489", + "GC000008": "1ce9d4760cd2222a", + "GC000009": "54fe5b1297aba396", + "GC000010": "218d082ef7a022b3", + "GC000011": "e8656df79b0a42eb", + "GC000012": "c77f6b59a0f01107", + "GC000013": "19d3b025337a026b", + "GC000014": "e00f0261036c07ab", + "GC000015": "dc32b92a53c959bd", + "GC000016": "8f7356e1316fac5e", + "GC000017": "56e83c37b775e7f9", + "GC000018": "8f7356e1316fac5e", + "GC000019": "5f10a82dedfc0753", + "GC000020": "af7ac3471af99254", + "GC000021": "02580e786f381fec", + "GC000022": "057f5fb799b23617", + "GC000023": "3e870c1a3a860774", + "GC000024": "e749b257555c0858", + "GC000025": "56e327bf3883ee69", + "GC000026": "4a0c18fd0b060511", + "GC000027": "ce7c628e4985ce54", + "GC000028": "ddaaf4e98e48fe89", + "GC000029": "0bcf8fc56ff72e17", + "GC000030": "fe53d3c5be000fea", + "GC000031": "eec307d81fc0e579", + "GC000032": "4ab2717a823a503e", + "GC000033": "869e3dcef49d00a4", + "GC000034": "d00217cbe34cbe48", + "GC000035": "ff1559143bc476e9", + "GC000036": "35fdfd61d1fe1779", + "GC000037": "2bebb481e471b97f", + "GC000038": "cf17119754a873c2", + "GC000039": "042608faaabdebab", + "GC000040": "9fdcbe64635af6a8", + "GC000041": "0b0af50d25347c24", + "GC000042": "af2a53c68a941986", + "GC000043": "333bdf09111669eb", + "GC000044": "a7a9a4c0d23e84ce", + "GC000045": "ec21c62469444f09", + "GC000046": "350d8def18179512", + "GC000047": "db5cc08edb175403", + "GC000048": "a231ca530d2e9eb1", + "GC000049": "1f99b7be4163ebef", + "GC000050": "3e6890bd47c5beee", + "GC000051": "479c00f67a5954c5", + "GC000052": "b6214336896cd50e", + "GC000053": "32d45ba23298e8e6", + "GC000054": "2e433953161b6247", + "GC000055": "d34e5c4ad37d175e", + "GC000056": "7c3bc2fd6f7db503", + "GC000057": "4e75f7d977d4b4af", + "GC000058": "681abfd1e3b906b3", + "GC000059": "681abfd1e3b906b3", + "GC000060": "7b092e8c949a572d", + "GC000061": "42951d83847f526a", + "GC000062": "8bf4d85f5f2bfb63", + "GC000063": "2c3ceb16fd842b72", + "GC000064": "8dd29715a12bbb7b", + "GC000065": "1c8619ba861b2164", + "GC000066": "c7a3fb47c26bb511", + "GC000067": "3930b3028464f516", + "GC000068": "1df1237c49f4cae8", + "GC000069": "36702e85d90e348d", + "GC000070": "22d5488bf0596041", + "GC000071": "c5461ad4791782da", + "GC000072": "0b0d08e79baa4da0", + "GC000073": "305b9f98815418ef", + "GC000074": "a171f068787c1c46", + "GC000075": "216eece7cb9e26b0", + "GC000076": "e33adfc8e1536b6d", + "GC000077": "9f4c46ba26264450", + "GC000078": "88b7fbe77d736d85", + "GC000079": "83d2941ddb03c59b", + "GC000080": "0b5adc6b35ba4c41", + "GC000081": "460f16a1a50f3e2a", + "GC000082": "9b91e97a106fc812", + "GC000083": "2cf319ce34009bcf", + "GC000084": "6719f35187514ea4", + "GC000085": "62da652b38d45159", + "GC000086": "a396521f34d0b23c", + "GC000087": "376481e663e0fe00", + "GC000088": "1ce6dbd35ee35279", + "GC000089": "9252ac2ca6a93a35", + "GC000090": "79d02d499e326d7a", + "GC000091": "a8430e047906f7e7", + "GC000092": "7d301e65ebafd412", + "GC000093": "da27a5ea6dfc764c", + "GC000094": "1108003107407565", + "GC000095": "0303ba6474cbde2c", + "GC000096": "dd32d308461003e0", + "GC000097": "3ffaeebf07de2362", + "GC000098": "8e9a11f572fd0c12", + "GC000099": "6c378d03508de7e9", + "GC000100": "3b450e029042486f", + "GC000101": "329a929667ba4694", + "GC000102": "f1519d0faa60ba72", + "GC000103": "a68cf9a73ba4b7b4", + "GC000104": "c63972dc1c0c4197", + "GC000105": "3fb80a854526097e", + "GC000106": "43f24fc293ab7902", + "GC000107": "22323ca3c5dbc3d1", + "GC000108": "7a9464b480365204", + "GC000109": "3b932460d4dd6857", + "GC000110": "6b13163c22436e36", + "GC000111": "a971125f812af0e6", + "GC000112": "9aa7ed694ba48890", + "GC000113": "d0ddf0a097062217", + "GC000114": "b39bda73d65845ba", + "GC000115": "7fc1b9c0c50a9ef2", + "GC000116": "c9239dd689e1b89c", + "GC000117": "817643177c70bb6a", + "GC000118": "e9f1253d0778fdf9", + "GC000119": "907b1a2a55ae1adb", + "GC000120": "073e203371de6b04", + "GC000121": "0538edccdb5d5647", + "GC000122": "1e7f348c09379ea3", + "GC000123": "b29906faf5836dbb", + "GC000124": "bcad2e02a0c4211f", + "GC000125": "8b9a9ea8d71bf981", + "GC000126": "77a6f587474cd1a5", + "GC000127": "e9b59685ca45e8a5", + "GC000128": "35500110a7430c80", + "GC000129": "0160a8e5778a2202", + "GC000130": "08785faeef912d27", + "GC000131": "2523bd73ff7b9288", + "GC000132": "e8518c2dfe049da5", + "GC000133": "2a283747e8f215de", + "GC000134": "e8518c2dfe049da5", + "GC000135": "2a283747e8f215de", + "GC000136": "b945dcece3d256d7", + "GC000137": "739ab15d4b6f11de", + "GC000138": "3f7fe7307747d642", + "GC000139": "8d55f05fec5a3aad", + "GC000140": "cde560f441d66406", + "GC000141": "de59966724f80967", + "GC000142": "9441d6e425b21ab0", + "GC000143": "152b7b126dcb320c", + "GC000144": "fc6c01e54bdf391b", + "GC000145": "cb4bb2aeb99b5999", + "GC000146": "016db242ebeb794f", + "GC000147": "239dd28801f2c19e", + "GC000148": "83789266edce600b", + "GC000149": "00a57a75f18bac9c", + "GC000150": "814c6888158d97e4", + "GC000151": "b5cd3aa3c6af28f2", + "GC000152": "5395d3e0fc3413c7", + "GC000153": "2a2267631875210b", + "GC000154": "5ab4f0b8d95febf4", + "GC000155": "31fafab1c84022f6", + "GC000156": "b7d0e483506acc00", + "GC000157": "a326e41ffbadea7b", + "GC000158": "d71d0fa56940d7ae", + "GC000159": "834540736e58e57e", + "GC000160": "816e0786d8d30010", + "GC000161": "1207209a86e047e7", + "GC000162": "171434c2317c9b54", + "GC000163": "1da6fb579048eac0", + "GC000164": "0779c30ca1aeab34", + "GC000165": "565f33f5b0d9ebb3", + "GC000166": "5d6ccc68fcb8932f", + "GC000167": "e8c67d2492db4550", + "GC000168": "dfe0b8b87b641ca6", + "GC000169": "6a207e509583b3aa", + "GC000170": "7768bcb205adb881", + "GC000171": "af7a71cd77223374", + "GC000172": "0c2dd9b71835ec9e", + "GC000173": "f35e04c448155165", + "GC000174": "5a6b4168788e8850", + "GC000175": "9bf920be12b6b4e8", + "GC000176": "dfb964e984b4e8cc", + "GC000177": "47336872e12123c3", + "GC000178": "991ea0b03c2c05db", + "GC000179": "176eadfde9bd44cc", + "GC000180": "52469e8a06d27b1f", + "GC000181": "13e52b9848be7000", + "GC000182": "97fd6a96e729e38d", + "GC000183": "a2591f98def54985", + "GC000184": "dab3c3960298a5d0", + "GC000185": "c68a748764d2fb4f", + "GC000186": "614afc8823290476", + "GC000187": "6fdbc3f02d88de59", + "GC000188": "4c732de52a987455", + "GC000189": "ef44b267e0043bfa", + "GC000190": "e2b223fea9134a34", + "GC000191": "f83b96fccc8bc2bf", + "GC000192": "ab43dbfdb004f378", + "GC000193": "0c81b9be9d3c1e49", + "GC000194": "614afc8823290476", + "GC000195": "e8c7f9e52d6926d5", + "GC000196": "dd55a05c33c81378", + "GC000197": "106c999ac312407b", + "GC000198": "a616aa21e678f4f9", + "GC000199": "490fc27fb87f3654", + "GC000200": "8a6aa53c4f183242", + "GC000201": "915ae6f25a8931d1", + "GC000202": "08794e48f6016fc6", + "GC000203": "035db34fa954b63b", + "GC000204": "a976f0f6ec0d6e7d", + "GC000205": "040c8154fbe2c187", + "GC000206": "af634c08f29dc85c", + "GC000207": "ce15954d6bce38c9", + "GC000208": "e63e48c689669d5e", + "GC000209": "ad9af83d08c7a473", + "GC000210": "eca549e43315549f", + "GC000211": "5633ab2e79e1355b", + "GC000212": "68a09199609ab821", + "GC000213": "5d2008d98597bd01", + "GC000214": "0a2b07adbbdc35fb", + "GC000215": "2c450520f9964c30", + "GC000216": "562a3f3ddd830a0c", + "GC000217": "c18e1801c149f842", + "GC000218": "1054a09b4b1d71a3", + "GC000219": "45409808a95e5fac", + "GC000220": "a316f0b8358cf6e1", + "GC000221": "68d5d0b1c83eacc0", + "GC000222": "a50cf7c788357e15", + "GC000223": "b012b58e2a7b3329", + "GC000224": "b1711b74eed80dd4", + "GC000225": "a3e01906ae3a8300", + "GC000226": "143f8769167172b2", + "GC000227": "63f924067c3d294f", + "GC000228": "449e56b67f91b1b0", + "GC000229": "4f7a5f792b2fd61b", + "GC000230": "bf3b5e968de87225", + "GC000231": "f22faeed576d66a7", + "GC000232": "5d8d107580c014fd", + "GC000233": "0b8a4cdbf7032b54", + "GC000234": "c268e58c7908829c", + "GC000235": "3913427c4649ab86", + "GC000236": "62edaa9ac74dea3f", + "GC000237": "26df410acfad5098", + "GC000238": "44e23b400b981faf", + "GC000239": "7a289d0b85b4436b", + "GC000240": "ff62f41c2ca3115e", + "GC000241": "99d4aaf455fd0b30", + "GC000242": "70f5c24c3d71b3ec", + "GC000243": "001cd10a8fe7d2b9", + "GC000244": "6f93231855805fe3", + "GC000245": "ef08c6289eea08e1", + "GC000246": "bc072da57f7ebaf6", + "GC000247": "d4228244b4603330", + "GC000248": "af629268dff54800", + "GC000249": "503ec3adf0425cee", + "GC000250": "b93c87ed39f4d0df", + "GC000251": "85a8254ef8c6e521", + "GC000252": "1330ed61a826bd5b", + "GC000253": "b447d91e4dfacf35", + "GC000254": "3b145710a3d99aa6", + "GC000255": "a3e65a65634e1a77", + "GC000256": "02c2b03e68e6fb7a", + "GC000257": "cf84beb76e7f1d41", + "GC000258": "7a890fd5cb2d182b", + "GC000259": "c146cb0d30fc6d8c", + "GC000260": "ae7e5fe10bcf0c21", + "GC000261": "6775b2d2f9a3cc77", + "GC000262": "026a09f3cbc1a96f", + "GC000263": "4d13d387fa99eeed", + "GC000264": "578ab88e198a355b", + "GC000265": "f5c9235b25924220", + "GC000266": "dc6d2a3def556d9a", + "GC000267": "a8aa14b8ca482bcc", + "GC000268": "39563737c19979fc", + "GC000269": "22f8b5ad1ee1dcd5", + "GC000270": "92ccaea47eb1b818", + "GC000271": "a9db0bb065003807", + "GC000272": "26c90a1b51574bbb", + "GC000273": "91c3f2c432712166", + "GC000274": "7b91cb515ef3ee59", + "GC000275": "c67d366803dfe2d0", + "GC000276": "ddd6f5ab3fde81c4", + "GC000277": "592a375749b7cb08", + "GC000278": "30c313f2568afc34", + "GC000279": "b717aab63021472d", + "GC000280": "45a77c999c7e9ff0", + "GC000281": "397bc2a910fd05c4", + "GC000282": "4d18153218ddf574", + "GC000283": "ffaaef2dab66c592", + "GC000284": "d87edb7fe04219a1", + "GC000285": "cbaf846d290e3d84", + "GC000286": "9cd5381018d68d6a", + "GC000287": "a0c1e4e5bc09c0ac", + "GC000288": "c380bb0281ba9068", + "GC000289": "b1e0c2dbc9b2b057", + "GC000290": "a49e72e7a9efabe7", + "GC000291": "dc1d4d5c49cad894", + "GC000292": "5ac93e860722245e", + "GC000293": "493696569faadfc2", + "GC000294": "f6e74be0fedb7f67", + "GC000295": "32414e3934e3c6a7", + "GC000296": "95d80c31acac68d2", + "GC000297": "3974fa2179b08526", + "GC000298": "fc4a4ff72cfe6ee5", + "GC000299": "257b9af8cfa0d994", + "GC000300": "1167554684a053c3", + "GC000301": "3b91dc274383f232", + "GC000302": "0db1610e26a19d8a", + "GC000303": "de01bdc3a46e7cd9", + "GC000304": "ff8498b88b5acf94", + "GC000305": "d4db816aa7e51081", + "GC000306": "d09ba071f51ec522", + "GC000307": "f61e947a96dfdac8", + "GC000308": "1af9a5dd86f0cb75", + "GC000309": "cd9f2016a51b3fe2", + "GC000310": "033a61acc64a03b5", + "GC000311": "b8ed109508f8ec01", + "GC000312": "736f2aeca1cd6878", + "GC000313": "4075f84cbd7b3999", + "GC000314": "b739d9890041b9cf", + "GC000315": "6138c880c3737964", + "GC000316": "7d673f2666593a2f", + "GC000317": "3902f1769546a395", + "GC000318": "149a60e5310675d8", + "GC000319": "4727529e3a6ada3e", + "GC000320": "3fe9ab6a14852bbb", + "GC000321": "c953ef3d1c61951c", + "GC000322": "804f2ea385ddfb24", + "GC000323": "3d5d0ad3465bed45", + "GC000324": "af6e587bdd8865a2", + "GC000325": "83e28e076d2f6cc3", + "GC000326": "ffb1ec900144636f", + "GC000327": "4437c1eadca442f2", + "GC000328": "0d7256783a3a54a8", + "GC000329": "56de8e34f4641146", + "GC000330": "f9e6bedfe39ea62f", + "GC000331": "499467ad1d669a47", + "GC000332": "e1d95871eb7ef9ae", + "GC000333": "6e91eb6587f221b1", + "GC000334": "5dbfa2ad4b52978f", + "GC000335": "a081c99a18cf8219", + "GC000336": "65fb30065cac36f4", + "GC000337": "c1e1a3c52d3fc415", + "GC000338": "786abe47f875ea74", + "GC000339": "7a3888ff8b254d91", + "GC000340": "f31a667901f64d50", + "GC000341": "4623d7786e56f523", + "GC000342": "1ab6d205d6dda513", + "GC000343": "b872c6b0ad15a3f4", + "GC000344": "5ca0d6fcd7714b3e", + "GC000345": "083813776c5a2547", + "GC000346": "8315dab034d0f80e", + "GC000347": "4e813d9d19285eb9", + "GC000348": "e20600a0db20ea90", + "GC000349": "cf092c24b3956bbb", + "GC000350": "187fd2fed776ddae", + "GC000351": "cad4a76874a9e486", + "GC000352": "0ba4501895f9aba5", + "GC000353": "900f604913fba5dd", + "GC000354": "e4edd96b86f392f2", + "GC000355": "b095779b2ef6d3a9", + "GC000356": "8cf509599cbc58f9", + "GC000357": "ab73b383dd25c984", + "GC000358": "8630b431b573a740", + "GC000359": "228460c982846c0c", + "GC000360": "86824b360e9becf9", + "GC000361": "6a764753ec7260b6", + "GC000362": "41d8c89c557a9e93", + "GC000363": "30062847c4a820a0", + "GC000364": "901d66e174667c73", + "GC000365": "c26e723b54ff9909", + "GC000366": "ceecc7da2ff787c5", + "GC000367": "b59845e60ad2d8e7", + "GC000368": "13712ef75ca4d128", + "GC000369": "463b7a2882a024b1", + "GC000370": "dbfb60f5c69645e9", + "GC000371": "1b2940f63fad92e9", + "GC000372": "49c1f5d1134a41a2", + "GC000373": "bc4f053f20a10a00", + "GC000374": "e1259acefc57dda7", + "GC000375": "69cdba1dcf3377b6", + "GC000376": "1ffd152fdefbfec9", + "GC000377": "6934acf35ddf9d09", + "GC000378": "2481cb3c7490dced", + "GC000379": "da9aa356f6b224ba", + "GC000380": "cd4e9434459452ee", + "GC000381": "4a30630384eddaee", + "GC000382": "2207fccd5e8f1522", + "GC000383": "89c3ee89ed9559b3", + "GC000384": "93427389914e85d7", + "GC000385": "5c4a041193010421", + "GC000386": "665a9b7fac395ae7", + "GC000387": "91cb9e1cf133641f", + "GC000388": "3d5aa3d12d1cd75a", + "GC000389": "183e503eeda6fe47", + "GC000390": "c16ff2e6d11421d1", + "GC000391": "2010d3a4a7ed2f42", + "GC000392": "ed1581f0c182b0ce", + "GC000393": "95036c2e8f1a7f9c", + "GC000394": "f04f7016d70e3a85", + "GC000395": "ef5f9661b9fcfce9", + "GC000396": "551b1b0f8c9225c9", + "GC000397": "29ccbc912d5b6771", + "GC000398": "7514a3158bd75e6a", + "GC000399": "8bee310cca76013a", + "GC000400": "16f4dccf83b5fae1", + "GC000401": "2d034e165fad1f59", + "GC000402": "9ddb366af08cef76", + "GC000403": "226d41db226820ac", + "GC000404": "34fda658b8f0030b", + "GC000405": "6c7cfcc2783de11e", + "GC000406": "dfd21abf6e15d8f2", + "GC000407": "60c543272d861afb", + "GC000408": "5c5110ae15ebb002", + "GC000409": "423b499dc751216a", + "GC000410": "8bd19c4ac86dfe0a", + "GC000411": "1157ae18cd887621", + "GC000412": "8b46b41b8662875a", + "GC000413": "e8200881d1d35ceb", + "GC000414": "ef7f6447a61d395c", + "GC000415": "419f4530a41252cf", + "GC000416": "ea518c48b1305da9", + "GC000417": "878bdb151d35ae47", + "GC000418": "14fd35e8da998c28", + "GC000419": "23af86832b67c851", + "GC000420": "f5d433d70202edba", + "GC000421": "e4e5b51893ef8866", + "GC000422": "41e3b84f8a51ea0c", + "GC000423": "6988956b87763917", + "GC000424": "6988956b87763917", + "GC000425": "d7032392d2acfebd", + "GC000426": "68d55e6906572ea2", + "GC000427": "a5b2278f719faddd", + "GC000428": "cf7fd73485df1dfc", + "GC000429": "804ea4f065a52922", + "GC000430": "32baa1c46876e010", + "GC000431": "5dc61455969acaac", + "GC000432": "d00a8b19e9203cb4", + "GC000433": "42aaf7e2b4836106", + "GC000434": "bd9ddb71e0d7e4bc", + "GC000435": "5835b7b18ba096bd", + "GC000436": "a79ef27342919e2b", + "GC000437": "d3e6c94ef760a1ed", + "GC000438": "c76fa39e6c005b5d", + "GC000439": "11d5cfacbfa50aab", + "GC000440": "799d053490d8da3a", + "GC000441": "9669bebf40299aeb", + "GC000442": "f1ead0b1ccd1ef3a", + "GC000443": "aaba0d7d434f46ad", + "GC000444": "fc7e3cf093ed80b8", + "GC000445": "c198c813815e578a", + "GC000446": "53294304ede0f7b2", + "GC000447": "0fb9979008c202a1", + "GC000448": "f9243ff390ae90e9", + "GC000449": "48da069b4650f45d", + "GC000450": "7f89b0ca48852cdd", + "GC000451": "6cae33da8d2416a0", + "GC000452": "ca0a827b8d4ec0b9", + "GC000453": "aae0fc97a5b5dfa9", + "GC000454": "5c62953be469dba1", + "GC000455": "4e52bf8164df1ec5", + "GC000456": "24c2bf1273203545", + "GC000457": "13e1a461e52c3168", + "GC000458": "4ee3298e2845576f", + "GC000459": "af9bd1469beec9eb", + "GC000460": "4599998a2d33ac6c", + "GC000461": "0b5cfeda73ae9239", + "GC000462": "a275f3c64b188eda", + "GC000463": "a275f3c64b188eda", + "GC000464": "f938ca98fd791d29", + "GC000465": "04ed885342d126da", + "GC000466": "473b30bf38f289bf", + "GC000467": "db9eb1af9f9b9bb8", + "GC000468": "9a82cae1af1969bb", + "GC000469": "7a2b03001ba6e057", + "GC000470": "744386b1a8c8927f", + "GC000471": "a13ed2d95a3f3155", + "GC000472": "da8b15cd3778374a", + "GC000473": "3b5745eecfce4213", + "GC000474": "7fc63feaa0c1c797", + "GC000475": "5cc8f64b8dcd55dd", + "GC000476": "aaaf23c47848cbe4", + "GC000477": "468c887a419b6793", + "GC000478": "395b8dc781ab7e85", + "GC000479": "df9c86cc1947e717", + "GC000480": "8d9807039f98bf9d", + "GC000481": "675f440ec88580d1", + "GC000482": "e419dbeee3135e18", + "GC000483": "a76cdea1f06f33e0", + "GC000484": "d91aa873e7dd6789", + "GC000485": "d91aa873e7dd6789", + "GC000486": "aa3fa3f6b4a21ecb", + "GC000487": "ed1eb533b52714db", + "GC000488": "79e6b3db3e51cb87", + "GC000489": "3f926b355cefaa68", + "GC000490": "a8ab4963c623fb14", + "GC000491": "74236ec4a397990b", + "GC000492": "d7481664a8208c1b", + "GC000493": "7881101e0351e483", + "GC000494": "ebae29835c57e845", + "GC000495": "e7e34a57159558f8", + "GC000496": "ef2fbeb9f5c53608", + "GC000497": "b8e67dc7d5a6d9f5", + "GC000498": "5a0a1f6b826e9fbd", + "GC000499": "24f5a56f014438d3", + "GC000500": "f695564512e71d41", + "GC000501": "7c3a27189202496a", + "GC000502": "25695fecf7ded260", + "GC000503": "116f8514271a7b8b", + "GC000504": "2b3f6354db90e7cc", + "GC000505": "2d4070d17013d454", + "GC000506": "ffe5b631feab2967", + "GC000507": "66731d8858f89260", + "GC000508": "147eb67c08324a37", + "GC000509": "66731d8858f89260", + "GC000510": "06f4f233442ec506", + "GC000511": "894214bd003adec9", + "GC000512": "f03c4be0b2a96d20", + "GC000513": "6bd923d7bfa85d4c", + "GC000514": "a4cd2d29b0b15a8a", + "GC000515": "5af56e54590b6039", + "GC000516": "7a96ec2e52c7dd7c", + "GC000517": "b3613c9d7938e85b", + "GC000518": "caf3963e6652ae82", + "GC000519": "5b149ad5a3516937", + "GC000520": "7dd4bc390fc3ff93", + "GC000521": "9d261610e50e1b26", + "GC000522": "5e2f8544ffc884f5", + "GC000523": "99d45f0596965cb0", + "GC000524": "58ceea16ae35eac9", + "GC000525": "cbf5a8917700f9b6", + "GC000526": "cbf5a8917700f9b6", + "GC000527": "16b7bf7bd49d4f07", + "GC000528": "d049de1836a9ee66", + "GC000529": "e2fcf006ec6c17a6", + "GC000530": "7b7c5d7ae98906ab", + "GC000531": "e812d5622b2c5500", + "GC000532": "e4c58a11b42694e9", + "GC000533": "d2d80ad51d91e68a", + "GC000534": "1d68a8a59468235a", + "GC000535": "f4d9dfc7eade0474", + "GC000536": "faee1c1b69a964c5", + "GC000537": "63f64df37d2869c8", + "GC000538": "9712ddf3092cd144", + "GC000539": "1e0084715819eb51", + "GC000540": "f4d9dfc7eade0474", + "GC000541": "faee1c1b69a964c5", + "GC000542": "1c5e96be648eef87", + "GC000543": "7cc09487dc72dd28", + "GC000544": "63ad3efed7249aab", + "GC000545": "44d0d3aa14906581", + "GC000546": "4660617a2f5291d4", + "GC000547": "2c8b10bd7b8de584", + "GC000548": "08435f2b1accd59f", + "GC000549": "cbc28a7c71218507", + "GC000550": "f7a75612f0f77462", + "GC000551": "ad91718180bf4b2c", + "GC000552": "7b447abde20efbe3", + "GC000553": "12eb0e5dcb5a4cb1", + "GC000554": "4d51fbb8543088d4", + "GC000555": "6a1cec5fd0e3894e", + "GC000556": "29a7ad1a1f71518b", + "GC000557": "9a5c3f5227e38d6f", + "GC000558": "015430a7c3037364", + "GC000559": "9fbd70deea84e5d1", + "GC000560": "1e0926891d886b60", + "GC000561": "e839b6097c17f0e6", + "GC000562": "d3757f0d0d0c46e2", + "GC000563": "aa508a4308161daa", + "GC000564": "7ca2bda1b0ae7162", + "GC000565": "8ae6a355eb402677", + "GC000566": "490140d715bcc66e", + "GC000567": "cd74ea2e0a71438a", + "GC000568": "86608ca0deabfa88", + "GC000569": "9440372e1e8ff008", + "GC000570": "6c5ed3881ed75be1", + "GC000571": "84fbe26c3418e5d9", + "GC000572": "d7dafd54908d640e", + "GC000573": "e0163bbd28fa137b", + "GC000574": "339e26796ffd476d", + "GC000575": "33a8cf3ccf0c761b", + "GC000576": "7fc9379a97227a85", + "GC000577": "a0a93c91c2715877", + "GC000578": "a61734e7cc3508d0", + "GC000579": "71e85c3475922f49", + "GC000580": "430d745cc7070cbd", + "GC000581": "94c35362b64ea877", + "GC000582": "574145187e959b2b", + "GC000583": "4fc7668fe8a9ac49", + "GC000584": "40c0830a7eaf0b91", + "GC000585": "7c1bd4549d17dc93", + "GC000586": "afad8ccafc9d18f1", + "GC000587": "6f33d0fce9594a3b", + "GC000588": "fcfb1ddea554a593", + "GC000589": "5616dc674a53cb92", + "GC000590": "486c681c97c23baa", + "GC000591": "861c510bee03a688", + "GC000592": "3887c51649fcf745", + "GC000593": "ac92e6045630007b", + "GC000594": "e063c59e2ebb7097", + "GC000595": "c5afa5202e666647", + "GC000596": "1780d678e1530445", + "GC000597": "167d340467339c25", + "GC000598": "2e5725f7df99ed9b", + "GC000599": "376fc10a5180c477", + "GC000600": "d86b9d1823c83f24", + "GC000601": "08fde41bb7cb4c37", + "GC000602": "93580b9a43898cc6", + "GC000603": "d2cda11b58f91d59", + "GC000604": "d363b1141999a529", + "GC000605": "29b2c0f44e652deb", + "GC000606": "c7fc2a480a005bc8", + "GC000607": "2f108a6a9fd0803b", + "GC000608": "03a70fca9e46f911", + "GC000609": "dfa272c7f7c2d041", + "GC000610": "801168b5a820a45e", + "GC000611": "b4d51973238a9936", + "GC000612": "6b1e7f8a0779935e", + "GC000613": "4238a156fe31be52", + "GC000614": "1d63649c8bbc8140", + "GC000615": "39551a289a3bc0ca", + "GC000616": "13b12e6ea47f1397", + "GC000617": "6a384d28fdfa0d48", + "GC000618": "8c0f5f34c1db6620", + "GC000619": "34c01395cf558e38", + "GC000620": "13a87d443b54bb06", + "GC000621": "4c7159b2417ac1fc", + "GC000622": "34b7505ea6510537", + "GC000623": "d0465a3d4bcd3bd6", + "GC000624": "7aa632f7e86abaca", + "GC000625": "4d5a60d4047cc2e3", + "GC000626": "66cadc508b86a07b", + "GC000627": "299f020dee1a6a56", + "GC000628": "c8f2ce1594775240", + "GC000629": "4790c4a60ff69089", + "GC000630": "2a418056f3bcc95d", + "GC000631": "32602d91c8761da8", + "GC000632": "f84afb890984ed59", + "GC000633": "f607534124d50438", + "GC000634": "8051ff9d7b1d4406", + "GC000635": "7f43f1374857b91e", + "GC000636": "cef1ca54177d44c6", + "GC000637": "311c4246ff98e1cc", + "GC000638": "b2ce310564b521c3", + "GC000639": "c060dee86a0950ba", + "GC000640": "d00aa3c7888f3190", + "GC000641": "4cd5fadb8f4cae6c", + "GC000642": "83e03cf972e7450c", + "GC000643": "0b4130079859ae06", + "GC000644": "7afe666e2b02a57a", + "GC000645": "95d7cca9707a5290", + "GC000646": "acc1b2d2d0d5cf5a", + "GC000647": "a847b741484426dc", + "GC000648": "3320f578ddbca8bc", + "GC000649": "2bfa6f843406473e", + "GC000650": "a1f1d2790473a2e4", + "GC000651": "4dbb7e5668a80fa1", + "GC000652": "6e97e197fd051ec9", + "GC000653": "70862a416df85949", + "GC000654": "3c4f49f4627d110c", + "GC000655": "5f5428107544742f", + "GC000656": "284de96c29f0c90e", + "GC000657": "882d114d0bf65f81", + "GC000658": "dbf0ffb608d8723e", + "GC000659": "8177882a33d255d8", + "GC000660": "562fe45378b7c9b7", + "GC000661": "db9768ef41270c51", + "GC000662": "77c432430f95ead4", + "GC000663": "931c00fcef6f5d0e", + "GC000664": "66c197ea91acd5f3", + "GC000665": "0171d304a64640f5", + "GC000666": "70adb1de64c18dc0", + "GC000667": "1d3639a3c5332665", + "GC000668": "ad73a7bf7d2a4275", + "GC000669": "23377bab152a7222", + "GC000670": "30a2aefc4586a2ee", + "GC000671": "770a8caf37ed46a5", + "GC000672": "dc53bf3ce5f289b2", + "GC000673": "3da81c6487b9b7cd", + "GC000674": "619c4910c4e07ef5", + "GC000675": "475dd6bbe544654d", + "GC000676": "d77c7de625a8ae47", + "GC000677": "f5660b8aec1f4112", + "GC000678": "a2b7225641e8314d", + "GC000679": "4063f19c45bcabd7", + "GC000680": "2e27f9f59b436d9b", + "GC000681": "125e9d8824a615c0", + "GC000682": "c0c94d121309a210", + "GC000683": "ef4abf0daf6f276e", + "GC000684": "8036e1606272664a", + "GC000685": "102e92843f00870f", + "GC000686": "2d2cc152589c7d7e", + "GC000687": "5c579207ba2778c7", + "GC000688": "41268b586f9eb25f", + "GC000689": "322c52aa0f3cde61", + "GC000690": "22d855ddb2c5484f", + "GC000691": "3796b2a06e90425e", + "GC000692": "776a07b6c6e20cfb", + "GC000693": "d9e5f3864879629f", + "GC000694": "3b67260b6b307a7a", + "GC000695": "b8465e8cd4bc3b24", + "GC000696": "98867a3d5dc940b6", + "GC000697": "d0feb8aed34db1ee", + "GC000698": "b169a3ea455f50e8", + "GC000699": "007edbdaef63554c", + "GC000700": "d3cbc50ecc748124", + "GC000701": "29710d26ca7dc3a5", + "GC000702": "a98a7b24ddd8d4cb", + "GC000703": "ea4d9b6d69edc37d", + "GC000704": "7206b8e8fdc1153f", + "GC000705": "b598b2fd7a2b6053", + "GC000706": "27826dd815e98062", + "GC000707": "0a5dd7dcbe810eb1", + "GC000708": "ffaf19a3e4856a4f", + "GC000709": "4db918d837563f8a", + "GC000710": "e9e7459573d45c46", + "GC000711": "3c593c42fbf2d684", + "GC000712": "d38c28f312b0294e", + "GC000713": "d202720ce890f40d", + "GC000714": "8510add0e8f69c92", + "GC000715": "ca12ae2dae1da030", + "GC000716": "d9ff6ebd01214024", + "GC000717": "90eb046f002a507e", + "GC000718": "8a855aedb171d079", + "GC000719": "412fabe2c0c2d83d", + "GC000720": "4f0accb7cc732189", + "GC000721": "731b8b31155c290d", + "GC000722": "a20bd4a85779311d", + "GC000723": "dc85a67045b92657", + "GC000724": "e24b826a2a24f055", + "GC000725": "3d6a8a41d4911866", + "GC000726": "515950bfcb998d30", + "GC000727": "ca6ac422db5ac73e", + "GC000728": "d1efc682587f6e7d", + "GC000729": "3acb02144654433c", + "GC000730": "84f7b631b63b7759", + "GC000731": "e339370f83b2ccdc", + "GC000732": "97b58e576eafd34c", + "GC000733": "ea814de553a078a2", + "GC000734": "859f3d9944cbdb59", + "GC000735": "8d88bac004ac25e9", + "GC000736": "d68f08b811070662", + "GC000737": "0d528b3616924de5", + "GC000738": "ca8748fcd7a4ba01", + "GC000739": "17da4513adab93f2", + "GC000740": "bc90a752410e1c84", + "GC000741": "f59855175df9e580", + "GC000742": "139c1b972139318f", + "GC000743": "ce99159e358b9bfe", + "GC000744": "72237153ab8bdd2d", + "GC000745": "7781b0d7ea522dcd", + "GC000746": "dafeb8d3b1d631af", + "GC000747": "bdbe8f0bc0a28ae8", + "GC000748": "4ff344e19b6abe49", + "GC000749": "f4a4a30357905aa0", + "GC000750": "acafcf7f568beb52", + "GC000751": "6ad55af562df5443", + "GC000752": "d8e0795628672bd5", + "GC000753": "b4100303eb1a1ce5", + "GC000754": "be5b9a508cf496a9", + "GC000755": "be2b346a970de8a7", + "GC000756": "6b1a67252091ff36", + "GC000757": "64d406ab6ab93164", + "GC000758": "64d406ab6ab93164", + "GC000759": "7fc6fd24a0511f08", + "GC000760": "df0c02317b68666c", + "GC000761": "4565a4c710acf471", + "GC000762": "d53b2ce4f5a9de54", + "GC000763": "d2c538c8ef97d812", + "GC000764": "3e83aa283432ce01", + "GC000765": "8b6a154df0919903", + "GC000766": "a92708cc4f4f352e", + "GC000767": "e81d4fc93fd00a9c", + "GC000768": "af8f61ca743b08e5", + "GC000769": "62cefefc2a2b89f2", + "GC000770": "7d1bea43c6411266", + "GC000771": "721a058358898206", + "GC000772": "ed607ea1caed3b2c", + "GC000773": "946415495049f3bf", + "GC000774": "0ddc3e262a0e035d", + "GC000775": "96087a7d72d31b2f", + "GC000776": "f3916b3868ccd35c", + "GC000777": "dc906d0dd3cda362", + "GC000778": "cb646b5c5e065f3e", + "GC000779": "d60e4a6caeb836e3", + "GC000780": "f1fd206aea99b0d2", + "GC000781": "94eb80b116cf29c6", + "GC000782": "ab8eaad4327fc349", + "GC000783": "5812cba9e8d5273b", + "GC000784": "fef0219c559682ae", + "GC000785": "626c612fec27860c", + "GC000786": "29a1800bf284b7d5", + "GC000787": "515bb463be073cf6", + "GC000788": "d170e880fbe005bf", + "GC000789": "f709895ac5ca821b", + "GC000790": "53277337529a27ce", + "GC000791": "6c418e483f22a38c", + "GC000792": "71ac6687eeb9f613", + "GC000793": "e495163b171f7306", + "GC000794": "8a4015e630e21a7a", + "GC000795": "1cbe0018fc02bc18", + "GC000796": "cd71e36489e91846", + "GC000797": "5b090a741861c936", + "GC000798": "b7b899bb9c9625ab", + "GC000799": "28da22079acdb5a0", + "GC000800": "e760eeb08a5610d1", + "GC000801": "d55008a803cf345b", + "GC000802": "f9088dc661adcbc9", + "GC000803": "950d305053c89c0a", + "GC000804": "1a08da8910fcb276", + "GC000805": "0e33178ac0a8dbb5", + "GC000806": "7ac5eda8148e9494", + "GC000807": "e15e766bfb5e0ef2", + "GC000808": "a73c26305a1331cf", + "GC000809": "655e734cab832b52", + "GC000810": "2cec932085ec016f", + "GC000811": "499b4da193dffb66", + "GC000812": "48442fe6318e8872", + "GC000813": "85d50046b89e01db", + "GC000814": "b962e0973fb0f862", + "GC000815": "874887dde3cafb8a", + "GC000816": "cd9c724d6f475dca", + "GC000817": "987ff79e2e8db70d", + "GC000818": "55548cb33a2a38f6", + "GC000819": "5c502dc187827923", + "GC000820": "eb96ae0380b812c0", + "GC000821": "178f1f8da8cf356d", + "GC000822": "0ded040135c71cdc", + "GC000823": "5c8a2ea46b42444d", + "GC000824": "c5fb0b48688b297b", + "GC000825": "e4243699eceaba5a", + "GC000826": "1d352de033ad695f", + "GC000827": "ff2c09e4313ddd64", + "GC000828": "1c1e6ca2f18e0422", + "GC000829": "5a8ce41f21cc5cd6", + "GC000830": "646be8362c6fdecb", + "GC000831": "3bfef117674ba78c", + "GC000832": "85eb99eda917aa56", + "GC000833": "3e1dbdfa9dbe0ac4", + "GC000834": "0122b8544410c12b", + "GC000835": "3934eb93f35bed80", + "GC000836": "097fe590efd99903", + "GC000837": "a5ea998318581da1", + "GC000838": "8d5855a1374f977c", + "GC000839": "a3166647b599e73e", + "GC000840": "2effda474edbf237", + "GC000841": "065d2256365f4eba", + "GC000842": "e032b955ffe9c8a6", + "GC000843": "efe9d141b51d8ff9", + "GC000844": "e7776288ac2d0b75", + "GC000845": "5aa2848631045286", + "GC000846": "29122063893ded23", + "GC000847": "64fe6145805c2e1d", + "GC000848": "f5387c96eb4ef043", + "GC000849": "21b8ecc17e9ab895", + "GC000850": "db3c06787fcfbe56", + "GC000851": "9119082a5fb563f4", + "GC000852": "92dd8978fc627068", + "GC000853": "21b9e0bafa3c5fc2", + "GC000854": "9b2bfa46a1d7c7dd", + "GC000855": "9f3a2b38b3848a07", + "GC000856": "bf23149883a73b35", + "GC000857": "aa8400207c20afab", + "GC000858": "50bec9ad9e168c58", + "GC000859": "37014ddc310df7b4", + "GC000860": "f4410048cc6efdac", + "GC000861": "a9d13c49fed90f8c", + "GC000862": "5a9e66a9826ca5c6", + "GC000863": "5712e6213b09990e", + "GC000864": "059c0936d11e7412", + "GC000865": "9c476209f24c5d1c", + "GC000866": "ee34bf32af6fe20c", + "GC000867": "14e69c64036a7b81", + "GC000868": "f44549d250ea7403", + "GC000869": "a6e78f68b1391359", + "GC000870": "56dcc09896d6c768", + "GC000871": "9b075b64379aabc5", + "GC000876": "e1d54177bc315382", + "GC000877": "68879e7c0afea1ed", + "GC000878": "63d996779f923c2e", + "GC000879": "1369d10da3874649", + "GC000880": "c68bf58c3c25f4b4", + "GC000881": "e510f364947382e0", + "GC000882": "a5a91204fb767e6a", + "GC000883": "c078ec2863f6431b", + "GC000884": "6b460980b8e3a9d7", + "GC000885": "2ed818e630829a8b", + "GC000886": "701c168f2bdf14e7", + "GC000887": "072e8d18e0a2df9f", + "GC000888": "4ee4e2a9a85b3763", + "GC000889": "4336c0f4f5593a97", + "GC000890": "d349803e0759fb65", + "GC000891": "c532253640a76783", + "GC000892": "4831e33ae107d5f3", + "GC000893": "060a59e01b24d088", + "GC000894": "a81746803e0ef427", + "GC000895": "c6016df121e66c29", + "GC000896": "7c5a997e36a4b292", + "GC000897": "cc84403ec560f27c", + "GC000898": "12225d8f1e735588", + "GC000899": "8f585d46b9c00b89", + "GC000900": "c18984d48eb8e746", + "GC000901": "d249a941b8faf7df", + "GC000902": "623091dc60e94b9c", + "GC000903": "6b953bf97fff9139", + "GC000904": "3c23dd5f5653ff94", + "GC000905": "fe7966bc5058dfdf", + "GC000906": "99c5e10767427727", + "GC000907": "c73c199d985b3cc4", + "GC000908": "7bffed9304803f44", + "GC000909": "669a1cc79decae9e", + "GC000910": "ad299f1c1cd17243", + "GC000911": "7ef329d1f6d717c3", + "GC000912": "2a70d0824faac80b", + "GC000913": "814051575beb9e9b", + "GC000914": "4a9703b27ada7633", + "GC000915": "2b21137e301c58f2", + "GC000916": "2c213963d40a8f09", + "GC000917": "562b25590756cb52", + "GC000918": "6c7fbe82ba97c6c7", + "GC000919": "7f1ef43e45591f01", + "GC000920": "d92ed21b02b3609e", + "GC000921": "dccd82ae534e42b0", + "GC000922": "f4b16cc2cea9f587", + "GC000923": "b3df4f8442b5dc24", + "GC000924": "e4680416d314b0f3", + "GC000925": "3ba2058b0d13fceb", + "GC000926": "796aa2be5d7d0638", + "GC000927": "c3a6c3c9f5dead50", + "GC000928": "4d90275bf55471e6", + "GC000929": "8579db531e8abd16", + "GC000930": "dc4de5f16d45a862", + "GC000931": "2431c735144b4359", + "GC000932": "aaf497bf8b48906d", + "GC000933": "9e491dca9170049c", + "GC000934": "4ae228fe8500299b", + "GC000935": "ead30ce15c8b332e", + "GC000936": "b12c0db372f3b0d6", + "GC000937": "2a4b2a5ef6dcde84", + "GC000938": "1cd83ee850bb0469", + "GC000939": "942382f4e0689449", + "GC000940": "365806fa96942653", + "GC000941": "f5bb181ca26bea7d", + "GC000942": "1bbff6b92d4be049", + "GC000943": "eb31c5c1e7c33059", + "GC000944": "04d343c65e702a72", + "GC000945": "1a4f93b1602a9515", + "GC000946": "175d5c24c1750075", + "GC000947": "fcf250194ab904c7", + "GC000948": "9384e52180e105a1", + "GC000949": "fb9bfeee82706414", + "GC000950": "f7cf3a1de28b23ff", + "GC000951": "43b7eabee06974fd", + "GC000952": "c593828ba6913e8b", + "GC000953": "c775d570978c4862", + "GC000954": "557f814bc08284a0", + "GC000955": "0bcc92857e6ddc91", + "GC000956": "eaf893af7b220a28", + "GC000957": "7e5c5059a0155cee", + "GC000958": "e008cca10c543ca0", + "GC000959": "e4686c819dfefddc", + "GC000960": "3fec9eb9c91def2a", + "GC000961": "e6da8a34feb4973a", + "GC000962": "15ec628a4ba39526", + "GC000963": "6295c65646915b2a", + "GC000964": "5202d3461e99dbe2", + "GC000965": "53258e03f92dbea7", + "GC000966": "2da3948961a71a1e", + "GC000967": "2da3948961a71a1e", + "GC000968": "9f397e69c1910fd2", + "GC000969": "a050ceaeb347cce2", + "GC000970": "55f3a77b57a875a2", + "GC000971": "55f3a77b57a875a2", + "GC000972": "8753e3633c3a315b", + "GC000973": "f00a65b2aed3c179", + "GC000974": "c6c6f24acdd81129", + "GC000975": "fcd3f1cc7e8de0b5", + "GC000976": "ab604ec378c14055", + "GC000977": "0d938c485c5321f6", + "GC000978": "1788013e6339af56", + "GC000979": "e88dcb406f6d3a6c", + "GC000980": "2dc01638604aef2b", + "GC000981": "100b689fb03a080e", + "GC000982": "250ca842a337da77", + "GC000983": "87ab123c4dbcff36", + "GC000984": "3832b5b337ec4b31", + "GC000985": "a3f84ce56753bb95", + "GC000986": "b0e0a9283f982b71", + "GC000987": "457527231c70d67a", + "GC000988": "12f93a62cbb07d3f", + "GC000989": "769a1b9fa84555b6", + "GC000990": "441535b35efba686", + "GC000991": "eb05d6e7829867d7", + "GC000992": "92ec8ee6eeab79c1", + "GC000993": "5599960b070af760", + "GC000994": "5033d6d727a90e52", + "GC000995": "b29906faf5836dbb", + "GC000996": "fcced1b90bbdce56", + "GC000997": "943dab0d3c124d55", + "GC000998": "fdeb0955966de51d", + "GC000999": "8b21966a553ef00d", + "GC001000": "b11f1fc4d7ec157f", + "GC001001": "19567c1a58cf1c62", + "GC001002": "685a3226e6d8ef47", + "GC001003": "16d10173a1fe3e2f", + "GC001004": "a9b2953e82a1239e", + "GC001005": "90f61372d1e8a351", + "GC001006": "2260a6098b4cf477", + "GC001007": "4e377be1caa394e8", + "GC001008": "4a7fdae06e512ae4", + "GC001009": "f0f95c187101fe54", + "GC001010": "e0311716ef21734e", + "GC001011": "f083bec3d77752e4", + "GC001012": "67bfc3599780b972", + "GC001013": "c27329591b62f02a", + "GC001014": "d2496909501014e6", + "GC001015": "7dad53c7ad35d14f", + "GC001016": "033e8a8f9a95e2a0", + "GC001017": "457a9e2efe99355e", + "GC001018": "a58fce5d6651f478", + "GC001019": "dec9e04b94d1aa9e", + "GC001020": "1af78074604b8744", + "GC001021": "ed3036a14c0ad921", + "GC001022": "a55e162cc0813466", + "GC001023": "7dec76f17eb788fb", + "GC001024": "b558d311a5892554", + "GC001025": "a524176df4bb9715", + "GC001026": "8307164edcce8a23", + "GC001027": "395f0396953f1244", + "GC001028": "96a2f2a21fe24b88", + "GC001029": "b7e377f1f0df1382", + "GC001030": "beffcfe55717bd75", + "GC001031": "e063f7db916fc02c", + "GC001032": "1b734a7dab524909", + "GC001033": "5e23eba011d49862", + "GC001034": "2ffdc3e8bb7f87b5", + "GC001035": "2d9d02b2eb78624a", + "GC001036": "b1e3244048eae312", + "GC001037": "f674336998e63bf0", + "GC001038": "9c9fa1246c3d1e6f", + "GC001039": "335e4696d0302eb7", + "GC001040": "032354e5f9789481", + "GC001041": "70980d9c00d53fd5", + "GC001042": "ed477c3949cee530", + "GC001043": "a34643678c55aede", + "GC001044": "d66eb0b310c712ee", + "GC001045": "2b1563cdbe79af94", + "GC001046": "430cb9630c56a900", + "GC001047": "a31176e49b99dca0", + "GC001048": "17948ad5dc2c56b4", + "GC001049": "a1b7accfa5b18587", + "GC001050": "9585f839cc5a737d", + "GC001051": "1e70b07bad033ab3", + "GC001052": "fe66604feff02485", + "GC001053": "867f093f8f613de2", + "GC001054": "da8e91f6d5a1ce60", + "GC001055": "87fbc095cdf41768", + "GC001056": "ddd8dd53f27b0c3e", + "GC001057": "2b42b45756a51426", + "GC001058": "7d870d4ed1e86073", + "GC001059": "c399d9137b8d6397", + "GC001060": "681fb6318eae5dac", + "GC001061": "678dd08145137ec2", + "GC001062": "c46abd59a0464bd4", + "GC001063": "dbc957c2c2bc0663", + "GC001064": "2eb310002a652862", + "GC001065": "8f86c435d9f96ddc", + "GC001066": "38cbcc27018861c5", + "GC001067": "3ec4defb1143c241", + "GC001068": "854d7f4e0e6aed66", + "GC001069": "892ac4f2fdc8f0a8", + "GC001070": "3625d62e4407132d", + "GC001071": "92945140d473cab9", + "GC001072": "1f803a6bb403602e", + "GC001073": "7c9159fc539c99f9", + "GC001074": "b7554ef994b96a83", + "GC001075": "bbbe3548fc7ffa06", + "GC001076": "acf2cf17e33aff7c", + "GC001077": "bed59e3d4837f945", + "GC001078": "79c112b797e5c907", + "GC001079": "4b4d8f10e15b0f66", + "GC001080": "ff870486aefbffdb", + "GC001081": "02fb1ffdbf28dd6e", + "GC001082": "39a2d35bba4f66fd", + "GC001083": "a12993a7b4845c4a", + "GC001084": "6d7f2d0419a17dcf", + "GC001085": "f3d04ad844926bc1", + "GC001086": "bb33acd2bd567154", + "GC001087": "1b2940f63fad92e9", + "GC001088": "84612f7ed1d55741", + "GC001089": "0966132e160ba45a", + "GC001090": "f2a4072ce598cf77", + "GC001091": "c0ea36039b59f399", + "GC001092": "3f9e993ffbd7c9fd", + "GC001093": "f840f12d2a391310", + "GC001094": "9bfe9f87f29d5840", + "GC001095": "e2d2adfd6de41e1d", + "GC001096": "8ee252b04084805d", + "GC001097": "ce7a15391540dc4a", + "GC001098": "6c049ee74d34cbf0", + "GC001099": "0e375e694a5d8a32", + "GC001100": "176acc290cf2d317", + "GC001101": "56cf3d47bc4399eb", + "GC001102": "f4f523c271c4830b", + "GC001103": "5670f4efa80b7616", + "GC001104": "63aadfaf2cb4fa18", + "GC001105": "2b1b60ddbe13ca38", + "GC001106": "bfeef3f679a47b23", + "GC001107": "e6d755f4daf387a3", + "GC001108": "92aed2e36b94d5d5", + "GC001109": "f34effccc20d245e", + "GC001110": "de31681225736151", + "GC001111": "fa2451846289b8ab", + "GC001112": "e287967e67d9f0a3", + "GC001113": "f477eff692241d03", + "GC001114": "07f2ea61030d1d34", + "GC001115": "909426a44b2c9c4a", + "GC001116": "1a884834a1c5ea3c", + "GC001117": "306051951e0b60a4", + "GC001118": "59cc715f43876717", + "GC001119": "78ab520638cec169", + "GC001120": "5638fc48dec795c0", + "GC001121": "6f050b3af9577d0a", + "GC001122": "974ada4de6791b61", + "GC001123": "922cace1bf4d16b6", + "GC001124": "03fa3036ffaa080a", + "GC001125": "146c66374315f431", + "GC001126": "986b2c7733b93357", + "GC001127": "a4eff242437d373a", + "GC001128": "be633cf67a0dc56d", + "GC001129": "e6d40b6ad8fab00c", + "GC001130": "d6794a38717b83c2", + "GC001131": "feaabf6ed8e30da1", + "GC001132": "d3696d42c180301a", + "GC001133": "727c98926db72eb0", + "GC001134": "41d2a505e8b0dddc", + "GC001135": "6bb122f1ab67749f", + "GC001136": "e99d65c933dbb22b", + "GC001137": "36cb464ebdf3dc4e", + "GC001138": "b8d81fcba9aff4d8", + "GC001139": "751e72b7fc88e0ad", + "GC001140": "da246ee736f3223a", + "GC001141": "ae725c5adb0527b0", + "GC001142": "f185438f9821169f", + "GC001143": "5a9c7f8fac68c91a", + "GC001144": "134777fdb64fc57d", + "GC001146": "c5e3479de922b645", + "GC001147": "fd200af97a31fbb5", + "GC001149": "bc59fb543dd3db23", + "GC001150": "7c86f0a11b0a18a6", + "GC001152": "88aedb642ad24f1a", + "GC001153": "a52ba223caf36662", + "GC001154": "52eecfb2c01dd387", + "GC001155": "388041e3973b528d", + "GC001157": "bf05b024f88e675c", + "GC001158": "cca0637d7e117763", + "GC001160": "d602a8259a8ba039", + "GC001161": "b774471d2b9ff104", + "GC001162": "f3021ba11596010d", + "GC001163": "61ab002f226c33a9", + "GC001164": "c2564d7fbe4a0b20", + "GC001165": "815e6c7bf92d8dcf", + "GC001167": "2bbfed5b08f52578", + "GC001168": "d70382c35f8c4f51", + "GC001169": "cd50a51320f0f16d", + "GC001170": "21ac91b06518ddac", + "GC001171": "ef074d00d224932c", + "GC001172": "55ad4be3a4ede107", + "GC001173": "14c317a6d1e4cc92", + "GC001174": "f6b06b29c6d171ca", + "GC001175": "604b851ee7c19f4d", + "GC001176": "b510d105fa7cea33", + "GC001177": "f43c45f22780f59e", + "GC001178": "43b88d9ec63f4d79", + "GC001179": "0284b2a1642022f2", + "GC001180": "8470f0134a9c5aca", + "GC001181": "13c4434b7300d27f", + "GC001182": "dcdc29fa5c9d0ac1", + "GC001183": "e044cb9c618975f7", + "GC001184": "ee68ac4a28834acb", + "GC001185": "b2d34ddef08d44dc", + "GC001186": "b05eeaaa19ceb913", + "GC001187": "583365b1cd85f7d6", + "GC001188": "7d98417e4cd39ad5", + "GC001189": "b7baf4849f7907d8", + "GC001190": "a84c3a5e704cdf8f", + "GC001191": "319c2d3b33b82501", + "GC001192": "5d9d97f40575678b", + "GC001193": "26e804ce5ac12551", + "GC001194": "55372636b0bc4840", + "GC001196": "d7eece6cfb557f60", + "GC001197": "eb36702baf6d2220", + "GC001198": "546372e72abf04d4", + "GC001199": "f69677f85463240d", + "GC001200": "874f6fd45351a1b7", + "GC001201": "874f6fd45351a1b7", + "GC001202": "d8ec9c69f1d7de86", + "GF000001": "55372636b0bc4840", + "GF000002": "02f089c8823ac307", + "GF000003": "b28b03ee68e7846f", + "GF000004": "1b0765c1fdd2ceb7", + "GF000005": "c3c5c4d86948bac6", + "GF000006": "9eb51e754c667391", + "GF000007": "97a6b65ca428fad6", + "GF000008": "45bf18fea8e0dae3", + "GF000009": "faf87acce631cb4a", + "GF000010": "de7f54bf2c330521", + "GF000011": "b9d922b76257f9d0", + "GF000012": "13d488dbebfc53e5", + "GF000013": "db44362774a0c37d", + "GF000014": "cd91a2c268fddce5", + "GF000015": "c3f2490375a41949", + "GF000016": "e1ba6d7096fedbb4", + "GF000017": "f4be53b07de16aa0", + "GF000018": "c20d048cbc23ba3c", + "GF000019": "a5ecba323ad3adbc", + "GF000020": "d9f42891fc9d19d6", + "GF000021": "434c7c90214e29aa", + "GF000022": "cbb50496730b5edd", + "GF000023": "fc266488dd7f8aab", + "GF000024": "06a5b7d6d752ffef", + "GF000025": "413e1297c5765ad3", + "GF000026": "a45c6d51cd8bb3d9", + "GF000027": "286729d9f84206e0", + "GF000028": "ad6872416be21a67", + "GF000029": "4fa577c78c431e4a", + "GF000030": "8aa6224f3786b0d2", + "GF000031": "b04a5cb89f5e53fc", + "GF000032": "605d543c2b08f707", + "GF000033": "c9f7f0bf52200faf", + "GF000034": "b03f8201a7f61a1f", + "GF000035": "459b3ad7099f1f30", + "GF000036": "97b57a694e97955d", + "GF000037": "0766e66368701140", + "GF000038": "0766e66368701140", + "GF000039": "8a01ecd63377e15d", + "GF000040": "43550d9406a88e91", + "GF000041": "c54c2208271f79a4", + "GF000042": "2ace67e81528847f", + "GF000043": "eba3448c33cf7eea", + "GF000044": "8d619023e4639ab8", + "GF000045": "c0a66b6d97189c12", + "GF000046": "69c699d288f7d158", + "GF000047": "3023c0d80f0735c8", + "GF000048": "abed4f5c8373cddc", + "GF000049": "f6cd19750cba340a", + "GF000050": "e434796faa483cf9", + "GF000051": "f2e5d20bf7646aa6", + "GF000052": "ab08c0e49380defc", + "GF000053": "55372636b0bc4840", + "GF000054": "aa34b02f3f1fd1d1", + "GF000055": "17655b2ef1b679e0", + "GF000056": "50044cf17101aa0e", + "GF000057": "76c7ac9801f9c287", + "GF000058": "7bdb58644ab03c11", + "GF000059": "a189482d5c6021ec", + "GF000060": "aef70d094cc7c33f", + "GF000061": "a7e3e9a655d2f1a0", + "GF000062": "840aa64111958d52", + "GF000063": "3a125b50a3eefc0c", + "GF000064": "9df540a032f2466a", + "GF000065": "41a30000390c5f64", + "GF000066": "991fbb631d763582", + "GF000067": "e911d24e05ba6e9a", + "GF000068": "1e5d3b4a1a910241", + "GF000069": "1409580c844ebf55", + "GF000070": "10ac5e4e7cd406f0", + "GF000071": "58c751889d78df4c", + "GF000072": "99d2506ecb4358dc", + "GF000073": "6c31e4c2870dc66a", + "GF000074": "ceb4a10f95b6b5da", + "GF000075": "0c83310d5ca267f1", + "GF000076": "576b15067fd12f2e", + "GF000077": "42ee0e8fb7d35b6a", + "GF000078": "a7ad83bf9eb11d63", + "GF000079": "57c08007d04c7a28", + "GF000080": "0a78378615d76be3", + "GF000081": "6f1e1c6650dc2532", + "GF000082": "6842bbbbfed54ba9", + "GF000083": "d0af11b98757f485", + "GF000084": "a7d2492f6c45da55", + "GF000085": "bc3662d379b0bd8b", + "GF000086": "3964ab9101f4cd74", + "GF000087": "8fdbf6b299398d18", + "GF000088": "71632a1882d2f21c", + "GF000089": "def27b3e5711c347", + "GF000090": "9fb5565d4ab5980e", + "GF000091": "8a358cce2782c84e", + "GF000092": "5d6d30b03ebab0fa", + "GF000093": "29a3616459f65237", + "GF000094": "4624e37f28bb1960", + "GF000095": "df09ec05589b12ae", + "GF000096": "1872cbdad965563c", + "GF000097": "2b8e5388c5aee6f9", + "GF000098": "edaebcac53218015", + "GF000099": "5e94fe53c7bb48aa", + "GF000101": "71fc6c00e2bdb5c3", + "GF000103": "6123ec69147e87ba", + "GF000105": "7eceddbcdf77ae24", + "GF000107": "ba4ed6f556a4b486", + "GF000109": "f79af37102135446", + "GF000111": "5880754306f429ce", + "GF000112": "b9439f53473dd7c3", + "GF000113": "fb22b20c4773ff24", + "GF000114": "78e565901a1da215", + "GF000115": "cdbe95ef7c35c08d", + "GF000116": "4286d9e8937493d0", + "GF000117": "4deaeb8e94720b0b", + "GF000118": "5e5489bf54c32d2f", + "GF000119": "bc58b000a9ffcc5f", + "GF000120": "ca302cd5058223f5", + "GF000121": "33ee33757c708be8", + "GF000122": "4fa52d0e17e103fe", + "GF000123": "f213755f4d014187", + "GF000124": "a9cfaf196fb21568", + "GF000125": "7db8452e1de8d408", + "GF000126": "ddfc3a61ca950e08", + "GF000127": "89ab4f425ee8e69d", + "GF000128": "e88778aedc9e092d", + "GF000129": "02e382e1e7eda555", + "GF000130": "f0f86fcde8bf60c3", + "GF000131": "0fbc9651d7e3d545", + "GF000132": "c4fdfc7d01c1f63f", + "GF000133": "184506b5753af449", + "GF000134": "c4be2c2fb950c8af", + "GF000135": "c4be2c2fb950c8af", + "GF000136": "c4be2c2fb950c8af", + "GF000137": "604b7daf45556c1d", + "GF000138": "e2fd19821a1eaec3", + "GF000139": "175f033b3d6b9f40", + "GF000140": "77402698bf38825f", + "GF000141": "031c0a7bf27a484d", + "GF000142": "2a5f100403e2fa58", + "GF000143": "0929fe81d3db35a9", + "GF000144": "41837046fd377f6e", + "GF000145": "2204cc9591a6acea", + "GF000146": "a19565c3a7ef1004", + "GF000147": "e9299ea65592b236", + "GF000148": "14fdfc2edd4e8c3f", + "GF000149": "49ce9126cbd5dd9c", + "GF000150": "20d80f4e2be71313", + "GF000151": "fbaac52f7229ab91", + "GF000152": "bb900a13ea654971", + "GF000153": "5e5489bf54c32d2f", + "GF000154": "bc58b000a9ffcc5f", + "GF000155": "2d2413058fe5dbf6", + "GF000156": "96d6be3c7120c2ca", + "GF000157": "6015f433785ff3fb", + "GF000158": "c882a9665ae57054", + "GF000159": "21d19458353fbbab", + "GF000160": "cd132adc365f967e", + "GF000161": "8b7adfd7096108a4", + "GF000162": "dd151f735930cbf4", + "GF000163": "ef0b3b210f5f09a2", + "GF000164": "93a7340613328a71", + "GF000165": "e4e684919da259a5", + "GF000166": "2358b9b47e9e1efb", + "GF000167": "ea2542da00706e8a", + "GF000168": "a049b4026d4d0532", + "GF000169": "732d9fc258e94679", + "GF000170": "b27037d8cbe3ed02", + "GF000171": "7e5ef5dfe609e03e", + "GF000172": "110e790ca87fb013", + "GF000173": "aeccee759abadac8", + "GF000174": "9c59756c70b121fb", + "GF000175": "5aa7149e467aec4d", + "GF000176": "8ee24f8ba06f052b", + "GF000177": "d890d96d179519c0", + "GF000178": "f8ecfc06566a3755", + "GF000179": "07fd1ae53088f812", + "GF000180": "0c1c2dea593342d5", + "GF000181": "7e62e997b1a30ece", + "GF000182": "f07ae8a695b578ed", + "GF000183": "b3a13280d4c77a27", + "GF000184": "50e6fec5a613c9dd", + "GF000185": "2246e25d73e9a64d", + "GF000186": "c48a245ec5ad4377", + "GF000187": "ac1af5ff04e10985", + "GF000188": "267efec6cc3f9d95", + "GF000189": "eb8ef850cba5a360", + "GF000190": "24112a977b353d0e", + "GF000191": "348677716c05da84", + "GF000192": "fa7f7d800ec8f21a", + "GF000193": "5b0285cfa316d291", + "GF000194": "3f3ae186ab2e8bdf", + "GF000195": "db92df40ad80dfff", + "GF000196": "6189c31e5405cd4d", + "GF000197": "694d17058a92e431", + "GF000198": "baf9b485ca959dd9", + "GF000199": "8fcfc90ca985726d", + "GF000200": "12976f6405aa64eb", + "GF000201": "4061b1e8f2a98b08", + "GF000202": "faaebcb70aec4bc3", + "GF000203": "773dc083e6e44cae", + "GF000204": "ba54056c7cfab8c9", + "GF000205": "79fba9eef0232262", + "GF000206": "4668fdf8b4b401c1", + "GF000207": "35354caed928b596", + "GF000208": "07039c8117c7ebb5", + "GF000209": "f6192bbd082fc075", + "GF000210": "9120d887dcb0f41c", + "GF000211": "5f5d9d84e1235b49", + "GF000212": "9e3c0987547dfb74", + "GF000213": "a86a7325e5311e84", + "GF000214": "26876f5949b63bd4", + "GF000215": "e7a355646dda132b", + "GF000218": "654af8d58723c9bc", + "GF000219": "9c7c8bf4dd387603", + "GF000220": "75a7685ac72271d9", + "GF000221": "cc75f41be89d7135", + "GF000222": "c857b203a42af734", + "GF000223": "50505934699b48ee", + "GF000224": "0c3b028af28a5af3", + "GF000225": "82dd40c87f2ab16d", + "GF000226": "9d843e828de5c5a3", + "GF000227": "09f58ac23619e617", + "GF000228": "8fc731f56f4cbc9b", + "GF000229": "f89a7965a972cd49", + "GF000230": "a9b99bb678803c63", + "GF000231": "e34a174535f0fccf", + "GF000232": "6109cc5d556e08d1", + "GF000233": "5aad77ee785454df", + "GF000234": "929fc7aedd16acfb", + "GF000235": "5b444746c1d5d3f4", + "GF000236": "e0e287c95cae2bd6", + "GF000237": "75391b5e8d801631", + "GF000238": "ed0ab2096c646c86", + "GF000239": "f31e42c70e6aee44", + "GF000240": "7261662b622864ab", + "GF000241": "05d9dbac55df7b73", + "GF000242": "2d758e165e881509", + "GF000243": "e9784bd9041486cc", + "GF000244": "f7e3ba2910167a9f", + "GF000245": "be12c8f792d5c898", + "GF000246": "d753841ea860358a", + "GF000247": "f30cb15df60bc349", + "GF000248": "e05e0f0497cd0ffd", + "GF000249": "a319f577536a5952", + "GF000250": "e2a518ee45cfb972", + "GF000251": "a8b8b713d5fb4d5b", + "GF000252": "a20a6c1259ba125a", + "GF000253": "a20a6c1259ba125a", + "GF000254": "73d91a924a2dab55", + "GF000255": "ac043bbe9640a74d", + "GF000256": "6f51375d8bcd7192", + "GF000257": "4a7eaabff011f0cc", + "GF000258": "b442815a7437e76b", + "GF000259": "09799bb88f3ff236", + "GF000260": "6f51375d8bcd7192", + "GF000261": "7027e8938c8c785e", + "GF000262": "d69a07733768a4d5", + "GF000263": "e619af3a04106d0e", + "GF000264": "8f47595f22d8f004", + "GF000265": "4435cc70b320768e", + "GF000266": "7d45d3ced9f91786", + "GF000267": "d8f11c41c91b7a8a", + "GF000268": "042661b1c83a61b0", + "GF000269": "f086ef9c94efaf5b", + "GF000270": "b0e7b15ba4f42c8e", + "GF000271": "b61b82c4c339fe84", + "GF000272": "2f523d333e8f30de", + "GF000273": "2e4d1f4a5a3c4a6b", + "GF000274": "c1ded10f80205384", + "GF000275": "edc9cb53cfff0b53", + "GF000276": "f9aa5e7b69aa6581", + "GF000277": "671933b89a04ead9", + "GF000278": "9a9aef537cf48a1e", + "GF000279": "59755951a30bcaf6", + "GF000280": "8dd4ca470cc06d0a", + "GF000281": "29e5fc7990445168", + "GF000282": "d8c46c5506fea13f", + "GF000283": "64620f97a58b3bd8", + "GF000284": "4ebf6d9f11fa171b", + "GF000285": "8aeffa415186b78d", + "GF000286": "dadd815818621b87", + "GF000287": "d4dcdac6507b3ee2", + "GF000288": "d78fc34ebde6735a", + "GF000289": "0b031afdf07b1474", + "GF000290": "24a540ec47dc969e", + "GF000291": "7d904236333f9f99", + "GF000292": "38724b9a9b1afefd", + "GF000293": "d0ab2b51da892f00", + "GF000294": "a93d206c5472be58", + "GF000295": "1f54d4ad697745e3", + "GF000296": "3a8731f0dd66bf3d", + "GF000297": "763450bb45590dc7", + "GF000298": "56a43ea3658683c9", + "GF000299": "a4c283a84aa32dad", + "GF000300": "c7f417878c5199ef", + "GF000301": "415e417de158c64c", + "GF000302": "279254b0d9d6f19f", + "GF000303": "d753841ea860358a", + "GF000304": "7055bcbcc8db83f9", + "GF000305": "08eee94e5e134459", + "GF000306": "71869e32c55ad16f", + "GF000307": "07271be44023cb8c", + "GF000308": "5bdc51bb7024303a", + "GF000309": "5da9078518569c91", + "GF000310": "0853f8caff2663e6", + "GF000311": "47622161ee55e9ab", + "GF000312": "54069e3665fec9f1", + "GF000313": "0c7616e65a8189c9", + "GF000314": "4f26e03ad01d54a3", + "GF000315": "7de1e0fa301cee56", + "GF000316": "58c983634cde6267", + "GF000317": "3519980b4d67a51c", + "GF000318": "95729d30f63807bd", + "GF000319": "aaa44f1267f61d31", + "GF000320": "2e838dfa57a8d380", + "GF000321": "361d80ae0593c0fa", + "GF000322": "5fcc4c17a1b0bd93", + "GF000323": "23f8000ea768c687", + "GF000324": "b2003417eb0c8488", + "GF000325": "2ec4728aa2d6e273", + "GF000326": "ebfa0cfb633d8b74", + "GF000327": "cd63b47d9f093716", + "GF000328": "e8ef10d3ecce9945", + "GF000329": "4a6f0f547aec5261", + "GF000330": "edc3f9b565749960", + "GF000331": "97c79730ca04620e", + "GF000332": "a62e193b082aa139", + "GF000333": "6b08745a7f650ed2", + "GF000334": "8ec89eef9f0e258a", + "GF000335": "7661263f5efb886d", + "GF000336": "0fea4975fb2b9c87", + "GF000337": "fbed9c13bff2eddb", + "GX000004": "04217dcfcb11686f" + } +} diff --git a/resources/tester/helper_855_engine.py b/resources/tester/helper_855_engine.py new file mode 100644 index 000000000..224cead19 --- /dev/null +++ b/resources/tester/helper_855_engine.py @@ -0,0 +1,164 @@ +"""855-A 지킴 도우미 — 로직마다 셈 경우(기본 + 옵션 표본) · 옛 엔진 대 새 계산기 층 가름 · 새 답 지문. + +- 경우 = 빌더 대조와 같은 표본(`build_수식문서_802_2.build`) — 기본 입력(수식 탭 기본값) + 고르기 입력의 + 다른 갈래 하나씩(나머지 기본). +- 옛 = `master_formula.run` → `master_cut.engine` · 새 = 저장된 수식 문서(`master_doc_link.load_all`) · + `master_doc_calc.calc`. +- 층(앞 층이 다르면 뒤 층 안 봄): L0 합계 · L1 줄 이름별 비목 금액 · L2 줄 꼴(차례 · 이름 · 금액 · 비목) · + L3 수량 · 단가. 「보임」 = 금액은 같고 보이는 단가만 다름(옛 = 줄 끝수 자리로 자른 단가 · 새 = 날 값 / + 수량 0 줄 단가 0 ↔ 빈 값 / 값 없는 줄 단가 빈 값 ↔ 채움 / 묶음 단가 = 계로 맞댐). +""" + +from __future__ import annotations + +import hashlib +import importlib +import json +from collections import defaultdict +from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal +from functools import lru_cache + +from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠 + +mf = importlib.import_module("master_formula") +mcut = importlib.import_module("master_cut") +mc = importlib.import_module("master_doc_calc") +ml = importlib.import_module("master_doc_link") +meq = importlib.import_module("master_equation") +build = importlib.import_module("build_수식문서_802_2") + +KEYS = ("노무비", "재료비", "경비", "계") +SEEN = "보임" + + +@lru_cache(maxsize=1) +def world(): + """(로직 줄 목록, M01 색인, 수식 문서 {키: 문서}, 연결).""" + files, whole = m01.loaded() + docs = ml.load_all() + rows = [r for d in files.values() if d.get("그룹") == "로직" for r in d.get("줄") or []] + return rows, whole, docs, ml.Links(whole, docs) + + +def cases(row: dict, options: bool) -> list[tuple[str, dict, dict | None]]: + """(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력).""" + whole = world()[1] + base = meq.given_of(whole, row) + out = [("", base, None)] + if options: + for spec in row.get("입력") or []: + for opt in spec.get("고르기") or []: + if str(opt) != str(base.get(spec["이름"])): + one = {spec["이름"]: opt} + out.append((f"{spec['이름']}={opt}", {**base, **one}, one)) + return out + + +def old_run(row: dict, given: dict): + whole = world()[1] + try: + return mcut.engine(whole, row["키"], mf.run(whole, row["키"], mf.fill_empty(row, given))) + except Exception: # 옛 엔진 멈춤도 대조 값 + return None + + +def new_run(doc: dict, changed: dict | None): + try: + got = mc.calc(doc, world()[3], changed) + except Exception: + return None + return got if got.get("셈됨") else None + + +def _d(v): + try: + return Decimal(str(v)) + except Exception: + return None + + +def _unit(v): + return _d(v.get("계")) if isinstance(v, dict) else _d(v) + + +def _per_name(lines) -> dict: + acc: dict = defaultdict(lambda: defaultdict(Decimal)) + for ln in lines or []: + for k, v in (ln.get("비목") or {}).items(): + if _d(v) is not None: + acc[str(ln.get("이름"))][k] += _d(v) + return {n: {k: v for k, v in b.items() if v} for n, b in acc.items()} + + +def _shape(lines) -> list: + return [ + ( + str(ln.get("이름")), + _d(ln.get("금액")), + tuple(sorted((k, _d(v)) for k, v in (ln.get("비목") or {}).items() if v is not None)), + ) + for ln in lines or [] + ] + + +def _cut_only(a, b) -> bool: + """옛 단가 = 새 날 값을 옛 자리로 자른 값(버림 · 반올림 · 올림 어느 하나).""" + ua, ub = _unit(a.get("단가")), _unit(b.get("단가")) + if ua is None and _d(a.get("금액")) is None and _d(b.get("금액")) is None: + return True # 값 없는 줄 — 금액 둘 다 빈 값 + if ub is None and ua == 0 and _d(a.get("수량")) == 0: + return True # 수량 0 줄 — 금액 0 + if ua is None or ub is None: + return False + return ua in (ub.quantize(ua, m) for m in (ROUND_DOWN, ROUND_HALF_UP, ROUND_UP)) + + +def level(old, new, money: bool) -> str | None: + """다름 층 — None = 같음(둘 다 못 셈 포함) · 「보임」 = 보이는 단가만 다름.""" + if old is None or new is None: + return None if old is None and new is None else "L0" + keys = KEYS if money else ("결과",) + if any(_d(old.get(k)) != _d(new.get(k)) for k in keys): + return "L0" + if not money: + return None + if _per_name(old["줄"]) != _per_name(new["줄"]): + return "L1" + if _shape(old["줄"]) != _shape(new["줄"]): + return "L2" + seen = False + for a, b in zip(old["줄"], new["줄"]): + if _d(a.get("수량")) != _d(b.get("수량")): + return "L3" + if _unit(a.get("단가")) != _unit(b.get("단가")): + if not _cut_only(a, b): + return "L3" + seen = True + return SEEN if seen else None + + +def adopted(key: str, label: str, lv: str) -> bool: + """채택된 차이(요구 714-3 · 빌더 `ADOPTED`) — 합계는 그 목록만 · 줄 비목은 같은 까닭 + (식 속 단가산출 부름 = 끝수 뒤 값)이 있는 문서만.""" + if lv == "L0": + return (key, label) in build.ADOPTED + return lv == "L1" and build._uses_raw_sub(world()[2][key]) + + +def answer(got) -> object: + """새 답의 지문 꼴 — 노 · 재 · 경 · 계(돈 아닌 = 결과) · 줄(이름 · 금액 · 비목).""" + if got is None: + return "못 셈" + if "결과" in got and got.get("계") is None: + return {"결과": str(got.get("결과"))} + return { + "합": [str(got.get(k)) for k in KEYS], + "줄": [[n, str(m), [[k, str(v)] for k, v in b]] for n, m, b in _shape(got.get("줄"))], + } + + +def fingerprint(key: str, row: dict, options: bool = True) -> str: + doc = world()[2][key] + got = [[label, answer(new_run(doc, changed))] for label, _, changed in cases(row, options)] + raw = json.dumps(got, ensure_ascii=False, sort_keys=True) + return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] diff --git a/resources/tester/test_812_1_xlsx_golden.py b/resources/tester/test_812_1_xlsx_golden.py index 613056cf7..0f62d6cb4 100644 --- a/resources/tester/test_812_1_xlsx_golden.py +++ b/resources/tester/test_812_1_xlsx_golden.py @@ -379,14 +379,19 @@ def sweep(tag: str) -> dict: path = practice.FILES[tag] saved = fn.pack(excel(tag), path.name) out = {"블록": 0, "같음": 0, "다름": set(), "변수줄": 0, "자원줄": 0, "자원추정": 0} + out["옛 검산 다름"] = set() for ln in (x for b in saved["산근"] for x in b["줄"]): out["변수줄"] += bool(ln.get("변수")) out["자원줄"] += bool(ln.get("자원")) for no, blk in fn.numbers(saved).items(): out["블록"] += 1 emitted = fn.emit(saved, no) - _, _, got = nd.doc_and_money(emitted) + sk, _, got = nd.doc_and_money(emitted) mine = {c: got.get(k) for c, k in nd.COST} + old = nd.imp._money(nd.imp._run(sk, nd.whole())) or {} # 855-A 옛 검산(옛 엔진) + pair = [(old.get(k), got.get(k)) for _, k in nd.COST] + if any(a is None or b is None or nd.D(str(a)) != nd.D(str(b)) for a, b in pair): + out["옛 검산 다름"].add((tag, no)) nag = (emitted["원본"].get("계약") or {}).get("낙찰률") if nag: for c in "LMS": @@ -408,3 +413,4 @@ MONEY_SAMPLE = ("거창", "봉화") def test_money_equals_excel(tag: str) -> None: got = sweep(tag) assert got["블록"] and got["다름"] == {x for x in ODD_MONEY if x[0] == tag}, sorted(got["다름"]) + assert got["옛 검산 다름"] == set(), sorted(got["옛 검산 다름"]) # 855-A 옛 검산 = 새 셈 diff --git a/resources/tester/test_855_block.py b/resources/tester/test_855_block.py new file mode 100644 index 000000000..2de6a343a --- /dev/null +++ b/resources/tester/test_855_block.py @@ -0,0 +1,33 @@ +"""855-A 지킴 ④ — 막힘 판정 옛(`master_formula.check_logic` · M01 로직 목록 · `/logic`) = 새(수식 문서 +표지 `master_doc.check`) 전수 · 막힘 기준 = 표지만(기본 입력으로 셈이 안 되는 것은 막힘 아님 · 판정 855-0). + +걸음 2-B3(막힘 검사를 문서 기준으로) 앞뒤로 같아야 함 · 옛 검사를 지우는 걸음에서 옛 쪽만 뗌.""" + +from __future__ import annotations + +import importlib + +import helper_855_engine as h + +md = importlib.import_module("master_doc") + + +def test_막힘_옛_새_같음(): + rows, whole, docs, _ = h.world() + old = {str(r["키"]) for r in rows if h.mf.check_logic(whole, r)[0]} + new = {str(r["키"]) for r in rows if str(r["키"]) not in docs or md.check(docs[str(r["키"])])} + assert old == new, {"옛만 막힘": sorted(old - new)[:20], "새만 막힘": sorted(new - old)[:20]} + + +def test_틀린_식은_옛_새_모두_막힘(): + """자가 살아 있는지 — 같은 로직의 식을 틀리게 하면 두 판정 모두 막힘(사본만 · 자료 안 고침).""" + import copy + + rows, whole, docs, _ = h.world() + row = next(r for r in rows if r.get("호표") and str(r["키"]) in docs) + bad_row = copy.deepcopy(row) + bad_row["호표"][0]["수량"] = "없는변수 * 2" + bad_doc = copy.deepcopy(docs[str(row["키"])]) + bad_doc["금액"][0]["수량"] = "없는기호 × 2" + assert h.mf.check_logic(whole, bad_row)[0] + assert md.check(bad_doc) diff --git a/resources/tester/test_855_engine_parity.py b/resources/tester/test_855_engine_parity.py new file mode 100644 index 000000000..3c9088393 --- /dev/null +++ b/resources/tester/test_855_engine_parity.py @@ -0,0 +1,46 @@ +"""855-A 지킴 ① — 로직 전수 옛 엔진 대 새 계산기(저장된 수식 문서) · 걸음 2 동안 「다름 0」 자. + +- 기본 입력 전수(관문 · 십여 초) · 옵션 표본 전수 = 환경 `S855_ALL=1`(3 분 남짓). +- 층 L0 합계 · L1 줄 비목 · L2 줄 꼴 · L3 수량 · 단가(`helper_855_engine.level`). +- 다름 = 채택된 차이와 같아야 함(합계 = 빌더 `ADOPTED` 그대로 · 줄 비목 = 같은 까닭의 문서만) · + 「보임」(보이는 단가만 · 금액 같음)은 허용 갈래로 셈. +- 옛 엔진을 지우는 걸음(2-E4)에서 은퇴 — 그 뒤는 `test_855_golden` 이 지킴. +""" + +from __future__ import annotations + +import os + +import helper_855_engine as h + +ALL = os.environ.get("S855_ALL") == "1" + + +def _diffs(options: bool) -> dict[str, list]: + rows, _, docs, _ = h.world() + out: dict[str, list] = {"문서 없음": [], "채택 밖": [], "채택": [], h.SEEN: []} + for row in rows: + key = str(row["키"]) + doc = docs.get(key) + if doc is None: + out["문서 없음"].append(key) + continue + money = not doc.get("결과") + for label, given, changed in h.cases(row, options): + lv = h.level(h.old_run(row, given), h.new_run(doc, changed), money) + if lv == h.SEEN: + out[h.SEEN].append((key, label)) + elif lv and h.adopted(key, label, lv): + out["채택"].append((key, label, lv)) + elif lv: + out["채택 밖"].append((key, label, lv)) + return out + + +def test_로직마다_수식_문서_있음_옛_대_새_다름은_채택뿐(): + got = _diffs(ALL) + assert got["문서 없음"] == [] + assert got["채택 밖"] == [], got["채택 밖"][:20] + total = {(k, o) for k, o, lv in got["채택"] if lv == "L0"} + want = {x for x in h.build.ADOPTED if not x[1]} if not ALL else set(h.build.ADOPTED) + assert total == want # 채택 목록이 다 나오고 그 밖은 없음(기본만 돌면 옵션 채택은 안 나옴) diff --git a/resources/tester/test_855_golden.py b/resources/tester/test_855_golden.py new file mode 100644 index 000000000..03a8c9e85 --- /dev/null +++ b/resources/tester/test_855_golden.py @@ -0,0 +1,47 @@ +"""855-A 지킴 ② — 새 계산기 답 지문(로직마다 기본 + 옵션 표본 · 노 · 재 · 경 · 계 · 줄 금액 · 비목). + +- 지문 = `golden_855_engine.json`(로직 키 → 답 묶음 sha256 앞 16 자 · `helper_855_engine.fingerprint`). +- 다르면 실패 — 계산기 · 수식 문서 · M01 자료가 금액을 바꿨다는 뜻. 자료 · 규칙을 **뜻대로 바꾼 걸음만** + 다시 뜸: `./venv/Scripts/python.exe resources/tester/test_855_golden.py --write`(바뀐 키를 커밋 글에). +- 옛 엔진을 지운 뒤(2-E4) 옛 → 새 대조(`test_855_engine_parity` · `test_802_2`)를 이것이 대신함. +""" + +from __future__ import annotations + +import json +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent +FILE = HERE / "golden_855_engine.json" +REDO = "./venv/Scripts/python.exe resources/tester/test_855_golden.py --write" + + +def current() -> dict[str, str]: + import helper_855_engine as h + + rows, _, docs, _ = h.world() + return {str(r["키"]): h.fingerprint(str(r["키"]), r) for r in rows if str(r["키"]) in docs} + + +def test_새_계산기_답_지문_같음(): + want = json.loads(FILE.read_text("utf-8"))["지문"] + got = current() + changed = sorted(k for k in want.keys() & got.keys() if want[k] != got[k]) + gone, new = sorted(want.keys() - got.keys()), sorted(got.keys() - want.keys()) + assert not (changed or gone or new), ( + f"지문 다름 — 바뀜 {len(changed)} {changed[:20]} · 빠짐 {gone[:20]} · 새 키 {new[:20]}\n" + f"뜻대로 금액을 바꾼 걸음이면 다시 뜸: {REDO} (아니면 고친 코드 · 자료를 되짚음)" + ) + + +if __name__ == "__main__": + ROOT = HERE.parents[1] + for p in (str(ROOT), str(HERE)): + if p not in sys.path: + sys.path.insert(0, p) + if "--write" not in sys.argv: + sys.exit(f"다시 뜨기 = {REDO}") + body = {"판": 1, "지문": dict(sorted(current().items()))} + FILE.write_text(json.dumps(body, ensure_ascii=False, indent=1) + "\n", "utf-8", newline="\n") + print(f"지문 {len(body['지문'])} 씀 → {FILE.name}") diff --git a/resources/tester/test_855_sk_layers.py b/resources/tester/test_855_sk_layers.py new file mode 100644 index 000000000..a18e60351 --- /dev/null +++ b/resources/tester/test_855_sk_layers.py @@ -0,0 +1,125 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""855-A 지킴 ③ — 단가산출(SK) 셈 답 · 견본 꼴마다 옛 엔진 길(`M02_Doc_Sk.OLD`) 대 지금 길(수식 사본 → +문서 계산기) · 지금 길 답의 줄 비목 합(원 버림) = 기준. + +견본(임시 storage · 개인 층 · M01 은 읽기만): 바탕 로직 · 옛 칸 값(더한줄 로직) · 율 더한줄 · 형제 SK(바탕 참조) · +「따로」(수식 사본을 고쳐 저장) · 가져온 식(엑셀 줄 · 저장 없음). +걸음 2-C1(SK 셈 한 길)이 이 시험을 자로 씀 — 「따로」 단언은 지금 사실(줄 = 옛 · 기준 = 새)이고 2-C1 에서 뒤집음. +""" + +from __future__ import annotations + +import copy +from decimal import ROUND_DOWN, Decimal + +import pytest + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Doc_Sk as dsk +from M02_MasterTemplete import M02_Doc_Sk_Path as path +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sangeun_Calc as calc +from M02_MasterTemplete import M02_Sangeun_Doc as sd +from resources.tester import test_793_2_sangeun_imported as imported +from resources.tester.test_778_4_rate_line import SUB, _rate +from resources.tester.test_795_1_sk_copy import PCT, _doc, _sk +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + +COSTS = ("노무비", "재료비", "경비") +FORM = "GC000211" # 합판거푸집 +ADD = {"종류": "로직", "로직": "GF000089", "수량": 2, "입력값": {}, "이름": "sub6임시 굴착기"} + + +@pytest.fixture(autouse=True) +def _manual(monkeypatch): + """자동 따라옴 끔 — 저장본 그대로 셈(층 꼴만 봄).""" + from M02_MasterTemplete import M02_Sk_AutoRenew as renew + + monkeypatch.setattr(renew, "on", lambda: False) + + +def _run(doc: dict, old: bool) -> dict: + whole = m01.loaded()[1] + token = dsk.OLD.set(old) + try: + return calc.run(sd.clean(doc, None, whole), whole) + finally: + dsk.OLD.reset(token) + + +def _both(folder, doc) -> tuple[dict, dict]: + with store.at(folder): + return _run(doc, True), _run(doc, False) + + +def _lines_sum(got: dict) -> dict: + total = {k: Decimal(0) for k in COSTS} + for ln in got.get("줄") or []: + for k in COSTS: + v = (ln.get("비목") or {}).get(k) + total[k] += Decimal(str(v)) if v is not None else 0 + return {k: v.quantize(Decimal(1), ROUND_DOWN) for k, v in total.items()} + + +def _base(got: dict) -> dict: + return {k: Decimal(str(got["기준"][k])).quantize(Decimal(1), ROUND_DOWN) for k in COSTS} + + +def _same_paths(old: dict, new: dict) -> None: + assert old["기준"] is not None and new["기준"] is not None + assert {k: Decimal(str(old["기준"][k])) for k in COSTS} == { + k: Decimal(str(new["기준"][k])) for k in COSTS + } + assert _lines_sum(new) == _base(new) + + +@pytest.mark.parametrize( + "body", + [ + {"바탕": {"로직": FORM}}, + {"바탕": {"로직": PCT}}, + {"바탕": {"로직": FORM}, "더한줄": [ADD]}, # 옛 칸 값(더한줄 로직) + {"바탕": {"로직": SUB}, "더한줄": [_rate("인력", 2)], "단위": "주"}, # 율 더한줄 + ], + ids=["바탕", "율_바탕", "옛칸_더한줄", "율_더한줄"], +) +def test_층_SK_옛_대_새_같고_줄_합_기준(world, body): + me = world["personal"] + key = _sk(me, **copy.deepcopy(body)) + doc = _doc(me, key) + old, new = _both(me, doc) + assert "수식셈" in new # 지금 길 = 수식 사본 문서 셈 + _same_paths(old, new) + + +def test_형제_SK_바탕_참조(world): + me = world["personal"] + first = _sk(me, 바탕={"로직": FORM}) + second = _sk(me, 바탕={"참조": {"층": "personal", "주인": "7/42", "키": first}}) + old, new = _both(me, _doc(me, second)) + _same_paths(old, new) + assert new["기준"] == _both(me, _doc(me, first))[1]["기준"] + + +def test_가져온_식_옛_대_새(world): + old, new = _both(world["personal"], imported._doc()) + assert "수식셈" in new + _same_paths(old, new) + + +def test_따로_SK_지금은_줄_옛_기준_새(world): + """「따로」 = 고친 수식 사본이 정본 — 지금 셈 답은 줄 = 옛 엔진(옛 칸) · 기준 = 문서 계산기라 갈림. + 2-C1 에서 뒤집을 단언 — 그 뒤엔 `_same_paths` 꼴(줄 합 = 기준)로 바꿈.""" + me = world["personal"] + key = _sk(me, 바탕={"로직": PCT}) + with store.at(me): + read = path.read(key) + twice = copy.deepcopy(read["문서"]) + line = twice["금액"][0] + line["수량"] = f"({line.get('수량') or 1}) × 2" + saved = path.save(key, {"문서": twice, "판": read["판"]}) + assert saved["사본"]["따로"] is True + old, new = _both(me, _doc(me, key)) + assert new["수식셈"]["따로"] is True + assert _base(new) != _base(old) # 2-C1 에서 뒤집을 단언 — 기준이 옛 길과 다름 + assert _lines_sum(new) == _base(old) != _base(new) # 2-C1 에서 뒤집을 단언 — 줄 = 옛 길 From fe6452f8585160b7f61b94a0cd2e08b7be37cc23 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 16:54:07 +0900 Subject: [PATCH 5/6] =?UTF-8?q?chore(ledger):=20=EC=84=A4=EA=B3=84=20855?= =?UTF-8?q?=20=EB=B3=B4=EC=B6=A9=20=E2=80=94=20B08=20=C2=B7=20B09=20?= =?UTF-8?q?=EC=98=9B=20=EC=97=94=EC=A7=84=20=EA=B1=B7=EA=B8=B0=20=C2=B7=20?= =?UTF-8?q?=EB=A1=9C=EC=A7=81=20JSON=20=EC=97=86=EC=95=A0=EA=B8=B0=20?= =?UTF-8?q?=C2=B7=20=ED=98=B8=ED=99=98=20=EB=BA=8C=20=C2=B7=20=EB=B0=94?= =?UTF-8?q?=EB=80=90=20=EA=B1=B8=EC=9D=8C=20=ED=91=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude --- .../설계_855_보충_B09_로직JSON_호환.md | 286 ++++++++++++++++++ 1 file changed, 286 insertions(+) create mode 100644 docs/raw/요구_1104/설계_855_보충_B09_로직JSON_호환.md diff --git a/docs/raw/요구_1104/설계_855_보충_B09_로직JSON_호환.md b/docs/raw/요구_1104/설계_855_보충_B09_로직JSON_호환.md new file mode 100644 index 000000000..276867106 --- /dev/null +++ b/docs/raw/요구_1104/설계_855_보충_B09_로직JSON_호환.md @@ -0,0 +1,286 @@ +# 설계 855 보충 — 사용자 확정 넷 반영 (PLAN 855-F) + +요구 898 · 899 · sub7 · 2026-11-17 · 읽기 · 세기만(코드 · 자료 · 시험 고침 0). 바탕 = `docs/raw/요구_1104/설계_855_정본하나_계산기하나.md`(아래 「본 설계」). +세는 도구 · 결과 = `tmp/s894/m855b/`(sub6 도구 셋 복사 + 새 도구 넷 · 결과 파일은 4 절 끝 표). + +## 0. 한눈 요약 + +- **B08 · B09 는 지금 「M02 셈 답을 받는」 게 아니라 「M02 를 복사한 옛 로직 줄을 옛 엔진으로 다시 푸는」 꼴** — 프로젝트 사본 `단가.json` 에 M01 로직 줄 · 굳힌 SK 로직 줄(`로직_단가산출.json` `GX9…`)을 싣고, B09 가 그 줄을 `run_line` · `mf.evaluate` 로 다시 풀어 수량 · 자원 키 · 하위 산근 · 풀이 글을 얻음. 셈 몸은 이미 M02 엔진 값(841-1) — B09 고유 셈은 비목 합 · 끝수 · 관급 0 원 · % 밑수뿐. +- 사본에 이미 `수식.json`(수식 문서 닫힌 묶음 · 802-4a)이 같이 실림 — **쓰는 곳 0**(만들기만). +- 권함 = **안 B「프로젝트는 M02 계산기(문서 셈) 한 벌을 불러 사본을 셈 · B09 는 답을 갈라 합산만」** + 입력 지문이 같으면 다시 안 셈(파생 저장본). 안 A(복사 때 셈 답만 굳힘)는 프로젝트 입력값(구조물마다 · 운반 거리) · [단가 갱신] 이 다시 셈을 요구해 못 씀. +- **B09 손 줄이 M01 기초를 직접 고름**(설계내역서 [단가 연결] · 운반 단가 모달 · `ref.tab = logic`) — 저장된 프로젝트 1 곳에 **6 줄 살아 있음**. M02 를 거치지 않는 유일한 길 → 판단 거리 1. +- 로직 JSON 칸 19 가운데 문서에 같은 값으로 이미 있는 것 4(`이름 결과단위 출처 부품`) · 문서로 옮길 이름표 6(`원문번호 구분 상세구분 소유 비고 개정`) + `별칭`(지금 값 0) + 파일 머리 3(`원문 부문 차례`) · 셈 칸 8 은 문서 셈 칸이 대신(버림) · **문서에 없는 정보 = 이름표뿐**. +- 로직 줄을 직접 읽는 파이썬 자리 = `.logic(` 류 **102 곳 · 49 파일**(M01 7 파일 19 · M02 23 파일 48 · B09 7 파일 16 · scripts 12 파일 19) + 층 서고 SK `수식.로직` · `사본.로직`(로직 줄 값 사본 28 줄) — 모두 문서 읽기로 옮긴 뒤 로직 JSON 을 뺌. +- **지금 진행 중인 기초 고침(851-1 등)이 로직 JSON → 빌더 길을 씀** — 로직 JSON 을 빼기 전에 「기초 내용 고침 = 수식 문서를 바로 고치는 스크립트 · M01 [저장]」 으로 길을 바꿔야 함(차례 조건). +- 호환을 안 만들면 빠지는 것: 2-D 올림 규칙 · 사본 없는 SK 옛 길 · 옛 SK 상세 시험 8 군 고쳐 쓰기 · 프로젝트 옛 사본 꼴 읽기(`items/` · `complete_old`) · SK `사본` · `수식.로직` 이행 — **어림 −1,200 줄 · 걸음 하나(2-D) 크기 절반**. +- 저장본을 비울 때 = **2-C1(SK 셈 한 길) 바로 앞**(옛 칸을 읽는 셈이 꺼지기 전에 자료가 0 이면 2-C1 · 2-D 가 옛 꼴을 볼 필요 없음). +- 「가져온 식」(`가져온.로직` = 옛 로직 줄 꼴)은 저장본을 비워도 불러올 때마다 새로 생김 → 옛 식 **파서만** 불러오기 몫으로 남김(엔진 몸은 지움) · 857 이 문서를 바로 내면 그때 걷음. + +--- + +## 1. ㉮ B08 · B09 — 옛 엔진 부름 걷기 + +### 1-1 옛 엔진을 부르는 자리 하나하나 + +길 = 화면 → 서버 길 → 함수. 「살아 있음」 = 화면 단추 · 페이지 열기가 실제로 탐 · 「자료 0」 = 길은 살았으나 지금 저장소에 그 자료가 없어 실제로는 안 돎(프로젝트 사본 0 · 구조물 조합 줄 0). + +| 자리 | 부름 | 무엇을 얻으려고 | 타는 길 | 판정 | +| --- | --- | --- | --- | --- | +| `B08_Quantity_Router_Material.py:79` `_ref_mats.run` | `labor.run_line` | 참조 일위대가 안 **옛 로직 줄**의 재료 줄(이름 · 단위 · 품목 키 · 수량) → 단위수량 | B08 자재 집계표 열기 `GET …/quantity/materials`(:275) → `snapshot_units` → `_folder_units`(:117) | 살아 있음 · 자료 0(SC 옛 로직 줄 0) | +| 같은 파일 `_folder_units` | `copies.calc`(`M02_Item_Copy.py:338` → `Item_Prices.calc` → `Labor_Doc.calc` → `run_line`) | 사본 일위대가 줄 재료 · 자재 수량 | 같음 | 살아 있음 · 자료 0(사본 0) | +| `B09_Estimation_Sangeun.py:346` `Solver._solve:333` | `labor_doc.run_line(raw=True)` | 산근 줄마다 **엔진 금액 ÷ 수량 = 단가**(841-1) | B09 열기 · [저장] · 셈 `GET/PUT …/estimation` · `POST …/estimation/calc`(:430) → `calc_user` → `Sangeun.build`(:667) → `collect`(:626) | 살아 있음 · 손 줄 6 이 탐 | +| 같은 파일 `_env:200` | `mau.values` · `mf._inputs` · `mf.evaluate(중간)` | **입력 기본값** · 중간 값(작업량 Q 표시 자리) | 위 `_solve` 안 | 살아 있음 | +| `_line:445` · `_logic_line:488` | `mf.evaluate(수량)` · `mf.fill(요소)` · `mf.mp.priced` | 줄 **수량 · 자원 키**(노임 · 자재 · 기계) · 고른 품목 | 같음 | 살아 있음 | +| `call_of:223` · `line_calls:242` · `_captured:261` | `mf.parse` · `mf.evaluate` · `whole.get` 가로채기 | **하위 산근**(부른 로직 키 + 넘긴 입력) · 기계경비 줄의 **기계 키** | 같음 + `rows_of`(일위대가화 줄 펼침) + `Labor_Source` | 살아 있음 | +| `_extras:513` | `mf.evaluate(덧줄 식)` · `labor_doc.pct_extras` | **율 줄**(% · 밑수 = B09 비목 합) | 같음 | 살아 있음 | +| `hand_resource_keys:602` | `run_line`(+ `whole.get` 가로채기) | 손 줄이 부르는 **자원 키**(자재 단가 책 수요) | B09 열기 `payload` → `Router.py:238` | 살아 있음 | +| `B09_Estimation_Sangeun_Text.py` 13 함수 31 곳(`render_sangeun_text:347`) | `mf.*` · `master_text`(`mtx.fmt` · `render` · `_names`) | **산출근거 글**(머리 · 줄 · 계) | `_solve` → `_text` · `POST …/estimation/logic-preview`(:444 · 운반 단가 모달 ③) | 살아 있음 | +| `B09_Estimation_Sangeun_Sum.py:36 · 87` | `mcut._line` · `mcut.settle` | **끝수**(줄 자리 · 끝전 · 조정 · 792-3) | `_solve` 안 | 살아 있음 | +| `B09_Estimation_Labor_Rule.py:90 · 115` | `mf.parse`(덧줄 식 꼴 읽기) | 대가 블록 **율 줄 밑수 · 합밖 · 번지 표지**(792-4) | `Labor_Source._poomsem` | 살아 있음 · 자료 0 | +| `B09_Estimation_Labor_Source.py:140` `_poomsem` | `run_line(raw=True)` + `sg.line_calls` | 대가(품셈) 블록 **줄 꼴 · 수량 · 비목 · 하위 산근** | B09 열기 `payload` → `daega_inputs`(:656) | 살아 있음 · 자료 0 | +| 같은 파일 `sangeun:181` → `Supply.sk_money:79` | `Sangeun_Calc.unit`(옛 엔진 + 문서 합계 덮음) | 굳힌 SK 블록 **합(노 · 재 · 경)** | 같음 | 살아 있음 · 자료 0 | +| `B09_Estimation_Linked.py:64` `used_keys` | `run_line`(+ `get` 가로채기) | 사본이 부르는 **자원 키**(단가 책 수요) | `payload` → `linked_resource_keys`(`Router.py:237`) | 살아 있음 · 자료 0 | +| `M02_Item_Sangeun.py:45` `freeze` | `Sangeun_Calc.resolve` | 사본 만들 때 SK 를 **옛 로직 줄 하나(GX9)로 굳힘** | 구조물 [저장] → `Item_Snapshot.build_snapshot:126` · B09 서고 [가져오기] `POST …/estimation/library` → `Bill_Library.import_copy:272` · [재생성] `Refresh` | 살아 있음 · 자료 0 | +| `M02_Item_Prices.py:234` `collect` · `:346` `calc` | `_texts`(옛 식 글 훑기) · `mf._expand` 류 · `Labor_Doc.calc` | 사본 **닫힌 묶음**(로직 줄 · 요소 · 표) 모으기 · 사본 셈 | 사본 만들기 · B08 · B09 전부 | 살아 있음 | + +죽은 길 = 없음(모두 화면에서 닿음). 지금 실제로 도는 것은 **손 줄 로직 6 줄**(B09 프로젝트 1 곳)뿐 — 나머지는 자료 0. + +### 1-2 사본에 지금 실어 오는 것 대 실어 와야 할 것 + +| 파일(구조물 사본 `templates/structures/{id}/` · B09 서고 `library/`) | 지금 내용 | 쓰는 곳 | 끝 모습(안 B) | +| --- | --- | --- | --- | +| `일위대가.json` | 일위대가 문서 + **M01 로직 줄 사본**(`로직`) · 알약 · `참조사본`(SC · 굳힌 SK 문서 = `굳힌줄` · `원본` · `정체`) (`Item_Source.py:93 · 105`) | B08 · B09 전부 | 일위대가 문서 + 참조사본(SC 그대로 · **SK = 수식 문서 사본**) · 로직 줄 사본 없음 | +| `단가.json` | 닫힌 묶음 = **M01 로직 줄** + 요소 · 표 줄 + 자원 단가 줄 + `로직_단가산출.json`(GX9 굳힌 SK 줄) (`Item_Source.py:162`) | 옛 엔진 색인(`load_prices`) | **자원 단가 줄 · 표 줄만**(로직 줄 · GX9 없음) — [단가 갱신] 이 바꾸는 자리 | +| `수식.json` | 수식 문서 닫힌 묶음(`Doc_B09.build:33` · 802-4a) | **없음**(만들기만) | **셈 정본** — 프로젝트 셈이 읽는 유일한 식 | +| `입력값.json` · `고른자재.json` · `면적.json` | 구조물마다 입력 · 고른 재료 · 알약 칸 값 | 사본 셈 | 그대로(키 = 문서 키 · 입력 이름 → 변수 열쇠 맞춤 필요) | +| B09 견적 `user_values.json` 손 줄 `ref{tab: logic, code, given, rate, picks}` | M01 로직 키 + 입력 | `hand_whole`(지금 M01 묶음 즉석 모음) | 안 바뀜 — 키가 같은 수식 문서로 셈(판단 거리 1) | + +### 1-3 「프로젝트는 직접 계산하지 않음」 을 지키는 두 안 + +B09 가 셈 답에서 먹는 것 = 줄마다 **이름 · 종류(인력 · 자재 · 기계 · 하위 산근 · 율) · 자원 키 · 수량(1 단위) · 비목 금액 · 하위 부름(키 + 입력) · 율 밑 · 끝수 표지** + **풀이 글**. 새 계산기 답(`master_doc_calc.calc:545` → 줄 `{이름 비목 수량 단가 금액 까닭 합밖 묶음 작업량}`)에 **자원 키 · 하위 부름이 없음** → 어느 안이든 「줄마다 무엇을 불렀나」 기록이 새로 필요(셈은 안 바꿈 · 연결 풀이 `master_doc_link.Links` 를 감싸 부른 것을 적음 · 서버 단독 · TS 짝 안 건드림). + +| 경우 | 안 A — 복사 때 셈 답을 굳혀 실어 옴 | 안 B — 프로젝트가 M02 문서 계산 함수를 불러 사본을 셈(권함) | +| --- | --- | --- | +| 실어 오는 것 | 셈 답(줄 · 비목 · 자원 키 · 하위 부름 · 풀이 글) | 수식 사본 + 자원 단가 줄(지금 `수식.json` + 줄인 `단가.json`) | +| 프로젝트 안 [단가 갱신] | 자원 단가가 바뀌면 줄 금액이 달라짐 → 굳힌 답 못 씀 → M02 에서 다시 복사([재생성]) 해야 함 = 지금 뜻(사본 로직 그대로 · 단가만 새로)과 다름 | 자원 줄만 바꾸고 다시 셈 — 지금 뜻 그대로 | +| 수량 · 입력 바뀜(구조물마다 입력값 · 운반 거리 이정표 `haul_dist` · 면적 알약) | 입력이 바뀌면 굳힌 답 무효 → 못 함 | 같은 계산기로 다시 셈 | +| 산출근거 보기 | 굳힌 글(단가 갱신 · 입력 바뀜 뒤엔 틀림) | 셈 답 → 서버 풀이 글(본 설계 ② `master_doc_text` · 2-C4) + B09 단가 | +| 내역서 합산 | 같음(비목 합) | 같음(비목 합) — B09 고유 셈 = 비목 합 · 끝수 · 관급 0 원 · % 밑수만 | +| 손 줄 M01 로직(6 줄) | 고를 때 M02 에서 셈해 굳힘 — 입력 바꾸면 다시 | 그대로 문서 셈 | +| 속도 | 빠름 | 입력 지문이 같으면 저장본(CLAUDE.md 5 장 「파생 저장본」) → 안 A 와 같은 속도 | +| 고칠 크기 | 사본 꼴 + B09 5 파일 + [단가 갱신] · 입력 바꿈 길 새로 | 사본 꼴 + B09 5 파일(읽는 답만 바뀜) | + +→ **안 B 권함.** 「계산을 직접 할 일 없음」 = B09 에 식 엔진이 없음(계산기는 M01 · M02 와 같은 한 벌) · B09 는 답을 갈라 합산만 — 로 읽음(판단 거리 2 에서 확인). + +### 1-4 걸음(두 박자 · 한 걸음 = 한 커밋 묶음) + +| 걸음 | 무엇 | 파일(어림 줄) | 지킴 | 앞 조건 | +| --- | --- | --- | --- | --- | +| **B9-0 견본 · 골든** | 지금 사본 0 · 조합 줄 0 → **임시 storage 견본 프로젝트**를 시험이 지음: 층 견본(SK 가져온 식 · 따로 · 율 더한줄 · 형제 SK · 기계 · 관급 재료 / SC 참조 · 고정 · 자재 / 구조물 조합 일위대가 열) → 구조물 지정 → 사본 만들기(지금 길) → B09 `calc_user` · `daega_inputs` · `payload` 수요 키 · B08 `snapshot_units` · `logic_preview` 답을 지문으로 `855_b09_golden.json` · 손 줄 견본(운반공 · 율 · 고른 재료) 포함 · 실제 B09 프로젝트 1 곳(손 줄 6)은 자기 포트에서 `GET …/estimation` 답 읽기만 전후 대조(tmp) | 새 `resources/tester/test_855_b09_golden.py`(+ 250) · 견본 짓기는 기존 `test_143_*` · `145_*` · `792_3` · `802_4a` 견본을 모아 씀 | 지금 수치 그대로 통과 | 2-A(855-A) | +| B9-1 셈 기록 | 문서 셈 줄마다 부른 자원 키 · 하위 문서(키 + 입력) · 고른 품목을 적는 연결 감쌈 | 새 `scripts/master_doc_trace.py`(+ 120) · 시험 | 1,521 기초 기본 옵션 — 기록한 자원 키 = 옛 `whole.get` 가로채기 키(같음) | B9-0 | +| B9-2 사본 셈 한 길 | `Item_Copy.calc` · `Item_Prices.calc` = `수식.json` 문서 셈 · B08 `_folder_units` · `_ref_mats` = 문서 셈 답 재료 줄 | `M02_Item_Prices.py`(± 120) · `M02_Item_Copy.py`(± 20) · `B08_Quantity_Router_Material.py`(± 60) | 골든(B08 단위수량 · 사본 셈 금액) 같음 · `test_143_*` · `145_3_b08` | B9-1 · 2-C1(SK 문서 셈) | +| B9-3 B09 산근 · 대가 | `Sangeun._solve · _env · _line · call_of · line_calls · _captured · rows_of · _extras · hand_resource_keys` · `Labor_Source._poomsem` · `Linked.used_keys` · `Supply.sk_money` · `Sangeun_Sum` · `Labor_Rule` → 문서 셈 답 + 기록(끝수 = 답 `끝수` · 율 = 금액 줄 `합밖 · 자리 · 단계` 칸) | `B09_Estimation_Sangeun.py`(± 250) · `_Labor_Source.py`(± 120) · `_Linked.py`(± 40) · `_Supply.py`(± 20) · `_Sangeun_Sum.py`(− 40) · `_Labor_Rule.py`(± 60) | 골든 B09 산근 합 · 줄 비목 · 대가 줄 · 내역서 합계 같음 · `test_145_*` · `792_3`(다섯 길) | B9-1 · 2-C1 | +| B9-4 산출근거 글 | `Sangeun_Text` 31 곳 → 서버 풀이 글(본 설계 ②) + B09 단가 끼움 | `B09_Estimation_Sangeun_Text.py`(± 250 · 줄어듦) | 글 = 골든 글(줄 수 · 금액 숫자) · 화면 산근 탭 · 운반 모달 ③ 확인 | 2-C4(`master_doc_text`) · B9-3 | +| B9-5 사본 꼴 | 새 사본 = `수식.json`(셈 정본) + 자원 줄만 `단가.json` · SK 굳힘(`Item_Sangeun.freeze` → GX9 줄) 대신 SK 수식 문서 사본(따로 · 덮음 반영) · [재생성] · [단가 갱신] 같은 꼴로 | `M02_Item_Source.py`(± 80) · `M02_Item_Sangeun.py`(− 150) · `M02_Doc_B09.py`(± 20) · `B09_Estimation_Bill_Library.py`(± 30) · `_Refresh.py` · `_Copy_Prices.py`(± 40) | 골든 같음 · 사본 파일 칸 전수(`census_copies`) · 옛 꼴 사본 읽기 없음(지금 0 · 1-2) | B9-3 | +| B9-6 옛 길 지움 | B08 · B09 의 `run_line` · `mf` · `mau` · `mtx` · `mcut` 부름 · `Item_Prices` 옛 묶음 모음(`_texts` · `collect` 로직 줄) · `Labor_Doc.run_line` 의 B 쪽 | 위 파일들 · 옛 사본 시험 줄(`test_143_4` · `145_1` · `145_2` 등 옛 꼴 견본 부분) | 골든 · 관련 시험 전부 · `/openapi.json` 같음 | B9-5 | + +### 1-5 2-E4(엔진 모듈 지움) 앞 조건 — 새 차례 + +1. 본 설계 2-C1(SK 셈 한 길) · 2-C4(서버 풀이 글) 끝. +2. B9-0 → B9-6 끝 = B08 · B09 가 옛 엔진 · `master_text` · `master_cut.engine` · `master_auto` 를 부르는 곳 0(`census_calls.py` 에서 B08 · B09 줄 0). +3. 불러오기 옛 식 **파서**(`mf.parse` 류 · `Doc_Import` · `San_Basis_Index` · `Sangeun_QtyLinks`)는 엔진 몸과 떼어 「바탕 기반」 새 모듈로(3-3). +4. 그 뒤 2-E4 = 엔진 몸 · 셈 · 글 · `master_auto` · `master_combo.run` 지움 · `test_791_1` 은퇴. + +--- + +## 2. ㉯ 로직 JSON 없애기 — 수식 문서에 합침 + +### 2-1 칸 전수와 갈 곳(`census_logic_fields.py` · 1,521 줄 · 59 파일) + +| 칸 | 줄 수(값 있음) | 문서에 지금 | 갈 곳 | +| --- | --- | --- | --- | +| 파일 머리 `그룹` · `판` | 59 | 문서 파일 머리 `그룹` · 줄 `판` | 그대로(문서 파일 `그룹 = 수식문서`) | +| 파일 머리 `원문` · `부문` · `차례` | 59 · 45 · 58 | 없음(문서 파일 머리 = `로직파일` 이름만) | **문서 파일 머리로** — M01 분류(원문 · 장 차례 · 부문) 정본 | +| `키` | 1,521 | 같음 | 그대로 | +| `이름` · `결과단위` · `출처` · `부품` | 1,521 · 1,521 · 1,521 · 81 | **같은 값**(다름 0) | 이미 문서 — 로직 쪽 버림 | +| `원문번호` · `구분` · `상세구분` · `소유` | 1,521 | 없음 | **문서 줄 머리로**(이름표) | +| `비고` · `개정` | 1,452 · 1,257 | 없음 | **문서 줄 머리로** | +| `별칭` | 0(지금 값 없음 · 칸은 화면 · 저장 길에 있음) | 없음 | **문서 줄 머리로** | +| `입력` · `중간` · `호표` · `덧줄` · `끝수` · `결과` | 1,245 · 1,227 · 1,452 · 570 · 70 · 65 | 문서 `변수` · `식` · `금액` · `끝수` · `결과`(꼴 다름 · 빌더가 변환) | 버림(문서가 셈 정본 · 금액 다름 0 = 본 설계 3 절) | +| `입력[].고르기`(기계 목록 2,757) | — | 문서 변수 `선택 목록` | 버림(기계 등록이 문서만 고침) | +| `변수표` | 1,423 | 문서 `변수`(이름 · 기호 · 단위 · 빌더 `master_equation` 길) | 버림 | +| `시험입력` | 234 | 없음 | **버림** — 읽는 곳 = 옛 틀 검사(`check_master`) · 옛 수식 탭(`master_equation*`) · 한 번용 스크립트뿐(작은 결정) | + +→ 문서에 없는 정보 = 이름표 칸 여섯 + 별칭 + 파일 머리 셋. 셈 칸은 전부 문서가 대신함. + +### 2-2 로직 줄을 읽는 자리 전수(`census_logic_readers.py` · `.logic(` 류 102 곳 49 파일 · 결과 `out_logic_readers.tsv`) + +| 갈래 | 자리(대표 `파일:줄`) | 무엇을 읽나 | 문서 읽기로 바꾸는 법 | +| --- | --- | --- | --- | +| **M01 관문** | `M01_MasterData_Store.py:337 _logic_files` · `:21-26`(scripts 길 · `check_master.load` → `mf.Master` 로직 그룹) | 로직 파일 전부 | 문서 색인(`master_doc_link.load_all` · 이미 있음)을 관문 하나로 · `mf.GROUPS` 에서 「로직」 뺌 | +| 목록 · 찾기 · 분류 | `Store.logics:343` · `files_of('로직'):113` · `subs` · `Store_List.attach` · `Store_Find`(↔ `ui_template_logic_find.ts` 짝) · 화면 `UI_Side.ts:48` · `Logic_List` | `키 원문번호 구분 상세구분 이름 결과단위 출처 소유 별칭` · 파일 머리 차례 | 같은 칸을 문서 머리에서 · 답 꼴 그대로(화면 안 바뀜) | +| 상세 · 기본정보 | `Store.logic:384`(+ `blocked` · `prices`) · `LogicLab_Detail` · `_Basic` | 줄 통째 · 막힘 · 단가 미리보기 | 이름표 = 문서 머리 · 막힘 = 2-B3 문서 막힘 · 단가 미리보기 = 문서 셈 | +| 별칭 | `M01_MasterData_Alias.py`(`/alias/save` → `Make.save` 별칭 칸) · 로직 목록 `onAlias` | `별칭` 칸 | 문서 머리 `별칭` 쓰기(문서 저장 길 · 잠금 = 걸음 1 의 문서 저장 잠금) | +| 개정 · 개정 확인 | `Store_Revise`(정본 줄 지문 · 409) · `UI_Logic_Text.ts` · `build_로직_개정.py` | `개정` · 줄 지문 | 문서 지문(`dc.doc_fp` 꼴) · 개정 칸 = 문서 머리 | +| 키 대장 | `master_keys`(`_키대장.json`) · `Store_Save._errors`(키 겹침 · 대장 대조) | 로직 키 발급 · 대조 | 대장 그대로 · 대조 대상 = 문서 키 | +| 기계 등록 | `Machine.register`(`M01_MasterData_Machine.py:131-201`) | 로직 `입력[기계].고르기` + 문서 `선택 목록` 두 벌 | 문서만 | +| [신규 로직] · [복사/생성] · [삭제] | `Store_Make`(3 곳) · `/logic/copy` · `/logic/formula*` · `/logic/remove` · `/logic/users` | 로직 줄 만들기 · 지우기 · 쓰는 곳 | 문서만 만들고 지움(854-2 가 문서 같이 만들기 하는 중 → 그 뒤 로직 쪽 걷음) | +| 저장 검사 | `check_master`(로직 틀 · `시험입력`) · `Store_Save._errors` · `Store_Cache._check · check_saved` | 로직 줄 틀 | 문서 검사(`master_doc.check` + 2-B3 막힘) | +| 손고침 판정 | `M01_MasterData_Doc.py`(`built()` = `master_doc_convert.convert(로직 줄)`) | 로직 줄 → 빌더 문서 | 빌더 은퇴와 함께 `손고침` 칸 뜻 없어짐 → 걷음 | +| 계산서 덧칸 | `Store_Sheet` · `master_sheet_line`(B09 `_annotate` 도) | 로직 줄 식 | 문서 셈 기록(B9-1) | +| 일위대가 조합 알약 · 입력 | `M01_MasterData_Store_Combo.combo_pills` · `M02_Labor_Inputs.py:36-94`(`/logic-lib/inputs` ← M02 일위대가 · B09 손 줄 · 운반 모달 `fetchLogicInputs`) · `Combo_Store` · `Router_Combos` | `입력`(이름 · 설명 · 단위 · 고르기 · 범위) · `결과단위` | 문서 `변수`(입력 갈래 · `선택 목록` · `연결.값` 기본값 = 본 설계 ③) | +| M02 기초 고르기 · 찾아 넣기 | `/logic-lib/logics · subs · logic · source`(`M02_MasterTemplete_Router_Combos.py:42-93` → M01 함수) · `Logic_Standard`(2-C4) | 목록 · 이름표 · 출처 | M01 목록 갈래를 따라 바뀜 | +| M02 SK · SC 사본 | `Sangeun_Copy`(`사본.로직` · `수식.로직` = **로직 줄 값 사본**) · `Copy_Slim` · `Doc_Gap` · `Item_Prices.collect`(로직 식 글 훑어 닫힌 묶음) | 로직 줄 · 표 · 요소 줄 | 로직 줄 값 사본 없앰 → `수식.부름`(문서 사본)이 대신 · 닫힌 묶음 = `Doc_Copy.closure`(문서로 · 이미 있음) · 표 · 요소 줄은 남음 | +| M02 그 밖 이름 · 단위 읽기 | `Layer_Index` · `Library_Flat`(5) · `Doc_Copy` · `Doc_Sk` · `Doc_Take` · `Labor_SkRow` · `Sangeun_Doc` · `Sangeun_Block` · `Machine_Find` · `MyMachine*` · `Material_Own` · `Elem_Alias` | `이름` · `결과단위` · `입력` | 문서 머리 · 변수 | +| 불러오기 이음 | `Hopyo_Elem`(5) · `Hopyo_Match`(3) · `Hopyo_Clause` · `Hopyo_Relink` · `Hopyo_Row` · `Hopyo_Units` · `Hopyo_Build` · `Doc_Import` · `San_*` | 엑셀 호표 ↔ M01 기초 맞춤(이름 · 원문번호 · 단위 · 입력) | 문서 머리(원문번호 · 이름 · 단위) · 변수 — **857 과 겹침**(아래 2-3 묶음 ⓒ) | +| B08 · B09 | `Item_Source.logic_rows:105`(사본에 로직 줄 실음) · B09 `Sangeun` 6 · `Sangeun_Text` 4 · `Labor_Source` 2 · `Supply` · `Bill_Hopyo` · `Bill_Library` · `Daega_Personal` | 사본 · 지금 M01 로직 줄 | ㉮ 끝(B9-6)이면 0 | +| 옛 엔진 · 옛 수식 탭 | `master_formula` · `_check` · `_sum` · `master_cut` · `master_text` · `master_combo` · `master_equation*` · `M01_MasterData_Equation` · `M02_Sangeun_Equation` · `M02_Sangeun_Formula` | 로직 줄 셈 칸 | 2-E2 · 2-E4 로 지움 | +| 갱신 스크립트 | `build_로직_직접칸_851_1.py` · `build_로직_개정.py` · `build_용도.py` · `build_재료_검색어.py`(쓰기) · `build_변수표_796_3` · `build_변수기호_800_1` · `build_단위표기_801_5` · `build_기계_작업량_846_1` · `compare_estx` · `master_bundle` · `master_doc_unit` | 로직 JSON 읽고 씀 | 2-4 | +| 시험 | 로직 파일 이름 45 · `.logic(` 42 · `run_line` 27 · `master_formula` 23 · `master_doc_convert` 7 · 빌더 4(1,401 시험 파일 중) | 로직 줄 견본 · 대조 | 걸음마다 그 자리 시험만 문서 견본으로 · 대조 시험은 은퇴 | + +### 2-3 차례 · 병행 · 지킴 + +| 걸음 | 무엇 | 지킴 | 앞 조건 | +| --- | --- | --- | --- | +| L1 이름표 싣기(첫 박자) | 빌더가 이름표 칸 일곱 · 파일 머리 셋을 문서에 실음(`--check` 새 기준) · M01 [저장](비고 · 별칭 · 자체 이름 · 개정)이 두 곳에 씀 | 1,521 문서 이름표 = 로직 줄 이름표(다름 0) · 금액 골든 같음 | 2-B3 · 854-2 끝 · **로직 JSON 을 고치는 일감 0**(851 류 끝) | +| L2 읽는 쪽 바꿈(묶음 셋 병행) | ⓐ M01 목록 · 찾기 · 분류 · 상세 · 별칭 · 개정 · 키 대장 · 저장 검사 · 기계 등록 · 신규 · 복사 · 삭제 ⓑ M02 입력 목록 · 알약 · 이름 읽기 · SK 사본 `로직` 값 사본 없앰(`수식.부름` 으로) · 닫힌 묶음 = 문서 ⓒ 불러오기 이음(Hopyo · San — 857 과 같이 하거나 857 앞에 이름표 읽기만 바꿈) | 화면 답 전후 같음(`/logics` 전 갈래 · `/subs` · `/groups/로직/files` · `/logic` · `/alias` · `/logic-lib/inputs` 답 JSON 대조) · 금액 골든 · 불러오기 골든(`test_812_1`) | L1 · ⓑ 는 2-C1 · 2-D 뒤 · ⓒ 는 2-C2 뒤 | +| L3 로직 JSON 뺌(둘째 박자) | 읽는 곳 0 확인(`census_logic_readers` 관문 · 이름표 0) → `로직_*.json` 59 `git rm`(브레인이 tmp 보관) · `mf.GROUPS` 「로직」 뺌 · 키 대장은 그대로 | 금액 골든 · 화면 답 대조 · 핵심 시험 · 서버 뜸 | L2 · ㉮ B9-6 · 2-E1 · 2-E2 | +| L4 은퇴 | 2-4 표 | `test_855_golden` + `test_802_1`(거울)이 관문 | L3 | + +### 2-4 은퇴 목록 + +| 대상 | 은퇴 때 | 대신 | +| --- | --- | --- | +| 빌더 `build_수식문서_802_2.py` · `master_doc_convert` · `_목록_802-2_변환대조.xlsx` | L3 | 문서가 정본 · 고침 = M01 [저장] · 문서 고침 스크립트 | +| `test_802_2_convert`(싱크 관문) | L3 | `test_855_golden`(지문) + `test_802_1`(파이썬 ↔ TS 거울) 관문 | +| `master_equation*` 6 · `M01_MasterData_Equation` · `M02_Sangeun_Equation` · `master_symbol` | 2-E2(SK 옛 식 덮개 걷음) 뒤 · L3 | 문서 변수(이름 · 기호 · 단위) | +| `M01_MasterData_Doc` 의 `built()` · `손고침` 판정 | L3 | 없음(빌더가 없으니 갈림도 없음) | +| 「로직 줄을 더한 뒤 채우기」 넷(`build_변수표_796_3` · `build_변수기호_800_1` · `build_단위표기_801_5` · `build_재료_검색어`) | L3 | 문서에서 같은 채우기가 필요하면 문서 대상 스크립트로 다시 씀(지금은 새 로직이 늘 때만 돎) | +| `build_로직_개정.py` | L1 에서 문서 머리 `개정` 을 쓰도록 바꿈 | 같은 스크립트 · 대상만 문서 | +| 한 번용 `build_로직_*`(851-1 등) | 다 돈 것 → 걸음 0 보관 갈래 | 앞으로 기초 고침 = 문서 고침 스크립트 | +| `_갱신절차.md` 로직 절 · 수식 문서 절 | L3 | 수식 문서 절 하나(빌더 없음 · 고치는 길 = 화면 · 문서 스크립트) — 갱신절차 고침은 이 일감 범위 밖 · 그때 같이 | + +### 2-5 수식 문서 파일 나눔 + +지금 = 옛 로직 파일마다 한 벌(59 파일 · 원문 · 장 단위 · 파일 머리 `로직파일`). **그대로 둠(권함)** — 분류 화면(원문 · 장 차례)과 파일이 1:1 · 저장 한 번에 작은 파일 하나만 씀 · git 다름이 장 단위로 읽힘. 바꾸는 것 = 파일 머리 `로직파일` → `원문 · 부문 · 차례`(L1) · 파일 이름은 그대로(`수식_<원문>_장_….json`). + +--- + +## 3. ㉰ 호환을 안 만드는 쪽으로 줄이기 + +### 3-1 빼거나 줄이는 걸음(저장본을 비우는 전제) + +| 본 설계 자리 | 원래 할 일 | 비우면 | 어림 줄 | 차례 | +| --- | --- | --- | --- | --- | +| 2-C1 「사본 없는 SK 는 옛 `run_line`」 | 옛 길을 남겨 둠 | **뺌** — SK 는 늘 `수식` 사본으로 만들어짐 · 없는 SK = 「못 셈 · 까닭」 | −150(2-C1 안 옛 갈래 · 2-E2 가 나중에 지울 몫이 미리 없음) | 2-C1 과 2-E2 일부가 한 걸음 | +| 2-C1 「옛 칸 값 있는 SK 는 옛 길 그대로(2-D 에서 올림)」 | 옛 7 칸 셈 유지 | **뺌** | −100 | 같음 | +| 2-D 「읽을 때 올림」(옛 7 칸 → `따로` 굳힘 · `사본` → `수식` · `바탕판` 버림) | 올림 규칙 새로 + 시험 | **뺌** — 칸만 걷고 읽지 않음 | −250(+ 시험 −150) | 2-D 가 2-C1 바로 뒤에 붙음 · 옛 엔진 살아 있을 때 할 일 없음 | +| 5-1 SC 「옛 로직 줄 → SK 참조」(`Labor_SkRow.migrate` 꼴) | 규칙 유지 | **뺌**(이미 걷음 · 자료 0) | 0 | — | +| SK `사본` 칸(= `수식` 여섯 칸) · `수식.로직`(로직 줄 값 사본) | 2-D 에서 이행 | 그냥 안 씀 · 안 읽음 · `Copy_Slim` · `Doc_Gap` 의 `사본` 갈래 걷음 | −120 | 2-D | +| 옛 SK 상세 길 시험 8 군(`715_*` 4 · `717_4` · `725_1` · `742_1` · `744_1` · `806_1`) | 견본을 문서 꼴로 고쳐 씀 | **지움**(옛 칸 견본만 붙듦) · 살아 있는 결과는 `test_855_sk_layers` 가 봄 | −(시험) | 2-C1 과 같은 커밋 묶음 | +| 옛 식 문법 도구 — SK 옛 식 덮개(`Sangeun_Formula` `변수줄 · 식덮개 · 더한줄 수량식`) | 옛 칸 있는 동안 유지 | 저장본에 이 칸 값 0 → **2-C1 과 같이 걷음**(2-E2 몫이 앞당겨짐) | −530 | 2-C1 뒤 | +| 프로젝트 옛 사본 꼴 — `Item_Snapshot.migrate_items:198`(25-2b `items/`) · `complete_old:384` · `Item_Copy._migrated:71` | 남김 | 프로젝트 사본 0 · `items/` 0 → **뺌**(판단 거리 3 — 프로젝트는 사용자 확정 범위 밖) | −120 | B9-5 | +| `M02_Sk_AutoRenew` 의 옛 사본 갈래 · `MasterTemplete_Tree.old_fields:58` · `MyMachine._old:467` | 남김 | 각 갈래가 옛 저장 꼴을 읽는지 그 걸음에서 확인 뒤 뺌(지금 확인 안 함) | −(미확인) | 2-D · 858 | +| B09 사본 안 굳힌 로직(`로직_단가산출.json` · `굳힌줄` · `GX9`) | 판단 5 · B09 와 같이 꼴 바꿈 | 사본 0 → 이행 없이 새 꼴(B9-5) | 0(이행) | B9-5 | + +합 어림 = 코드 **−1,200 줄 안팎** + 이행 시험 0 · 2-D 크기 절반 · 2-E2 일부가 2-C1 로 당겨짐. + +### 3-2 저장본을 비울 때 · 범위(비우는 일은 하지 않음 · 브레인이 사용자 확인 뒤) + +**때 = 2-C1 바로 앞**(855-B 끝 · 855-C 첫 걸음 전). 까닭: 2-C1 이 옛 칸 · 사본 없는 SK 를 보지 않으려면 그때 자료가 새 꼴뿐이어야 함 · 2-A 골든은 저장본이 아니라 임시 storage 견본이라 영향 없음 · 비운 뒤 사용자가 새로 만든 SK 는 이미 새 꼴(`수식` 있음). + +| 후보 | 자리 | 지금 수(`census_storage` · `census_copy_fields`) | 권함 | +| --- | --- | --- | --- | +| 단가산출 SK | 개인 `templates/sangeun/SK-*.json` · `sangeun_폴더.json` | 14 ~ 15(세는 동안 늘어남 = 사용자가 지금 만드는 중) · 가져온 식 12 ~ 13 | 비움 — 단 **사용자가 지금 개인 층에서 단가산출을 만들어 쓰는 중**(공통 지시) → 판단 거리 4 | +| 일위대가 SC | 개인 `precombo/SC-*.json` · `precombo_폴더.json` | 6 | 비움(같은 판단) | +| 지운 문서 보관 | 개인 `_합친것/` | SK 12 · SC 3 | 비움 | +| 구조물 조합 | 회사 · 개인 `구조물집계표조합.json` · `table/구조물집계표.json` | 줄 0(파일 6 · 표 6) | 그대로(빈 틀 · 새 꼴 상관없음) | +| 불러온 자료 | 개인 `실무자료/`(불러옴 4 · HP 3) | 7 | 비움 — 다시 불러오면 새로 생김 | +| 내 기계 · 내 재료 | 개인 `내기계/_다음.json` · `개인자재.json` | 1 · 1 | 858(서고 한 벌) 앞에 같이 · 855 엔 상관없음 | +| 번호 · 겉 | `_번호.json` · `manifest.json` | 1 · 1 | 비우면 번호도 처음부터(번호 겹침 위험 없음 — 문서 0) | +| **따로 둠** | 마스터 층 `resources/master_template/`(구조물 표 · 도면 틀 · 구조물정의) · 회사 `drawing/` · 프로젝트 `_initial/` · `drawing/` · `table/`(14 프로젝트) | — | 비우지 않음 — 다른 페이지(B05 · B08 · 도면)가 씀 | +| **따로 둠** | B09 견적 저장 `B09_Estimation/v1/`(1 프로젝트 · 손 줄 로직 6) | — | 프로젝트 자료 — 확정 범위 밖 · 키가 같아 새 계산기로 그대로 셈 | + +### 3-3 가져온 식(`가져온.로직` = 옛 로직 줄 꼴)은 따로 + +- 지금 SK 12 의 `가져온.로직` 칸 = `호표 · 중간 · 덧줄 · 단계 · 끝전 · 이름 · 결과단위`(옛 로직 줄 꼴) — 불러오기 읽기기(`Hopyo_*` · `San_*`)가 **불러올 때마다 이 꼴을 새로 냄** → 저장본을 비워도 다시 생김. +- 이것을 문서로 바꾸는 `Doc_Import`(`mf.parse` · `_OPS` · `_plain`) · 가져온 식 기호 `San_Basis_Index` · `Sangeun_QtyLinks` 는 **옛 식 파서**만 씀(엔진 셈 · 글 · 끝수는 안 씀 · 2-C2 · 2-C3 뒤). +- 가름: 2-E4 때 파서(`parse` · 연산 표)는 「바탕 기반」 새 모듈(`mf.Master` · `FormulaError` · `COST_ITEMS` 등과 같이)로 떼어 남김 → 857(불러오기 한 번 읽기)이 읽기기에서 문서를 바로 내면 그때 파서도 걷음. +- 저장본 비우기와 무관 · 호환 아님(살아 있는 입력 꼴). + +--- + +## 4. ㉱ 바뀐 전체 걸음 표 · 병행 묶음 + +### 4-1 걸음 표(본 설계 4-1 을 고친 것 · ★ = 새 · ✂ = 줄임) + +| 걸음 | 무엇 | 바뀐 점 | +| --- | --- | --- | +| 2-A 지킴 올림 | 855 시험 넷 · 골든 | 끝(855-A) | +| ★ B9-0 B09 견본 · 골든 | 1-4 | 새 | +| 2-B1 | 854-2 확인만 | 그대로 | +| 2-B2 · 2-B3 · 2-B4 | 기계 폴백 · 문서 막힘(기준 지금 그대로 · 확정 3) · M01 시험 계산 | 그대로 | +| ★ B9-1 셈 기록 | 1-4 | 새 · 2-B 와 병행 | +| ★ 저장본 비움(사용자 확인 · 브레인) | 3-2 | 새 · 2-C1 바로 앞 | +| 2-C1 ✂ SK 셈 한 길 | 수식 사본 셈만 · 옛 길 갈래 없음 · `Sangeun_Formula` 옛 식 칸 · 옛 상세 시험 8 군 같이 걷음 | 옛 칸 · 사본 없는 SK 갈래 뺌 | +| 2-C2 · 2-C3 | 가져온 식 열기 · 검산 | 그대로 | +| 2-C4 | 기준 목록 · 서버 풀이 글 ② | 그대로 · B9-4 의 앞 조건 | +| 2-C5 | 나머지 셈 자리 | 그대로 | +| ★ B9-2 · B9-3 | 사본 셈 · B08 / B09 산근 · 대가 | 2-C1 뒤 | +| ★ B9-4 · B9-5 | 산출근거 글 · 사본 꼴 | 2-C4 · B9-3 뒤 | +| 2-D ✂ 파일 칸 정리 | 칸 걷음만(올림 규칙 · 이행 없음) · `사본` · `수식.로직` 안 씀 | 크기 절반 | +| ★ L1 이름표 싣기 | 2-3 | 새 · 2-D 와 병행 가능(파일 다름) | +| 2-E1 · 2-E2 | M01 · M02 옛 길 지움 | 2-E2 일부(옛 식 칸)는 2-C1 로 당겨짐 | +| ★ B9-6 B08 · B09 옛 길 지움 | 1-4 | 새 | +| ★ L2 읽는 쪽 바꿈 ⓐ ⓑ ⓒ | 2-3 | 새(본 설계 2-E3 의 앞 절반) | +| 2-E3 → L3 · L4 | 로직 JSON 뺌 · 빌더 은퇴 | 「이름표만 남김」 → 「없앰」 | +| 2-E4 엔진 모듈 지움 | 1-5 차례 · 파서는 바탕 기반으로 | 보류 풂 | + +### 4-2 병행 묶음(창 여덟까지 · 파일 안 겹침) + +| 묶음 | 같이 도는 걸음(창) | 겹침 확인 | 앞 조건 | +| --- | --- | --- | --- | +| ① | 2-B2 · 2-B3 · 2-B4 · 2-C2 · 2-C4 · **B9-0** · **B9-1**(일곱) | 본 설계 ② + 새 시험 파일 · 새 `master_doc_trace.py` — 서로 다름 | 2-A · 2-B2 는 854-1 뒤 | +| ② | 저장본 비움(브레인 · 사용자 확인) | — | ① 의 2-B3 | +| ③ | 2-C1(중심) · 2-C3 · **B9-2**(B08 · `Item_Prices` · `Item_Copy`)(셋) | Sangeun_Calc · Doc_Sk ↔ Sangeun_Imported ↔ Item_* · B08 — 다름 | ② · 2-C2 · B9-1 | +| ④ | 2-C5 · **B9-3**(B09 Sangeun · Labor_Source · Linked · Supply · Sum · Rule) · 856 화면 하나 · **L1**(빌더 · M01 저장 두 곳)(넷) | Labor_Expand · Hopyo_Build ↔ B09 5 파일 ↔ 화면 TS ↔ 빌더 · M01 Store_Save — 다름 | 2-C1 · B9-2 | +| ⑤ | 2-D · **B9-4** · **B9-5** · **L2 ⓐ**(M01 쪽)(넷) | Sangeun_Doc · Copy_Slim 무리 ↔ B09 Sangeun_Text ↔ Item_Source · Item_Sangeun · Bill_Library ↔ M01 Store 무리 — 다름(B9-4 · B9-5 는 B09 안 파일이 다름) | ④ · 2-C4 | +| ⑥ | 2-E1 · 2-E2 · **B9-6** · **L2 ⓑ**(M02 이름 읽기 · SK 값 사본)(넷) | M01 ↔ M02 Sangeun 무리 ↔ B08 · B09 ↔ M02 Labor_Inputs · Layer_Index 무리 — 2-E2 와 L2 ⓑ 가 `Sangeun_Copy` 를 같이 만질 수 있음 → 그 파일은 2-E2 한 창 몫 | ⑤ · 856 | +| ⑦ | **L2 ⓒ**(불러오기 이음 — 857 과 합침 권함) | Hopyo · San | ⑥ · 857 | +| ⑧ | L3 → L4 → 2-E4(차례 · 한 창) | scripts · 자료 | ⑥ · ⑦ | + +꼭 차례인 까닭(본 설계에 더함): +- 저장본 비움은 2-C1 앞 — 2-C1 이 옛 꼴 갈래를 안 가지려면. +- B9-2 · B9-3 은 2-C1 뒤 — 사본 안 SK 셈이 문서 한 길이어야 B09 가 같은 답을 받음. +- B9-4 는 2-C4 뒤 — 서버 풀이 글이 먼저 있어야 함. +- L1 은 로직 JSON 을 고치는 일감이 0 일 때 — 빌더 기준이 두 번 바뀌지 않게. +- L3 은 B9-6 · 2-E1 · 2-E2 · L2 뒤 — 로직 줄을 읽는 곳 0. +- 2-E4 는 L3 뒤 — `mf.Master` 의 로직 그룹이 빠져야 엔진 몸이 지울 수 있는 꼴. + +### 4-3 세기 결과 파일(`tmp/s894/m855b/`) + +| 도구 | 결과 | 핵심 수 | +| --- | --- | --- | +| `census_calls.py`(sub6 · 내 폴더에서 다시) | `out_calls.tsv` | 185 자리 · 39 파일 · B08 1 · B09 5 파일 51 자리 | +| `census_copies.py` · `census_storage.py`(sub6) | `out_copies.json` · `out_storage.json` | 프로젝트 사본 0 · SK 15 · SC 6 · `_합친것` 15 | +| `census_logic_fields.py`(새) | `out_logic_fields.json` | 로직 칸 19 · 문서와 같은 값 4 · 문서 없는 이름표 6 + 별칭 + 파일 머리 3 | +| `census_logic_readers.py`(새) | `out_logic_readers.tsv` | 파일 · 갈래(관문 · 파일 이름 · 셈 칸 · 이름표 칸)별 자리 | +| `census_copy_fields.py`(새) | `out_copy_fields.json` | SK `수식.로직` 16 줄 · `사본.로직` 12 줄 · `가져온.로직` 12 · B09 손 줄 `ref.tab = logic` 6 | + +--- + +## 5. 사용자 판단 거리 + +1. **B09 손 줄이 M01 기초를 바로 고르는 기능** — B09 설계내역서 [단가 연결] · 운반 단가 모달에서 M01 단가산출 기초를 직접 골라 셈(지금 프로젝트 1 곳에 6 줄). 확정 1(「M02 것을 복사해 가져감」)과 어긋남. ㉠ 그대로 둠 — 같은 새 계산기로 셈 · 지금 6 줄 그대로 이어짐(권함) ㉡ M02 단가산출만 고르게 바꿈 — 6 줄을 다시 이어야 함. +2. **「계산을 직접 할 일 없음」 의 뜻** — 프로젝트에서 구조물 입력값 · 운반 거리를 바꾸거나 [단가 갱신] 을 누르면 금액이 다시 나와야 함. 이때 M02 와 **같은 계산기 한 벌**을 불러 다시 셈(B09 엔 식 엔진 없음 · 갈라 합산만)으로 이해(권함 · 1-3 안 B). 「복사 때 굳힌 금액만 쓰고 프로젝트에선 절대 다시 셈 안 함」 이 뜻이면 입력 바꿈 · [단가 갱신] 을 M02 [재생성]으로만 하게 바뀜. +3. **프로젝트 쪽 옛 꼴** — 확정 5 는 M02 층 자료. 프로젝트 사본은 지금 0 개라 옛 사본 꼴 읽기(25-2b `items/` 옮겨 받기 등)도 같이 걷어도 되는지(권함 = 걷음 · 지금 옮길 것 0). +4. **저장본 비우는 때** — 지금 개인 층 단가산출이 계속 늘어나는 중(세는 동안 14 → 15). 2-C1 앞에 비우면 그 사이 만든 것도 지워짐 → 비우기 전날 알림 · 남길 것만 다시 만들 길(가져온 식은 다시 불러오면 됨)을 같이 알림. + +## 6. 못 본 것 + +- 서버 · 화면을 돌리지 않음(코드 따라가기 + 자료 세기). 「살아 있음」 = 화면 TS 에서 서버 길까지 이름으로 이은 것 · 단추를 눌러 보지 않음. +- B09 프로젝트 1 곳의 손 줄 6 은 칸 이름만 셈(로직 키 · 값 안 봄). +- `M02_Sk_AutoRenew` · `MasterTemplete_Tree.old_fields` · `MyMachine._old` 가 옛 저장 꼴만 읽는지는 확인 안 함(3-1 「미확인」). +- `.logic(` 류 자리 수(102)는 글자 찾기 — `whole.logic` 처럼 이름을 바꿔 부르는 곳 · 문자열로 조립한 부름은 빠졌을 수 있음(L3 앞 전수는 다시 셈). +- 855-A 시험(sub6 커밋 327fdc5d9)은 이 폴더 받은 판에 아직 없음 — 이름만 PLAN 에서 봄. +- 줄 수 어림은 함수 크기로 짐작한 값. From 7d19c0389d807870cde3f0683a915bae3b53e92f Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 17:00:54 +0900 Subject: [PATCH 6/6] =?UTF-8?q?feat(854-2):=20M01=20[=EB=A1=9C=EC=A7=81=20?= =?UTF-8?q?=EB=B3=B5=EC=82=AC/=EC=83=9D=EC=84=B1]=20=EC=9D=B4=20=EC=88=98?= =?UTF-8?q?=EC=8B=9D=20=EB=AC=B8=EC=84=9C=EB=A5=BC=20=EA=B0=99=EC=9D=B4=20?= =?UTF-8?q?=EC=A7=80=EC=9D=8C=20=C2=B7=20=EB=A1=9C=EC=A7=81=20=EC=A7=80?= =?UTF-8?q?=EC=9A=B0=EB=A9=B4=20=EB=AC=B8=EC=84=9C=EB=8F=84=20=E2=80=94=20?= =?UTF-8?q?=EB=AC=B6=EC=9D=8C=20=E2=91=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Doc.make = 빌더와 같은 변환(convert) · 같은 대조(옛 엔진 = 새 계산기 · 기본 + 옵션 표본 · 부르는 단가산출 저장본)를 지난 것만 수식_<파일>.json 에 씀(빌더가 다시 지어도 같은 글) · 못 지나면 안 씀 - Store_Make.logic_new(/logic/copy · /logic/formula/save 공용)가 make 부름 · 답에 「수식문서」 - Store_Make.save 의 로직 줄 지움(/save)도 그 수식 문서를 지움(/logic/remove 와 같은 끝 · 문서만 남지 않게) - 빌더 build_수식문서_802_2 = 대조 갈래 cases_of · agree 로 꺼냄(동작 같음 · --check 같음) - 시험 test_854_2_m01_copy_doc — 복사 · 식 복사 → 문서 있음 · 금액 = 옛 엔진 = 본뜬 로직 · 빌더 다시 지음 = 같은 파일 글 · 지움 → 문서 없음 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Doc.py | 42 +++++++ M01_MasterData/M01_MasterData_Store_Make.py | 21 +++- .../scripts/build_수식문서_802_2.py | 29 +++-- resources/tester/test_854_2_m01_copy_doc.py | 108 ++++++++++++++++++ 4 files changed, 189 insertions(+), 11 deletions(-) create mode 100644 resources/tester/test_854_2_m01_copy_doc.py diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index 3627779db..767827b1f 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -154,6 +154,48 @@ def built(key: str) -> dict | None: return None +def make(key: str) -> bool: + """[로직 복사/생성](`Store_Make.logic_new`) 뒤 수식 문서를 지어 씀 — 빌더(`build_수식문서_802_2`)와 + 같은 변환 · 같은 대조(옛 엔진 = 새 계산기 · 기본 + 옵션 표본 · 부르는 단가산출이 저장본)를 지난 것만 + (빌더도 그것만 넣음 · 못 지나면 안 씀 = 열면 빈 문서) · 이미 있으면 그대로 · 썼거나 있음 = True.""" + import importlib + + builder = importlib.import_module("build_수식문서_802_2") + files, whole = store.loaded() + row = next( + ( + r + for data in files.values() + if data.get("그룹") == "로직" + for r in data.get("줄") or [] + if str(r.get("키")) == key + ), + None, + ) + doc = built(key) if row is not None else None + if doc is None: + return False + with _LOCK: + have = docs() + if key in have: + return True + links = ml.Links(whole, {**have, key: doc}) + if not builder._calls(doc) <= set(have) or not all( + builder.agree( + builder.old_answer(whole, row, given), builder.new_answer(links, doc, one) + ) + for _, given, one in builder.cases_of(whole, row) + ): + return False + path = folder() / _file_for(key) + data = ( + ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []} + ) + data.setdefault("줄", []).append(doc) + put(path, data) + return True + + def layered(doc: dict, key: str) -> dict: """848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 · 다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로.""" diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py index 40c84f4b9..e60e3f328 100644 --- a/M01_MasterData/M01_MasterData_Store_Make.py +++ b/M01_MasterData/M01_MasterData_Store_Make.py @@ -257,12 +257,26 @@ def save(batch: list[dict], confirmed: bool = False) -> dict: _own_path().unlink(missing_ok=True) raise docs_too() # 수식 문서 기계 고르기 목록도 같게(848-5) + _drop_docs(batch) added = [ {"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old ] return {"files": files, "added": added, "warnings": []} +def _drop_docs(batch: list[dict]) -> None: + """지운 로직 줄의 수식 문서도 지움(문서만 남지 않게 · `/logic/remove` 와 같은 끝).""" + from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게 + + files = store.loaded()[0] + for part in batch: + if (files.get(str(part.get("file"))) or {}).get("그룹") != "로직": + continue + for ch in part.get("changes") or []: + if ch.get("op") == "delete" and ch.get("key"): + doc_store.drop(str(ch["key"])) + + def _keep_same(part: dict) -> None: """고친 줄의 값이 같은 칸 = 파일 값 그대로(화면 왕복 「9.0」 → 「9」 막음 · 그 칸만 바뀜).""" data = store.loaded()[0].get(str(part.get("file") or "")) # 읽기만 — 기억(826-2) @@ -340,11 +354,14 @@ def _keys() -> list[str]: def logic_new(logic: dict, owner: str = OWNERS[0]) -> dict: - """새 자체 로직 — 키는 서버가 `GX` 다음 번호로 줌.""" + """새 자체 로직 — 키 = 서버가 `GX` 다음 번호 · 수식 문서도 같이(`Doc.make` · 요구 896).""" + from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게 + before = set(_keys()) done = _write([{"op": "add", "row": _clean(logic, owner)}]) key = next((k for k in reversed(_keys()) if k not in before), "") - return {**done, "key": key, "logic": store.logic(key)["logic"] if key else {}} + made = doc_store.make(key) if key else False + return {**done, "key": key, "logic": store.logic(key)["logic"] if key else {}, "수식문서": made} def logic_copy(key: str, 이름: str = "", owner: str = OWNERS[0]) -> dict: diff --git a/resources/master_data/scripts/build_수식문서_802_2.py b/resources/master_data/scripts/build_수식문서_802_2.py index 2eaa2fa84..bbe15a9ff 100644 --- a/resources/master_data/scripts/build_수식문서_802_2.py +++ b/resources/master_data/scripts/build_수식문서_802_2.py @@ -81,6 +81,23 @@ def new_answer(links, doc: dict, given: dict | None = None): return {"결과": got["결과"]} if doc.get("결과") else {k: got.get(k) for k in KEYS} +def cases_of(whole, row: dict) -> list[tuple]: + """(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력) — 기본 + 고르기 입력의 다른 갈래 하나씩.""" + base = meq.given_of(whole, row) + cases = [("", base, None)] + for spec in row.get("입력") or []: + for opt in spec.get("고르기") or []: + if str(opt) != str(base.get(spec["이름"])): + one = {spec["이름"]: opt} + cases.append((f"{spec['이름']}={opt}", {**base, **one}, one)) + return cases + + +def agree(old, new) -> bool: + """대조 같음 — 같은 값 · 둘 다 못 셈.""" + return old == new or (isinstance(old, str) and isinstance(new, str)) + + def _text(v) -> str: if isinstance(v, str): return v @@ -137,17 +154,11 @@ def build(log=print) -> dict: links = ml.Links(whole, docs) runs, both_out = [], 0 for _, row in items: - key, base = str(row["키"]), meq.given_of(whole, row) - cases = [("", base, None)] # (옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력) - for spec in row.get("입력") or []: - for opt in spec.get("고르기") or []: - if str(opt) != str(base.get(spec["이름"])): - one = {spec["이름"]: opt} - cases.append((f"{spec['이름']}={opt}", {**base, **one}, one)) - for label, given, changed in cases: + key = str(row["키"]) + for label, given, changed in cases_of(whole, row): old = old_answer(whole, row, given) new = new_answer(links, docs[key], changed) - same = old == new or (isinstance(old, str) and isinstance(new, str)) + same = agree(old, new) both_out += isinstance(old, str) and isinstance(new, str) runs.append( { diff --git a/resources/tester/test_854_2_m01_copy_doc.py b/resources/tester/test_854_2_m01_copy_doc.py new file mode 100644 index 000000000..a53e1a438 --- /dev/null +++ b/resources/tester/test_854_2_m01_copy_doc.py @@ -0,0 +1,108 @@ +"""M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만. + +- 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글. +- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음. +""" + +from __future__ import annotations + +import importlib +import shutil +from decimal import Decimal +from pathlib import Path + +import pytest +from fastapi import FastAPI +from fastapi.testclient import TestClient + +from M01_MasterData import M01_MasterData_Doc as doc_screen +from M01_MasterData import M01_MasterData_Router as router_module +from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Make as make + +REAL = store.FOLDER +SAMPLE = "GF000219" # 산림 13-4-1 메쌓기(인력) +COSTS = ("노무비", "재료비", "경비", "계") + + +@pytest.fixture +def client(tmp_path: Path, monkeypatch) -> TestClient: + for path in REAL.glob("*.json"): + if not path.name.startswith("_") or path.name == store.mk.BOOK.name: + shutil.copy(path, tmp_path / path.name) + shutil.copytree(REAL / "기계", tmp_path / "기계") + shutil.copytree(REAL / "수식문서", tmp_path / "수식문서") + monkeypatch.setattr(store, "FOLDER", tmp_path) + monkeypatch.setattr(doc_screen.ml, "FOLDER", tmp_path / "수식문서") + doc_screen._memo.clear() + app = FastAPI() + app.include_router(router_module.router) + return TestClient(app) + + +def _get(client: TestClient, url: str, **params) -> dict: + res = client.get(url, params=params) + assert res.status_code == 200, res.text + return res.json() + + +def _post(client: TestClient, url: str, body: dict) -> dict: + res = client.post(url, json=body) + assert res.status_code == 200, res.text + return res.json() + + +def _money(answer: dict) -> dict: + return {k: Decimal(str(answer[k])) for k in COSTS} + + +def _old(key: str) -> dict: + """옛 엔진 금액(빌더 대조와 같은 길 · 기본 입력).""" + builder = importlib.import_module("build_수식문서_802_2") + whole = store.loaded()[1] + row = store.logic(key)["logic"] + return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1])) + + +def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진과_같다(client: TestClient) -> None: + made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, "이름": "sub5임시 본뜸"}) + key = made["key"] + assert key.startswith("GX") and made["수식문서"] is True + got = _get(client, "/api/m01/logic/doc", key=key) + assert got["새"] is False and got["파일"] == "수식_자체.json" and got["문서"]["식"] + assert got["셈"]["셈됨"] is True + source = _get(client, "/api/m01/logic/doc", key=SAMPLE) + assert _money(got["셈"]) == _old(key) == _money(source["셈"]) and _old(key)["계"] > 0 + + # 빌더가 다음에 다시 지어도 같은 파일 글(옛 로직 줄이 있는 키 = 빌더 몫) + builder = importlib.import_module("build_수식문서_802_2") + result = builder.build(log=lambda *_: None) + assert key in result["저장"] + want = builder.files_of(result)["수식_자체.json"] + assert (doc_screen.folder() / "수식_자체.json").read_text(encoding="utf-8") == want + + # 지우면 문서도 같이 + info = _get(client, "/api/m01/logic", key=key) + _post( + client, + "/api/m01/logic/remove", + {"key": key, "file": info["file"], "version": info["version"]}, + ) + assert _get(client, "/api/m01/logic/doc", key=SAMPLE)["새"] is False + assert key not in doc_screen.docs() + + +def test_식_복사로_만든_로직도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None: + view = _get(client, "/api/m01/logic/formula", key=SAMPLE) + made = _post( + client, + "/api/m01/logic/formula/save", + {"로직": view["로직"], "별칭": view["별칭"], "본뜬키": SAMPLE, "이름": "sub5임시 식복사"}, + ) + key = made["key"] + assert made["수식문서"] is True and key in doc_screen.docs() + assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == _old(key) + + body = {"file": make.OWN, "version": made["version"], "changes": [{"op": "delete", "key": key}]} + _post(client, "/api/m01/save", {"files": [body]}) + assert key not in doc_screen.docs()