refactor(855-E L3ⓐ): M01 기초 저장 · 검사 · 막힘 세기 = 수식 문서 기준 · 로직 줄 쓰기 = Store_Logic.mirror 한 자리

앞 세션 auto 커밋 cce57c298(Store_Logic 새 길 · /logic 답 머리만 · 판 = 문서 파일 지문 · 개정 = 문서 머리 대조 · 별칭 · 기계 등록 · [신규] · [삭제])에 이어
- Store_Cache: 막힘 세기(blocks · counted)를 문서 파일마다 · 저장 검사 logic_errors = 키 겹침 · 대장(요소 + 문서 키) · 연결 · 문서 막힘(check_logics 로직 줄 검사 걷음) · _docs_of = 문서 전부 · narrow 로직 갈래 걷음 · check_saved(부름 0) 지움
- Store_Save: 기초(로직 파일) 받지 않음(400) · gone · labor_errors(whole) 갈래 걷음
- Store_Logic: 정본 파일에도 새 기초(그 파일 표 키 — 옛 /save 와 같음) · 지움 검사에 조합 · 지운 기초를 부르던 문서 더함(옛 422 그대로) · 쓰는 곳 409 는 Doc.remove 로(옛 자리)
- 시험(옛 /save 로 로직 줄 셈 칸 고침 · /logic 답 셈 칸을 붙든 것 = 죽은 길): 새 test_855_l3_doc_only(로직 파일 없음 + 같이 쓰기 끔 = 켬과 답 같음 · 목록 · 상세 · 저장 · 개정 409 · 판 409 · 별칭 · 신규 · 복사 · 삭제 · 기계 등록)
  · test_m01_cache 셈 칸 /save 검사 셋 · test_794_1 식 고침 /save 422 걷음(셈 칸 고침 = 문서 저장 몫 · /save 는 머리만 씀)
  · test_m01_make 「시험 계산에 돈다」 → 빈 문서로 열림 · test_m01_api · test_m01_text 옛 셈 길 시험은 로직 줄 사본에서 읽음
  · test_854_2_m01_key_book 대장 끊김 = 인력 줄 + 기초 문서 쓰기 · test_794_1b · test_804_7 판 = 문서 파일 · test_802_3 문서 없는 키 = 404(빈 문서 안 지음)
  · test_826_2 좁힌 검사 = 판정만 견줌(기초 흠 글이 문서 꼴) · 로직 갈래 셋 뺌 · test_m01_copy 옛 시트 길 걷고 master_copy 왕복만 · test_854_2_m01_copy_doc 식 복사 → 기본정보 고친 복사
  · test_713_1 · test_796_1 row_print 줄 뺌(row_print 지움)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 08:37:53 +09:00
