refactor(855-E L3b ②): 로직 줄 같이 쓰기 끔 — mirror · 스위치 · 빌더 문서 갈래 걷음
- Store_Logic: WRITE · CALC · mirror · _ordered · _headed_row · _picks · _write 지움(로직 JSON 쓰는 곳 0) - Machine.register 의 mirror 줄 · Store_Save._logic_file · Store_Cache 「!= 로직」 표지 걷음 · labor_errors = 있는 기초 키(수식 문서)만(whole.logic 갈래 지움) - M01 Doc: _row · sync_tags · ensure · built · of_row · make 지움 · 읽기 「층바탕」(빌더 문서) 뺌 · 손고침 = 셈 칸을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 브레인 정함) - M02 Doc_Sk.base_doc · Doc_Sk_Path 층바탕의 빌더 문서 갈래 지움(그 자리 = 지금 문서) - 화면 LogicRow 셈 칸 · [신규] 빈 셈 칸 · 안 쓰는 꼴 셋 지움 - 시험: 855_l3_doc_only = 옛 로직 파일 놓여도 안 읽고 안 씀 · 848_1 손고침 표지 · 848_10 빌더 층 시험 지움 · 파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 문서를 따라감 · 854_2 복사 = 원본 문서 금액(옛 엔진 대조 뺌) · 848_5 · 855_l1 로직 줄 대조 뺌 · labor_errors 손님 셋 = 있는 키 묶음 - 서버 답 243 건 다름 0 · typecheck 0 · 관련 105 파일(717_2a 원래 실패 · 792_3 엔진 몸 일감 몫 빼고) 통과 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -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,
|
||||
) # 그 파일이 이 파일을 부름 — 늦게
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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.개정확인)
|
||||
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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"))
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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 };
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -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, {})
|
||||
|
||||
@@ -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,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)
|
||||
|
||||
@@ -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"
|
||||
)
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user