Merge remote-tracking branch 'origin/sub_laptop_7' into sub_laptop_5

This commit is contained in:
2026-11-18 13:30:11 +09:00
20 changed files with 86 additions and 458 deletions
+14 -134
View File
@@ -4,12 +4,11 @@
셈 = `master_doc_calc.calc`(파이썬 정본 · TS 짝 `common_util_formula_doc_calc.ts`) ·
연결 기록 = `master_doc_record.Rec` — 셈이 쓴 요소 값 · 표 · 단가산출 문서를 화면 캐시로 실음
(화면은 같은 계산기로 즉시 셈 · 캐시에 없는 연결만 뒤에서 미리 셈).
- 읽기 {키} → {문서, 셈, 연결, 파일, 새, 층바탕?} — 문서가 없으면 빈 문서(이름 · 단위 = 로직 줄) ·
층바탕(848-8) = {위: 빌더가 지을 문서} — 화면이 칸 단위로 맞대 시스템 관리자 고침 테두리(읽기만 · 파일 안 씀)
- 읽기 {키} → {문서, 셈, 연결, 파일, 새, 판} — 없는 키 = 404
- 미리 셈 {문서, 입력} → {셈, 연결} — 쓰기 없음
- 저장 {문서} → {문서, 셈, 연결, 파일} — 서버가 정본으로 다시 셈 · 문서 파일에 씀(브라우저 셈 값 안 받음)
· 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) · 셈 칸이 빌더 결과와 같으면
빌더 글 + 기계덮음 · 다르면 받은 문서 + `손고침`(빌더가 안 덮음 · 같게 되돌려 저장하면 사라짐)
· 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) ·
셈 칸을 고치면 `손고침`(M02 SK 가 기초 문서 사본을 실음 · 한 번 붙으면 남음)
권한 = 라우터를 `main.py` 가 `system_admin_only` 로 붙임. M02 는 같은 꼴로 따로(802-4).
"""
@@ -91,7 +90,9 @@ def docs() -> dict[str, dict]:
return _memo["docs"]
#: 목록 · 상세가 문서에서 읽는 머리(이름표 `md.TAGS` 밖) — 로직 줄 고침도 같게(`sync_tags`)
#: 손고침 표지를 가르는 셈 칸(`layered`)
CALC = ("변수", "식", "금액", "끝수")
#: 목록 · 상세가 문서에서 읽는 머리(이름표 `md.TAGS` 밖)
HEAD = ("이름", "결과단위", "출처", "부품")
@@ -163,10 +164,8 @@ def read(key: str) -> dict:
if found is None:
raise store.StoreError(404, f"없는 로직 「{key}」")
out = _run(found)
up = built(key) # ponytail: 빌더 문서(층바탕) — 로직 JSON 이 없으면 None · 둘째 박자에서 걷음
more = {"층바탕": {"위": up}} if up is not None else {}
판 = version_of(found) # 저장 때 대조(다른 곳에서 바뀌면 409)
return {"문서": found, **out, "파일": _where(key) or "", "새": False, "판": 판, **more}
return {"문서": found, **out, "파일": _where(key) or "", "새": False, "판": 판}
def preview(doc: dict, given: dict | None = None) -> dict:
@@ -185,39 +184,8 @@ def _new_file(name: str) -> dict:
return {"그룹": "수식문서", "로직파일": logic, **tags, "줄": []}
def _row(key: str) -> dict | None:
"""그 키의 로직 줄(기억 · 읽기만) — 없음 = None."""
for data in store.loaded()[0].values():
if data.get("그룹") == "로직":
for row in data.get("줄") or []:
if str(row.get("키")) == key:
return row
return None
def sync_tags(keys) -> int:
"""로직 줄 이름표를 수식 문서 줄 머리에 같게(855 L1 · 읽는 쪽이 문서로 옮길 때까지 두 곳) —
로직 줄 · 문서가 둘 다 있는 키만 · 바뀐 문서 파일만 씀(`put`) · 바꾼 문서 수."""
want = {k: r for k in set(map(str, keys)) if (r := _row(k)) is not None}
if not want:
return 0
n = 0
with _LOCK:
for path in sorted(folder().glob("수식_*.json")):
data, hit = ml.load_file(path), False
rows = data.get("줄") or []
for at, doc in enumerate(rows):
row = want.get(str(doc.get("키")))
if row is not None and _headed(doc, row) != doc:
rows[at], hit = _headed(doc, row), True
n += 1
if hit:
put(path, data)
return n
def _headed(doc: dict, row: dict) -> dict:
"""문서 머리를 로직 줄 것과 같게 — 이름표(`md.tag`) + `HEAD`(있던 자리 그대로 · 줄에 없는 칸은 뺌)."""
"""문서 머리를 받은 머리와 같게 — 이름표(`md.tag`) + `HEAD`(있던 자리 그대로 · 머리에 없는 칸은 뺌)."""
out = md.tag(doc, row)
for k in HEAD:
if k in row:
@@ -227,96 +195,9 @@ def _headed(doc: dict, row: dict) -> dict:
return out
def ensure(key: str) -> bool:
"""새 로직 줄의 수식 문서 — 빌더와 같은 문서(`make`) · 못 지으면 빈 문서 + 머리(목록이 문서에서 읽으므로
문서 없는 로직 0 · 열면 빈 문서는 그대로) · 지어 넣었거나 이미 있음 = True."""
if make(key):
return True
row = _row(key)
if row is None:
return False
blank = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원"))
blank = {
**dict(list(blank.items())[:5]),
"출처": row.get("출처"),
**dict(list(blank.items())[5:]),
}
with _LOCK:
if key in docs():
return True
path = folder() / _file_for(key)
data = ml.load_file(path) if path.exists() else _new_file(path.name)
data.setdefault("줄", []).append(_headed(blank, row))
put(path, data)
return False
def built(key: str) -> dict | None:
"""빌더가 지을 그 키 문서(옛 로직 줄 변환 · `build_수식문서_802_2`) · 로직 줄 없음 · 변환 틀림 = None."""
for data in store.loaded()[0].values():
if data.get("그룹") != "로직":
continue
for row in data.get("줄") or []:
if str(row.get("키")) == key:
return of_row(row)
return None
def of_row(row: dict) -> dict | None:
"""로직 줄(저장 전 고친 줄도) → 빌더와 같은 변환의 수식 문서 · 변환 틀림 = None —
[로직 복사/생성] 시험 계산(855 2-B4)이 저장하면 지을 문서로 셈."""
import master_doc_convert as cv
try:
doc = cv.convert(store.loaded()[1], row)[0]
except Exception: # noqa: BLE001 — 변환 틀림 = 빌더 문서 없음(표지 안 담)
return None
return md.tag(doc, row) # 855 L1 이름표 = 빌더와 같게
def make(key: str) -> bool:
"""[로직 복사/생성](`Store_Make.logic_new`) 뒤 수식 문서를 지어 씀 — 빌더(`build_수식문서_802_2`)와
같은 변환 · 같은 대조(옛 엔진 = 새 계산기 · 기본 + 옵션 표본 · 부르는 단가산출이 저장본)를 지난 것만
(빌더도 그것만 넣음 · 못 지나면 안 씀 = 열면 빈 문서) · 이미 있으면 그대로 · 썼거나 있음 = True."""
import importlib
builder = importlib.import_module("build_수식문서_802_2")
files, whole = store.loaded()
row = next(
(
r
for data in files.values()
if data.get("그룹") == "로직"
for r in data.get("줄") or []
if str(r.get("키")) == key
),
None,
)
doc = built(key) if row is not None else None
if doc is None:
return False
with _LOCK:
have = docs()
if key in have:
return True
links = ml.Links(whole, {**have, key: doc})
if not builder._calls(doc) <= set(have) or not all(
builder.agree(
builder.old_answer(whole, row, given), builder.new_answer(links, doc, one)
)
for _, given, one in builder.cases_of(whole, row)
):
return False
path = folder() / _file_for(key)
data = ml.load_file(path) if path.exists() else _new_file(path.name)
data.setdefault("줄", []).append(doc)
put(path, data)
return True
def layered(doc: dict, key: str) -> dict:
"""848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 ·
다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로."""
"""848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 받은 문서 + 덮음 ·
`손고침` = 셈 칸(`CALC`)을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 855-E L4)."""
links = ml.Links(store.loaded()[1], {**docs(), key: doc})
try:
doc = mcv.prune_doc(doc, links)
@@ -324,10 +205,9 @@ def layered(doc: dict, key: str) -> dict:
raise store.StoreError(400, str(e)) from e
cover = doc.get(mcv.COVER)
bare = {k: v for k, v in doc.items() if k not in (mcv.COVER, mcv.HAND)}
base = built(key)
hand = base is not None and ml._norm(bare) != ml._norm(base)
if base is not None and not hand:
bare = base
was = docs().get(key)
calc = lambda d: ml._norm({k: d.get(k) for k in CALC}) # noqa: E731
hand = was is not None and (bool(was.get(mcv.HAND)) or calc(was) != calc(bare))
out = {**bare, **({mcv.HAND: True} if hand else {}), **({mcv.COVER: cover} if cover else {})}
if "쌓기" in out: # 줄 쌓기 차림 = 끝 칸(화면 `docOf` 와 같은 차례)
out["쌓기"] = out.pop("쌓기")
@@ -422,7 +302,7 @@ def drop(key: str) -> None:
def remove(key: str, file: str, version: str, confirmed: bool) -> dict:
"""로직 지우기 — 쓰는 곳 있으면 409 {쓰는곳} · 기초 저장 길(`Store_Logic` — 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기)."""
"""로직 지우기 — 쓰는 곳 있으면 409 {쓰는곳} · 기초 저장 길(`Store_Logic` — 개정 확인 · 판 · 검사 · 문서 지움)."""
from M01_MasterData import (
M01_MasterData_Store_Logic as logic_store,
) # 그 파일이 이 파일을 부름 — 늦게
+1 -4
View File
@@ -120,7 +120,7 @@ def formula(row: dict) -> dict:
def register(batch: list[dict]) -> Callable[[], None]:
"""[새 기계] 저장 = 꼴 식 「기계」 목록에 그 원문번호 더함 · M01 에서 만든 기계(출처 모두 「자체」)를
지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록(정본 ·
848-5)에 더함 · 뺌 + 옛 로직 줄 고르기 같이 쓰기(`Store_Logic.mirror` · 855 L3 ⓐ)."""
848-5)에 더함 · 뺌."""
from M02_MasterTemplete import M02_Machine_Hourly as mh # M02 가 M01 을 부름 — 늦게
from M02_MasterTemplete import M02_MyMachine as mym
@@ -153,10 +153,7 @@ def register(batch: list[dict]) -> Callable[[], None]:
return lambda: None
def after() -> None:
from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 늦게(서로 부름)
_register_docs(add, drop)
logic_store.mirror([], (add, drop))
after.lists = (
add,
+1 -1
View File
@@ -280,7 +280,7 @@ def get_logic_users(key: str) -> dict:
@router.post("/logic/remove")
def post_logic_remove(body: RemoveBody) -> dict:
"""로직 지우기(804-7) — 수식 문서(+ 옛 로직 줄 같이 쓰기) · 부르는 곳 있으면 409 {쓰는곳}."""
"""로직 지우기(804-7) — 수식 문서 · 부르는 곳 있으면 409 {쓰는곳}."""
return _call(doc_screen.remove, body.key, body.file, body.version, body.개정확인)
+10 -19
View File
@@ -117,10 +117,9 @@ def stale(names, marks=()) -> None:
`marks` = 요소·표에서 흔들린 자리 — 그 자리를 보던 로직 줄만 다시 셈."""
with _FRESH:
for name in names:
was = _READ.pop(name, (None, {}))[1]
_READ.pop(name, None)
_BLOCK.pop(name, None)
if was.get("그룹") != "로직":
_MARKED.setdefault(name, set()).update(marks)
_MARKED.setdefault(name, set()).update(marks)
_INDEX.pop("자국", None)
if (held := _STEADY.get()) is not None:
held.clear()
@@ -139,11 +138,9 @@ def adopt(folder: Path, files: dict[str, dict], whole, names, marks=()) -> None:
):
return stale(names, marks)
for name in names:
was = _READ.get(name, (None, {}))[1]
_READ[name] = (now[name], files[name])
_BLOCK.pop(name, None)
if was.get("그룹") != "로직":
_MARKED.setdefault(name, set()).update(marks)
_MARKED.setdefault(name, set()).update(marks)
_INDEX.update(자국=now, files={n: _READ[n][1] for n in now}, whole=whole)
if (held := _STEADY.get()) is not None:
held.clear()
@@ -180,7 +177,7 @@ def blocks(folder: Path) -> dict[str, list[str]]:
if _INDEX.get("문서") is not (now := docs()): # 수식 문서가 바뀌면 통째로 다시
_BLOCK.clear()
_INDEX["문서"] = now
base = {n: s for n, s in stamps.items() if files[n].get("그룹") != "로직"}
base = dict(stamps)
marks = None # 요소·표에서 흔들린 자리 — None 이면 무엇이 바뀐지 모름(통째로 다시)
if _BASE != base: # 인력 · 재료 · 표가 바뀌면 바탕이 달라짐
off = {n for n in set(_BASE) | set(base) if _BASE.get(n) != base.get(n)}
@@ -277,7 +274,7 @@ def logic_errors(files: dict, whole, book: dict | None, narrow=None) -> list[str
"""저장 검사의 기초 몫(855 L3 ⓐ — 수식 문서가 정본) — 키 겹침 · 대장(요소 파일 + 문서 키) ·
좁힘 없으면 연결 · 준용이 먼저 · 그것이 깨끗하면 수식 문서 막힘(`narrow` 를 주면 그 키만 · 요소 닫힘 ·
문서 사이 순환) — 같은 흠을 두 번 안 적음."""
view = {n: d for n, d in files.items() if d.get("그룹") != "로직"} | dict(_logic_files())
view = files | 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)
@@ -300,11 +297,11 @@ def _labor_files() -> list[tuple[str, Path]]:
]
def labor_errors(whole, keys=None, have=None) -> list[str]:
"""일위대가 · 사전조합 문서가 담은 로직 마스터에 없음(39-1d · 50-3) —
def labor_errors(have, keys=None) -> list[str]:
"""일위대가 · 사전조합 문서가 담은 로직이 기초에 없음(39-1d · 50-3) —
로직 지우기를 막음 · 어디서 쓰는지 알림 · 참조 줄(로직 없음)은 건너뜀. 전부터 깨진 것은
`save` 가 고치기 전 검사와 견주어 뺌. `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶) ·
`have` = 있는 기초 키(저장 뒤 문서 · 855 L3 ⓐ — 주면 `whole` 대신)."""
`save` 가 고치기 전 검사와 견주어 뺌. `have` = 있는 기초 키(수식 문서 · 855-E L3) ·
`keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶)."""
out = []
if keys is not None and not keys:
return out
@@ -321,13 +318,7 @@ def labor_errors(whole, keys=None, have=None) -> list[str]:
key = str(one.get("로직") or "") if isinstance(one, dict) else ""
if not key or (keys is not None and key not in keys):
continue
if have is not None:
if key not in have:
out.append(f"{where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌")
continue
try:
whole.logic(key)
except cm.mf.FormulaError:
if key not in have:
out.append(f"{where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌")
return out
+7 -116
View File
@@ -5,7 +5,7 @@
- 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`)
- 키 = 대장(`_키대장.json` · 그 파일 표 다음 번호 · 자체 GX) · 검사 = 문서(일위대가 · 사전조합 · 조합이 담은 기초 ·
키 겹침 · 대장) · 쓰는 곳 409 는 [삭제](`Doc.remove`)
- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`)
- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) · 로직 JSON 은 없음(855-E L3)
화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫.
"""
@@ -15,24 +15,14 @@ import copy
import os
from pathlib import Path
from common_util.common_util_time import kst_today
from M01_MasterData import M01_MasterData_Doc as doc_store
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Revise as revise
from M01_MasterData.M01_MasterData_Store_Shape import dump, keep_shape
md, ml, mk, cm = doc_store.md, doc_store.ml, store.mk, store.cm
#: 로직 줄 같이 쓰기 — M02 · B09 가 로직 줄을 더 안 읽게 되면(둘째 박자) 끄고 `mirror` 를 지움
WRITE = os.environ.get("AISLO_LOGIC_WRITE", "1") != "0"
OWN = "로직_자체.json"
FIELDS = revise.FIELDS
CALC = {
"입력": [],
"중간": [],
"호표": [],
"끝수": None,
} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음)
def is_logic(file: str) -> bool:
@@ -68,10 +58,10 @@ def _fresh_doc(key: str, row: dict, base: dict | None) -> dict:
return doc_store._headed(base, {**head(row), "키": key})
def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]:
"""고침 · 더함 · 지움을 문서 파일 사본에 — (문서 파일 → 내용, 같이 쓰기 편집, 더한 키, 지운 키)."""
def _plan(parts: list[dict], book: dict) -> tuple[dict, list, set]:
"""고침 · 더함 · 지움을 문서 파일 사본에 — (문서 파일 → 내용, 더한 키, 지운 키)."""
plan: dict[str, dict] = {}
edits, added, gone = [], [], set()
added, gone = [], set()
for part in parts:
file = str(part.get("file") or "")
path = _doc_file(file)
@@ -97,7 +87,6 @@ def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]:
if str(row.get("키")) != key:
raise store.StoreError(400, f"{file} · 키는 바꾸지 않음 「{key}」")
rows[at] = doc_store._headed(rows[at], head(row))
edits.append(("머리", key, doc_store.head_of(rows[at])))
elif op == "add":
where = doc_store.logic_files().get(file) or {"원문": "자체"}
tid = mk.table_id("로직", store._book(where))
@@ -106,13 +95,11 @@ def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]:
source = str(ch.get("from") or "")
base = doc_store.docs().get(source) if source else None
rows.append(_fresh_doc(key, row, base))
edits.append(("더함", key, {"file": file, "row": head(row), "from": source}))
added.append({"file": file, "key": key})
else:
del rows[at]
gone.add(key)
edits.append(("지움", key, None))
return plan, edits, added, gone
return plan, added, gone
def _combos(have: dict) -> list[str]:
@@ -140,7 +127,7 @@ def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]:
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(keys, gone)
def save(parts: list[dict], confirmed: bool = False) -> dict:
@@ -156,7 +143,7 @@ def save(parts: list[dict], confirmed: bool = False) -> dict:
book_path = store.FOLDER / mk.BOOK.name
book = mk.load_book(book_path)
old_book = {"키": dict(book["키"]), "다음": dict(book["다음"])}
plan, edits, added, gone = _plan(parts, book)
plan, added, gone = _plan(parts, book)
mk.finish(book)
if bad := _errors(plan, gone, old_book, book):
raise store.StoreError(422, {"errors": bad})
@@ -171,7 +158,6 @@ def save(parts: list[dict], confirmed: bool = False) -> dict:
except BaseException:
_undo(paths, raw, book_path, book_raw)
raise
mirror(edits)
files = list(dict.fromkeys(str(p.get("file")) for p in parts))
return {
"files": [{"file": f, "version": doc_store.file_version(f)} for f in files],
@@ -196,98 +182,3 @@ def _put(path: Path, data: bytes) -> None:
tmp = path.with_name(f".{path.name}.tmp")
tmp.write_bytes(data)
os.replace(tmp, path)
# ── 옛 로직 줄 같이 쓰기 — 로직 JSON 을 쓰는 단 한 자리(둘째 박자에서 지움) ──────────
def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None:
"""문서에 한 고침을 옛 로직 줄에도 — 머리(이름표 · 이름 · 결과단위 · 출처 · 부품 덮음) ·
더함(본뜬 로직 줄 셈 칸 / 빈 셈 칸) · 지움 · 기계 고르기 목록(`picks` = 더함 · 뺌).
검사 없음(문서가 정본) · 스위치 `WRITE` 가 꺼지면 아무것도 안 함."""
if not WRITE or (not edits and not picks):
return
with store._LOCK:
files = store.loaded()[0]
logic = {n: d for n, d in files.items() if d.get("그룹") == "로직"}
where = {str(r.get("키")): n for n, d in logic.items() for r in d.get("줄") or []}
after = {n: {**d, "줄": list(d.get("줄") or [])} for n, d in logic.items()}
touched: set[str] = set()
for op, key, what in edits:
if op == "더함":
name = what["file"]
if name not in after: # 자체 로직 파일이 없으면 머리만 두고 만듦
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}
after[name]["줄"].append(_ordered({**what["row"], **calc, "키": key}))
where[key] = name
elif (name := where.get(key)) is not None:
rows = after[name]["줄"]
at = _at(rows, key)
if at is None:
continue
if op == "지움":
del rows[at]
else:
rows[at] = _headed_row(rows[at], what)
else:
continue
touched.add(name)
if picks:
touched |= _picks(after, *picks)
for name in touched:
_write(name, logic.get(name), after[name])
store.cache.stale(touched)
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},
}
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_
}
return {**out, **{k: v for k, v in head_.items() if k not in out}}
def _picks(after: dict, add: dict, drop: set) -> set[str]:
"""기계경비식 로직 줄 「기계」 고르기 목록에 더함 · 뺌(문서 `선택 목록` 과 같게 · 848-5)."""
touched = set()
for name, data in after.items():
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,
)
if pick is None:
continue
codes = [c for c in pick["고르기"] if str(c) not in drop]
codes += [c for c in add.get(str(row["키"]), []) if c not in codes]
if codes != pick["고르기"]:
new = copy.deepcopy(row)
next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes
data["줄"][at] = new
touched.add(name)
return touched
def _write(name: str, before: dict | None, after: dict) -> None:
path = store.FOLDER / name
text = None
if before is not None and path.is_file():
text = keep_shape(path.read_bytes().decode("utf-8"), before, after, "줄")
_put(path, (text or dump(after)).encode("utf-8"))
+1 -2
View File
@@ -310,8 +310,7 @@ def _chapter_of(logic: dict) -> str:
def logic_new(logic: dict, owner: str = OWNERS[0], source: str = "") -> dict:
"""새 자체 기초 — 키 = 서버가 `GX` 다음 번호 · 문서 = 빈 문서 / `source` 문서 복제(본뜸) ·
옛 로직 줄은 같이 쓰기(`Store_Logic.mirror`)."""
"""새 자체 기초 — 키 = 서버가 `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)
+1 -7
View File
@@ -76,9 +76,7 @@ def _errors(files, whole, names, book, narrowed, keys) -> list[str]:
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)}")
"""요소 · 표 파일 저장 — 단가산출 기초는 `Store_Logic`(855 L3 ⓐ · `Store_Make.save` 가 가름)."""
with store._LOCK:
stale = [
p.get("file", "") for p in batch if store.version(p.get("file", "")) != p.get("version")
@@ -134,10 +132,6 @@ 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)
@@ -415,10 +415,6 @@ export async function mountM01LogicLab(
const row: LogicRow = {
키: "",
...info,
입력: [],
중간: [],
호표: [], // 빈 시트 줄 — 자체 로직 편집기 · 시트로 채움
끝수: null,
};
const id = logicId("자체", `새${Date.now()}`);
drafts[id] = { sub: "자체", file: OWN_FILE, version: own?.version ?? "", origKey: null, row };
+1 -28
View File
@@ -5,28 +5,7 @@
import { API_BASE_URL } from "@config/config_frontend";
/** 로직 한 줄 — 파일 그대로(한글 칸) · 틀 `_틀.md` 6장 */
export interface LogicInput {
이름: string;
단위?: string;
고르기?: (string | number)[];
범위?: [number, number];
}
export interface HoLine {
종류: string;
요소: string;
이름?: string;
규격?: string;
단위?: string;
수량: string;
비목?: string;
}
export interface NamedFormula {
이름: string;
식: string;
비목?: string;
출처?: string;
}
/** 단가산출 기초 머리 — 키 · 이름표 · 이름 · 결과단위 · 출처(셈 = 수식 문서 · 855-E L3) */
export interface LogicRow {
/** 서버가 주는 키 — 새 로직은 "" (저장 때 대장의 다음 번호) */
키: string;
@@ -37,12 +16,6 @@ export interface LogicRow {
/** 원문 절 머리 개정 연도(빌더가 채움 · 읽기만 · 794-2b) */
개정?: number[];
소유?: string;
입력: LogicInput[];
중간: NamedFormula[];
호표?: HoLine[];
결과?: { 식: string };
덧줄?: NamedFormula[];
끝수?: string | null;
비고?: string;
/** 설계자가 찾는 다른 이름 — 쉼표로 여럿 · 없으면 칸 없음(208-1) */
별칭?: string;
+1 -7
View File
@@ -89,19 +89,13 @@ def _set_values(doc: dict, given: dict) -> None:
def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]:
"""기초 문서(848-10) → (문서, 옵션 기본을 문서에서 읽음) — 프로젝트 층 밖 = 지금 M01 문서 ·
그 밖(굳힌 사본 · 프로젝트 층) = 굳힐 때 사본 `바탕문서` › 손고침 기초 = 빌더 문서
(굳은 뒤 고침 안 받음) › 지금 문서 · 문서에서 안 읽음 = 옛 로직 줄 자동값
(옛 사본 금액 그대로)."""
그 밖(굳힌 사본 · 프로젝트 층) = 굳힐 때 사본 `바탕문서` › 지금 문서."""
live = dc.folder().get(key)
if renew.on() and live is not None:
return dc.doc_of(whole, key), True
kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None
if kept: # 프로젝트 층 = 굳힐 때 문서 + 옛 자동값(855 L2 ⓑ — 전과 같은 옵션 값)
return cp.deepcopy(kept), renew.on()
if live is not None and live.get(mcv.HAND):
from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게
return m01.built(key), False
return dc.doc_of(whole, key), False
+1 -6
View File
@@ -99,7 +99,7 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]:
def layers(copy: dict, sk: dict) -> dict[str, Any]:
"""848-8 바뀐 자리 바탕 — {위: 위 층 문서, 빌더?: 기초가 손고침이면 빌더 문서} · 모름 = 빈 묶음.
"""848-8 바뀐 자리 바탕 — {위: 위 층 문서} · 모름 = 빈 묶음.
위 층 = 파생과 같은 기초 문서(`dsk.base_doc` · 덮음 · 손고침 표지 뺌 · 옵션 값 = 그 문서 기본 ·
옛 길 = 옛 로직 줄 기본) · 가져온 식 = 불러올 때 문서(따로 = `처음` · 아니면 지금 파생) ·
읽기만(파일 안 씀)."""
@@ -115,11 +115,6 @@ def layers(copy: dict, sk: dict) -> dict[str, Any]:
if top is None:
return {}
out = {"위": dsk._bare_doc(top)}
if live.get(mcv.HAND) and renew.on():
from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게
if (built := m01.built(key)) is not None:
out["빌더"] = built
out = json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str)) # 사본
if not real: # 옛 길 — `derive` 와 같은 옵션 값
auto = dc.given_of(skc.whole_(), key, {})
+1 -1
View File
@@ -120,7 +120,7 @@ def _old_check(files: dict, changed: list[str], book: dict, narrowed) -> list[st
out += cm.check_logics(files, whole, book, narrowed and narrowed[:2])
if narrowed and narrowed[2]:
out += cm.check_links(whole)
return out + cm.mcb.check_all(files, whole) + cache.labor_errors(whole)
return out + cm.mcb.check_all(files, whole) + cache.labor_errors(set(cache.docs()))
def _old(batch: list[dict]) -> list[str]:
+6 -39
View File
@@ -6,8 +6,8 @@
㉢ 있던 단가산출 — 안 고친 것 = 따라옴 · 다른 옵션을 고른 것 = 내 값 지킴 + 나머지 따라옴 ·
같은 옵션을 고른 것 = 내 값 지킴 + 알림 → [확인] 뒤 알림 없음 · 줄을 고친 것 + 옵션 기본 바뀜 = 줄 고침 지킴
(다시 복사 아님) · 기초 줄 이름만 바뀜 = 안 고친 줄 이름 따라옴.
㉣ 프로젝트 사본 — 고치기 전 굳힌 것 = 그대로 · 고친 뒤 굳힌 것 = 그때 단가산출 금액(손고침 기초 사본).
㉤ 손고침 기초 = 빌더가 안 덮음(그 로직 파일 글 = 저장본) · SK 층바탕 = {위: 기초, 빌더} → 기초에서 바꾼 옵션 = 위(주황).
㉣ 프로젝트 사본 — 고치기 전 굳힌 것 = 그대로 · 고친 뒤 굳힌 것 = 그때 단가산출 금액 ·
파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 M01 문서를 따라감.
㉥ 기초가 그룹째 뺀 줄 되살림 = 제 그룹(제목)으로 · 처음 문서 차례.
정본 파일 안 고침 — 수식 문서 폴더 = 임시 사본 · 층 = 임시 storage.
"""
@@ -22,7 +22,6 @@ import shutil
import pytest
from M01_MasterData import M01_MasterData_Doc as m01doc
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Item_Prices as item_prices
@@ -36,8 +35,6 @@ from resources.tester.test_m02_labor_ref import world # noqa: F401
ml = importlib.import_module("master_doc_link")
mcv = importlib.import_module("master_doc_cover")
cv = importlib.import_module("master_doc_convert")
build = importlib.import_module("build_수식문서_802_2")
CON = "GC000198" # 레디믹스트콘크리트 타설 — 선택 · 입력 옵션 · 인력 둘 · 굴착기 · 공구손료
CUT = "GC000088" # 터파기(기계) — 옵션 Type 이 굴착기를 고름
@@ -194,43 +191,13 @@ def test_프로젝트_사본(world, docs_tmp):
now = float(_read(me, key)["셈"]["계"])
assert now != was
assert before() == was # 고치기 전 굳힌 것 = 그대로
p = _read(proj, key) # 프로젝트 층 = 그대로
assert p["셈"]["계"] == in_proj["셈"]["계"] and _bare(p["문서"]) == _bare(in_proj["문서"])
p = _read(
proj, key
) # 파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 M01 문서를 따라감(855-E L4)
assert in_proj["셈"]["계"] == was and float(p["셈"]["계"]) == now
assert _freeze(me, key)() == now # 고친 뒤 굳힘 = 그때 단가산출 금액
def test_손고침_빌더_층바탕(world, docs_tmp):
_m01(CUT, _opt("Type", "TypeⅢ"))
saved = ml.load_all()[CUT]
assert saved.get(mcv.HAND)
files, whole = m01.loaded()
name = next(
n
for n, d in files.items()
if d.get("그룹") == "로직" and any(str(r.get("키")) == CUT for r in d.get("줄") or [])
)
rows = files[name]["줄"]
keys = [str(r["키"]) for r in rows]
result = {
"문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows},
"파일": {name: keys},
"저장": set(keys) & build.saved_keys(),
"저장본": build.carried(),
}
file = ml.FOLDER / ml.file_of(name)
assert build.files_of(result)[ml.file_of(name)] == file.read_text(encoding="utf-8")
assert CUT in build.hand_kept(result)
me = world["personal"]
got = _read(me, _sk(me, CUT))
assert _val(got["문서"], "Type") == "TypeⅢ" and set(got["층바탕"]) == {"위", "빌더"}
shown = _node(
{"문서": got["문서"], "위": got["층바탕"]["위"], "빌더": got["층바탕"]["빌더"], "고침": []}
)[0]
[(where, (kind, was, back))] = shown["표시"].items() # 기초에서 바꾼 옵션 = 위(주황)
assert (where, kind, was["연결"]["값"], back) == ("v:Type", "upper", "TypeⅠ", False)
assert shown["빠짐"] == {} and shown["줄틀"] == {}
def test_그룹째_뺀_줄_되살림_제_그룹():
top = _j(ml.load_all()["GC000994"]) # 인력 · 크롤러드릴 · 공기압축기 · 크레인 그룹
up = cp.deepcopy(top)
+11 -41
View File
@@ -1,9 +1,9 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""848-1 겹쳐 덮는 층(요구 889 · 요구서_889 1 절) — 층 셈 거울 · M01 기초 고침 저장 · SK 위 층 덮음 · 빌더 이어받기.
"""848-1 겹쳐 덮는 층(요구 889 · 요구서_889 1 절) — 층 셈 거울 · M01 기초 고침 저장 · SK 위 층 덮음.
① 거울 — 합침 · 층 합침 · 정리(위 층 대조) · 위 층 값 · 출처가 파이썬 = TS(손셈 기대값 몇 개 + 전수 대조).
㉠ M01 기초 고침(가격 · 조종원 · 작업량 시간당 + 변수) = 그 기초 셈만 바뀜 · 다른 기초 · 기계 정본 그대로 ·
문서 밖 기계 고침 뺌 · ㉥ 빌더 이어받기(덮음 얹음 · 손고침 문서 그대로 + 목록 · 같게 되돌리면 표지 없음) ·
문서 밖 기계 고침 뺌 · 줄 식 고침 = 받은 문서 그대로(손고침 표지 없음) ·
㉣ 정본 값으로 되돌림 = 고침 0 · 문서 바이트 = 고침 전.
㉡ 그 기초로 만든 SK = 위덮음 · 금액 = 기초 금액 · SK 고침 = ② 에만 · 금액 = ① + ② 셈 · 출처 ·
㉢ ② 를 위 층 값으로 = ② 0 · ㉤ 옵션으로 기계를 바꿔 저장해도 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐 ·
@@ -36,8 +36,6 @@ from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은
mc = importlib.import_module("master_doc_calc")
ml = importlib.import_module("master_doc_link")
mcv = importlib.import_module("master_doc_cover")
cv = importlib.import_module("master_doc_convert")
build = importlib.import_module("build_수식문서_802_2")
HERE = os.path.dirname(os.path.abspath(__file__))
COVER = mcv.COVER
@@ -206,30 +204,10 @@ def _calls(key: str) -> bool:
)
def _mini():
"""빌더 한 로직 파일 몫(BASE 가 든 파일) — {결과, 쓸 글, 파일}."""
files, whole = m01.loaded()
name = next(
n
for n, d in files.items()
if d.get("그룹") == "로직" and any(str(r.get("키")) == BASE for r in d.get("줄") or [])
)
rows = files[name]["줄"]
keys = [str(r["키"]) for r in rows]
result = {
"문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows},
"파일": {name: keys},
"저장": set(keys) & build.saved_keys(),
"저장본": build.carried(),
}
return result, build.files_of(result)[ml.file_of(name)], ml.FOLDER / ml.file_of(name)
def test_M01_기초_고침_빌더_이어받기_되돌림(docs_tmp):
def test_M01_기초_고침_되돌림(docs_tmp):
d = _defaults()
result, text, file = _mini()
file = ml.FOLDER / m01doc._where(BASE)
orig = file.read_text(encoding="utf-8") # 글(줄 끝 맞춤) — CRLF 체크아웃도 같게
assert text == file.read_text(encoding="utf-8") # 고침 없음 = 빌더 글 = 저장본
other = next(k for k in sorted(m01doc.docs()) if k != BASE and _calls(k))
before, other_before = m01doc.read(BASE)["셈"]["계"], m01doc.read(other)["셈"]["계"]
price = m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"]
@@ -243,27 +221,19 @@ def test_M01_기초_고침_빌더_이어받기_되돌림(docs_tmp):
assert m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"] == price # 기계 정본 그대로
line = next(x for x in got["셈"]["줄"] if x.get("작업량"))
assert line["작업량"]["꼴"] == "시간당" and str(line["작업량"]["변수"]["f"]) == "0.8"
# ㉥ 빌더 — 덮음 얹음(글 = 저장본)
result, text, _ = _mini()
assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == []
# ㉥ 손고침 — 줄 식을 고친 문서 = 저장본 그대로 + 목록 · 같게 되돌리면 표지 없음
def qty(text_):
return lambda doc: doc["금액"][0].update({"수량": text_})
first = m01doc.read(BASE)["문서"]["금액"][0]["수량"]
_save_m01(want, qty("Q_굴착기^표 × 9 ÷ Q_시공"))
assert ml.load_all()[BASE].get(mcv.HAND) is True
result, text, _ = _mini()
assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == [BASE]
_save_m01(want, qty(first))
assert mcv.HAND not in ml.load_all()[BASE]
# ㉣ 정본 값으로 되돌림 = 고침 0 · 글 = 고침 전
back = {NO: {"값": {"가격": float(d["값"]["가격"])}, "조종원": d["조종원"]},
SYM: {"작업량": {"방식": "일당"}}} # fmt: skip
got = _save_m01(back)
assert COVER not in got["문서"] and file.read_text(encoding="utf-8") == orig
assert got["셈"]["계"] == before
# 줄 식을 고친 문서 = 받은 문서 그대로 + 손고침 표지(한 번 붙으면 남음 · 855-E L4)
first = m01doc.read(BASE)["문서"]["금액"][0]["수량"]
got = _save_m01(None, lambda doc: doc["금액"][0].update({"수량": "Q_굴착기^표 × 9 ÷ Q_시공"}))
assert got["문서"]["금액"][0]["수량"] == "Q_굴착기^표 × 9 ÷ Q_시공"
assert ml.load_all()[BASE].get(mcv.HAND) is True
_save_m01(None, lambda doc: doc["금액"][0].update({"수량": first}))
assert ml.load_all()[BASE].get(mcv.HAND) is True
def _sk(me) -> str:
@@ -292,7 +292,7 @@ def _text(path: Path) -> bytes:
return path.read_bytes().replace(b"\r\n", b"\n") # 체크아웃 줄끝(CRLF) = 문서 화면 저장(LF)
def test_new_machine_goes_to_both_lists(copy: Path):
def test_new_machine_goes_to_doc_list(copy: Path):
client, docs_dir = _app(), copy / "수식문서"
before = {p.name: _text(p) for p in docs_dir.glob("*.json")}
row = {
@@ -313,7 +313,6 @@ def test_new_machine_goes_to_both_lists(copy: Path):
save([{"op": "add", "row": row}])
doc = ml.load_all(docs_dir)["GC000268"]
assert "9999-0848" in next(v for v in doc["변수"] if v["이름"] == "기계")["연결"]["목록"]
assert _pairs(copy, ml.load_all(docs_dir))[1] == 0
key = next(
r["키"] for r in m01.loaded()[1].index["EQ"].values() if r["원문번호"] == "9999-0848"
)
+5 -20
View File
@@ -1,12 +1,11 @@
"""M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만.
- 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글.
- 만들면 문서 있음 · 금액 = 본뜬 기초 문서 금액.
- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음 · [복사/생성] = 원본 문서 복제 + 기본정보(855 L3 ⓐ).
"""
from __future__ import annotations
import importlib
import shutil
from decimal import Decimal
from pathlib import Path
@@ -56,15 +55,7 @@ def _money(answer: dict) -> dict:
return {k: Decimal(str(answer[k])) for k in COSTS}
def _old(key: str) -> dict:
"""옛 엔진 금액(빌더 대조와 같은 길 · 기본 입력)."""
builder = importlib.import_module("build_수식문서_802_2")
whole = store.loaded()[1]
row = whole.logic(key) # 옛 로직 줄(같이 쓰기 · `/logic` 답은 머리만 · 855 L3 ⓐ)
return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1]))
def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진과_같다(client: TestClient) -> None:
def test_복사로_만든_로직은_수식_문서가_있고_금액이_본뜬_기초와_같다(client: TestClient) -> None:
made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, "이름": "sub5임시 본뜸"})
key = made["key"]
assert key.startswith("GX") and made["수식문서"] is True
@@ -72,14 +63,7 @@ def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진
assert got["새"] is False and got["파일"] == "수식_자체.json" and got["문서"]["식"]
assert got["셈"]["셈됨"] is True
source = _get(client, "/api/m01/logic/doc", key=SAMPLE)
assert _money(got["셈"]) == _old(key) == _money(source["셈"]) and _old(key)["계"] > 0
# 빌더가 다음에 다시 지어도 같은 파일 글(옛 로직 줄이 있는 키 = 빌더 몫)
builder = importlib.import_module("build_수식문서_802_2")
result = builder.build(log=lambda *_: None)
assert key in result["저장"]
want = builder.files_of(result)["수식_자체.json"]
assert (doc_screen.folder() / "수식_자체.json").read_text(encoding="utf-8") == want
assert _money(got["셈"]) == _money(source["셈"]) and _money(source["셈"])["계"] > 0
# 지우면 문서도 같이
info = _get(client, "/api/m01/logic", key=key)
@@ -97,7 +81,8 @@ def test_기본정보를_고쳐_복사해도_문서가_있고_save_지움이면_
made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, **more}) # 855 L3 ⓐ [복사/생성]
key = made["key"]
assert made["수식문서"] is True and key in doc_screen.docs()
assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == _old(key)
source = _money(_get(client, "/api/m01/logic/doc", key=SAMPLE)["셈"])
assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == source
head = _get(client, "/api/m01/logic", key=key)["logic"]
assert {k: head[k] for k in more} == more and head["키"] == key
+1 -3
View File
@@ -105,7 +105,7 @@ def test_화면_저장_길을_지나도_이름표가_같다(client: TestClient,
_ok(client.post("/api/m01/alias/save", json={"키": SAMPLE, "별칭": ""}))
assert "별칭" not in _doc(SAMPLE)
# 문서 저장 왕복 — 화면이 이름표 칸을 빼고 보내도 로직 줄 것으로 실림
# 문서 저장 왕복 — 화면이 이름표 칸을 빼고 보내도 저장된 문서 것으로 실림
got = _ok(client.get("/api/m01/logic/doc", params={"key": SAMPLE}))
sent = {k: v for k, v in got["문서"].items() if k not in md.TAGS}
_ok(client.post("/api/m01/logic/doc/save", json={"문서": sent, "판": got["판"]}))
@@ -122,12 +122,10 @@ def test_화면_저장_길을_지나도_이름표가_같다(client: TestClient,
"changes": [{"op": "edit", "key": key, "row": fixed}]} # fmt: skip
_ok(client.post("/api/m01/save", json={"files": [part]}))
assert _doc(key)["비고"] == "sub5임시 자체 비고"
assert _gaps(tmp_path, tmp_path / "수식문서") == []
info = _ok(client.get("/api/m01/logic", params={"key": key}))
body = {"key": key, "file": info["file"], "version": info["version"]}
_ok(client.post("/api/m01/logic/remove", json=body))
assert key not in doc_store.docs()
assert _gaps(tmp_path, tmp_path / "수식문서") == []
def test_tag_는_셈_칸을_안_건드림() -> None:
+14 -12
View File
@@ -1,9 +1,8 @@
"""855 L3 ⓐ 지킴 — M01 단가산출 기초가 수식 문서만으로 돎(로직 JSON 은 같이 쓰기만).
"""855 L3 지킴 — M01 단가산출 기초가 수식 문서만으로 돎(로직 JSON 을 읽지도 쓰지도 않음).
마스터 사본 두 벌에서 같은 차례로 부름 — 켬(로직 파일 있음 · 같이 쓰기 켬) / 끔(로직 파일 없음 ·
`Store_Logic.WRITE` 끔). 목록 · 상세 · 비고 [저장] · 개정 확인 409 · 판 409 · 별칭 · [신규] ·
[복사/생성] · [삭제] · 기계 등록 답이 두 벌 같음.
다른 자리(둘째 박자에서 걷을 것) = `/logic/doc` 의 「층바탕」(빌더 문서 = 옛 로직 줄 변환)만 — 빼고 견줌.
마스터 사본 두 벌에서 같은 차례로 부름 — 옛 로직 파일 놓임 / 없음. 목록 · 상세 · 비고 [저장] ·
개정 확인 409 · 판 409 · 별칭 · [신규] · [복사/생성] · [삭제] · 기계 등록 답이 두 벌 같음 ·
놓인 로직 파일은 글자 하나 안 바뀜 · 없는 쪽엔 안 생김.
"""
from __future__ import annotations
@@ -21,7 +20,6 @@ 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
@@ -42,7 +40,6 @@ def _world(tmp: Path, monkeypatch, logic: bool) -> TestClient:
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()
@@ -61,8 +58,6 @@ def _run(client: TestClient) -> 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
@@ -127,11 +122,17 @@ def _run(client: TestClient) -> list:
return out
def test_로직_파일_없이_같이_쓰기_끄고도_답이_같음(tmp_path: Path, monkeypatch) -> None:
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))
client = _world(tmp_path / "on", m, logic=True)
(tmp_path / "on" / "로직_건설품셈_99장_흉내.json").write_text(
'{"그룹": "로직", "원문": "건설품셈", "줄": [{"키": "GC999999", "이름": "흉내"}]}',
encoding="utf-8",
) # 옛 로직 파일이 남아 있어도 안 읽음
laid = {p.name: p.read_bytes() for p in (tmp_path / "on").glob("로직_*.json")}
on = _run(client)
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]
@@ -147,4 +148,5 @@ def test_로직_파일_없이_같이_쓰기_끄고도_답이_같음(tmp_path: Pa
json.dumps(a[3], ensure_ascii=False)[:300],
json.dumps(b[3], ensure_ascii=False)[:300],
)
assert not list((tmp_path / "off").glob("로직_*.json")) # 끔 = 로직 파일을 만들지 않음
assert not list((tmp_path / "off").glob("로직_*.json")) # 로직 파일을 만들지 않음
assert {p.name: p.read_bytes() for p in (tmp_path / "on").glob("로직_*.json")} == laid
+3 -4
View File
@@ -254,10 +254,9 @@ def test_로직_지우기_검사는_모든_층_일위대가를_봄(tmp_path, mon
monkeypatch.setattr(layers, "SYSTEM_ROOT", system) # 검사는 39-1d 한 벌(층 자리 = layers)
monkeypatch.setattr(config_system, "STORAGE_BASE_DIR", str(storage))
class Gone: # STONE 을 지운 마스터
def logic(self, code):
if code == STONE:
raise cache.cm.mf.FormulaError("없음")
class Gone: # STONE 을 지운 기초(있는 기초 키 묶음)
def __contains__(self, code):
return code != STONE
got = cache.labor_errors(Gone())
assert len(got) == 2 and all(STONE in x for x in got)
+6 -8
View File
@@ -377,10 +377,9 @@ def test_로직_지우기_검사는_승격_줄도_보고_참조_줄은_건너뜀
line = {"참조": {**SYS, "키": sp}}
store.write("labor", "rv", have["판"], {**have["문서"], "담은로직": [line]})
class Gone: # STONE 을 지운 마스터
def logic(self, code):
if code == STONE:
raise cache.cm.mf.FormulaError("없음")
class Gone: # STONE 을 지운 기초(있는 기초 키 묶음)
def __contains__(self, code):
return code != STONE
assert cache.labor_errors(Gone()) == [] # 옛 승격 서고는 안 봄(134-2) · 참조 줄 건너뜀
with store.at(world["system"]):
@@ -439,10 +438,9 @@ def test_사전조합_로직_줄_섞임_합은_손셈_지우기_409_굳힘(world
assert one["반영"]["계"] == pytest.approx(float(want * 5), abs=20) # 751-3 끝수 × 5
assert [x.get("로직") or x["참조"]["키"] for x in one["안"]] == [sp, STONE, TEN]
class Gone: # STONE 을 지운 마스터
def logic(self, code):
if code == STONE:
raise cache.cm.mf.FormulaError("없음")
class Gone: # STONE 을 지운 기초(있는 기초 키 묶음)
def __contains__(self, code):
return code != STONE
got = cache.labor_errors(Gone())
assert f"사전조합 마스터 「{sc}」 이 로직 「{STONE}」 을 씀 — 거기서 먼저 뺌" in got