co-authored by Claude Opus 5.5
parent b78e5f6786
commit 7e6190f8d3
21 changed files with 368 additions and 561 deletions
+7 -2
View File
@@ -422,8 +422,13 @@ def drop(key: str) -> None:
def remove(key: str, file: str, version: str, confirmed: bool) -> dict:
"""로직 지우기 — 기초 저장 길(`Store_Logic` — 쓰는 곳 409 · 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기)."""
from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 그 파일이 이 파일을 부름 — 늦게
"""로직 지우기 — 쓰는 곳 있으면 409 {쓰는곳} · 기초 저장 길(`Store_Logic` — 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기)."""
from M01_MasterData import (
M01_MasterData_Store_Logic as logic_store,
) # 그 파일이 이 파일을 부름 — 늦게
used = users(key)
if used:
raise store.StoreError(409, {"쓰는곳": used})
part = {"file": file, "version": version, "changes": [{"op": "delete", "key": key}]}
return logic_store.save([part], confirmed)
+35 -65
View File
@@ -67,17 +67,20 @@ def _stamps(folder: Path) -> dict[str, tuple]:
return out
def _logic_files(files: dict[str, dict]):
for name, data in files.items():
if data.get("그룹") == "로직":
yield name, data
def _doc_store():
from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 Store 를 부름 — 늦게
return doc_store
def docs() -> dict[str, dict]:
"""저장 수식 문서 전부 {키: 문서}(`M01_MasterData_Doc.docs` · 파일 시각이 같으면 같은 묶음)."""
from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 Store 를 부름 — 늦게
return _doc_store().docs()
return doc_store.docs()
def _logic_files():
"""단가산출 기초 = 수식 문서 파일(옛 로직 파일 이름 · `Doc.logic_files` · 855 L3 ⓐ)."""
return _doc_store().logic_files().items()
def reasons(key: str, whole) -> list[str]:
@@ -169,8 +172,8 @@ def loaded(folder: Path) -> tuple[dict[str, dict], object]:
def blocks(folder: Path) -> dict[str, list[str]]:
"""로직 키마다 막힘 까닭 — 미리 세어 둔 값. 요소 파일이 바뀌면 모든 로직을,
로직 파일은 바뀐 그 파일과 그 로직을 부르던 줄만 다시 셈."""
"""로직 키마다 막힘 까닭 — 미리 세어 둔 값(수식 문서 파일마다). 요소 파일이 바뀌면 흔들린 자리를 보던
기초만 · 수식 문서가 바뀌면 통째로 다시 셈."""
with _FRESH:
files, whole = loaded(folder)
stamps = _INDEX["자국"]
@@ -192,28 +195,16 @@ def blocks(folder: Path) -> dict[str, list[str]]:
_BASE.clear()
_BASE.update(base)
_MARKED.clear()
moved, fresh = set(), set() # 바뀐 로직 파일의 키(옛것 · 새것)
names = {name for name, _ in _logic_files(files)}
for gone in [name for name in _BLOCK if name not in names]: # 파일째 사라진 것
moved |= set(_BLOCK.pop(gone)[1])
for name, data in _logic_files(files):
if _BLOCK.get(name, (None,))[0] == stamps[name]:
continue
got = {str(r.get("키")): _check(whole, r) for r in data.get("줄") or []}
moved |= set(_BLOCK.get(name, (None, {}))[1]) | set(got)
_BLOCK[name] = (stamps[name], got)
fresh.add(name)
for name, data in _logic_files(files): # 그 로직을 부르던 줄 · 바뀐 요소를 보던 줄
if name in fresh:
for (
name,
data,
) in _logic_files(): # 문서가 그대로면 세어 둔 것 · 바뀐 요소를 보던 기초만 다시
if name not in _BLOCK:
_BLOCK[name] = (None, {str(r.get("키")): _check(whole, r) for r in data["줄"]})
continue
got = _BLOCK[name][1]
rows = {str(r.get("키")): r for r in data.get("줄") or []}
shaken = [
k
for k, (_, calls, seen) in got.items()
if calls & moved or (marks and seen & marks)
]
for key in shaken:
rows = {str(r.get("키")): r for r in data["줄"]}
for key in [k for k, (_, _c, seen) in got.items() if marks and seen & marks]:
got[key] = _check(whole, rows[key])
return {key: why for _, got in _BLOCK.values() for key, (why, *_) in got.items()}
@@ -230,47 +221,28 @@ def _rows_of(data: dict) -> list:
def narrow(folder: Path, batch: list[dict], before: dict, after: dict):
"""(검사할 로직 키, 안 보는 줄이 부르는 키, 요소도 고쳤는지) — 저장이 흔드는 줄만.
"""(검사할 로직 키, 로직마다 부르는 키, 흔들린 자리) — 저장이 흔드는 줄만.
로직 줄은 고친 줄과 **그 줄을 부르던 줄** · 요소·표 줄은 그 줄을 **보던 로직**
(키 · 「ID:원문번호」 · 자재품목은 묶음 통째 — `_check` 가 적어 둔 지도 · 855 2-B3 부터 수식 문서 연결).
요소·표 줄은 그 줄을 **보던 기초**(키 · 「ID:원문번호」 · 자재품목은 묶음 통째 — `_check` 가 적어 둔
수식 문서 연결 지도) · 기초(로직) 고침은 이 길로 안 옴(`Store_Logic` · 855 L3 ⓐ).
"""
counts = counted(folder)
calls = {key: got[1] for key, got in counts.items()}
touched, gone, marks = set(), set(), set()
marks = set()
for part in batch:
name = part["file"]
was, now = ({str(r.get("키")): r for r in _rows_of(side[name])} for side in (before, after))
keys = (set(now) - set(was)) | {
str(c.get("key")) for c in part.get("changes") or [] if c.get("op") != "add"
}
if after[name].get("그룹") == "로직":
touched |= keys
gone |= set(was) - set(now)
continue
for key in keys | (set(was) - set(now)): # 지운 줄도 — 가리키던 자리가 끊김
marks |= {key, "#" + key[:2]}
for side in (was, now):
number = (side.get(key) or {}).get("원문번호")
if number:
marks.add(f"{key[:2]}:{number}")
only = touched | {key for key, called in calls.items() if called & touched}
only |= {key for key, got in counts.items() if got[2] & marks}
return only, {key: called for key, called in calls.items() if key not in gone}, marks
def check_saved(files: dict, changed: list[str], book: dict, narrowed=None) -> list[str]:
"""저장 전 검사(M01) — 고친 파일의 틀 + 로직의 변수 · 키 + 조합.
`files` = 폴더 전부(고친 뒤) · `book` = 키 대장 · `narrowed` = `narrow` 가 준 좁힘
(None 이면 전부 검사 — 마스터 전체 검사는 `check_master` 몫).
"""
whole = cm.mf.Master(files)
out = [x for name in changed for x in cm.check_form(name, files[name])]
out += logic_errors(files, whole, book, narrowed and narrowed[:2])
if narrowed and narrowed[2]: # 요소·표를 고쳤으면 연결 · 준용도 봄(로직 좁힘과 따로)
out += cm.check_links(whole)
return out + combo_errors(files) + labor_errors(whole)
only = {key for key, got in counts.items() if got[2] & marks}
return only, calls, marks
_PICKS: contextvars.ContextVar[tuple | None] = contextvars.ContextVar("m01_picks", default=None)
@@ -286,11 +258,9 @@ def picks(add: dict, drop: set):
_PICKS.reset(token)
def _docs_of(files: dict) -> dict[str, dict]:
"""`files` 에 로직 줄이 있는 키의 수식 문서만 — 지운 로직은 문서가 아직 있어도 없는 것으로 ·
저장 중 기계 목록 고침(`picks`)은 사본에 얹음."""
keys = {str(r.get("키")) for _, data in _logic_files(files) for r in data.get("줄") or []}
out = {k: d for k, d in docs().items() if k in keys}
def _docs_of() -> dict[str, dict]:
"""수식 문서 전부(기초 정본 · 855 L3 ⓐ) — 저장 중 기계 목록 고침(`picks`)은 사본에 얹음."""
out = dict(docs())
if pending := _PICKS.get():
from M01_MasterData import (
M01_MasterData_Machine as machine,
@@ -304,17 +274,17 @@ def _docs_of(files: dict) -> dict[str, dict]:
def logic_errors(files: dict, whole, book: dict | None, narrow=None) -> list[str]:
"""저장 검사의 로직 몫 — 옛 로직 줄 검사(`check_master.check_logics` · 좁힌 줄 · 키 겹침 · 대장 ·
연결)가 먼저 · 그것이 깨끗하면 수식 문서 막힘(`narrow` 를 주면 그 키만 · 문서 없는 새 줄은 안 봄 ·
요소 닫힘 · 문서 사이 순환) — 같은 흠을 두 번 안 적음.
ponytail: 로직 줄 몫 = 옛 `check_logic` 남음(로직 JSON 이 아직 옛 엔진 길에 쓰임) · L3 에서 걷음."""
out = cm.check_logics(files, whole, book, narrow)
return out or mb.check_docs(_docs_of(files), narrow[0] if narrow else None, whole)
"""저장 검사의 기초 몫(855 L3 ⓐ — 수식 문서가 정본) — 키 겹침 · 대장(요소 파일 + 문서 키) ·
좁힘 없으면 연결 · 준용이 먼저 · 그것이 깨끗하면 수식 문서 막힘(`narrow` 를 주면 그 키만 · 요소 닫힘 ·
문서 사이 순환) — 같은 흠을 두 번 안 적음."""
view = {n: d for n, d in files.items() if d.get("그룹") != "로직"} | dict(_logic_files())
out = cm.duplicate_keys(view, book) + ([] if narrow else cm.check_links(whole))
return out or mb.check_docs(_docs_of(), narrow[0] if narrow else None, whole)
def combo_errors(files: dict) -> list[str]:
"""일위대가 조합 전부(옛 `master_combo.check_all` 대신) — 로직이 있는지는 수식 문서로."""
have = _docs_of(files)
have = _docs_of()
return [f"{name} · {x}" for name, row in cm.mcb.rows(files) for x in mb.combo_row(row, have)]
+46 -20
View File
@@ -3,7 +3,8 @@
화면 [저장](`/save` 의 로직 파일 몫) · [신규] · [본떠 만들기] · [복사/생성] · [삭제] · 별칭이 이 길로.
- 판 = 문서 파일 글 지문(`Doc.file_version`) — 다르면 409 {stale}
- 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`)
- 키 = 대장(`_키대장.json` · 자체 GX 다음 번호) · 검사 = 문서(쓰는 곳 · 일위대가 담은 로직 · 키 겹침 · 대장)
- 키 = 대장(`_키대장.json` · 그 파일 표 다음 번호 · 자체 GX) · 검사 = 문서(일위대가 · 사전조합 · 조합이 담은 기초 ·
키 겹침 · 대장) · 쓰는 곳 409 는 [삭제](`Doc.remove`)
- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`)
화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫.
"""
@@ -26,7 +27,12 @@ md, ml, mk, cm = doc_store.md, doc_store.ml, store.mk, store.cm
WRITE = os.environ.get("AISLO_LOGIC_WRITE", "1") != "0"
OWN = "로직_자체.json"
FIELDS = revise.FIELDS
CALC = {"입력": [], "중간": [], "호표": [], "끝수": None} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음)
CALC = {
"입력": [],
"중간": [],
"호표": [],
"끝수": None,
} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음)
def is_logic(file: str) -> bool:
@@ -71,7 +77,9 @@ def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]:
path = _doc_file(file)
if path.name not in plan:
plan[path.name] = (
copy.deepcopy(ml.load_file(path)) if path.is_file() else doc_store._new_file(path.name)
copy.deepcopy(ml.load_file(path))
if path.is_file()
else doc_store._new_file(path.name)
)
rows = _rows(plan[path.name])
for ch in part.get("changes") or []:
@@ -91,9 +99,8 @@ def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]:
rows[at] = doc_store._headed(rows[at], head(row))
edits.append(("머리", key, doc_store.head_of(rows[at])))
elif op == "add":
if file != OWN:
raise store.StoreError(400, f"새 기초는 {OWN} 에만")
tid = mk.table_id("로직", "자체")
where = doc_store.logic_files().get(file) or {"원문": "자체"}
tid = mk.table_id("로직", store._book(where))
number = str(row.get("원문번호") or "")
key = mk.issue(book, tid, store.ledger_label(book, tid, number, row), file)
source = str(ch.get("from") or "")
@@ -108,8 +115,14 @@ def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]:
return plan, edits, added, gone
def _combos(have: dict) -> list[str]:
"""일위대가 조합(실무문서)이 담은 기초가 문서에 없음 — `Store_Cache.combo_errors` 와 같은 글."""
rows = cm.mcb.rows(store.loaded()[0])
return [f"{n} · {x}" for n, row in rows for x in store.cache.mb.combo_row(row, have)]
def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]:
"""문서 검사 — 일위대가 · 사전조합이 담은 기초가 빠짐 · 키 겹침 · 대장(저장 전에 있던 흠은 뺌)."""
"""문서 검사 — 일위대가 · 사전조합 · 조합이 담은 기초가 빠짐 · 키 겹침 · 대장(저장 전에 있던 흠은 뺌)."""
have = dict(doc_store.logic_files())
after = dict(have)
for name, data in plan.items():
@@ -118,21 +131,21 @@ def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]:
keys = {str(d.get("키")) for f in after.values() for d in f["줄"]}
old = set(cm.duplicate_keys(have, old_book))
out = [x for x in cm.duplicate_keys(after, book) if x not in old]
if gone:
docs = {k: d for k, d in doc_store.docs().items() if k not in gone}
docs |= {str(d.get("키")): d for data in plan.values() for d in data.get("줄") or []}
was = set(_combos(doc_store.docs()))
out += [x for x in _combos(docs) if x not in was]
mb, whole = store.cache.mb, store.loaded()[1] # 지운 기초를 부르던 문서
if callers := {k for k, d in docs.items() if mb.calls(d) & gone}:
was = set(mb.check_docs(doc_store.docs(), callers, whole))
out += [x for x in mb.check_docs(docs, callers, whole) if x not in was]
return out + store.cache.labor_errors(None, gone, keys)
def save(parts: list[dict], confirmed: bool = False) -> dict:
"""로직 파일 몫 저장 — {files: [{file, version}], added: [{file, key}], warnings}."""
revise.guard(parts, confirmed)
gone_used = {
k: used
for p in parts
for c in p.get("changes") or []
if c.get("op") == "delete" and (k := str(c.get("key") or ""))
and (used := doc_store.users(k))
}
if gone_used:
raise store.StoreError(409, {"쓰는곳": [x for v in gone_used.values() for x in v]})
with doc_store._LOCK:
stale = [
str(p.get("file")) for p in parts
@@ -202,7 +215,12 @@ def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None:
if op == "더함":
name = what["file"]
if name not in after: # 자체 로직 파일이 없으면 머리만 두고 만듦
after[name] = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []}
after[name] = {
"그룹": "로직",
"원문": "자체",
"판": str(kst_today().year),
"줄": [],
}
src = next((r for r in logic.get(where.get(what["from"], ""), {}).get("줄") or []
if str(r.get("키")) == what["from"]), None) # fmt: skip
calc = {k: copy.deepcopy(v) for k, v in (src or CALC).items() if k not in FIELDS}
@@ -230,12 +248,17 @@ def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None:
def _ordered(row: dict) -> dict:
"""새 로직 줄 칸 차례 — `_틀.md` 2장(`mk.ROW_ORDER`) 다음 나머지."""
order = mk.ROW_ORDER["로직"]
return {**{k: row[k] for k in order if k in row}, **{k: v for k, v in row.items() if k not in order}}
return {
**{k: row[k] for k in order if k in row},
**{k: v for k, v in row.items() if k not in order},
}
def _headed_row(row: dict, head_: dict) -> dict:
"""로직 줄 머리를 문서 머리와 같게 — 있던 칸은 제자리 · 빠진 머리 칸은 뺌 · 새 칸은 끝(옛 [저장]과 같음)."""
out = {k: head_[k] if k in FIELDS else v for k, v in row.items() if k not in FIELDS or k in head_}
out = {
k: head_[k] if k in FIELDS else v for k, v in row.items() if k not in FIELDS or k in head_
}
return {**out, **{k: v for k, v in head_.items() if k not in out}}
@@ -246,7 +269,10 @@ def _picks(after: dict, add: dict, drop: set) -> set[str]:
if "건설기계" not in name:
continue
for at, row in enumerate(data["줄"]):
pick = next((i for i in row.get("입력") or [] if i.get("이름") == "기계" and "고르기" in i), None)
pick = next(
(i for i in row.get("입력") or [] if i.get("이름") == "기계" and "고르기" in i),
None,
)
if pick is None:
continue
codes = [c for c in pick["고르기"] if str(c) not in drop]
+14 -3
View File
@@ -226,7 +226,11 @@ def save(batch: list[dict], confirmed: bool = False) -> dict:
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")):
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:
@@ -234,11 +238,18 @@ def save(batch: list[dict], confirmed: bool = False) -> dict:
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만 키 — 목록 찾기 금지
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]
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"]
@@ -50,7 +50,12 @@ def changed(batch: list[dict]) -> list[dict]:
for ch in part.get("changes") or []:
op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row")
old = have.get(key)
if op == "edit" and old is not None and isinstance(row, dict) and _head(row) == _head(old):
if (
op == "edit"
and old is not None
and isinstance(row, dict)
and _head(row) == _head(old)
):
continue
name = row.get("이름") if isinstance(row, dict) else None
out.append(
+14 -11
View File
@@ -2,8 +2,8 @@
전 = 기억(`Store_Cache.loaded`) · 후 = 고친 파일만 얕은 사본(줄 목록만 새로 · 줄은 바꿔 끼움만) —
폴더를 다시 읽지 않음. 검사 = 저장이 흔드는 것만: 로직은 `Store_Cache.narrow` · 틀은 고친 줄만 ·
연결 · 준용은 요소를 고쳤을 때 · 조합은 조합 파일을 고쳤거나 로직 줄이 빠질 때 · 일위대가 · 사전조합
문서(모든 층 파일)는 로직 줄이 빠질 때 그 키만 · 키 겹침 · 대장 대조 · 돌고 도는 참조는 전체(가벼움).
연결 · 준용은 요소를 고쳤을 때 · 조합은 조합 파일을 고쳤을 때 · 키 겹침 · 대장 대조 ·
돌고 도는 참조는 전체(가벼움) · 기초(로직) 저장은 `Store_Logic`(855 L3 ⓐ).
전 검사는 기억 색인(재료 고르기 찾기 기억이 데워져 있음) · 후 색인은 그 기억을 이어받음
(자재품목 줄이 바뀌면 그 줄이 걸리는 찾기만 버림). 저장 뒤 = 쓴 파일만 기억에 갈아 끼움.
"""
@@ -65,17 +65,20 @@ def _index(files: dict, whole, moved: list[dict]):
return out
def _errors(files, whole, names, book, narrowed, keys, gone) -> list[str]:
def _errors(files, whole, names, book, narrowed, keys) -> list[str]:
out = [x for name in names for x in cm.check_form(name, _only(name, files[name], keys[name]))]
out += cache.logic_errors(files, whole, book, narrowed[:2]) # 수식 문서 기준(855 2-B3)
if narrowed[2]: # 요소·표를 고쳤으면 연결 · 준용도 봄(로직 좁힘과 따로)
out += cm.check_links(whole)
if cm.mcb.FILE in names or gone:
if cm.mcb.FILE in names:
out += cache.combo_errors(files)
return out
def save(batch: list[dict]) -> list[dict]:
"""요소 · 표 파일 저장 — 단가산출 기초(로직 파일 몫)는 받지 않음(`Store_Logic` · 855 L3 ⓐ)."""
if bad := [p.get("file") for p in batch if _logic_file(p.get("file", ""))]:
raise store.StoreError(400, f"기초는 기초 저장 길로 — {', '.join(bad)}")
with store._LOCK:
stale = [
p.get("file", "") for p in batch if store.version(p.get("file", "")) != p.get("version")
@@ -92,7 +95,7 @@ def save(batch: list[dict]) -> list[dict]:
for part in batch:
store._apply(after[part["file"]], part.get("changes") or [], part["file"], book)
mk.finish(book)
keys, gone, moved = {}, set(), []
keys, moved = {}, []
for name in names:
was, now = _rows(before[name]), _rows(after[name])
keys[name] = set(now) - set(was)
@@ -103,17 +106,13 @@ def save(batch: list[dict]) -> list[dict]:
for c in p.get("changes") or []
if c.get("op") != "add"
}
if after[name].get("그룹") == "로직":
gone |= set(was) - set(now)
moved += [s[k] for k in keys[name] for s in (was, now) if k[:2] == "MT" and k in s]
# 저장이 흔드는 줄만 검사(고친 줄 · 그 줄을 부르던 줄 · 그 요소를 보던 줄) —
# 마스터 전체 검사는 `check_master` 몫
narrowed = cache.narrow(store.FOLDER, batch, before, after)
old = set(_errors(before, whole, names, old_book, narrowed, keys, gone))
old = set(_errors(before, whole, names, old_book, narrowed, keys))
fresh = _index(after, whole, moved)
new = _errors(after, fresh, names, book, narrowed, keys, gone)
# 일위대가 · 사전조합 문서가 담은 로직이 빠짐 — 빠지기 전엔 있던 키라 전 검사는 없음
new = [x for x in new + cache.labor_errors(fresh, gone) if x not in old]
new = [x for x in _errors(after, fresh, names, book, narrowed, keys) if x not in old]
if new:
raise store.StoreError(422, {"errors": new})
# 대장(원자적) → 파일 · 중간에 끊기면 쓴 것 모두 저장 전으로(대장만 · 파일만 앞서가지 않게)
@@ -135,6 +134,10 @@ def save(batch: list[dict]) -> list[dict]:
return out
def _logic_file(name: str) -> bool:
return name.startswith("로직_") and name.endswith(".json")
def _machine(name: str) -> bool:
return name == mmf.NAME and mmf.here(store.FOLDER) # 기계 = 폴더(826-2)