Files
Aislo/M02_MasterTemplete/M02_Doc_Import_Carry.py
T
eomsangdonandClaude Opus 5.5 13e68f9e81 feat(851-2): 불러오기 가져온 값 층 넓힘 — 덤프 구간 셋 · 표 밖 속도 · t2 수 · t3 ~ t5 직접 · 불도저 · 로더 · 롤러 · 믹서
- 덤프 8-2-8 t2 = 구간 셋까지(`(Σ l ÷ V) × 60` · × 2 = 같은 속도 왕복 · ÷ 1000 = m) · 표 속도 쌍 = 도로상태 · 아니면 속도 직접 · 거리 0 구간 = 칸 안 채움
- t2 를 수로 적음 · 꼴 다름 = 왕복시간 직접 · t3 · t4 · t5 표 밖 = 직접 칸
- 끝수 딴길 — 경쟁사 t1 · t2 를 반올림 · 버림한 줄은 첫 길 Q 가 어긋나면 그 값 통째(t2입력 · 적재방법 「직접 입력」)로 다시 셈
- 새 짝 — 불도저 8-2-1(q° · e · L · V1 · V2 · t 표) · 로더 8-2-5(q · K · f · E · m · l · t1 · t2 표) · 롤러 8-2-9 토량 · 면적 · 콘크리트 믹서 8-2-17(t 표)
- 그대로 = 「Q 가 경쟁사 Q 끝자리 안일 때만」 · 방식 없는 위 층(켜기 전 금액 불변)
- 전후(네 원천 3,241 블록) = 실은 줄 759 → 964(덤프 93 → 235 · 불도저 5 · 로더 20 · 롤러 22 · 믹서 16) · 켜면 Q = 경쟁사 Q 964/964 · 금액 재현 다름 0
- 시험 test_851_2 새로(구간 둘 · 셋 · 속도 직접 · t2 수 · 새 짝 넷 · 켜기 전 그대로 · 켜면 Q 같음 · 끝수 못 실음 까닭)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 09:14:38 +09:00

