refactor(855-E 2-E4): 값 사본 닫힌 묶음 = 수식 문서 묶음 — Item_Prices.collect 옛 식 글 훑기 걷음
- M02_Item_Prices.collect: 로직 키 → `Doc_Copy.closure` 문서 묶음 → `Item_Bundle.collect`(자원 · 표 줄 · 로직 줄 없음) ·
M01 문서 없는 키 = `_빠진` · `extra`(마스터 밖 로직 줄) 안 받음(부르는 곳 0) · `_Collector` 옛 훑기
(refs · pick · flow · element · logic · row · `_texts`) 지움 — 옛 엔진 몸 부름 mf.parse · walk · fill · _HOLE · _expand · static 7 → 0
- M02_Item_Bundle: 구멍 값 후보 = 고르기 목록 · 빈 목록 = 끼울 값 없음 · 요소 칸을 읽는 변수(「EQ:{기계}」 의 조종원직종 ·
주연료종류) = 그 줄 값(옛 `_choices` 와 같은 뜻 · 기계 = 인력 · 잡품 보기)
- 대조: 값 사본(`skc.snap` → 로직 줄 뺀 꼴) 표본 로직 150 옛 = 새 같음(전엔 테이블 통째 20,227 줄 더 담김)
- 시험: test_155_5 견본 = 문서 묶음 색인(고친 로직 줄 = 값 사본 줄 → 그 줄 문서) · test_item_copy_complete
닫힌 묶음 = 문서 셈 대조(옛 엔진 run 대조 걷음)
- 검증: 묶음 ① 커밋 글과 같음
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -17,18 +17,48 @@ from typing import Any
|
||||
from M02_MasterTemplete import M02_Item_Prices as prices
|
||||
|
||||
import master_doc as md # noqa: E402 — scripts 길 = prices(m01) 뒤에
|
||||
import master_machine_crew as crew # noqa: E402
|
||||
|
||||
_HOLE = re.compile(r"\{([^{}]+)\}")
|
||||
|
||||
|
||||
def _options(ids: dict, hole: str) -> list | None:
|
||||
opts = ((ids.get(hole) or {}).get("연결") or {}).get("목록")
|
||||
return [str(x).strip("'") for x in opts] if opts else None
|
||||
|
||||
|
||||
class _Docs(prices._Collector):
|
||||
"""수식 문서가 잇는 자원 · 표 줄 키 모음."""
|
||||
|
||||
def options(self, ids: dict, hole: str, depth: int = 0) -> list | None:
|
||||
"""구멍 변수의 값 후보 — 고르기 목록 · 요소 칸을 읽는 변수(「EQ:{기계}」 의 조종원직종 등) = 그 틀을
|
||||
끼운 줄마다 그 칸 값(옛 식 글 훑기 `_expand` 와 같은 뜻) · 모름 = None."""
|
||||
link = (ids.get(hole) or {}).get("연결") or {}
|
||||
if isinstance(link.get("목록"), list): # 빈 목록 = 끼울 값 없음(옛 `_choices` 와 같음)
|
||||
return [str(x).strip("'") for x in link["목록"]]
|
||||
if link.get("갈래") != "요소" or not link.get("키") or not link.get("칸") or depth > 3:
|
||||
return None
|
||||
keys = self._filled(str(link["키"]), ids, depth + 1)
|
||||
if keys is None:
|
||||
return None
|
||||
out = []
|
||||
for key in keys:
|
||||
try:
|
||||
row = self.whole.get(key)
|
||||
except prices.mf.FormulaError:
|
||||
continue
|
||||
vals = row.get("값") or {} # 줄 값 — 기계 = 인력 · 잡품 목록을 칸으로(842-3)
|
||||
vals = crew.view(vals) if str(row.get("키"))[:2] == "EQ" else vals
|
||||
value = vals.get(link["칸"]) if isinstance(vals, dict) else None
|
||||
if value not in (None, ""):
|
||||
out.append(str(value))
|
||||
return list(dict.fromkeys(out))
|
||||
|
||||
def _filled(self, text: str, ids: dict, depth: int = 0) -> list[str] | None:
|
||||
"""틀 글 → 끼운 글들 · 못 끼움 = None."""
|
||||
out = [text]
|
||||
for hole in sorted(set(_HOLE.findall(text))):
|
||||
opts = self.options(ids, hole, depth)
|
||||
if opts is None:
|
||||
return None
|
||||
out = [one.replace(f"{{{hole}}}", x) for one in out for x in opts]
|
||||
return out
|
||||
|
||||
def doc(self, doc: dict) -> None:
|
||||
ids = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
for v in ids.values():
|
||||
@@ -42,16 +72,13 @@ class _Docs(prices._Collector):
|
||||
self.add(ref)
|
||||
|
||||
def fill(self, text: str, ids: dict) -> list[str]:
|
||||
"""틀 글 `{변수}` 구멍 → 고르기 목록으로 끼운 글들 · 목록 없는 구멍 = 그 테이블 전부(빈 목록)."""
|
||||
out = [text]
|
||||
for hole in sorted(set(_HOLE.findall(text))):
|
||||
opts = _options(ids, hole)
|
||||
if opts is None:
|
||||
tid = prices.mk.id_of(text)
|
||||
if tid and tid not in prices._TOO_BIG:
|
||||
self.keys.update(self.whole.index.get(tid, {}))
|
||||
return []
|
||||
out = [one.replace(f"{{{hole}}}", x) for one in out for x in opts]
|
||||
"""틀 글 `{변수}` 구멍 → 값 후보로 끼운 글들(`options`) · 못 끼움 = 그 테이블 전부(빈 목록)."""
|
||||
out = self._filled(text, ids)
|
||||
if out is None:
|
||||
tid = prices.mk.id_of(text)
|
||||
if tid and tid not in prices._TOO_BIG:
|
||||
self.keys.update(self.whole.index.get(tid, {}))
|
||||
return []
|
||||
return out
|
||||
|
||||
def cond(self, cond: dict, unit: Any, ids: dict) -> None:
|
||||
@@ -61,7 +88,7 @@ class _Docs(prices._Collector):
|
||||
variants = [cond]
|
||||
holes = {h for v in cond.values() if isinstance(v, str) for h in _HOLE.findall(v)}
|
||||
for hole in sorted(holes):
|
||||
opts = _options(ids, hole)
|
||||
opts = self.options(ids, hole)
|
||||
if opts is None:
|
||||
variants = [prices.mm.static(cond)]
|
||||
break
|
||||
|
||||
@@ -23,7 +23,7 @@ from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_MyMachine as mym
|
||||
from M02_MasterTemplete import M02_MyMachine as mym # noqa: F401 — Item_Bundle.collect 가 씀
|
||||
|
||||
mf = m01.cm.mf
|
||||
mk = m01.mk
|
||||
@@ -39,18 +39,6 @@ def master() -> tuple[dict[str, dict], Any]:
|
||||
return m01.loaded()
|
||||
|
||||
|
||||
def _texts(row: dict) -> list[str]:
|
||||
out = [step["식"] for step in row.get("중간", [])]
|
||||
if "결과" in row:
|
||||
out.append(row["결과"]["식"])
|
||||
for item in row.get("호표", []):
|
||||
out.append(item["수량"])
|
||||
if isinstance(item.get("요소"), str): # 단가산출 참조 · 고정 더한줄 = 요소 없음(719-1)
|
||||
out.append(item["요소"])
|
||||
out += [extra["식"] for extra in row.get("덧줄", [])]
|
||||
return out
|
||||
|
||||
|
||||
#: 재료 후보 찾기 답 — (마스터 색인, {조건 글: 키}) · 색인이 바뀌면(마스터 저장) 새로 ·
|
||||
#: 복사본 목록이 복사본마다 단가 묶음을 다시 모아도 같은 조건은 한 번만 찾음(156-2)
|
||||
_FOUND: tuple[Any, dict[str, list[str]]] = (None, {})
|
||||
@@ -73,22 +61,8 @@ class _Collector:
|
||||
def __init__(self, whole: Any):
|
||||
self.whole = whole
|
||||
self.keys: set[str] = set()
|
||||
self.logics: set[str] = set()
|
||||
self.missing: list[str] = []
|
||||
|
||||
def refs(self, row: dict, template: str) -> list[str]:
|
||||
"""원문번호 틀 → 닿을 수 있는 요소 참조 — 고르기로 끼우고, 못 풀면 그 테이블 전부."""
|
||||
if "{" not in template:
|
||||
return [template]
|
||||
expanded = mf._expand(row, template, self.whole)
|
||||
if expanded is not None:
|
||||
return expanded
|
||||
tid = mk.id_of(template)
|
||||
if not tid or tid in _TOO_BIG:
|
||||
self.missing.append(f"{row.get('키')} 「{template}」 틀을 못 풂")
|
||||
return []
|
||||
return list(self.whole.index.get(tid, {}))
|
||||
|
||||
def add(self, ref: str) -> None:
|
||||
try:
|
||||
row = self.whole.get(ref)
|
||||
@@ -119,113 +93,6 @@ class _Collector:
|
||||
if root.endswith(want) and u == unit_p and (not spec or s == spec):
|
||||
self.keys.add(key)
|
||||
|
||||
def pick(self, row: dict, cond: dict, unit: Any) -> None:
|
||||
"""재료 고르기 조건 — 대표 줄 · 후보 줄(`{입력}` 은 고르기 값으로 끼움)."""
|
||||
if cond.get("지역") == "입력" or cond.get("계약종별") == "입력":
|
||||
self.widely(cond, unit)
|
||||
return
|
||||
holes = sorted(
|
||||
{h for v in cond.values() if isinstance(v, str) for h in mf._HOLE.findall(v)}
|
||||
)
|
||||
variants = [cond]
|
||||
if holes:
|
||||
env_sets = mf._expand(row, "|".join(f"{{{h}}}" for h in holes), self.whole)
|
||||
if env_sets is None:
|
||||
variants = [mf.static(cond)]
|
||||
else:
|
||||
variants = []
|
||||
for filled in env_sets:
|
||||
env = dict(zip(holes, filled.split("|")))
|
||||
variants.append(
|
||||
{k: mf.fill(v, env) if isinstance(v, str) else v for k, v in cond.items()}
|
||||
)
|
||||
for one in variants:
|
||||
if one.get("대표"):
|
||||
self.add(str(one["대표"]))
|
||||
if not one.get("구분") and not one.get("검색어"):
|
||||
continue
|
||||
for key in _candidates(self.whole, one):
|
||||
self.add(key)
|
||||
|
||||
def flow(self, row: dict) -> None:
|
||||
"""흐름 입력 상자 — 요소(고정 · 기본 · 검색어 묶음 · 조건 찾기 후보) · 표 · 다른 로직 ·
|
||||
기계 시간당 경비 로직."""
|
||||
from M02_MasterTemplete.DataFlow import M02_DF_Values as dv # 흐름 값 찾기와 같은 뜻
|
||||
|
||||
for box in row["흐름"].get("boxes") or []:
|
||||
inp = (box.get("input") or {}) if box.get("kind") == "input" else {}
|
||||
if inp.get("mode") == "logic":
|
||||
self.logic(str((inp.get("logic") or {}).get("key") or ""))
|
||||
if inp.get("table"):
|
||||
self.add(str(inp["table"].get("key") or ""))
|
||||
for el in inp.get("elements") or []:
|
||||
ref, unit = str(el.get("ref") or ""), el.get("unit")
|
||||
for one in (ref, str(el.get("default") or "")):
|
||||
cond = dv._pick(one)
|
||||
if cond is not None:
|
||||
self.pick(row, cond, unit)
|
||||
elif one and not one.startswith("UE-"):
|
||||
self.element(one)
|
||||
if el.get("mode") != "rule":
|
||||
continue
|
||||
if inp.get("group") in dv.GROUP_RULE: # 인력 · 기계 · 유가전력 찾기 = 그 그룹 전부
|
||||
self.keys.update(str(r.get("키")) for r in dv._group_rows(inp["group"]))
|
||||
elif dv._pick(ref) is None: # 재료 범위 찾기 — 범위(구분 · 상세구분) 후보
|
||||
scope = el.get("scope") or {}
|
||||
self.pick(
|
||||
row, {k: scope[k] for k in ("구분", "상세구분") if scope.get(k)}, unit
|
||||
)
|
||||
|
||||
def element(self, ref: str) -> None:
|
||||
"""요소 키 · 「EQ키#칸」(시간당 경비면 그 기계경비 로직까지) · 「ID:원문번호{…}」 틀."""
|
||||
from M02_MasterTemplete.DataFlow import M02_DF_Values as dv
|
||||
|
||||
base, _, field = ref.partition(dv.MACHINE_SEP)
|
||||
if "{" in base: # 「EQ:{기계}」 같은 틀 — 그 테이블 전부
|
||||
self.keys.update(self.whole.index.get(mk.id_of(base) or "", {}))
|
||||
return
|
||||
self.add(base)
|
||||
if field == dv.HOURLY:
|
||||
from M02_MasterTemplete import M02_Machine_Hourly as mh
|
||||
|
||||
row = self.whole.index.get(base[:2], {}).get(base) or {}
|
||||
if got := mh.pick(row): # 식 고름 한 곳(822-2)
|
||||
self.logic(str(got.get("키")))
|
||||
|
||||
def logic(self, key: str) -> None:
|
||||
if key in self.logics:
|
||||
return
|
||||
try:
|
||||
row = self.whole.logic(key)
|
||||
except mf.FormulaError as error:
|
||||
self.missing.append(f"{key} · {error}")
|
||||
return
|
||||
self.logics.add(key)
|
||||
self.keys.add(key)
|
||||
self.row(row)
|
||||
|
||||
def row(self, row: dict) -> None:
|
||||
"""로직 줄 하나가 닿는 것 — 마스터 로직 · 굳힌 단가산출 줄(719-1 · 마스터 밖 줄)."""
|
||||
if isinstance(row.get("흐름"), dict): # 흐름 로직 — 옛 칸 대신 흐름이 쓰는 것을 모음
|
||||
self.flow(row)
|
||||
return
|
||||
for text in _texts(row):
|
||||
try:
|
||||
node = mf.parse(text)
|
||||
except mf.FormulaError:
|
||||
continue # 못 읽는 식 — 계산도 같은 까닭으로 멈춤
|
||||
for part in mf.walk(node):
|
||||
kind = part[0]
|
||||
if kind == "ref" or kind == "find":
|
||||
for ref in self.refs(row, part[1]):
|
||||
self.add(ref)
|
||||
elif kind == "logic":
|
||||
for ref in self.refs(row, part[1]):
|
||||
self.logic(ref)
|
||||
for item in row.get("호표", []):
|
||||
if isinstance(item.get("요소"), dict):
|
||||
self.pick(row, item["요소"], item.get("단위"))
|
||||
|
||||
|
||||
#: M01 에서 지워진 사본 줄(795-4) 자리 — `Master` 가 그룹 아닌 「줄」 로 읽음
|
||||
COPY_FILE = "사본_남은줄.json"
|
||||
@@ -238,45 +105,19 @@ def collect(
|
||||
over: list[dict] | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""담은 로직 + 자재(MT)의 닫힌 단가 묶음 — `{파일 이름: 파일(줄은 모은 것만 · 차례 그대로)}` ·
|
||||
`extra` = 마스터 밖 로직 줄(굳힌 단가산출 719-1) — 그 줄이 닿는 것만 모음(줄은 안 담음) ·
|
||||
`over` = M02 로직 사본 줄(795-4) — 같은 키는 M01 줄 대신 · M01 에 없는 키 = `COPY_FILE`."""
|
||||
files, whole = master()
|
||||
from M02_MasterTemplete import M02_Material_Own as mat
|
||||
닫힌 묶음 = 로직 키의 수식 문서 묶음(`M02_Doc_Copy.closure`)이 잇는 자원 · 표 줄(`M02_Item_Bundle.collect`
|
||||
· 로직 줄 · 옛 식 글 훑기 없음 · 855-E 2-E4) · `over` = M02 값 사본 줄(795-4 · 같은 키는 M01 줄 대신) ·
|
||||
M01 수식 문서 없는 로직 키 = `_빠진` · `extra`(마스터 밖 로직 줄) = 받지 않음(부르는 곳 0)."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_Item_Bundle as item_bundle
|
||||
|
||||
whole = mat.whole(
|
||||
mym.whole(whole)
|
||||
) # 지금 층 내 기계(821-1) · 내 재료(840-4) — 없으면 M01 그대로
|
||||
own = {str(r.get("키")): r for r in (*mym.added(whole), *mat.added(whole))}
|
||||
mine = {str(r.get("키")): r for r in over or []}
|
||||
if mine:
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
|
||||
whole = skc.Copy(whole, skc._rows({"로직": list(mine.values())}))
|
||||
collector = _Collector(whole)
|
||||
for key in logic_keys:
|
||||
collector.logic(key)
|
||||
for row in extra or []:
|
||||
collector.row(row)
|
||||
for code in materials or []:
|
||||
collector.add(code)
|
||||
out: dict[str, Any] = {}
|
||||
seen: set[str] = set()
|
||||
for name, data in files.items():
|
||||
slot = m01.items_key(data)
|
||||
rows = [
|
||||
mine.get(str(row.get("키")), row)
|
||||
for row in data.get(slot) or []
|
||||
if str(row.get("키")) in collector.keys
|
||||
]
|
||||
seen.update(str(row.get("키")) for row in rows)
|
||||
if rows:
|
||||
out[name] = {**{k: v for k, v in data.items() if k != slot}, slot: rows}
|
||||
left = [r for k, r in {**own, **mine}.items() if k in collector.keys and k not in seen]
|
||||
if left:
|
||||
out[COPY_FILE] = {"그룹": "사본", "줄": left}
|
||||
if collector.missing:
|
||||
out["_빠진"] = sorted(set(collector.missing))
|
||||
return out
|
||||
keys = [str(k) for k in logic_keys]
|
||||
docs = dc.closure(master()[1], keys)
|
||||
out = item_bundle.collect(docs, materials, over)
|
||||
lost = sorted(
|
||||
set(out.pop("_빠진", [])) | {f"{k} · 수식 문서 없음" for k in keys if k not in docs}
|
||||
)
|
||||
return out | ({"_빠진": lost} if lost else {})
|
||||
|
||||
|
||||
def to_json(value: Any) -> Any:
|
||||
|
||||
@@ -22,15 +22,27 @@ BASE = "GF000218" # 기초다짐 및 뒷채움(기계) — 보통인부 + 굴
|
||||
GIVEN = {"규격": 150, "지역": "전국평균", "보정작업": "해당 없음"}
|
||||
|
||||
|
||||
def _copy(codes, over=None):
|
||||
"""사본 셈 색인(855-E 2-E4) = 수식 문서 묶음 + 그 문서가 잇는 자원 · 표 줄(`Item_Bundle.load`) ·
|
||||
`over` = 견본 값 사본 색인(고친 로직 줄 → 그 줄 문서)."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_Item_Bundle as item_bundle
|
||||
|
||||
docs = dc.closure(over or item_prices.master()[1], codes)
|
||||
return item_bundle.load(item_prices.to_json(item_bundle.collect(docs)), docs)
|
||||
|
||||
|
||||
def _whole(edit=None):
|
||||
"""사본 단가 묶음 — `edit(로직 줄)` 로 GF000218 을 엑셀 견본 꼴로 바꿈(수량 · 중간 · 덧줄)."""
|
||||
files = copy.deepcopy(item_prices.to_json(item_prices.collect([BASE])))
|
||||
if edit:
|
||||
for data in files.values():
|
||||
for row in data.get("줄") or []:
|
||||
if isinstance(row, dict) and row.get("키") == BASE:
|
||||
edit(row)
|
||||
return item_prices.load_prices(files)
|
||||
"""사본 셈 색인 — `edit(로직 줄)` 로 GF000218 을 엑셀 견본 꼴로 바꿈(수량 · 중간 · 덧줄 · 고친 줄 =
|
||||
값 사본 줄 → 그 줄 문서)."""
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
|
||||
if not edit:
|
||||
return _copy([BASE])
|
||||
master = item_prices.master()[1]
|
||||
row = copy.deepcopy(item_prices.to_json(master.logic(BASE)))
|
||||
edit(row)
|
||||
return _copy([BASE], skc.Copy(master, skc._rows({"로직": [row]})))
|
||||
|
||||
|
||||
def _excel(qty_labor: str, qty_eq: str, mids=(), extras=()):
|
||||
@@ -102,7 +114,7 @@ def test_켜쌓기율_꼬리():
|
||||
|
||||
def test_글_속_금액은_산근_풀이_값과_같음():
|
||||
for code, given in ((BASE, GIVEN), ("GF000288", {})): # 중기 · 노무 · % 덧줄 · 배 1,000
|
||||
whole = item_prices.load_prices(item_prices.to_json(item_prices.collect([code])))
|
||||
whole = _copy([code])
|
||||
block = sg.Solver().add(whole, {"code": code, "given": given}, "s1")
|
||||
assert block["foot"] == _foot(block), code
|
||||
for ln in block["lines"]:
|
||||
@@ -115,7 +127,7 @@ def test_글_속_금액은_산근_풀이_값과_같음():
|
||||
|
||||
def test_자재_자리표시_키는_실제_키로():
|
||||
"""「MO:휘발유:{지역}」 자리표시 = 대비표 키(MO…) · 수집량 공식 줄 · 「× (6.5 × 0.125)」 · % 덧줄."""
|
||||
whole = item_prices.load_prices(item_prices.to_json(item_prices.collect(["GF000062"])))
|
||||
whole = _copy(["GF000062"])
|
||||
block = sg.Solver().add(whole, {"code": "GF000062", "given": {}}, "s1")
|
||||
fuel = next(ln for ln in block["lines"] if ln["name"].startswith("휘발유"))
|
||||
assert fuel["ref"]["key"].startswith("MO") and ":" not in fuel["ref"]["key"]
|
||||
|
||||
@@ -148,37 +148,37 @@ def test_지정하면_새_파일까지_복사(world):
|
||||
|
||||
|
||||
def test_단가_묶음은_닫혀_있음(world):
|
||||
"""조합마다 복사본 단가 묶음만으로 돌린 값 = 마스터로 돌린 값(자동값 · 고르기 끝값)."""
|
||||
"""조합마다 복사본 단가 묶음 + 수식 문서만으로 셈한 값 = 마스터로 셈한 값(자동값 · 고르기 첫 · 끝값 ·
|
||||
문서 셈 · 855-E 2-E4 — 옛 엔진 대조 걷음)."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_Item_Bundle as item_bundle
|
||||
|
||||
files, whole = prices.master()
|
||||
combos = [r for d in files.values() if d.get("그룹") == "일위대가조합" for r in d["줄"]]
|
||||
runs = 0
|
||||
for ua in combos:
|
||||
keys = prices.mcb.logic_keys(ua)
|
||||
snapshot = prices.load_prices(prices.to_json(prices.collect(keys)))
|
||||
docs = dc.closure(whole, keys)
|
||||
snapshot = item_bundle.load(prices.to_json(prices.collect(keys)), docs)
|
||||
for key in keys:
|
||||
try:
|
||||
row = whole.logic(key)
|
||||
except prices.mf.FormulaError:
|
||||
doc = docs.get(key)
|
||||
if doc is None:
|
||||
continue
|
||||
picks = [
|
||||
v for v in doc.get("변수") or [] if (v.get("연결") or {}).get("갈래") == "선택"
|
||||
]
|
||||
for pick in (0, -1):
|
||||
values = m01.mau.values(whole, row)
|
||||
for spec in row.get("입력", []):
|
||||
if spec.get("고르기"):
|
||||
values[spec["이름"]] = spec["고르기"][pick]
|
||||
assert _run(whole, key, values) == _run(snapshot, key, values), (ua["키"], key)
|
||||
given = {v["열쇠"]: v["연결"]["목록"][pick] for v in picks if v["연결"].get("목록")}
|
||||
one = {"로직": key, "입력값": given}
|
||||
want = prices.line(whole, dict(docs), one)
|
||||
got = prices.line(snapshot, dict(docs), one)
|
||||
assert _money(got) == _money(want), (ua["키"], key)
|
||||
runs += 1
|
||||
assert len(combos) >= 30 and runs >= 300
|
||||
|
||||
|
||||
def _run(master: Any, key: str, values: dict) -> str:
|
||||
try:
|
||||
got = prices.mf.run(master, key, dict(values))
|
||||
except Exception as error: # 까닭도 같아야 함
|
||||
return f"멈춤 {error}"
|
||||
return str(got.get("계", got.get("결과")))
|
||||
|
||||
|
||||
# ── 계산 · 마스터 바뀜 · 새로 가져오기 ───────────────────
|
||||
def _money(got: dict) -> str:
|
||||
return str(got.get("기준") or got.get("결과") or got.get("까닭"))
|
||||
|
||||
|
||||
def test_입력이_없으면_빠진_입력_목록_셈은_자동값(world):
|
||||
|
||||
Reference in New Issue
Block a user