diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index b3b31c6f6..8422ece55 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -47,7 +47,6 @@ OLD_FIELDS = ( "수식고침", "고름", "자재표시", "켜쌓기율", ) # fmt: skip _STAMPED = ("원값", "바탕판", "처음수량", "M01판", "끊음") # 서버가 적는 칸 — 옛 칸 대조에서 뺌 -OLD: ContextVar[bool] = ContextVar("옛길", default=False) # 옛 셈 길(옮기기 전 금액 대조) SAVING: ContextVar[dict | None] = ContextVar("수식길저장", default=None) # {키, 사본} — 수식 길만 diff --git a/M02_MasterTemplete/M02_Labor_Copy.py b/M02_MasterTemplete/M02_Labor_Copy.py index a71221c8e..c5c8fc785 100644 --- a/M02_MasterTemplete/M02_Labor_Copy.py +++ b/M02_MasterTemplete/M02_Labor_Copy.py @@ -30,6 +30,7 @@ import master_doc_trace as mt # noqa: E402 — scripts 길 = dc(855-F 셈 기 KEY, JOB, PRICE, REGEN = skc.KEY, skc.JOB, skc.PRICE, skc.REGEN _SC = re.compile(r"^SC-\d{6}$") +_HOLE = re.compile(r"\{([^{}]+)\}") # 틀 구멍 `{S_규격}` def _project() -> bool: @@ -136,14 +137,9 @@ def _formula_of(doc: dict) -> dict | None: def line(whole: Any, doc: dict, one: dict) -> dict[str, Any]: """로직 줄 기준 — 층 셈 = 수식 문서 셈 한 길(줄 옵션 = 문서 규칙 · `dc.line_doc` · 줄 = 문서 답 줄 · - 재료 = 셈 기록이 읽은 품목 · 옛 엔진 안 돎 · 855 2-C1 · 2-C5) · 수식 사본 있음 = 사본 · 없음(저장 전 새 문서) = - 지금 M01 문서(저장 때 사본 찍음) · 프로젝트 층 · B09(단가 책) · `OLD` 시험 = 옛 길(B9 걸음 몫).""" - from M02_MasterTemplete import M02_Labor_Doc as labor - + 재료 = 셈 기록이 읽은 품목 · 옛 엔진 안 돎 · 855 2-C1 · 2-C5) · 수식 사본 있음 = 사본 · 없음(저장 전 새 문서 · + 프로젝트 층) = 지금 M01 문서(저장 때 사본 찍음 · 프로젝트 층 옛 엔진 갈래 걷음 · 855-E 2-E4).""" code, rate, picks = one["로직"], one.get("켜쌓기율"), one.get("고름") - if _project() or dsk.OLD.get(): - got = labor.run_line(whole, code, one.get("입력값"), rate, picks) - return labor.drop_apart(got, one.get("자재표시")) copy = _formula_of(doc) if copy and getattr(whole, "_tag", None) == (copy.get("판"), copy.get("단가판")): base, docs = copy["부름"].get(code), dc.docs_of(copy) @@ -167,7 +163,7 @@ def line(whole: Any, doc: dict, one: dict) -> dict[str, Any]: for n, x in enumerate(ans.get("줄") or []) if n not in apart ] - found = _mats(mats, ans, picks) + found = _mats(mats, ans, picks, base) return {"기준": got, "줄": lines, "재료": found, "까닭": None if got else dc.why(ans)} @@ -183,9 +179,24 @@ def _traced(doc: dict, whole: Any, docs: dict, given: dict, copy: dict) -> dict: } -def _mats(mats: list, ans: dict, picks: Any) -> list[dict[str, Any]]: +def _tied(link: dict, doc: dict) -> list[str]: + """재료 조건 · 요소 키 틀 구멍에 든 입력 이름(화면 `releaseTied` 가 그 입력이 바뀌면 고름을 풂 · 문서 몫 · + 855-E 2-E4 — 옛 `logic_mats` 의 `걸림`).""" + texts = [v for v in (link.get("재료") or {}).values() if isinstance(v, str)] + texts += [str(link.get("키") or "")] + holes = {h for t in texts for h in _HOLE.findall(t)} + ids = {dc.md.var_id(v): v for v in doc.get("변수") or []} + names = { + str(ids[h].get("열쇠")) + for h in holes + if h in ids and (ids[h].get("연결") or {}).get("갈래") in ("입력", "선택") + } + return sorted(names) + + +def _mats(mats: list, ans: dict, picks: Any, doc: dict) -> list[dict[str, Any]]: """로직 자재(103-1) — 재료 금액 줄(`_mat_lines` · 단위 = 연결 단위 = 로직 원문 표기)마다 - 셈 기록이 읽은 품목 키 · 수량 · 단가 · 금액(별도계상 · 같은 품목 400 · `_inside` 가 읽음).""" + 셈 기록이 읽은 품목 키 · 수량 · 단가 · 금액 · 걸린 입력(별도계상 · 같은 품목 400 · `_inside` 가 읽음).""" calls, lines, out = ans.get("부름") or [], ans.get("줄") or [], [] for n, line, link in mats: if n >= len(lines): @@ -204,6 +215,7 @@ def _mats(mats: list, ans: dict, picks: Any) -> list[dict[str, Any]]: } | head | {"품목": {"키": key} if key else None, "고름": str(n) in (picks or {})} + | {"걸림": _tied(link, doc)} ) return out diff --git a/M02_MasterTemplete/M02_Labor_Doc.py b/M02_MasterTemplete/M02_Labor_Doc.py index 50a15fc5e..826c55f5f 100644 --- a/M02_MasterTemplete/M02_Labor_Doc.py +++ b/M02_MasterTemplete/M02_Labor_Doc.py @@ -7,34 +7,32 @@ 이름은 구조물 열 이름(따로 안 둠). 수량 = `null`(면적산출 알약 칸 값 · 로직 알약 「이름|단위」 · 자재 알약 「자재|MT키」) | `{손: 수}` (손이 칸보다 앞섬) · 같은 로직 두 번 금지 · 입력값 = 그 로직 입력 이름만(빈 값 = 자동값). -금액: 기준 = 결과단위 그대로(서버 단독 · M01 엔진) · 반영 = 기준 × 수량 ÷ 배 · 돈 아닌 로직은 +금액: 기준 = 결과단위 그대로(서버 단독 · 로직 줄 = 수식 문서 셈 `Labor_Copy.line`) · 반영 = 기준 × 수량 ÷ 배 · 돈 아닌 로직은 반영 없음 · 자재 기준 단가 = `master_material.element` 기본값 · 자재 줄에 값 열 다섯(`가격`) · 기준단가가 된 칸 이름(`기준칸`)도 실음(43-3). 켜쌓기율(85-2) = 표 주문 「골쌓기 기준」 로직만 · % · 없음 = 100 · 그 로직 세부항목 줄 전부 수량 × 율 -(`layered` · `run_line` 한 곳 → 문서 · 프로젝트 사본 · 서고 같은 함수). +(문서 규칙 `M02_Doc_Copy.line_doc` · 문서 · 프로젝트 사본 · 서고 같은 함수). 참조 줄(단가승격 · 사전조합 · 50-3) = 기준이 가리킨 문서 1 단위 값(펼침 `M02_Labor_Ref.Expand` · 안 줄 수량 = 같은 given 의 안 줄 알약 · 723-1) · 분모 = 그 문서 단위 · 배 1 · 알약 키 = `ref_id` · 같은 참조 두 번 금지. 짝(CLAUDE.md 5장 ①): 수량 · 반영 · 합 `settle` ↔ `M02_MasterTemplete_Labor_Calc.ts` — 거울 시험 `resources/tester/test_m02_labor_calc_mirror.py`. 규격 열(704-4) = 문서 `규격?` 칸 · 열마다 줄 수량(`M02_Labor_Spec` · settle `col`) · 계산값 `규격합`. -로직 자재(103-1) = 담은 로직 맨 위 층 호표 재료 줄(`logic_mats` · 줄마다 `재료`) · +로직 자재(103-1) = 담은 로직 문서 재료 금액 줄(`Labor_Copy.line` · 줄마다 `재료`) · 고름 = `{호표 차례: MT키}`(엔진 `choosing` 그대로) · 금액은 로직 재료비 안이라 합 · 알약에 안 더함(보기만) · 사용자 자재와 같은 품목 두 번은 [저장] 때 400. 승격(134-1) = 로직 줄 「단가승격」 표시(`true` 만 · 없음 = 단가산출) · 금액 무관 · B09 호표 몫. 자재 세 칸(148-4) = `MARKS` 허용 값만(그 밖 · 빈 것 버림 · 별도계상만 금액에 닿음) — 사용자 자재 = 줄 덧칸 · 로직 자재 = 로직 줄 `자재표시 {호표 차례: {세 칸}}`(차례가 재료 줄인 것만 · 틀리면 버림) · 빈 칸 = 읽을 때 `MARK_DEFAULT`(`mark_of` · 저장은 비움 · 옛 「일반」 = 버림 → 사급 · 162-1). -별도계상(222-1) = 그 자재 금액은 기준 · 합에서 빠지고 로직 `줄` 에서 지움(`drop_apart` · `settle` · +별도계상(222-1) = 그 자재 금액은 기준 · 합에서 빠지고 로직 `줄` 에서 지움(문서 `합밖` · `settle` · 짝 `Labor_Calc.ts`) · `재료` · `자재`(자재목록 · B08 수량)엔 남음. 고정 줄(705-1) = `{고정: {이름 · 규격 · 단위 · 단가 · 이음 · 출처}}` — 숫자 그대로 · 셈 `M02_Labor_Fixed`. -% 덧줄(149-4) = 식 「X * Y / 100」 덧줄에 덧칸 `율`(Y) · `규격`(「노무비의 %」 등 · `pct_extras`) — 표기만 · -단위 · 수량 · 금액 그대로(「식 · 1」) · 화면이 율 · % 로 그림 · M01 시험계산 표도 이 함수. +옛 엔진 줄 셈(`run_line` · `pct_extras` · `logic_mats` · `layered` · `drop_apart`) = 855-E 2-E4 에서 걷음. """ from __future__ import annotations import json -import re from decimal import Decimal, InvalidOperation from typing import Any @@ -62,7 +60,6 @@ MARKS = { } MARK_DEFAULT = {"자재구분": "사급", "별도계상": "별도계상", "운반비": "포함"} # 읽을 때 기본(162-1) ALIAS_MAX = 40 # 별칭(44-6) 글자 수 상한 — 화면 칸과 같음 -_BRACE = re.compile(r"\{([^{}]+)\}") # 품목 조건의 {입력} def _bad(text: str) -> store.StoreError: @@ -80,11 +77,26 @@ def _number(raw: Any) -> Decimal | None: return got if got.is_finite() else None -def _specs(logic: dict) -> list[dict]: - """로직 입력 꼴 — 흐름 로직은 「설계 때 정할 것」.""" - if isinstance(logic.get("흐름"), dict): - return mf.inputs_of(logic) - return list(logic.get("입력") or []) +def _head(whole: Any, code: str) -> dict: + """담을 로직 머리(855-E 2-E4 · M01 로직 줄 안 읽음) — 입력 이름 = 문서 입력 · 선택 열쇠 · 호표 = 문서 + 금액 줄(재료 줄 표지 · 차례 = 호표 차례) · 문서 없음 = FormulaError.""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Prices as prices + + doc = dc.doc_of(whole, code) + if doc is None: + raise mf.FormulaError(f"없는 로직 「{code}」") + mats = {n for n, _, _ in prices._mat_lines(doc)} + return { + "키": code, + "이름": doc.get("이름"), + "결과단위": doc.get("결과단위"), + "입력": [{"이름": n} for n in prices.doc_inputs(doc)], + "호표": [ + {"이름": x.get("이름"), "종류": "재료" if n in mats else ""} + for n, x in enumerate(doc.get("금액") or []) + ], + } def _qty(value: Any, where: str) -> dict | None: @@ -136,13 +148,13 @@ def clean(doc: Any) -> dict[str, Any]: continue code = str(one.get("로직") or "") try: - logic = whole.logic(code) + logic = _head(whole, code) except mf.FormulaError as e: raise _bad(f"{where} · {e}") from e if code in seen: raise _bad(f"{where} · 같은 로직을 두 번 담음 「{code}」") seen.add(code) - names = {str(spec.get("이름")) for spec in _specs(logic)} + names = {str(x["이름"]) for x in logic["입력"]} given = one.get("입력값") or {} if not isinstance(given, dict): raise _bad(f"{where} · 입력값이 묶음 아님") @@ -254,23 +266,6 @@ def apart(one: Any) -> bool: return mark_of(one, "별도계상") == "별도계상" -def drop_apart(got: dict[str, Any], shown: Any) -> dict[str, Any]: - """로직 줄 답(`run_line`)에서 별도계상 로직 자재 빼기(222-1) — 그 재료 줄 금액을 기준에서 빼고 - `줄`(일위대가 상세)에서 지움 · `재료`(자재목록 · 세 칸 고침)는 그대로. - ponytail: 「재료비의 %」 덧줄은 엔진 값 그대로(뺀 재료 몫 안 고침) — 그런 로직이 별도계상을 쓰면 엔진에 넘김.""" - shown = shown if isinstance(shown, dict) else {} - lines = got.get("줄") or [] - out = { - n - for m in got.get("재료") or [] - if (n := m["차례"]) < len(lines) and apart(shown.get(str(n))) - } - if not out or not got.get("기준"): - return got - got = mcut.plain(got, out) # 기준 = 남은 줄 합(751-3 끝수 · 791-1 셈법) - return {**got, "기준": _json(got["기준"])} - - def _mat_marks(value: Any, logic: dict) -> dict[str, dict[str, str]] | None: """로직 자재 세 칸(148-4) `{호표 차례: {세 칸}}` — 맨 위 층 재료 줄 차례 · 허용 값만 · 빈 것 = None.""" @@ -297,28 +292,6 @@ def _rate(value: Any, code: str, where: str) -> int | float | None: return int(rate) if rate == rate.to_integral_value() else float(rate) -def layered(got: dict[str, Any], rate: Any) -> dict[str, Any]: - """엔진 답 × 켜쌓기율(85-2) — 세부항목 줄 전부 수량 · 금액 · 비목 · 비목 합 · 계 · 단가는 그대로.""" - if rate in (None, 100) or "결과" in got: - return got - times = Decimal(str(rate)) / 100 - - def mul(value: Any) -> Any: - return value * times if isinstance(value, Decimal) else value - - lines = [ - { - **x, - "수량": mul(x.get("수량")), - "금액": mul(x.get("금액")), - "비목": {k: mul(v) for k, v in (x.get("비목") or {}).items()}, - } - for x in got.get("줄") or [] - ] - sums = {k: mul(got[k]) for k in COSTS} - return {**got, "줄": lines, **sums, "계": sum(sums.values())} - - def from_combo(key: str) -> dict[str, Any]: """옛 일위대가 조합(마스터 UA · 회사 UC · 개인 UP) → 일위대가 문서 몸 — 담은로직 · 단위 복사 · 입력값 {} · 수량 null · 자재 [] · `본뜬` = 그 조합(층 · 주인 · 키). @@ -542,110 +515,6 @@ def calc( return settle(_json({"줄": lines, "자재": mats}), doc, have) -def run_line( - whole: Any, code: str, given: Any, rate: Any = None, picks: Any = None, raw: bool = False -) -> dict[str, Any]: - """로직 한 줄 기준(서버 단독 · M01 엔진 · 빈 입력 = 자동값 · × 켜쌓기율 · 고른 재료 = 엔진 - `choosing`) — `{기준, 줄, 재료, 까닭}` · 돈 아닌 로직은 `{결과, 기준: None}`(반영 없음) · - 끝수 = 품셈 1-2-2(`master_cut` · 751-3) · `raw` = 엔진 날 값(B09 = 제 단가로 버림).""" - try: - logic = whole.logic(code) - auto = {k: v for k, v in m01.mau.values(whole, logic).items() if v is not None} - with mf.mp.choosing(picks): - got = layered(mf.run(whole, code, {**auto, **m01._dec(given or {})}), rate) - got = got if raw else mcut.engine(whole, code, got) # 율 곱 → 끝수(문서 셈 · 844-1) - except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e: - return {"기준": None, "까닭": str(e) or type(e).__name__} - if "결과" in got: - return {"결과": got["결과"], "기준": None, "까닭": None} - # 「줄」 = 그 로직 재료 · 노무 · 경비 줄(줄 누름 상세 · 50-4) - money = {k: got[k] for k in (*COSTS, "계")} - mats = logic_mats(whole, logic, got["줄"], picks) - lines = pct_extras(whole, logic, got["줄"], got.get("중간") or {}) - out = {"기준": money, "줄": lines, "재료": mats, "까닭": None, **mcut.kept(got)} - return out - - -def pct_extras(whole: Any, logic: dict, lines: list[dict], env: dict) -> list[dict]: - """% 덧줄(149-4) — 덧줄 식이 「X * Y / 100」 이면 그 엔진 줄(호표 수 뒤 같은 차례)에 덧칸 - `율` = Y(엔진 마지막 env 로 셈) · `규격` = X 이름(「노무비의 %」 · 인력 줄 합 「인건비의 %」 · - `줄.'이름'` · 중간값 「이름의 %」 · 그 밖 복합 = 빈 글). 다른 덧줄 · 흐름 로직 · 못 셈 = 그대로.""" - if isinstance(logic.get("흐름"), dict): - return lines - out, head = list(lines), len(logic.get("호표") or []) - for n, add in enumerate(logic.get("덧줄") or []): - if head + n >= len(out): - break - try: - node = mf.parse(add.get("식") or "") - except mf.FormulaError: - continue - if not ( - node[0] == "bin" - and node[1] == "/" - and node[3] == ("num", Decimal(100)) - and node[2][0] == "bin" - and node[2][1] == "*" - ): - continue # 금액 식(기계손료 등) · 조건부 % = 「식」 그대로 - base, part = node[2][2], node[2][3] - try: - rate = mf.evaluate(part, dict(env), whole) - except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): - continue - if isinstance(rate, Decimal): - out[head + n] = {**out[head + n], "율": rate, "규격": _pct_base(base)} - return out - - -def _pct_base(node: tuple) -> str: - """% 덧줄 밑수 이름 — B09 대가(`B09_Estimation_Labor_Source._base_of`)와 같은 말.""" - if node[0] == "name": - return f"{node[1]}의 %" # 노무비 · 재료비 · 경비 · 중간값 이름 - if node[0] == "field" and node[1] == ("name", "줄"): - return f"{node[2]}의 %" - parts = list(mf.walk(node)) - if any(x[0] == "ref" and str(x[1]).startswith("LB") for x in parts) and not any( - x[0] == "name" and x[1] in COSTS for x in parts - ): - return "인건비의 %" - return "" - - -def logic_mats(whole: Any, logic: dict, lines: list[dict], picks: Any) -> list[dict[str, Any]]: - """로직 자재(103-1) — 맨 위 층 호표 재료 줄마다 엔진 답 줄(같은 차례) 그대로 · 금액은 로직 - 재료비 안(합에 안 더함) · `걸림` = 품목 조건에 든 입력 이름(중간값이면 입력 전부 — 그 입력이 - 바뀌면 화면이 고름을 풂 · 짝 `M02_Labor_LogicMats_Model.ts` `releaseTied`).""" - if isinstance(logic.get("흐름"), dict): - return [] # 흐름 로직 재료 자리는 입력 이름 — 이번엔 안 보임 - names = {str(spec.get("이름")) for spec in _specs(logic)} - out = [] - for n, item in enumerate(logic.get("호표") or []): - if item.get("종류") != "재료" or n >= len(lines): - continue - line, goods = lines[n], lines[n].get("품목") - try: - row = (whole.get(goods["키"]) if goods else None) or {} - except mf.FormulaError: - row = {} - cond = item.get("요소") - texts = cond.values() if isinstance(cond, dict) else [cond] - tied = {w for t in texts if isinstance(t, str) for w in _BRACE.findall(t)} - out.append( - { - "차례": n, - "이름": item.get("이름") or "", - "단위": item.get("단위") or "", - **{k: line.get(k) for k in ("수량", "단가", "금액", "까닭")}, - "품목": goods, - "가격": {slot: row.get(slot) for slot in mm.SLOTS}, - "고름": str(n) in (picks or {}), - "걸림": sorted(tied if tied <= names else names) if tied else [], - } - ) - return out - - def ref_line(ref: dict, got: dict[str, Any]) -> dict[str, Any]: """참조 줄 계산 답 — 분모 = 가리킨 문서 단위 · 배 1 · `안` = 사전조합 안 줄(한 층).""" line = {"참조": ref, "이름": got.get("이름"), "알약": refs.ref_id(ref), "분모": got.get("단위")} diff --git a/M02_MasterTemplete/M02_Labor_Ref.py b/M02_MasterTemplete/M02_Labor_Ref.py index c363d7921..453760ccd 100644 --- a/M02_MasterTemplete/M02_Labor_Ref.py +++ b/M02_MasterTemplete/M02_Labor_Ref.py @@ -3,7 +3,7 @@ 자리 = 층 양식 길 종류(`M02_Template_Layers.LIBRARY_KINDS`) — 파일 이름 = 키: promote 옛 단가승격 `{층}/promote/SP-######.json`(134-2 · 새로 안 만듦 · 읽기 · 셈만) — `{종류:"단가승격", 키, 이름, 단위, 배, 담은로직:[{로직, 입력값}]}` · 값 = 로직 기준 ÷ 배 · - 층 문서를 읽을 때 옛 참조 줄 = 로직 줄 + `승격`(`unpromote`) · 프로젝트 사본은 그대로 셈 + 프로젝트 사본은 그대로 셈 precombo `{층}/precombo/SC-######.json` 사전조합 `{종류:"사전조합", 키, 이름, 단위, 본뜬, 담은로직:[{참조, 수량:{손}, 메모} | {로직, 입력값, 메모, 수량:{손}, 고름?, 자재표시?}], 자재:[일위대가 자재 꼴]}` — @@ -247,55 +247,6 @@ def saved_qty(one: dict[str, Any]) -> dict[str, Any]: return {**one, "수량": {SAVED: hand}} -_OLD_CLASS = re.compile(r"품셈") # 134-5 — 옛 품셈 분류(건설품셈 공통 · 산림품셈 · 07장 …) - - -def filled(kind: str, doc: Any) -> Any: - """옛 서고 문서 읽을 때 칸 채움 — 칸 없음(51-12 앞) · 옛 품셈 분류(134-5) = 빈 글(미분류) · - 파일은 안 고침([저장] 때 굳음) · 그 밖 지금 값 그대로(구조물정의가 바뀌어도 화면이 선택지로 둠).""" - if not isinstance(doc, dict) or kind not in PREFIX: - return doc - if "구분" in doc and not _OLD_CLASS.search(str(doc.get("구분") or "")): - return doc - return {**doc, "구분": "", "상세구분": ""} - - -def unpromote(kind: str, doc: Any) -> Any: - """층 문서를 읽을 때(134-2) — 옛 단가승격 참조 줄 → 로직 줄 `{로직, 입력값, 켜쌓기율, 수량}` + - 일위대가면 `승격: true`(사전조합 안 로직 줄엔 없음) · 값 같음(승격 값 = 기준 ÷ 배 = 로직 줄 반영) · - 같은 로직 줄이 이미 있으면 그 줄은 옛 참조 그대로(읽기 · 셈 · 저장 됨) · 파일은 안 고침([저장] 때 굳음).""" - lines = doc.get("담은로직") if isinstance(doc, dict) and kind in ("labor", "precombo") else None - if not isinstance(lines, list): - return doc - have = {str(one.get("로직")) for one in lines if isinstance(one, dict) and one.get("로직")} - out, changed = [], False - for one in lines: - ref = one.get("참조") if isinstance(one, dict) else None - src = ( - read_ref(ref) if isinstance(ref, dict) and kind_of(ref.get("키")) == "promote" else None - ) - line = ((src or {}).get("담은로직") or [None])[0] - code = str(line.get("로직") or "") if isinstance(line, dict) else "" - if not code or code in have: - out.append(one) - continue - have.add(code) - changed = True - # ponytail: 수량 null(면적산출 칸 연결)은 알약 키가 로직 것으로 바뀌어 칸을 다시 이어야 함 - out.append( - { - "로직": code, - "별칭": one.get("별칭"), - "메모": one.get("메모"), - "입력값": dict(line.get("입력값") or {}), - "수량": one.get("수량"), - **{k: line[k] for k in ("켜쌓기율", "고름") if line.get(k) is not None}, - **({"승격": True} if kind == "labor" else {}), - } - ) - return {**doc, "담은로직": out} if changed else doc - - def _combo_lines(doc: dict, key: str) -> list[dict[str, Any]]: """참조 줄 `{참조, 수량, 메모}` · 로직 줄 `{로직, 입력값, 메모, 수량}`(51-11) — 검사는 일위대가와 같은 길(`labor.clean` · 같은 로직 · 같은 참조 두 번 · 입력값) · 수량 기본 {손: 1}.""" @@ -404,7 +355,7 @@ def summary( """층 목록 한 줄에 붙일 것 — `{제목, 단위, 구분, 상세구분, 연결}`(51-12) · `expand` 면 1 단위 기준 계(`기준금액` · 51-4).""" try: - doc = filled(kind, json.loads((Path(folder) / kind / f"{key}.json").read_bytes())) + doc = json.loads((Path(folder) / kind / f"{key}.json").read_bytes()) except (OSError, ValueError): return {} keep = ("구분", "상세구분", "연결") @@ -450,14 +401,6 @@ def summaries(folder: Path, rows: list[dict[str, Any]]) -> None: row.update(summary(folder, row["종류"], row["이름"], expand, files)) -# ── 쓰는 곳 · 지우기 ────────────────────────────────────────────────── -def refuse_used(folder: Path, kind: str, key: str) -> None: - """쓰는 곳이 있으면 409 — 쓰는 곳 색인 한 벌(`M02_Library_Uses` · 858 5-5).""" - from M02_MasterTemplete import M02_Library_Uses as uses - - uses.refuse_used(folder, kind, key) - - # ── 층 사이 복사 ────────────────────────────────────────────────────── def origin_mark(doc: dict[str, Any], ref: Ref) -> dict[str, Any]: """복사 문서의 `본뜬` — 실무자료 본뜬(키 · 전국자재 …)은 지키고 원본 참조는 `복사원본` 칸에 둠.""" diff --git a/M02_MasterTemplete/M02_Library_Delete.py b/M02_MasterTemplete/M02_Library_Delete.py index 61329df94..1a8f3b92e 100644 --- a/M02_MasterTemplete/M02_Library_Delete.py +++ b/M02_MasterTemplete/M02_Library_Delete.py @@ -34,9 +34,6 @@ _ADD = re.compile(r"^add:#(\d+)(.*)$") _PATCH = ("덮개", "고름", "자재표시") -can_write = access.can_write # 쓰기 판단 한 벌(858-B) — 이름은 5-8 에서 걷음 - - def _hits(doc: dict[str, Any], rids: dict[str, str]) -> list[tuple[str, str]]: """문서 안 지울 참조 줄 — [(줄, 키)].""" out = [] @@ -84,7 +81,7 @@ def users(session: dict[str, Any] | None, kind: str, gone: list[str]) -> list[di if not hits: continue at = refs.where(path.parent.parent) - ok = can_write(session, at) + ok = access.can_write(session, at) name = doc.get("일위대가번") or doc.get("이름") or path.stem if ukind == "labor" and (title := _columns(path.parent.parent, memo).get(path.stem)): name = f"{title} · {name}" @@ -180,7 +177,7 @@ def remove( files[at] = r done: list[dict[str, Any]] = [] # ponytail: 부르는 곳(`Precombo_Folders.edit`)의 `store.batch` 안 — 실패하면 앞서 고친 파일을 - # 앞판 바이트로 되돌림(되돌림 몸을 `batch` 로 옮기는 것은 5-8) + # 앞판 바이트로 되돌림 · 되돌림을 `batch` 가 맡으면(파일마다 앞판 기록) 이 몸을 걷음 for path, r in files.items(): raw = path.read_bytes() try: @@ -259,7 +256,7 @@ def undo(session: dict[str, Any], folder: Path, kind: str, rec: dict[str, Any]) at = (one.get("층"), one.get("주인")) path = refs.folder_of(*at) / str(one.get("종류")) / f"{one.get('이름')}.json" try: - if not can_write(session, at) or not path.is_file(): + if not access.can_write(session, at) or not path.is_file(): raise store.StoreError(403, "권한 밖 · 없음") raw = path.read_bytes() if store.version_of(raw) != one.get("뒤판"): diff --git a/M02_MasterTemplete/M02_Library_Same_Router.py b/M02_MasterTemplete/M02_Library_Same_Router.py index d17ee2a0f..6d1d14901 100644 --- a/M02_MasterTemplete/M02_Library_Same_Router.py +++ b/M02_MasterTemplete/M02_Library_Same_Router.py @@ -88,10 +88,6 @@ def _docs(at: refs.Here, kind: str) -> list[tuple[str, dict[str, Any]]]: # ── 쓰는 곳 ─────────────────────────────────────────────────────────── -def _can_write(session: Session, at: refs.Here) -> bool: - return access.can_write(session, at) - - def _retarget(doc: dict[str, Any], olds: set[str], new: refs.Ref) -> dict[str, Any]: """문서의 `olds` 참조를 모두 `new` 로(규격 열 수량 열쇠까지 · `M02_Labor_Ref` 한 벌).""" done: dict[str, refs.Ref] = {} @@ -229,7 +225,7 @@ def _merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[s for path, (ukind, olds) in by_file.items(): at = refs.where(path.parent.parent) why = "" - if not (_can_write(session, at) and refs.readable(at, keep)): + if not (access.can_write(session, at) and refs.readable(at, keep)): why = "권한 밖" else: try: @@ -306,7 +302,7 @@ def _undo(session: Session, folder: Path, kind: str, key: str) -> dict[str, Any] at = (one.get("층"), one.get("주인")) user = refs.folder_of(*at) / str(one.get("종류")) / f"{one.get('이름')}.json" try: - if not _can_write(session, at) or not user.is_file(): + if not access.can_write(session, at) or not user.is_file(): raise store.StoreError(403, "권한 밖 · 없음") _rewrite(user, str(one.get("종류")), {refs.ref_id(keep)}, new) back += 1 diff --git a/M02_MasterTemplete/M02_MasterTemplete_Router_Layers.py b/M02_MasterTemplete/M02_MasterTemplete_Router_Layers.py index 5dc148576..3f5cad4d6 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Router_Layers.py +++ b/M02_MasterTemplete/M02_MasterTemplete_Router_Layers.py @@ -24,10 +24,10 @@ from common_util import common_util_spreadsheet as spreadsheet from common_util.common_util_auth import verify_session from common_util.common_util_storage import resolve_stored_project_path from config.config_db import get_db_pool, run_with_connection -from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Layer_Access as access from M02_MasterTemplete import M02_Layer_Index as index from M02_MasterTemplete import M02_Library_Flat as flat +from M02_MasterTemplete import M02_Library_Uses as library_uses from M02_MasterTemplete import M02_MasterTemplete_Items as items_store from M02_MasterTemplete import M02_MasterTemplete_Router_Items as items_router from M02_MasterTemplete import M02_MasterTemplete_Store as store @@ -270,9 +270,7 @@ async def read_layer_template( raise HTTPException(status_code=404, detail="양식을 찾을 수 없습니다.") found["층"] = layer found["출처"] = layers.read_manifest(folder).get(f"{kind}/{name}") - found["문서"] = refs.filled(kind, found["문서"]) # 옛 서고 문서 구분 · 상세구분(51-12) - if layer != "project": # 옛 단가승격 참조 줄 = 새 꼴(134-2 · 프로젝트 사본은 그대로) - found["문서"] = await asyncio.to_thread(refs.unpromote, kind, found["문서"]) + if layer != "project": found["문서"] = await asyncio.to_thread(flat.flat_doc, kind, found["문서"]) # 740-1 return found @@ -387,7 +385,7 @@ async def delete_layer_template( except ValueError as error: raise _bad(error) from error try: # 서고 문서를 담은 일위대가 · 사전조합이 있으면 409(50-3) - await asyncio.to_thread(refs.refuse_used, folder, kind, name) + await asyncio.to_thread(library_uses.refuse_used, folder, kind, name) except store.StoreError as error: raise HTTPException(status_code=error.status, detail=error.detail) from error if not 판: diff --git a/M02_MasterTemplete/M02_MasterTemplete_Store.py b/M02_MasterTemplete/M02_MasterTemplete_Store.py index e80ba2f86..66d83c9cb 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Store.py +++ b/M02_MasterTemplete/M02_MasterTemplete_Store.py @@ -215,9 +215,9 @@ def delete(kind: str, name: str, version: str | None = None) -> None: if (kind, name) in IN_USE: raise StoreError(409, f"쓰는 양식이라 못 지움 「{name}」 — {IN_USE[(kind, name)]}") if kind in layers.LIBRARY_KINDS: - from M02_MasterTemplete import M02_Labor_Ref as refs + from M02_MasterTemplete import M02_Library_Uses as library_uses - refs.refuse_used(root(), kind, name) + library_uses.refuse_used(root(), kind, name) with _LOCK: if not path.is_file(): raise StoreError(404, f"없는 양식 「{name}」") diff --git a/M02_MasterTemplete/M02_Material_Own.py b/M02_MasterTemplete/M02_Material_Own.py index ea946596b..daf39703f 100644 --- a/M02_MasterTemplete/M02_Material_Own.py +++ b/M02_MasterTemplete/M02_Material_Own.py @@ -148,20 +148,15 @@ def update( return got -def uses(folder: str | Path, key: str) -> list[dict[str, Any]]: - """쓰는 문서 — 쓰는 곳 색인 한 벌(`M02_Library_Uses.materials` · 858 5-5).""" +def remove(folder: str | Path, key: str) -> None: + """내 재료 지움 — 쓰는 문서가 있으면 409(그 줄을 먼저 바꿈 · 쓰는 곳 = `M02_Library_Uses.materials`).""" from M02_MasterTemplete import M02_Library_Uses as library_uses - return library_uses.materials(folder, [key])[key] - - -def remove(folder: str | Path, key: str) -> None: - """내 재료 지움 — 쓰는 문서가 있으면 409(그 줄을 먼저 바꿈).""" with store._LOCK: doc = read(folder) if not any(r.get("키") == key for r in doc["줄"]): raise store.StoreError(404, f"없는 내 재료 「{key}」") - if used := uses(folder, key): + if used := library_uses.materials(folder, [key])[key]: names = " · ".join(str(u["이름"]) for u in used[:3]) raise store.StoreError(409, f"쓰는 곳 {len(used)} — {names} · 그 줄을 먼저 바꿈") doc["줄"] = [r for r in doc["줄"] if r.get("키") != key] diff --git a/M02_MasterTemplete/M02_Material_Pick.ts b/M02_MasterTemplete/M02_Material_Pick.ts index 3e2933f3c..b407673ab 100644 --- a/M02_MasterTemplete/M02_Material_Pick.ts +++ b/M02_MasterTemplete/M02_Material_Pick.ts @@ -11,7 +11,7 @@ import { createButton, createInputField, el, showToast } from "@ui/ui_template_elements"; import { openModal } from "@ui/ui_template_modal"; import { searchMaterials } from "../M01_MasterData/M01_MasterData_Api_Fetch"; -import { addMyMaterial, listMyMaterials } from "./M02_MyMaterial_Api"; +import { addMyMaterial, listMyMaterials, type MyMaterial } from "./M02_MyMaterial_Api"; import { createUnitPick, NO_UNIT } from "@ui/ui_template_unit_pick"; import { createBadge } from "@ui/ui_template_badge"; import { createText } from "@ui/ui_template_text"; @@ -25,15 +25,6 @@ export interface MaterialItem { 단위: string | null; } -/** 개인 자재 한 줄(서버 `개인자재.json` 꼴) */ -export interface OwnRow { - 키: string; - 이름: string; - 규격: string; - 단위: string; - 값: number | null; -} - /** 개인 층 주인(148-3 · 지금 층이면 null) — 넘기면 개인 자재 · [신규 자재] */ export interface OwnLayer { owner: string | null; @@ -60,21 +51,21 @@ const TEXT = { needName: "품명 · 단위는 꼭 적음", }; -const toItem = (r: OwnRow): MaterialItem => ({ +const toItem = (r: MyMaterial): MaterialItem => ({ 코드: r.키, 이름: r.이름, 규격: r.규격, 단위: r.단위, }); /** 찾기 낱말이 모두 이름 · 규격 · 키에 듦(M01 찾기와 같은 규칙) */ -const matches = (r: OwnRow, words: string[]): boolean => { +const matches = (r: MyMaterial, words: string[]): boolean => { const hay = `${r.이름} ${r.규격} ${r.키}`.toLowerCase(); return words.every((w) => hay.includes(w)); }; /** 자재 고르기 창 — 고르면 `done` 부르고 닫음 · `own` = 개인 층(개인 자재 · [신규 자재]) */ export function pickMaterial(done: (item: MaterialItem) => void, own?: OwnLayer): void { - let mine: OwnRow[] = []; + let mine: MyMaterial[] = []; const loaded = own ? listMyMaterials(own.owner) .then((d) => void (mine = d.줄)) @@ -167,7 +158,7 @@ export function pickMaterial(done: (item: MaterialItem) => void, own?: OwnLayer) export function openNewMaterial( owner: string | null, seed: string, - saved: (row: OwnRow) => void, + saved: (row: MyMaterial) => void, ): void { openModal({ title: TEXT.newMat, @@ -193,7 +184,7 @@ export function openNewMaterial( function newForm( own: OwnLayer, seed: string, - saved: (row: OwnRow) => void, + saved: (row: MyMaterial) => void, back: () => void, backLabel: string = TEXT.back, ): HTMLElement { diff --git a/M02_MasterTemplete/M02_MyMachine.py b/M02_MasterTemplete/M02_MyMachine.py index a2e9b8526..e6137860b 100644 --- a/M02_MasterTemplete/M02_MyMachine.py +++ b/M02_MasterTemplete/M02_MyMachine.py @@ -32,6 +32,7 @@ from typing import Any from common_util.common_util_json import atomic_write_json from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Library_Uses as library_uses from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Template_Layers as layers @@ -471,20 +472,13 @@ def delete(key: str) -> dict[str, Any]: """지움 — 이미 만든 단가산출은 사본의 마지막 값 그대로(「지운키」).""" _user() _old(key) - used = _uses().get(key, []) + used = library_uses.machines().get(key, []) with _LOCK: _old(key) (_dir() / f"{key}.json").unlink(missing_ok=True) return {"지움": key, "쓰는곳": used} -def _uses() -> dict[str, list[dict]]: - """{내 기계 키: [{키, 이름}]} — 쓰는 곳 색인 한 벌(`M02_Library_Uses.machines` · 858 5-5).""" - from M02_MasterTemplete import M02_Library_Uses as library_uses - - return library_uses.machines() - - def same(name: Any, spec: Any, skip: str = "") -> list[dict]: """같은 이름 · 규격 알림 — M01 기계 · 이 층 내 기계(표기 정규화 `M02_Machine_Find.norm`).""" from M02_MasterTemplete.M02_Machine_Find import norm @@ -516,12 +510,12 @@ def one(key: str) -> dict[str, Any]: got = next((r for r in rows() if r["키"] == key), None) if got is None: raise _bad(f"없는 내 기계 「{key}」", 404) - return answer(got, _uses().get(key, [])) + return answer(got, library_uses.machines().get(key, [])) def listing() -> dict[str, Any]: """목록 — 줄마다 시간당 · 쓰는곳수(넣은 차례).""" - index, used = whole(), _uses() + index, used = whole(), library_uses.machines() return { "줄": [ {**r, "시간당": hourly(engine(r), index), "쓰는곳수": len(used.get(r["키"], []))} diff --git a/M02_MasterTemplete/M02_MyMachine_Look.py b/M02_MasterTemplete/M02_MyMachine_Look.py index a6bfa6b9e..9779221c8 100644 --- a/M02_MasterTemplete/M02_MyMachine_Look.py +++ b/M02_MasterTemplete/M02_MyMachine_Look.py @@ -10,7 +10,7 @@ GET `/api/m02/layers/{층}/my-items?owner=` = 내 품목 — 그 층 단가산 (이름 · 규격 · 단위 · 값) 묶음마다 쓰는 단가산출. POST `/api/m02/machine-sheet?owner=` 몸 {줄, 본?, 덮음?, 개인?} = 기계 보기(840-2 · `M02_MyMachine_Sheet` · 쓰기 없음 · 개인 = 그 개인 층 · 아니면 M01 만). -권한 = 내 기계 길과 같음(`M02_MyMachine_Router._folder` — 개인 층 · 본인 · 맡은 회사 관리자 읽기). +권한 = 내 기계 길과 같음(`Router_Items._root` 개인 층만 `M02_MyMachine_Router.MINE` — 개인 층 · 본인 · 맡은 회사 관리자 읽기). ⚠ 등록은 `main.py`(로그인만). """ @@ -26,8 +26,8 @@ from common_util.common_util_auth import verify_session from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_MyMachine as mym -from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Session, _call -from M02_MasterTemplete.M02_MyMachine_Router import _folder +from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Session, _call, _root +from M02_MasterTemplete.M02_MyMachine_Router import MINE router = APIRouter(prefix="/api/m02", tags=["M02 My Machine Look"]) DIRECT = ("숫자", "입력") # 단가 변수 연결 — 값을 줄에 바로 적은 것 @@ -120,14 +120,14 @@ def get_lists() -> dict: def get_find( layer: str, q: str = "", owner: str | None = None, session: Session = Depends(verify_session) ) -> dict: - return {"rows": _call(_folder(session, layer, owner), find, q)} + return {"rows": _call(_root(session, layer, owner, personal=MINE), find, q)} @router.get("/layers/{layer}/my-items") def get_items( layer: str, owner: str | None = None, session: Session = Depends(verify_session) ) -> dict: - return {"rows": _call(_folder(session, layer, owner), items)} + return {"rows": _call(_root(session, layer, owner, personal=MINE), items)} class SheetBody(BaseModel): @@ -144,5 +144,5 @@ def post_sheet( """기계 보기(840-2 · `M02_MyMachine_Sheet`) — 개인 = 내 기계(그 층) · 아니면 M01 기계만 · 쓰기 없음.""" from M02_MasterTemplete import M02_MyMachine_Sheet as ms - folder = _folder(session, "personal", owner) if body.개인 else store.FOLDER + folder = _root(session, "personal", owner, personal=MINE) if body.개인 else store.FOLDER return _call(folder, ms.sheet, body.줄, body.본, body.덮음, body.개인) diff --git a/M02_MasterTemplete/M02_MyMachine_Router.py b/M02_MasterTemplete/M02_MyMachine_Router.py index c7226c8c4..a473c7203 100644 --- a/M02_MasterTemplete/M02_MyMachine_Router.py +++ b/M02_MasterTemplete/M02_MyMachine_Router.py @@ -36,20 +36,19 @@ class MachineBody(BaseModel): 판: str | None = None # 고치기 — 화면이 연 판(854-1 · 다르면 409) -def _folder(session: Session, layer: str, owner: str | None, write: bool = False): - return _root(session, layer, owner, write=write, personal="내 기계는 개인 층만") +MINE = "내 기계는 개인 층만" # 층 폴더 한 벌 `_root` 의 개인 층만 글(858 5-2) @router.get(PATH) def my_machines(layer: str, owner: str | None = None, session: Session = Depends(verify_session)): - return _call(_folder(session, layer, owner), mym.listing) + return _call(_root(session, layer, owner, personal=MINE), mym.listing) @router.get(PATH + "/{key}") def my_machine( layer: str, key: str, owner: str | None = None, session: Session = Depends(verify_session) ): - return _call(_folder(session, layer, owner), mym.one, key) + return _call(_root(session, layer, owner, personal=MINE), mym.one, key) @router.post(PATH) @@ -59,7 +58,7 @@ def my_machine_create( owner: str | None = None, session: Session = Depends(verify_session), ): - return _call(_folder(session, layer, owner, True), mym.create_own, body.줄, body.본뜬) + return _call(_root(session, layer, owner, True, MINE), mym.create_own, body.줄, body.본뜬) @router.put(PATH + "/{key}") @@ -70,7 +69,7 @@ def my_machine_update( owner: str | None = None, session: Session = Depends(verify_session), ): - return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄, body.판) + return _call(_root(session, layer, owner, True, MINE), mym.update_own, key, body.줄, body.판) @router.post(PATH + "/{key}/impact") @@ -82,14 +81,14 @@ def my_machine_impact( session: Session = Depends(verify_session), ): """[저장] 전 영향 — 쓰는 단가산출 · 따로 고쳐 둔 곳(848-5 · 쓰기 없음).""" - return _call(_folder(session, layer, owner), impact.impact, key, body.줄) + return _call(_root(session, layer, owner, personal=MINE), impact.impact, key, body.줄) @router.delete(PATH + "/{key}") def my_machine_delete( layer: str, key: str, owner: str | None = None, session: Session = Depends(verify_session) ): - return _call(_folder(session, layer, owner, True), mym.delete, key) + return _call(_root(session, layer, owner, True, MINE), mym.delete, key) # ── 내 재료(858 5-6 · `Labor_Router` 에서 옮김) ────────────────────────── diff --git a/M02_MasterTemplete/M02_MyMachine_Text.ts b/M02_MasterTemplete/M02_MyMachine_Text.ts index d79a93497..7d04557f2 100644 --- a/M02_MasterTemplete/M02_MyMachine_Text.ts +++ b/M02_MasterTemplete/M02_MyMachine_Text.ts @@ -31,7 +31,6 @@ const TEXT = { Stale: "그 사이 다른 곳에서 바뀜 — 목록에서 다시 열어 고침", Name_Needed: "이름 · 비어 있음", Same: "같은 이름 · 규격 있음 — {value}", - Copied: "「{value}」 값을 복사 — 고친 뒤 [저장]", Own_Value: "개인 값", Own_Note: "개인 값 = 이 기계 고유 값(가격 · 손료계수 · 연료 ℓ · 인력 줄 · 잡품 줄) · 단가(노임 · 유가)는 M01 값 · 단가산출(프로젝트 밖)은 고치면 저절로 따라옴", @@ -63,17 +62,8 @@ const TEXT = { Win_Live: "원본 지금 값", Win_Newer: "원본에 새 값 있음 — 프로젝트 사본은 [단가 갱신] 으로 반영", Win_Swap: "이 기계로 바꾸기", - Win_Edit: "고쳐 쓰기", - Win_Blank: "빈 양식에서 새 기계", - Win_Ok: "확인", - Win_Cancel: "취소", - Win_Edit_Note: - "[확인] = 이 단가산출에 초안으로 끼움 · 단가산출 [저장] 때 내 기계로 저장 · 저장 안 하고 나가면 사라짐", - Win_Uses: "이 기계를 쓰는 다른 단가산출 {value} 건 — 저장하면 그쪽도 새 값으로 셈", Win_Hint: "왼쪽에서 기계를 고르면 값이 보임", Win_View: "조회", - Why_M01: "기계 값은 M01 기계 상세에서", - Why_Company: "개인용으로 복사해서 씀", // 내 품목 Items_Note: "단가산출 줄에 값을 바로 적은 재료(재료 DB · 내 재료에 안 이어진 것 · 읽기만) — 고치기는 그 단가산출에서 · 줄 누르면 쓰는 단가산출", diff --git a/M02_MasterTemplete/M02_Template_Layers.py b/M02_MasterTemplete/M02_Template_Layers.py index 1e765d04f..38c2d6914 100644 --- a/M02_MasterTemplete/M02_Template_Layers.py +++ b/M02_MasterTemplete/M02_Template_Layers.py @@ -336,15 +336,6 @@ def _write_manifest(layer_dir: str | Path, entries: dict[str, Any]) -> None: atomic_write_json(Path(layer_dir) / MANIFEST_NAME, {"양식": entries}) -def note_source( - layer_dir: str | Path, kind: str, name: str, source_layer: str, version: str -) -> None: - """manifest 한 줄 — 복사가 아니라 고쳐 쓴 양식의 출처 · 판.""" - manifest = read_manifest(layer_dir) - manifest[f"{kind}/{name}"] = _stamp(source_layer, name, version) - _write_manifest(layer_dir, manifest) - - def _stamp(layer: str, name: str, version: str | None, **extra: Any) -> dict[str, Any]: entry = { "층": layer, diff --git a/resources/tester/helper_855_line.py b/resources/tester/helper_855_line.py new file mode 100644 index 000000000..67a098cb9 --- /dev/null +++ b/resources/tester/helper_855_line.py @@ -0,0 +1,24 @@ +"""옛 `M02_Labor_Doc.run_line` 자리(855-E 2-E4) — 로직 줄 하나 = 층 문서 셈(`M02_Labor_Copy.line`). + +재료 줄 전부 직접계산(옛 날 답 = 별도계상 안 뺌) · 켜쌓기율 · 고름 = 줄 옵션 · 답 `{기준, 줄, 재료, 까닭}`. +""" + +from __future__ import annotations + +from typing import Any + +DIRECT = {"별도계상": "직접계산"} + + +def run_line( + whole: Any, code: str, given: dict | None = None, rate: Any = None, picks: dict | None = None +) -> dict[str, Any]: + from M02_MasterTemplete import M02_Labor_Copy as lc + + one: dict[str, Any] = {"로직": code, "입력값": dict(given or {})} + one["자재표시"] = {str(n): DIRECT for n in range(64)} + if rate is not None: + one["켜쌓기율"] = rate + if picks: + one["고름"] = picks + return lc.line(whole, {}, one) diff --git a/resources/tester/helper_855_old_engine_routes.py b/resources/tester/helper_855_old_engine_routes.py index 6d06f3ca3..ccdca0c81 100644 --- a/resources/tester/helper_855_old_engine_routes.py +++ b/resources/tester/helper_855_old_engine_routes.py @@ -7,6 +7,7 @@ from __future__ import annotations +from decimal import Decimal from typing import Any from fastapi import APIRouter @@ -112,14 +113,12 @@ def post_calc(body: CalcBody) -> dict: got = m01._call(calc, body.key, body.inputs, body.row, body.file) if not got.get("lines"): return got - from M02_MasterTemplete import M02_Labor_Doc as labor_doc # % 덧줄 표기(149-4) - whole = store.loaded()[1] try: logic = body.row or whole.logic(body.key) except mf.FormulaError: return got - lines = labor_doc.pct_extras(whole, logic, got["lines"], got.get("middle") or {}) + lines = _pct_extras(whole, logic, got["lines"], got.get("middle") or {}) return {**got, "lines": m01._num(lines)} @@ -127,3 +126,53 @@ def post_calc(body: CalcBody) -> dict: def post_text(body: CalcBody) -> dict: with mf.mp.choosing(body.고름): return m01._call(text, body.key, body.inputs, body.row, body.file) + + +COSTS = ("노무비", "재료비", "경비") + + +# ── 옛 % 덧줄 표기(옛 `M02_Labor_Doc.pct_extras` · 855-E 2-E4 에서 제품에서 걷어 옛 길 도우미로 옮김) ── +def _pct_extras(whole: Any, logic: dict, lines: list[dict], env: dict) -> list[dict]: + """% 덧줄(149-4) — 덧줄 식이 「X * Y / 100」 이면 그 엔진 줄(호표 수 뒤 같은 차례)에 덧칸 + `율` = Y(엔진 마지막 env 로 셈) · `규격` = X 이름(「노무비의 %」 · 인력 줄 합 「인건비의 %」 · + `줄.'이름'` · 중간값 「이름의 %」 · 그 밖 복합 = 빈 글). 다른 덧줄 · 흐름 로직 · 못 셈 = 그대로.""" + if isinstance(logic.get("흐름"), dict): + return lines + out, head = list(lines), len(logic.get("호표") or []) + for n, add in enumerate(logic.get("덧줄") or []): + if head + n >= len(out): + break + try: + node = mf.parse(add.get("식") or "") + except mf.FormulaError: + continue + if not ( + node[0] == "bin" + and node[1] == "/" + and node[3] == ("num", Decimal(100)) + and node[2][0] == "bin" + and node[2][1] == "*" + ): + continue # 금액 식(기계손료 등) · 조건부 % = 「식」 그대로 + base, part = node[2][2], node[2][3] + try: + rate = mf.evaluate(part, dict(env), whole) + except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): + continue + if isinstance(rate, Decimal): + out[head + n] = {**out[head + n], "율": rate, "규격": _pct_base_name(base)} + return out + + +def _pct_base_name(node: tuple) -> str: + """% 덧줄 밑수 이름 — B09 대가(`B09_Estimation_Labor_Source._base_of`)와 같은 말.""" + if node[0] == "name": + return f"{node[1]}의 %" # 노무비 · 재료비 · 경비 · 중간값 이름 + if node[0] == "field" and node[1] == ("name", "줄"): + return f"{node[2]}의 %" + parts = list(mf.walk(node)) + if any(x[0] == "ref" and str(x[1]).startswith("LB") for x in parts) and not any( + x[0] == "name" and x[1] in COSTS for x in parts + ): + return "인건비의 %" + return "" diff --git a/resources/tester/test_149_4_pct_extra.py b/resources/tester/test_149_4_pct_extra.py deleted file mode 100644 index 775e38518..000000000 --- a/resources/tester/test_149_4_pct_extra.py +++ /dev/null @@ -1,43 +0,0 @@ -"""% 덧줄 표기(PLAN 149-4) — 식 「X * Y / 100」 덧줄 = 덧칸 율 · 규격 · 금액 · 단위 · 수량 그대로. - -- M02 `run_line` → 큰돌쌓기 찰쌓기 제잡비 설치 9 · 안 함 3 · 「노무비의 %」 -- 인력 줄 합 밑수 = 「인건비의 %」 · 호표 줄 밑수 = 「그 줄 이름의 %」 · 금액 식(기계손료) = 덧칸 없음 -- M01 시험계산 길(`post_calc`)은 855 2-E1 에 걷음 · 화면은 `pctView` 한 벌 -""" - -from decimal import Decimal -from pathlib import Path - -from M01_MasterData import M01_MasterData_Store as m01 -from M02_MasterTemplete import M02_Labor_Doc as labor - -ROOT = Path(__file__).resolve().parents[2] - - -def _extra(code: str, given: dict | None = None, name: str | None = None) -> dict: - got = labor.run_line(m01.loaded()[1], code, given or {}) - assert got["까닭"] is None - lines = [x for x in got["줄"] if x.get("단위") == "식" and (name is None or x["이름"] == name)] - assert lines, code - return {**lines[-1], "_기준": got["기준"]} - - -def test_큰돌쌓기_찰쌓기_제잡비_율_설치_9_안함_3_금액_그대로(): - for pipe, rate in (("설치", 9), ("설치 안 함", 3)): - x = _extra("GF000227", {"물빼기파이프": pipe}, "제잡비") - assert x["율"] == Decimal(rate) and x["규격"] == "노무비의 %" - assert x["단위"] == "식" and x["수량"] == 1 # 엔진 줄은 그대로 · 표기는 화면 - labor_sum = x["_기준"]["노무비"] - # 751-3 — % 밑 = 버린 줄 합(소계 1 원 버림 전) · 금액 0.1 원 버림 - assert abs(x["금액"] - labor_sum * rate / 100) <= Decimal(rate) / 100 + Decimal("0.1") - - -def test_인건비_호표줄_밑수_금액식은_덧칸_없음(): - x = _extra("GC000198") - assert x["율"] == 2 and x["규격"] == "인건비의 %" - x = _extra("GF000002", name="잡품") - assert x["규격"] == "휘발유(체인톱)의 %" and x["율"] > 0 - mach = _extra("GC000267", name="기계손료") - assert "율" not in mach and "규격" not in mach - mat = _extra("GC000267", name="잡재료비") - assert mat["규격"] == "재료비의 %" diff --git a/resources/tester/test_175_precombo_mats.py b/resources/tester/test_175_precombo_mats.py index 073e3e588..6b1c563c0 100644 --- a/resources/tester/test_175_precombo_mats.py +++ b/resources/tester/test_175_precombo_mats.py @@ -16,6 +16,7 @@ from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store +from resources.tester.test_222_1_m02_apart import raw_line from resources.tester.test_m02_labor_ref import _area, world # noqa: F401 — 임시 층 fixture HERE = os.path.dirname(os.path.abspath(__file__)) @@ -95,7 +96,7 @@ def _world_combo(world): # noqa: F811 key = refs.create( "precombo", {"이름": "자재 조합", "단위": "㎡", "담은로직": lines, "자재": mats} )["이름"] - stone = Decimal(str(labor.run_line(m01.loaded()[1], STONE, {})["기준"]["계"])) + stone = Decimal(str(raw_line(STONE)["기준"]["계"])) # 로직 줄 값(문서 셈 · 855-E 2-E4) return key, stone + _price(MAT) * 2 diff --git a/resources/tester/test_222_1_m02_apart.py b/resources/tester/test_222_1_m02_apart.py index 00a54a552..cf33dbdaa 100644 --- a/resources/tester/test_222_1_m02_apart.py +++ b/resources/tester/test_222_1_m02_apart.py @@ -34,6 +34,15 @@ def _whole(): return m01.loaded()[1] +def raw_line(code: str, given: dict | None = None) -> dict: + """별도계상 없는 로직 줄 답(옛 `run_line` 자리 · 층 문서 셈 `Labor_Copy.line` · 855-E 2-E4) — 재료 줄 전부 + 직접계산 → 줄 · 재료 · 기준 통째.""" + from M02_MasterTemplete import M02_Labor_Copy as lc + + marks = {str(n): DIRECT for n in range(64)} + return lc.line(_whole(), {}, {"로직": code, "입력값": given or {}, "자재표시": marks}) + + def _rows(got): return {x["이름"]: {**x, "수량": float(x["수량"])} for x in got["줄"]} @@ -49,13 +58,13 @@ def _kept(raw, names=None): # ── ① 단위 ────────────────────────────────────────────────────────── def test_단위중량_칸에_t_값이면_1000배_0이면_표_위끝(): - wrong = labor.run_line(_whole(), MIX, {**GIVEN, "모래단위중량": 2, "자갈단위중량": 2.1}) + wrong = raw_line(MIX, {**GIVEN, "모래단위중량": 2, "자갈단위중량": 2.1}) rows = _rows(wrong) - assert rows["시멘트"]["단위"] == "kg" and rows["시멘트"]["수량"] == pytest.approx(335) + assert rows["시멘트"]["단위"] == "㎏" and rows["시멘트"]["수량"] == pytest.approx(335) assert rows["모래(건조상태)"]["수량"] == pytest.approx(838 / 2) # 419 ㎥ assert rows["자갈 또는 부순돌"]["수량"] == pytest.approx(1032 / 2.1) # 491.4 ㎥ zero = {**GIVEN, "모래단위중량": 0, "자갈단위중량": 0} - right = _rows(labor.run_line(_whole(), MIX, zero)) + right = _rows(raw_line(MIX, zero)) assert right["모래(건조상태)"]["수량"] == pytest.approx(838 / 1700) assert right["자갈 또는 부순돌"]["수량"] == pytest.approx(1032 / 1800) @@ -70,7 +79,7 @@ def _calc(shown=None, mats=()): def test_로직_자재_기본_별도계상은_기준_줄에서_빠지고_재료엔_남음(): - raw = labor.run_line(_whole(), MIX, GIVEN) + raw = raw_line(MIX, GIVEN) one = _calc()["줄"][0] names = {x["이름"] for x in one["줄"]} assert not names & {"시멘트", "모래(건조상태)", "자갈 또는 부순돌"} @@ -82,7 +91,7 @@ def test_로직_자재_기본_별도계상은_기준_줄에서_빠지고_재료 def test_직접계산은_그대로_섞이면_그_자재만_빠짐(): - raw = labor.run_line(_whole(), MIX, GIVEN) + raw = raw_line(MIX, GIVEN) full = _calc({str(n): DIRECT for n in (3, 4, 5)})["줄"][0] assert full["기준"]["계"] == pytest.approx(float(raw["기준"]["계"])) assert len(full["줄"]) == len(raw["줄"]) @@ -113,7 +122,7 @@ def test_사용자_자재_별도계상_파이썬과_TS_같은_답(mark): def test_사전조합_안_줄도_별도계상_뺌(): - raw = labor.run_line(_whole(), MIX, GIVEN) + raw = raw_line(MIX, GIVEN) doc = { "이름": "비빔 조합", "단위": "㎥", diff --git a/resources/tester/test_715_3_labor_patch.py b/resources/tester/test_715_3_labor_patch.py index 90324be75..d5457abc4 100644 --- a/resources/tester/test_715_3_labor_patch.py +++ b/resources/tester/test_715_3_labor_patch.py @@ -12,6 +12,7 @@ from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store +from resources.tester.test_222_1_m02_apart import raw_line from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층 PCT = "GC001109" # 원/㎡ · 인력 둘(LB000036 · LB000002) + 「노무비 * 3 / 100」 @@ -55,10 +56,8 @@ def test_refusals(world): def test_no_patch_same_value(world): - """덮개 없는 줄 = run_line 값 그대로(옛 셈 길).""" + """덮개 없는 줄 = 로직 줄 값 그대로(문서 셈 · 855-E 2-E4).""" sc = _sc(world["personal"], [{"로직": PCT, "패치": {}}]) with store.at(world["personal"]): assert "패치" not in store.read("precombo", sc)["문서"]["담은로직"][0] - assert _value(world["personal"], sc)["기준"]["계"] == pytest.approx( - labor.run_line(_whole(), PCT, {})["기준"]["계"] - ) + assert _value(world["personal"], sc)["기준"]["계"] == pytest.approx(raw_line(PCT)["기준"]["계"]) diff --git a/resources/tester/test_715_sangeun_store.py b/resources/tester/test_715_sangeun_store.py index 9fc74dd75..ae2e488c2 100644 --- a/resources/tester/test_715_sangeun_store.py +++ b/resources/tester/test_715_sangeun_store.py @@ -39,9 +39,9 @@ def _whole(): def _bare(code): - from M02_MasterTemplete import M02_Labor_Doc as labor + from resources.tester.helper_855_line import run_line - return labor.run_line(_whole(), code, {}) + return run_line(_whole(), code, {}) def test_refusals(world): diff --git a/resources/tester/test_727_sk_base_add.py b/resources/tester/test_727_sk_base_add.py index a0368cd12..5922b333c 100644 --- a/resources/tester/test_727_sk_base_add.py +++ b/resources/tester/test_727_sk_base_add.py @@ -17,11 +17,11 @@ import pytest from M01_MasterData import M01_MasterData_Doc as m01_doc from M01_MasterData import M01_MasterData_Store as m01 -from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Logic_Standard as standard from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Sangeun_Calc as calc +from resources.tester.helper_855_line import run_line from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층 ROOT = Path(__file__).resolve().parents[2] @@ -100,7 +100,7 @@ def _line(got, cid): def _m01(code, values=None): - return float(labor.run_line(m01.loaded()[1], code, values or {}, None, None)["기준"]["계"]) + return float(run_line(m01.loaded()[1], code, values or {}, None, None)["기준"]["계"]) def test_727_3_옵션_저장_일위대가_그_옵션(world): # noqa: F811 diff --git a/resources/tester/test_733_3_library_same_merge.py b/resources/tester/test_733_3_library_same_merge.py index 56edcabe6..16c58f684 100644 --- a/resources/tester/test_733_3_library_same_merge.py +++ b/resources/tester/test_733_3_library_same_merge.py @@ -87,7 +87,7 @@ def test_권한_밖이면_안_지움(api, world, monkeypatch): a = _make(me, 이름="가", 바탕={"로직": PCT}) c = _make(me, 이름="다", 바탕={"로직": PCT}) top = _user(me, [c]) - monkeypatch.setattr(same_router, "_can_write", lambda session, at: False) + monkeypatch.setattr(same_router.access, "can_write", lambda session, at: False) 판 = api.get(URL.format("personal")).json()["판"] res = _merge(api, {**MINE, "키": a}, [c], 판) left = res.json()["남김"] diff --git a/resources/tester/test_733_3_library_same_screen.py b/resources/tester/test_733_3_library_same_screen.py index c53746bcd..4ae7dd850 100644 --- a/resources/tester/test_733_3_library_same_screen.py +++ b/resources/tester/test_733_3_library_same_screen.py @@ -1,4 +1,4 @@ -"""서고 [중복 찾기] 화면 지킴(PLAN 733-3) — 부품 상자만 · 날 색 없음 · 나무 메뉴 · 서버 길 짝.""" +"""서고 [중복 찾기] 화면 지킴(PLAN 733-3) — 부품 상자만 · 날 색 없음.""" import re from pathlib import Path @@ -18,15 +18,3 @@ def test_부품만_씀(): assert not RAW_COLOR.search(CSS) for sel in (".ui-btn", ".ui-table", ".ui-badge", "button", "table", "th", "td"): assert not re.search(rf"(^|[\s,]){re.escape(sel)}\b", CSS), f"CSS 가 {sel} 꼴을 만짐" - - -def test_나무_메뉴_서버_길_짝(): - side = (M02 / "M02_MasterTemplete_UI_Side_Library.ts").read_text(encoding="utf-8") - assert "openLibrarySame" in side and "sameLabel()" in side - router = (M02 / "M02_Library_Same_Router.py").read_text(encoding="utf-8") - for tail in ("", "/merge", "/undo"): - assert f'"/layers/{{layer}}/{{kind}}-same{tail}"' in router - assert "`/layers/${layer}/${kind}-same${tail}" in TS - assert '"/merge"' in TS and '"/undo"' in TS - main = (ROOT / "main.py").read_text(encoding="utf-8") - assert "M02_MasterTemplete.M02_Library_Same_Router" in main diff --git a/resources/tester/test_735_1_library_delete.py b/resources/tester/test_735_1_library_delete.py index fc141d4e9..427dfc052 100644 --- a/resources/tester/test_735_1_library_delete.py +++ b/resources/tester/test_735_1_library_delete.py @@ -123,7 +123,7 @@ def test_쓰는곳_없으면_그냥_지움_기록은_남음(api, world): def test_권한_밖이면_409_목록_아무것도_안_바뀜(api, world, monkeypatch): me, sk, _top = _world(world) - monkeypatch.setattr(deleting, "can_write", lambda session, at: False) + monkeypatch.setattr(deleting.access, "can_write", lambda session, at: False) res = _tree(api, SK_TREE, op="delete", 대상=[{"키": sk}], 확인=True) assert res.status_code == 409 detail = res.json()["detail"] diff --git a/resources/tester/test_742_1_sc_qty_saved.py b/resources/tester/test_742_1_sc_qty_saved.py index 168b1aca7..11c8f2fab 100644 --- a/resources/tester/test_742_1_sc_qty_saved.py +++ b/resources/tester/test_742_1_sc_qty_saved.py @@ -15,9 +15,9 @@ import pytest from B09_Estimation.B09_Estimation_Calc_Labor import compute_labor from M01_MasterData import M01_MasterData_Store as m01 -from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store +from resources.tester.helper_855_line import run_line from resources.tester.test_723_4_b09_sc_qty import MAT, RID, SHEETS, _build, _doc from resources.tester.test_m02_labor_ref import world # noqa: F401 — 임시 층 fixture @@ -28,7 +28,7 @@ RATE = {"이름": "공구손료", "단위": "%", "단가": {"노무비": 0, "재 def _stone() -> float: - return labor.run_line(m01.loaded()[1], STONE, {})["기준"]["계"] + return run_line(m01.loaded()[1], STONE, {})["기준"]["계"] def _sc(world, lines): # noqa: F811 diff --git a/resources/tester/test_747_1_sk_material.py b/resources/tester/test_747_1_sk_material.py index 50005d20b..a4ebf4c0b 100644 --- a/resources/tester/test_747_1_sk_material.py +++ b/resources/tester/test_747_1_sk_material.py @@ -7,6 +7,7 @@ from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Sangeun_Calc as calc from M02_MasterTemplete import M02_Sangeun_Doc as sd +from resources.tester.helper_855_line import run_line FORM = "GC000211" # 6-3-1 합판거푸집 — 합판 1.03 · 각재 0.038 · 폼타이 0 · 소모자재 = 재료비 % PLY = "금액#2" # 합판 = 기초 문서 금액 줄 2째(855 L2 ⓑ-3 줄 규칙 열쇠) @@ -23,7 +24,7 @@ def _run(**doc): def test_base_materials_count_like_m01(): - m01_ = labor._json(labor.run_line(_whole(), FORM, None)) + m01_ = labor._json(run_line(_whole(), FORM, None)) got = _run(바탕={"로직": FORM}) assert got["기준"]["재료비"] == pytest.approx(m01_["기준"]["재료비"]) assert got["기준"]["계"] == pytest.approx(m01_["기준"]["계"]) diff --git a/resources/tester/test_751_3_money_cut.py b/resources/tester/test_751_3_money_cut.py index 8d9ac1536..9dd6b1f68 100644 --- a/resources/tester/test_751_3_money_cut.py +++ b/resources/tester/test_751_3_money_cut.py @@ -6,7 +6,6 @@ M01 시험 계산 · 읽는 식 · M02 단가산출(SK) · 일위대가 반영 from decimal import Decimal -from B09_Estimation import B09_Estimation_Sangeun as sg from M01_MasterData import M01_MasterData_Store as m01 import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 몸(855 2-E1 · 시험 전용) from M02_MasterTemplete import M02_Labor_Doc as labor @@ -35,38 +34,6 @@ def _sums_of_lines(lines) -> dict: return {k: mcut.down(v, 0) for k, v in total.items()} -def test_줄은_0점1원_소계는_1원_버림_줄합이_소계(): - got = labor.run_line(_whole(), KEY, {}) - base = got["기준"] - assert all(_tenth(x.get("금액")) for x in got["줄"]) - assert all(Decimal(str(base[k])) == int(base[k]) for k in COSTS) - assert {k: Decimal(str(base[k])) for k in COSTS} == _sums_of_lines(got["줄"]) - assert base["계"] == sum(base[k] for k in COSTS) - - -def test_B09_산근_끝수와_같음(): - """엔진 날 줄을 B09 규칙(줄 ROUNDDOWN 1 · % = 버린 밑 × 율 · 비목 ROUNDDOWN 0)으로 = 끝수 답.""" - whole = _whole() - raw = labor.run_line(whole, KEY, {}, raw=True) - cut = labor.run_line(whole, KEY, {}) - lines = [] - for x in raw["줄"][: len(whole.logic(KEY)["호표"])]: - lines.append( - {k: sg._money(float(x["단가"] or 0), float(x["수량"] or 0)) for k in x["비목"]} - ) - under = {k: sum(ln.get(k, 0) for ln in lines) for k in COSTS} - for x in raw["줄"][len(lines) :]: # % 덧줄 = 버린 밑 × 율 / 100 → ROUNDDOWN 1 - (part,) = x["비목"] - base = under["재료비"] if "재료" in x["이름"] or "소모" in x["이름"] else under["노무비"] - lines.append({part: sg.rounddown(base * float(x["율"]) / 100, 1)}) - b09 = sg.block_totals([{"labor": ln.get("노무비", 0), "material": ln.get("재료비", 0), - "expense": ln.get("경비", 0)} for ln in lines]) # fmt: skip - assert (b09["labor"], b09["material"], b09["expense"], b09["sum"]) == tuple( - float(cut["기준"][k]) for k in (*COSTS, "계") - ) - assert raw["기준"]["계"] != cut["기준"]["계"] # 날 값은 버리기 전(B09 몫) - - def test_화면_넷_같은_값_SK_시험계산_읽는식(): whole = _whole() doc = sd.clean( @@ -88,37 +55,6 @@ def _line_text(v) -> str: return fmt_line_money(Decimal(str(v))) -def test_하위_로직_줄은_하위_계를_버려_단가로(): - """기계 · 하위 로직 줄 단가 = 하위 로직 끝수 계(1 원) · - 비목마다 하위 비목 × 수량 0.1 원 버림.""" - whole = _whole() - key = next( - str(r["키"]) - for _, d in m01._logic_files(m01.cm.load(folder=m01.FOLDER)) - for r in d.get("줄") or [] - if any(i.get("종류") == "로직" for i in r.get("호표") or []) - and "결과" not in r - and not isinstance(r.get("흐름"), dict) - and labor.run_line(whole, str(r["키"]), {}).get("기준") - ) - got = labor.run_line(whole, key, {}) - for item, x in zip(whole.logic(key)["호표"], got["줄"]): - if item.get("종류") == "로직" and x.get("단가") is not None and x.get("수량") is not None: - assert Decimal(str(x["단가"])) == int(x["단가"]) - parts = [ - Decimal(str(v)) for v in x["비목"].values() - ] # 비목마다 0.1 원 버림 · 금액 = 합 - assert all(_tenth(v) for v in parts) and Decimal(str(x["금액"])) == sum(parts) - assert abs(Decimal(str(x["단가"])) * x["수량"] - sum(parts)) < Decimal("0.3") - - -def test_날_값은_엔진_그대로(): - whole = _whole() - eng = mf.run(whole, KEY, {**m01.mau.values(whole, whole.logic(KEY))}) - raw = labor.run_line(whole, KEY, {}, raw=True) - assert raw["기준"]["계"] == eng["계"] - - def test_일위대가_반영_줄_0점1원_합_1원(): doc = labor.clean({"담은로직": [{"로직": KEY, "수량": {"손": 3.3}}]}) out = labor.calc(doc, {}) @@ -129,13 +65,3 @@ def test_일위대가_반영_줄_0점1원_합_1원(): assert {k: Decimal(str(total[k])) for k in COSTS} == { k: mcut.down(Decimal(str(line[k])), 0) for k in COSTS } - - -def test_별도계상_뺀_기준은_남은_줄_합_버림(): - whole = _whole() - got = labor.run_line(whole, KEY, {}) - marks = {str(m["차례"]): {"별도계상": "직접계산"} for m in got["재료"]} - marks[str(got["재료"][0]["차례"])] = {"별도계상": "별도계상"} # 첫 재료만 뺌 - out = labor.drop_apart(got, marks) - assert len(out["줄"]) == len(got["줄"]) - 1 - assert {k: Decimal(str(out["기준"][k])) for k in COSTS} == _sums_of_lines(out["줄"]) diff --git a/resources/tester/test_792_3_engine_paths.py b/resources/tester/test_792_3_engine_paths.py index d04b71b21..de29d875a 100644 --- a/resources/tester/test_792_3_engine_paths.py +++ b/resources/tester/test_792_3_engine_paths.py @@ -210,20 +210,3 @@ def test_단위_로직_새_의미가_금액을_바꿈(): for k in ("합밖", "자리", "번지"): x.pop(k, None) assert got != _engine(t._master([plain], t.LAB, t.MAT), plain) # 시험이 새 길을 거침 - - -@pytest.mark.parametrize("name", ["영월", "단위"]) -def test_다시_버림도_셈법_지킴(name): - """켜쌓기율 · 별도계상 뒤 다시 버림(`plain`) — 셈법이 있으면 - 줄 자리 · 합밖 · 끝전 · 조정 그대로.""" - master, row, _ = CASES[name]() - out = labor.run_line(master, _key(row), {}) - assert "셈법" in out and out["단계"] - again = mcut.plain(out) - assert again["기준"] == out["기준"] - assert [x["계"] for x in again["단계"]] == [x["계"] for x in out["단계"]] - old = mcut.plain({k: v for k, v in out.items() if k != "셈법"}) - if name == "영월": - assert ( - old["기준"]["계"] == 5470 and again["기준"]["계"] == 5471 - ) # 옛 다시 버림 = 1 원 모자람 diff --git a/resources/tester/test_795_1_sk_copy.py b/resources/tester/test_795_1_sk_copy.py index 29fc83f18..60fa73b16 100644 --- a/resources/tester/test_795_1_sk_copy.py +++ b/resources/tester/test_795_1_sk_copy.py @@ -15,13 +15,13 @@ import pytest from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Doc_Sk_Path as path -from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Library_Same as same from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Sangeun_Calc as calc from M02_MasterTemplete import M02_Sangeun_Copy as skc from M02_MasterTemplete import M02_Sangeun_Imported as imp +from resources.tester.helper_855_line import run_line from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 @@ -108,9 +108,9 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch): first = _calc(me, _doc(me, key)) assert first["사본"]["M01새판"] is False and first["사본"]["지운키"] == [] was = first["기준"]["계"] - plain = labor.run_line(_live(), PCT, {})["기준"]["계"] + plain = run_line(_live(), PCT, {})["기준"]["계"] _fake(monkeypatch, [_changed(_live().logic(PCT))]) - assert labor.run_line(m01.loaded()[1], PCT, {})["기준"]["계"] != plain # M01 셈은 바뀜 + assert run_line(m01.loaded()[1], PCT, {})["기준"]["계"] != plain # M01 셈은 바뀜 now = _calc(me, _doc(me, key)) assert now["기준"]["계"] == was assert now["사본"]["M01새판"] is True @@ -168,7 +168,7 @@ def test_old_sk_without_copy_old_path(world, monkeypatch): with store.at(me): assert same.Same().finger("sangeun", old) == same.Same().finger("sangeun", _doc(me, fresh)) _fake(monkeypatch, [_changed(_live().logic(PCT))]) - moved = labor.run_line(m01.loaded()[1], PCT, {})["기준"]["계"] + moved = run_line(m01.loaded()[1], PCT, {})["기준"]["계"] assert _sum(me, key) == pytest.approx(moved, abs=1) # 옛 길 = 따라감 assert _sum(me, fresh) != _sum(me, key) # 사본 SK = 그대로 with store.at(me): # 판 다른 두 SK = 지문 다름(오판 막음) diff --git a/resources/tester/test_795_2_sc_copy.py b/resources/tester/test_795_2_sc_copy.py index 988417d63..910969bef 100644 --- a/resources/tester/test_795_2_sc_copy.py +++ b/resources/tester/test_795_2_sc_copy.py @@ -19,6 +19,7 @@ from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Sangeun_Copy as skc +from resources.tester.helper_855_line import run_line from resources.tester.test_795_1_sk_copy import _changed, _fake, _live from resources.tester.test_m02_labor_calc_mirror import _same, _ts from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 @@ -87,7 +88,7 @@ def test_copy_stamped_logic_change_kept(world, monkeypatch): was = (_calc(me, COL)["반영합"]["계"], _calc(me, sc)["기준합"]["계"], _unit(me, sc)) assert _calc(me, COL)["사본"]["M01새판"] is False _fake(monkeypatch, [_changed(_live().logic(PCT))]) - assert labor.run_line(m01.loaded()[1], PCT, {})["기준"]["계"] != was[2] # M01 셈은 바뀜 + assert run_line(m01.loaded()[1], PCT, {})["기준"]["계"] != was[2] # M01 셈은 바뀜 now = (_calc(me, COL)["반영합"]["계"], _calc(me, sc)["기준합"]["계"], _unit(me, sc)) assert now == was assert _calc(me, COL)["사본"]["M01새판"] is True @@ -157,7 +158,7 @@ def test_old_doc_without_copy_old_path(world, monkeypatch): path.write_text(json.dumps(raw, ensure_ascii=False), encoding="utf-8") assert "사본" not in _calc(me, COL) _fake(monkeypatch, [_double(LB)]) - moved = labor.run_line(m01.loaded()[1], PCT, {})["기준"]["계"] + moved = run_line(m01.loaded()[1], PCT, {})["기준"]["계"] assert _calc(me, COL)["기준합"]["계"] == pytest.approx(moved, abs=1) with store.at(me): assert skc.has(labor.server(raw)) diff --git a/resources/tester/test_797_1_import_links.py b/resources/tester/test_797_1_import_links.py index 9c270f506..aabe169a9 100644 --- a/resources/tester/test_797_1_import_links.py +++ b/resources/tester/test_797_1_import_links.py @@ -19,7 +19,6 @@ import pytest from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Hopyo_Store as hs -from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Library_Uses as library_uses from M02_MasterTemplete import M02_Machine_Hourly as machine from M02_MasterTemplete import M02_MasterTemplete_Store as store @@ -145,7 +144,7 @@ def test_nested_stmate_follows_inner(world) -> None: assert fh.make(folder, KEY, 2200)["이름"] == made["이름"] # 다시 올려도 같은 SK assert library_uses.users(ref) # 쓰는 곳에 바깥 SK with pytest.raises(store.StoreError) as why: - refs.refuse_used(folder, "sangeun", ref["키"]) + library_uses.refuse_used(folder, "sangeun", ref["키"]) assert why.value.status == 409 # 안쪽이 바뀌면 따라감 — 안쪽 단가 줄 하나 두 배 sub = _read(ref["키"]) diff --git a/resources/tester/test_802_4a_m02_doc.py b/resources/tester/test_802_4a_m02_doc.py index 7a1dfa208..e42a2c5a2 100644 --- a/resources/tester/test_802_4a_m02_doc.py +++ b/resources/tester/test_802_4a_m02_doc.py @@ -17,12 +17,10 @@ from fastapi import HTTPException from M02_MasterTemplete import M02_Doc_B09 as doc_b09 from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Doc_Router as router -from M02_MasterTemplete import M02_Doc_Sk as dsk from M02_MasterTemplete import M02_Doc_Sk_Path as path from M02_MasterTemplete import M02_Item_Snapshot as snap from M02_MasterTemplete import M02_Item_Source as source from M02_MasterTemplete import M02_Labor_Copy as lc -from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_MasterTemplete_Store as store from resources.tester.test_795_1_sk_copy import _calc, _changed, _doc, _fake, _live, _save, _sk from resources.tester.test_795_2_sc_copy import LB, PCT, _double, _labor, _sc @@ -71,11 +69,6 @@ def test_stamp_is_m01_doc_copy(world): assert not got.get("따로") and got["로직"] and got["단가"] m01_calc = dc.mc.calc(root, dc.ml.Links(_live(), dc.folder())) assert _sum(me, key) == m01_calc["계"] - token = dsk.OLD.set(True) - try: - assert _sum(me, key) == m01_calc["계"] # 옛 엔진 금액과 같음 - finally: - dsk.OLD.reset(token) read = _at(me, path.read, key) assert read["셈"]["계"] == m01_calc["계"] and read["사본"]["따로"] is False @@ -181,39 +174,10 @@ def test_sc_and_labor_use_doc(world, monkeypatch): monkeypatch.setattr(lc, "_traced", lambda *a, **k: runs.append(1) or real(*a, **k)) new = (_sc_calc(me, sc)["기준합"], _sc_calc(me, "sub2임시")["반영합"]) assert runs - token = dsk.OLD.set(True) - try: - assert (_sc_calc(me, sc)["기준합"], _sc_calc(me, "sub2임시")["반영합"]) == new - finally: - dsk.OLD.reset(token) _fake(monkeypatch, [_changed(_live().logic(PCT))]) assert _sc_calc(me, sc)["기준합"] == new[0] -@pytest.mark.parametrize( - "code, rate, picks, marks", - [ - ("GC000261", 90, None, None), # 켜쌓기율 = 변수 r · 수량 × r ÷ 100 - ("GF000156", None, {"3": "MT004176", "4": "MT003834"}, None), # 고른 자재 = 요소 키 - ("GC000665", None, None, None), # 별도계상(기본) = 합밖 · 「재료비의 %」 밑엔 듦 - ], -) -def test_line_rules_in_doc(code, rate, picks, marks): - """⑥ 일위대가 줄 옵션 = 문서 규칙(브레인 ④) — 옛 `run_line` · `drop_apart` 와 같은 금액.""" - whole = _live() - old = labor.drop_apart(labor.run_line(whole, code, {}, rate, picks), marks) - assert old["기준"] - apart = dc.apart_of(marks, old.get("재료")) - doc = dc.line_doc(dc.folder()[code], rate, picks, apart) - if rate: - assert dc.RATE_ID in str(doc["금액"][0]["수량"]) - if apart: - assert all(doc["금액"][n].get("합밖") for n in apart) - got = dc.mc.calc(doc, dc.ml.Links(whole, dc.folder()), dc.given_of(whole, code, {})) - assert {k: got[k] for k in dc.COSTS} == {k: old["기준"][k] for k in dc.COSTS} - assert dc.line_doc(dc.folder()[code]) is dc.folder()[code] # 옵션 없음 = 그 문서 - - def test_b09_copy_has_doc_file(world, monkeypatch): """⑦ B09 사본 = 단가 묶음 옆 `수식.json`(만든 때 부름) · 원본판에 듦(로직 몫 · 855-F B9-6) · M01 바뀌어도 그대로.""" diff --git a/resources/tester/test_821_1_my_machine.py b/resources/tester/test_821_1_my_machine.py index afa99fe9e..4399d291e 100644 --- a/resources/tester/test_821_1_my_machine.py +++ b/resources/tester/test_821_1_my_machine.py @@ -186,12 +186,14 @@ def test_rights(world): user = {"role": "USER", "company_id": 7, "user_id": 42} boss = {"role": "ADMIN", "company_id": 7, "user_id": 1} with pytest.raises(HTTPException) as e: - route._folder(user, "personal", "7/43", True) + route._root(user, "personal", "7/43", True, route.MINE) assert e.value.status_code == 403 with pytest.raises(HTTPException) as e: - route._folder(user, "company", None, True) + route._root(user, "company", None, True, route.MINE) assert e.value.status_code == 404 - assert route._folder(user, "personal", None, True) == world["personal"] - assert route._folder(boss, "personal", "7/42") == world["personal"] # 맡은 회사 관리자 읽기 + assert route._root(user, "personal", None, True, route.MINE) == world["personal"] + assert ( + route._root(boss, "personal", "7/42", personal=route.MINE) == world["personal"] + ) # 맡은 회사 관리자 읽기 with pytest.raises(store.StoreError): # 개인 층 아닌 자리에서 만들기 _at(world["company"], mym.create, _easy()) diff --git a/resources/tester/test_840_4_my_material.py b/resources/tester/test_840_4_my_material.py index f81acc4e6..9b9f385f7 100644 --- a/resources/tester/test_840_4_my_material.py +++ b/resources/tester/test_840_4_my_material.py @@ -12,6 +12,7 @@ from __future__ import annotations import pytest from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Library_Uses as library_uses from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Material_Own as own from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 @@ -67,7 +68,7 @@ def test_sk_reads_and_follows(world): assert _at(me, path.read, sk)["셈"]["계"] == 2000 _at(me, own.update, me, code, {"이름": NAME, "규격": "y", "단위": "kg", "값": 1500}) assert _at(me, path.read, sk)["셈"]["계"] == 3000 # 값 바꿈 → 따라옴 - assert [u["키"] for u in _at(me, own.uses, me, code)] == [sk] + assert [u["키"] for u in library_uses.materials(me, [code])[code]] == [sk] assert _at(me, _code, own.remove, me, code) == 409 # 쓰는 곳 있음 _at(me, store.delete, "sangeun", sk) aside = me / "_합친것" / f"{sk}.json" # 파생 · 보관 폴더 = 쓰는 곳 아님 diff --git a/resources/tester/test_855_sk_layers.py b/resources/tester/test_855_sk_layers.py index aab9d397a..f496cfd1e 100644 --- a/resources/tester/test_855_sk_layers.py +++ b/resources/tester/test_855_sk_layers.py @@ -86,12 +86,16 @@ def test_층_SK_한_길_줄_합_기준(world, body): def test_옛_엔진_안_돎(world, monkeypatch): - """한 번 셈에 옛 엔진(`run_line`) 부름 0.""" + """한 번 셈에 옛 엔진(`master_formula.run`) 부름 0 · 옛 줄 셈 함수 없음(855-E 2-E4).""" + import importlib + me = world["personal"] key = _sk(me, 바탕={"로직": FORM}) hits = [] - real = labor.run_line - monkeypatch.setattr(labor, "run_line", lambda *a, **k: hits.append(1) or real(*a, **k)) + eng = importlib.import_module("master_formula") + real = eng.run + monkeypatch.setattr(eng, "run", lambda *a, **k: hits.append(1) or real(*a, **k)) + assert not hasattr(labor, "run_line") _one_path(_run(me, _doc(me, key))) assert hits == [] diff --git a/resources/tester/test_m02_labor_layer.py b/resources/tester/test_m02_labor_layer.py index 991b64561..13c860a63 100644 --- a/resources/tester/test_m02_labor_layer.py +++ b/resources/tester/test_m02_labor_layer.py @@ -20,6 +20,7 @@ from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store +from resources.tester.helper_855_line import run_line CODE = "GC000260" @@ -36,8 +37,8 @@ def test_대상은_골쌓기_기준_주문_로직() -> None: def test_90퍼센트는_100퍼센트_곱하기_0점9() -> None: whole = m01.loaded()[1] - full = labor.run_line(whole, CODE, {}) - part = labor.run_line(whole, CODE, {}, 90) + full = run_line(whole, CODE, {}) + part = run_line(whole, CODE, {}, 90) for k in (*labor.COSTS, "계"): # 751-3 — 곱한 뒤 줄 0.1 원 · 비목 합 1 원 다시 버림 assert part["기준"][k] == pytest.approx(full["기준"][k] * Decimal("0.9"), abs=5) @@ -47,7 +48,7 @@ def test_90퍼센트는_100퍼센트_곱하기_0점9() -> None: assert b["금액"] == pytest.approx(a["금액"] * Decimal("0.9"), abs=Decimal("0.3")) for k, v in a["비목"].items(): assert b["비목"][k] == pytest.approx(v * Decimal("0.9"), abs=Decimal("0.1")) - assert labor.run_line(whole, CODE, {}, 100) == full + assert run_line(whole, CODE, {}, 100) == full @pytest.mark.parametrize("bad", [0, -5, 200.1, 90.55, "abc"]) @@ -91,7 +92,7 @@ def test_옛_단가승격도_율() -> None: whole = m01.loaded()[1] expand = refs.Expand(whole, lambda ref: doc) got = expand({"층": "system", "주인": None, "키": "SP-900001"}) - full = labor.run_line(whole, CODE, {}) + full = run_line(whole, CODE, {}) times = _d(doc["배"]) assert got["기준"]["계"] == pytest.approx(full["기준"]["계"] * Decimal("0.9") / times, abs=5) diff --git a/resources/tester/test_m02_labor_logic_mats.py b/resources/tester/test_m02_labor_logic_mats.py index 9bf93cef2..e29c12e83 100644 --- a/resources/tester/test_m02_labor_logic_mats.py +++ b/resources/tester/test_m02_labor_logic_mats.py @@ -19,6 +19,7 @@ from M02_MasterTemplete import M02_Item_Snapshot as snap from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store +from resources.tester.helper_855_line import run_line from resources.tester.test_m02_structure import write_sample_table HERE = os.path.dirname(os.path.abspath(__file__)) @@ -38,27 +39,27 @@ def _doc(**extra): def test_로직_자재는_맨_위_층_재료_줄_재료_없는_로직은_빈_목록(): - got = labor.run_line(_whole(), NET, {}) + got = run_line(_whole(), NET, {}) assert [(m["차례"], m["품목"]["키"]) for m in got["재료"]] == [ (3, NET_ITEM), (4, WIRE), (5, "MT007705"), ] assert all(m["고름"] is False and m["걸림"] == [] for m in got["재료"]) - assert labor.run_line(_whole(), BARE, {})["재료"] == [] + assert run_line(_whole(), BARE, {})["재료"] == [] def test_조건에_든_입력은_걸림(): - mats = {m["차례"]: m for m in labor.run_line(_whole(), BORING, {})["재료"]} + mats = {m["차례"]: m for m in run_line(_whole(), BORING, {})["재료"]} assert all(mats[n]["걸림"] == ["규격"] for n in range(4, 9)) assert mats[9]["걸림"] == [] def test_고름이_단가와_로직_재료비를_바꿈_고름_없으면_지금_값(): - plain = labor.run_line(_whole(), NET, {}) - again = labor.run_line(_whole(), NET, {}, None, None) + plain = run_line(_whole(), NET, {}) + again = run_line(_whole(), NET, {}, None, None) assert again["기준"] == plain["기준"] # 고름 없음 = 지금 길 그대로(회귀) - picked = labor.run_line(_whole(), NET, {}, None, {"3": WIRE}) + picked = run_line(_whole(), NET, {}, None, {"3": WIRE}) row = picked["재료"][0] assert (row["품목"]["키"], row["고름"]) == (WIRE, True) assert row["단가"] == picked["재료"][1]["단가"] != plain["재료"][0]["단가"] @@ -99,7 +100,7 @@ def test_단가승격도_고름을_따름_없으면_지금_값(): expand = refs.Expand(_whole()) plain = expand._promote({"담은로직": [{"로직": NET}], "배": 1}) picked = expand._promote({"담은로직": [{"로직": NET, "고름": {"3": WIRE}}], "배": 1}) - assert plain["기준"] == labor.run_line(_whole(), NET, {})["기준"] + assert plain["기준"] == run_line(_whole(), NET, {})["기준"] assert picked["기준"]["재료비"] < plain["기준"]["재료비"] @@ -130,7 +131,7 @@ def _release(row: dict, before: dict, mats: list) -> dict: def test_입력이_바뀌면_걸린_고름만_풂_화면_짝(): - mats = labor._json(labor.run_line(_whole(), BORING, {})["재료"]) + mats = labor._json(run_line(_whole(), BORING, {})["재료"]) picks = {"4": "MT007895", "9": WIRE} row = {"로직": BORING, "입력값": {"규격": "NX"}, "고름": picks} assert _release(row, {"규격": "NX"}, mats)["고름"] == picks # 그대로 diff --git a/resources/tester/test_m02_labor_ref.py b/resources/tester/test_m02_labor_ref.py index c4ec1d66a..8fb336b71 100644 --- a/resources/tester/test_m02_labor_ref.py +++ b/resources/tester/test_m02_labor_ref.py @@ -3,7 +3,7 @@ 펼침(재귀 · 순환 · 깊이) · 층 규칙(위 층만) · 쓰는 곳 지우기 409 · 층 사이 따라 복사 · 프로젝트 굳힘 · 로직 지우기 검사 · TS 짝 settle 거울. 층은 임시 폴더(마스터 · storage). 옛 단가승격(SP) = 새로 못 만듦 · 남은 파일은 읽기 · 셈 · 굳힘만(`_promote` = 옛 파일을 바로 씀) · -층 문서를 읽을 때 옛 참조 줄 = 로직 줄 + 승격(`unpromote` · 같은 로직이 있으면 그대로). +읽을 때 옛 참조 줄을 새 꼴로 바꾸던 것은 858 5-8 에서 걷음(요구 899 — 옛 꼴 호환 없음). """ import json @@ -16,6 +16,7 @@ from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Library_Uses as library_uses from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Template_Layers as layers +from resources.tester.helper_855_line import run_line from resources.tester.test_m02_labor_calc_mirror import _same, _ts from resources.tester.test_m02_structure import write_sample_table @@ -88,7 +89,7 @@ def _read(folder, kind, key): def _base(code): import M01_MasterData.M01_MasterData_Store as m01 - return labor.run_line(m01.loaded()[1], code, {})["기준"] + return run_line(m01.loaded()[1], code, {})["기준"] # ── 자료 틀 ──────────────────────────────────────────────────────────── @@ -98,74 +99,6 @@ def test_단가승격_서고는_없음_층_종류에서_뺌(world): refs.create("promote", {"담은로직": [{"로직": TEN}]}) -# ── 옛 단가승격 참조 줄 = 읽을 때 새 꼴(134-2) ─────────────────────────── -def test_옛_참조_줄은_로직_줄_승격으로_보이고_값_같음(world): - sp = _promote(world["system"], TEN) - old = { - "열": "rv", - "담은로직": [ - {"참조": {**SYS, "키": sp}, "별칭": "승", "메모": "m", "수량": {"손": 4}}, - {"로직": STONE, "수량": {"손": 1}}, - ], - "자재": [], - } - got = refs.unpromote("labor", old) - assert got["담은로직"][0] == { - "로직": TEN, - "별칭": "승", - "메모": "m", - "입력값": {}, - "수량": {"손": 4}, - "승격": True, - } - assert old["담은로직"][0]["참조"]["키"] == sp # 받은 문서는 그대로 - held = _promote(world["system"], PLAIN, {"규격": "NX"}, 켜쌓기율=90) # 입력값 · 율도 옮김 - one = refs.unpromote("labor", {"담은로직": [{"참조": {**SYS, "키": held}}]})["담은로직"][0] - assert (one["입력값"], one["켜쌓기율"]) == ({"규격": "NX"}, 90) - with store.at(world["system"]): - before = labor.calc(labor.clean(old), {})["반영합"]["계"] - after = labor.clean(got) - assert after["담은로직"][0]["승격"] is True # [저장] 때 새 꼴로 굳음 - assert labor.calc(after, {})["반영합"]["계"] == pytest.approx(before, rel=1e-9) - - -def test_옛_참조_줄은_같은_로직이_있으면_그대로_사전조합은_승격_없이(world): - sp = _promote(world["system"], STONE) - lines = [{"로직": STONE, "수량": None}, {"참조": {**SYS, "키": sp}, "수량": None}] - doc = {"열": "rv", "담은로직": lines, "자재": []} - assert refs.unpromote("labor", doc) is doc # 겹침 = 옛 참조 줄 그대로(저장 됨) - with store.at(world["system"]): - assert labor.clean(doc)["담은로직"][1]["참조"]["키"] == sp - combo = {"담은로직": [{"참조": {**SYS, "키": sp}, "수량": {"손": 2}, "메모": None}]} - one = refs.unpromote("precombo", combo)["담은로직"][0] - assert one["로직"] == STONE and one["수량"] == {"손": 2} and "승격" not in one - assert refs.unpromote("area", combo) is combo # 다른 종류는 안 봄 - - -def test_층_길_읽기는_옛_참조_줄을_새_꼴로_파일은_그대로(world): - from fastapi import FastAPI - from fastapi.testclient import TestClient - - from common_util.common_util_auth import verify_session - from M02_MasterTemplete import M02_MasterTemplete_Router_Layers as layer_router - - sp = _promote(world["system"]) - with store.at(world["personal"]): - line = {"참조": {**SYS, "키": sp}, "수량": {"손": 2}} - store.write("labor", "x1", "", {"열": "x1", "담은로직": [line], "자재": []}) - app = FastAPI() - app.include_router(layer_router.router) - app.dependency_overrides[verify_session] = lambda: { - "user_id": 42, - "company_id": 7, - "role": "USER", - "is_master": False, - } - got = TestClient(app).get("/api/m02/layers/personal/templates/labor/x1").json() - assert got["문서"]["담은로직"][0]["로직"] == TEN and got["문서"]["담은로직"][0]["승격"] is True - assert _read(world["personal"], "labor", "x1")["담은로직"][0]["참조"]["키"] == sp - - def test_사전조합_틀린_줄_400_순환_422(world): sp = _promote(world["system"]) one = {"참조": {**SYS, "키": sp}} @@ -541,7 +474,7 @@ def test_사전조합이_자기_자신을_담으면_422_수량_없음(world): assert e.value.status == 422 and "자기 자신" in e.value.detail -def test_서고_구분_상세구분_사전조합은_고른_값_옛_문서는_읽을_때(world): +def test_서고_구분_상세구분_사전조합은_고른_값(world): sp = _promote(world["system"]) sc = _combo(world["system"], [{"참조": {**SYS, "키": sp}}]) assert (_read(world["system"], "precombo", sc)["구분"], "") == ("", "") @@ -550,10 +483,6 @@ def test_서고_구분_상세구분_사전조합은_고른_값_옛_문서는_읽 store.write("precombo", sc, have["판"], {**have["문서"], "구분": " 가 ", "상세구분": "나"}) got = _read(world["system"], "precombo", sc) assert (got["구분"], got["상세구분"]) == ("가", "나") - # 옛 문서(칸 없음) — 사전조합은 빈 글 · 옛 승격은 손대지 않음 - old = _read(world["system"], "promote", sp) - assert refs.filled("promote", old) is old - assert refs.filled("precombo", {"담은로직": []})["구분"] == "" rows = [{"종류": "precombo", "이름": sc}] refs.summaries(world["system"], rows) assert (rows[0]["구분"], rows[0]["상세구분"], rows[0]["연결"]) == ("가", "나", None) diff --git a/resources/tester/test_m02_precombo_class.py b/resources/tester/test_m02_precombo_class.py index b80d9bc82..9208ab004 100644 --- a/resources/tester/test_m02_precombo_class.py +++ b/resources/tester/test_m02_precombo_class.py @@ -1,7 +1,6 @@ """일위대가 사전조합 구분 · 상세구분 새 분류(PLAN 134-5) — 구조물군 A~G › 그 군 종류 + 「공통」. - 원천 = 마스터 `구조물정의.json`(구조물군 · types) — 군마다 첫 상세구분 「공통」 · 꺼진 종류도 · 「호환(기타)」 뺌 -- 옛 품셈 분류(건설품셈 공통 · 산림품셈) = 읽을 때 빈 값(미분류) · 파일 안 고침 · 새 분류 값 · 지금 값은 그대로 - 새 문서 = 빈 값(미분류) · 상세 드롭다운 원천 = 구조물 정의(로직 구분 목록 아님) """ @@ -10,8 +9,6 @@ import os import subprocess from pathlib import Path -from M02_MasterTemplete import M02_Labor_Ref as refs - HERE = os.path.dirname(os.path.abspath(__file__)) ROOT = Path(HERE).parents[1] M02 = ROOT / "M02_MasterTemplete" @@ -49,18 +46,6 @@ def test_분류는_구조물군_종류_공통(): ) -def test_옛_품셈_분류는_미분류_새_값은_그대로(): - old = {"이름": "가", "구분": "건설품셈 공통", "상세구분": "07장 돌공사", "담은로직": []} - got = refs.filled("precombo", old) - assert (got["구분"], got["상세구분"]) == ("", "") and old["구분"] == "건설품셈 공통" - assert refs.filled("precombo", {**old, "구분": "산림품셈", "상세구분": "03장"})["구분"] == "" - now = {**old, "구분": "C 사면안정", "상세구분": "옹벽"} - assert refs.filled("precombo", now) is now - gone = {**old, "구분": "Z 없어진 군", "상세구분": "x"} # 지금 값은 선택지로(화면 몫) - assert refs.filled("precombo", gone) is gone - assert refs.filled("precombo", {"담은로직": []})["구분"] == "" # 칸 없는 옛 문서 - - def test_화면_원천은_구조물_정의_새_문서는_미분류(): detail = (M02 / "M02_MasterTemplete_Labor_LibMeta.ts").read_text("utf-8") # 717-3 나눔 assert "subs = precomboClasses(def);" in detail and "fetchLibLogicSubs" not in detail