- 지움(부르는 곳 다시 찾음 — 저장소 전체 · 조립 주소 · 라우터 · 시험 · 도우미)
· M02_Hopyo_SkUnit(import 0 · 시험 778-5 · 780-1 만) · M02_Hopyo_Item(길 hopyo-item 하나만)
· 길 GET hopyo/{키}/{번}/siblings · POST hopyo-item(TS · JS 0 — 화면 [구조물 조합으로]는 구조물 조합 길을 바로 부름) + 그 몸 Build* 다섯
· Library_Ask.ask_item · labor_finger(Hopyo_Item 만 부름)
· Hopyo_Sangeun.Maker · _doc(만드는 곳 0) · Hopyo_Elem.prices · Hopyo_Units.hopyo_unit · summary(부르는 곳 0 · 시험만)
- 시험: test_572_hopyo_same 지움(Maker 만 봄) · test_705_2 구조물 조합으로 넷 지움 · test_778_5 단위 SK 셈 줄 뺌(줄 잇기 결과는 그대로 · 연결 표 셈은 시험 안에서) · test_780_1 단위 SK 판정 뺌(블록 · 부름 수 · 빈 블록 밖은 그대로)
- helper_728_2_cover_unit.cjs 는 SkUnit 안 부름(Cover_Model 을 봄) — 남김
- 서버 길 484 → 482(뜻한 둘만)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
160 lines
7.4 KiB
Python
160 lines
7.4 KiB
Python
"""M02 실무 호표가 다른 호표를 부를 때 = 일위대가 둘(PLAN 777-1 · 요구 621-4 · 요구 581 「SK · SC 서로 독립」).
|
|
|
|
하위 호표 번(`kids_of`) · 하위 먼저 만들기는 옮기기(`M02_Hopyo_Make`) · 모두 고정(`M02_Hopyo_Build.build_all`) 몫 ·
|
|
부모 줄 = 하위 사본(740-1 그대로) · 옛 서버 체크 제안 하위 함께(`first` · `proposal`)는 785-7 에서 지움.
|
|
같은 내용 일위대가 재사용 `save` — 같은 본뜬(키 · 원본)이면 그 SC(혼자 쓰면 덮음 · 나눠 쓰면 내용 같을 때만) ·
|
|
아니면 이 층 같은 이름 · 같은 내용 SC(`M02_Library_Same.find_same` + 수량까지) 의 `본뜬.또` 에 출처를 더해 씀
|
|
· 없으면 새로 → 다시 불러와도 SC 가 안 늚.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
from M02_MasterTemplete import M02_Hopyo_Fixed as hfix
|
|
from M02_MasterTemplete import M02_Labor_Ref as refs
|
|
from M02_MasterTemplete import M02_Library_Flat as lflat
|
|
from M02_MasterTemplete import M02_Library_Same as lsame
|
|
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
|
|
|
ORIGIN = "실무자료"
|
|
KIND = "precombo"
|
|
|
|
|
|
# ── 같은 내용 재사용 ─────────────────────────────────────────────────
|
|
def _same_mark(a: dict, b: dict) -> bool:
|
|
"""같은 출처 — 본뜬 키 같음 · 원본(파일 층)이 둘 다 있으면 같음(SC · SK 함께 · `Sangeun` 이 빌림)."""
|
|
if a.get("키") != b.get("키"):
|
|
return False
|
|
return not a.get("원본") or not b.get("원본") or tuple(a["원본"]) == tuple(b["원본"])
|
|
|
|
|
|
def entries(folder: str | Path):
|
|
"""층 사전조합 실무자료 출처 → (키, 본뜬 · 또 한 칸, 판) — 또 = 같은 내용으로 이 SC 를 쓴 뒤 출처."""
|
|
for path in sorted((Path(folder) / KIND).glob("SC-*.json")):
|
|
try:
|
|
raw = path.read_bytes()
|
|
doc = json.loads(raw)
|
|
except (OSError, ValueError):
|
|
continue
|
|
got = doc.get("본뜬") if isinstance(doc, dict) else None
|
|
if isinstance(got, dict) and got.get("층") == ORIGIN:
|
|
for one in [got, *(x for x in got.get("또") or [] if isinstance(x, dict))]:
|
|
yield path.stem, one, raw
|
|
|
|
|
|
def same_source(got: dict[str, Any], source: refs.Here | None) -> bool:
|
|
"""본뜬 원본 층이 같음 — 원본 없는 옛 것 · `source` None 은 가리지 않음."""
|
|
have = got.get("원본")
|
|
return source is None or not have or tuple(have) == tuple(source)
|
|
|
|
|
|
def _bare(value: Any) -> Any:
|
|
"""사본 블록 `주인`(몸 지문 · 메모까지 셈) 뺌 — 셈 내용은 `몸` 이 다 가짐."""
|
|
if isinstance(value, list):
|
|
return [_bare(x) for x in value]
|
|
if not isinstance(value, dict):
|
|
return value
|
|
return {k: _bare(x) for k, x in value.items() if not (k == "주인" and "몸" in value)}
|
|
|
|
|
|
def _rows(doc: dict[str, Any], part: str) -> list[str]:
|
|
return sorted(json.dumps(lsame.norm(_bare(x)), ensure_ascii=False, sort_keys=True) for x in doc.get(part) or []) # fmt: skip
|
|
|
|
|
|
def body(doc: dict[str, Any]) -> list:
|
|
"""셈 내용 그대로(수량까지 · 하위 = 펼친 사본 몸) — `find_same` 지문은 SC 수량을 안 봄."""
|
|
flat = lflat.flat_doc(KIND, doc)
|
|
head = [lsame.unit(flat.get("단위")), lsame.norm(flat.get("규격"))]
|
|
return [*head, _rows(flat, "담은로직"), _rows(flat, "자재")]
|
|
|
|
|
|
def _entry(doc: dict[str, Any]) -> dict[str, Any]:
|
|
return {**doc["본뜬"], "이름": doc["이름"]}
|
|
|
|
|
|
def _split(old: dict[str, Any], mine: dict[str, Any]) -> tuple[dict, list]:
|
|
got = old.get("본뜬") or {}
|
|
own = {k: v for k, v in got.items() if k != "또"}
|
|
rest = [x for x in got.get("또") or [] if isinstance(x, dict) and not _same_mark(x, mine)]
|
|
return own, rest
|
|
|
|
|
|
def _put(key: str, raw: bytes, old: dict, own: dict, also: list, doc: dict | None = None) -> None:
|
|
new = {**(doc or old), "본뜬": {**own, "또": also} if also else own}
|
|
if new != old:
|
|
store.write(KIND, key, store.version_of(raw), new)
|
|
|
|
|
|
def _empty(root: Path, doc: dict[str, Any]) -> list[str]:
|
|
"""빈 호표(줄 · 자재 없음 = 지문 없음) — 이름 · 단위 같은 실무자료 SC."""
|
|
if doc.get("담은로직") or doc.get("자재"):
|
|
return []
|
|
out = []
|
|
for path in sorted((root / KIND).glob("SC-*.json")):
|
|
try:
|
|
got = json.loads(path.read_bytes())
|
|
except (OSError, ValueError):
|
|
continue
|
|
same = (got.get("이름"), lsame.unit(got.get("단위"))) == (doc["이름"], lsame.unit(doc.get("단위"))) # fmt: skip
|
|
if same and (got.get("본뜬") or {}).get("층") == ORIGIN:
|
|
out.append(path.stem)
|
|
return out
|
|
|
|
|
|
def save(doc: dict[str, Any], same: lsame.Same | None = None) -> tuple[dict[str, Any], bool, bool]:
|
|
"""(참조, 다시씀, 재사용) — 엑셀 수량 = 저장(742-1) · `same` = 한 요청 안 지문 메모."""
|
|
hands = {
|
|
"줄": {str(i): x["수량"]["손"] for i, x in enumerate(doc["담은로직"]) if x.get("수량")},
|
|
"자재": {m["코드"]: m["수량"]["손"] for m in doc.get("자재") or [] if m.get("수량")},
|
|
}
|
|
doc = {**doc, "본뜬": {**doc["본뜬"], "실무수량": hands}}
|
|
same, root, mine = same or lsame.Same(), store.root(), doc["본뜬"]
|
|
here = refs.here()
|
|
ref = lambda key: {"층": here[0], "주인": here[1], "키": key} # noqa: E731
|
|
have = next(
|
|
(
|
|
(key, raw)
|
|
for key, got, raw in entries(root)
|
|
if got.get("키") == mine["키"] and same_source(got, tuple(mine["원본"]))
|
|
),
|
|
None,
|
|
)
|
|
if have:
|
|
key, raw = have
|
|
old = json.loads(raw)
|
|
own, rest = _split(old, mine)
|
|
owner, alike = _same_mark(own, mine), body(old) == body(doc)
|
|
if owner and (not rest or alike): # 혼자 · 내용 같음 = 제자리 덮음(나눈 출처 그대로)
|
|
_put(key, raw, old, mine, rest, doc)
|
|
same.add(root, KIND, key, doc)
|
|
return ref(key), True, False
|
|
if alike: # 남의 SC 를 같은 내용으로 씀 — 제 출처 칸만
|
|
_put(key, raw, old, own, [*rest, _entry(doc)])
|
|
return ref(key), True, False
|
|
head = {k: v for k, v in rest[0].items() if k != "이름"} if owner else own
|
|
_put(key, raw, old, head, rest[1:] if owner else rest) # 내용 달라짐 = 떼어 냄
|
|
for key in same.find_same(root, KIND, doc) or _empty(root, doc):
|
|
raw = (root / KIND / f"{key}.json").read_bytes()
|
|
old = json.loads(raw)
|
|
if old.get("이름") == doc["이름"] and body(old) == body(doc): # 이름까지 = 같은 호표
|
|
own, rest = _split(old, mine)
|
|
_put(key, raw, old, own, [*rest, _entry(doc)])
|
|
return ref(key), False, True
|
|
key = refs.create(KIND, doc)["이름"]
|
|
same.add(root, KIND, key, doc)
|
|
return ref(key), False, False
|
|
|
|
|
|
# ── 하위 함께 만들기 ─────────────────────────────────────────────────
|
|
def kids_of(hopyo: dict[str, Any]) -> list[int]:
|
|
"""호표 줄이 부르는 호표 번(줄 차례)."""
|
|
out = []
|
|
for line in hopyo.get("줄") or []:
|
|
ref = line.get("참조") or {}
|
|
if hfix.kind_of(line) == "호표" or ref.get("종류") == "일위":
|
|
out.append(int(ref.get("번") or 0))
|
|
return out
|