chore(853-2): 걸음 0 묶음 ④ — 한 번 쓰고 끝난 도구 걷음
- 파일: 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 <noreply@anthropic.com>
This commit is contained in:
@@ -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
|
||||
|
||||
|
||||
@@ -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))
|
||||
@@ -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))
|
||||
@@ -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))
|
||||
@@ -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 <xlsx> 목록 파일(기본 `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))
|
||||
@@ -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()
|
||||
@@ -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"]))
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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())
|
||||
@@ -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)
|
||||
|
||||
@@ -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}}
|
||||
@@ -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
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -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"])
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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"))
|
||||
@@ -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()
|
||||
|
||||
@@ -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 포함)
|
||||
|
||||
Reference in New Issue
Block a user