Files
Aislo/M01_MasterData/M01_MasterData_Store_Make.py
T
eomsangdonandClaude Opus 5.5 badceff991 refactor(855-E L3b ②): 로직 줄 같이 쓰기 끔 — mirror · 스위치 · 빌더 문서 갈래 걷음
- Store_Logic: WRITE · CALC · mirror · _ordered · _headed_row · _picks · _write 지움(로직 JSON 쓰는 곳 0)
- Machine.register 의 mirror 줄 · Store_Save._logic_file · Store_Cache 「!= 로직」 표지 걷음 ·
  labor_errors = 있는 기초 키(수식 문서)만(whole.logic 갈래 지움)
- M01 Doc: _row · sync_tags · ensure · built · of_row · make 지움 · 읽기 「층바탕」(빌더 문서) 뺌 ·
  손고침 = 셈 칸을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 브레인 정함)
- M02 Doc_Sk.base_doc · Doc_Sk_Path 층바탕의 빌더 문서 갈래 지움(그 자리 = 지금 문서)
- 화면 LogicRow 셈 칸 · [신규] 빈 셈 칸 · 안 쓰는 꼴 셋 지움
- 시험: 855_l3_doc_only = 옛 로직 파일 놓여도 안 읽고 안 씀 · 848_1 손고침 표지 · 848_10 빌더 층 시험 지움 ·
  파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 문서를 따라감 · 854_2 복사 = 원본 문서 금액(옛 엔진 대조 뺌) ·
  848_5 · 855_l1 로직 줄 대조 뺌 · labor_errors 손님 셋 = 있는 키 묶음
- 서버 답 243 건 다름 0 · typecheck 0 · 관련 105 파일(717_2a 원래 실패 · 792_3 엔진 몸 일감 몫 빼고) 통과

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 13:28:00 +09:00

331 lines
15 KiB
Python