502 lines
23 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""M02 가져온 식 「가져온 값」 층(PLAN 848-7 · 요구서_889 8 절) — 서버 단독.
경쟁사 블록의 시간당 작업량 변수 값(q · K · f · E · Cm · 덤프 T · rt · L · t1 ~ t4 …)을 그 기계 줄의
위 층 고침(`수식.위덮음`)으로 — {단가 기호: {작업량: {식: 우리 작업량 식 키, 변수: {우리 열쇠: 경쟁사 값}}}}.
방식은 싣지 않음(방식 없음 = 위 층 방식 → 처음은 경쟁사 식 그대로 「문서 식」 · 사용자가 「시간당 식」 을
고르는 순간 경쟁사 값에서 시작 · [원래 값] = 경쟁사 값).
짝 = 경쟁사 Q 식 모양 → 우리 식 변수(굴착기 8-2-3 `3600·q·K·f·E/Cm` · 덤프 8-2-8 구간 셋까지 · 851-2 = 불도저 8-2-1 ·
로더 8-2-5 · 롤러 8-2-9 · 콘크리트 믹서 8-2-17 · 표 밖 값 = 851-1 「직접」 칸) ·
실은 값으로 우리 식을 셈한 Q 가 경쟁사 Q 와 같은(끝자리 안) 줄만 실음 — 다르면 안 실음(`why` = 줄마다 까닭).
경쟁사 자료(단가 · 품목)를 우리 마스터로 옮기지 않음(그 공사의 조건 값을 그 단가산출에만).
"""
from __future__ import annotations
import copy as cp
import hashlib
import json
import re
from decimal import Decimal
from typing import Any
from M02_MasterTemplete import M02_Doc_Copy as dc
md, mc, mw, mcv = dc.md, dc.mc, dc.mc.mw, dc.mc.mcv
EXC, DUMP = "GC001147", "GC001155" # 굴착기 8-2-3 · 덤프트럭 8-2-8 작업량 식
_SECT = (
("운반거리", "도로상태", "V1입력", "V2입력"),
("구간2거리", "구간2도로상태", "V3입력", "V4입력"),
("구간3거리", "구간3도로상태", "V5입력", "V6입력"),
) # 덤프 운반 구간 칸(851-1)
_ALT = "_딴길" # 후보 속 둘째 길 — 첫 길로 Q 가 어긋날 때 덮어 볼 칸
_EXC = {"q": "버킷용량", "qs": "버킷용량", "qo": "버킷용량", "k": "K입력", "f": "f", "e": "E입력",
"es": "E입력", "cm": "싸이클입력", "cms": "싸이클입력"} # fmt: skip
_RANGE = {
"E입력": (0, 1),
"싸이클입력": (0, 30),
"K입력": (0, 2),
} # 우리 입력 칸 범위(0 = 표 → 0 초과만)
_MEMO: dict[str, tuple] = {}
class _No(Exception):
"""못 실음 — 까닭 글."""
def _role(name: str) -> str:
return re.sub(r"[_\d]+$", "", str(name)).lower()
def _inner(node):
"""반올림 · 버림 · 올림(식, 자리) → (식, 자리) · 아님 = (그대로, None)."""
if node[0] == "call" and node[1] in ("반올림", "버림", "올림") and node[2]:
places = node[2][1] if len(node[2]) > 1 else None
return node[2][0], (places[1] if places and places[0] == "num" else None)
return node, None
class _Doc:
"""문서 식 줄 · 셈 값 — 기호 → 정의 나무 · 값."""
def __init__(self, doc: dict, values: dict) -> None:
self.defs = {str(x.get("기호")): x.get("식") for x in doc.get("식") or []}
self.values = values
def tree(self, name: str):
text = self.defs.get(name)
if text is None:
return None
try:
return _inner(md.parse(text))[0]
except md.DocError:
return None
def value(self, node) -> Decimal:
if node[0] == "num":
return node[1]
got = self.values.get(node[1]) if node[0] == "var" else None
if not isinstance(got, Decimal):
raise _No(f"값 못 읽음({md.text_of(node)})")
return got
def _excavator(d: _Doc, fs: list) -> dict:
"""3600·q·K·f·E/Cm → {버킷용량 · K입력 · f · E입력 · 싸이클입력}."""
nums = [(s, n) for s, n in fs if n[0] == "num"]
if nums != [(1, ("num", Decimal(3600)))]:
raise _No("3600 꼴 아님")
out: dict[str, Any] = {}
for s, n in fs:
if n[0] == "num":
continue
role = _EXC.get(_role(n[1])) if n[0] == "var" else None
if role is None or role in out or (role == "싸이클입력") != (s < 0):
raise _No(f"변수 이름 낯섦({md.text_of(n)})")
out[role] = d.value(n)
if len(out) != 5:
raise _No("변수 모자람")
return out
def _cut(d: _Doc, node) -> bool:
"""변수 정의가 끝수(반올림 · 버림 · 올림 + 자리)로 싸였나."""
text = d.defs.get(node[1]) if node[0] == "var" else None
try:
return text is not None and _inner(md.parse(text))[1] is not None
except md.DocError:
return False
def _sum_terms(node) -> list:
if node[0] == "bin" and node[1] == "+":
return [*_sum_terms(node[2]), *_sum_terms(node[3])]
return [node]
def _legs(d: _Doc, tree) -> list[tuple]:
"""t2 → 구간 [(거리 ㎞, 적재 속도, 공차 속도)] — (Σ l ÷ V) × 60 · × 2 = 같은 속도 왕복 · ÷ 1000 = m · 구간 셋까지."""
k, rest = Decimal(1), []
for s, n in mw._factors(tree) if tree is not None else []:
if n[0] == "num":
k = k * n[1] if s > 0 else k / n[1]
else:
rest.append((s, n))
metre = k in (Decimal("0.06"), Decimal("0.12"))
k = k * 1000 if metre else k
if len(rest) != 1 or rest[0][0] < 0 or k not in (60, 120):
raise _No("t2 = (Σ l ÷ V) × 60 꼴 아님")
terms = [mw._factors(x) for x in _sum_terms(rest[0][1])]
if any([s for s, _ in x] != [1, -1] for x in terms):
raise _No("t2 항 l ÷ V 꼴 아님")
if k == 120:
legs = [(x[0][1], x[1][1], x[1][1]) for x in terms]
elif len(terms) % 2 or any(a[0][1] != b[0][1] for a, b in zip(terms[::2], terms[1::2])):
raise _No("t2 구간 거리 짝 안 맞음")
else:
legs = [(a[0][1], a[1][1], b[1][1]) for a, b in zip(terms[::2], terms[1::2])]
if not 1 <= len(legs) <= len(_SECT):
raise _No(f"t2 구간 {len(legs)} — 우리 칸 {len(_SECT)}")
return [(d.value(x) / (1000 if metre else 1), d.value(a), d.value(b)) for x, a, b in legs]
def _dump(d: _Doc, fs: list, tpl: dict) -> dict:
"""60·q·f·E/Cm(덤프 8-2-8) — q = T ÷ rt × L(L 없음 = 1) · Cm = t1 + t2 + t3 + t4(+ t5 덮개 + t6 세륜) ·
t1 = cms·n ÷ (60·Es) · n = q ÷ (버킷 × k) · t2 = 구간 셋까지(`_legs` · 표 밖 속도 = 속도 직접) · 못 읽는 t2 =
왕복시간 직접 · t3 · t4 · t5 표 밖 = 직접 칸(851-1) → 우리 입력 · 고르기."""
if [(s, n) for s, n in fs if n[0] == "num"] != [(1, ("num", Decimal(60)))]:
raise _No("60 꼴 아님")
up = [n for s, n in fs if s > 0 and n[0] == "var"]
down = [n for s, n in fs if s < 0]
if len(up) != 3 or len(down) != 1 or down[0][0] != "var":
raise _No("덤프 Q 꼴 아님")
roles = {_role(n[1]): n for n in up}
f, e = roles.get("f"), roles.get("e") or roles.get("es")
load = [n for n in up if n is not f and n is not e]
if f is None or e is None or len(load) != 1:
raise _No("덤프 q · f · E 못 가림")
out: dict[str, Any] = {"f": d.value(f), "E입력": d.value(e)}
q = d.tree(load[0][1])
qf = mw._factors(q) if q is not None else []
if [s for s, _ in qf] not in ([1, -1, 1], [1, -1]):
raise _No("적재량 q = T ÷ rt × L 꼴 아님")
out |= {"적재용량": d.value(qf[0][1]), "단위중량": d.value(qf[1][1]),
"체적변화율": d.value(qf[2][1]) if len(qf) == 3 else Decimal(1)} # fmt: skip
cm = d.tree(down[0][1])
ts: dict[str, Any] = {}
for t in _sum_terms(cm) if cm is not None else []:
m = re.match(r"^[tT](\d)(?:_\d+)?$", t[1]) if t[0] == "var" else None
if not m or m.group(1) in ts:
raise _No(f"Cm 항 낯섦({md.text_of(t)})")
ts[m.group(1)] = t
if set(ts) - {"5", "6"} != {"1", "2", "3", "4"}:
raise _No("Cm = t1 + t2 + t3 + t4 꼴 아님")
if "5" in ts and (t5 := d.value(ts["5"])) != 0:
try:
out["덮개"] = _option(tpl, "덮개", lambda r: Decimal(str(r.get("시간"))) == t5, "t5")
except _No:
out["t5입력"] = t5
if "6" in ts and (t6 := d.value(ts["6"])) != 0:
if not _row(tpl, "CC000058", {}, t6): # 세륜기 통과시간(t6)
raise _No(f"t6 {t6} 표에 없음")
out["세륜"] = "함"
t1 = d.tree(ts["1"][1])
f1 = mw._factors(t1) if t1 is not None else []
if (-1, ("num", Decimal(60))) not in f1 or len(f1) != 4:
raise _No("t1 = cms × n ÷ (60 × Es) 꼴 아님")
rest = [x for x in f1 if x != (-1, ("num", Decimal(60)))]
n_var = next((n for s, n in rest if s > 0 and n[0] == "var" and _role(n[1]) == "n"), None)
cms = next((n for s, n in rest if s > 0 and n is not n_var), None)
es = next((n for s, n in rest if s < 0), None)
nt = d.tree(n_var[1]) if n_var else None
nf = mw._factors(nt) if nt is not None else []
if None in (n_var, cms, es) or [s for s, _ in nf] != [1, -1, -1] or nf[0][1] != load[0]:
raise _No("n = q ÷ (버킷 × k) 꼴 아님")
bk = sorted(nf[1:], key=lambda x: x[1][0] == "var" and _role(x[1][1]) == "k") # 버킷 › k
out |= {"적재싸이클": d.value(cms), "적재효율": d.value(es), "적재버킷": d.value(bk[0][1]), "버킷계수": d.value(bk[1][1])} # fmt: skip
try: # t2 = 구간(거리 · 적재 · 공차 속도) — 표 속도 쌍이면 도로상태 · 아니면 속도 직접(851-1)
for (dist, v1, v2), (kd, kr, k1, k2) in zip(_legs(d, d.tree(ts["2"][1])), _SECT):
if dist == 0 and kd != _SECT[0][0]:
continue # 거리 0 구간 = 안 씀(칸 안 채움)
out[kd] = dist
try:
out[kr] = _option(tpl, "도로상태", lambda r: sorted(Decimal(str(r[k])) for k in ("적재", "공차")) == sorted((v1, v2))) # fmt: skip
except _No:
out[k1], out[k2] = v1, v2
# t2 끝수(반올림 · 버림) = 딴길 t2 통째
alt = {"t2입력": d.value(ts["2"])} if _cut(d, ts["2"]) else {}
except _No:
out["t2입력"] = d.value(ts["2"]) # t2 를 수로 적음 · 꼴 다름 = 왕복시간 직접
alt = {}
t3, t4 = d.value(ts["3"]), d.value(ts["4"])
soil = next(((s, c) for s in _options(tpl, "적하토질") for c in _options(tpl, "적하조건") if _row(tpl, "CC000055", {"S_적하토질": s, "S_적하조건": c}, t3)), None) # fmt: skip
if soil is not None:
out["적하토질"], out["적하조건"] = soil
else:
out["t3입력"] = t3 # 표 밖 = 적하시간 직접
try:
out["적재장소"] = _option(
tpl, "적재장소", lambda r: Decimal(str(r.get("시간"))) == t4, "t4"
)
except _No:
out["t4입력"] = t4
if _cut(d, ts["1"]): # t1 끝수 = 딴길 적재시간 직접(적재방법 「직접 입력」)
alt |= {"적재방법": "직접 입력", "적재시간입력": d.value(ts["1"])}
if alt: # 딴길 = 끝수 낸 t1 · t2 를 경쟁사 값 통째로(t2 통째면 구간 · 속도 칸 뺌)
drop = "t2입력" in alt
out[_ALT] = {
k: v for k, v in out.items() if not (drop and any(k in x for x in _SECT))
} | alt
return out
def _options(tpl: dict, key: str) -> list:
v = next((x for x in tpl.get("변수") or [] if x.get("열쇠") == key), {})
return list((v.get("연결") or {}).get("목록") or [])
def _table(tpl: dict, ref: str) -> tuple[dict, dict]:
"""표 번호(CC…) → (표 연결, 그 표) — 그 표를 찾는 첫 변수(직접 칸 막이로 변수 열쇠가 바뀌어도)."""
v = next((x for x in tpl.get("변수") or [] if (x.get("연결") or {}).get("표") == ref), {})
link = v.get("연결") or {}
return link, dc.skc.whole_().get(str(link.get("표")))
def _row(tpl: dict, key: str, picked: dict, want: Decimal) -> bool:
link, table = _table(tpl, key)
want_row = {c: str(ref)[1:-1] if str(ref).startswith("'") else picked.get(ref) for c, ref in (link.get("조건") or {}).items()} # fmt: skip
return any(
all(str(r.get(c)) == str(v) for c, v in want_row.items())
and Decimal(str(r.get(link.get("칸")))) == want
for r in table.get("줄") or []
)
def _option(tpl: dict, key: str, test, label: str = "") -> str:
"""고르기 칸 — 목록 가운데 표 줄이 맞는 첫 값(표 = 그 고르기를 조건으로 쓰는 표)."""
sym = f"S_{key}"
for v in tpl.get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") == "표" and sym in (link.get("조건") or {}).values():
table = dc.skc.whole_().get(str(link.get("표")))
col = next(c for c, ref in link["조건"].items() if ref == sym)
for opt in _options(tpl, key):
if any(str(r.get(col)) == str(opt) and test(r) for r in table.get("줄") or []):
return opt
break
raise _No(f"{label or key} 표에 없음")
def _top(fs: list, head: int, ups: int) -> tuple[list, list]:
"""Q 인수 → (위 변수, 아래 변수) — 수는 머리 수(60 · 1000 · 3600) 하나 · 아래 변수 하나."""
if [(s, n) for s, n in fs if n[0] == "num"] != [(1, ("num", Decimal(head)))]:
raise _No(f"{head} 꼴 아님")
up = [n for s, n in fs if s > 0 and n[0] == "var"]
down = [n for s, n in fs if s < 0]
if len(up) != ups or len(down) != 1 or down[0][0] != "var":
raise _No("Q 꼴 아님")
return up, down
def _by_role(d: _Doc, nodes: list, roles: dict) -> dict:
"""변수 마디 → {우리 열쇠: 값} — 이름 머리(밑줄 · 수 뗌 · 작은 글자)로 · 겹치거나 모르면 못 실음."""
out: dict[str, Any] = {}
for n in nodes:
k = roles.get(_role(n[1]))
if k is None or k in out:
raise _No(f"변수 이름 낯섦({md.text_of(n)})")
out[k] = d.value(n)
return out
def _const(ref: str, head: str) -> Decimal:
"""산정식 상수 표(ref) 「항목」 이 head 로 시작하는 줄 값."""
rows = (dc.skc.whole_().get(ref) or {}).get("줄") or []
return next(Decimal(str(r["값"])) for r in rows if str(r.get("항목") or "").startswith(head))
def _dozer(d: _Doc, fs: list, tpl: dict) -> dict:
"""불도저 8-2-1 — 60·q·f·E/Cm · q = q° × e(수 하나 · 끝수 = q° 직접 · e 1) · Cm = L ÷ V1 + L ÷ V2 + t(표)."""
up, down = _top(fs, 60, 3)
load = next((n for n in up if _role(n[1]) not in ("f", "e", "es")), None)
out = _by_role(d, [n for n in up if n is not load], {"f": "f", "e": "E입력", "es": "E입력"})
if len(out) != 2 or load is None:
raise _No("q · f · E 못 가림")
text = d.defs.get(load[1])
tree, places = _inner(md.parse(text)) if text else (None, None)
qf = mw._factors(tree) if tree is not None else []
if places is None and [s for s, _ in qf] == [1, 1]:
out["q0입력"], out["e입력"] = d.value(qf[0][1]), d.value(qf[1][1])
else:
out["q0입력"], out["e입력"] = d.value(load), Decimal(1)
cm = d.tree(down[0][1])
legs, rest = [], []
for x in _sum_terms(cm) if cm is not None else []:
f2 = mw._factors(x)
if [s for s, _ in f2] == [1, -1]:
legs.append(f2)
else:
rest.append(x)
if len(legs) != 2 or len(rest) != 1 or legs[0][0][1] != legs[1][0][1]:
raise _No("Cm = L ÷ V1 + L ÷ V2 + t 꼴 아님")
if (t := d.value(rest[0])) != _const("CC000039", "기어 변속시간"):
raise _No(f"기어 변속시간 t {t} 표 밖")
out |= {"운반거리": d.value(legs[0][0][1]), "V1입력": d.value(legs[0][1][1]), "V2입력": d.value(legs[1][1][1])} # fmt: skip
return out
def _loader(d: _Doc, fs: list, tpl: dict) -> dict:
"""로더 8-2-5 — 3600·q·K·f·E/Cm · Cm = m × l + t1 + t2(표 14 초) → 버킷용량 · K · f · E · m · 주행거리 · t1 직접."""
up, down = _top(fs, 3600, 4)
roles = {"q": "버킷용량", "qs": "버킷용량", "qo": "버킷용량", "k": "K입력", "f": "f", "e": "E입력", "es": "E입력"} # fmt: skip
out = _by_role(d, up, roles)
cm = d.tree(down[0][1])
terms = _sum_terms(cm) if cm is not None else []
prod = [x for x in terms if [s for s, _ in mw._factors(x)] == [1, 1]]
rest = [x for x in terms if not any(x is y for y in prod)]
if len(out) != 4 or len(prod) != 1 or len(rest) != 2:
raise _No("Cm = m × l + t1 + t2 꼴 아님")
(_, m), (_, ln) = mw._factors(prod[0])
t1, t2 = sorted(rest, key=lambda x: x[0] == "var" and x[1].lower().startswith("t2"))
if (v := d.value(t2)) != _const("CC000052", "기본시간"):
raise _No(f"기본시간 t2 {v} 표 밖")
return out | {"m입력": d.value(m), "주행거리": d.value(ln), "t1입력": d.value(t1)}
def _roller(volume: bool):
"""롤러 8-2-9 — 1000·V·W(·D·f)·E/N → 다짐속도 · 유효폭 직접 · E · (두께 · f) · 다짐횟수."""
def parse(d: _Doc, fs: list, tpl: dict) -> dict:
if not volume: # 면적 식에 f = 1 을 곱해 둔 꼴(값 같음) — f 뗌
fs = [
(s, n)
for s, n in fs
if not (n[0] == "var" and _role(n[1]) == "f" and d.value(n) == 1)
]
up, down = _top(fs, 1000, 5 if volume else 3)
roles = {
"v": "V입력",
"w": "W입력",
"e": "E입력",
**({"d": "두께", "f": "f"} if volume else {}),
}
out = _by_role(d, up, roles)
if _role(down[0][1]) != "n":
raise _No("다짐횟수 N 아님")
return out | {"다짐횟수": d.value(down[0])}
return parse
def _mixer(d: _Doc, fs: list, tpl: dict) -> dict:
"""콘크리트 믹서 8-2-17 — 60 ÷ t × q × E(t = 표 작업시간) → 믹서용량 · E."""
if [(s, n) for s, n in fs if n[0] == "num" and s > 0] != [(1, ("num", Decimal(60)))]:
raise _No("60 꼴 아님")
up = [n for s, n in fs if s > 0 and n[0] == "var"]
down = [n for s, n in fs if s < 0]
if len(up) != 2 or len(down) != 1:
raise _No("Q 꼴 아님")
if (t := d.value(down[0])) != _const("CC000388", "재료투입"):
raise _No(f"작업시간 t {t} 표 밖")
return _by_role(d, up, {"q": "믹서용량", "e": "E입력"})
MAP = {
EXC: lambda d, fs, tpl: _excavator(d, fs),
DUMP: _dump,
"GC001144": _dozer,
"GC001150": _loader,
"GC001157": _roller(True),
"GC001158": _roller(False),
"GC001170": _mixer,
} # 경쟁사 Q 식 모양 → 우리 작업량 식 변수(851-2 = 불도저 · 로더 · 롤러 · 믹서 · 덤프 구간 여럿)
def _plain(v: Any) -> Any:
return float(v) if isinstance(v, Decimal) else v
def _candidates(doc: dict, ans: dict, links: Any) -> tuple[dict, dict, dict, dict]:
"""줄마다 (단가 기호 → 덮음 후보) · (기호 → 경쟁사 Q · 끝자리) · 까닭 · 딴길 변수."""
d = _Doc(doc, ans.get("값") or {})
cand, comp, why, alts = {}, {}, {}, {}
for z in ans.get("줄") or []:
w = z.get(mw.WORK) or {}
sym = str(w.get("기호") or "")
if not sym or w.get(mw.FOLLOW) or sym in cand:
continue
if w.get("꼴") != "식":
why[sym] = f"작업량 꼴 {w.get('꼴') or '없음'}"
continue
node = d.defs.get(str(w.get("율")))
try:
whole = md.parse(node) if node is not None else None
except md.DocError:
whole = None
if whole is None:
why[sym] = "Q 값 직접"
continue
inner, places = _inner(whole)
forms = [k for k in w.get("식들") or [] if k in MAP]
if not forms:
why[sym] = "짝 있는 우리 식 없음" if w.get("식들") else "우리 작업량 식 없음"
continue
for key in forms:
try:
got = MAP[key](d, mw._factors(inner), links.doc(key) or {})
except _No as e:
why[sym] = f"{key} {e}"
continue
for k, (low, high) in _RANGE.items():
if k in got and not (low < got[k] <= high):
why[sym] = f"{key} {k} {got[k]} 범위 밖"
break
else:
if _ALT in got:
alts[sym] = {k: _plain(v) for k, v in got.pop(_ALT).items()}
cand[sym] = {mw.WORK: {"식": key, "변수": {k: _plain(v) for k, v in got.items()}}}
tol = Decimal(1).scaleb(-int(places)) if places is not None else Decimal("0.001")
comp[sym] = (w.get("값"), tol)
why.pop(sym, None)
break
return cand, comp, why, alts
def _check(mine: dict, links: Any, cand: dict, comp: dict, why: dict) -> tuple[dict, list]:
"""후보를 시간당 식으로 켜 셈 — (Q 가 경쟁사 Q 끝자리 안인 줄, 어긋난 줄) · 까닭 고침."""
on = {k: {mw.WORK: {"방식": mw.HOURLY}} for k in cand}
test = mc.calc(mine, links, cover=mcv.merge_layers(cand, on)) if cand else {}
got, miss = {}, []
for z in test.get("줄") or []:
w = z.get(mw.WORK) or {}
sym = str(w.get("기호") or "")
if sym not in cand or w.get(mw.FOLLOW):
continue
q, (want, tol) = w.get("값"), comp[sym]
if isinstance(q, Decimal) and isinstance(want, Decimal) and abs(q - want) <= tol:
got[sym] = cand[sym]
why.pop(sym, None)
else:
miss.append(sym)
why[sym] = f"우리 식 Q {q} ≠ 경쟁사 Q {want}" + (f" — {w.get('까닭')}" if w.get("까닭") else "") # fmt: skip
return got, miss
def carried(doc: dict, whole: Any = None) -> tuple[dict, dict]:
"""문서(기계덮음 뗀) → (가져온 값 층, 못 실은 줄 까닭 {단가 기호: 글}) — 같은 문서 = 기억."""
from M02_MasterTemplete import M02_Doc_Import as dim
bare = {k: v for k, v in doc.items() if k != mcv.COVER}
key = hashlib.sha1(json.dumps(bare, ensure_ascii=False, sort_keys=True, default=str).encode()).hexdigest() # fmt: skip
if key in _MEMO:
return cp.deepcopy(_MEMO[key])
links = dim.Links(whole or dim.imp._whole(), "엑셀")
mine = dim.view(bare, "엑셀")
try:
ans = mc.calc(mine, links)
cand, comp, why, alts = _candidates(mine, ans, links)
got, miss = _check(mine, links, cand, comp, why)
retry = {k: {mw.WORK: {**cand[k][mw.WORK], "변수": alts[k]}} for k in miss if k in alts}
if retry: # 딴길(덤프 t2 통째) — 경쟁사 t2 끝수로 첫 길 Q 가 어긋난 줄
got |= _check(mine, links, retry, comp, why)[0]
except Exception as e: # noqa: BLE001 — 못 셈 = 층 없음(가져온 식 셈은 그대로)
return {}, {"*": f"셈 틀림 — {e}"}
if len(_MEMO) > 512:
_MEMO.clear()
_MEMO[key] = (got, why)
return cp.deepcopy(got), dict(why)
def carry(sk: dict, copy: Any) -> Any:
"""가져온 식 SK 사본 → ① 위 층 덮음 = 그 문서의 가져온 값(셈마다 · 문서 변수를 고치면 따라감)."""
from M02_MasterTemplete import M02_Doc_Import as dim
if (
not dim.is_imported(sk)
or not isinstance(copy, dict)
or not isinstance(copy.get("문서"), dict)
):
return copy
got = carried(copy["문서"])[0]
rest = {k: v for k, v in copy.items() if k != mcv.UPPER}
return {**rest, mcv.UPPER: got} if got else rest