From df96db9dcc1f12a4eb354677b081a258882c6add Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 13:51:01 +0900 Subject: [PATCH] =?UTF-8?q?test(855-E=202-E4=20=E3=89=AE-1):=20helper=5F85?= =?UTF-8?q?5=5Fengine=20=EC=83=88=20=EC=AA=BD=EB=A7=8C=20=EB=82=A8?= =?UTF-8?q?=EA=B9=80=20=E2=80=94=20=EC=98=9B=20=EC=97=94=EC=A7=84=20?= =?UTF-8?q?=EB=8C=80=EC=A1=B0=20=EC=9D=80=ED=87=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - helper_855_engine: world = (색인 · 수식 문서 · 연결) · doc_cases · new_run · answer · fingerprint 만 남김 — 옛 쪽(cases · old_run · level · adopted · _old_env · _old_captured · old_line_calls)과 master_formula · master_cut · master_equation · 빌더 import 지움 · 지문 같음(골든 전수 1,521 통과) - test_855_engine_parity git rm — 옛 엔진 ↔ 새 계산기 대조(다름 0 은 걸음마다 확인됨) · 뒤는 test_855_golden 이 지킴 - test_855_trace: 옛 가로채기 자원 키 · 옛 하위 부름(line_calls) 대조 둘 지움 · 기록 켜도 셈 답 같음 · 고른 품목 · 기계경비 부름은 그대로 · 셈 문서 수 > 1000(빈 통과 막음) · 전수 = 수식 문서 전부 - test_855_block: 옛 check_logic 대조 둘(옛 = 새 · 틀린 식 두 판정) 지움 · 문서 막힘 화면 답 · 저장 검사 · 요소 닫힘 셋 그대로 - test_855_golden · test_855_e4a_base_only: world 차례 고침만 Co-Authored-By: Claude Opus 5.5 --- resources/tester/helper_855_engine.py | 189 ++------------------- resources/tester/test_855_block.py | 32 +--- resources/tester/test_855_e4a_base_only.py | 2 +- resources/tester/test_855_engine_parity.py | 43 ----- resources/tester/test_855_golden.py | 2 +- resources/tester/test_855_trace.py | 104 +----------- 6 files changed, 24 insertions(+), 348 deletions(-) delete mode 100644 resources/tester/test_855_engine_parity.py diff --git a/resources/tester/helper_855_engine.py b/resources/tester/helper_855_engine.py index f27f74f21..bbd226245 100644 --- a/resources/tester/helper_855_engine.py +++ b/resources/tester/helper_855_engine.py @@ -1,12 +1,8 @@ -"""855-A 지킴 도우미 — 로직마다 셈 경우(기본 + 옵션 표본) · 옛 엔진 대 새 계산기 층 가름 · 새 답 지문. +"""855-A 지킴 도우미 — 수식 문서마다 셈 경우(기본 + 옵션 표본) · 새 계산기 답 지문. -- 경우 = 빌더 대조와 같은 표본(`build_수식문서_802_2.build`) — 기본 입력(수식 탭 기본값) + 고르기 입력의 - 다른 갈래 하나씩(나머지 기본). -- 옛 = `master_formula.run` → `master_cut.engine` · 새 = 저장된 수식 문서(`master_doc_link.load_all`) · - `master_doc_calc.calc`. -- 층(앞 층이 다르면 뒤 층 안 봄): L0 합계 · L1 줄 이름별 비목 금액 · L2 줄 꼴(차례 · 이름 · 금액 · 비목) · - L3 수량 · 단가. 「보임」 = 금액은 같고 보이는 단가만 다름(옛 = 줄 끝수 자리로 자른 단가 · 새 = 날 값 / - 수량 0 줄 단가 0 ↔ 빈 값 / 값 없는 줄 단가 빈 값 ↔ 채움 / 묶음 단가 = 계로 맞댐). +- 경우 = 문서 변수(선택 목록 · 기본값) — 기본 입력 + 고르기 입력의 다른 갈래 하나씩(나머지 기본). +- 셈 = 저장된 수식 문서(`master_doc_link.load_all`) · `master_doc_calc.calc` — 옛 엔진 몸 모듈 안 + 읽음(옛 엔진 대조는 855-E 2-E4 에서 은퇴). """ from __future__ import annotations @@ -14,48 +10,27 @@ from __future__ import annotations import hashlib import importlib import json -from collections import defaultdict -from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal +from decimal import Decimal from functools import lru_cache from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠 -mf = importlib.import_module("master_formula") -mcut = importlib.import_module("master_cut") mc = importlib.import_module("master_doc_calc") ml = importlib.import_module("master_doc_link") -meq = importlib.import_module("master_equation") -build = importlib.import_module("build_수식문서_802_2") KEYS = ("노무비", "재료비", "경비", "계") -SEEN = "보임" @lru_cache(maxsize=1) def world(): - """(로직 줄 목록, M01 색인, 수식 문서 {키: 문서}, 연결).""" - files, whole = m01.loaded() + """(M01 색인, 수식 문서 {키: 문서}, 연결).""" + whole = m01.loaded()[1] docs = ml.load_all() - rows = [r for d in files.values() if d.get("그룹") == "로직" for r in d.get("줄") or []] - return rows, whole, docs, ml.Links(whole, docs) - - -def cases(row: dict, options: bool) -> list[tuple[str, dict, dict | None]]: - """(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력).""" - whole = world()[1] - base = meq.given_of(whole, row) - out = [("", base, None)] - if options: - for spec in row.get("입력") or []: - for opt in spec.get("고르기") or []: - if str(opt) != str(base.get(spec["이름"])): - one = {spec["이름"]: opt} - out.append((f"{spec['이름']}={opt}", {**base, **one}, one)) - return out + return whole, docs, ml.Links(whole, docs) def doc_cases(doc: dict, options: bool) -> list[tuple[str, dict | None]]: - """(옵션 글, 새 문서에 넘길 바뀐 입력) — 수식 문서 변수(선택 목록 · 기본값)에서 · `cases` 와 같은 표본.""" + """(옵션 글, 새 문서에 넘길 바뀐 입력) — 수식 문서 변수(선택 목록 · 기본값)에서.""" out: list[tuple[str, dict | None]] = [("", None)] if options: for var in doc.get("변수") or []: @@ -67,17 +42,9 @@ def doc_cases(doc: dict, options: bool) -> list[tuple[str, dict | None]]: return out -def old_run(row: dict, given: dict): - whole = world()[1] - try: - return mcut.engine(whole, row["키"], mf.run(whole, row["키"], mf.fill_empty(row, given))) - except Exception: # 옛 엔진 멈춤도 대조 값 - return None - - def new_run(doc: dict, changed: dict | None): try: - got = mc.calc(doc, world()[3], changed) + got = mc.calc(doc, world()[2], changed) except Exception: return None return got if got.get("셈됨") else None @@ -90,19 +57,6 @@ def _d(v): return None -def _unit(v): - return _d(v.get("계")) if isinstance(v, dict) else _d(v) - - -def _per_name(lines) -> dict: - acc: dict = defaultdict(lambda: defaultdict(Decimal)) - for ln in lines or []: - for k, v in (ln.get("비목") or {}).items(): - if _d(v) is not None: - acc[str(ln.get("이름"))][k] += _d(v) - return {n: {k: v for k, v in b.items() if v} for n, b in acc.items()} - - def _shape(lines) -> list: return [ ( @@ -114,50 +68,6 @@ def _shape(lines) -> list: ] -def _cut_only(a, b) -> bool: - """옛 단가 = 새 날 값을 옛 자리로 자른 값(버림 · 반올림 · 올림 어느 하나).""" - ua, ub = _unit(a.get("단가")), _unit(b.get("단가")) - if ua is None and _d(a.get("금액")) is None and _d(b.get("금액")) is None: - return True # 값 없는 줄 — 금액 둘 다 빈 값 - if ub is None and ua == 0 and _d(a.get("수량")) == 0: - return True # 수량 0 줄 — 금액 0 - if ua is None or ub is None: - return False - return ua in (ub.quantize(ua, m) for m in (ROUND_DOWN, ROUND_HALF_UP, ROUND_UP)) - - -def level(old, new, money: bool) -> str | None: - """다름 층 — None = 같음(둘 다 못 셈 포함) · 「보임」 = 보이는 단가만 다름.""" - if old is None or new is None: - return None if old is None and new is None else "L0" - keys = KEYS if money else ("결과",) - if any(_d(old.get(k)) != _d(new.get(k)) for k in keys): - return "L0" - if not money: - return None - if _per_name(old["줄"]) != _per_name(new["줄"]): - return "L1" - if _shape(old["줄"]) != _shape(new["줄"]): - return "L2" - seen = False - for a, b in zip(old["줄"], new["줄"]): - if _d(a.get("수량")) != _d(b.get("수량")): - return "L3" - if _unit(a.get("단가")) != _unit(b.get("단가")): - if not _cut_only(a, b): - return "L3" - seen = True - return SEEN if seen else None - - -def adopted(key: str, label: str, lv: str) -> bool: - """채택된 차이(요구 714-3 · 빌더 `ADOPTED`) — 합계는 그 목록만 · 줄 비목은 같은 까닭 - (식 속 단가산출 부름 = 끝수 뒤 값)이 있는 문서만.""" - if lv == "L0": - return (key, label) in build.ADOPTED - return lv == "L1" and build._uses_raw_sub(world()[2][key]) - - def answer(got) -> object: """새 답의 지문 꼴 — 노 · 재 · 경 · 계(돈 아닌 = 결과) · 줄(이름 · 금액 · 비목).""" if got is None: @@ -171,84 +81,7 @@ def answer(got) -> object: def fingerprint(key: str, options: bool = True) -> str: - doc = world()[2][key] + doc = world()[1][key] got = [[label, answer(new_run(doc, changed))] for label, changed in doc_cases(doc, options)] raw = json.dumps(got, ensure_ascii=False, sort_keys=True) return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] - - -def _old_env(whole, row: dict, given: dict) -> dict: - """옛 B09 `Sangeun._env`(B9-4 에서 B09 는 걷음 · 대조 기준만) — 입력(빈 입력 = 자동값) + 중간값 · - 작업량 Q = ROUND 2 · `표시` 자리.""" - import re - - from B09_Estimation.B09_Estimation_Calc_Base import round_half - - ms = importlib.import_module("master_formula_sum") - auto = {k: v for k, v in m01.mau.values(whole, row).items() if v is not None} - env = mf._inputs(row, {**auto, **m01._dec(given or {})}) - for step in row.get("중간", []): - try: - value = mf.evaluate(mf.parse(step["식"]), env, whole, 0) - except mf.EmptyInput as e: - env[step["이름"]] = mf.Blank(str(e)) - continue - if step.get("표시") is not None or ms.uses(row): - value = ms.shown(step, value) - elif re.fullmatch(r"Q\d*", step["이름"]) and isinstance(value, Decimal): - value = Decimal(str(round_half(float(value), 2))) - env[step["이름"]] = value - return env - - -def _old_captured(whole, node, env: dict) -> list[str]: - """옛 B09 `Sangeun._captured` — 식을 돌리며 부른 기계 키(EQ).""" - seen: list[str] = [] - base = whole.get - - def get(ref): - row = base(ref) - key = str(row.get("키") or "") - if key.startswith("EQ") and key not in seen: - seen.append(key) - return row - - whole.get = get - try: - mf.evaluate(node, env, whole, 1) - except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): - pass - finally: - whole.get = base - return seen - - -def old_line_calls(whole, code: str, given) -> dict: - """옛 엔진 하위 부름(855-F B9-3 전 `B09 line_calls` · 대조 기준 · 2-E4 에서 은퇴) — 로직 호표 줄 - 차례 → 기계경비 {machine} · 돈 로직 {code, given} · 못 셈 = None.""" - from B09_Estimation import B09_Estimation_Sangeun as sg - - try: - row = whole.logic(code) - env = _old_env(whole, row, sg._clean_given(given)) - except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): - return {} - out: dict = {} - for n, item in enumerate(row.get("호표", [])): - if item.get("종류") != "로직": - continue - try: - node = mf.parse(item["요소"]) - called = node[1] if node and node[0] == "logic" else None - target = whole.logic(called) if called else None - if not target: - out[n] = None - elif mf.mb.is_machine(target): - keys = _old_captured(whole, node, env) - out[n] = {"machine": keys[0] if keys else None} - else: - given_ = {name: mf.evaluate(expr, env, whole, 1) for name, expr in node[2]} - out[n] = {"code": called, "given": sg._clean_given(given_)} - except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): - out[n] = None - return out diff --git a/resources/tester/test_855_block.py b/resources/tester/test_855_block.py index f1cfba342..4aa339f22 100644 --- a/resources/tester/test_855_block.py +++ b/resources/tester/test_855_block.py @@ -1,7 +1,6 @@ -"""855-A 지킴 ④ — 막힘 판정 옛(`master_formula.check_logic` · M01 로직 목록 · `/logic`) = 새(수식 문서 -표지 `master_doc.check`) 전수 · 막힘 기준 = 표지만(기본 입력으로 셈이 안 되는 것은 막힘 아님 · 판정 855-0). +"""855-A 지킴 ④ — 막힘 판정 = 수식 문서 표지(`master_doc_block`) · 화면 답 · 저장 검사 · 요소 닫힘. -걸음 2-B3(막힘 검사를 문서 기준으로) 앞뒤로 같아야 함 · 옛 검사를 지우는 걸음에서 옛 쪽만 뗌.""" +옛 `master_formula.check_logic` 대조(옛 = 새 전수 · 틀린 식 두 판정)는 855-E 2-E4 에서 은퇴.""" from __future__ import annotations @@ -9,29 +8,6 @@ import importlib import helper_855_engine as h -md = importlib.import_module("master_doc") - - -def test_막힘_옛_새_같음(): - rows, whole, docs, _ = h.world() - old = {str(r["키"]) for r in rows if h.mf.check_logic(whole, r)[0]} - new = {str(r["키"]) for r in rows if str(r["키"]) not in docs or md.check(docs[str(r["키"])])} - assert old == new, {"옛만 막힘": sorted(old - new)[:20], "새만 막힘": sorted(new - old)[:20]} - - -def test_틀린_식은_옛_새_모두_막힘(): - """자가 살아 있는지 — 같은 로직의 식을 틀리게 하면 두 판정 모두 막힘(사본만 · 자료 안 고침).""" - import copy - - rows, whole, docs, _ = h.world() - row = next(r for r in rows if r.get("호표") and str(r["키"]) in docs) - bad_row = copy.deepcopy(row) - bad_row["호표"][0]["수량"] = "없는변수 * 2" - bad_doc = copy.deepcopy(docs[str(row["키"])]) - bad_doc["금액"][0]["수량"] = "없는기호 × 2" - assert h.mf.check_logic(whole, bad_row)[0] - assert md.check(bad_doc) - def test_화면_답이_문서_막힘_길을_씀(monkeypatch): """2-B3 뒤 — M01 `/logic` 막힘 · 목록 막힘 · 일위대가 조합 막힘이 수식 문서 기준(`master_doc_block`). @@ -62,7 +38,7 @@ def test_화면_답이_문서_막힘_길을_씀(monkeypatch): def test_저장_검사_부름_닫힘_순환(): """저장 검사 로직 몫(`master_doc_block.check_docs`) — 부르는 단가산출이 빠지면 막힘 · 문서 사이 순환.""" mb = importlib.import_module("master_doc_block") - _, _, docs, _ = h.world() + _, docs, _ = h.world() caller = next(k for k, d in docs.items() if mb.calls(d)) called = sorted(mb.calls(docs[caller]))[0] assert not mb.check_docs(docs, {caller}) @@ -79,7 +55,7 @@ def test_요소_닫힘_쓰이는_요소가_없으면_막힘(): import copy mb = importlib.import_module("master_doc_block") - _, whole, docs, _ = h.world() + whole, docs, _ = h.world() key, doc = next( (k, d) for k, d in docs.items() diff --git a/resources/tester/test_855_e4a_base_only.py b/resources/tester/test_855_e4a_base_only.py index f09d15fbe..1a362d515 100644 --- a/resources/tester/test_855_e4a_base_only.py +++ b/resources/tester/test_855_e4a_base_only.py @@ -82,7 +82,7 @@ def test_바탕_기반만으로_새_계산기_지문_골든과_같음(): import helper_855_engine as h from helper_test_all import spread - docs = h.world()[2] + docs = h.world()[1] rows = spread(list(docs), N) want = { key: [[label, changed] for label, changed in h.doc_cases(docs[key], True)] for key in rows diff --git a/resources/tester/test_855_engine_parity.py b/resources/tester/test_855_engine_parity.py deleted file mode 100644 index 4801179bb..000000000 --- a/resources/tester/test_855_engine_parity.py +++ /dev/null @@ -1,43 +0,0 @@ -"""855-A 지킴 ① — 로직 전수 옛 엔진 대 새 계산기(저장된 수식 문서) · 걸음 2 동안 「다름 0」 자. - -- 기본 입력 전수(관문 · 십여 초) · 옵션 표본 전수 = 환경 `AISLO_TEST_ALL=1`(옛 `S855_ALL=1` · 3 분 남짓). -- 층 L0 합계 · L1 줄 비목 · L2 줄 꼴 · L3 수량 · 단가(`helper_855_engine.level`). -- 다름 = 채택된 차이와 같아야 함(합계 = 빌더 `ADOPTED` 그대로 · 줄 비목 = 같은 까닭의 문서만) · - 「보임」(보이는 단가만 · 금액 같음)은 허용 갈래로 셈. -- 옛 엔진을 지우는 걸음(2-E4)에서 은퇴 — 그 뒤는 `test_855_golden` 이 지킴. -""" - -from __future__ import annotations - -import helper_855_engine as h -from helper_test_all import ALL # noqa: E402 - - -def _diffs(options: bool) -> dict[str, list]: - rows, _, docs, _ = h.world() - out: dict[str, list] = {"문서 없음": [], "채택 밖": [], "채택": [], h.SEEN: []} - for row in rows: - key = str(row["키"]) - doc = docs.get(key) - if doc is None: - out["문서 없음"].append(key) - continue - money = not doc.get("결과") - for label, given, changed in h.cases(row, options): - lv = h.level(h.old_run(row, given), h.new_run(doc, changed), money) - if lv == h.SEEN: - out[h.SEEN].append((key, label)) - elif lv and h.adopted(key, label, lv): - out["채택"].append((key, label, lv)) - elif lv: - out["채택 밖"].append((key, label, lv)) - return out - - -def test_로직마다_수식_문서_있음_옛_대_새_다름은_채택뿐(): - got = _diffs(ALL) - assert got["문서 없음"] == [] - assert got["채택 밖"] == [], got["채택 밖"][:20] - total = {(k, o) for k, o, lv in got["채택"] if lv == "L0"} - want = {x for x in h.build.ADOPTED if not x[1]} if not ALL else set(h.build.ADOPTED) - assert total == want # 채택 목록이 다 나오고 그 밖은 없음(기본만 돌면 옵션 채택은 안 나옴) diff --git a/resources/tester/test_855_golden.py b/resources/tester/test_855_golden.py index d16c0c21c..567f51acc 100644 --- a/resources/tester/test_855_golden.py +++ b/resources/tester/test_855_golden.py @@ -22,7 +22,7 @@ def current(n: int | None = None) -> dict[str, str]: import helper_855_engine as h from helper_test_all import spread - keys = list(h.world()[2]) # 수식 문서 차례(= 옛 로직 줄 차례) + keys = list(h.world()[1]) # 수식 문서 차례 keys = spread(keys, n) if n else keys return {key: h.fingerprint(key) for key in keys} diff --git a/resources/tester/test_855_trace.py b/resources/tester/test_855_trace.py index 52710c2b1..e35e29940 100644 --- a/resources/tester/test_855_trace.py +++ b/resources/tester/test_855_trace.py @@ -1,19 +1,13 @@ """855-F B9-1 지킴 — 문서 셈 기록(`master_doc_trace`) · 로직 전수 기본 입력. - 기록을 켜도 셈 답 같음(줄 `부름` · 답 `부름` `자원` 칸만 더해짐). -- 자원 키 = 옛 엔진 셈 중 `whole.get` 가로채기 키(B09 `hand_resource_keys` 방식 · - 찾기 색인 데운 뒤) — 다름 = `MORE` 뿐(새 계산기는 이름마다 셈 — 옛은 안 고른 「만약」 갈래 · - 빈 수량 줄 · 앞서 멈춘 줄을 안 읽음 · 새 쪽에만 더 있음). -- 하위 부름 = 옛 `B09 line_calls`(`helper_855_engine.old_line_calls` · 돈 문서 {code, given} · 기계경비 {machine}) — 다름 = 옛이 입력 - 기본값을 못 세 빈 답인 문서뿐 · 새 쪽 결과 문서 부름(작업량 등 중간 값)은 하위 산근 아님. - 고른 품목 = `master_pick.priced` 의 품목 키 · 줄 `부름` = 그 줄 자원. -- 옛 엔진을 지우는 걸음(2-E4)에서 옛 대조(자원 · 하위)는 은퇴. +- 옛 엔진 대조(자원 키 가로채기 · 하위 부름 `line_calls`)는 855-E 2-E4 에서 은퇴. """ from __future__ import annotations import importlib -import json from functools import lru_cache import helper_855_engine as h @@ -22,48 +16,11 @@ mt = importlib.import_module("master_doc_trace") mp = importlib.import_module("master_pick") mm = importlib.import_module("master_material") -MORE = { # 새 쪽에만 더 있는 자원 키 — 까닭 - "GC001200": "옛 엔진이 빈 입력에서 멈춤 · 새는 전력 재료 이름도 셈", - "GC001201": "옛 엔진이 빈 입력에서 멈춤 · 새는 전력 재료 이름도 셈", - "GF000312": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈", - "GF000313": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈", - "GF000320": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈", - "GF000192": "옛은 수량 빈 줄의 재료 단가를 안 읽음", - "GF000200": "옛은 수량 빈 줄의 재료 단가를 안 읽음", - "GF000203": "옛은 수량 빈 줄의 재료 단가를 안 읽음", - "GF000209": "옛은 수량 빈 줄의 재료 단가를 안 읽음", -} - - -def sg(): - from B09_Estimation import B09_Estimation_Sangeun as mod - - return mod - def mc_calc(doc: dict, links) -> dict: return importlib.import_module("master_doc_calc").calc(doc, links) -def _old_keys(whole, row: dict, given: dict) -> set[str]: - seen: set[str] = set() - base = whole.get - - def get(ref): - got = base(ref) - key = str(got.get("키") or "") - if key[:2] in mt.CAT: - seen.add(key) - return got - - whole.get = get - try: - h.old_run(row, given) - finally: - del whole.get - return seen - - def _strip(got: dict) -> dict: out = {k: v for k, v in got.items() if k not in ("부름", "자원")} if "줄" in out: @@ -71,50 +28,16 @@ def _strip(got: dict) -> dict: return out -def _calls(old: dict, new: dict, docs: dict) -> tuple[set, set]: - a = {json.dumps(v, ensure_ascii=False, sort_keys=True, default=str) for v in old.values()} - b = set() - for c in new["부름"]: - if c["깊이"] != 1 or c["갈래"] != "단가산출": - continue - if (docs.get(str(c["부름"].get("키"))) or {}).get("결과"): - continue # 결과 문서 = 중간 값 - one = ( - {"machine": c["기계"]} - if "기계" in c - else {"code": c["부름"]["키"], "given": sg()._clean_given(c["부름"].get("입력"))} - ) - b.add(json.dumps(one, ensure_ascii=False, sort_keys=True, default=str)) - return a, b - - @lru_cache(maxsize=1) def survey() -> dict: - rows, whole, docs, links = h.world() - rows = [r for r in rows if str(r["키"]) in docs] - for row in rows: # 재료 찾기 색인 데움(첫 찾기 때 훑은 후보 읽음 빼려고) - h.old_run(row, h.cases(row, False)[0][1]) + whole, docs, links = h.world() trace = mt.Trace(whole, docs) - out = {"답 다름": [], "자원": {}, "하위": {}, "품목": [], "줄": [], "옛 빈 답": set()} - for row in rows: - key = str(row["키"]) - doc, given = docs[key], h.cases(row, False)[0][1] - old = _old_keys(whole, row, given) + out = {"답 다름": [], "품목": [], "줄": [], "셈": 0} + for key, doc in docs.items(): got = mt.calc(doc, trace) + out["셈"] += 1 if _strip(got) != mc_calc(doc, links): out["답 다름"].append(key) - new = set(got["자원"]) - if old != new: - out["자원"][key] = (sorted(old - new), sorted(new - old)) - lines = h.old_line_calls(whole, key, given) # 옛 엔진 기준(B9-3 뒤 B09 는 문서 셈) - a, b = _calls(lines, got, docs) - if a != b: - out["하위"][key] = (sorted(a), sorted(b)) - if not lines: - try: - h._old_env(whole, row, sg()._clean_given(given)) - except Exception: - out["옛 빈 답"].add(key) for c in got["부름"]: p = c["부름"] if c["깊이"] == 1 and "품목" in c and p.get("재료") is not None: @@ -132,23 +55,10 @@ def survey() -> dict: def test_기록_켜도_셈_답_같음(): + assert survey()["셈"] > 1000 # 문서를 못 읽어 빈 통과하지 않게 assert survey()["답 다름"] == [] -def test_자원_키_옛_가로채기와_같음_다름은_까닭_목록뿐(): - got = survey()["자원"] - assert all(not old for old, _ in got.values()), {k: v for k, v in got.items() if v[0]} - assert sorted(got) == sorted(MORE), sorted(got) - - -def test_하위_부름_옛_call_of_와_같음_다름은_옛_빈_답뿐(): - s = survey() - assert set(s["하위"]) == s["옛 빈 답"], { - k: s["하위"][k] for k in set(s["하위"]) - s["옛 빈 답"] - } - assert all(not old for old, _ in s["하위"].values()) - - def test_고른_품목_줄_부름(): s = survey() assert s["품목"] == [] @@ -156,7 +66,7 @@ def test_고른_품목_줄_부름(): def test_기계경비_부름_기계_키_줄마다_부름(): - _, whole, docs, _ = h.world() + whole, docs, _ = h.world() got = mt.calc( docs["GC000337"], mt.Trace(whole, docs) ) # 낙석방지망 — 인력 둘 · 크레인 · 재료 셋