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: def remove(key: str, file: str, version: str, confirmed: bool) -> dict:
"""로직 지우기 — 기초 저장 길(`Store_Logic` — 쓰는 곳 409 · 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기).""" """로직 지우기 — 쓰는 곳 있으면 409 {쓰는곳} · 기초 저장 길(`Store_Logic` — 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기)."""
from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 그 파일이 이 파일을 부름 — 늦게 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}]} part = {"file": file, "version": version, "changes": [{"op": "delete", "key": key}]}
return logic_store.save([part], confirmed) return logic_store.save([part], confirmed)
+35 -65
View File
@@ -67,17 +67,20 @@ def _stamps(folder: Path) -> dict[str, tuple]:
return out return out
def _logic_files(files: dict[str, dict]): def _doc_store():
for name, data in files.items(): from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 Store 를 부름 — 늦게
if data.get("그룹") == "로직":
yield name, data return doc_store
def docs() -> dict[str, dict]: def docs() -> dict[str, dict]:
"""저장 수식 문서 전부 {키: 문서}(`M01_MasterData_Doc.docs` · 파일 시각이 같으면 같은 묶음).""" """저장 수식 문서 전부 {키: 문서}(`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]: 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]]: def blocks(folder: Path) -> dict[str, list[str]]:
"""로직 키마다 막힘 까닭 — 미리 세어 둔 값. 요소 파일이 바뀌면 모든 로직을, """로직 키마다 막힘 까닭 — 미리 세어 둔 값(수식 문서 파일마다). 요소 파일이 바뀌면 흔들린 자리를 보던
로직 파일은 바뀐 그 파일과 그 로직을 부르던 줄만 다시 셈.""" 기초만 · 수식 문서가 바뀌면 통째로 다시 셈."""
with _FRESH: with _FRESH:
files, whole = loaded(folder) files, whole = loaded(folder)
stamps = _INDEX["자국"] stamps = _INDEX["자국"]
@@ -192,28 +195,16 @@ def blocks(folder: Path) -> dict[str, list[str]]:
_BASE.clear() _BASE.clear()
_BASE.update(base) _BASE.update(base)
_MARKED.clear() _MARKED.clear()
moved, fresh = set(), set() # 바뀐 로직 파일의 키(옛것 · 새것) for (
names = {name for name, _ in _logic_files(files)} name,
for gone in [name for name in _BLOCK if name not in names]: # 파일째 사라진 것 data,
moved |= set(_BLOCK.pop(gone)[1]) ) in _logic_files(): # 문서가 그대로면 세어 둔 것 · 바뀐 요소를 보던 기초만 다시
for name, data in _logic_files(files): if name not in _BLOCK:
if _BLOCK.get(name, (None,))[0] == stamps[name]: _BLOCK[name] = (None, {str(r.get("키")): _check(whole, r) for r in data["줄"]})
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:
continue continue
got = _BLOCK[name][1] got = _BLOCK[name][1]
rows = {str(r.get("키")): r for r in data.get("줄") or []} rows = {str(r.get("키")): r for r in data["줄"]}
shaken = [ for key in [k for k, (_, _c, seen) in got.items() if marks and seen & marks]:
k
for k, (_, calls, seen) in got.items()
if calls & moved or (marks and seen & marks)
]
for key in shaken:
got[key] = _check(whole, rows[key]) got[key] = _check(whole, rows[key])
return {key: why for _, got in _BLOCK.values() for key, (why, *_) in got.items()} 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): def narrow(folder: Path, batch: list[dict], before: dict, after: dict):
"""(검사할 로직 키, 안 보는 줄이 부르는 키, 요소도 고쳤는지) — 저장이 흔드는 줄만. """(검사할 로직 키, 로직마다 부르는 키, 흔들린 자리) — 저장이 흔드는 줄만.
로직 줄은 고친 줄과 **그 줄을 부르던 줄** · 요소·표 줄은 그 줄을 **보던 로직** 요소·표 줄은 그 줄을 **보던 기초**(키 · 「ID:원문번호」 · 자재품목은 묶음 통째 — `_check` 가 적어 둔
(키 · 「ID:원문번호」 · 자재품목은 묶음 통째 — `_check` 가 적어 둔 지도 · 855 2-B3 부터 수식 문서 연결). 수식 문서 연결 지도) · 기초(로직) 고침은 이 길로 안 옴(`Store_Logic` · 855 L3 ⓐ).
""" """
counts = counted(folder) counts = counted(folder)
calls = {key: got[1] for key, got in counts.items()} calls = {key: got[1] for key, got in counts.items()}
touched, gone, marks = set(), set(), set() marks = set()
for part in batch: for part in batch:
name = part["file"] name = part["file"]
was, now = ({str(r.get("키")): r for r in _rows_of(side[name])} for side in (before, after)) was, now = ({str(r.get("키")): r for r in _rows_of(side[name])} for side in (before, after))
keys = (set(now) - set(was)) | { keys = (set(now) - set(was)) | {
str(c.get("key")) for c in part.get("changes") or [] if c.get("op") != "add" 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)): # 지운 줄도 — 가리키던 자리가 끊김 for key in keys | (set(was) - set(now)): # 지운 줄도 — 가리키던 자리가 끊김
marks |= {key, "#" + key[:2]} marks |= {key, "#" + key[:2]}
for side in (was, now): for side in (was, now):
number = (side.get(key) or {}).get("원문번호") number = (side.get(key) or {}).get("원문번호")
if number: if number:
marks.add(f"{key[:2]}:{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}
only |= {key for key, got in counts.items() if got[2] & marks} return only, calls, 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)
_PICKS: contextvars.ContextVar[tuple | None] = contextvars.ContextVar("m01_picks", default=None) _PICKS: contextvars.ContextVar[tuple | None] = contextvars.ContextVar("m01_picks", default=None)
@@ -286,11 +258,9 @@ def picks(add: dict, drop: set):
_PICKS.reset(token) _PICKS.reset(token)
def _docs_of(files: dict) -> dict[str, dict]: def _docs_of() -> dict[str, dict]:
"""`files` 에 로직 줄이 있는 키의 수식 문서만 — 지운 로직은 문서가 아직 있어도 없는 것으로 · """수식 문서 전부(기초 정본 · 855 L3 ⓐ) — 저장 중 기계 목록 고침(`picks`)은 사본에 얹음."""
저장 중 기계 목록 고침(`picks`)은 사본에 얹음.""" out = dict(docs())
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}
if pending := _PICKS.get(): if pending := _PICKS.get():
from M01_MasterData import ( from M01_MasterData import (
M01_MasterData_Machine as machine, 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]: def logic_errors(files: dict, whole, book: dict | None, narrow=None) -> list[str]:
"""저장 검사의 로직 몫 — 옛 로직 줄 검사(`check_master.check_logics` · 좁힌 줄 · 키 겹침 · 대장 · """저장 검사의 기초 몫(855 L3 ⓐ — 수식 문서가 정본) — 키 겹침 · 대장(요소 파일 + 문서 키) ·
연결)가 먼저 · 그것이 깨끗하면 수식 문서 막힘(`narrow` 를 주면 그 키만 · 문서 없는 새 줄은 안 봄 · 좁힘 없으면 연결 · 준용이 먼저 · 그것이 깨끗하면 수식 문서 막힘(`narrow` 를 주면 그 키만 · 요소 닫힘 ·
요소 닫힘 · 문서 사이 순환) — 같은 흠을 두 번 안 적음. 문서 사이 순환) — 같은 흠을 두 번 안 적음."""
ponytail: 로직 줄 몫 = 옛 `check_logic` 남음(로직 JSON 이 아직 옛 엔진 길에 쓰임) · L3 에서 걷음.""" view = {n: d for n, d in files.items() if d.get("그룹") != "로직"} | dict(_logic_files())
out = cm.check_logics(files, whole, book, narrow) out = cm.duplicate_keys(view, book) + ([] if narrow else cm.check_links(whole))
return out or mb.check_docs(_docs_of(files), narrow[0] if narrow else None, whole) return out or mb.check_docs(_docs_of(), narrow[0] if narrow else None, whole)
def combo_errors(files: dict) -> list[str]: def combo_errors(files: dict) -> list[str]:
"""일위대가 조합 전부(옛 `master_combo.check_all` 대신) — 로직이 있는지는 수식 문서로.""" """일위대가 조합 전부(옛 `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)] 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` 의 로직 파일 몫) · [신규] · [본떠 만들기] · [복사/생성] · [삭제] · 별칭이 이 길로. 화면 [저장](`/save` 의 로직 파일 몫) · [신규] · [본떠 만들기] · [복사/생성] · [삭제] · 별칭이 이 길로.
- 판 = 문서 파일 글 지문(`Doc.file_version`) — 다르면 409 {stale} - 판 = 문서 파일 글 지문(`Doc.file_version`) — 다르면 409 {stale}
- 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`) - 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`)
- 키 = 대장(`_키대장.json` · 자체 GX 다음 번호) · 검사 = 문서(쓰는 곳 · 일위대가 담은 로직 · 키 겹침 · 대장) - 키 = 대장(`_키대장.json` · 그 파일 표 다음 번호 · 자체 GX) · 검사 = 문서(일위대가 · 사전조합 · 조합이 담은 기초 ·
키 겹침 · 대장) · 쓰는 곳 409 는 [삭제](`Doc.remove`)
- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`) - 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`)
화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫. 화면이 보낸 줄은 이름표(`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" WRITE = os.environ.get("AISLO_LOGIC_WRITE", "1") != "0"
OWN = "로직_자체.json" OWN = "로직_자체.json"
FIELDS = revise.FIELDS FIELDS = revise.FIELDS
CALC = {"입력": [], "중간": [], "호표": [], "끝수": None} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음) CALC = {
"입력": [],
"중간": [],
"호표": [],
"끝수": None,
} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음)
def is_logic(file: str) -> bool: 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) path = _doc_file(file)
if path.name not in plan: if path.name not in plan:
plan[path.name] = ( 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]) rows = _rows(plan[path.name])
for ch in part.get("changes") or []: 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)) rows[at] = doc_store._headed(rows[at], head(row))
edits.append(("머리", key, doc_store.head_of(rows[at]))) edits.append(("머리", key, doc_store.head_of(rows[at])))
elif op == "add": elif op == "add":
if file != OWN: where = doc_store.logic_files().get(file) or {"원문": "자체"}
raise store.StoreError(400, f"새 기초는 {OWN} 에만") tid = mk.table_id("로직", store._book(where))
tid = mk.table_id("로직", "자체")
number = str(row.get("원문번호") or "") number = str(row.get("원문번호") or "")
key = mk.issue(book, tid, store.ledger_label(book, tid, number, row), file) key = mk.issue(book, tid, store.ledger_label(book, tid, number, row), file)
source = str(ch.get("from") or "") 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 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]: def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]:
"""문서 검사 — 일위대가 · 사전조합이 담은 기초가 빠짐 · 키 겹침 · 대장(저장 전에 있던 흠은 뺌).""" """문서 검사 — 일위대가 · 사전조합 · 조합이 담은 기초가 빠짐 · 키 겹침 · 대장(저장 전에 있던 흠은 뺌)."""
have = dict(doc_store.logic_files()) have = dict(doc_store.logic_files())
after = dict(have) after = dict(have)
for name, data in plan.items(): 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["줄"]} keys = {str(d.get("키")) for f in after.values() for d in f["줄"]}
old = set(cm.duplicate_keys(have, old_book)) old = set(cm.duplicate_keys(have, old_book))
out = [x for x in cm.duplicate_keys(after, book) if x not in old] 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) return out + store.cache.labor_errors(None, gone, keys)
def save(parts: list[dict], confirmed: bool = False) -> dict: def save(parts: list[dict], confirmed: bool = False) -> dict:
"""로직 파일 몫 저장 — {files: [{file, version}], added: [{file, key}], warnings}.""" """로직 파일 몫 저장 — {files: [{file, version}], added: [{file, key}], warnings}."""
revise.guard(parts, confirmed) 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: with doc_store._LOCK:
stale = [ stale = [
str(p.get("file")) for p in parts 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 == "더함": if op == "더함":
name = what["file"] name = what["file"]
if name not in after: # 자체 로직 파일이 없으면 머리만 두고 만듦 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 [] src = next((r for r in logic.get(where.get(what["from"], ""), {}).get("줄") or []
if str(r.get("키")) == what["from"]), None) # fmt: skip 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} 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: def _ordered(row: dict) -> dict:
"""새 로직 줄 칸 차례 — `_틀.md` 2장(`mk.ROW_ORDER`) 다음 나머지.""" """새 로직 줄 칸 차례 — `_틀.md` 2장(`mk.ROW_ORDER`) 다음 나머지."""
order = 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: 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}} 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: if "건설기계" not in name:
continue continue
for at, row in enumerate(data["줄"]): 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: if pick is None:
continue continue
codes = [c for c in pick["고르기"] if str(c) not in drop] 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 part in logic:
for ch in part.get("changes") or []: for ch in part.get("changes") or []:
row = ch.get("row") 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]))) ch.update(op="add", key=None, row=_clean(row, str(row.get("소유") or OWNERS[0])))
files, added = [], [] files, added = [], []
if rest: if rest:
@@ -234,11 +238,18 @@ def save(batch: list[dict], confirmed: bool = False) -> dict:
machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2) machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2)
_keep_same(part) _keep_same(part)
docs_too = machine.register(rest) # [새 기계] = 꼴 식 목록 등록(822-2 · 848-5 문서 정본) 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()))): with store.cache.picks(*getattr(docs_too, "lists", ({}, set()))):
files = store.save(rest) files = store.save(rest)
docs_too() 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: if logic:
got = logic_store.save(logic, True) got = logic_store.save(logic, True)
files, added = files + got["files"], added + got["added"] 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 []: for ch in part.get("changes") or []:
op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row") op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row")
old = have.get(key) 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 continue
name = row.get("이름") if isinstance(row, dict) else None name = row.get("이름") if isinstance(row, dict) else None
out.append( out.append(
+14 -11
View File
@@ -2,8 +2,8 @@
전 = 기억(`Store_Cache.loaded`) · 후 = 고친 파일만 얕은 사본(줄 목록만 새로 · 줄은 바꿔 끼움만) — 전 = 기억(`Store_Cache.loaded`) · 후 = 고친 파일만 얕은 사본(줄 목록만 새로 · 줄은 바꿔 끼움만) —
폴더를 다시 읽지 않음. 검사 = 저장이 흔드는 것만: 로직은 `Store_Cache.narrow` · 틀은 고친 줄만 · 폴더를 다시 읽지 않음. 검사 = 저장이 흔드는 것만: 로직은 `Store_Cache.narrow` · 틀은 고친 줄만 ·
연결 · 준용은 요소를 고쳤을 때 · 조합은 조합 파일을 고쳤거나 로직 줄이 빠질 때 · 일위대가 · 사전조합 연결 · 준용은 요소를 고쳤을 때 · 조합은 조합 파일을 고쳤을 때 · 키 겹침 · 대장 대조 ·
문서(모든 층 파일)는 로직 줄이 빠질 때 그 키만 · 키 겹침 · 대장 대조 · 돌고 도는 참조는 전체(가벼움). 돌고 도는 참조는 전체(가벼움) · 기초(로직) 저장은 `Store_Logic`(855 L3 ⓐ).
전 검사는 기억 색인(재료 고르기 찾기 기억이 데워져 있음) · 후 색인은 그 기억을 이어받음 전 검사는 기억 색인(재료 고르기 찾기 기억이 데워져 있음) · 후 색인은 그 기억을 이어받음
(자재품목 줄이 바뀌면 그 줄이 걸리는 찾기만 버림). 저장 뒤 = 쓴 파일만 기억에 갈아 끼움. (자재품목 줄이 바뀌면 그 줄이 걸리는 찾기만 버림). 저장 뒤 = 쓴 파일만 기억에 갈아 끼움.
""" """
@@ -65,17 +65,20 @@ def _index(files: dict, whole, moved: list[dict]):
return out 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 = [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) out += cache.logic_errors(files, whole, book, narrowed[:2]) # 수식 문서 기준(855 2-B3)
if narrowed[2]: # 요소·표를 고쳤으면 연결 · 준용도 봄(로직 좁힘과 따로) if narrowed[2]: # 요소·표를 고쳤으면 연결 · 준용도 봄(로직 좁힘과 따로)
out += cm.check_links(whole) out += cm.check_links(whole)
if cm.mcb.FILE in names or gone: if cm.mcb.FILE in names:
out += cache.combo_errors(files) out += cache.combo_errors(files)
return out return out
def save(batch: list[dict]) -> list[dict]: 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: with store._LOCK:
stale = [ stale = [
p.get("file", "") for p in batch if store.version(p.get("file", "")) != p.get("version") 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: for part in batch:
store._apply(after[part["file"]], part.get("changes") or [], part["file"], book) store._apply(after[part["file"]], part.get("changes") or [], part["file"], book)
mk.finish(book) mk.finish(book)
keys, gone, moved = {}, set(), [] keys, moved = {}, []
for name in names: for name in names:
was, now = _rows(before[name]), _rows(after[name]) was, now = _rows(before[name]), _rows(after[name])
keys[name] = set(now) - set(was) keys[name] = set(now) - set(was)
@@ -103,17 +106,13 @@ def save(batch: list[dict]) -> list[dict]:
for c in p.get("changes") or [] for c in p.get("changes") or []
if c.get("op") != "add" 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] moved += [s[k] for k in keys[name] for s in (was, now) if k[:2] == "MT" and k in s]
# 저장이 흔드는 줄만 검사(고친 줄 · 그 줄을 부르던 줄 · 그 요소를 보던 줄) — # 저장이 흔드는 줄만 검사(고친 줄 · 그 줄을 부르던 줄 · 그 요소를 보던 줄) —
# 마스터 전체 검사는 `check_master` 몫 # 마스터 전체 검사는 `check_master` 몫
narrowed = cache.narrow(store.FOLDER, batch, before, after) 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) fresh = _index(after, whole, moved)
new = _errors(after, fresh, names, book, narrowed, keys, gone) new = [x for x in _errors(after, fresh, names, book, narrowed, keys) if x not in old]
# 일위대가 · 사전조합 문서가 담은 로직이 빠짐 — 빠지기 전엔 있던 키라 전 검사는 없음
new = [x for x in new + cache.labor_errors(fresh, gone) if x not in old]
if new: if new:
raise store.StoreError(422, {"errors": new}) raise store.StoreError(422, {"errors": new})
# 대장(원자적) → 파일 · 중간에 끊기면 쓴 것 모두 저장 전으로(대장만 · 파일만 앞서가지 않게) # 대장(원자적) → 파일 · 중간에 끊기면 쓴 것 모두 저장 전으로(대장만 · 파일만 앞서가지 않게)
@@ -135,6 +134,10 @@ def save(batch: list[dict]) -> list[dict]:
return out return out
def _logic_file(name: str) -> bool:
return name.startswith("로직_") and name.endswith(".json")
def _machine(name: str) -> bool: def _machine(name: str) -> bool:
return name == mmf.NAME and mmf.here(store.FOLDER) # 기계 = 폴더(826-2) return name == mmf.NAME and mmf.here(store.FOLDER) # 기계 = 폴더(826-2)
+2 -7
View File
@@ -1,11 +1,9 @@
"""713-1 지킴 — 로직 정본 줄 고침 · 지우기 · 더하기는 「원문 개정 반영」 확인(`개정확인`) 없이는 409 · """713-1 지킴 — 로직 정본 줄 고침 · 지우기 · 더하기는 「원문 개정 반영」 확인(`개정확인`) 없이는 409 ·
요소 · 같은 줄 다시 보냄은 그대로 · 줄 바탕 지문(`Store_Revise.row_print`). 임시 사본 폴더만 씀.""" 요소 · 같은 줄 다시 보냄은 그대로 · 대조 = 문서 머리(855 L3 ⓐ). 임시 사본 폴더만 씀."""
from __future__ import annotations from __future__ import annotations
import shutil import shutil
from decimal import Decimal
from pathlib import Path
import pytest import pytest
from fastapi import FastAPI from fastapi import FastAPI
@@ -103,9 +101,6 @@ def test_요소_파일은_대상_밖(client: TestClient) -> None:
assert client.post("/api/m01/save", json={"files": [part]}).status_code == 200 assert client.post("/api/m01/save", json={"files": [part]}).status_code == 200
def test_지문_수_꼴_같음() -> None: def test_정본_파일_가름() -> None:
a = {"이름": "가", "호표": [{"수량": Decimal("10.0")}], "끝수": 1}
b = {"이름": "나", "호표": [{"수량": 10}], "끝수": 1.0, "별칭": "x"}
assert revise.row_print(a) == revise.row_print(b)
assert revise.is_canon("로직_산림품셈_09장_토공.json") assert revise.is_canon("로직_산림품셈_09장_토공.json")
assert not revise.is_canon("로직_자체.json") and not revise.is_canon("인력.json") assert not revise.is_canon("로직_자체.json") and not revise.is_canon("인력.json")
+2 -51
View File
@@ -1,14 +1,12 @@
# ruff: noqa: E501 # ruff: noqa: E501
"""794-1 M01 로직 줄 식 고침 저장 — `/save`(개정 확인) 뒤 다시 셈 · 틀린 식 422 · 시스템 관리자만. """794-1 M01 저장 길 — 시스템 관리자만(로직 줄 식 고침 `/save` 시험은 855 L3 ⓐ 에서 걷음 — /save 는 기초 머리만 씀 · 셈 = 문서 저장).
- 시트 서버 길(`/logic/sheet` · `/check`)은 화면 0 이라 853-1 에 걷음 — 남은 것은 살아 있는 `/save` · `/calc` - 시트 서버 길(`/logic/sheet` · `/check`)은 화면 0 이라 853-1 에 걷음 — 남은 것은 살아 있는 `/save` · `/calc`
- 서버(사본 폴더): 공구손료 식 1 → 2 % 저장(개정 확인 409 → 200) 뒤 셈 51,802 · 틀린 식 저장 422 · 시스템 관리자가 아니면 403 - 서버(사본 폴더): 시스템 관리자가 아니면 403
""" """
from __future__ import annotations from __future__ import annotations
import copy
import hashlib
import shutil import shutil
from pathlib import Path from pathlib import Path
@@ -19,18 +17,8 @@ from fastapi.testclient import TestClient
from common_util.common_util_auth import require_system_admin, verify_session from common_util.common_util_auth import require_system_admin, verify_session
from M01_MasterData import M01_MasterData_Router as m01_router from M01_MasterData import M01_MasterData_Router as m01_router
from M01_MasterData import M01_MasterData_Store as store from M01_MasterData import M01_MasterData_Store as store
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
REAL = store.FOLDER REAL = store.FOLDER
KEY = "GC000211" # 합판거푸집 설치 및 해체
INPUTS = {"자재지역": "포항", "유형": "보통", "사용횟수": "6회", "높이감률": 0, "지붕슬래브": "아님",
"폼타이": "아님", "폼타이규격": "12.7㎜", "측압": "3t/㎡", "구멍땜": 0} # fmt: skip
TOOL_1 = "(형틀목공 * LB000007 + 보통인부 * LB000002) * 1 / 100" # 덧줄 첫 줄 엔진 식
TOOL_2 = TOOL_1.replace("* 1 / 100", "* 2 / 100")
def _hashes(folder: Path) -> dict[str, str]:
return {p.name: hashlib.md5(p.read_bytes()).hexdigest() for p in sorted(folder.glob("*.json"))}
# ── 서버 ───────────────────────────────────────────────────────────── # ── 서버 ─────────────────────────────────────────────────────────────
@@ -45,43 +33,6 @@ def folder(tmp_path: Path, monkeypatch) -> Path:
return master return master
@pytest.fixture
def client(folder: Path) -> TestClient:
app = FastAPI()
app.include_router(m01_router.router)
app.include_router(old_engine.router)
return TestClient(app)
def _post(client: TestClient, url: str, body: dict, want: int = 200) -> dict:
res = client.post(url, json=body)
assert res.status_code == want, res.text
return res.json()
def test_저장_길_개정_확인_다시_셈_틀린_식_422(client: TestClient, folder: Path) -> None:
real = _hashes(REAL)
one = client.get("/api/m01/logic", params={"key": KEY}).json()
row = copy.deepcopy(one["logic"])
assert row["덧줄"][0]["식"] == TOOL_1
row["덧줄"][0]["식"] = TOOL_2
body = {"files": [{"file": one["file"], "version": one["version"],
"changes": [{"op": "edit", "key": KEY, "row": row}]}]} # fmt: skip
assert client.post("/api/m01/save", json=body).status_code == 409 # 정본 = 개정 확인
_post(client, "/api/m01/save", {**body, "개정확인": True})
saved = client.get("/api/m01/logic", params={"key": KEY}).json()
assert saved["logic"]["덧줄"][0]["식"] == TOOL_2
sums = _post(client, "/api/m01/calc", {"key": KEY, "inputs": INPUTS})["sums"]
assert sums["계"] == 51802 and sums["경비"] == 765 # _분석_650-H2 4 장 공구손료 2 %
bad = copy.deepcopy(saved["logic"])
bad["덧줄"][0]["식"] = "형틀목공 * 없는이름"
body = {"files": [{"file": saved["file"], "version": saved["version"],
"changes": [{"op": "edit", "key": KEY, "row": bad}]}], "개정확인": True} # fmt: skip
before = _hashes(folder)
assert client.post("/api/m01/save", json=body).status_code == 422
assert _hashes(folder) == before and _hashes(REAL) == real
def test_시스템_관리자가_아니면_403(folder: Path) -> None: def test_시스템_관리자가_아니면_403(folder: Path) -> None:
app = FastAPI() app = FastAPI()
app.include_router( app.include_router(
+5 -1
View File
@@ -47,7 +47,11 @@ def test_흐름_길은_없고_표준_표는_남음(client: TestClient) -> None:
def test_신규_로직은_시트_줄로_자체_GX(client: TestClient) -> None: def test_신규_로직은_시트_줄로_자체_GX(client: TestClient) -> None:
version = store.read(OWN)[1] if (store.FOLDER / OWN).is_file() else "" version = next(
f["version"]
for f in client.get("/api/m01/groups/로직/files").json()["files"]
if f["file"] == OWN
) # 판 = 문서 파일(855 L3 ⓐ)
row = { row = {
"키": "", "키": "",
"이름": "sub3임시 새 로직", "이름": "sub3임시 새 로직",
@@ -25,7 +25,6 @@ mf = importlib.import_module("master_formula")
mcut = importlib.import_module("master_cut") mcut = importlib.import_module("master_cut")
meq = importlib.import_module("master_equation") meq = importlib.import_module("master_equation")
me = importlib.import_module("master_equation_edit") me = importlib.import_module("master_equation_edit")
revise = importlib.import_module("M01_MasterData.M01_MasterData_Store_Revise")
REAL = store.FOLDER REAL = store.FOLDER
EXCAVATOR, AFRAME, FORM = "GF000089", "GC001140", "GC000211" EXCAVATOR, AFRAME, FORM = "GF000089", "GC001140", "GC000211"
@@ -188,7 +187,6 @@ def test_변수표_칸은_셈_안_바꿈():
row = dict(whole().logic(AFRAME)) row = dict(whole().logic(AFRAME))
row[meq.FIELD] = {"일운반회수": {"기호": "n", "아래": "d", "이름": "하루 운반 횟수"}} row[meq.FIELD] = {"일운반회수": {"기호": "n", "아래": "d", "이름": "하루 운반 횟수"}}
assert raw(AFRAME, row)["계"] == raw(AFRAME)["계"] assert raw(AFRAME, row)["계"] == raw(AFRAME)["계"]
assert revise.row_print(row) == revise.row_print(whole().logic(AFRAME)) # M01 개정 배지 안 뜸
# ── ③ 고침 ──────────────────────────────────────────────────────────── # ── ③ 고침 ────────────────────────────────────────────────────────────
+4 -7
View File
@@ -66,14 +66,11 @@ def test_읽기_미리셈_연결기록(client):
assert other["셈"]["값"]["Q_조"] == other["셈"]["값"]["Q_4t^표"] > 0 assert other["셈"]["값"]["Q_조"] == other["셈"]["값"]["Q_4t^표"] > 0
def test_없는문서_빈문서_없는키_404(client): def test_문서_없는_키_404(client):
assert ( """855 L3 ⓐ — 기초마다 문서가 늘 있음(만들 때 문서부터) · 문서가 없으면 로직 줄로 빈 문서를 짓지 않고 404."""
_read(client, "GC000100")["새"] is False assert _read(client, "GC000100")["새"] is False
) # 802-2a 로 문서 넣음 — 임시 사본에서 지워 빈 문서 길을 봄
doc_screen.drop("GC000100") doc_screen.drop("GC000100")
fresh = _read(client, "GC000100") assert client.get("/api/m01/logic/doc", params={"key": "GC000100"}).status_code == 404
assert fresh["새"] is True and fresh["문서"]["식"] == [] and fresh["문서"]["금액"] == []
assert fresh["셈"]["셈됨"] is False and fresh["셈"]["계"] is None
assert client.get("/api/m01/logic/doc", params={"key": "GX999999"}).status_code == 404 assert client.get("/api/m01/logic/doc", params={"key": "GX999999"}).status_code == 404
@@ -67,7 +67,11 @@ def _new_logic(c: TestClient, name: str) -> str:
"호표": [], "호표": [],
"끝수": None, "끝수": None,
} }
ver = store.read("로직_자체.json")[1] if (store.FOLDER / "로직_자체.json").is_file() else "" ver = next(
f["version"]
for f in c.get("/api/m01/groups/로직/files").json()["files"]
if f["file"] == "로직_자체.json"
) # 판 = 문서 파일(855 L3 ⓐ)
res = c.post( res = c.post(
"/api/m01/save", "/api/m01/save",
json={ json={
+6 -41
View File
@@ -3,8 +3,10 @@
① 폴더 → 옛 한 파일 꼴(머리 · 줄 · 키 차례) · 옮기는 빌더 왕복 같음 · 두 번 써도 안 바뀜 ① 폴더 → 옛 한 파일 꼴(머리 · 줄 · 키 차례) · 옮기는 빌더 왕복 같음 · 두 번 써도 안 바뀜
② 한 대 고침 = 파일 하나만 · 새 기계 = 파일 하나 더함(끝) · 지움 = 파일 하나 지움 · 판 충돌 409 ② 한 대 고침 = 파일 하나만 · 새 기계 = 파일 하나 더함(끝) · 지움 = 파일 하나 지움 · 판 충돌 409
③ 내 기계 — 옛 `내기계.json` 은 읽을 때 폴더로 한 번 옮김(내용 · 다음 번호 같음 · 옛 파일 지움) ③ 내 기계 — 옛 `내기계.json` 은 읽을 때 폴더로 한 번 옮김(내용 · 다음 번호 같음 · 옛 파일 지움)
④ 저장 검사 좁히기 — 옛 길(폴더 두 번 읽고 전체 검사 두 번)과 같은 오류 목록(견본 고침 스물) ④ 저장 검사 좁히기 — 옛 길(폴더 두 번 읽고 전체 검사 두 번)과 같은 판정(걸림 · 안 걸림 · 견본 고침 열일곱)
기본 = 갈래(기계 · 자재 · 인력 · 유가 · 표 · 로직 · 조합)마다 하나 이상 아홉(`SAMPLE`) · 전수 = `AISLO_TEST_ALL=1` 기본 = 갈래(기계 · 자재 · 인력 · 유가 · 표 · 조합)마다 하나 이상 일곱(`SAMPLE`) · 전수 = `AISLO_TEST_ALL=1`
(855 L3 ⓐ — 기초 연결 흠 글은 수식 문서 기준이라 옛 로직 줄 글과 꼴이 다름 → 판정만 견줌 · 기초(로직 파일) 저장은
`Store_Logic` 길이라 로직 갈래 셋은 `test_m01_make` · `test_855_l3_doc_only` 가 봄)
""" """
from __future__ import annotations from __future__ import annotations
@@ -34,8 +36,6 @@ SAMPLE = {
"인력 준용 끊김", "인력 준용 끊김",
"유가 값", "유가 값",
"표 조건 틀림", "표 조건 틀림",
"로직 요소 끊김",
"로직 지움(일위대가 문서가 씀)",
"조합 지움", "조합 지움",
} }
@@ -181,43 +181,12 @@ def _add(file: str, like: str, **cols) -> list[dict]:
return [_part(file, {"op": "add", "row": row})] return [_part(file, {"op": "add", "row": row})]
def _logic_with_ref() -> tuple[str, str]:
for name, data in store._logic_files(store.loaded()[0]):
for row in data.get("줄") or []:
for item in row.get("호표") or []:
if isinstance(item.get("요소"), str) and item["요소"][:2] == "LB":
return name, str(row["키"])
raise AssertionError("요소 줄 있는 로직 없음")
def _leaf() -> tuple[str, str]:
"""아무도 안 부르고 조합에도 없는 로직 — 일위대가 문서만 쓰게 둠."""
files = store.loaded()[0]
called = {k for _, calls, _ in cache.counted(store.FOLDER).values() for k in calls}
held = {k for _, row in cm.mcb.rows(files) for k in cm.mcb.logic_keys(row)}
for name, data in store._logic_files(files):
for row in data.get("줄") or []:
if str(row["키"]) not in called | held:
return name, str(row["키"])
raise AssertionError("잎 로직 없음")
def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch) -> None: def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch) -> None:
leaf_file, leaf = _leaf() monkeypatch.setattr(cache, "_labor_files", lambda: []) # 층 일위대가 문서는 안 봄(임시 사본만)
doc = tmp_path / "labor.json"
doc.write_text(json.dumps({"담은로직": [{"로직": leaf}]}), encoding="utf-8")
monkeypatch.setattr(cache, "_labor_files", lambda: [("일위대가 시험", doc)])
used = next(r["키"] for r in _rows(M) if r.get("원문번호") == "0201-0100") used = next(r["키"] for r in _rows(M) if r.get("원문번호") == "0201-0100")
ref_file, ref_logic = _logic_with_ref()
combo = [r["키"] for r in _rows(cm.mcb.FILE)] combo = [r["키"] for r in _rows(cm.mcb.FILE)]
table = next(n for n in store.loaded()[0] if n.startswith("계수_")) table = next(n for n in store.loaded()[0] if n.startswith("계수_"))
cell = _rows(table)[0]["키"] cell = _rows(table)[0]["키"]
called = "GC000268" # 317 줄이 부름
called_file = next(
n
for n, d in store._logic_files(store.loaded()[0])
if any(r["키"] == called for r in d["줄"])
)
def bump(r): def bump(r):
r["값"]["가격"] += 1 r["값"]["가격"] += 1
@@ -237,9 +206,6 @@ def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch)
("인력 준용 끊김", lambda: _edit(LB, "LB000006", lambda r: r.update(준용="LB999999")), True), ("인력 준용 끊김", lambda: _edit(LB, "LB000006", lambda r: r.update(준용="LB999999")), True),
("유가 값", lambda: _edit(MO, "MO000001", lambda r: r.update(값=r["값"] + 1)), False), ("유가 값", lambda: _edit(MO, "MO000001", lambda r: r.update(값=r["값"] + 1)), False),
("표 조건 틀림", lambda: _edit(table, cell, lambda r: r["조건"].update(sub1="모름")), True), ("표 조건 틀림", lambda: _edit(table, cell, lambda r: r["조건"].update(sub1="모름")), True),
("로직 요소 끊김", lambda: _edit(ref_file, ref_logic, lambda r: next(i for i in r["호표"] if str(i.get("요소", ""))[:2] == "LB").update(요소="LB999999")), True),
("로직 지움(부름 받음)", lambda: _delete(called_file, called), True),
("로직 지움(일위대가 문서가 씀)", lambda: _delete(leaf_file, leaf), True),
("조합 이름 겹침", lambda: _edit(cm.mcb.FILE, combo[0], lambda r: r.update(이름=_rows(cm.mcb.FILE)[1]["이름"])), True), ("조합 이름 겹침", lambda: _edit(cm.mcb.FILE, combo[0], lambda r: r.update(이름=_rows(cm.mcb.FILE)[1]["이름"])), True),
("조합 지움", lambda: _delete(cm.mcb.FILE, combo[-1]), False), ("조합 지움", lambda: _delete(cm.mcb.FILE, combo[-1]), False),
("새 자재", lambda: _add(MT, "MT000008", 이름="sub1임시새자재"), False), ("새 자재", lambda: _add(MT, "MT000008", 이름="sub1임시새자재"), False),
@@ -251,5 +217,4 @@ def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch)
batch = make() batch = make()
want = _old(batch) want = _old(batch)
got = _new(batch) got = _new(batch)
assert sorted(got) == sorted(want), name assert bool(got) == bool(want) == bad, (name, got[:3], want[:3])
assert bool(want) == bad, (name, want[:3])
+7 -9
View File
@@ -1,7 +1,7 @@
"""M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만. """M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만.
- 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글. - 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글.
- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음. - 지우면(`/logic/remove` · `/save` 지움) 문서도 없음 · [복사/생성] = 원본 문서 복제 + 기본정보(855 L3 ⓐ).
""" """
from __future__ import annotations from __future__ import annotations
@@ -60,7 +60,7 @@ def _old(key: str) -> dict:
"""옛 엔진 금액(빌더 대조와 같은 길 · 기본 입력).""" """옛 엔진 금액(빌더 대조와 같은 길 · 기본 입력)."""
builder = importlib.import_module("build_수식문서_802_2") builder = importlib.import_module("build_수식문서_802_2")
whole = store.loaded()[1] whole = store.loaded()[1]
row = store.logic(key)["logic"] row = whole.logic(key) # 옛 로직 줄(같이 쓰기 · `/logic` 답은 머리만 · 855 L3 ⓐ)
return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1])) return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1]))
@@ -92,16 +92,14 @@ def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진
assert key not in doc_screen.docs() assert key not in doc_screen.docs()
def test_식_복사로_만든_로직도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None: def test_기본정보를_고쳐_복사해도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None:
view = _get(client, "/api/m01/logic/formula", key=SAMPLE) more = {"이름": "sub7임시 복사", "원문번호": "13-4-9", "결과단위": "m3", "출처": "자체 시험"}
made = _post( made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, **more}) # 855 L3 ⓐ [복사/생성]
client,
"/api/m01/logic/formula/save",
{"로직": view["로직"], "별칭": view["별칭"], "본뜬키": SAMPLE, "이름": "sub5임시 식복사"},
)
key = made["key"] key = made["key"]
assert made["수식문서"] is True and key in doc_screen.docs() assert made["수식문서"] is True and key in doc_screen.docs()
assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == _old(key) assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == _old(key)
head = _get(client, "/api/m01/logic", key=key)["logic"]
assert {k: head[k] for k in more} == more and head["키"] == key
body = {"file": make.OWN, "version": made["version"], "changes": [{"op": "delete", "key": key}]} body = {"file": make.OWN, "version": made["version"], "changes": [{"op": "delete", "key": key}]}
_post(client, "/api/m01/save", {"files": [body]}) _post(client, "/api/m01/save", {"files": [body]})
+35 -31
View File
@@ -15,7 +15,7 @@ from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Save as save_mod from M01_MasterData import M01_MasterData_Store_Save as save_mod
REAL = store.FOLDER REAL = store.FOLDER
OWN = "로직_자체.json" LABOR_FILE = "인력.json"
MACHINE = "EQ000002" MACHINE = "EQ000002"
LABOR = "LB000002" # 보통인부 LABOR = "LB000002" # 보통인부
@@ -36,37 +36,19 @@ def _bytes(folder: Path) -> dict[str, bytes]:
return out return out
def _new_logic() -> dict: def _new_labor() -> dict:
"""새 인력 줄 — LB 키 발급 = 대장 바뀜(기초 저장은 `Store_Logic` 길 · 855 L3 ⓐ)."""
rows = json.loads((store.FOLDER / LABOR_FILE).read_text(encoding="utf-8"))["줄"]
seed = next(r for r in rows if r["키"] == LABOR)
row = {k: v for k, v in seed.items() if k != "키"}
return { return {
"op": "add", "op": "add",
"row": { "row": {**row, "원문번호": "9999", "이름": "sub7임시 인부", "출처": "자체"},
"원문번호": "",
"구분": "자체",
"상세구분": "",
"소유": "현장",
"이름": "sub5임시 대장 시험",
"결과단위": "원/㎡",
"출처": "자체",
"입력": [],
"중간": [],
"호표": [
{
"종류": "인력",
"요소": LABOR,
"이름": "보통인부",
"단위": "인",
"수량": "1 / 7",
"비목": "노무비",
}
],
"덧줄": [],
"끝수": None,
},
} }
def _batch() -> list[dict]: def _batch() -> list[dict]:
"""기계 한 대 고침(기계 폴더) + 자체 로직 새 줄(GX 키 발급 = 대장 바뀜).""" """기계 한 대 고침(기계 폴더) + 인력 새 줄(LB 키 발급 = 대장 바뀜)."""
machine = json.loads((store.FOLDER / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8")) machine = json.loads((store.FOLDER / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8"))
machine["비고"] = "sub5임시" machine["비고"] = "sub5임시"
return [ return [
@@ -75,7 +57,7 @@ def _batch() -> list[dict]:
"version": store.version("기계.json"), "version": store.version("기계.json"),
"changes": [{"op": "edit", "key": MACHINE, "row": machine}], "changes": [{"op": "edit", "key": MACHINE, "row": machine}],
}, },
{"file": OWN, "version": store.version(OWN), "changes": [_new_logic()]}, {"file": LABOR_FILE, "version": store.version(LABOR_FILE), "changes": [_new_labor()]},
] ]
@@ -99,15 +81,37 @@ def test_파일_쓰기가_끊기면_대장과_파일이_저장_전_그대로(
with pytest.raises(OSError): with pytest.raises(OSError):
store.save(_batch()) store.save(_batch())
after = _bytes(master) after = _bytes(master)
assert after == before # 대장 · 기계 · 로직 파일 모두 저장 전 글 그대로 assert after == before # 대장 · 기계 · 인력 파일 모두 저장 전 글 그대로
assert not list(master.glob(".*.tmp")) and not list((master / "기계").glob(".*.tmp")) assert not list(master.glob(".*.tmp")) and not list((master / "기계").glob(".*.tmp"))
def test_끊김_없으면_대장과_파일이_같이_간다(master: Path) -> None: def test_끊김_없으면_대장과_파일이_같이_간다(master: Path) -> None:
book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("GX", 1) book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("LB", 1)
store.save(_batch()) store.save(_batch())
book = store.mk.load_book(master / store.mk.BOOK.name) book = store.mk.load_book(master / store.mk.BOOK.name)
keys = [r["키"] for r in json.loads((master / OWN).read_text(encoding="utf-8"))["줄"]] keys = [r["키"] for r in json.loads((master / LABOR_FILE).read_text(encoding="utf-8"))["줄"]]
assert f"GX{book_before:06d}" in keys and book["다음"]["GX"] == book_before + 1 assert f"LB{book_before:06d}" in keys and book["다음"]["LB"] == book_before + 1
machine = json.loads((master / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8")) machine = json.loads((master / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8"))
assert machine["비고"] == "sub5임시" assert machine["비고"] == "sub5임시"
def test_기초_문서_쓰기가_끊기면_대장과_문서가_저장_전_그대로(master: Path, monkeypatch) -> None:
"""855 L3 ⓐ — 새 기초 = 대장 GX 발급 → 자체 문서 파일 · 문서 쓰기가 끊기면 둘 다 저장 전 글."""
from M01_MasterData import M01_MasterData_Doc as doc_store
from M01_MasterData import M01_MasterData_Store_Logic as logic_store
shutil.copytree(REAL / "수식문서", master / "수식문서")
monkeypatch.setattr(doc_store.ml, "FOLDER", master / "수식문서")
doc_store._memo.clear()
before = _bytes(master) | {p.name: p.read_bytes() for p in (master / "수식문서").glob("*.json")}
def broken(path, data):
raise OSError("디스크 흉내 실패")
monkeypatch.setattr(doc_store, "put", broken)
row = {"키": "", "이름": "sub7임시 기초", "원문번호": "", "결과단위": "원", "출처": "자체"}
part = {"file": "로직_자체.json", "version": doc_store.file_version("로직_자체.json")}
with pytest.raises(OSError):
logic_store.save([{**part, "changes": [{"op": "add", "row": row}]}])
after = _bytes(master) | {p.name: p.read_bytes() for p in (master / "수식문서").glob("*.json")}
assert after == before
+150
View File
@@ -0,0 +1,150 @@
"""855 L3 ⓐ 지킴 — M01 단가산출 기초가 수식 문서만으로 돎(로직 JSON 은 같이 쓰기만).
마스터 사본 두 벌에서 같은 차례로 부름 — 켬(로직 파일 있음 · 같이 쓰기 켬) / 끔(로직 파일 없음 ·
`Store_Logic.WRITE` 끔). 목록 · 상세 · 비고 [저장] · 개정 확인 409 · 판 409 · 별칭 · [신규] ·
[복사/생성] · [삭제] · 기계 등록 답이 두 벌 같음.
다른 자리(둘째 박자에서 걷을 것) = `/logic/doc` 의 「층바탕」(빌더 문서 = 옛 로직 줄 변환)만 — 빼고 견줌.
"""
from __future__ import annotations
import json
import shutil
import sys
from pathlib import Path
from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient
from common_util import common_util_auth as auth
from M01_MasterData import M01_MasterData_Alias as alias
from M01_MasterData import M01_MasterData_Doc as doc_store
from M01_MasterData import M01_MasterData_Router as router_module
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Logic as logic_store
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts"))
import master_doc_link as mdl # noqa: E402
REAL = store.FOLDER
CANON = "GF000219" # 산림 13-4-1 메쌓기(인력) — 정본 기초
MACHINE, FAMILY = "기계.json", "GC000268" # [새 기계] = 꼴 식 고르기 목록 등록
def _world(tmp: Path, monkeypatch, logic: bool) -> TestClient:
for path in REAL.glob("*.json"):
if path.name.startswith("로직_") and not logic:
continue
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
shutil.copy(path, tmp / path.name)
shutil.copytree(REAL / "기계", tmp / "기계")
shutil.copytree(REAL / "수식문서", tmp / "수식문서")
monkeypatch.setattr(store, "FOLDER", tmp)
monkeypatch.setattr(doc_store.ml, "FOLDER", tmp / "수식문서")
monkeypatch.setattr(mdl, "FOLDER", tmp / "수식문서")
monkeypatch.setattr(logic_store, "WRITE", logic)
doc_store._memo.clear()
store.cache.forget() # 앞 시험이 남긴 기억 없이
app = FastAPI()
app.dependency_overrides[auth.verify_session] = lambda: {
"user_id": 1, "name": "시험", "role": "SYSTEM_ADMIN", "company_id": 1,
} # fmt: skip
deps = [Depends(auth.verify_session), Depends(auth.require_system_admin)]
app.include_router(router_module.router, dependencies=deps)
app.include_router(alias.router, dependencies=deps)
return TestClient(app)
def _run(client: TestClient) -> list:
out: list = []
def call(method: str, url: str, body=None, **params):
res = client.request(method, url, json=body, params=params or None)
got = res.json()
if isinstance(got, dict):
got.pop("층바탕", None) # 빌더 문서(옛 로직 줄 변환) — 둘째 박자에서 걷음
out.append((method, url, res.status_code, got))
return got
def save(file: str, version: str, changes: list, ok: bool = True) -> dict:
body = {"files": [{"file": file, "version": version, "changes": changes}], "개정확인": ok}
return call("POST", "/api/m01/save", body)
call("GET", "/api/m01/logics")
call("GET", "/api/m01/logics", q="메쌓기")
call("GET", "/api/m01/groups/로직/files")
one = call("GET", "/api/m01/logic", key=CANON)
call("GET", "/api/m01/logic/doc", key=CANON)
row = {**one["logic"], "비고": "sub7임시 비고"}
edit = [{"op": "edit", "key": CANON, "row": row}]
save(one["file"], one["version"], edit, ok=False) # 개정 확인 없음 = 409
saved = save(one["file"], one["version"], edit)
save(one["file"], one["version"], edit) # 옛 판 = 409
call("GET", "/api/m01/logic", key=CANON)
back = [{"op": "edit", "key": CANON, "row": one["logic"]}]
save(one["file"], saved["files"][0]["version"], back)
call("POST", "/api/m01/alias/save", {"키": CANON, "별칭": "sub7임시별칭"})
call("GET", "/api/m01/alias")
call("POST", "/api/m01/alias/save", {"키": CANON, "별칭": ""})
call("GET", "/api/m01/logic", key=CANON)
own = next(
f
for f in call("GET", "/api/m01/groups/로직/files")["files"]
if f["file"] == "로직_자체.json"
)
new = {"키": "", "이름": "sub7임시 신규", "원문번호": "", "결과단위": "m3", "출처": "자체"}
made = save("로직_자체.json", own["version"], [{"op": "add", "row": new}])
key = made["added"][-1]["key"]
call("GET", "/api/m01/logic", key=key)
call("GET", "/api/m01/logic/doc", key=key)
copied = call("POST", "/api/m01/logic/copy", {"key": CANON, "이름": "sub7임시 복사"})
call("GET", "/api/m01/logic/doc", key=copied["key"])
for gone in (key, copied["key"]):
info = call("GET", "/api/m01/logic", key=gone)
body = {"key": gone, "file": info["file"], "version": info["version"]}
call("POST", "/api/m01/logic/remove", body)
call("GET", "/api/m01/logics", q="sub7임시")
seed = call("GET", "/api/m01/machine/row", key="EQ000022")
first = json.loads(json.dumps(seed["row"]))
machine = {
**first,
"키": "",
"원문번호": "9999-0855",
"이름": "sub7임시기계",
"출처": {},
"단위": {},
}
machine.pop("별칭", None)
save(MACHINE, seed["version"], [{"op": "add", "row": machine}])
picks = call("GET", "/api/m01/logic/doc", key=FAMILY)
assert "9999-0855" in json.dumps(picks["문서"], ensure_ascii=False)
rows = store.read(MACHINE)[0]["줄"]
eq = next(r["키"] for r in rows if r.get("원문번호") == "9999-0855")
save(MACHINE, store.version(MACHINE), [{"op": "delete", "key": eq}])
call("GET", "/api/m01/logic/doc", key=FAMILY)
return out
def test_로직_파일_없이_같이_쓰기_끄고도_답이_같음(tmp_path: Path, monkeypatch) -> None:
(tmp_path / "on").mkdir()
(tmp_path / "off").mkdir()
with monkeypatch.context() as m:
on = _run(_world(tmp_path / "on", m, logic=True))
with monkeypatch.context() as m:
off = _run(_world(tmp_path / "off", m, logic=False))
assert [c[2] for c in on] == [c[2] for c in off]
assert [c[2] for c in on].count(409) == 2 # 개정 확인 · 옛 판
assert not [c for c in on if c[2] >= 400 and c[2] != 409], on
for a, b in zip(on, off, strict=True):
if a != b and isinstance(a[3], dict) and "logics" in a[3]:
x, y = a[3]["logics"], b[3]["logics"]
hit = next(((p, q) for p, q in zip(x, y) if p != q), (len(x), len(y)))
raise AssertionError((a[:3], hit))
assert a == b, (
a[:3],
json.dumps(a[3], ensure_ascii=False)[:300],
json.dumps(b[3], ensure_ascii=False)[:300],
)
assert not list((tmp_path / "off").glob("로직_*.json")) # 끔 = 로직 파일을 만들지 않음
+9 -2
View File
@@ -62,6 +62,12 @@ def _get(client: TestClient, url: str, **params) -> dict:
return res.json() return res.json()
def _row(file: str, key: str) -> dict:
"""옛 로직 줄(같이 쓰기 사본) — `/logic` 답은 머리만(855 L3 ⓐ) · 옛 셈 길 시험 몫."""
rows = json.loads((store.FOLDER / file).read_text(encoding="utf-8"))["줄"]
return next(r for r in rows if r["키"] == key)
def _calc(client: TestClient, **inputs) -> dict: def _calc(client: TestClient, **inputs) -> dict:
res = client.post( res = client.post(
"/api/m01/calc", "/api/m01/calc",
@@ -264,7 +270,8 @@ def test_단가_자동_요소_찾기_저장전_시험계산(client: TestClient)
assert tables["items"] and all(x["값칸"] for x in tables["items"]) assert tables["items"] and all(x["값칸"] for x in tables["items"])
raw = (store.FOLDER / one["file"]).read_bytes() raw = (store.FOLDER / one["file"]).read_bytes()
before = _calc(client)["sums"]["계"] before = _calc(client)["sums"]["계"]
half = {**one["logic"], "호표": one["logic"]["호표"][:1]} # 보통인부 줄 뺌 row = _row(one["file"], LOGIC_KEY)
half = {**row, "호표": row["호표"][:1]} # 보통인부 줄 뺌
res = client.post( res = client.post(
"/api/m01/calc", "/api/m01/calc",
json={"key": LOGIC_KEY, "inputs": LOGIC_INPUTS, "row": half}, json={"key": LOGIC_KEY, "inputs": LOGIC_INPUTS, "row": half},
@@ -390,7 +397,7 @@ def test_전력은_계약종별을_골라야_값이_섬(client: TestClient) -> N
계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인).""" 계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인)."""
one = _get(client, "/api/m01/logic", key=key_of("GC000893")) one = _get(client, "/api/m01/logic", key=key_of("GC000893"))
cond = {"이름": "전력량요금", "계약종별": "입력"} cond = {"이름": "전력량요금", "계약종별": "입력"}
assert "전력 계약종별" in {x["이름"] for x in one["logic"]["입력"]} assert "전력 계약종별" in {x["이름"] for x in _row(one["file"], one["logic"]["키"])["입력"]}
with pytest.raises(store.cm.mf.FormulaError, match="전력 계약종별"): with pytest.raises(store.cm.mf.FormulaError, match="전력 계약종별"):
store.cm.mf.element(store.cm.master(), cond, {}) store.cm.mf.element(store.cm.master(), cond, {})
value, source = store.cm.mf.element(store.cm.master(), cond, {"전력 계약종별": "주택용 저압"}) value, source = store.cm.mf.element(store.cm.master(), cond, {"전력 계약종별": "주택용 저압"})
+1 -64
View File
@@ -3,7 +3,7 @@
목록(`/logics` · `/combos`)은 요청마다 마스터를 새로 읽지 않고 막힘도 미리 세어 둔 값을 씀. 목록(`/logics` · `/combos`)은 요청마다 마스터를 새로 읽지 않고 막힘도 미리 세어 둔 값을 씀.
여기서 보는 것 = ① 세어 둔 값이 줄마다 검사한 것과 같음 ② 파일이 바뀌면 바로 다시 읽음 여기서 보는 것 = ① 세어 둔 값이 줄마다 검사한 것과 같음 ② 파일이 바뀌면 바로 다시 읽음
③ 저장 직후 목록에 바로 비침 ④ 다른 파일의 로직이 바뀌면 그것을 부르던 줄도 다시 셈 ③ 저장 직후 목록에 바로 비침 ④ 다른 파일의 로직이 바뀌면 그것을 부르던 줄도 다시 셈
⑤ 저장 검사를 고친 줄 둘레로 좁혀도 흠(없는 키 · 없는 요소 · 돌고 도는 참조)을 그대로 잡음. ⑤ 요소 저장 검사를 좁혀도 흠을 그대로 잡음(기초 셈 칸 고침 검사 = 문서 저장 몫 · 855 L3 ⓐ).
""" """
from __future__ import annotations from __future__ import annotations
@@ -129,74 +129,11 @@ def test_부르는_로직이_바뀌면_다른_파일의_줄도_다시_센다(
assert caller["blocked"] is True and any("입력 「지역」" in x for x in caller["reasons"]) assert caller["blocked"] is True and any("입력 「지역」" in x for x in caller["reasons"])
def _save(client: TestClient, key: str, spoil) -> object:
"""그 로직 줄을 고쳐 저장 길로 보냄 — 저장 검사가 흠을 잡는지 보려고."""
one = client.get("/api/m01/logic", params={"key": key}).json()
row = json.loads(json.dumps(one["logic"], ensure_ascii=False))
spoil(row)
return client.post(
"/api/m01/save",
json={
"files": [
{
"file": one["file"],
"version": one["version"],
"changes": [{"op": "edit", "key": key, "row": row}],
}
],
"개정확인": True, # 정본 줄 고침 = 개정 확인(713-1)
},
)
def _errors(res) -> list[str]: def _errors(res) -> list[str]:
assert res.status_code == 422, res.text assert res.status_code == 422, res.text
return res.json()["detail"]["errors"] return res.json()["detail"]["errors"]
def test_저장_검사를_좁혀도_흠을_잡는다(client: TestClient) -> None:
"""고친 줄과 그 줄을 부르던 줄만 검사하지만 없는 키 · 없는 요소는 그대로 걸림."""
_logics(client) # 미리 세어 둔 값이 선 평소 모양
def no_logic(row: dict) -> None:
at = next(i for i, h in enumerate(row["호표"]) if h["종류"] == "로직")
row["호표"][at]["요소"] = "로직(GC999999, 기계='5401-0017', 지역=지역)"
def no_element(row: dict) -> None:
at = next(i for i, h in enumerate(row["호표"]) if h["종류"] == "인력")
row["호표"][at]["요소"] = "LB999999"
for spoil, word in ((no_logic, "GC999999"), (no_element, "LB999999")):
assert any(word in x for x in _errors(_save(client, CALLER, spoil)))
def test_돌고_도는_참조도_저장이_막는다(client: TestClient) -> None:
_logics(client)
def call_back(row: dict) -> None:
row.setdefault("호표", []).append(
{
"종류": "로직",
"요소": f"로직({CALLER}, 지반구분='토사', 크레인='2104-0010', 지역=지역)",
"이름": "되부르기",
"단위": "시간",
"수량": "1",
}
)
assert any("돌고 도는" in x for x in _errors(_save(client, CALLEE, call_back)))
def test_고친_줄을_부르던_줄이_깨지면_저장이_막힌다(client: TestClient) -> None:
"""좁힌 검사가 「그 줄을 부르는 줄」 을 빠뜨리지 않는지 — 다른 파일에 있는 줄."""
_logics(client)
def add_input(row: dict) -> None:
row["입력"] = [*row.get("입력", []), {"이름": "새입력", "종류": "수"}]
assert any("새입력" in x for x in _errors(_save(client, CALLEE, add_input)))
def test_미리_읽어_두면_첫_목록이_기다리지_않는다(client: TestClient) -> None: def test_미리_읽어_두면_첫_목록이_기다리지_않는다(client: TestClient) -> None:
store.cache.forget() store.cache.forget()
thread = store.cache.warm(store.FOLDER) thread = store.cache.warm(store.FOLDER)
+3 -238
View File
@@ -1,119 +1,21 @@
"""M01 복사해서 만들기(PLAN 3-4) — 별칭 꼴 식 펴기 · 되돌려 자체 로직으로 저장. """master_copy 펴기 · 되돌리기 왕복(PLAN 3-4) — 로직 전부가 펴고 되돌리면 원래 식 글자 그대로.
계약 `resources/master_data/_화면_계약.md` 7장 · 규칙 `resources/master_data/ref/_설계_식_복사.md`. M01 [복사/생성] 옛 시트 길(`/logic/formula*`)은 855 L3 ⓐ 에서 걷음(문서 복제 = `test_854_2_m01_copy_doc`) ·
못박는 것 `master_copy` 는 M02 `Sangeun_Formula` · `master_text` 가 아직 씀 — 로직 JSON 을 걷는 둘째 박자에서 이 시험도 걷음.
- 13-4-1 을 식으로 펴 아무것도 안 고치고 되돌려 저장하면 원본과 계산 결과가 같음.
- 12-4 처럼 같은 표를 다른 인자로 쓰는 로직은 별칭이 찾은 줄 값으로 갈림.
- 로직 전부(1,354줄)가 펴고 되돌리면 원래 식 글자 그대로 돌아옴.
""" """
from __future__ import annotations from __future__ import annotations
import shutil
import sys import sys
from decimal import Decimal
from pathlib import Path from pathlib import Path
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from M01_MasterData import M01_MasterData_Router as router_module
from M01_MasterData import M01_MasterData_Store as store from M01_MasterData import M01_MasterData_Store as store
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts")) sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts"))
import master_copy as mcp # noqa: E402 import master_copy as mcp # noqa: E402
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
REAL = store.FOLDER REAL = store.FOLDER
STACK = "GF000219" # 13-4-1 메쌓기(인력) — 같은 표를 같은 인자로 두 번(별칭 하나로 합침)
FORM = "GF000160" # 12-4 합판거푸집 — 같은 표를 다른 인자로 일곱 번(번호로 갈림)
@pytest.fixture
def client(tmp_path: Path, monkeypatch) -> TestClient:
for path in REAL.glob("*.json"):
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
shutil.copy(path, tmp_path / path.name)
shutil.copytree(REAL / "기계", tmp_path / "기계") # 기계 = 폴더(826-2)
monkeypatch.setattr(store, "FOLDER", tmp_path)
shutil.copytree(REAL / "수식문서", tmp_path / "수식문서") # 로직 목록 = 수식 문서(855 L2 ⓐ)
monkeypatch.setattr(store._docs().ml, "FOLDER", tmp_path / "수식문서")
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
return TestClient(app)
def _get(client: TestClient, url: str, **params) -> dict:
res = client.get(url, params=params)
assert res.status_code == 200, res.text
return res.json()
def _post(client: TestClient, url: str, body: dict, want: int = 200) -> dict:
res = client.post(url, json=body)
assert res.status_code == want, res.text
return res.json()
def _inputs(key: str) -> dict:
"""그 로직의 일괄 시험 입력 한 벌(`check_master.시험입력`)."""
row = store.cm.master(REAL).logic(key)
return {k: str(v) for k, v in store.cm.시험입력(row).items()}
def _sums(client: TestClient, key: str, inputs: dict) -> dict:
got = _post(client, "/api/m01/calc", {"key": key, "inputs": inputs})
assert got["ok"] is True, got
return got["sums"]
# ── 펴기 ──────────────────────────────────────────────────────────────
def test_별칭이_식에서_이름_하나로_보이고_원문은_뒤에_남는다(client: TestClient) -> None:
got = _get(client, "/api/m01/logic/formula", key=STACK)
names = {one["이름"]: one for one in got["별칭"]}
assert set(names) == {"메쌓기인력", "높이에대한증가율표"}
hit = names["메쌓기인력"]
assert hit["참조"] == "QF000421"
assert hit["원문"] == "찾기(QF000421, 뒷길이=뒷길이, 돌=돌, 쌓기=쌓기)"
assert hit["자리"] == ["호표[0].수량", "호표[1].수량"] # 완전히 같은 부르기는 하나로 합침
assert "석공" in hit["값칸"]
가로 = {one["자리"]: one["식"] for one in got["줄"]}
assert 가로["호표[0].수량"] == "메쌓기인력.석공 * (1 + 증가율 / 100)" # 값 칸은 그대로 둠
assert "찾기(" not in 가로["중간[0].식"]
assert "높이에대한증가율표.증가율" in 가로["중간[0].식"]
def test_같은_표를_다른_인자로_쓰면_별칭이_찾은_줄_값으로_갈린다(client: TestClient) -> None:
got = _get(client, "/api/m01/logic/formula", key=FORM)
형틀 = [one for one in got["별칭"] if one["참조"] == "QF000357"]
assert [one["이름"] for one in 형틀] == [
f"합판거푸집_{n}" for n in ("합판", "각재", "철선", "못", "박리제", "형틀목공", "보통인부")
]
assert [one["원문"] for one in 형틀][:2] == [
"찾기(QF000357, 구분='합판')",
"찾기(QF000357, 구분='각재')",
]
# 같은 표를 같은 인자로 두 번 쓰는 자리(QF000358)는 번호 없이 하나
한벌 = [one for one in got["별칭"] if one["참조"] == "QF000358"]
assert len(한벌) == 1 and 한벌[0]["자리"] == ["중간[0].식", "중간[1].식"]
가로 = {one["자리"]: one["식"] for one in got["줄"]}
assert 가로["호표[0].수량"] == "합판거푸집_합판.기준수량_1회사용 * 재료율"
assert 가로["호표[1].수량"] == "합판거푸집_각재.기준수량_1회사용 * 재료율"
def test_로직_부르기도_별칭으로_보인다(client: TestClient) -> None:
got = _get(client, "/api/m01/logic/formula", key="GC000994")
부름 = [one for one in got["별칭"] if one["종류"] == "로직"]
assert 부름, got["별칭"]
assert all(one["원문"].startswith("로직(") for one in 부름)
요소 = [one.get("요소") for one in got["줄"] if one["갈래"] == "호표"]
assert any(str(one) in {x["이름"] for x in 부름} for one in 요소) # 호표 요소도 별칭으로
def test_로직_전부가_펴고_되돌리면_원래_식으로_돌아온다() -> None: def test_로직_전부가_펴고_되돌리면_원래_식으로_돌아온다() -> None:
@@ -128,140 +30,3 @@ def test_로직_전부가_펴고_되돌리면_원래_식으로_돌아온다() ->
bad += mcp.check(master, row) bad += mcp.check(master, row)
assert rows > 1000, rows assert rows > 1000, rows
assert not bad, bad[:5] assert not bad, bad[:5]
# ── 되돌려 저장 ────────────────────────────────────────────────────────
def test_안_고치고_되돌려_저장하면_원본과_계산이_같다(client: TestClient) -> None:
inputs = _inputs(STACK)
was = _sums(client, STACK, inputs)
view = _get(client, "/api/m01/logic/formula", key=STACK)
made = _post(
client,
"/api/m01/logic/formula/save",
{"로직": view["로직"], "별칭": view["별칭"], "본뜬키": STACK, "이름": "메쌓기 복사본"},
)
key = made["key"]
assert key.startswith("GX"), made
assert made["logic"]["소유"] == "현장" and made["logic"]["구분"] == "자체"
assert f"{STACK} 를 본뜸" in made["logic"]["비고"]
# 별칭은 저장되지 않음 — 식은 원문 그대로
식 = made["logic"]["호표"][0]["수량"]
assert 식 == "찾기(QF000421, 뒷길이=뒷길이, 돌=돌, 쌓기=쌓기).석공 * (1 + 증가율 / 100)"
assert Decimal(str(_sums(client, key, inputs)["계"])) == Decimal(str(was["계"]))
assert Decimal(str(was["계"])) > 0
# 원본은 그대로
assert _get(client, "/api/m01/logic", key=STACK)["logic"]["호표"][0]["수량"] == 식
def test_식을_고쳐_저장하면_그_값으로_계산된다(client: TestClient) -> None:
inputs = _inputs(FORM)
was = _sums(client, FORM, inputs)
view = _get(client, "/api/m01/logic/formula", key=FORM)
row = view["로직"]
row["호표"][6]["수량"] = (
"합판거푸집_형틀목공.기준수량_1회사용 * 인력율 * 2" # 형틀목공 품 두 배
)
made = _post(
client,
"/api/m01/logic/formula/save",
{"로직": row, "별칭": view["별칭"], "본뜬키": FORM},
)
saved = made["logic"]["호표"][6]["수량"]
assert saved == "찾기(QF000357, 구분='형틀목공').기준수량_1회사용 * 인력율 * 2"
now = _sums(client, made["key"], inputs)
assert Decimal(str(now["노무비"])) > Decimal(str(was["노무비"]))
assert Decimal(str(now["재료비"])) == Decimal(str(was["재료비"]))
def test_별칭과_같은_이름의_사용자_변수를_만들면_저장을_막는다(client: TestClient) -> None:
"""일감 15 — 교차 검증 어긋남 1건. 가림 못 하는 이름 겹침은 조용히 안 바꾸고 막음."""
view = _get(client, "/api/m01/logic/formula", key=STACK)
row = view["로직"]
row["중간"].insert(0, {"이름": "메쌓기인력", "식": "1"}) # 별칭과 같은 이름
for h in row["호표"]:
if h["이름"] == "석공":
h["수량"] = "메쌓기인력 * 2"
got = _post(
client,
"/api/m01/logic/formula/save",
{"로직": row, "별칭": view["별칭"], "본뜬키": STACK},
want=400,
)
assert "메쌓기인력" in str(got["detail"])
# 미리보기 길도 같이 막힘
got2 = _post(
client, "/api/m01/logic/formula/preview", {"로직": row, "별칭": view["별칭"]}, want=400
)
assert "메쌓기인력" in str(got2["detail"])
def test_별칭_원문이_부르기가_아니면_막는다(client: TestClient) -> None:
view = _get(client, "/api/m01/logic/formula", key=STACK)
marks = [{**one} for one in view["별칭"]]
marks[0]["원문"] = "1 + 1"
got = _post(
client,
"/api/m01/logic/formula/save",
{"로직": view["로직"], "별칭": marks},
want=400,
)
assert "찾기" in str(got["detail"])
def test_미리보기는_저장_없이_원문으로_되돌린_로직과_지을_문서를_준다(client: TestClient) -> None:
"""3-4 화면의 [시험 계산] 이 쓰는 길(855 2-B4) — 답의 `문서` 를 문서 셈(`/logic/doc/preview`)
으로 · 금액 = 그 로직 수식 문서 금액(옵션을 바꿔도)."""
view = _get(client, "/api/m01/logic/formula", key=STACK)
before_keys = _get(client, "/api/m01/logics")["logics"]
preview = _post(
client, "/api/m01/logic/formula/preview", {"로직": view["로직"], "별칭": view["별칭"]}
)
resolved = preview["logic"]["호표"][0]["수량"]
assert resolved == "찾기(QF000421, 뒷길이=뒷길이, 돌=돌, 쌓기=쌓기).석공 * (1 + 증가율 / 100)"
after_keys = _get(client, "/api/m01/logics")["logics"]
assert after_keys == before_keys # 아무것도 저장 안 함
def total(doc: dict, given: dict) -> Decimal:
got = _post(client, "/api/m01/logic/doc/preview", {"문서": doc, "입력": given})
assert got["셈"]["셈됨"], got["셈"]
return Decimal(str(got["셈"]["계"]))
saved = _get(client, "/api/m01/logic/doc", key=STACK)["문서"]
draft = {**preview["문서"], "키": "_새"} # 화면이 보내는 꼴(저장 전 = 빈 키)
picks = [total(saved, {})]
for given in ({}, {"돌": "견치돌", "쌓기": "켜쌓기", "뒷길이": 45}):
assert total(draft, given) == total(saved, given)
picks.append(total(saved, given))
assert picks[0] != picks[-1] # 옵션이 금액을 바꿈(같음이 빈 대조가 아님)
def test_미리보기도_별칭_원문이_부르기가_아니면_막는다(client: TestClient) -> None:
view = _get(client, "/api/m01/logic/formula", key=STACK)
marks = [{**one} for one in view["별칭"]]
marks[0]["원문"] = "아무거나"
got = _post(
client,
"/api/m01/logic/formula/preview",
{"로직": view["로직"], "별칭": marks},
want=400,
)
assert "찾기" in str(got["detail"])
def test_정본_로직은_이_길로도_안_바뀐다(client: TestClient) -> None:
"""저장은 늘 새 자체 로직(`GX`) — 본뜬 원본 파일은 판본까지 그대로."""
before = _get(client, "/api/m01/logic", key=STACK)
view = _get(client, "/api/m01/logic/formula", key=STACK)
_post(
client,
"/api/m01/logic/formula/save",
{"로직": view["로직"], "별칭": view["별칭"], "본뜬키": STACK},
)
after = _get(client, "/api/m01/logic", key=STACK)
assert after["version"] == before["version"]
assert after["logic"] == before["logic"]
+8 -3
View File
@@ -164,10 +164,15 @@ def test_모르는_소유는_400(client: TestClient) -> None:
assert caught.value.status == 400 assert caught.value.status == 400
def test_만든_자체_로직이_시험_계산에_돈다(client: TestClient) -> None: def test_만든_자체_로직은_빈_문서로_열리고_목록에_든다(client: TestClient) -> None:
"""855 L3 ⓐ — 새 기초 셈은 문서(줄 쌓기) 몫 · 받은 줄의 셈 칸은 안 씀(옛 「시험 계산에 돈다」 걷음)."""
made = _new("공용") made = _new("공용")
got = _post(client, "/api/m01/calc", {"key": made["key"], "inputs": {}}) got = _get(client, "/api/m01/logic/doc", key=made["key"])
assert got["ok"] is True and Decimal(str(got["sums"]["노무비"])) > 0 assert (
got["새"] is False
and got["파일"] == "수식_자체.json"
and got["문서"]["이름"] == "시험 초안"
)
listed = _get(client, "/api/m01/logics", owner="공용")["logics"] listed = _get(client, "/api/m01/logics", owner="공용")["logics"]
assert made["key"] in [x["키"] for x in listed] assert made["key"] in [x["키"] for x in listed]
+9 -2
View File
@@ -6,6 +6,7 @@
from __future__ import annotations from __future__ import annotations
import json
import re import re
import shutil import shutil
import sys import sys
@@ -45,6 +46,12 @@ def client(tmp_path: Path, monkeypatch) -> TestClient:
return TestClient(app) return TestClient(app)
def _row(file: str, key: str) -> dict:
"""옛 로직 줄(같이 쓰기 사본) — `/logic` 답은 머리만(855 L3 ⓐ) · 옛 글 길 시험 몫."""
rows = json.loads((store.FOLDER / file).read_text(encoding="utf-8"))["줄"]
return next(r for r in rows if r["키"] == key)
def _inputs(key: str) -> dict: def _inputs(key: str) -> dict:
"""그 로직의 일괄 시험 입력 한 벌(`check_master.시험입력`).""" """그 로직의 일괄 시험 입력 한 벌(`check_master.시험입력`)."""
row = store.cm.master(REAL).logic(key) row = store.cm.master(REAL).logic(key)
@@ -166,7 +173,7 @@ def test_고른_값이_틀리면_그대로_막힘(client: TestClient) -> None:
def test_끝수는_줄이_아니라_소계에_붙는다(client: TestClient) -> None: def test_끝수는_줄이_아니라_소계에_붙는다(client: TestClient) -> None:
got = client.get("/api/m01/logic", params={"key": STACK}).json() got = client.get("/api/m01/logic", params={"key": STACK}).json()
row = dict(got["logic"], 끝수={"대상": "계", "자리": 0, "방법": "버림"}) row = dict(_row(got["file"], STACK), 끝수={"대상": "계", "자리": 0, "방법": "버림"})
body = {"key": STACK, "inputs": _inputs(STACK), "row": row, "file": got["file"]} body = {"key": STACK, "inputs": _inputs(STACK), "row": row, "file": got["file"]}
cut = client.post("/api/m01/text", json=body).json() cut = client.post("/api/m01/text", json=body).json()
assert cut["ok"] is True assert cut["ok"] is True
@@ -301,7 +308,7 @@ def test_조각_로직_부르는_줄_990개_세_비목에_다_걸치고_계산_
비목이 안 정해진 로직 부르는 줄은 세 비목에 다 걸쳐 보여야 하나, 이 견본(STACK)은 비목이 안 정해진 로직 부르는 줄은 세 비목에 다 걸쳐 보여야 하나, 이 견본(STACK)은
호표 둘 다 비목이 「노무비」로 정해진 인력 줄이라 한 비목에만 걸림 — 그 좁은 경우 확인.""" 호표 둘 다 비목이 「노무비」로 정해진 인력 줄이라 한 비목에만 걸림 — 그 좁은 경우 확인."""
got = client.get("/api/m01/logic", params={"key": STACK}).json() got = client.get("/api/m01/logic", params={"key": STACK}).json()
row = dict(got["logic"]) row = dict(_row(got["file"], STACK))
row["호표"] = [dict(row["호표"][0], 요소="LB099999"), dict(row["호표"][1])] row["호표"] = [dict(row["호표"][0], 요소="LB099999"), dict(row["호표"][1])]
body = {"key": STACK, "inputs": _inputs(STACK), "row": row, "file": got["file"]} body = {"key": STACK, "inputs": _inputs(STACK), "row": row, "file": got["file"]}
text = client.post("/api/m01/text", json=body) text = client.post("/api/m01/text", json=body)