"""M01 「만들기」 저장소 — 원문 절 목록 · 표 조건 값 · 자체 로직 만들기 · 본뜨기(= [복사/생성]) · 고치기 · 지우기.
계약: `resources/master_data/_화면_계약.md` 2장·5장 · 파일 모양: `_틀.md` 7장.
기초(로직) 저장 = 수식 문서 먼저(`Store_Logic` · 855 L3 ⓐ) · 자체 기초는 `수식_자체.json` 한 파일 ·
키는 `_키대장.json` 의 `GX` 다음 번호(서버가 줌).
"""
from __future__ import annotations
import re
from M01_MasterData import M01_MasterData_Doc as doc_store
from M01_MasterData import M01_MasterData_Machine as machine
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Logic as logic_store
from M01_MasterData import M01_MasterData_Store_Revise as revise
cm, mk = store.cm, store.mk
OWN = "로직_자체.json" # 자체 로직 한 자리 — 이 파일 줄만 고치고 지울 수 있음
OWNERS = ("현장", "공용")
BODY = mk._BODY # resources/knowledge/original/원가계산
BOOKS = {"산림품셈": "산림_표준품셈", "건설품셈": "건설공사_표준품셈"}
_HEAD = re.compile(r"^#{2,6}\s*(\d+(?:-\d+)*)\.?\s+(\S.*?)\s*$")
_CHAPTER_DIR = re.compile(r"^제(\d\d)장_(.+)$")
# ── 원문 절 목록 ───────────────────────────────────────────────────────
def _chapters(book: str):
"""(부문, 장 번호, 장 제목, 폴더) — 건설품셈은 부문 폴더 아래."""
root = BODY / BOOKS[book] / "본문"
tops = sorted(root.glob("*부문")) if book == "건설품셈" else [root]
for top in tops:
division = top.name.split("_", 1)[1].removesuffix("부문") if book == "건설품셈" else ""
for folder in sorted(top.glob("제*장_*")):
m = _CHAPTER_DIR.match(folder.name)
if m:
yield division, m.group(1), m.group(2).replace("_", " "), folder
_CACHE: dict[str, list[dict]] = {}
def _all_sections(book: str) -> list[dict]:
"""원문 본문 제목 줄에서 모은 절 — 한 번 세워 두고 다시 씀(원문은 안 바뀜)."""
if book in _CACHE:
return _CACHE[book]
out, seen = [], set()
for division, number, title, folder in _chapters(book):
for md in sorted(folder.glob("*.md")):
for line in md.read_text(encoding="utf-8").split("\n"):
m = _HEAD.match(line)
if not m or m.group(1).split("-")[0] != str(int(number)):
continue
if (division, m.group(1)) in seen:
continue
seen.add((division, m.group(1)))
out.append(
{
"book": book,
"division": division,
"chapter": f"{division} {number}장 {title}".strip(),
"chapterNo": number,
"section": m.group(1),
"title": m.group(2),
}
)
_CACHE[book] = out
return out
# ── 로직 원문(출처 글 → 품셈 본문 절) ──────────────────────────────────
_NUMBER = re.compile(r"(?<![\d-])(\d+(?:-\d+)+)(?![\d-])(?:\s+(주[①-⑳]?|\d{1,2})(?![\d-]))?")
_ESCAPE = re.compile(r"\\([.\-*_()#\[\]>~`])") # 마크다운 이스케이프 `\.` `\-` …
_COMMENT = re.compile(r"<!--.*?-->") # 글 안 주석(글자층 표시) — 글자만 남김
_CIRCLED = "①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳"
def _plain(text: str) -> str:
"""원문 md 기호 벗김 — 주석 · 이스케이프 · 인용 머리 `> `."""
text = _ESCAPE.sub(r"\1", _COMMENT.sub("", text)).strip()
return text[1:].strip() if text.startswith(">") else text
def _blocks(lines: list[str]) -> list[dict]:
"""md 줄 → 화면 조각 — 제목 {h} · 표 {table} · 글 {p} · 주석 줄은 뺌 ·
빈 줄 · 주석이 표를 끊음(붙은 표 둘을 한 표로 안 합침) · `<br>` = 줄바꿈."""
out: list[dict] = []
joinable = False
for line in lines:
text = re.sub(r"<br\s*/?>", "\n", line.strip())
if not text or text.startswith("<!--"):
joinable = False
continue
if not text.startswith(("#", "|")):
text = _plain(text)
if not text:
joinable = False
continue
if text.startswith("#"):
out.append({"h": len(text) - len(text.lstrip("#")), "text": text.lstrip("#").strip()})
elif text.startswith("|"):
cells = [_plain(c) for c in text.strip("|").split("|")]
if all(re.fullmatch(r":?-{3,}:?", c) for c in cells):
continue # 머리 · 몸 가름 줄
if not joinable:
out.append({"table": []})
out[-1]["table"].append(cells)
joinable = True
continue
else:
out.append({"p": text})
joinable = False
return out
def _mark(blocks: list[dict], item: str) -> bool:
"""출처 항 · 주 번호(「1」 · 「주③」 · 「주」)에 드는 조각에 hit 표시 — 못 찾으면 False(절 통째만)."""
texts = [b.get("p") or b.get("text") or "" for b in blocks]
if item.startswith("주"):
note = next((i for i, t in enumerate(texts) if t.startswith("[주]")), None)
if note is None:
return False
start, stop = note, len(blocks)
if len(item) > 1: # 「주③」 — [주] 아래 ③ 줄 하나(다음 ① ~ ⑳ 줄 앞까지)
start = next(
(i for i in range(note + 1, len(texts)) if texts[i].startswith(item[1])), None
)
if start is None:
return False
stop = next(
(i for i in range(start + 1, len(texts)) if texts[i][:1] in _CIRCLED), len(blocks)
)
else: # 「1」 — 「1. …」 제목 · 줄 ~ 다음 제목 · 「2. …」 앞(줄이면 [주] 앞도)
head = re.compile(rf"{item}[.)]\s")
start = next((i for i, t in enumerate(texts) if head.match(t)), None)
if start is None:
return False
under = "h" in blocks[start]
stop = next(
(
i
for i in range(start + 1, len(blocks))
if "h" in blocks[i]
or (not under and re.match(r"\d+[.)]\s|\[주\]", texts[i]))
or (under and re.match(r"\d+[.)]\s", texts[i]) and "p" in blocks[i])
),
len(blocks),
)
for b in blocks[start:stop]:
b["hit"] = True
return True
def _section(book: str, division: str, number: str) -> dict | None:
"""번호 절을 품셈 본문에서 찾음 — 없으면 끝 마디를 하나씩 떼며 위 절로(두 마디까지)."""
parts = number.split("-")
folders = [f for d, no, _t, f in _chapters(book) if d == division and int(no) == int(parts[0])]
for upto in range(len(parts), 1, -1):
want = "-".join(parts[:upto])
for folder in folders:
for md in sorted(folder.glob("*.md")):
lines = md.read_text(encoding="utf-8").split("\n")
for i, line in enumerate(lines):
m = _HEAD.match(line)
if not m or m.group(1) != want:
continue
level = len(line) - len(line.lstrip("#"))
end = next(
(
j
for j in range(i + 1, len(lines))
if _HEAD.match(lines[j])
and len(lines[j]) - len(lines[j].lstrip("#")) <= level
),
len(lines),
)
return {
"number": number,
"matched": want,
"file": md.relative_to(BODY.parent).as_posix(),
"blocks": _blocks(lines[i:end]),
}
return None
def source(src: str) -> dict:
"""로직 출처 글(예 「건설품셈 토목 1-1-2」 · 「산림품셈 3-4-2 1」)로 찾은 품셈 원문 절 —
번호가 여럿이면(「8-1-5 · 8-1-6」) 절마다 · 못 찾으면 found 빈 목록(화면 「원문 연결 없음」)."""
words = src.split()
book = words[0] if words else ""
if book not in BOOKS:
return {"source": src, "found": []}
division = (
next((d for d in cm.DIVISIONS if src.startswith(f"{book} {d} ")), "")
if book == "건설품셈"
else ""
)
found = []
for number, item in dict.fromkeys(_NUMBER.findall(src)):
one = _section(book, division, number)
if one:
if item and _mark(one["blocks"], item):
one["item"] = item
found.append(one)
return {"source": src, "found": found}
# ── 저장 ──────────────────────────────────────────────────────────────
def _alias(part: dict) -> None:
"""별칭(815-2) = 앞뒤 빈칸만 뗌 · 빈 글 = 칸 없음."""
for ch in part.get("changes") or []:
row = ch.get("row")
if isinstance(row, dict) and "별칭" in row:
text = str(row["별칭"] or "").strip()
row.update(별칭=text) if text else row.pop("별칭")
def save(batch: list[dict], confirmed: bool = False) -> dict:
"""`/save` — 기초(로직 파일 몫)는 `Store_Logic`(문서 먼저 · 정본 머리 고침은 `confirmed` 없으면 409) ·
요소 · 표는 `store.save` · 자체 새 줄(키 없음)은 서버가 칸을 잡고 GX 다음 키 — {files, added, warnings}."""
logic = [p for p in batch if logic_store.is_logic(str(p.get("file") or ""))]
rest = [p for p in batch if not logic_store.is_logic(str(p.get("file") or ""))]
revise.guard(logic, confirmed)
for part in batch:
_alias(part)
for part in logic:
for ch in part.get("changes") or []:
row = ch.get("row")
if (
part.get("file") == OWN
and isinstance(row, dict)
and (ch.get("op") == "add" or not ch.get("key"))
):
ch.update(op="add", key=None, row=_clean(row, str(row.get("소유") or OWNERS[0])))
files, added = [], []
if rest:
for part in rest:
machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2)
_keep_same(part)
docs_too = machine.register(rest) # [새 기계] = 꼴 식 목록 등록(822-2 · 848-5 문서 정본)
before = {
p["file"]: set(_file_keys(p["file"])) for p in rest
} # 자재 3만 키 — 목록 찾기 금지
with store.cache.picks(*getattr(docs_too, "lists", ({}, set()))):
files = store.save(rest)
docs_too()
added = [
{"file": f, "key": k}
for f, old in before.items()
for k in _file_keys(f)
if k not in old
]
if logic:
got = logic_store.save(logic, True)
files, added = files + got["files"], added + got["added"]
return {"files": files, "added": added, "warnings": []}
def _keep_same(part: dict) -> None:
"""고친 줄의 값이 같은 칸 = 파일 값 그대로(화면 왕복 「9.0」 → 「9」 막음 · 그 칸만 바뀜)."""
data = store.loaded()[0].get(str(part.get("file") or "")) # 읽기만 — 기억(826-2)
if data is None:
return
rows = {str(r.get("키")): r for r in data.get(store.items_key(data)) or []}
for ch in part.get("changes") or []:
old, row = rows.get(str(ch.get("key"))), ch.get("row")
if ch.get("op") == "edit" and isinstance(old, dict) and isinstance(row, dict):
same = {k for k, v in row.items() if k in old and store._dec(v) == old[k]}
ch["row"] = {k: old[k] if k in same else v for k, v in row.items()}
def _file_keys(file: str) -> list[str]:
data = store.loaded()[0].get(file) or {} # 읽기만 — 기억(826-2 · 저장 뒤엔 갈아 끼운 것)
return [str(r.get("키")) for r in data.get(store.items_key(data)) or []]
# ── 자체 로직 ──────────────────────────────────────────────────────────
def _clean(logic: dict, owner: str, key: str | None = None) -> dict:
"""서버가 잡는 칸 — 키·소유·구분·상세구분. 화면이 보낸 것은 안 씀."""
if not isinstance(logic, dict) or not str(logic.get("이름") or "").strip():
raise store.StoreError(400, "로직 줄에 「이름」 이 없음")
if owner not in OWNERS:
raise store.StoreError(400, f"모르는 소유 「{owner}」 — {' · '.join(OWNERS)}")
number = str(logic.get("원문번호") or "")
rest = {
k: v for k, v in logic.items() if k not in ("키", "원문번호", "구분", "상세구분", "소유")
}
head = {"키": key, "원문번호": number} if key else {"원문번호": number}
one = {**head, "구분": "자체", "상세구분": _chapter_of(logic), "소유": owner, **rest}
order = mk.ROW_ORDER["로직"] # 열 차례는 `_틀.md` 2장
return {
**{k: one[k] for k in order if k in one},
**{k: v for k, v in one.items() if k not in order},
}
def _chapter_of(logic: dict) -> str:
"""상세구분 — 원문 절이 속한 장(「13장 구조물」) · 원문 절이 없으면 빈 글."""
number = str(logic.get("원문번호") or "")
source = str(logic.get("출처") or "")
book = next((b for b in BOOKS if source.startswith(b)), "")
if not number or not book:
return ""
at = int(number.split("-")[0])
division = next((d for d in cm.DIVISIONS if source.startswith(f"{book} {d} ")), "")
for one_division, chapter, title, _ in _chapters(book):
if one_division == division and int(chapter) == at:
return f"{chapter}장 {title}"
return ""
def logic_new(logic: dict, owner: str = OWNERS[0], source: str = "") -> dict:
"""새 자체 기초 — 키 = 서버가 `GX` 다음 번호 · 문서 = 빈 문서 / `source` 문서 복제(본뜸)."""
change = {"op": "add", "row": _clean(logic, owner), "from": source}
part = {"file": OWN, "version": doc_store.file_version(OWN), "changes": [change]}
got = logic_store.save([part], True)
key = got["added"][-1]["key"]
return {**got["files"][0], "key": key, "logic": store.logic(key)["logic"], "수식문서": True}
def logic_copy(key: str, 이름: str = "", owner: str = OWNERS[0], more: dict | None = None) -> dict:
"""본떠 만들기 = [복사/생성] — 원본 문서를 새 자체 기초로 복제(정본도 본뜸) · 비고 끝에 본뜬 키 ·
`more` = 기본정보 창에서 고친 원문번호 · 결과단위 · 출처(빈 글은 원본 그대로)."""
_, doc = doc_store.find(key)
row = doc_store.head_of(doc)
note = " · ".join(x for x in (str(row.get("비고") or ""), f"{key} 를 본뜸") if x)
copy = {**row, "비고": note, **{k: v for k, v in (more or {}).items() if v}}
if 이름:
copy["이름"] = 이름
return logic_new(copy, owner, key)