From 102c993247233f8fa7c12894b52a5b9f45accbe7 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 12:31:49 +0900 Subject: [PATCH] =?UTF-8?q?chore(853-2):=20=EA=B1=B8=EC=9D=8C=200=20?= =?UTF-8?q?=EB=AC=B6=EC=9D=8C=20=E2=91=A3=20=E2=80=94=20=ED=95=9C=20?= =?UTF-8?q?=EB=B2=88=20=EC=93=B0=EA=B3=A0=20=EB=81=9D=EB=82=9C=20=EB=8F=84?= =?UTF-8?q?=EA=B5=AC=20=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 파일: M02_Copy_Units · M02_Copy_Symbols · M02_Copy_Migrate · M02_Doc_Migrate · M02_Labor_Migrate · M02_Template_Migrate - 조각: Labor_SkRow 옮기기(convert · relink · money · run_here · _sandbox · migrate · to_xlsx · __main__ 등 · 289 → 61 줄) · Library_Flat migrate · __main__ · _value - 살아 있는 project_root(대시보드 요약)는 M02_Template_Layers 로 옮김 · B01_Dashboard_Summary 가져감 고침 · 지킴 시험 하나 더함 - 먼저 확인: 보기만 돌림 = Copy_Units · Copy_Symbols 채울것없음 6 · Copy_Migrate · Doc_Migrate 있음 6 · Labor_Migrate 옮김 0 · Labor_SkRow 0 줄 · Library_Flat 0 줄 — 다시 돌릴 일 없음 · 비시험에서 그 안 함수를 가져가는 곳 0 - 시험: 도구만 보던 795-3 · labor_migrate 파일 지움 · 함수째 지움(801-5 · 800-5 · 802-4b1 · 795-4 · 811-1 · 740-1 · template_layers) · 740-1 의 SC 값 셈 도우미는 시험 안으로 - 낡은 글자 시험: structures_summary_snapshot 의 robocopy 인자 글자 대조 지움(인자가 조건식으로 바뀌어 이미 실패 · 소스 글자 시험) - 검증: 빌더 --check 같음 · 핵심 시험 99 통과 · 관련 시험 631 + 20 통과 · 서버 로그 오류 0 Co-Authored-By: Claude Opus 5.5 --- B01_Dashboard/B01_Dashboard_Summary.py | 2 +- M02_MasterTemplete/M02_Copy_Migrate.py | 222 ----------------- M02_MasterTemplete/M02_Copy_Symbols.py | 115 --------- M02_MasterTemplete/M02_Copy_Units.py | 55 ----- M02_MasterTemplete/M02_Doc_Migrate.py | 232 ------------------ M02_MasterTemplete/M02_Labor_Migrate.py | 90 ------- M02_MasterTemplete/M02_Labor_SkRow.py | 230 +---------------- M02_MasterTemplete/M02_Library_Flat.py | 65 +---- M02_MasterTemplete/M02_Template_Layers.py | 17 +- M02_MasterTemplete/M02_Template_Migrate.py | 174 ------------- resources/tester/test_740_1_library_flat.py | 48 +--- resources/tester/test_795_3_migrate.py | 101 -------- resources/tester/test_795_4_b09_copy.py | 13 - resources/tester/test_800_5_copy_symbols.py | 98 +------- resources/tester/test_801_5_units.py | 20 -- resources/tester/test_802_4b1_import_doc.py | 13 - resources/tester/test_811_1_labor_ref.py | 86 +------ resources/tester/test_m02_labor_migrate.py | 119 --------- resources/tester/test_m02_template_layers.py | 94 +------ .../test_structures_summary_snapshot.py | 4 - 20 files changed, 38 insertions(+), 1760 deletions(-) delete mode 100644 M02_MasterTemplete/M02_Copy_Migrate.py delete mode 100644 M02_MasterTemplete/M02_Copy_Symbols.py delete mode 100644 M02_MasterTemplete/M02_Copy_Units.py delete mode 100644 M02_MasterTemplete/M02_Doc_Migrate.py delete mode 100644 M02_MasterTemplete/M02_Labor_Migrate.py delete mode 100644 M02_MasterTemplete/M02_Template_Migrate.py delete mode 100644 resources/tester/test_795_3_migrate.py delete mode 100644 resources/tester/test_m02_labor_migrate.py diff --git a/B01_Dashboard/B01_Dashboard_Summary.py b/B01_Dashboard/B01_Dashboard_Summary.py index 2306927f4..185229a01 100644 --- a/B01_Dashboard/B01_Dashboard_Summary.py +++ b/B01_Dashboard/B01_Dashboard_Summary.py @@ -16,7 +16,7 @@ import aiomysql from common_util.common_util_time import utc_now_naive, utc_text from config.config_db import get_db_pool -from M02_MasterTemplete.M02_Template_Migrate import project_root +from M02_MasterTemplete.M02_Template_Layers import project_root from .B01_Dashboard_Repository import get_workflow_states_for_projects diff --git a/M02_MasterTemplete/M02_Copy_Migrate.py b/M02_MasterTemplete/M02_Copy_Migrate.py deleted file mode 100644 index 9c220e72f..000000000 --- a/M02_MasterTemplete/M02_Copy_Migrate.py +++ /dev/null @@ -1,222 +0,0 @@ -"""옛 SK · SC · 일위대가 → 로직 사본 찍어 넣기 — 한 번 돌리는 도구(PLAN 795-3 · 요구 655 · 656). - -대상 = 사본 없는 마스터 · 회사 · 개인 층 문서(`sangeun` · `precombo` · `labor`) — 지금 M01 로 사본을 -찍고(`M02_Sangeun_Copy.stamp` · `M02_Labor_Copy.stamp`) 전후 금액 대조: - SK = `calc_doc` 기준(노 · 재 · 경 · 계) · SC · 일위대가 = `Labor_Doc.calc` 기준합 · 반영합. -같음 = 파일에 `사본` 칸만 더해 씀(그 밖 칸 그대로) · 다름 · 못 셈 = 안 씀(목록) · -닿을 것 없음(바탕 참조 SK · 참조 · 손 단가 줄만) = 그대로. -프로젝트 층 일위대가 = 세기 · 대조만(795-4 · 쓰지 않음) — 옛 SP 참조(프로젝트 층은 굳힌 - 사본만 읽음 · 마스터 SP 를 바로 가리키는 옛 꼴) = 「못셈(옛 SP 참조)」 갈래. -B09 사본(795-4 · 보기만) = 구조물 사본 · 서고 사본 — 만든 때 그대로 셈(옮길 것 없음 · - 상태 「그대로」) · - `재생성` = 지금 원본으로 다시 가져오면 금액(바뀌면 `재생성다름`) · 못 셈 = 까닭. -되돌릴 길 = 쓰기 전 파일 그대로 `--backup` 폴더에(층 자리 그대로) · `--restore` = 다시 덮음. - - ./venv/Scripts/python.exe -m M02_MasterTemplete.M02_Copy_Migrate # 보기만(표) - ./venv/Scripts/python.exe -m M02_MasterTemplete.M02_Copy_Migrate --apply --backup tmp/795_3 - ./venv/Scripts/python.exe -m M02_MasterTemplete.M02_Copy_Migrate --restore tmp/795_3 -""" - -from __future__ import annotations - -import json -import shutil -import sys -from collections import Counter -from pathlib import Path -from typing import Any - -from common_util.common_util_json import atomic_write_json -from M02_MasterTemplete import M02_Labor_Copy as lc -from M02_MasterTemplete import M02_Sangeun_Copy as skc -from M02_MasterTemplete import M02_Template_Layers as layers - -KINDS = ("sangeun", "precombo", "labor") - - -def _anchors() -> dict[str, Path]: - return {"system": layers.system_dir(), "storage": layers.storage_root()} - - -def _files() -> list[tuple[str, str, Path, bool]]: - """(어디, 종류, 파일, 프로젝트?) — 층 문서 + 프로젝트 층 일위대가.""" - out = [(w, k, p, False) for k in KINDS for w, p in layers.layer_files(k)] - root = layers.storage_root() - for p in sorted(root.glob("*/*/*/templates/labor/[!.]*.json")): - out.append((f"프로젝트 {p.parts[-4]}", "labor", p, True)) - return out - - -def _round(value: Any) -> Any: - if isinstance(value, dict): - return {k: _round(v) for k, v in value.items()} - return None if value is None else round(float(value), 6) - - -def _money(kind: str, doc: dict, whole: Any) -> Any: - """그 문서 금액 — `whole` = 셈 색인(지금 M01 | 사본 덮개).""" - from M02_MasterTemplete import M02_Labor_Doc as labor - from M02_MasterTemplete import M02_Sangeun_Calc as calc - - if kind == "sangeun": - return _round(calc.run(doc, whole, None, line=False).get("기준")) - got = labor.calc(doc, None if kind == "labor" else {}, whole=whole) - return _round({k: got.get(k) for k in ("기준합", "반영합")}) - - -def _clean(kind: str, doc: dict, key: str) -> dict: - from M02_MasterTemplete import M02_Labor_Doc as labor - from M02_MasterTemplete import M02_Sangeun_Doc as sd - - plain = {k: v for k, v in doc.items() if k not in (skc.KEY, skc.JOB)} - if kind == "sangeun": - return sd.clean(plain, None, skc.whole_()) - return labor.clean({**plain, "열": doc.get("열") or key}) - - -def check(kind: str, path: Path) -> dict[str, Any]: - """문서 하나 — {상태: 있음 | 필요없음 | 같음 | 다름 | 못셈, 전, 후, 사본?, 까닭?}.""" - from M02_MasterTemplete import M02_MasterTemplete_Store as store - - doc = json.loads(path.read_bytes()) - if skc.has(doc): - return {"상태": "있음"} - folder = path.parent.parent - try: - with store.at(folder): - clean = _clean(kind, doc, path.stem) - copy = skc.stamp(clean) if kind == "sangeun" else lc.stamp(clean) - if copy is None: - return {"상태": "필요없음"} - live = skc.whole_() - before = _money(kind, clean, live) - after = _money(kind, clean, skc.over({skc.KEY: copy}, live)) - except Exception as e: # noqa: BLE001 — 못 셈 = 목록(통째로 멈추지 않음) - return {"상태": "못셈", "까닭": str(e) or type(e).__name__} - row = {"상태": "같음" if before == after else "다름", "전": before, "후": after} - return {**row, "사본": copy} if before == after else {**row, "까닭": "전후 금액 다름 — 안 옮김"} - - -def _backup_path(path: Path, backup: Path) -> Path: - for name, anchor in _anchors().items(): - if path.resolve().is_relative_to(anchor.resolve()): - return backup / name / path.resolve().relative_to(anchor.resolve()) - raise ValueError(f"층 밖 파일 「{path}」") - - -OLD_SP = "위 층만 가리킴" # 프로젝트 층 문서가 마스터 SP 를 바로 가리킴(굳힌 사본 아님) -LOCAL = ("입력값.json", "고른자재.json", "면적.json") # 재생성 대조 때 사본 값 그대로 - - -def _b09_files() -> list[tuple[str, str, Path]]: - """(어디, 종류, 폴더) — 프로젝트 구조물 사본 · B09 서고 사본.""" - root = layers.storage_root() - out = [] - for kind, pattern in ( - ("구조물사본", "*/*/*/templates/structures/*/manifest.json"), - ("서고사본", "*/*/*/B09_Estimation/v1/library/*/manifest.json"), - ): - for p in sorted(root.glob(pattern)): - at = p.parents[3] if kind == "구조물사본" else p.parents[4] - out.append((f"B09 {at.name}", kind, p.parent)) - return out - - -def _copy_money(files: dict[str, Any]) -> Any: - from M02_MasterTemplete import M02_Item_Prices as prices - - labor = files.get("일위대가.json") - if not isinstance(labor, dict): - return None - got = prices.calc( - labor, - files.get("단가.json") or {}, - files.get("입력값.json") or {}, - files.get("고른자재.json") or {}, - files.get("면적.json"), - ) - return _round({k: got.get(k) for k in ("기준합", "반영합")}) - - -def b09_check(kind: str, folder: Path) -> dict[str, Any]: - """B09 사본 하나(보기만) — {상태: 그대로 | 필요없음 | 못셈, 전, 재생성?, 재생성다름?, 까닭?}.""" - from B09_Estimation import B09_Estimation_Bill_Library as lib - from M02_MasterTemplete.M02_Item_Source import build_source, read_json - - own = {p.name: read_json(p) for p in folder.glob("*.json")} - manifest = own.get("manifest.json") or {} - try: - before = _copy_money(own) - except Exception as e: # noqa: BLE001 — 못 셈 = 목록 - return {"상태": "못셈", "까닭": str(e) or type(e).__name__} - if before is None: - return {"상태": "필요없음"} - try: - if kind == "서고사본": - fresh, _ = lib._build(*lib._source_of(manifest)) - lib._apply(fresh, str(manifest.get("종류")), manifest.get("값") or {}) - else: - fresh = build_source(manifest["원본"]) - after = _copy_money({**fresh, **{n: own[n] for n in LOCAL if n in own}}) - except Exception as e: # noqa: BLE001 — 원본 없음 · 못 셈 = 재생성 대조만 빠짐 - return {"상태": "그대로", "전": before, "까닭": f"재생성 대조 못 함 — {e}"} - return {"상태": "그대로", "전": before, "재생성": after, "재생성다름": after != before} - - -def migrate(apply: bool = False, backup: Path | None = None) -> list[dict[str, Any]]: - """모든 층 — 문서마다 {어디, 종류, 키, 상태, 씀, …} · `apply` = 같음만 씀(프로젝트 층 빼고).""" - if apply and backup is None: - raise ValueError("--apply 는 --backup 폴더가 있어야 함") - out = [] - for where_, kind, path, project in _files(): - got = check(kind, path) - if project and got["상태"] == "못셈" and OLD_SP in got.get("까닭", ""): - got["상태"] = "못셈(옛 SP 참조)" - copy = got.pop("사본", None) - row = {"어디": where_, "종류": kind, "키": path.stem, **got, "씀": False} - if apply and copy and not project: - keep = _backup_path(path, backup) - keep.parent.mkdir(parents=True, exist_ok=True) - shutil.copy2(path, keep) - atomic_write_json(path, {**json.loads(path.read_bytes()), skc.KEY: copy}) - row["씀"] = True - out.append(row) - for where_, kind, folder in _b09_files(): # 795-4 B09 사본 = 보기만 - out.append({"어디": where_, "종류": kind, "키": folder.name, **b09_check(kind, folder)}) - out[-1]["씀"] = False - return out - - -def restore(backup: Path) -> list[str]: - """`--backup` 폴더 파일을 제자리로 다시 덮음 — 덮은 파일 목록.""" - done = [] - for name, anchor in _anchors().items(): - for keep in sorted((backup / name).rglob("*.json")): - target = anchor / keep.relative_to(backup / name) - shutil.copy2(keep, target) - done.append(str(target)) - return done - - -def table(rows: list[dict[str, Any]]) -> dict[str, dict[str, int]]: - """층 갈래 × 종류 × 상태 개수.""" - count: Counter = Counter() - for r in rows: - count[(r["어디"].split(" ")[0], r["종류"], r["상태"])] += 1 - out: dict[str, dict[str, int]] = {} - for (layer, kind, state), n in sorted(count.items()): - out.setdefault(f"{layer} {kind}", {})[state] = n - return out - - -if __name__ == "__main__": # 브레인 · 사용자 승인 뒤만 --apply - args = sys.argv[1:] - if "--restore" in args: - print("\n".join(restore(Path(args[args.index("--restore") + 1])))) - raise SystemExit - at = Path(args[args.index("--backup") + 1]) if "--backup" in args else None - rows = migrate("--apply" in args, at) - for one in rows: - if one["상태"] not in ("있음", "필요없음", "같음") or one.get("재생성다름"): - print(json.dumps(one, ensure_ascii=False, default=str)) - print(json.dumps(table(rows), ensure_ascii=False, indent=1)) diff --git a/M02_MasterTemplete/M02_Copy_Symbols.py b/M02_MasterTemplete/M02_Copy_Symbols.py deleted file mode 100644 index 3a1c6b46d..000000000 --- a/M02_MasterTemplete/M02_Copy_Symbols.py +++ /dev/null @@ -1,115 +0,0 @@ -"""옛 로직 사본 변수표 새로 쓰기 — 한 번 돌리는 도구(PLAN 800-5 · 요구 660-1 · 659-1). - -옛 사본(795-5 이전에 찍힌 것) 줄은 변수표(이름 · 기호 · 아래 · 위)가 비었거나 한글 그대로 → -수식 영역에 한글 기호가 보임. 지금 M01 줄의 변수표로 그 줄 변수만 채움: - · 사본 줄에 이미 정한 기호(영문 · 그리스 · 사용자가 고친 것)가 있는 칸 = 그대로 - · 기호가 비었거나 열쇠 그대로(한글)인 칸 = M01 칸(이름 · 기호 · 아래 · 위)으로 - · M01 에 그 줄 · 그 변수가 없으면 건드리지 않음(= 목록 「못닿음」) -금액 · 셈 = 변수표는 보이기만 → 전후 금액 대조(같을 때만 씀) · 사본 `판`은 줄 지문으로 다시 셈 -(M01 줄과 같아지면 `M01새판` 표지도 걷힘). -되돌릴 길 = 쓰기 전 파일 그대로 `--backup` 폴더에(`M02_Copy_Migrate --restore` 로 덮음). -프로젝트 층 문서는 건드리지 않음(굳힌 사본). - - ./venv/Scripts/python.exe -m M02_MasterTemplete.M02_Copy_Symbols # 보기만 - ./venv/Scripts/python.exe -m M02_MasterTemplete.M02_Copy_Symbols --apply --backup tmp/800_5 -""" - -from __future__ import annotations - -import json -import shutil -import sys -from pathlib import Path -from typing import Any - -from common_util.common_util_json import atomic_write_json -from M02_MasterTemplete import M02_Copy_Migrate as mig -from M02_MasterTemplete import M02_Sangeun_Copy as skc - -FIELD = "변수표" # master_equation.FIELD 와 같은 칸 -LOOK = ("이름", "기호", "아래", "위") - - -def _open(entry: Any, name: str) -> bool: - """사본 칸이 채울 자리 — 없음 · 기호 없음 · 열쇠 그대로(한글 기본).""" - sign = str((entry or {}).get("기호") or "") - return not sign or sign == name - - -def fill(copy: dict, whole: Any) -> tuple[dict, int, int]: - """(새 사본, 채운 칸 수, 못 닿은 변수 수) — 줄 `변수표`만 고치고 `판` 다시 셈.""" - rows, done, lost = [], 0, 0 - for row in copy["로직"]: - key = str(row.get("키")) - live = whole.index.get(key[:2], {}).get(key) or {} - src = live.get(FIELD) if isinstance(live.get(FIELD), dict) else {} - mine = dict(row.get(FIELD) or {}) - for part in ("입력", "중간"): - for spec in row.get(part) or []: - name = str(spec.get("이름")) - new = (src or {}).get(name) - if not _open(mine.get(name), name): - continue - if not isinstance(new, dict) or not new.get("기호"): - lost += 1 - continue - mine[name] = {**(mine.get(name) or {}), **{k: new[k] for k in LOOK if k in new}} - done += 1 - rows.append({**row, FIELD: mine} if mine != (row.get(FIELD) or {}) else row) - return {**copy, "로직": rows, "판": skc._fp(rows)}, done, lost - - -def check(kind: str, path: Path, fill_fn=None) -> dict[str, Any]: - """문서 하나 — {상태: 있음 | 채울것없음 | 같음 | 다름 | 못셈, 채움, 못닿음, 사본?} · `fill_fn` = 다른 고침(801-5 단위 글).""" - from M02_MasterTemplete import M02_MasterTemplete_Store as store - - doc = json.loads(path.read_bytes()) - if not skc.has(doc): - return {"상태": "사본없음"} - try: - with store.at(path.parent.parent): - live = skc.whole_() - new, done, lost = (fill_fn or fill)(doc[skc.KEY], live) - if not done: - return {"상태": "채울것없음", "못닿음": lost} - clean = mig._clean(kind, doc, path.stem) - before = mig._money(kind, clean, skc.over({skc.KEY: doc[skc.KEY]}, live)) - after = mig._money(kind, clean, skc.over({skc.KEY: new}, live)) - except Exception as e: # noqa: BLE001 — 못 셈 = 목록(통째로 멈추지 않음) - return {"상태": "못셈", "까닭": str(e) or type(e).__name__} - row = {"상태": "같음" if before == after else "다름", "채움": done, "못닿음": lost} - return {**row, "사본": new} if before == after else {**row, "전": before, "후": after} - - -def run(apply: bool = False, backup: Path | None = None, fill_fn=None) -> list[dict[str, Any]]: - """마스터 · 회사 · 개인 층 문서마다 {어디, 종류, 키, 상태, 씀, …} · `apply` = 같음만 씀.""" - if apply and backup is None: - raise ValueError("--apply 는 --backup 폴더가 있어야 함") - out = [] - for where_, kind, path, project in mig._files(): - if project: - continue - got = check(kind, path, fill_fn) - copy = got.pop("사본", None) - row = {"어디": where_, "종류": kind, "키": path.stem, **got, "씀": False} - if apply and copy: - keep = mig._backup_path(path, backup) - keep.parent.mkdir(parents=True, exist_ok=True) - shutil.copy2(path, keep) - atomic_write_json(path, {**json.loads(path.read_bytes()), skc.KEY: copy}) - row["씀"] = True - out.append(row) - return out - - -if __name__ == "__main__": # 브레인 지시 뒤만 --apply - args = sys.argv[1:] - at = Path(args[args.index("--backup") + 1]) if "--backup" in args else None - rows = run("--apply" in args, at) - for one in rows: - if one["상태"] not in ("사본없음", "채울것없음", "같음"): - print(json.dumps(one, ensure_ascii=False, default=str)) - count: dict[str, int] = {} - for one in rows: - count[one["상태"]] = count.get(one["상태"], 0) + 1 - print(json.dumps(count, ensure_ascii=False), "채움", sum(r.get("채움", 0) for r in rows)) diff --git a/M02_MasterTemplete/M02_Copy_Units.py b/M02_MasterTemplete/M02_Copy_Units.py deleted file mode 100644 index 0710552b8..000000000 --- a/M02_MasterTemplete/M02_Copy_Units.py +++ /dev/null @@ -1,55 +0,0 @@ -"""옛 로직 사본 단위 글 새로 쓰기 — 한 번 돌리는 도구(PLAN 801-5 · 요구 663-2). - -M01 로직 단위 글을 건설품셈 원문 꼴(`master_unit_text`)로 바꾼 뒤, 사본 줄의 입력 · 중간 `단위` · `결과단위` 를 -같은 규칙으로 바꿈(`M02_Copy_Symbols` 와 같은 길 — 금액 전후 같을 때만 씀 · 쓰기 전 `--backup` 사본 · -사본 `판` 다시 셈 · 프로젝트 층 문서는 안 건드림). - - ./venv/Scripts/python.exe -m M02_MasterTemplete.M02_Copy_Units # 보기만 - ./venv/Scripts/python.exe -m M02_MasterTemplete.M02_Copy_Units --apply --backup tmp/801_5 -""" - -from __future__ import annotations - -import json -import sys -from pathlib import Path -from typing import Any - -from M02_MasterTemplete import M02_Copy_Symbols as cs -from M02_MasterTemplete import M02_Sangeun_Copy as skc - - -def fill(copy: dict, whole: Any) -> tuple[dict, int, int]: - """(새 사본, 바꾼 칸 수, 0) — 줄 단위 글만 고치고 `판` 다시 셈.""" - import master_unit_text as ut # M01 이 길을 둔 뒤 - - done, rows = 0, [] - for row in copy["로직"]: - new = {**row} - for part in ("입력", "중간"): - specs = [] - for spec in row.get(part) or []: - now = ut.canon(spec.get("단위")) - done += now != (spec.get("단위") or "") - specs.append({**spec, "단위": now} if now != (spec.get("단위") or "") else spec) - if row.get(part): - new[part] = specs - if row.get("결과단위"): - now = ut.canon(row["결과단위"]) - done += now != row["결과단위"] - new["결과단위"] = now - rows.append(new) - return {**copy, "로직": rows, "판": skc._fp(rows)}, done, 0 - - -if __name__ == "__main__": # 브레인 지시 뒤만 --apply - args = sys.argv[1:] - at = Path(args[args.index("--backup") + 1]) if "--backup" in args else None - rows = cs.run("--apply" in args, at, fill) - for one in rows: - if one["상태"] not in ("사본없음", "채울것없음", "같음"): - print(json.dumps(one, ensure_ascii=False, default=str)) - count: dict[str, int] = {} - for one in rows: - count[one["상태"]] = count.get(one["상태"], 0) + 1 - print(json.dumps(count, ensure_ascii=False), "바꿈", sum(r.get("채움", 0) for r in rows)) diff --git a/M02_MasterTemplete/M02_Doc_Migrate.py b/M02_MasterTemplete/M02_Doc_Migrate.py deleted file mode 100644 index bf44cf518..000000000 --- a/M02_MasterTemplete/M02_Doc_Migrate.py +++ /dev/null @@ -1,232 +0,0 @@ -"""옛 SK · SC · 일위대가 · B09 사본 → 수식 문서 사본 찍어 넣기 — 한 번 돌리는 도구(PLAN 802-4a 3). - -대상 = 마스터 · 회사 · 개인 층 문서(`sangeun` · `precombo` · `labor`) · B09 사본(구조물 · 서고). -층 문서 — 전 = 옛 셈 길(`M02_Doc_Sk.OLD` · 로직 사본 엔진) · 후 = 수식 사본 문서 셈: - SK = 기준(노 · 재 · 경 · 계) · SC · 일위대가 = `Labor_Doc.calc` 기준합 · 반영합(원 단위 · 반올림 6 자리). - 같음 = 파일에 `수식` 칸만 더해 씀(그 밖 칸 그대로) · 다름 · 못 셈 = 안 씀(목록 · 까닭) · - 가져온 식 SK(807-1) = 가져온 줄 문서(`M02_Doc_Import`) · 전 = 옛 엔진 · 후 = 문서 셈 · - 바탕 참조 SK · 로직 사본 없는 문서 = 필요없음 · 이미 있음 = 있음. -B09 사본 — `수식.json`(`M02_Doc_B09.build` · 만든 때 `단가.json` 줄 기준) 더함 · 견적 셈은 그대로 - (`prices.calc` 전후 같음) · 문서 대조 = 일위대가 로직 줄마다 옛 엔진(`run_line`) 대 문서 셈 - (M01 규칙 · 같은 사본 값) — 다르면 목록. -되돌릴 길 = 쓰기 전 파일 그대로 `--backup` 폴더(층 자리 그대로) · `--restore` = 다시 덮음 - (B09 = 더한 `수식.json` 을 지움). - - ./venv/Scripts/python.exe -m M02_MasterTemplete.M02_Doc_Migrate # 보기만(표 · 목록) - ./venv/Scripts/python.exe -m M02_MasterTemplete.M02_Doc_Migrate --apply --backup tmp/802_4a - ./venv/Scripts/python.exe -m M02_MasterTemplete.M02_Doc_Migrate --restore tmp/802_4a - --list 목록 파일(기본 `docs/raw/요구_1104/_목록_802-4a_M02대조.xlsx`) -""" - -from __future__ import annotations - -import json -import shutil -import sys -from collections import Counter -from pathlib import Path -from typing import Any - -from common_util.common_util_json import atomic_write_json -from M02_MasterTemplete import M02_Copy_Migrate as old -from M02_MasterTemplete import M02_Doc_B09 as doc_b09 -from M02_MasterTemplete import M02_Doc_Copy as dc -from M02_MasterTemplete import M02_Doc_Sk as dsk -from M02_MasterTemplete import M02_Sangeun_Copy as skc - -LIST = Path(__file__).resolve().parents[1] / "docs/raw/요구_1104/_목록_802-4a_M02대조.xlsx" -HEAD = ("어디", "종류", "키", "이름", "상태", "전", "후", "까닭") - - -def _money(kind: str, doc: dict) -> Any: - from M02_MasterTemplete import M02_Labor_Copy as lc - from M02_MasterTemplete import M02_Labor_Doc as labor - from M02_MasterTemplete import M02_Sangeun_Calc as calc - - if kind == "sangeun": - got = calc.calc_doc(doc, None, False) - return old._round(got.get("기준")), got.get("수식셈") - lc._LAST[0] = (None, None) - got = labor.calc(lc.settle(doc), None if kind == "labor" else {}) - return old._round({k: got.get(k) for k in ("기준합", "반영합")}), None - - -def _with_old(fn, *args): - token = dsk.OLD.set(True) - try: - return fn(*args) - finally: - dsk.OLD.reset(token) - - -def formula_of(kind: str, doc: dict) -> dict | None: - """그 문서에 찍을 수식 사본(저장 첫머리와 같은 길 · 저장 없음).""" - from M02_MasterTemplete import M02_Labor_Copy as lc - from M02_MasterTemplete import M02_Sangeun_Doc as sd - - if kind != "sangeun": - return lc.settle(doc).get(dc.KEY) - if not dsk.own(doc): - return None - clean, whole = None, None - settled = skc.settle(doc) - whole = skc.over(settled, skc.whole_()) - clean = sd.clean(settled, None, whole) - return dsk.settle(clean, whole, None, doc).get(dc.KEY) - - -def check(kind: str, path: Path) -> dict[str, Any]: - """층 문서 하나 — {상태: 있음 | 필요없음 | 같음 | 다름 | 못셈, 전, 후, 수식?, 까닭?}.""" - from M02_MasterTemplete import M02_MasterTemplete_Store as store - - doc = json.loads(path.read_bytes()) - head = {"이름": doc.get("이름") or ""} - if dc.has(doc): - return {**head, "상태": "있음"} - try: - with store.at(path.parent.parent): - copy = formula_of(kind, doc) - if copy is None: - return {**head, "상태": "필요없음", "까닭": "로직 사본 없음(바탕 참조 · 손 줄만)"} - before = _with_old(_money, kind, doc)[0] - after, mark = _money(kind, {**doc, dc.KEY: copy}) - except Exception as e: # noqa: BLE001 — 못 셈 = 목록(통째로 멈추지 않음) - return {**head, "상태": "못셈", "까닭": str(e) or type(e).__name__} - row = {**head, "전": before, "후": after} - if before == after: - return {**row, "상태": "같음", "수식": copy} - why = (mark or {}).get("까닭") or "전후 금액 다름 — 안 옮김" - if kind == "sangeun" and not (doc.get("바탕") or doc.get("더한줄") or doc.get("가져온")): - why = "빈 SK(바탕 · 줄 없음) — 옛 0 · 새 빈 문서 「—」(요구서_664 0 장 · 브레인 802-4a ③)" - return {**row, "상태": "다름(빈 문서)", "까닭": why, "수식": copy} - return {**row, "상태": "다름", "까닭": why} - - -def b09_check(folder: Path) -> dict[str, Any]: - """B09 사본 하나 — {상태: 있음 | 필요없음 | 같음 | 다름 | 못셈, 전, 후, 수식?, 까닭?}.""" - from M02_MasterTemplete import M02_Item_Prices as prices - from M02_MasterTemplete import M02_Labor_Doc as labor - from M02_MasterTemplete.M02_Item_Source import read_json - - if (folder / doc_b09.FILE).is_file(): - return {"상태": "있음"} - own = {p.name: read_json(p) for p in folder.glob("*.json")} - bundle = own.get("단가.json") - if not isinstance(bundle, dict) or not doc_b09.logic_keys(bundle): - return {"상태": "필요없음", "까닭": "로직 줄 없음"} - try: - before = old._copy_money(own) - made = doc_b09.build(bundle, own.get("일위대가.json")) - after = old._copy_money({**own, doc_b09.FILE: made}) - whole, copy = prices.load_prices(bundle), {"부름": made["문서"]} - lines = ((own.get("일위대가.json") or {}).get("줄") or {}).get("담은로직") or [] - bad = [] - for one in [x for x in lines if isinstance(x, dict) and x.get("로직")]: - code = str(one["로직"]) - was = labor.run_line( - whole, code, one.get("입력값"), one.get("켜쌓기율"), one.get("고름") - ) - if was.get("기준") is None or code not in made["문서"]: - continue - doc = dc.line_doc(made["문서"][code], one.get("켜쌓기율"), one.get("고름")) - got = dc.money(dc.run(doc, copy, dc.given_of(whole, code, one.get("입력값")), whole)) - if old._round(got) != old._round(was["기준"]): - bad.append(f"{code} 옛 {old._round(was['기준'])} · 문서 {old._round(got)}") - except Exception as e: # noqa: BLE001 - return {"상태": "못셈", "까닭": str(e) or type(e).__name__} - row = {"전": before, "후": after, "수식": made} - if before != after: - return {**row, "상태": "다름", "까닭": "견적 셈이 바뀜 — 안 옮김"} - if bad: - return {**row, "상태": "다름", "까닭": "문서 대조 다름 — " + " / ".join(bad[:5])} - return {**row, "상태": "같음", "까닭": f"문서 {len(made['문서'])} · 견적 셈 그대로"} - - -def migrate(apply: bool = False, backup: Path | None = None) -> list[dict[str, Any]]: - """모든 층 · B09 사본 — {어디, 종류, 키, 상태, 씀, …} · `apply` = 같음(빈 문서 포함)만 씀.""" - if apply and backup is None: - raise ValueError("--apply 는 --backup 폴더가 있어야 함") - out = [] - for where_, kind, path, project in old._files(): - if project: - continue # 프로젝트 층 일위대가 = B09 몫(옛 길 · 795-4) - got = check(kind, path) - copy = got.pop("수식", None) - row = {"어디": where_, "종류": kind, "키": path.stem, **got, "씀": False} - if apply and copy is not None: - keep = old._backup_path(path, backup) - keep.parent.mkdir(parents=True, exist_ok=True) - shutil.copy2(path, keep) - atomic_write_json(path, {**json.loads(path.read_bytes()), dc.KEY: copy}) - row["씀"] = True - out.append(row) - for where_, kind, folder in old._b09_files(): - got = b09_check(folder) - made = got.pop("수식", None) - row = {"어디": where_, "종류": kind, "키": folder.name, **got, "씀": False} - if apply and made is not None and got["상태"] == "같음": - note = old._backup_path(folder / doc_b09.FILE, backup).with_suffix(".added") - note.parent.mkdir(parents=True, exist_ok=True) - note.write_text("802-4a 이 더함 — --restore 가 지움", encoding="utf-8") - atomic_write_json(folder / doc_b09.FILE, made) - row["씀"] = True - out.append(row) - return out - - -def restore(backup: Path) -> list[str]: - """`--backup` 폴더 파일을 제자리로 · 더한 `수식.json` 지움 — 손댄 파일 목록.""" - done = old.restore(backup) - for name, anchor in old._anchors().items(): - for note in sorted((backup / name).rglob("*.added")): - target = (anchor / note.relative_to(backup / name)).with_suffix(".json") - target.unlink(missing_ok=True) - done.append(f"지움 {target}") - return done - - -def table(rows: list[dict[str, Any]]) -> dict[str, dict[str, int]]: - count: Counter = Counter((r["어디"].split(" ")[0], r["종류"], r["상태"]) for r in rows) - out: dict[str, dict[str, int]] = {} - for (layer, kind, state), n in sorted(count.items()): - out.setdefault(f"{layer} {kind}", {})[state] = n - return out - - -def write_list(rows: list[dict[str, Any]], path: Path = LIST) -> Path: - from openpyxl import Workbook - - book = Workbook() - sheet = book.active - sheet.title = "요약" - sheet.append(("층 · 종류", "상태", "개수")) - for group, states in table(rows).items(): - for state, n in states.items(): - sheet.append((group, state, n)) - rows_sheet = book.create_sheet("목록") - rows_sheet.append(HEAD) - for r in rows: - cells = [r.get(k) for k in HEAD] - plain = (str, int, float, type(None)) - rows_sheet.append( - [c if isinstance(c, plain) else json.dumps(c, ensure_ascii=False) for c in cells] - ) - path.parent.mkdir(parents=True, exist_ok=True) - book.save(path) - return path - - -if __name__ == "__main__": # 브레인 · 사용자 승인 뒤만 --apply - args = sys.argv[1:] - if "--restore" in args: - print("\n".join(restore(Path(args[args.index("--restore") + 1])))) - raise SystemExit - at = Path(args[args.index("--backup") + 1]) if "--backup" in args else None - rows = migrate("--apply" in args, at) - for one in rows: - if one["상태"] not in ("있음", "필요없음", "같음"): - print(json.dumps(one, ensure_ascii=False, default=str)) - print(json.dumps(table(rows), ensure_ascii=False, indent=1)) - if "--list" in args or "--apply" not in args: - to = Path(args[args.index("--list") + 1]) if "--list" in args else LIST - print("목록", write_list(rows, to)) diff --git a/M02_MasterTemplete/M02_Labor_Migrate.py b/M02_MasterTemplete/M02_Labor_Migrate.py deleted file mode 100644 index 8359bfd31..000000000 --- a/M02_MasterTemplete/M02_Labor_Migrate.py +++ /dev/null @@ -1,90 +0,0 @@ -"""옛 일위대가 조합 → 구조물 열마다 일위대가 문서 — 한 번 돌리는 도구(PLAN 39-1b · 설계_정함 1장). - -층마다 구조물 열마다 `labor/<열id>.json`: - - 열 `일위대가` 키가 있으면 그 조합의 담은로직 · 단위 복사(`본뜬.키` = 옛 키 · 입력값 {} · - 수량 null · 자재 []) — 여러 열이 쓰던 조합도 열마다 따로 복사 - - 키 없는 열 = 빈 일위대가 · 번호 SU 는 저장소가 줌(도번과 같은 뒷자리) - - 몇 번 돌려도 같음 — 이미 그 키를 본뜬 문서 · 사람이 채운 문서(담은로직 · 자재가 있음)는 그대로 -옛 조합 파일 · 집계표 열 `일위대가` 칸은 손대지 않음. - - ./venv/Scripts/python.exe M02_MasterTemplete/M02_Labor_Migrate.py # 시스템 층 - ./venv/Scripts/python.exe M02_MasterTemplete/M02_Labor_Migrate.py --storage # 회사 · 개인 층 - [--dry-run] -""" - -from __future__ import annotations - -import argparse -import json -import sys -from pathlib import Path -from typing import Any - -sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) - -from M02_MasterTemplete import M02_Labor_Doc as labor # noqa: E402 -from M02_MasterTemplete import M02_MasterTemplete_Store as store # noqa: E402 -from M02_MasterTemplete import M02_Template_Layers as layers # noqa: E402 - - -def _filled(doc: dict) -> bool: - return bool(doc.get("담은로직") or doc.get("자재")) - - -def migrate(folder: Path, dry: bool = False) -> dict[str, list[str]]: - """`folder` 층 하나 — `{만듦, 옮김, 그대로, 못함}`(열 id · 못함은 까닭 붙임).""" - out: dict[str, list[str]] = {"만듦": [], "옮김": [], "그대로": [], "못함": []} - with store.at(folder): - for col in store._structure_columns(): - cid, key = col["id"], str(col.get("일위대가") or "") - path = store._path("labor", cid) - have = json.loads(path.read_bytes()) if path.is_file() else None - done = have is not None and (have.get("본뜬") or {}).get("키") == key - if have is not None and (_filled(have) or not key or done): - out["그대로"].append(cid) - continue - if not key: - out["만듦"].append(cid) - if not dry: - store._ensure("labor", cid) - continue - try: - body = labor.from_combo(key) - except store.StoreError as e: - out["못함"].append(f"{cid} · {e.detail}") - continue - out["옮김"].append(f"{cid} ← {key}") - if dry: - continue - store._ensure("labor", cid) # 번호(SU · 같은 뒷자리) - got = store.read("labor", cid) - store.write("labor", cid, got["판"], {**got["문서"], **body}) - return out - - -def layer_folders(storage: bool) -> list[Path]: - """시스템 층 하나 · 또는 storage 회사 · 개인 층(구조물집계표가 있는 것 · 프로젝트 빼고).""" - if not storage: - return [layers.system_dir()] - root = layers.storage_root() - table = Path("table") / f"{store.STRUCTURE_TABLE}.json" - found = [ - *root.glob(f"*/{layers.TEMPLATES_DIRNAME}"), - *root.glob(f"*/*/{layers.TEMPLATES_DIRNAME}"), - ] - return sorted(p for p in found if (p / table).is_file()) - - -def main() -> None: - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--storage", action="store_true", help="회사 · 개인 층(storage)") - parser.add_argument("--dry-run", action="store_true") - args = parser.parse_args() - report: dict[str, Any] = {} - for folder in layer_folders(args.storage): - report[str(folder)] = migrate(folder, args.dry_run) - print(json.dumps(report, ensure_ascii=False, indent=2)) - - -if __name__ == "__main__": - main() diff --git a/M02_MasterTemplete/M02_Labor_SkRow.py b/M02_MasterTemplete/M02_Labor_SkRow.py index 0b91dea82..22d494ac6 100644 --- a/M02_MasterTemplete/M02_Labor_SkRow.py +++ b/M02_MasterTemplete/M02_Labor_SkRow.py @@ -8,27 +8,16 @@ M01 로직 줄(옛 저장본 · 740-1 로 펼쳐 담은 줄) → 그 층 SK 문 이름 = 별칭 › 로직 이름 · 단위 = 바탕 기준단위(앞 수 뗌 · 원/10㎡ → ㎡ = 일위대가 로직 줄 ÷ 배와 같은 값) · 자재표시 빈 재료 = 일위대가 기본(별도계상)을 적어 둠(SK 빈 칸 = 직접계산이라 금액이 바뀜) · 사본 · 수식 = 그 일위대가 것을 실어 보냄(같은 값 묶음 · M01 이 바뀌었어도 금액 그대로) -옮기기(`migrate` · 한 번) = 층(마스터 · 회사 · 개인) SC · 구조물 조합 일위대가의 로직 줄 → SK + 참조 한 행 · -같은 몸 · 같은 사본 = 한 층 안 SK 하나 공유 · 면적산출 칸 잇기(수량 빈 줄) = 옛 알약 키 → 참조 알약 키 · -전후 금액(원 단위 · 줄마다) 같을 때만 씀 · 다르면 공유 없이 한 번 더 · 그래도 다르면 안 옮기고 목록 · -프로젝트(B09 사본)는 손대지 않음 · 보기 = 임시 storage 사본에서 실제로 옮겨 봄(공유 storage 안 씀). - `python -m M02_MasterTemplete.M02_Labor_SkRow [--apply] [--backup <폴더>] [--xlsx <파일>]` +옛 로직 줄 → SK 참조 옮기기(한 번용 `migrate`)는 끝나 걷음(894) — 남은 것 = [+ 줄] M01 기초 SK 사본. """ from __future__ import annotations -import json -import shutil -from contextlib import contextmanager -from decimal import Decimal -from pathlib import Path from typing import Any from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store -from M02_MasterTemplete import M02_Template_Layers as layers -KINDS = ("precombo", "labor") CARRY = ("사본", "수식") # 일위대가 값 묶음 → 새 SK(같은 금액) @@ -70,220 +59,3 @@ def from_logic(code: Any, new: bool = False, use: str | None = None) -> dict[str key = ask.ask("sangeun", sk, new, use) or refs.create("sangeun", sk)["이름"] at = refs.here() return {"이름": key, "참조": {"층": at[0], "주인": at[1], "키": key}} - - -def ref_line(one: dict, ref: refs.Ref) -> dict[str, Any]: - """옛 로직 줄 → 참조 한 행(별칭 · 메모 · 수량 그대로).""" - return {"참조": ref, **{k: one.get(k) for k in ("별칭", "메모", "수량")}} - - -def _finger(sk: dict) -> str: - """한 층 안 공유 열쇠 — 몸 + 사본 판(값 묶음이 같아야 같은 금액).""" - copy = sk.get("사본") or {} - body = {k: v for k, v in sk.items() if k not in CARRY} - tag = (copy.get("판"), copy.get("단가판")) if isinstance(copy, dict) else None - return json.dumps([body, tag], ensure_ascii=False, sort_keys=True, default=str) - - -def convert( - doc: dict, made: dict[str, str] | None, whole: Any -) -> tuple[dict, dict[str, str], list]: - """지금 층(`store.at` 안) 문서의 로직 줄 → SK(만들거나 `made` 에서 공유) + 참조 한 행 · - 답 = (새 문서, {옛 알약 키: 새 알약 키}(수량 빈 줄), [만든 SK 키]).""" - from M01_MasterData import M01_MasterData_Store_Combo as combo_store - - lines = [x for x in doc.get("담은로직") or [] if isinstance(x, dict)] - pills = combo_store.combo_pills({"담은로직": lines})["물량"] - by_logic = {code: p["키"] for p in pills for code in p.get("로직") or []} - at, out, moved, new = refs.here(), [], {}, [] - for one in doc.get("담은로직") or []: - if not (isinstance(one, dict) and one.get("로직")): - out.append(one) - continue - sk = logic_doc(one, doc, whole) - key = (made or {}).get(_finger(sk)) - if key is None: - key = refs.create("sangeun", sk)["이름"] - new.append(key) - if made is not None: - made[_finger(sk)] = key - ref = {"층": at[0], "주인": at[1], "키": key} - out.append(ref_line(one, ref)) - if one.get("수량") is None and by_logic.get(one["로직"]): - moved.setdefault(by_logic[one["로직"]], []).append(refs.ref_id(ref)) - return {**doc, "담은로직": out}, moved, new - - -def relink(area: dict, moved: dict[str, list[str]]) -> dict: - """면적산출 칸 잇기 — 옛 로직 알약 키 칸을 새 참조 알약 키에도(같은 칸 · 옛 잇기는 뗌).""" - sheets = [] - for sheet in area.get("시트") or []: - links = [] - for link in sheet.get("연결") or []: - keys = moved.get(str(link.get("키"))) if isinstance(link, dict) else None - links += [{**link, "키": k} for k in keys] if keys else [link] - sheets.append({**sheet, "연결": links} if "연결" in sheet else sheet) - return {**area, "시트": sheets} - - -# ── 금액(전후 대조) ──────────────────────────────────────────────────── -def _won(v: Any) -> Any: - return None if v is None else int(Decimal(str(v))) - - -def _unit(line: dict) -> Any: - """줄 1 단위 값(기준 ÷ 배 · 0.01 원).""" - got = (line.get("기준") or {}).get("계") - times = Decimal(str(line.get("배") or 1)) - return None if got is None else str((Decimal(str(got)) / times).quantize(Decimal("0.01"))) - - -def money(kind: str, key: str, doc: dict) -> dict[str, Any]: - """지금 층 문서 금액 — 조합 = 줄마다 반영 · 합(면적산출 칸 값) · SC = 1 단위(안 줄 저장 수량 · - 빈 수량 = 1).""" - from M02_MasterTemplete import M02_Labor_Doc as labor - from M02_MasterTemplete.M02_Labor_Expand import Expand, inner_pills - - if kind == "labor": # 기준합 = 줄마다 단위가 달라(로직 줄 결과단위 · 참조 줄 1 단위) 안 견줌 - got = labor.calc(doc) - rows = [[_won((x.get("반영") or {}).get("계")), _unit(x)] for x in got.get("줄") or []] - return {"줄": rows, "합": _won((got.get("반영합") or {}).get("계"))} - at = refs.here() - ref = {"층": at[0], "주인": at[1], "키": key} - given = {p["키"]: 1 for p in inner_pills(ref)} - out = {} - for name, use in (("저장", {}), ("하나", given)): - base = Expand(_whole(), refs.read_ref, use)(ref).get("기준") or {} - out[name] = _won(base.get("계")) - return out - - -def _path(kind: str, key: str) -> Path: - return store.root() / kind / f"{key}.json" - - -def _write(path: Path, doc: dict) -> None: - path.write_text(json.dumps(doc, ensure_ascii=False, indent=2), encoding="utf-8") - - -def _one(kind: str, path: Path, made: dict[str, str] | None, whole: Any) -> dict[str, Any]: - """문서 하나 옮김(지금 층에 씀) — 전후 금액 · 다르면 되돌림(만든 SK 지움 · 파일 · 면적 원래대로).""" - raw = path.read_bytes() - doc = json.loads(raw) - key = path.stem - before = money(kind, key, doc) - area_path = _path("area", str(doc.get("열") or key)) if kind == "labor" else None - area_raw = area_path.read_bytes() if area_path and area_path.is_file() else None - got, moved, new = convert(doc, made, whole) - path.write_text(json.dumps(got, ensure_ascii=False, indent=2), encoding="utf-8") - if area_raw is not None and moved: - _write(area_path, relink(json.loads(area_raw), moved)) - after = money(kind, key, got) - same = before == after - if not same: # 되돌림 — 이번에 만든 SK 지움(공유 기억도) - path.write_bytes(raw) - if area_raw is not None: - area_path.write_bytes(area_raw) - for sk in new: - _path("sangeun", sk).unlink(missing_ok=True) - if made is not None: - for f in [f for f, k in made.items() if k in new]: - made.pop(f) - sks = {r["키"] for r in refs.refs_in(got) if str(r.get("키"))[:2] == "SK"} if same else set() - return { - "줄": sum(1 for x in doc.get("담은로직") or [] if isinstance(x, dict) and x.get("로직")), - "SK": sorted(sks), - "새SK": new if same else [], - "알약": sum(len(v) for v in moved.values()) if area_path else 0, - "전": before, - "후": after, - "같음": same, - } - - -def run_here(whole: Any = None) -> list[dict[str, Any]]: - """지금 설정 storage 의 층 문서 전부 옮김(쓰기) — 줄마다 결과.""" - whole, out = whole or _whole(), [] - shared: dict[tuple, dict[str, str]] = {} - for kind in KINDS: - for where, path in layers.layer_files(kind): - try: - doc = json.loads(path.read_bytes()) - except (OSError, ValueError): - continue - if not any(isinstance(x, dict) and x.get("로직") for x in doc.get("담은로직") or []): - continue - folder = path.parent.parent - made = shared.setdefault(refs.where(folder), {}) - with store.at(folder): - row = _one(kind, path, made, whole) - if not row["같음"]: # 공유 없이 한 번 더 - row = {**_one(kind, path, None, whole), "공유없음": True} - out.append({"어디": where, "종류": kind, "키": path.stem, **row}) - return out - - -@contextmanager -def _sandbox(root: Path): - """층 폴더(마스터 · 회사 · 개인 templates)만 임시 storage 로 복사 → 설정을 그리로.""" - from config import config_system - - old = (config_system.STORAGE_BASE_DIR, layers.SYSTEM_ROOT, store.FOLDER) - src = layers.storage_root() - shutil.copytree(layers.system_dir(), root / "system") - for tpl in [*src.glob("*/templates"), *src.glob("*/*/templates")]: - shutil.copytree(tpl, root / "storage" / tpl.relative_to(src)) - config_system.STORAGE_BASE_DIR = str(root / "storage") - layers.SYSTEM_ROOT = store.FOLDER = root / "system" - try: - yield - finally: - config_system.STORAGE_BASE_DIR, layers.SYSTEM_ROOT, store.FOLDER = old - - -def migrate(apply: bool = False, backup: Path | None = None, work: Path | None = None) -> list: - """보기(`apply` False) = 임시 storage 에서 옮겨 봄 · 씀 = `backup` 에 층 폴더 사본을 떠 둔 뒤 실제 층.""" - if not apply: - import tempfile - - with tempfile.TemporaryDirectory(dir=work) as tmp, _sandbox(Path(tmp)): - return run_here() - if backup is None: - raise SystemExit("--apply 는 --backup <폴더> 와 함께") - src = layers.storage_root() - shutil.copytree(layers.system_dir(), backup / "system") - for tpl in [*src.glob("*/templates"), *src.glob("*/*/templates")]: - shutil.copytree(tpl, backup / "storage" / tpl.relative_to(src)) - return run_here() - - -def to_xlsx(rows: list[dict], path: Path) -> None: - from openpyxl import Workbook - - wb = Workbook() - ws = wb.active - ws.title = "옮기기" - ws.append(["어디", "종류", "키", "로직 줄", "참조 SK", "새 SK", "알약 잇기", "전", "후", "같음", "공유없음"]) # fmt: skip - for r in rows: - ws.append( - [r["어디"], r["종류"], r["키"], r["줄"], " ".join(r["SK"]), len(r["새SK"]), r["알약"]] - + [json.dumps(r[k], ensure_ascii=False) for k in ("전", "후")] - + ["같음" if r["같음"] else "다름", "예" if r.get("공유없음") else ""] - ) - path.parent.mkdir(parents=True, exist_ok=True) - wb.save(path) - - -if __name__ == "__main__": # 브레인 — 보기 먼저 · `--apply --backup <폴더>` 는 승인 뒤 - import sys - - argv = sys.argv[1:] - opt = {a: argv[i + 1] for i, a in enumerate(argv[:-1]) if a in ("--backup", "--xlsx")} - got = migrate("--apply" in argv, Path(opt["--backup"]) if "--backup" in opt else None) - for one in got: - print(json.dumps(one, ensure_ascii=False, default=str)) - lines, same = sum(r["줄"] for r in got), sum(r["줄"] for r in got if r["같음"]) - sks = len({(r["어디"], k) for r in got for k in r["새SK"]}) - print(f"문서 {len(got)} · 로직 줄 {lines} · 옮김 {same} · 새 SK {sks} · 다름 {sum(not r['같음'] for r in got)}") # fmt: skip - if "--xlsx" in opt: - to_xlsx(got, Path(opt["--xlsx"])) diff --git a/M02_MasterTemplete/M02_Library_Flat.py b/M02_MasterTemplete/M02_Library_Flat.py index 64ab90384..bc632bb9a 100644 --- a/M02_MasterTemplete/M02_Library_Flat.py +++ b/M02_MasterTemplete/M02_Library_Flat.py @@ -22,8 +22,7 @@ 초기화(`reset`) = 덮개 · 뺀줄 · 더한줄 단가 걷음(안쪽 넣은 몸 · 사본 블록까지) · 이음 기계 고정 줄 단가 = M01 기계 한 시간 값 다시 받음(736-3) · 항목 · 수량 · 입력값 · 고름 · 자재표시 · 켜쌓기율 · 기본정보 남김 → 값 = 연결된 M01 키 값. -옮기기(`migrate`) = 층 문서 펼쳐 다시 씀 — 전후 1 단위 금액 같을 때만(안 줄 수량 모두 1 로 대조) · -공유 storage 는 브레인이 돌림. +한 번용 옮기기(`migrate`)는 끝나 걷음(894). """ from __future__ import annotations @@ -621,65 +620,3 @@ def reset_doc(kind: str, key: str | None, doc: Any, look: bool, version: str | N version = store.read(kind, name)["판"] store.write(kind, name, version, got) return {"걷힘": n, "문서": store.read(kind, name)["문서"]} - - -# ── 옮기기 ──────────────────────────────────────────────────────────── -def _value(ref: refs.Ref, read: Read, whole: Any) -> Any: - from M02_MasterTemplete.M02_Labor_Expand import Expand, inner_pills - - given = {p["키"]: 1 for p in inner_pills(ref, read)} - got = Expand(whole, read, given)(ref).get("기준") - return None if got is None else {k: round(float(v), 6) for k, v in got.items()} - - -def migrate(apply: bool = False) -> list[dict[str, Any]]: - """저장소 층(마스터 · 회사 · 개인) SK · SC 의 M02 참조 줄을 펼쳐 다시 씀 — 줄마다 결과 - {어디, 키, 펼침, 같음, 씀, 까닭} · `apply` False = 보기만.""" - from M02_MasterTemplete import M02_MasterTemplete_Store as store - from M02_MasterTemplete import M02_Template_Layers as layers - - whole, out = _whole(), [] - for kind in ("sangeun", "precombo"): - for where_, path in layers.layer_files(kind): - try: - doc = json.loads(path.read_bytes()) - except (OSError, ValueError): - continue - if not refs.refs_in(doc): - continue - layer, owner = refs.where(path.parent.parent) - ref = {"층": layer, "주인": owner, "키": path.stem} - got = flat_doc(kind, doc) - left = [ - r.get("키") - for r in refs.refs_in(got) - if refs.kind_of(r.get("키")) != "promote" and not refs.is_copy(r) - ] - row = { - "어디": where_, - "키": path.stem, - "펼침": left == [], - "남은참조": left, - "씀": False, - } - - def mine(r: refs.Ref, _got: dict = got, _rid: str = refs.ref_id(ref)) -> dict | None: - return _got if refs.ref_id(r) == _rid else refs.read_ref(r) - - row["전"], row["후"] = _value(ref, refs.read_ref, whole), _value(ref, mine, whole) - row["같음"] = row["전"] == row["후"] - if not row["같음"]: - row["까닭"] = "전후 금액 다름 — 안 옮김" - elif apply and got != doc: - with store.at(path.parent.parent): - store.write(kind, path.stem, store.read(kind, path.stem)["판"], got) - row["씀"] = True - out.append(row) - return out - - -if __name__ == "__main__": # 브레인 — `python -m M02_MasterTemplete.M02_Library_Flat [--apply]` - import sys - - for one in migrate("--apply" in sys.argv): - print(json.dumps(one, ensure_ascii=False, default=str)) diff --git a/M02_MasterTemplete/M02_Template_Layers.py b/M02_MasterTemplete/M02_Template_Layers.py index 9e077af37..31f69c704 100644 --- a/M02_MasterTemplete/M02_Template_Layers.py +++ b/M02_MasterTemplete/M02_Template_Layers.py @@ -17,8 +17,9 @@ from __future__ import annotations import hashlib import json +import os import shutil -from pathlib import Path +from pathlib import Path, PurePosixPath from typing import Any from common_util.common_util_json import atomic_write_json @@ -75,6 +76,20 @@ def system_dir() -> Path: return Path(SYSTEM_ROOT) +def project_root(storage_path: str | None) -> Path | None: + """DB 저장 경로 → 실경로 · 없거나 수상하면 None(폴더를 만들지 않음) — 대시보드 요약이 씀.""" + if not storage_path: + return None + parts = PurePosixPath(storage_path.replace("\\", "/")).parts + if not parts or parts[0] != "storage" or ".." in parts or len(parts) < 2: + return None + root = Path(os.path.realpath(config_system.STORAGE_BASE_DIR)) + path = Path(os.path.realpath(root.joinpath(*parts[1:]))) + if root not in path.parents or not path.is_dir(): + return None + return path + + def company_dir(company_id: int | str) -> Path: root = storage_root() return _inside(root, root / _id(company_id, "회사") / TEMPLATES_DIRNAME) diff --git a/M02_MasterTemplete/M02_Template_Migrate.py b/M02_MasterTemplete/M02_Template_Migrate.py deleted file mode 100644 index e5cf4591f..000000000 --- a/M02_MasterTemplete/M02_Template_Migrate.py +++ /dev/null @@ -1,174 +0,0 @@ -"""이미 만든 프로젝트에 시스템 양식 넣기 — 한 번 돌리는 도구 (PLAN 10-5). - -프로젝트마다 `seed_project(only_missing=True)` — 작업본 · `_initial/` 에 **없는 것만 더함**. -이미 있는 양식 · 다른 파일은 안 건드림 · 폴더가 없는 프로젝트는 건너뜀(만들지 않음). -다시 돌려도 됨 — 시스템 양식이 늘었으면 그 몫만 더해짐. -`--refresh-tables` — 옛 표 틀(계산 열에 바인딩)만 새 판으로 · 손 값은 지킴. - - ./venv/Scripts/python.exe M02_MasterTemplete/M02_Template_Migrate.py \\ - [--dry-run] [--refresh-tables] [--report 파일] -""" - -from __future__ import annotations - -import argparse -import asyncio -import copy -import os -import sys -from pathlib import Path, PurePosixPath -from typing import Any - -from common_util.common_util_time import kst_now - -sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) - -from config import config_system # noqa: E402 -from config.config_db import close_db_pool, get_db_pool, init_db_pool # noqa: E402 -from M02_MasterTemplete import M02_Table_Fill as fill # noqa: E402 -from M02_MasterTemplete import M02_Template_Layers as layers # noqa: E402 - - -async def _projects() -> list[dict[str, Any]]: - pool = get_db_pool() - async with pool.acquire() as connection, connection.cursor() as cursor: - await cursor.execute( - """SELECT p.id, p.name, p.company_id, p.user_id, p.storage_path, u.name - FROM projects p LEFT JOIN users u ON u.id = p.user_id - WHERE p.deleted_at IS NULL ORDER BY p.company_id, p.created_at""" - ) - rows = await cursor.fetchall() - keys = ("id", "name", "company_id", "user_id", "storage_path", "owner") - return [dict(zip(keys, row, strict=True)) for row in rows] - - -def project_root(storage_path: str | None) -> Path | None: - """DB 저장 경로 → 실경로 · 없거나 수상하면 None(폴더를 만들지 않음).""" - if not storage_path: - return None - parts = PurePosixPath(storage_path.replace("\\", "/")).parts - if not parts or parts[0] != "storage" or ".." in parts or len(parts) < 2: - return None - root = Path(os.path.realpath(config_system.STORAGE_BASE_DIR)) - path = Path(os.path.realpath(root.joinpath(*parts[1:]))) - if root not in path.parents or not path.is_dir(): - return None - return path - - -def _stale_frame(document: Any) -> bool: - """옛 표 틀 — 계산 열에 바인딩(설계값 딱지)이 붙은 판.""" - return isinstance(document, dict) and any( - isinstance(column, dict) - and column.get("바인딩") - and (column.get("식") or column["바인딩"].get("값") == "식") - for column in document.get("열") or [] - ) - - -def refresh_tables(root: Path, *, dry_run: bool = False) -> list[str]: - """옛 표 틀을 시스템 새 판으로 — 작업본 · `_initial/` 둘 다 · 줄(손 값) · 변수 · 보기는 지킴. - - 손댄 것이 없으면 시스템 파일을 그대로 복사(판이 시스템과 같음). - """ - done: list[str] = [] - for row in layers.list_templates(layers.system_dir()): - if row["종류"] != "table": - continue - system = layers.read_template(layers.system_dir(), "table", row["이름"]) - for folder in (layers.project_dir(root), layers.initial_dir(root)): - got = layers.read_template(folder, "table", row["이름"]) - if not system or not got or not _stale_frame(got["문서"]): - continue - done.append(f"{folder.name}/table/{row['이름']}") - if dry_run: - continue - old = fill.strip_design(got["문서"]) - doc = copy.deepcopy(system["문서"]) - doc["변수"] = {**(doc.get("변수") or {}), **(old.get("변수") or {})} - doc.update({key: old[key] for key in ("줄", "보기") if key in old}) - if doc == system["문서"]: - layers.copy_templates( - layers.system_dir(), - folder, - source_layer="system", - kind="table", - name=row["이름"], - ) - else: - layers.write_template(folder, "table", row["이름"], doc) - layers.note_source(folder, "table", row["이름"], "system", system["판"]) - return done - - -def migrate( - projects: list[dict[str, Any]], *, dry_run: bool = False, refresh: bool = False -) -> list[dict[str, Any]]: - """프로젝트마다 넣은 것 `[{…프로젝트, 작업본, 초기, 표갱신, 상태}]`.""" - system = {f"{row['종류']}/{row['이름']}" for row in layers.list_templates(layers.system_dir())} - report = [] - for project in projects: - root = project_root(project.get("storage_path")) - entry = {**project, "작업본": [], "초기": [], "표갱신": [], "상태": ""} - if root is not None and refresh: - entry["표갱신"] = refresh_tables(root, dry_run=dry_run) - if root is None: - entry["상태"] = "폴더 없음 — 건너뜀" - elif dry_run: - have = { - f"{row['종류']}/{row['이름']}" - for row in layers.list_templates(layers.project_dir(root)) - } - entry["작업본"] = sorted(system - have) - entry["상태"] = "넣을 것(시험)" - else: - done = layers.seed_project(root, only_missing=True) - entry.update(작업본=done["작업본"], 초기=done["초기"]) - entry["상태"] = "넣음" if done["작업본"] or done["초기"] else "이미 있음" - report.append(entry) - return report - - -def render(report: list[dict[str, Any]], system: list[dict[str, Any]]) -> str: - names = " · ".join(f"{row['종류']}/{row['이름']}" for row in system) or "없음" - lines = [ - "# 기존 프로젝트 양식 넣기", - "", - f"- 돌린 때: {kst_now().isoformat(timespec='seconds')}", - f"- 시스템 양식: {names}", - "- 방법: 작업본 · `_initial/` 에 없는 것만 더함 · 있는 양식 · 다른 파일은 그대로", - f"- 프로젝트 {len(report)}개 · 넣음 {sum(r['상태'] == '넣음' for r in report)}개", - "", - "| 회사 | 만든 사람 | 프로젝트 | ID | 넣은 양식 | 표 틀 새 판 | 상태 |", - "| --- | --- | --- | --- | --- | --- | --- |", - ] - for row in report: - added = " · ".join(row["작업본"]) or "—" - lines.append( - f"| {row['company_id']} | {row.get('owner') or row['user_id']} | {row['name']} " - f"| `{row['id']}` | {added} | {' · '.join(row['표갱신']) or '—'} | {row['상태']} |" - ) - return "\n".join(lines) + "\n" - - -async def main() -> None: - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--dry-run", action="store_true") - parser.add_argument("--refresh-tables", action="store_true") - parser.add_argument("--report", type=Path) - args = parser.parse_args() - await init_db_pool() - try: - projects = await _projects() - finally: - await close_db_pool() - report = migrate(projects, dry_run=args.dry_run, refresh=args.refresh_tables) - text = render(report, layers.list_templates(layers.system_dir())) - if args.report: - args.report.write_text(text, encoding="utf-8") - sys.stdout.reconfigure(encoding="utf-8") - print(text) - - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/resources/tester/test_740_1_library_flat.py b/resources/tester/test_740_1_library_flat.py index 5d570a8ec..425b23cd6 100644 --- a/resources/tester/test_740_1_library_flat.py +++ b/resources/tester/test_740_1_library_flat.py @@ -75,10 +75,14 @@ def _sk_total(folder, doc): def _sc_value(folder, key, read=None): + """SC 1 단위 값 — 안 줄 수량 모두 1(옛 `flat._value` 와 같은 셈).""" + from M02_MasterTemplete.M02_Labor_Expand import Expand, inner_pills + + ref, read = {**MINE, "키": key}, read or refs.read_ref with store.at(folder): - got = flat._value({**MINE, "키": key}, read or refs.read_ref, _whole()) + got = Expand(_whole(), read, {p["키"]: 1 for p in inner_pills(ref, read)})(ref).get("기준") assert got is not None - return got["계"] + return round(float(got["계"]), 6) def _y(folder): @@ -297,46 +301,6 @@ def test_길_넣기_초기화_권한(world): assert firm.status_code == 403 # 일반 사용자 회사 층 쓰기 막힘 -def test_옮기기_함수_전후_같음_사본_블록(world): - me = world["personal"] - y = _y(me) - inner = _make(me, "precombo", 이름="안", 담은로직=[{"로직": GF}]) - sk = _raw( - me, - "sangeun", - 이름="옛 SK", - 단위="㎥", - 바탕={"로직": GF}, - 더한줄=[{"참조": {**MINE, "키": y}, "수량": 1}], - ) - sc = _raw( - me, - "precombo", - 이름="옛 SC", - 담은로직=[{"참조": {**MINE, "키": y}}, {"참조": {**MINE, "키": inner}}], - ) - dup = _raw( - me, "precombo", 이름="겹침", 담은로직=[{"로직": GF}, {"참조": {**MINE, "키": inner}}] - ) - before = {k: _sc_value(me, k) for k in (sc, dup)} | { - sk: _sk_total(me, _read(me, "sangeun", sk)) - } - look = {r["키"]: r for r in flat.migrate(False)} - assert all(look[k]["같음"] and not look[k]["씀"] for k in (sk, sc, dup)) - assert look[sc]["남은참조"] == [y] # 811-1 SC 안 SK 줄 = 참조 한 행 그대로 - rows = {r["키"]: r for r in flat.migrate(True)} - assert all(rows[k]["씀"] for k in (sk, sc, dup)) - assert not refs.refs_in(json.loads((me / "sangeun" / f"{sk}.json").read_bytes())) - for key, keep in ((sc, [("personal", y)]), (dup, [])): # 하위 호표 = 사본 블록 - left = refs.refs_in(json.loads((me / "precombo" / f"{key}.json").read_bytes())) - assert [(r["층"], r["키"]) for r in left] == [*keep, ("사본", inner)] - assert _sk_total(me, _read(me, "sangeun", sk)) == pytest.approx(before[sk], rel=1e-9) - assert _sc_value(me, sc) == pytest.approx(before[sc], rel=1e-9) - assert _sc_value(me, dup) == pytest.approx(before[dup], rel=1e-9) - again = flat.migrate(True) # 두 번째 = 바꿀 것 없음 - assert all(not r["씀"] for r in again) - - def test_733_지문_옛_참조_펼친_것_같음(world): me = world["personal"] y = _y(me) diff --git a/resources/tester/test_795_3_migrate.py b/resources/tester/test_795_3_migrate.py deleted file mode 100644 index f6b10c0f7..000000000 --- a/resources/tester/test_795_3_migrate.py +++ /dev/null @@ -1,101 +0,0 @@ -# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 -"""795-3 옛 SK · SC · 일위대가 → 로직 사본 옮기기 — 임시 storage 에서만. - -① 보기만 = 안 씀 · 전후 같음 ② 쓰기 = 사본 칸만 더함 · 다른 칸 그대로 · 금액 같음 · 백업 · 되돌림 -③ 전후 다르면 안 씀(목록) ④ 프로젝트 층 일위대가 = 세기 · 대조만. -""" - -from __future__ import annotations - -import copy -import json - -from M02_MasterTemplete import M02_Copy_Migrate as mig -from M02_MasterTemplete import M02_Labor_Copy as lc -from M02_MasterTemplete import M02_Labor_Ref as refs -from M02_MasterTemplete import M02_MasterTemplete_Store as store -from M02_MasterTemplete import M02_Sangeun_Copy as skc -from M02_MasterTemplete import M02_Template_Layers as layers -from resources.tester.test_795_1_sk_copy import _fake, _live -from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 - -PCT, LB = "GC001109", "LB000036" -LINE = {"로직": PCT, "수량": {"손": 1}} - - -def _old(path): - """사본 칸 뗀 옛 문서로 되씀 → 옛 내용.""" - raw = {k: v for k, v in json.loads(path.read_bytes()).items() if k != skc.KEY} - path.write_text(json.dumps(raw, ensure_ascii=False), encoding="utf-8") - return raw - - -def _make(me): - with store.at(me): - sk = refs.create( - "sangeun", {"이름": "sub2임시", "단위": "㎡", "바탕": {"로직": PCT}, "더한줄": []} - )["이름"] - sc = refs.create("precombo", {"이름": "sub2임시", "단위": "㎡", "담은로직": [LINE]})["이름"] - store.write("labor", "sub2임시", "", {"열": "sub2임시", "담은로직": [LINE], "자재": []}) - paths = [me / "sangeun" / f"{sk}.json", me / "precombo" / f"{sc}.json"] - paths.append(me / "labor" / "sub2임시.json") - return {p: _old(p) for p in paths} - - -def _mine(rows, olds): - keys = {p.stem for p in olds} - return {r["키"]: r for r in rows if r["어디"].startswith("개인") and r["키"] in keys} - - -def test_dry_then_apply_then_restore(world, tmp_path): - """① · ② 보기만 → 쓰기(사본만 더함 · 금액 같음) → 되돌림 = 처음 파일.""" - olds = _make(world["personal"]) - rows = _mine(mig.migrate(), olds) - assert {r["상태"] for r in rows.values()} == {"같음"} and len(rows) == 3 - assert not any(r["씀"] for r in rows.values()) - assert all(json.loads(p.read_bytes()) == raw for p, raw in olds.items()) - back = tmp_path / "back" - rows = _mine(mig.migrate(True, back), olds) - assert all(r["씀"] for r in rows.values()) - for path, raw in olds.items(): - now = json.loads(path.read_bytes()) - assert skc.has(now) and {k: v for k, v in now.items() if k != skc.KEY} == raw - again = _mine(mig.migrate(), olds) # 다시 돌림 = 이미 있음 - assert {r["상태"] for r in again.values()} == {"있음"} - assert {r["전"]["계"] for r in rows.values() if r["종류"] == "sangeun"} == { - r["후"]["계"] for r in rows.values() if r["종류"] == "sangeun" - } - mig.restore(back) - assert all(json.loads(p.read_bytes()) == raw for p, raw in olds.items()) - - -def test_different_amount_not_written(world, monkeypatch, tmp_path): - """③ 찍은 사본 금액이 지금과 다르면(노임 다른 판) 안 씀 · 까닭.""" - olds = _make(world["personal"]) - real = lc.stamp - - def stale(doc): # 노임 두 배 판으로 찍힌 사본 흉내 - with monkeypatch.context() as m: - row = copy.deepcopy(_live().get(LB)) - row["값"] = row["값"] * 2 - _fake(m, [row]) - return real(doc) - - monkeypatch.setattr(lc, "stamp", stale) - rows = _mine(mig.migrate(True, tmp_path / "back"), olds) - bad = [r for r in rows.values() if r["종류"] != "sangeun"] - assert {r["상태"] for r in bad} == {"다름"} and not any(r["씀"] for r in bad) - assert all(not skc.has(json.loads(p.read_bytes())) for p in olds if p.parent.name != "sangeun") - - -def test_project_labor_count_only(world, tmp_path): - """④ 프로젝트 층 일위대가 = 대조만 · 안 씀.""" - folder = layers.storage_root() / "7" / "42" / "p1" / "templates" / "labor" - folder.mkdir(parents=True) - path = folder / "x.json" - raw = {"열": "x", "담은로직": [LINE], "자재": []} - path.write_text(json.dumps(raw, ensure_ascii=False), encoding="utf-8") - rows = [r for r in mig.migrate(True, tmp_path / "back") if r["어디"].startswith("프로젝트")] - assert [(r["키"], r["상태"], r["씀"]) for r in rows] == [("x", "같음", False)] - assert json.loads(path.read_bytes()) == raw - assert mig.table(rows) == {"프로젝트 labor": {"같음": 1}} diff --git a/resources/tester/test_795_4_b09_copy.py b/resources/tester/test_795_4_b09_copy.py index 320b4c76c..c800ffc25 100644 --- a/resources/tester/test_795_4_b09_copy.py +++ b/resources/tester/test_795_4_b09_copy.py @@ -181,16 +181,3 @@ def test_price_preview_shape(): assert got["할일"] == "단가갱신" and (got["전"], got["후"], got["고친칸"]) == (10, 20, 3) assert [(r["키"], r["전"]) for r in got["바뀐자원"]] == [(LB, 1), (WOOD, {"물가자료": 1})] assert got["바뀐자원"][1]["후"] == new["rows"][WOOD]["prices"] - - -def test_migrate_view_b09_copy(tmp_path): - """옮기기 도구 B09 대조(보기만) — 구조물 사본 = 「그대로」 · 전 금액 · 파일 안 바꿈.""" - from M02_MasterTemplete import M02_Copy_Migrate as mig - - root = _project(tmp_path / "proj", [(10.0, "SS000052")]) - _snap(root, "pipe@10.0", "SS000052", [{"로직": "GF000219", "수량": {"손": 1}}], {}) - folder = linked.structures_dir(root) / "pipe@10.0" - before = {p.name: p.read_bytes() for p in folder.iterdir()} - got = mig.b09_check("구조물사본", folder) - assert got["상태"] == "그대로" and got["전"]["기준합"]["계"] > 0 - assert {p.name: p.read_bytes() for p in folder.iterdir()} == before diff --git a/resources/tester/test_800_5_copy_symbols.py b/resources/tester/test_800_5_copy_symbols.py index 49bf5d468..9f48f0f89 100644 --- a/resources/tester/test_800_5_copy_symbols.py +++ b/resources/tester/test_800_5_copy_symbols.py @@ -1,43 +1,15 @@ -# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 -"""800-5 기호 남은 한글 — 임시 storage 에서만. +"""800-5 기호 남은 한글. -① 호표 줄 금액 참조(`줄.`) 기호 = 수식 영역 · 정의 영역 같은 글(한글 0) ② 새 사본 = 이미 새 기호 -③ 옛 사본 변수표 새로 씀 = 사용자 고침 칸 그대로 · 금액 같음 · 백업 되돌림 ④ M01 전수 한글 기호(하위 로직 칩 제외) 0. +① 호표 줄 금액 참조(`줄.`) 기호 = 수식 영역 · 정의 영역 같은 글(한글 0) ④ M01 전수 한글 기호(하위 로직 칩 제외) 0. +옛 사본 변수표 새로 쓰기 도구(②③ · `M02_Copy_Symbols`)는 한 번 쓰고 끝나 894 에서 걷음. """ from __future__ import annotations -import copy import importlib -import json import re -from M02_MasterTemplete import M02_Copy_Migrate as mig -from M02_MasterTemplete import M02_Copy_Symbols as sym -from M02_MasterTemplete import M02_Sangeun_Copy as skc from M01_MasterData import M01_MasterData_Store as m01 -from M02_MasterTemplete import M02_Labor_Ref as refs -from M02_MasterTemplete import M02_MasterTemplete_Store as store -from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 - -LINE = {"로직": "GC000211", "수량": {"손": 1}} # 변수 많은 합판거푸집 - - -def _make(me): - with store.at(me): - sk = refs.create( - "sangeun", - {"이름": "sub2임시", "단위": "㎡", "바탕": {"로직": "GC000211"}, "더한줄": []}, - )["이름"] - path = me / "sangeun" / f"{sk}.json" - raw = {k: v for k, v in json.loads(path.read_bytes()).items() if k != skc.KEY} - path.write_text(json.dumps(raw, ensure_ascii=False), encoding="utf-8") - return {path: raw} - - -def _mine(rows, olds): - keys = {p.stem for p in olds} - return {r["키"]: r for r in rows if r["어디"].startswith("개인") and r["키"] in keys} meq = importlib.import_module("master_equation") @@ -74,67 +46,3 @@ def test_M01_전수_정의_한글_기호는_하위_로직_칩뿐(): for code in keys[::25]: for d in meq.export(whole, str(code))["정의"]: assert d["갈래"] == "블록" or not HAN.search(d["기호"]), (code, d["이름"]) - - -def _old(path): - """사본 변수표를 걷어 옛 사본 흉내 → (옛 문서, 걷은 줄 수).""" - doc = json.loads(path.read_bytes()) - cut = 0 - for r in doc[skc.KEY]["로직"]: - cut += r.pop(sym.FIELD, None) is not None - doc[skc.KEY]["판"] = skc._fp(doc[skc.KEY]["로직"]) - path.write_text(json.dumps(doc, ensure_ascii=False), encoding="utf-8") - return doc, cut - - -def test_새_사본은_이미_새_기호_옛_사본은_새로_씀(world, tmp_path): - olds = _make(world["personal"]) - back = tmp_path / "stamp" - mig.migrate(True, back) # 새 사본 찍음 - paths = list(olds) - for p in paths: - rows = json.loads(p.read_bytes())[skc.KEY]["로직"] - assert any(r.get(sym.FIELD) for r in rows) # ② 새 사본 = 변수표 있음 - assert {r["상태"] for r in _mine(sym.run(), olds).values()} == {"채울것없음"} - stripped = {p: _old(p) for p in paths} - assert all(cut for _, cut in stripped.values()) - # 사용자 고침 칸 하나 — 영문 기호 Z 는 그대로 - sk = next(p for p in paths if p.parent.name == "sangeun") - doc = json.loads(sk.read_bytes()) - row = next(r for r in doc[skc.KEY]["로직"] if r.get("입력")) - name = str(row["입력"][0]["이름"]) - row[sym.FIELD] = {name: {"기호": "Z", "아래": "내것"}} - sk.write_text(json.dumps(doc, ensure_ascii=False), encoding="utf-8") - before = {p: p.read_bytes() for p in paths} - rows = _mine(sym.run(), olds) # 보기만 = 안 씀 - assert {r["상태"] for r in rows.values()} == {"같음"} and not any( - r["씀"] for r in rows.values() - ) - assert all(p.read_bytes() == b for p, b in before.items()) - back = tmp_path / "back" - rows = _mine(sym.run(True, back), olds) - assert all(r["씀"] and r["채움"] > 0 and r["못닿음"] == 0 for r in rows.values()) - for p in paths: - for r in json.loads(p.read_bytes())[skc.KEY]["로직"]: - for part in ("입력", "중간"): - for spec in r.get(part) or []: - look = (r.get(sym.FIELD) or {})[str(spec["이름"])] - assert look.get("기호") - if not (r is row and spec["이름"] == name): - assert not HAN.search(look["기호"]), (r["키"], spec["이름"]) - now = next(r for r in json.loads(sk.read_bytes())[skc.KEY]["로직"] if r["키"] == row["키"]) - assert now[sym.FIELD][name] == {"기호": "Z", "아래": "내것"} - assert {r["상태"] for r in _mine(sym.run(), olds).values()} == {"채울것없음"} # 다시 돌림 - mig.restore(back) - assert all(p.read_bytes() == before[p] for p in paths) - - -def test_채운_줄은_M01_줄_변수표_그대로(): - live = m01.loaded()[1] - row = copy.deepcopy(live.logic("GC000211")) - src = row[sym.FIELD] - stripped = {k: v for k, v in row.items() if k != sym.FIELD} - got, done, lost = sym.fill({"로직": [json.loads(json.dumps(stripped, default=str))]}, live) - names = {str(s["이름"]) for k in ("입력", "중간") for s in row[k]} - assert done == len(names & set(src)) and lost == len(names - set(src)) - assert all(got["로직"][0][sym.FIELD][n]["기호"] == src[n]["기호"] for n in names & set(src)) diff --git a/resources/tester/test_801_5_units.py b/resources/tester/test_801_5_units.py index 50cc98587..d62fac7d8 100644 --- a/resources/tester/test_801_5_units.py +++ b/resources/tester/test_801_5_units.py @@ -114,25 +114,5 @@ def test_금액_같음_옛_글로_되돌려도_셈_지문_같음(): assert build.fingerprint(now, now.logic(key)) == build.fingerprint(was, was.logic(key)), key -def test_M02_사본_도구(): - cu = importlib.import_module("M02_MasterTemplete.M02_Copy_Units") - old = { - "로직": [ - { - "키": "GC000001", - "결과단위": "㎥/시간", - "입력": [{"이름": "a", "단위": "mm"}], - "중간": [{"이름": "Cm", "단위": "초"}], - } - ], - "판": "x", - } - new, done, _ = cu.fill(old, None) - row = new["로직"][0] - assert done == 3 and row["결과단위"] == "㎥/hr" and row["입력"][0]["단위"] == "㎜" - assert row["중간"][0]["단위"] == "sec" and new["판"] != "x" - assert cu.fill(new, None)[1] == 0 # 두 번째 = 바꿀 것 없음 - - if __name__ == "__main__": pytest.main([__file__, "-q"]) diff --git a/resources/tester/test_802_4b1_import_doc.py b/resources/tester/test_802_4b1_import_doc.py index 6794b5d33..4bd3bb069 100644 --- a/resources/tester/test_802_4b1_import_doc.py +++ b/resources/tester/test_802_4b1_import_doc.py @@ -23,7 +23,6 @@ import pytest from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Doc_Import as dim -from M02_MasterTemplete import M02_Doc_Migrate as mig from M02_MasterTemplete import M02_Doc_Sk as dsk from M02_MasterTemplete import M02_Doc_Sk_Path as path from M02_MasterTemplete import M02_Hopyo_Store as hs @@ -247,18 +246,6 @@ def sd_id(sk: dict) -> str: return imp.sd.line_ids(imp.row_of(sk))[0] -def test_migrate_imported_same(world) -> None: - folder = world["personal"] - doc = _doc([_item("인력", "보통인부", 100000, "노무비", "LB000002", "0.5")]) - with store.at(folder): - key = imp.create(doc[imp.KEY]["로직"], {"엑셀금액": {"계": 50000}}, "sub2임시 옮김")["이름"] - file = folder / "sangeun" / f"{key}.json" - got = mig.check("sangeun", file) - assert got["상태"] in ("같음", "있음") - if got["상태"] == "같음": - assert got["수식"]["문서"]["키"] == key and got["전"] == got["후"] - - # ── TS 짝(importView) 거울 ───────────────────────────────────────────── _NODE = """ const fs = require("fs"), path = require("path"); diff --git a/resources/tester/test_811_1_labor_ref.py b/resources/tester/test_811_1_labor_ref.py index 1f93ca48e..f8814df5c 100644 --- a/resources/tester/test_811_1_labor_ref.py +++ b/resources/tester/test_811_1_labor_ref.py @@ -4,20 +4,17 @@ - 저장 · 읽기 = 안 펼침(SK 참조 그대로) · 셈 = SK 1 단위 × 수량 · 모달 저장 = 그 SK 문서 → 일위대가 금액 따라감 - [+ 줄] M01 기초 = 그 층 SK 사본(`from-logic` · 같은 내용 = 409 물음 · 씀 · 새로) · 일반 사용자 회사 층 403 - 다른 층 SK = 이 층 사본 뒤 참조(화면 `Labor_SkPick` · 서버 서고 복사 길) -- 옮기기 = 로직 줄 → SK + 참조 한 행 · 면적 칸 잇기 옮김 · 전후 금액 같음 · 보기 = 임시 사본 · 실제 저장본 전수 +- 옮긴 뒤 상태 = 마스터 층 로직 줄 0(한 번용 옮기기 도구는 894 에서 걷음) """ import json import re -from decimal import Decimal from pathlib import Path -import pytest from fastapi import FastAPI from fastapi.testclient import TestClient from common_util.common_util_auth import verify_session -from M01_MasterData import M01_MasterData_Store_Combo as combo_store from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Labor_SkRow as skrow @@ -108,84 +105,9 @@ def test_M01_기초_SK_값_로직_줄과_같음_재료_별도계상(world): assert doc["자재표시"] and all(v["별도계상"] == "별도계상" for v in doc["자재표시"].values()) -def _labor_world(me): - """개인 층 조합 일위대가(수량 빈 줄 = 면적 칸) + 면적 문서 + SC(로직 줄 · 손 수량).""" - lines = [{"로직": TEN, "수량": None}, {"로직": STONE, "수량": {"손": 2}}] - pill = combo_store.combo_pills({"담은로직": lines})["물량"][0]["키"] - with store.at(me): - doc = labor.clean({"담은로직": lines}) - (me / "labor").mkdir(parents=True, exist_ok=True) - (me / "area").mkdir(parents=True, exist_ok=True) - (me / "labor" / "c811.json").write_text(json.dumps({**doc, "열": "c811", "단위": "㎡"}, ensure_ascii=False), "utf-8") # fmt: skip - area = {"시트": [{"id": "s1", "칸": {"A1": {"값": "4"}}, "연결": [{"키": pill, "칸": "A1"}]}]} - (me / "area" / "c811.json").write_text(json.dumps(area, ensure_ascii=False), "utf-8") - sc = _make(me, "precombo", 이름="sub1임시 SC", 담은로직=[{"로직": TEN, "수량": {"손": 3}}]) - return pill, sc - - -def test_옮기기_로직_줄_SK_참조_면적_잇기_전후_같음(world): - me = world["personal"] - pill, sc = _labor_world(me) - with store.at(me): - before = labor.calc(json.loads((me / "labor" / "c811.json").read_bytes()))["반영합"] - sc_before = _value(me, sc) - rows = {r["키"]: r for r in skrow.run_here()} - assert rows["c811"]["같음"] and rows[sc]["같음"] and rows["c811"]["알약"] == 1 - doc = json.loads((me / "labor" / "c811.json").read_bytes()) - assert all("참조" in x and "로직" not in x for x in doc["담은로직"]) - assert [x["수량"] for x in doc["담은로직"]] == [None, {"손": 2}] # 수량 · 별칭 그대로 - area = json.loads((me / "area" / "c811.json").read_bytes()) - keys = [x["키"] for x in area["시트"][0]["연결"]] - assert keys == [refs.ref_id(doc["담은로직"][0]["참조"])] and pill not in keys - with store.at(me): - assert labor.calc(doc)["반영합"] == before # 원 단위 같음(면적 칸 4) - assert _value(me, sc) == sc_before - assert refs.refs_in(_read(me, "precombo", sc))[0]["키"].startswith("SK-") - made = {k for r in rows.values() for k in r["새SK"]} - assert len(made) == 3 # SC TEN · 조합 TEN · STONE — 사본(값 묶음)이 달라 공유 안 함 - assert skrow.run_here() == [] # 두 번째 = 옮길 로직 줄 없음 - - -def test_옮기기_다르면_되돌림(world, monkeypatch): - me = world["personal"] - _labor_world(me) - raw = (me / "labor" / "c811.json").read_bytes() - real = skrow.money - monkeypatch.setattr( - skrow, "money", lambda k, key, doc: {"다름": id(doc)} if k == "labor" else real(k, key, doc) - ) - rows = {r["키"]: r for r in skrow.run_here()} - assert not rows["c811"]["같음"] and rows["c811"]["공유없음"] - assert (me / "labor" / "c811.json").read_bytes() == raw # 원래대로 - left = {p.stem for p in (me / "sangeun").glob("SK-*.json")} - sc_made = set(rows[next(k for k in rows if k != "c811")]["새SK"]) - assert left == sc_made # 되돌린 문서가 만든 SK 는 지움 - - -def test_보기_임시_사본_공유_storage_안_씀(world, tmp_path): - me = world["personal"] - _labor_world(me) - raw = (me / "labor" / "c811.json").read_bytes() - rows = skrow.migrate(False, work=tmp_path) - assert rows and all(r["같음"] for r in rows) - assert (me / "labor" / "c811.json").read_bytes() == raw # 보기 = 진짜 층 안 고침 - assert not (me / "sangeun").exists() or not list((me / "sangeun").glob("SK-*.json")) - skrow.to_xlsx(rows, tmp_path / "목록.xlsx") - assert (tmp_path / "목록.xlsx").stat().st_size > 0 - - -@pytest.mark.skipif( - not any(layers.storage_root().glob("*/*/templates/labor/*.json")), reason="저장본 없음" -) -def test_실제_저장본_전수_보기_같음(tmp_path): - """공유 storage 층 문서 전부 — 임시 사본에서 옮겨 봄(쓰지 않음) · 줄마다 금액 같음.""" - rows = skrow.migrate(False, work=tmp_path) # 이미 옮겼으면 옮길 줄 0 → 통과 - assert all(r["같음"] for r in rows), [r["키"] for r in rows if not r["같음"]] - - def test_마스터_층_단가산출_로직_줄_0(): """옮긴 뒤 상태 — 마스터 층 일위대가 · 조합의 담은로직에 로직 줄 0(참조 줄은 SK · SP · SC).""" - for kind in skrow.KINDS: + for kind in ("precombo", "labor"): for where, path in layers.layer_files(kind): if where != "마스터": continue @@ -214,7 +136,3 @@ def test_화면_줄_넣기_SK_사본_참조_부품(): assert len(text.splitlines()) <= 700 assert not re.search(r"""\bel\(\s*["'](button|input|select)["']""", text) assert len((M02 / "M02_Labor_SkRow.py").read_text("utf-8").splitlines()) <= 700 - - -def test_값_한_벌_소수(): - assert skrow._unit({"기준": {"계": Decimal("1289832")}, "배": 100}) == "12898.32" diff --git a/resources/tester/test_m02_labor_migrate.py b/resources/tester/test_m02_labor_migrate.py deleted file mode 100644 index 1098822af..000000000 --- a/resources/tester/test_m02_labor_migrate.py +++ /dev/null @@ -1,119 +0,0 @@ -"""옛 일위대가 조합 → 열마다 일위대가 문서 옮기기(`M02_Labor_Migrate` · PLAN 39-1b). - -시스템 층 = 견본 표(임시 폴더) · 조합은 M01 마스터(읽기만) · 개인 층 = 임시 storage. -""" - -import json -from pathlib import Path - -import pytest - -from config import config_system -from M02_MasterTemplete import M02_Labor_Migrate as migrate -from M02_MasterTemplete import M02_MasterTemplete_Combo_Store as combos -from M02_MasterTemplete import M02_MasterTemplete_Items as items_store -from M02_MasterTemplete import M02_MasterTemplete_Store as store -from M02_MasterTemplete import M02_Template_Layers as layers -from resources.tester.test_m02_structure import write_sample_table - -SHARED = "UP42-000001" - - -def _point(folder: Path, keys: dict[str, str]) -> None: - path = folder / "table" / f"{store.STRUCTURE_TABLE}.json" - doc = json.loads(path.read_bytes()) - for col in doc["열"]: - if col["id"] in keys: - col["일위대가"] = keys[col["id"]] - path.write_text(json.dumps(doc, ensure_ascii=False), encoding="utf-8") - - -@pytest.fixture() -def world(tmp_path, monkeypatch): - system = tmp_path / "system" - system.mkdir() - write_sample_table(system) - monkeypatch.setattr(store, "FOLDER", system) - monkeypatch.setattr(layers, "SYSTEM_ROOT", system) - storage = tmp_path / "storage" - storage.mkdir() - monkeypatch.setattr(config_system, "STORAGE_BASE_DIR", str(storage)) - _point(system, {"rv": "UA000008", "c1": "UA000008", "pv_b": "UA999999"}) - personal = layers.personal_dir(7, 42) - items_store.ensure(personal) - with store.at(personal): - got = store.read("table", store.STRUCTURE_TABLE) - doc = got["문서"] - doc["열"] = [ - {"id": "a", "머리": ["돌", "가"], "꼴": "수", "일위대가": SHARED}, - {"id": "b", "머리": ["돌", "나"], "꼴": "수", "일위대가": SHARED}, - ] - store.write("table", store.STRUCTURE_TABLE, got["판"], doc) - combo = { - "그룹": "일위대가조합", - "다음": 2, - "줄": [ - { - "키": SHARED, - "이름": "개인 조합", - "단위": "개소", - "담은로직": [{"로직": "GF000219", "메모": "메쌓기"}], - } - ], - } - (personal / combos.FILE).write_text(json.dumps(combo, ensure_ascii=False), encoding="utf-8") - return {"system": system, "personal": personal, "storage": storage} - - -def _labor(folder: Path, cid: str) -> dict: - return json.loads((folder / "labor" / f"{cid}.json").read_bytes()) - - -def test_시스템_층_열마다_복사_같은_조합도_따로_없는_조합은_못함(world): - system = world["system"] - got = migrate.migrate(system) - assert got["옮김"] == ["rv ← UA000008", "c1 ← UA000008"] - assert got["못함"] == ["pv_b · 없는 일위대가 조합 「UA999999」"] - rv, c1 = _labor(system, "rv"), _labor(system, "c1") - assert rv["본뜬"] == {"층": "system", "주인": None, "키": "UA000008"} - assert rv["담은로직"] == c1["담은로직"] and len(rv["담은로직"]) == 14 - assert all(one["입력값"] == {} and one["수량"] is None for one in rv["담은로직"]) - assert rv["일위대가번"] != c1["일위대가번"] # 열마다 자기 번호 - with store.at(system): # 나중에 만든 도면도 같은 뒷자리 - store.create_structure("rv") - doc = json.loads((system / "structure" / "rv.json").read_bytes()) - assert doc["도번"][2:] == rv["일위대가번"][2:] - assert rv["계산값"]["줄"] # 서버가 계산값까지 - assert _labor(system, "ms")["담은로직"] == [] # 키 없는 열 = 빈 일위대가 - - -def test_개인_층_여러_열이_쓰던_조합은_열마다_본뜬은_그_층(world): - personal = world["personal"] - assert migrate.layer_folders(True) == [personal] - got = migrate.migrate(personal) - assert got["옮김"] == [f"a ← {SHARED}", f"b ← {SHARED}"] - a, b = _labor(personal, "a"), _labor(personal, "b") - assert a["본뜬"] == b["본뜬"] == {"층": "personal", "주인": "7/42", "키": SHARED} - assert (a["단위"], a["담은로직"][0]["메모"]) == ("개소", "메쌓기") - assert a["일위대가번"] != b["일위대가번"] - - -def test_다시_돌려도_같음_사람이_고친_문서는_그대로(world): - system = world["system"] - migrate.migrate(system) - before = {p.name: p.read_bytes() for p in (system / "labor").glob("*.json")} - assert migrate.migrate(system)["옮김"] == [] - after = {p.name: p.read_bytes() for p in (system / "labor").glob("*.json")} - assert before == after - with store.at(system): # 사람이 비운 문서도 다시 안 채움 - got = store.read("labor", "rv") - store.write("labor", "rv", got["판"], {**got["문서"], "담은로직": []}) - assert "rv" in migrate.migrate(system)["그대로"] - assert _labor(system, "rv")["담은로직"] == [] - - -def test_미리_보기는_파일을_안_씀(world): - system = world["system"] - got = migrate.migrate(system, dry=True) - assert "rv ← UA000008" in got["옮김"] - assert not list((system / "labor").glob("*.json")) diff --git a/resources/tester/test_m02_template_layers.py b/resources/tester/test_m02_template_layers.py index e58751e60..7abab21d5 100644 --- a/resources/tester/test_m02_template_layers.py +++ b/resources/tester/test_m02_template_layers.py @@ -197,51 +197,6 @@ def test_프로젝트_만들기_자리에서_시스템_양식을_복사(world: d assert (root / "project_manifest.json").is_file() -def test_옛_프로젝트_넣기_도구는_더하기만_폴더_없으면_건너뜀(world: dict[str, Any]) -> None: - from M02_MasterTemplete import M02_Template_Migrate as migrate - - old = world["storage"] / "7/42/old-project" - (old / "B05_Profile").mkdir(parents=True) - (old / "B05_Profile/keep.txt").write_text("x", encoding="utf-8") - root1 = _root(world, P1) - layers.write_template(root1 / "templates", "table", "구조물집계표", {"고침": 1}) - (root1 / "templates/drawing/A1_도각.json").unlink() - projects = [ - { - "id": "old", - "name": "옛", - "company_id": 7, - "user_id": 42, - "storage_path": "storage/7/42/old-project", - }, - { - "id": P1, - "name": "첫째", - "company_id": 7, - "user_id": 42, - "storage_path": f"storage/7/42/{P1}", - }, - { - "id": "gone", - "name": "없음", - "company_id": 7, - "user_id": 42, - "storage_path": "storage/7/42/gone", - }, - ] - dry = migrate.migrate(projects, dry_run=True) - assert not (old / "templates").exists() and dry[0]["상태"] == "넣을 것(시험)" - report = {row["id"]: row for row in migrate.migrate(projects)} - assert report["old"]["상태"] == "넣음" and (old / "templates/_initial/table").is_dir() - assert (old / "B05_Profile/keep.txt").read_text(encoding="utf-8") == "x" - assert report[P1]["작업본"] == ["drawing/A1_도각"] - assert layers.read_template(root1 / "templates", "table", "구조물집계표")["문서"] == {"고침": 1} - assert report["gone"]["상태"].startswith("폴더 없음") - assert not (world["storage"] / "7/42/gone").exists() - assert migrate.migrate(projects)[0]["상태"] == "이미 있음" - assert "| 7 | 42 | 옛 |" in migrate.render(list(report.values()), []) - - def test_프로젝트_표_저장은_서버가_설계값을_걸러_씀(world: dict[str, Any]) -> None: from M02_MasterTemplete import M02_Table_Fill as fill @@ -268,47 +223,6 @@ def test_프로젝트_표_저장은_서버가_설계값을_걸러_씀(world: dic assert "알림" not in stored and all("|" not in c["id"] for c in stored["열"]) -def test_옛_표_틀은_새_판으로_손_값은_지킴(world: dict[str, Any]) -> None: - from M02_MasterTemplete import M02_Template_Migrate as migrate - - new = { - "판": 2, - "열": [{"id": "a", "식": "1", "펼침틀": {"묶음": "g"}}], - "줄": [], - "변수": {"k": 1}, - } - old = { - "판": 1, - "열": [{"id": "a", "식": "1", "바인딩": {"종류": "pipe", "값": "식"}}, {"id": "memo"}], - "줄": [{"id": "s10.00", "값": {"sta": "NO.0+10", "memo": "손"}}], - "변수": {"k": 5}, - } - layers.write_template(layers.system_dir(), "table", "구조물집계표", new) - root2, root1 = _root(world, P2, user=43), _root(world, P1) - for folder in (root1 / "templates", root1 / "templates/_initial", root2 / "templates"): - layers.write_template(folder, "table", "구조물집계표", old) - layers.write_template( - root2 / "templates", "table", "구조물집계표", {**old, "줄": [], "변수": {"k": 1}} - ) - - assert migrate.refresh_tables(root1, dry_run=True) == [ - "templates/table/구조물집계표", - "_initial/table/구조물집계표", - ] - migrate.refresh_tables(root1) - work = layers.read_template(root1 / "templates", "table", "구조물집계표")["문서"] - assert work["열"] == new["열"] and work["변수"] == {"k": 5} # 틀만 새 판 · 변수 · 손 값 지킴 - assert work["줄"] == old["줄"] - system_version = layers.version_of(layers.system_dir() / "table/구조물집계표.json") - initial = root1 / "templates/_initial" - assert layers.version_of(initial / "table/구조물집계표.json") != system_version # 변수 다름 - assert layers.read_manifest(root1 / "templates")["table/구조물집계표"]["판"] == system_version - assert migrate.refresh_tables(root1) == [] # 다시 돌려도 그대로 - # 손댄 것 없는 작업본은 시스템 파일 그대로(판이 같음) - migrate.refresh_tables(root2) - assert layers.version_of(root2 / "templates/table/구조물집계표.json") == system_version - - def test_뼈대_없는_문서는_400으로_거절하고_파일을_안_씀(world: dict[str, Any]) -> None: client = world["client"] path = _root(world, P1) / "templates/drawing/A1_도각.json" @@ -370,3 +284,11 @@ def test_개인_회사_양식_지우기_권한_판_이름_예외(world: dict[str == 200 ) assert "table/내양식" not in layers.read_manifest(layers.company_dir(7)) + + +def test_저장_경로_실경로는_storage_안_있는_폴더만(world: dict[str, Any]) -> None: + """대시보드 요약이 쓰는 `project_root` — 있는 폴더만 · 없음 · 밖 · `..` = None(만들지 않음).""" + assert layers.project_root(f"storage/7/42/{P1}") == _root(world, P1) + for bad in (None, "", "storage/7/42/없는것", "other/7/42", "storage/../7", "storage"): + assert layers.project_root(bad) is None, bad + assert not (world["storage"] / "7/42/없는것").exists() diff --git a/resources/tester/test_structures_summary_snapshot.py b/resources/tester/test_structures_summary_snapshot.py index 8a0c0ac54..5b7c2b9f5 100644 --- a/resources/tester/test_structures_summary_snapshot.py +++ b/resources/tester/test_structures_summary_snapshot.py @@ -300,7 +300,3 @@ def test_스냅샷이_없으면_알림(world): def test_초기화는_templates_를_안_건드리고_복제는_통째로(): assert not any(tree.startswith("templates") for tree in initial._FILE_TREES) - tool = (config_system.PROJECT_ROOT / "common_util/common_util_project_copy.py").read_text( - "utf-8" - ) # 복제 도구 본체(tools_clone_project = CLI 껍데기) - assert '"robocopy",' in tool and '"/E",' in tool # 프로젝트 폴더 전체(templates 포함)