From badceff991548d517ad71a1ee9e09692b1f92a2d Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 13:28:00 +0900 Subject: [PATCH] =?UTF-8?q?refactor(855-E=20L3b=20=E2=91=A1):=20=EB=A1=9C?= =?UTF-8?q?=EC=A7=81=20=EC=A4=84=20=EA=B0=99=EC=9D=B4=20=EC=93=B0=EA=B8=B0?= =?UTF-8?q?=20=EB=81=94=20=E2=80=94=20mirror=20=C2=B7=20=EC=8A=A4=EC=9C=84?= =?UTF-8?q?=EC=B9=98=20=C2=B7=20=EB=B9=8C=EB=8D=94=20=EB=AC=B8=EC=84=9C=20?= =?UTF-8?q?=EA=B0=88=EB=9E=98=20=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Store_Logic: WRITE · CALC · mirror · _ordered · _headed_row · _picks · _write 지움(로직 JSON 쓰는 곳 0) - Machine.register 의 mirror 줄 · Store_Save._logic_file · Store_Cache 「!= 로직」 표지 걷음 · labor_errors = 있는 기초 키(수식 문서)만(whole.logic 갈래 지움) - M01 Doc: _row · sync_tags · ensure · built · of_row · make 지움 · 읽기 「층바탕」(빌더 문서) 뺌 · 손고침 = 셈 칸을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 브레인 정함) - M02 Doc_Sk.base_doc · Doc_Sk_Path 층바탕의 빌더 문서 갈래 지움(그 자리 = 지금 문서) - 화면 LogicRow 셈 칸 · [신규] 빈 셈 칸 · 안 쓰는 꼴 셋 지움 - 시험: 855_l3_doc_only = 옛 로직 파일 놓여도 안 읽고 안 씀 · 848_1 손고침 표지 · 848_10 빌더 층 시험 지움 · 파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 문서를 따라감 · 854_2 복사 = 원본 문서 금액(옛 엔진 대조 뺌) · 848_5 · 855_l1 로직 줄 대조 뺌 · labor_errors 손님 셋 = 있는 키 묶음 - 서버 답 243 건 다름 0 · typecheck 0 · 관련 105 파일(717_2a 원래 실패 · 792_3 엔진 몸 일감 몫 빼고) 통과 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Doc.py | 148 ++---------------- M01_MasterData/M01_MasterData_Machine.py | 5 +- M01_MasterData/M01_MasterData_Router.py | 2 +- M01_MasterData/M01_MasterData_Store_Cache.py | 29 ++-- M01_MasterData/M01_MasterData_Store_Logic.py | 123 +-------------- M01_MasterData/M01_MasterData_Store_Make.py | 3 +- M01_MasterData/M01_MasterData_Store_Save.py | 8 +- M01_MasterData/M01_MasterData_UI_LogicLab.ts | 4 - M01_MasterData/M01_MasterData_UI_Logic_Api.ts | 29 +--- M02_MasterTemplete/M02_Doc_Sk.py | 8 +- M02_MasterTemplete/M02_Doc_Sk_Path.py | 7 +- resources/tester/test_826_2_machine_files.py | 2 +- resources/tester/test_848_10_upper_down.py | 45 +----- resources/tester/test_848_1_cover_layers.py | 52 ++---- resources/tester/test_848_5_machine_impact.py | 3 +- resources/tester/test_854_2_m01_copy_doc.py | 25 +-- resources/tester/test_855_l1_tags.py | 4 +- resources/tester/test_855_l3_doc_only.py | 26 +-- resources/tester/test_m02_labor_doc.py | 7 +- resources/tester/test_m02_labor_ref.py | 14 +- 20 files changed, 86 insertions(+), 458 deletions(-) diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index 807cffc72..f28c1c3d4 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -4,12 +4,11 @@ 셈 = `master_doc_calc.calc`(파이썬 정본 · TS 짝 `common_util_formula_doc_calc.ts`) · 연결 기록 = `master_doc_record.Rec` — 셈이 쓴 요소 값 · 표 · 단가산출 문서를 화면 캐시로 실음 (화면은 같은 계산기로 즉시 셈 · 캐시에 없는 연결만 뒤에서 미리 셈). -- 읽기 {키} → {문서, 셈, 연결, 파일, 새, 층바탕?} — 문서가 없으면 빈 문서(이름 · 단위 = 로직 줄) · - 층바탕(848-8) = {위: 빌더가 지을 문서} — 화면이 칸 단위로 맞대 시스템 관리자 고침 테두리(읽기만 · 파일 안 씀) +- 읽기 {키} → {문서, 셈, 연결, 파일, 새, 판} — 없는 키 = 404 - 미리 셈 {문서, 입력} → {셈, 연결} — 쓰기 없음 - 저장 {문서} → {문서, 셈, 연결, 파일} — 서버가 정본으로 다시 셈 · 문서 파일에 씀(브라우저 셈 값 안 받음) - · 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) · 셈 칸이 빌더 결과와 같으면 - 빌더 글 + 기계덮음 · 다르면 받은 문서 + `손고침`(빌더가 안 덮음 · 같게 되돌려 저장하면 사라짐) + · 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) · + 셈 칸을 고치면 `손고침`(M02 SK 가 기초 문서 사본을 실음 · 한 번 붙으면 남음) 권한 = 라우터를 `main.py` 가 `system_admin_only` 로 붙임. M02 는 같은 꼴로 따로(802-4). """ @@ -91,7 +90,9 @@ def docs() -> dict[str, dict]: return _memo["docs"] -#: 목록 · 상세가 문서에서 읽는 머리(이름표 `md.TAGS` 밖) — 로직 줄 고침도 같게(`sync_tags`) +#: 손고침 표지를 가르는 셈 칸(`layered`) +CALC = ("변수", "식", "금액", "끝수") +#: 목록 · 상세가 문서에서 읽는 머리(이름표 `md.TAGS` 밖) HEAD = ("이름", "결과단위", "출처", "부품") @@ -163,10 +164,8 @@ def read(key: str) -> dict: if found is None: raise store.StoreError(404, f"없는 로직 「{key}」") out = _run(found) - up = built(key) # ponytail: 빌더 문서(층바탕) — 로직 JSON 이 없으면 None · 둘째 박자에서 걷음 - more = {"층바탕": {"위": up}} if up is not None else {} 판 = version_of(found) # 저장 때 대조(다른 곳에서 바뀌면 409) - return {"문서": found, **out, "파일": _where(key) or "", "새": False, "판": 판, **more} + return {"문서": found, **out, "파일": _where(key) or "", "새": False, "판": 판} def preview(doc: dict, given: dict | None = None) -> dict: @@ -185,39 +184,8 @@ def _new_file(name: str) -> dict: return {"그룹": "수식문서", "로직파일": logic, **tags, "줄": []} -def _row(key: str) -> dict | None: - """그 키의 로직 줄(기억 · 읽기만) — 없음 = None.""" - for data in store.loaded()[0].values(): - if data.get("그룹") == "로직": - for row in data.get("줄") or []: - if str(row.get("키")) == key: - return row - return None - - -def sync_tags(keys) -> int: - """로직 줄 이름표를 수식 문서 줄 머리에 같게(855 L1 · 읽는 쪽이 문서로 옮길 때까지 두 곳) — - 로직 줄 · 문서가 둘 다 있는 키만 · 바뀐 문서 파일만 씀(`put`) · 바꾼 문서 수.""" - want = {k: r for k in set(map(str, keys)) if (r := _row(k)) is not None} - if not want: - return 0 - n = 0 - with _LOCK: - for path in sorted(folder().glob("수식_*.json")): - data, hit = ml.load_file(path), False - rows = data.get("줄") or [] - for at, doc in enumerate(rows): - row = want.get(str(doc.get("키"))) - if row is not None and _headed(doc, row) != doc: - rows[at], hit = _headed(doc, row), True - n += 1 - if hit: - put(path, data) - return n - - def _headed(doc: dict, row: dict) -> dict: - """문서 머리를 로직 줄 것과 같게 — 이름표(`md.tag`) + `HEAD`(있던 자리 그대로 · 줄에 없는 칸은 뺌).""" + """문서 머리를 받은 머리와 같게 — 이름표(`md.tag`) + `HEAD`(있던 자리 그대로 · 머리에 없는 칸은 뺌).""" out = md.tag(doc, row) for k in HEAD: if k in row: @@ -227,96 +195,9 @@ def _headed(doc: dict, row: dict) -> dict: return out -def ensure(key: str) -> bool: - """새 로직 줄의 수식 문서 — 빌더와 같은 문서(`make`) · 못 지으면 빈 문서 + 머리(목록이 문서에서 읽으므로 - 문서 없는 로직 0 · 열면 빈 문서는 그대로) · 지어 넣었거나 이미 있음 = True.""" - if make(key): - return True - row = _row(key) - if row is None: - return False - blank = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원")) - blank = { - **dict(list(blank.items())[:5]), - "출처": row.get("출처"), - **dict(list(blank.items())[5:]), - } - with _LOCK: - if key in docs(): - return True - path = folder() / _file_for(key) - data = ml.load_file(path) if path.exists() else _new_file(path.name) - data.setdefault("줄", []).append(_headed(blank, row)) - put(path, data) - return False - - -def built(key: str) -> dict | None: - """빌더가 지을 그 키 문서(옛 로직 줄 변환 · `build_수식문서_802_2`) · 로직 줄 없음 · 변환 틀림 = None.""" - for data in store.loaded()[0].values(): - if data.get("그룹") != "로직": - continue - for row in data.get("줄") or []: - if str(row.get("키")) == key: - return of_row(row) - return None - - -def of_row(row: dict) -> dict | None: - """로직 줄(저장 전 고친 줄도) → 빌더와 같은 변환의 수식 문서 · 변환 틀림 = None — - [로직 복사/생성] 시험 계산(855 2-B4)이 저장하면 지을 문서로 셈.""" - import master_doc_convert as cv - - try: - doc = cv.convert(store.loaded()[1], row)[0] - except Exception: # noqa: BLE001 — 변환 틀림 = 빌더 문서 없음(표지 안 담) - return None - return md.tag(doc, row) # 855 L1 이름표 = 빌더와 같게 - - -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 _new_file(path.name) - data.setdefault("줄", []).append(doc) - put(path, data) - return True - - def layered(doc: dict, key: str) -> dict: - """848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 · - 다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로.""" + """848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 받은 문서 + 덮음 · + `손고침` = 셈 칸(`CALC`)을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 855-E L4).""" links = ml.Links(store.loaded()[1], {**docs(), key: doc}) try: doc = mcv.prune_doc(doc, links) @@ -324,10 +205,9 @@ def layered(doc: dict, key: str) -> dict: raise store.StoreError(400, str(e)) from e cover = doc.get(mcv.COVER) bare = {k: v for k, v in doc.items() if k not in (mcv.COVER, mcv.HAND)} - base = built(key) - hand = base is not None and ml._norm(bare) != ml._norm(base) - if base is not None and not hand: - bare = base + was = docs().get(key) + calc = lambda d: ml._norm({k: d.get(k) for k in CALC}) # noqa: E731 + hand = was is not None and (bool(was.get(mcv.HAND)) or calc(was) != calc(bare)) out = {**bare, **({mcv.HAND: True} if hand else {}), **({mcv.COVER: cover} if cover else {})} if "쌓기" in out: # 줄 쌓기 차림 = 끝 칸(화면 `docOf` 와 같은 차례) out["쌓기"] = out.pop("쌓기") @@ -422,7 +302,7 @@ def drop(key: str) -> None: def remove(key: str, file: str, version: str, confirmed: bool) -> dict: - """로직 지우기 — 쓰는 곳 있으면 409 {쓰는곳} · 기초 저장 길(`Store_Logic` — 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기).""" + """로직 지우기 — 쓰는 곳 있으면 409 {쓰는곳} · 기초 저장 길(`Store_Logic` — 개정 확인 · 판 · 검사 · 문서 지움).""" from M01_MasterData import ( M01_MasterData_Store_Logic as logic_store, ) # 그 파일이 이 파일을 부름 — 늦게 diff --git a/M01_MasterData/M01_MasterData_Machine.py b/M01_MasterData/M01_MasterData_Machine.py index 2a38b88ca..5cc149bd6 100644 --- a/M01_MasterData/M01_MasterData_Machine.py +++ b/M01_MasterData/M01_MasterData_Machine.py @@ -120,7 +120,7 @@ def formula(row: dict) -> dict: def register(batch: list[dict]) -> Callable[[], None]: """[새 기계] 저장 = 꼴 식 「기계」 목록에 그 원문번호 더함 · M01 에서 만든 기계(출처 모두 「자체」)를 지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록(정본 · - 848-5)에 더함 · 뺌 + 옛 로직 줄 고르기 같이 쓰기(`Store_Logic.mirror` · 855 L3 ⓐ).""" + 848-5)에 더함 · 뺌.""" from M02_MasterTemplete import M02_Machine_Hourly as mh # M02 가 M01 을 부름 — 늦게 from M02_MasterTemplete import M02_MyMachine as mym @@ -153,10 +153,7 @@ def register(batch: list[dict]) -> Callable[[], None]: return lambda: None def after() -> None: - from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 늦게(서로 부름) - _register_docs(add, drop) - logic_store.mirror([], (add, drop)) after.lists = ( add, diff --git a/M01_MasterData/M01_MasterData_Router.py b/M01_MasterData/M01_MasterData_Router.py index 2363f6657..c8f94bc48 100644 --- a/M01_MasterData/M01_MasterData_Router.py +++ b/M01_MasterData/M01_MasterData_Router.py @@ -280,7 +280,7 @@ def get_logic_users(key: str) -> dict: @router.post("/logic/remove") def post_logic_remove(body: RemoveBody) -> dict: - """로직 지우기(804-7) — 수식 문서(+ 옛 로직 줄 같이 쓰기) · 부르는 곳 있으면 409 {쓰는곳}.""" + """로직 지우기(804-7) — 수식 문서 · 부르는 곳 있으면 409 {쓰는곳}.""" return _call(doc_screen.remove, body.key, body.file, body.version, body.개정확인) diff --git a/M01_MasterData/M01_MasterData_Store_Cache.py b/M01_MasterData/M01_MasterData_Store_Cache.py index b6177a66b..12963e802 100644 --- a/M01_MasterData/M01_MasterData_Store_Cache.py +++ b/M01_MasterData/M01_MasterData_Store_Cache.py @@ -117,10 +117,9 @@ def stale(names, marks=()) -> None: `marks` = 요소·표에서 흔들린 자리 — 그 자리를 보던 로직 줄만 다시 셈.""" with _FRESH: for name in names: - was = _READ.pop(name, (None, {}))[1] + _READ.pop(name, None) _BLOCK.pop(name, None) - if was.get("그룹") != "로직": - _MARKED.setdefault(name, set()).update(marks) + _MARKED.setdefault(name, set()).update(marks) _INDEX.pop("자국", None) if (held := _STEADY.get()) is not None: held.clear() @@ -139,11 +138,9 @@ def adopt(folder: Path, files: dict[str, dict], whole, names, marks=()) -> None: ): return stale(names, marks) for name in names: - was = _READ.get(name, (None, {}))[1] _READ[name] = (now[name], files[name]) _BLOCK.pop(name, None) - if was.get("그룹") != "로직": - _MARKED.setdefault(name, set()).update(marks) + _MARKED.setdefault(name, set()).update(marks) _INDEX.update(자국=now, files={n: _READ[n][1] for n in now}, whole=whole) if (held := _STEADY.get()) is not None: held.clear() @@ -180,7 +177,7 @@ def blocks(folder: Path) -> dict[str, list[str]]: if _INDEX.get("문서") is not (now := docs()): # 수식 문서가 바뀌면 통째로 다시 _BLOCK.clear() _INDEX["문서"] = now - base = {n: s for n, s in stamps.items() if files[n].get("그룹") != "로직"} + base = dict(stamps) marks = None # 요소·표에서 흔들린 자리 — None 이면 무엇이 바뀐지 모름(통째로 다시) if _BASE != base: # 인력 · 재료 · 표가 바뀌면 바탕이 달라짐 off = {n for n in set(_BASE) | set(base) if _BASE.get(n) != base.get(n)} @@ -277,7 +274,7 @@ def logic_errors(files: dict, whole, book: dict | None, narrow=None) -> list[str """저장 검사의 기초 몫(855 L3 ⓐ — 수식 문서가 정본) — 키 겹침 · 대장(요소 파일 + 문서 키) · 좁힘 없으면 연결 · 준용이 먼저 · 그것이 깨끗하면 수식 문서 막힘(`narrow` 를 주면 그 키만 · 요소 닫힘 · 문서 사이 순환) — 같은 흠을 두 번 안 적음.""" - view = {n: d for n, d in files.items() if d.get("그룹") != "로직"} | dict(_logic_files()) + view = files | dict(_logic_files()) out = cm.duplicate_keys(view, book) + ([] if narrow else cm.check_links(whole)) return out or mb.check_docs(_docs_of(), narrow[0] if narrow else None, whole) @@ -300,11 +297,11 @@ def _labor_files() -> list[tuple[str, Path]]: ] -def labor_errors(whole, keys=None, have=None) -> list[str]: - """일위대가 · 사전조합 문서가 담은 로직 마스터에 없음(39-1d · 50-3) — +def labor_errors(have, keys=None) -> list[str]: + """일위대가 · 사전조합 문서가 담은 로직이 기초에 없음(39-1d · 50-3) — 로직 지우기를 막음 · 어디서 쓰는지 알림 · 참조 줄(로직 없음)은 건너뜀. 전부터 깨진 것은 - `save` 가 고치기 전 검사와 견주어 뺌. `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶) · - `have` = 있는 기초 키(저장 뒤 문서 · 855 L3 ⓐ — 주면 `whole` 대신).""" + `save` 가 고치기 전 검사와 견주어 뺌. `have` = 있는 기초 키(수식 문서 · 855-E L3) · + `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶).""" out = [] if keys is not None and not keys: return out @@ -321,13 +318,7 @@ def labor_errors(whole, keys=None, have=None) -> list[str]: key = str(one.get("로직") or "") if isinstance(one, dict) else "" if not key or (keys is not None and key not in keys): continue - if have is not None: - if key not in have: - out.append(f"{where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌") - continue - try: - whole.logic(key) - except cm.mf.FormulaError: + if key not in have: out.append(f"{where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌") return out diff --git a/M01_MasterData/M01_MasterData_Store_Logic.py b/M01_MasterData/M01_MasterData_Store_Logic.py index 76020539a..48fb43614 100644 --- a/M01_MasterData/M01_MasterData_Store_Logic.py +++ b/M01_MasterData/M01_MasterData_Store_Logic.py @@ -5,7 +5,7 @@ - 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`) - 키 = 대장(`_키대장.json` · 그 파일 표 다음 번호 · 자체 GX) · 검사 = 문서(일위대가 · 사전조합 · 조합이 담은 기초 · 키 겹침 · 대장) · 쓰는 곳 409 는 [삭제](`Doc.remove`) -- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`) +- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) · 로직 JSON 은 없음(855-E L3) 화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫. """ @@ -15,24 +15,14 @@ import copy import os from pathlib import Path -from common_util.common_util_time import kst_today from M01_MasterData import M01_MasterData_Doc as doc_store from M01_MasterData import M01_MasterData_Store as store from M01_MasterData import M01_MasterData_Store_Revise as revise -from M01_MasterData.M01_MasterData_Store_Shape import dump, keep_shape md, ml, mk, cm = doc_store.md, doc_store.ml, store.mk, store.cm -#: 로직 줄 같이 쓰기 — M02 · B09 가 로직 줄을 더 안 읽게 되면(둘째 박자) 끄고 `mirror` 를 지움 -WRITE = os.environ.get("AISLO_LOGIC_WRITE", "1") != "0" OWN = "로직_자체.json" FIELDS = revise.FIELDS -CALC = { - "입력": [], - "중간": [], - "호표": [], - "끝수": None, -} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음) def is_logic(file: str) -> bool: @@ -68,10 +58,10 @@ def _fresh_doc(key: str, row: dict, base: dict | None) -> dict: return doc_store._headed(base, {**head(row), "키": key}) -def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]: - """고침 · 더함 · 지움을 문서 파일 사본에 — (문서 파일 → 내용, 같이 쓰기 편집, 더한 키, 지운 키).""" +def _plan(parts: list[dict], book: dict) -> tuple[dict, list, set]: + """고침 · 더함 · 지움을 문서 파일 사본에 — (문서 파일 → 내용, 더한 키, 지운 키).""" plan: dict[str, dict] = {} - edits, added, gone = [], [], set() + added, gone = [], set() for part in parts: file = str(part.get("file") or "") path = _doc_file(file) @@ -97,7 +87,6 @@ def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]: if str(row.get("키")) != key: raise store.StoreError(400, f"{file} · 키는 바꾸지 않음 「{key}」") rows[at] = doc_store._headed(rows[at], head(row)) - edits.append(("머리", key, doc_store.head_of(rows[at]))) elif op == "add": where = doc_store.logic_files().get(file) or {"원문": "자체"} tid = mk.table_id("로직", store._book(where)) @@ -106,13 +95,11 @@ def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]: source = str(ch.get("from") or "") base = doc_store.docs().get(source) if source else None rows.append(_fresh_doc(key, row, base)) - edits.append(("더함", key, {"file": file, "row": head(row), "from": source})) added.append({"file": file, "key": key}) else: del rows[at] gone.add(key) - edits.append(("지움", key, None)) - return plan, edits, added, gone + return plan, added, gone def _combos(have: dict) -> list[str]: @@ -140,7 +127,7 @@ def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]: if callers := {k for k, d in docs.items() if mb.calls(d) & gone}: was = set(mb.check_docs(doc_store.docs(), callers, whole)) out += [x for x in mb.check_docs(docs, callers, whole) if x not in was] - return out + store.cache.labor_errors(None, gone, keys) + return out + store.cache.labor_errors(keys, gone) def save(parts: list[dict], confirmed: bool = False) -> dict: @@ -156,7 +143,7 @@ def save(parts: list[dict], confirmed: bool = False) -> dict: book_path = store.FOLDER / mk.BOOK.name book = mk.load_book(book_path) old_book = {"키": dict(book["키"]), "다음": dict(book["다음"])} - plan, edits, added, gone = _plan(parts, book) + plan, added, gone = _plan(parts, book) mk.finish(book) if bad := _errors(plan, gone, old_book, book): raise store.StoreError(422, {"errors": bad}) @@ -171,7 +158,6 @@ def save(parts: list[dict], confirmed: bool = False) -> dict: except BaseException: _undo(paths, raw, book_path, book_raw) raise - mirror(edits) files = list(dict.fromkeys(str(p.get("file")) for p in parts)) return { "files": [{"file": f, "version": doc_store.file_version(f)} for f in files], @@ -196,98 +182,3 @@ def _put(path: Path, data: bytes) -> None: tmp = path.with_name(f".{path.name}.tmp") tmp.write_bytes(data) os.replace(tmp, path) - - -# ── 옛 로직 줄 같이 쓰기 — 로직 JSON 을 쓰는 단 한 자리(둘째 박자에서 지움) ────────── -def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None: - """문서에 한 고침을 옛 로직 줄에도 — 머리(이름표 · 이름 · 결과단위 · 출처 · 부품 덮음) · - 더함(본뜬 로직 줄 셈 칸 / 빈 셈 칸) · 지움 · 기계 고르기 목록(`picks` = 더함 · 뺌). - 검사 없음(문서가 정본) · 스위치 `WRITE` 가 꺼지면 아무것도 안 함.""" - if not WRITE or (not edits and not picks): - return - with store._LOCK: - files = store.loaded()[0] - logic = {n: d for n, d in files.items() if d.get("그룹") == "로직"} - where = {str(r.get("키")): n for n, d in logic.items() for r in d.get("줄") or []} - after = {n: {**d, "줄": list(d.get("줄") or [])} for n, d in logic.items()} - touched: set[str] = set() - for op, key, what in edits: - if op == "더함": - name = what["file"] - if name not in after: # 자체 로직 파일이 없으면 머리만 두고 만듦 - after[name] = { - "그룹": "로직", - "원문": "자체", - "판": str(kst_today().year), - "줄": [], - } - src = next((r for r in logic.get(where.get(what["from"], ""), {}).get("줄") or [] - if str(r.get("키")) == what["from"]), None) # fmt: skip - calc = {k: copy.deepcopy(v) for k, v in (src or CALC).items() if k not in FIELDS} - after[name]["줄"].append(_ordered({**what["row"], **calc, "키": key})) - where[key] = name - elif (name := where.get(key)) is not None: - rows = after[name]["줄"] - at = _at(rows, key) - if at is None: - continue - if op == "지움": - del rows[at] - else: - rows[at] = _headed_row(rows[at], what) - else: - continue - touched.add(name) - if picks: - touched |= _picks(after, *picks) - for name in touched: - _write(name, logic.get(name), after[name]) - store.cache.stale(touched) - - -def _ordered(row: dict) -> dict: - """새 로직 줄 칸 차례 — `_틀.md` 2장(`mk.ROW_ORDER`) 다음 나머지.""" - order = mk.ROW_ORDER["로직"] - return { - **{k: row[k] for k in order if k in row}, - **{k: v for k, v in row.items() if k not in order}, - } - - -def _headed_row(row: dict, head_: dict) -> dict: - """로직 줄 머리를 문서 머리와 같게 — 있던 칸은 제자리 · 빠진 머리 칸은 뺌 · 새 칸은 끝(옛 [저장]과 같음).""" - out = { - k: head_[k] if k in FIELDS else v for k, v in row.items() if k not in FIELDS or k in head_ - } - return {**out, **{k: v for k, v in head_.items() if k not in out}} - - -def _picks(after: dict, add: dict, drop: set) -> set[str]: - """기계경비식 로직 줄 「기계」 고르기 목록에 더함 · 뺌(문서 `선택 목록` 과 같게 · 848-5).""" - touched = set() - for name, data in after.items(): - if "건설기계" not in name: - continue - for at, row in enumerate(data["줄"]): - pick = next( - (i for i in row.get("입력") or [] if i.get("이름") == "기계" and "고르기" in i), - None, - ) - if pick is None: - continue - codes = [c for c in pick["고르기"] if str(c) not in drop] - codes += [c for c in add.get(str(row["키"]), []) if c not in codes] - if codes != pick["고르기"]: - new = copy.deepcopy(row) - next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes - data["줄"][at] = new - touched.add(name) - return touched - - -def _write(name: str, before: dict | None, after: dict) -> None: - path = store.FOLDER / name - text = None - if before is not None and path.is_file(): - text = keep_shape(path.read_bytes().decode("utf-8"), before, after, "줄") - _put(path, (text or dump(after)).encode("utf-8")) diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py index e2f35209b..c9f868711 100644 --- a/M01_MasterData/M01_MasterData_Store_Make.py +++ b/M01_MasterData/M01_MasterData_Store_Make.py @@ -310,8 +310,7 @@ def _chapter_of(logic: dict) -> str: def logic_new(logic: dict, owner: str = OWNERS[0], source: str = "") -> dict: - """새 자체 기초 — 키 = 서버가 `GX` 다음 번호 · 문서 = 빈 문서 / `source` 문서 복제(본뜸) · - 옛 로직 줄은 같이 쓰기(`Store_Logic.mirror`).""" + """새 자체 기초 — 키 = 서버가 `GX` 다음 번호 · 문서 = 빈 문서 / `source` 문서 복제(본뜸).""" change = {"op": "add", "row": _clean(logic, owner), "from": source} part = {"file": OWN, "version": doc_store.file_version(OWN), "changes": [change]} got = logic_store.save([part], True) diff --git a/M01_MasterData/M01_MasterData_Store_Save.py b/M01_MasterData/M01_MasterData_Store_Save.py index f65c0f049..d71b84bca 100644 --- a/M01_MasterData/M01_MasterData_Store_Save.py +++ b/M01_MasterData/M01_MasterData_Store_Save.py @@ -76,9 +76,7 @@ def _errors(files, whole, names, book, narrowed, keys) -> list[str]: def save(batch: list[dict]) -> list[dict]: - """요소 · 표 파일 저장 — 단가산출 기초(로직 파일 몫)는 받지 않음(`Store_Logic` · 855 L3 ⓐ).""" - if bad := [p.get("file") for p in batch if _logic_file(p.get("file", ""))]: - raise store.StoreError(400, f"기초는 기초 저장 길로 — {', '.join(bad)}") + """요소 · 표 파일 저장 — 단가산출 기초는 `Store_Logic`(855 L3 ⓐ · `Store_Make.save` 가 가름).""" with store._LOCK: stale = [ p.get("file", "") for p in batch if store.version(p.get("file", "")) != p.get("version") @@ -134,10 +132,6 @@ def save(batch: list[dict]) -> list[dict]: return out -def _logic_file(name: str) -> bool: - return name.startswith("로직_") and name.endswith(".json") - - def _machine(name: str) -> bool: return name == mmf.NAME and mmf.here(store.FOLDER) # 기계 = 폴더(826-2) diff --git a/M01_MasterData/M01_MasterData_UI_LogicLab.ts b/M01_MasterData/M01_MasterData_UI_LogicLab.ts index 20adf436f..586a64249 100644 --- a/M01_MasterData/M01_MasterData_UI_LogicLab.ts +++ b/M01_MasterData/M01_MasterData_UI_LogicLab.ts @@ -415,10 +415,6 @@ export async function mountM01LogicLab( const row: LogicRow = { 키: "", ...info, - 입력: [], - 중간: [], - 호표: [], // 빈 시트 줄 — 자체 로직 편집기 · 시트로 채움 - 끝수: null, }; const id = logicId("자체", `새${Date.now()}`); drafts[id] = { sub: "자체", file: OWN_FILE, version: own?.version ?? "", origKey: null, row }; diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Api.ts b/M01_MasterData/M01_MasterData_UI_Logic_Api.ts index 1397b2e94..2cfe6162e 100644 --- a/M01_MasterData/M01_MasterData_UI_Logic_Api.ts +++ b/M01_MasterData/M01_MasterData_UI_Logic_Api.ts @@ -5,28 +5,7 @@ import { API_BASE_URL } from "@config/config_frontend"; -/** 로직 한 줄 — 파일 그대로(한글 칸) · 틀 `_틀.md` 6장 */ -export interface LogicInput { - 이름: string; - 단위?: string; - 고르기?: (string | number)[]; - 범위?: [number, number]; -} -export interface HoLine { - 종류: string; - 요소: string; - 이름?: string; - 규격?: string; - 단위?: string; - 수량: string; - 비목?: string; -} -export interface NamedFormula { - 이름: string; - 식: string; - 비목?: string; - 출처?: string; -} +/** 단가산출 기초 머리 — 키 · 이름표 · 이름 · 결과단위 · 출처(셈 = 수식 문서 · 855-E L3) */ export interface LogicRow { /** 서버가 주는 키 — 새 로직은 "" (저장 때 대장의 다음 번호) */ 키: string; @@ -37,12 +16,6 @@ export interface LogicRow { /** 원문 절 머리 개정 연도(빌더가 채움 · 읽기만 · 794-2b) */ 개정?: number[]; 소유?: string; - 입력: LogicInput[]; - 중간: NamedFormula[]; - 호표?: HoLine[]; - 결과?: { 식: string }; - 덧줄?: NamedFormula[]; - 끝수?: string | null; 비고?: string; /** 설계자가 찾는 다른 이름 — 쉼표로 여럿 · 없으면 칸 없음(208-1) */ 별칭?: string; diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index 8422ece55..24f7caa10 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -89,19 +89,13 @@ def _set_values(doc: dict, given: dict) -> None: def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]: """기초 문서(848-10) → (문서, 옵션 기본을 문서에서 읽음) — 프로젝트 층 밖 = 지금 M01 문서 · - 그 밖(굳힌 사본 · 프로젝트 층) = 굳힐 때 사본 `바탕문서` › 손고침 기초 = 빌더 문서 - (굳은 뒤 고침 안 받음) › 지금 문서 · 문서에서 안 읽음 = 옛 로직 줄 자동값 - (옛 사본 금액 그대로).""" + 그 밖(굳힌 사본 · 프로젝트 층) = 굳힐 때 사본 `바탕문서` › 지금 문서.""" live = dc.folder().get(key) if renew.on() and live is not None: return dc.doc_of(whole, key), True kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None if kept: # 프로젝트 층 = 굳힐 때 문서 + 옛 자동값(855 L2 ⓑ — 전과 같은 옵션 값) return cp.deepcopy(kept), renew.on() - if live is not None and live.get(mcv.HAND): - from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게 - - return m01.built(key), False return dc.doc_of(whole, key), False diff --git a/M02_MasterTemplete/M02_Doc_Sk_Path.py b/M02_MasterTemplete/M02_Doc_Sk_Path.py index fd00e77b1..41abe67bb 100644 --- a/M02_MasterTemplete/M02_Doc_Sk_Path.py +++ b/M02_MasterTemplete/M02_Doc_Sk_Path.py @@ -99,7 +99,7 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]: def layers(copy: dict, sk: dict) -> dict[str, Any]: - """848-8 바뀐 자리 바탕 — {위: 위 층 문서, 빌더?: 기초가 손고침이면 빌더 문서} · 모름 = 빈 묶음. + """848-8 바뀐 자리 바탕 — {위: 위 층 문서} · 모름 = 빈 묶음. 위 층 = 파생과 같은 기초 문서(`dsk.base_doc` · 덮음 · 손고침 표지 뺌 · 옵션 값 = 그 문서 기본 · 옛 길 = 옛 로직 줄 기본) · 가져온 식 = 불러올 때 문서(따로 = `처음` · 아니면 지금 파생) · 읽기만(파일 안 씀).""" @@ -115,11 +115,6 @@ def layers(copy: dict, sk: dict) -> dict[str, Any]: if top is None: return {} out = {"위": dsk._bare_doc(top)} - if live.get(mcv.HAND) and renew.on(): - from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게 - - if (built := m01.built(key)) is not None: - out["빌더"] = built out = json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str)) # 사본 if not real: # 옛 길 — `derive` 와 같은 옵션 값 auto = dc.given_of(skc.whole_(), key, {}) diff --git a/resources/tester/test_826_2_machine_files.py b/resources/tester/test_826_2_machine_files.py index 0e4d2a169..0f65a20c4 100644 --- a/resources/tester/test_826_2_machine_files.py +++ b/resources/tester/test_826_2_machine_files.py @@ -120,7 +120,7 @@ def _old_check(files: dict, changed: list[str], book: dict, narrowed) -> list[st out += cm.check_logics(files, whole, book, narrowed and narrowed[:2]) if narrowed and narrowed[2]: out += cm.check_links(whole) - return out + cm.mcb.check_all(files, whole) + cache.labor_errors(whole) + return out + cm.mcb.check_all(files, whole) + cache.labor_errors(set(cache.docs())) def _old(batch: list[dict]) -> list[str]: diff --git a/resources/tester/test_848_10_upper_down.py b/resources/tester/test_848_10_upper_down.py index 99686b011..1805351ae 100644 --- a/resources/tester/test_848_10_upper_down.py +++ b/resources/tester/test_848_10_upper_down.py @@ -6,8 +6,8 @@ ㉢ 있던 단가산출 — 안 고친 것 = 따라옴 · 다른 옵션을 고른 것 = 내 값 지킴 + 나머지 따라옴 · 같은 옵션을 고른 것 = 내 값 지킴 + 알림 → [확인] 뒤 알림 없음 · 줄을 고친 것 + 옵션 기본 바뀜 = 줄 고침 지킴 (다시 복사 아님) · 기초 줄 이름만 바뀜 = 안 고친 줄 이름 따라옴. -㉣ 프로젝트 사본 — 고치기 전 굳힌 것 = 그대로 · 고친 뒤 굳힌 것 = 그때 단가산출 금액(손고침 기초 사본). -㉤ 손고침 기초 = 빌더가 안 덮음(그 로직 파일 글 = 저장본) · SK 층바탕 = {위: 기초, 빌더} → 기초에서 바꾼 옵션 = 위(주황). +㉣ 프로젝트 사본 — 고치기 전 굳힌 것 = 그대로 · 고친 뒤 굳힌 것 = 그때 단가산출 금액 · + 파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 M01 문서를 따라감. ㉥ 기초가 그룹째 뺀 줄 되살림 = 제 그룹(제목)으로 · 처음 문서 차례. 정본 파일 안 고침 — 수식 문서 폴더 = 임시 사본 · 층 = 임시 storage. """ @@ -22,7 +22,6 @@ import shutil import pytest from M01_MasterData import M01_MasterData_Doc as m01doc -from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Doc_Sk_Path as path from M02_MasterTemplete import M02_Item_Prices as item_prices @@ -36,8 +35,6 @@ from resources.tester.test_m02_labor_ref import world # noqa: F401 ml = importlib.import_module("master_doc_link") mcv = importlib.import_module("master_doc_cover") -cv = importlib.import_module("master_doc_convert") -build = importlib.import_module("build_수식문서_802_2") CON = "GC000198" # 레디믹스트콘크리트 타설 — 선택 · 입력 옵션 · 인력 둘 · 굴착기 · 공구손료 CUT = "GC000088" # 터파기(기계) — 옵션 Type 이 굴착기를 고름 @@ -194,43 +191,13 @@ def test_프로젝트_사본(world, docs_tmp): now = float(_read(me, key)["셈"]["계"]) assert now != was assert before() == was # 고치기 전 굳힌 것 = 그대로 - p = _read(proj, key) # 프로젝트 층 = 그대로 - assert p["셈"]["계"] == in_proj["셈"]["계"] and _bare(p["문서"]) == _bare(in_proj["문서"]) + p = _read( + proj, key + ) # 파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 M01 문서를 따라감(855-E L4) + assert in_proj["셈"]["계"] == was and float(p["셈"]["계"]) == now assert _freeze(me, key)() == now # 고친 뒤 굳힘 = 그때 단가산출 금액 -def test_손고침_빌더_층바탕(world, docs_tmp): - _m01(CUT, _opt("Type", "TypeⅢ")) - saved = ml.load_all()[CUT] - assert saved.get(mcv.HAND) - files, whole = m01.loaded() - name = next( - n - for n, d in files.items() - if d.get("그룹") == "로직" and any(str(r.get("키")) == CUT for r in d.get("줄") or []) - ) - rows = files[name]["줄"] - keys = [str(r["키"]) for r in rows] - result = { - "문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows}, - "파일": {name: keys}, - "저장": set(keys) & build.saved_keys(), - "저장본": build.carried(), - } - file = ml.FOLDER / ml.file_of(name) - assert build.files_of(result)[ml.file_of(name)] == file.read_text(encoding="utf-8") - assert CUT in build.hand_kept(result) - me = world["personal"] - got = _read(me, _sk(me, CUT)) - assert _val(got["문서"], "Type") == "TypeⅢ" and set(got["층바탕"]) == {"위", "빌더"} - shown = _node( - {"문서": got["문서"], "위": got["층바탕"]["위"], "빌더": got["층바탕"]["빌더"], "고침": []} - )[0] - [(where, (kind, was, back))] = shown["표시"].items() # 기초에서 바꾼 옵션 = 위(주황) - assert (where, kind, was["연결"]["값"], back) == ("v:Type", "upper", "TypeⅠ", False) - assert shown["빠짐"] == {} and shown["줄틀"] == {} - - def test_그룹째_뺀_줄_되살림_제_그룹(): top = _j(ml.load_all()["GC000994"]) # 인력 · 크롤러드릴 · 공기압축기 · 크레인 그룹 up = cp.deepcopy(top) diff --git a/resources/tester/test_848_1_cover_layers.py b/resources/tester/test_848_1_cover_layers.py index e670bd317..cf140237d 100644 --- a/resources/tester/test_848_1_cover_layers.py +++ b/resources/tester/test_848_1_cover_layers.py @@ -1,9 +1,9 @@ # ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 -"""848-1 겹쳐 덮는 층(요구 889 · 요구서_889 1 절) — 층 셈 거울 · M01 기초 고침 저장 · SK 위 층 덮음 · 빌더 이어받기. +"""848-1 겹쳐 덮는 층(요구 889 · 요구서_889 1 절) — 층 셈 거울 · M01 기초 고침 저장 · SK 위 층 덮음. ① 거울 — 합침 · 층 합침 · 정리(위 층 대조) · 위 층 값 · 출처가 파이썬 = TS(손셈 기대값 몇 개 + 전수 대조). ㉠ M01 기초 고침(가격 · 조종원 · 작업량 시간당 + 변수) = 그 기초 셈만 바뀜 · 다른 기초 · 기계 정본 그대로 · - 문서 밖 기계 고침 뺌 · ㉥ 빌더 이어받기(덮음 얹음 · 손고침 문서 그대로 + 목록 · 같게 되돌리면 표지 없음) · + 문서 밖 기계 고침 뺌 · 줄 식 고침 = 받은 문서 그대로(손고침 표지 없음) · ㉣ 정본 값으로 되돌림 = 고침 0 · 문서 바이트 = 고침 전. ㉡ 그 기초로 만든 SK = 위덮음 · 금액 = 기초 금액 · SK 고침 = ② 에만 · 금액 = ① + ② 셈 · 출처 · ㉢ ② 를 위 층 값으로 = ② 0 · ㉤ 옵션으로 기계를 바꿔 저장해도 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐 · @@ -36,8 +36,6 @@ from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 mc = importlib.import_module("master_doc_calc") ml = importlib.import_module("master_doc_link") mcv = importlib.import_module("master_doc_cover") -cv = importlib.import_module("master_doc_convert") -build = importlib.import_module("build_수식문서_802_2") HERE = os.path.dirname(os.path.abspath(__file__)) COVER = mcv.COVER @@ -206,30 +204,10 @@ def _calls(key: str) -> bool: ) -def _mini(): - """빌더 한 로직 파일 몫(BASE 가 든 파일) — {결과, 쓸 글, 파일}.""" - files, whole = m01.loaded() - name = next( - n - for n, d in files.items() - if d.get("그룹") == "로직" and any(str(r.get("키")) == BASE for r in d.get("줄") or []) - ) - rows = files[name]["줄"] - keys = [str(r["키"]) for r in rows] - result = { - "문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows}, - "파일": {name: keys}, - "저장": set(keys) & build.saved_keys(), - "저장본": build.carried(), - } - return result, build.files_of(result)[ml.file_of(name)], ml.FOLDER / ml.file_of(name) - - -def test_M01_기초_고침_빌더_이어받기_되돌림(docs_tmp): +def test_M01_기초_고침_되돌림(docs_tmp): d = _defaults() - result, text, file = _mini() + file = ml.FOLDER / m01doc._where(BASE) orig = file.read_text(encoding="utf-8") # 글(줄 끝 맞춤) — CRLF 체크아웃도 같게 - assert text == file.read_text(encoding="utf-8") # 고침 없음 = 빌더 글 = 저장본 other = next(k for k in sorted(m01doc.docs()) if k != BASE and _calls(k)) before, other_before = m01doc.read(BASE)["셈"]["계"], m01doc.read(other)["셈"]["계"] price = m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"] @@ -243,27 +221,19 @@ def test_M01_기초_고침_빌더_이어받기_되돌림(docs_tmp): assert m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"] == price # 기계 정본 그대로 line = next(x for x in got["셈"]["줄"] if x.get("작업량")) assert line["작업량"]["꼴"] == "시간당" and str(line["작업량"]["변수"]["f"]) == "0.8" - # ㉥ 빌더 — 덮음 얹음(글 = 저장본) - result, text, _ = _mini() - assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == [] - - # ㉥ 손고침 — 줄 식을 고친 문서 = 저장본 그대로 + 목록 · 같게 되돌리면 표지 없음 - def qty(text_): - return lambda doc: doc["금액"][0].update({"수량": text_}) - - first = m01doc.read(BASE)["문서"]["금액"][0]["수량"] - _save_m01(want, qty("Q_굴착기^표 × 9 ÷ Q_시공")) - assert ml.load_all()[BASE].get(mcv.HAND) is True - result, text, _ = _mini() - assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == [BASE] - _save_m01(want, qty(first)) - assert mcv.HAND not in ml.load_all()[BASE] # ㉣ 정본 값으로 되돌림 = 고침 0 · 글 = 고침 전 back = {NO: {"값": {"가격": float(d["값"]["가격"])}, "조종원": d["조종원"]}, SYM: {"작업량": {"방식": "일당"}}} # fmt: skip got = _save_m01(back) assert COVER not in got["문서"] and file.read_text(encoding="utf-8") == orig assert got["셈"]["계"] == before + # 줄 식을 고친 문서 = 받은 문서 그대로 + 손고침 표지(한 번 붙으면 남음 · 855-E L4) + first = m01doc.read(BASE)["문서"]["금액"][0]["수량"] + got = _save_m01(None, lambda doc: doc["금액"][0].update({"수량": "Q_굴착기^표 × 9 ÷ Q_시공"})) + assert got["문서"]["금액"][0]["수량"] == "Q_굴착기^표 × 9 ÷ Q_시공" + assert ml.load_all()[BASE].get(mcv.HAND) is True + _save_m01(None, lambda doc: doc["금액"][0].update({"수량": first})) + assert ml.load_all()[BASE].get(mcv.HAND) is True def _sk(me) -> str: diff --git a/resources/tester/test_848_5_machine_impact.py b/resources/tester/test_848_5_machine_impact.py index b92e0aa2e..9ce80ea66 100644 --- a/resources/tester/test_848_5_machine_impact.py +++ b/resources/tester/test_848_5_machine_impact.py @@ -292,7 +292,7 @@ def _text(path: Path) -> bytes: return path.read_bytes().replace(b"\r\n", b"\n") # 체크아웃 줄끝(CRLF) = 문서 화면 저장(LF) -def test_new_machine_goes_to_both_lists(copy: Path): +def test_new_machine_goes_to_doc_list(copy: Path): client, docs_dir = _app(), copy / "수식문서" before = {p.name: _text(p) for p in docs_dir.glob("*.json")} row = { @@ -313,7 +313,6 @@ def test_new_machine_goes_to_both_lists(copy: Path): save([{"op": "add", "row": row}]) doc = ml.load_all(docs_dir)["GC000268"] assert "9999-0848" in next(v for v in doc["변수"] if v["이름"] == "기계")["연결"]["목록"] - assert _pairs(copy, ml.load_all(docs_dir))[1] == 0 key = next( r["키"] for r in m01.loaded()[1].index["EQ"].values() if r["원문번호"] == "9999-0848" ) diff --git a/resources/tester/test_854_2_m01_copy_doc.py b/resources/tester/test_854_2_m01_copy_doc.py index 8144f7e9d..e2f131862 100644 --- a/resources/tester/test_854_2_m01_copy_doc.py +++ b/resources/tester/test_854_2_m01_copy_doc.py @@ -1,12 +1,11 @@ """M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만. -- 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글. +- 만들면 문서 있음 · 금액 = 본뜬 기초 문서 금액. - 지우면(`/logic/remove` · `/save` 지움) 문서도 없음 · [복사/생성] = 원본 문서 복제 + 기본정보(855 L3 ⓐ). """ from __future__ import annotations -import importlib import shutil from decimal import Decimal from pathlib import Path @@ -56,15 +55,7 @@ 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 = whole.logic(key) # 옛 로직 줄(같이 쓰기 · `/logic` 답은 머리만 · 855 L3 ⓐ) - return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1])) - - -def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진과_같다(client: TestClient) -> None: +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 @@ -72,14 +63,7 @@ def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진 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 + assert _money(got["셈"]) == _money(source["셈"]) and _money(source["셈"])["계"] > 0 # 지우면 문서도 같이 info = _get(client, "/api/m01/logic", key=key) @@ -97,7 +81,8 @@ def test_기본정보를_고쳐_복사해도_문서가_있고_save_지움이면_ made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, **more}) # 855 L3 ⓐ [복사/생성] 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) + source = _money(_get(client, "/api/m01/logic/doc", key=SAMPLE)["셈"]) + assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == source head = _get(client, "/api/m01/logic", key=key)["logic"] assert {k: head[k] for k in more} == more and head["키"] == key diff --git a/resources/tester/test_855_l1_tags.py b/resources/tester/test_855_l1_tags.py index 24caad239..d61f91706 100644 --- a/resources/tester/test_855_l1_tags.py +++ b/resources/tester/test_855_l1_tags.py @@ -105,7 +105,7 @@ def test_화면_저장_길을_지나도_이름표가_같다(client: TestClient, _ok(client.post("/api/m01/alias/save", json={"키": SAMPLE, "별칭": ""})) assert "별칭" not in _doc(SAMPLE) - # 문서 저장 왕복 — 화면이 이름표 칸을 빼고 보내도 로직 줄 것으로 실림 + # 문서 저장 왕복 — 화면이 이름표 칸을 빼고 보내도 저장된 문서 것으로 실림 got = _ok(client.get("/api/m01/logic/doc", params={"key": SAMPLE})) sent = {k: v for k, v in got["문서"].items() if k not in md.TAGS} _ok(client.post("/api/m01/logic/doc/save", json={"문서": sent, "판": got["판"]})) @@ -122,12 +122,10 @@ def test_화면_저장_길을_지나도_이름표가_같다(client: TestClient, "changes": [{"op": "edit", "key": key, "row": fixed}]} # fmt: skip _ok(client.post("/api/m01/save", json={"files": [part]})) assert _doc(key)["비고"] == "sub5임시 자체 비고" - assert _gaps(tmp_path, tmp_path / "수식문서") == [] info = _ok(client.get("/api/m01/logic", params={"key": key})) body = {"key": key, "file": info["file"], "version": info["version"]} _ok(client.post("/api/m01/logic/remove", json=body)) assert key not in doc_store.docs() - assert _gaps(tmp_path, tmp_path / "수식문서") == [] def test_tag_는_셈_칸을_안_건드림() -> None: diff --git a/resources/tester/test_855_l3_doc_only.py b/resources/tester/test_855_l3_doc_only.py index 77d675ce2..33fedf3fe 100644 --- a/resources/tester/test_855_l3_doc_only.py +++ b/resources/tester/test_855_l3_doc_only.py @@ -1,9 +1,8 @@ -"""855 L3 ⓐ 지킴 — M01 단가산출 기초가 수식 문서만으로 돎(로직 JSON 은 같이 쓰기만). +"""855 L3 지킴 — M01 단가산출 기초가 수식 문서만으로 돎(로직 JSON 을 읽지도 쓰지도 않음). -마스터 사본 두 벌에서 같은 차례로 부름 — 켬(로직 파일 있음 · 같이 쓰기 켬) / 끔(로직 파일 없음 · -`Store_Logic.WRITE` 끔). 목록 · 상세 · 비고 [저장] · 개정 확인 409 · 판 409 · 별칭 · [신규] · -[복사/생성] · [삭제] · 기계 등록 답이 두 벌 같음. -다른 자리(둘째 박자에서 걷을 것) = `/logic/doc` 의 「층바탕」(빌더 문서 = 옛 로직 줄 변환)만 — 빼고 견줌. +마스터 사본 두 벌에서 같은 차례로 부름 — 옛 로직 파일 놓임 / 없음. 목록 · 상세 · 비고 [저장] · +개정 확인 409 · 판 409 · 별칭 · [신규] · [복사/생성] · [삭제] · 기계 등록 답이 두 벌 같음 · +놓인 로직 파일은 글자 하나 안 바뀜 · 없는 쪽엔 안 생김. """ from __future__ import annotations @@ -21,7 +20,6 @@ from M01_MasterData import M01_MasterData_Alias as alias from M01_MasterData import M01_MasterData_Doc as doc_store 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_Logic as logic_store sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts")) import master_doc_link as mdl # noqa: E402 @@ -42,7 +40,6 @@ def _world(tmp: Path, monkeypatch, logic: bool) -> TestClient: monkeypatch.setattr(store, "FOLDER", tmp) monkeypatch.setattr(doc_store.ml, "FOLDER", tmp / "수식문서") monkeypatch.setattr(mdl, "FOLDER", tmp / "수식문서") - monkeypatch.setattr(logic_store, "WRITE", logic) doc_store._memo.clear() store.cache.forget() # 앞 시험이 남긴 기억 없이 app = FastAPI() @@ -61,8 +58,6 @@ def _run(client: TestClient) -> list: def call(method: str, url: str, body=None, **params): res = client.request(method, url, json=body, params=params or None) got = res.json() - if isinstance(got, dict): - got.pop("층바탕", None) # 빌더 문서(옛 로직 줄 변환) — 둘째 박자에서 걷음 out.append((method, url, res.status_code, got)) return got @@ -127,11 +122,17 @@ def _run(client: TestClient) -> list: return out -def test_로직_파일_없이_같이_쓰기_끄고도_답이_같음(tmp_path: Path, monkeypatch) -> None: +def test_로직_파일을_안_읽고_안_씀(tmp_path: Path, monkeypatch) -> None: (tmp_path / "on").mkdir() (tmp_path / "off").mkdir() with monkeypatch.context() as m: - on = _run(_world(tmp_path / "on", m, logic=True)) + client = _world(tmp_path / "on", m, logic=True) + (tmp_path / "on" / "로직_건설품셈_99장_흉내.json").write_text( + '{"그룹": "로직", "원문": "건설품셈", "줄": [{"키": "GC999999", "이름": "흉내"}]}', + encoding="utf-8", + ) # 옛 로직 파일이 남아 있어도 안 읽음 + laid = {p.name: p.read_bytes() for p in (tmp_path / "on").glob("로직_*.json")} + on = _run(client) with monkeypatch.context() as m: off = _run(_world(tmp_path / "off", m, logic=False)) assert [c[2] for c in on] == [c[2] for c in off] @@ -147,4 +148,5 @@ def test_로직_파일_없이_같이_쓰기_끄고도_답이_같음(tmp_path: Pa json.dumps(a[3], ensure_ascii=False)[:300], json.dumps(b[3], ensure_ascii=False)[:300], ) - assert not list((tmp_path / "off").glob("로직_*.json")) # 끔 = 로직 파일을 만들지 않음 + assert not list((tmp_path / "off").glob("로직_*.json")) # 로직 파일을 만들지 않음 + assert {p.name: p.read_bytes() for p in (tmp_path / "on").glob("로직_*.json")} == laid diff --git a/resources/tester/test_m02_labor_doc.py b/resources/tester/test_m02_labor_doc.py index a599c1c6a..3d713a63e 100644 --- a/resources/tester/test_m02_labor_doc.py +++ b/resources/tester/test_m02_labor_doc.py @@ -254,10 +254,9 @@ def test_로직_지우기_검사는_모든_층_일위대가를_봄(tmp_path, mon monkeypatch.setattr(layers, "SYSTEM_ROOT", system) # 검사는 39-1d 한 벌(층 자리 = layers) monkeypatch.setattr(config_system, "STORAGE_BASE_DIR", str(storage)) - class Gone: # STONE 을 지운 마스터 - def logic(self, code): - if code == STONE: - raise cache.cm.mf.FormulaError("없음") + class Gone: # STONE 을 지운 기초(있는 기초 키 묶음) + def __contains__(self, code): + return code != STONE got = cache.labor_errors(Gone()) assert len(got) == 2 and all(STONE in x for x in got) diff --git a/resources/tester/test_m02_labor_ref.py b/resources/tester/test_m02_labor_ref.py index 8fb336b71..e0fa159c8 100644 --- a/resources/tester/test_m02_labor_ref.py +++ b/resources/tester/test_m02_labor_ref.py @@ -377,10 +377,9 @@ def test_로직_지우기_검사는_승격_줄도_보고_참조_줄은_건너뜀 line = {"참조": {**SYS, "키": sp}} store.write("labor", "rv", have["판"], {**have["문서"], "담은로직": [line]}) - class Gone: # STONE 을 지운 마스터 - def logic(self, code): - if code == STONE: - raise cache.cm.mf.FormulaError("없음") + class Gone: # STONE 을 지운 기초(있는 기초 키 묶음) + def __contains__(self, code): + return code != STONE assert cache.labor_errors(Gone()) == [] # 옛 승격 서고는 안 봄(134-2) · 참조 줄 건너뜀 with store.at(world["system"]): @@ -439,10 +438,9 @@ def test_사전조합_로직_줄_섞임_합은_손셈_지우기_409_굳힘(world assert one["반영"]["계"] == pytest.approx(float(want * 5), abs=20) # 751-3 끝수 × 5 assert [x.get("로직") or x["참조"]["키"] for x in one["안"]] == [sp, STONE, TEN] - class Gone: # STONE 을 지운 마스터 - def logic(self, code): - if code == STONE: - raise cache.cm.mf.FormulaError("없음") + class Gone: # STONE 을 지운 기초(있는 기초 키 묶음) + def __contains__(self, code): + return code != STONE got = cache.labor_errors(Gone()) assert f"사전조합 마스터 「{sc}」 이 로직 「{STONE}」 을 씀 — 거기서 먼저 뺌" in got