refactor(858 5-8 ②): 서고 옛 꼴 읽기 변환 · 부르는 곳 0 걷음

- 옛 꼴 읽기 변환 걷음(요구 899 — 옛 꼴 호환 없음 · storage 전 층 서고 문서 20 · 프로젝트 사본 = 칸 없는 문서 0 · 옛 품셈 분류 0 · 옛 단가승격 참조 0 · promote 파일 0): `Labor_Ref.filled`(51-12 · 134-5 칸 채움) · `unpromote`(134-2 승격 참조 → 로직 줄) · 층 양식 읽기 길의 두 부름 · `summary` 의 칸 채움
- 부르는 곳 0(저장소 전체 · 시험 포함 다시 셈): `Template_Layers.note_source` · 내 기계 글 키 9(Copied · Win_Edit · Win_Blank · Win_Ok · Win_Cancel · Win_Edit_Note · Win_Uses · Why_M01 · Why_Company)
- 남김: `Library_Delete._restore`(부르는 곳이 store.batch 안 · 되돌림을 batch 가 맡게 하려면 Store 몸을 고쳐야 함 — 이번 몫 밖) · 주석만 고침
- 시험: 걷은 두 변환만 붙들던 시험 지움(labor_ref 옛 참조 줄 셋 · 칸 채움 단언 · precombo_class 옛 품셈 분류 하나)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 10:10:39 +09:00
co-authored by Claude Opus 5.5
parent 0291a19347
commit d4e3affc1f
7 changed files with 6 additions and 164 deletions
+2 -51
View File
@@ -3,7 +3,7 @@
자리 = 층 양식 길 종류(`M02_Template_Layers.LIBRARY_KINDS`) — 파일 이름 = 키:
promote 옛 단가승격 `{층}/promote/SP-######.json`(134-2 · 새로 안 만듦 · 읽기 · 셈만) —
`{종류:"단가승격", 키, 이름, 단위, 배, 담은로직:[{로직, 입력값}]}` · 값 = 로직 기준 ÷ 배 ·
층 문서를 읽을 때 옛 참조 줄 = 로직 줄 + `승격`(`unpromote`) · 프로젝트 사본은 그대로 셈
프로젝트 사본은 그대로 셈
precombo `{층}/precombo/SC-######.json` 사전조합
`{종류:"사전조합", 키, 이름, 단위, 본뜬, 담은로직:[{참조, 수량:{손}, 메모}
| {로직, 입력값, 메모, 수량:{손}, 고름?, 자재표시?}], 자재:[일위대가 자재 꼴]}` —
@@ -247,55 +247,6 @@ def saved_qty(one: dict[str, Any]) -> dict[str, Any]:
return {**one, "수량": {SAVED: hand}}
_OLD_CLASS = re.compile(r"품셈") # 134-5 — 옛 품셈 분류(건설품셈 공통 · 산림품셈 · 07장 …)
def filled(kind: str, doc: Any) -> Any:
"""옛 서고 문서 읽을 때 칸 채움 — 칸 없음(51-12 앞) · 옛 품셈 분류(134-5) = 빈 글(미분류) ·
파일은 안 고침([저장] 때 굳음) · 그 밖 지금 값 그대로(구조물정의가 바뀌어도 화면이 선택지로 둠)."""
if not isinstance(doc, dict) or kind not in PREFIX:
return doc
if "구분" in doc and not _OLD_CLASS.search(str(doc.get("구분") or "")):
return doc
return {**doc, "구분": "", "상세구분": ""}
def unpromote(kind: str, doc: Any) -> Any:
"""층 문서를 읽을 때(134-2) — 옛 단가승격 참조 줄 → 로직 줄 `{로직, 입력값, 켜쌓기율, 수량}` +
일위대가면 `승격: true`(사전조합 안 로직 줄엔 없음) · 값 같음(승격 값 = 기준 ÷ 배 = 로직 줄 반영) ·
같은 로직 줄이 이미 있으면 그 줄은 옛 참조 그대로(읽기 · 셈 · 저장 됨) · 파일은 안 고침([저장] 때 굳음)."""
lines = doc.get("담은로직") if isinstance(doc, dict) and kind in ("labor", "precombo") else None
if not isinstance(lines, list):
return doc
have = {str(one.get("로직")) for one in lines if isinstance(one, dict) and one.get("로직")}
out, changed = [], False
for one in lines:
ref = one.get("참조") if isinstance(one, dict) else None
src = (
read_ref(ref) if isinstance(ref, dict) and kind_of(ref.get("키")) == "promote" else None
)
line = ((src or {}).get("담은로직") or [None])[0]
code = str(line.get("로직") or "") if isinstance(line, dict) else ""
if not code or code in have:
out.append(one)
continue
have.add(code)
changed = True
# ponytail: 수량 null(면적산출 칸 연결)은 알약 키가 로직 것으로 바뀌어 칸을 다시 이어야 함
out.append(
{
"로직": code,
"별칭": one.get("별칭"),
"메모": one.get("메모"),
"입력값": dict(line.get("입력값") or {}),
"수량": one.get("수량"),
**{k: line[k] for k in ("켜쌓기율", "고름") if line.get(k) is not None},
**({"승격": True} if kind == "labor" else {}),
}
)
return {**doc, "담은로직": out} if changed else doc
def _combo_lines(doc: dict, key: str) -> list[dict[str, Any]]:
"""참조 줄 `{참조, 수량, 메모}` · 로직 줄 `{로직, 입력값, 메모, 수량}`(51-11) — 검사는
일위대가와 같은 길(`labor.clean` · 같은 로직 · 같은 참조 두 번 · 입력값) · 수량 기본 {손: 1}."""
@@ -404,7 +355,7 @@ def summary(
"""층 목록 한 줄에 붙일 것 — `{제목, 단위, 구분, 상세구분, 연결}`(51-12) · `expand` 면
1 단위 기준 계(`기준금액` · 51-4)."""
try:
doc = filled(kind, json.loads((Path(folder) / kind / f"{key}.json").read_bytes()))
doc = json.loads((Path(folder) / kind / f"{key}.json").read_bytes())
except (OSError, ValueError):
return {}
keep = ("구분", "상세구분", "연결")
+1 -1
View File
@@ -177,7 +177,7 @@ def remove(
files[at] = r
done: list[dict[str, Any]] = []
# ponytail: 부르는 곳(`Precombo_Folders.edit`)의 `store.batch` 안 — 실패하면 앞서 고친 파일을
# 앞판 바이트로 되돌림(되돌림 몸을 `batch` 로 옮기는 것은 5-8)
# 앞판 바이트로 되돌림 · 되돌림을 `batch` 가 맡으면(파일마다 앞판 기록) 이 몸을 걷음
for path, r in files.items():
raw = path.read_bytes()
try:
@@ -24,7 +24,6 @@ from common_util import common_util_spreadsheet as spreadsheet
from common_util.common_util_auth import verify_session
from common_util.common_util_storage import resolve_stored_project_path
from config.config_db import get_db_pool, run_with_connection
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Layer_Access as access
from M02_MasterTemplete import M02_Layer_Index as index
from M02_MasterTemplete import M02_Library_Flat as flat
@@ -271,9 +270,7 @@ async def read_layer_template(
raise HTTPException(status_code=404, detail="양식을 찾을 수 없습니다.")
found["층"] = layer
found["출처"] = layers.read_manifest(folder).get(f"{kind}/{name}")
found["문서"] = refs.filled(kind, found["문서"]) # 옛 서고 문서 구분 · 상세구분(51-12)
if layer != "project": # 옛 단가승격 참조 줄 = 새 꼴(134-2 · 프로젝트 사본은 그대로)
found["문서"] = await asyncio.to_thread(refs.unpromote, kind, found["문서"])
if layer != "project":
found["문서"] = await asyncio.to_thread(flat.flat_doc, kind, found["문서"]) # 740-1
return found
-10
View File
@@ -31,7 +31,6 @@ const TEXT = {
Stale: "그 사이 다른 곳에서 바뀜 — 목록에서 다시 열어 고침",
Name_Needed: "이름 · 비어 있음",
Same: "같은 이름 · 규격 있음 — {value}",
Copied: "「{value}」 값을 복사 — 고친 뒤 [저장]",
Own_Value: "개인 값",
Own_Note:
"개인 값 = 이 기계 고유 값(가격 · 손료계수 · 연료 ℓ · 인력 줄 · 잡품 줄) · 단가(노임 · 유가)는 M01 값 · 단가산출(프로젝트 밖)은 고치면 저절로 따라옴",
@@ -63,17 +62,8 @@ const TEXT = {
Win_Live: "원본 지금 값",
Win_Newer: "원본에 새 값 있음 — 프로젝트 사본은 [단가 갱신] 으로 반영",
Win_Swap: "이 기계로 바꾸기",
Win_Edit: "고쳐 쓰기",
Win_Blank: "빈 양식에서 새 기계",
Win_Ok: "확인",
Win_Cancel: "취소",
Win_Edit_Note:
"[확인] = 이 단가산출에 초안으로 끼움 · 단가산출 [저장] 때 내 기계로 저장 · 저장 안 하고 나가면 사라짐",
Win_Uses: "이 기계를 쓰는 다른 단가산출 {value} 건 — 저장하면 그쪽도 새 값으로 셈",
Win_Hint: "왼쪽에서 기계를 고르면 값이 보임",
Win_View: "조회",
Why_M01: "기계 값은 M01 기계 상세에서",
Why_Company: "개인용으로 복사해서 씀",
// 내 품목
Items_Note:
"단가산출 줄에 값을 바로 적은 재료(재료 DB · 내 재료에 안 이어진 것 · 읽기만) — 고치기는 그 단가산출에서 · 줄 누르면 쓰는 단가산출",
@@ -336,15 +336,6 @@ def _write_manifest(layer_dir: str | Path, entries: dict[str, Any]) -> None:
atomic_write_json(Path(layer_dir) / MANIFEST_NAME, {"양식": entries})
def note_source(
layer_dir: str | Path, kind: str, name: str, source_layer: str, version: str
) -> None:
"""manifest 한 줄 — 복사가 아니라 고쳐 쓴 양식의 출처 · 판."""
manifest = read_manifest(layer_dir)
manifest[f"{kind}/{name}"] = _stamp(source_layer, name, version)
_write_manifest(layer_dir, manifest)
def _stamp(layer: str, name: str, version: str | None, **extra: Any) -> dict[str, Any]:
entry = {
"층": layer,
+2 -74
View File
@@ -3,7 +3,7 @@
펼침(재귀 · 순환 · 깊이) · 층 규칙(위 층만) · 쓰는 곳 지우기 409 · 층 사이 따라 복사 ·
프로젝트 굳힘 · 로직 지우기 검사 · TS 짝 settle 거울. 층은 임시 폴더(마스터 · storage).
옛 단가승격(SP) = 새로 못 만듦 · 남은 파일은 읽기 · 셈 · 굳힘만(`_promote` = 옛 파일을 바로 씀) ·
층 문서를 읽을 때 옛 참조 줄 = 로직 줄 + 승격(`unpromote` · 같은 로직이 있으면 그대로).
읽을 때 옛 참조 줄을 새 꼴로 바꾸던 것은 858 5-8 에서 걷음(요구 899 — 옛 꼴 호환 없음).
"""
import json
@@ -98,74 +98,6 @@ def test_단가승격_서고는_없음_층_종류에서_뺌(world):
refs.create("promote", {"담은로직": [{"로직": TEN}]})
# ── 옛 단가승격 참조 줄 = 읽을 때 새 꼴(134-2) ───────────────────────────
def test_옛_참조_줄은_로직_줄_승격으로_보이고_값_같음(world):
sp = _promote(world["system"], TEN)
old = {
"열": "rv",
"담은로직": [
{"참조": {**SYS, "키": sp}, "별칭": "승", "메모": "m", "수량": {"손": 4}},
{"로직": STONE, "수량": {"손": 1}},
],
"자재": [],
}
got = refs.unpromote("labor", old)
assert got["담은로직"][0] == {
"로직": TEN,
"별칭": "승",
"메모": "m",
"입력값": {},
"수량": {"손": 4},
"승격": True,
}
assert old["담은로직"][0]["참조"]["키"] == sp # 받은 문서는 그대로
held = _promote(world["system"], PLAIN, {"규격": "NX"}, 켜쌓기율=90) # 입력값 · 율도 옮김
one = refs.unpromote("labor", {"담은로직": [{"참조": {**SYS, "키": held}}]})["담은로직"][0]
assert (one["입력값"], one["켜쌓기율"]) == ({"규격": "NX"}, 90)
with store.at(world["system"]):
before = labor.calc(labor.clean(old), {})["반영합"]["계"]
after = labor.clean(got)
assert after["담은로직"][0]["승격"] is True # [저장] 때 새 꼴로 굳음
assert labor.calc(after, {})["반영합"]["계"] == pytest.approx(before, rel=1e-9)
def test_옛_참조_줄은_같은_로직이_있으면_그대로_사전조합은_승격_없이(world):
sp = _promote(world["system"], STONE)
lines = [{"로직": STONE, "수량": None}, {"참조": {**SYS, "키": sp}, "수량": None}]
doc = {"열": "rv", "담은로직": lines, "자재": []}
assert refs.unpromote("labor", doc) is doc # 겹침 = 옛 참조 줄 그대로(저장 됨)
with store.at(world["system"]):
assert labor.clean(doc)["담은로직"][1]["참조"]["키"] == sp
combo = {"담은로직": [{"참조": {**SYS, "키": sp}, "수량": {"손": 2}, "메모": None}]}
one = refs.unpromote("precombo", combo)["담은로직"][0]
assert one["로직"] == STONE and one["수량"] == {"손": 2} and "승격" not in one
assert refs.unpromote("area", combo) is combo # 다른 종류는 안 봄
def test_층_길_읽기는_옛_참조_줄을_새_꼴로_파일은_그대로(world):
from fastapi import FastAPI
from fastapi.testclient import TestClient
from common_util.common_util_auth import verify_session
from M02_MasterTemplete import M02_MasterTemplete_Router_Layers as layer_router
sp = _promote(world["system"])
with store.at(world["personal"]):
line = {"참조": {**SYS, "키": sp}, "수량": {"손": 2}}
store.write("labor", "x1", "", {"열": "x1", "담은로직": [line], "자재": []})
app = FastAPI()
app.include_router(layer_router.router)
app.dependency_overrides[verify_session] = lambda: {
"user_id": 42,
"company_id": 7,
"role": "USER",
"is_master": False,
}
got = TestClient(app).get("/api/m02/layers/personal/templates/labor/x1").json()
assert got["문서"]["담은로직"][0]["로직"] == TEN and got["문서"]["담은로직"][0]["승격"] is True
assert _read(world["personal"], "labor", "x1")["담은로직"][0]["참조"]["키"] == sp
def test_사전조합_틀린_줄_400_순환_422(world):
sp = _promote(world["system"])
one = {"참조": {**SYS, "키": sp}}
@@ -541,7 +473,7 @@ def test_사전조합이_자기_자신을_담으면_422_수량_없음(world):
assert e.value.status == 422 and "자기 자신" in e.value.detail
def test_서고_구분_상세구분_사전조합은_고른_값_옛_문서는_읽을_때(world):
def test_서고_구분_상세구분_사전조합은_고른_값(world):
sp = _promote(world["system"])
sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}}])
assert (_read(world["system"], "precombo", sc)["구분"], "") == ("", "")
@@ -550,10 +482,6 @@ def test_서고_구분_상세구분_사전조합은_고른_값_옛_문서는_읽
store.write("precombo", sc, have["판"], {**have["문서"], "구분": " 가 ", "상세구분": "나"})
got = _read(world["system"], "precombo", sc)
assert (got["구분"], got["상세구분"]) == ("가", "나")
# 옛 문서(칸 없음) — 사전조합은 빈 글 · 옛 승격은 손대지 않음
old = _read(world["system"], "promote", sp)
assert refs.filled("promote", old) is old
assert refs.filled("precombo", {"담은로직": []})["구분"] == ""
rows = [{"종류": "precombo", "이름": sc}]
refs.summaries(world["system"], rows)
assert (rows[0]["구분"], rows[0]["상세구분"], rows[0]["연결"]) == ("가", "나", None)
@@ -1,7 +1,6 @@
"""일위대가 사전조합 구분 · 상세구분 새 분류(PLAN 134-5) — 구조물군 A~G › 그 군 종류 + 「공통」.
- 원천 = 마스터 `구조물정의.json`(구조물군 · types) — 군마다 첫 상세구분 「공통」 · 꺼진 종류도 · 「호환(기타)」 뺌
- 옛 품셈 분류(건설품셈 공통 · 산림품셈) = 읽을 때 빈 값(미분류) · 파일 안 고침 · 새 분류 값 · 지금 값은 그대로
- 새 문서 = 빈 값(미분류) · 상세 드롭다운 원천 = 구조물 정의(로직 구분 목록 아님)
"""
@@ -10,8 +9,6 @@ import os
import subprocess
from pathlib import Path
from M02_MasterTemplete import M02_Labor_Ref as refs
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = Path(HERE).parents[1]
M02 = ROOT / "M02_MasterTemplete"
@@ -49,18 +46,6 @@ def test_분류는_구조물군_종류_공통():
)
def test_옛_품셈_분류는_미분류_새_값은_그대로():
old = {"이름": "가", "구분": "건설품셈 공통", "상세구분": "07장 돌공사", "담은로직": []}
got = refs.filled("precombo", old)
assert (got["구분"], got["상세구분"]) == ("", "") and old["구분"] == "건설품셈 공통"
assert refs.filled("precombo", {**old, "구분": "산림품셈", "상세구분": "03장"})["구분"] == ""
now = {**old, "구분": "C 사면안정", "상세구분": "옹벽"}
assert refs.filled("precombo", now) is now
gone = {**old, "구분": "Z 없어진 군", "상세구분": "x"} # 지금 값은 선택지로(화면 몫)
assert refs.filled("precombo", gone) is gone
assert refs.filled("precombo", {"담은로직": []})["구분"] == "" # 칸 없는 옛 문서
def test_화면_원천은_구조물_정의_새_문서는_미분류():
detail = (M02 / "M02_MasterTemplete_Labor_LibMeta.ts").read_text("utf-8") # 717-3 나눔
assert "subs = precomboClasses(def);" in detail and "fetchLibLogicSubs" not in detail