Merge branch 'sub_laptop_8' of C:/Aislo_wt/sub_laptop_8 into main_laptop_1
# Conflicts: # resources/tester/golden_855_b09.json
This commit is contained in:
@@ -45,7 +45,6 @@ HEAD = (
|
||||
GUESS = "추정" # 원파일 품셈 조건 글 표지(810-2 `M02_Doc_NativeEst.GUESS`)
|
||||
SUB = "원파일 소계" # 원파일 소계 덧줄(810-2 `M02_Doc_NativeEst`) — 합 밖 · 비목 칸 비움
|
||||
PICK = "소요량" # 고른 표 칸 기호 이름 머리
|
||||
_SCALE = {"eq": (1,), "pct": (100, 0.01), "kgt": (1000, 0.001)}
|
||||
|
||||
|
||||
def is_imported(sk: Any) -> bool:
|
||||
@@ -68,164 +67,42 @@ def _index(sk: dict, master: Any = None, doc: Any = None) -> Any:
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
|
||||
if basis_of(sk) == "우리" or swapped(doc):
|
||||
return skc.over(sk, imp._whole())
|
||||
return skc.over(sk, master or imp._whole()) # 받은 색인(B09 사본 단가) 위 · 없으면 지금 M01
|
||||
return master or imp._whole()
|
||||
|
||||
|
||||
# ── 엑셀 단가 그대로 고친 줄(가져온 로직 줄 + SK 고침 · 엔진 셈 없음) ─────────
|
||||
def _engine_adds(doc: dict) -> bool:
|
||||
"""값을 엔진 셈으로만 얻는 더한줄(율 · 세부 고친 둘째 기초)이 있음 — 못 셈(옛 셈 은퇴) ·
|
||||
형제 SK 더한줄 = 단가산출 연결(`_attach`)."""
|
||||
return any(sd.is_rate(one) or sd.sub_patched(one) for one in doc.get("더한줄") or [])
|
||||
# ── 불러올 때 문서 한 번 짓기(857-3b) ───────────────────────────────────
|
||||
OLD_FORM = "옛 꼴로 저장된 불러온 단가산출 — 엑셀 · 원파일을 다시 불러와 저장"
|
||||
FIRST = "문서" # `가져온` 칸 — 불러온 그대로 문서(정본 · 고침 = `수식` 따로 사본)
|
||||
LIST = "이음없음" # 문서 머리 `가져온` — 이음 없는 가져온 줄 [{자리, 이름, 까닭, 견적?, 종?}]
|
||||
|
||||
|
||||
def _ctx(sk: dict, whole: Any) -> tuple:
|
||||
"""엑셀 단가 기준 고친 줄(855 2-C2) — 가져온 로직 줄(`row_of`) + 수식 고침 · SK 고침(`sd.patched`) ·
|
||||
더한줄 고정 값(`fixed.line`) → (색인, 키, 입력, {정체, 고친 줄(`ROW`)}, None) · 옛 엔진 안 돎.
|
||||
안쪽 산근(형제 SK) 줄 값 = 0 자리값(`_attach` 가 형제 SK 연결 + 엑셀 값으로 갈음).
|
||||
`_engine_adds` 인 SK = 못 셈(그 더한줄 값이 옛 엔진 답 — 옛 셈 은퇴 · 855 2-C1)."""
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
from M02_MasterTemplete import M02_Sangeun_Equation as eqm
|
||||
|
||||
raw = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": "엑셀"}}
|
||||
doc = sd.clean(raw, None, whole)
|
||||
if _engine_adds(doc):
|
||||
raise ValueError("율 · 고친 둘째 기초 더한줄 — 옛 엔진 셈 은퇴 · 못 셈")
|
||||
w = skc.over(doc, whole)
|
||||
base = sd.empty_row(doc)
|
||||
base = {**base, "호표": [dict(x) for x in base.get("호표") or []]}
|
||||
for item in base["호표"]:
|
||||
if "참조" in item and item.get("값묶음") is None:
|
||||
item["값묶음"] = dict.fromkeys(imp.COSTS, Decimal(0))
|
||||
base, _ = eqm.on(base, doc, skc.over(doc, w))
|
||||
filled, lack = calc._fill(doc, w, dict(doc.get("입력값") or {}))
|
||||
got = sd.patched(base, filled, {}, {})
|
||||
items = got["줄"]["호표"]
|
||||
for item in items: # 더한 형제 SK 줄도 0 자리값(`_attach` 가 단가산출 연결로 갈음)
|
||||
if "참조" in item and item.get("값묶음") is None:
|
||||
item["값묶음"] = dict.fromkeys(imp.COSTS, Decimal(0))
|
||||
calc._direct(got["자재표시"], items)
|
||||
for at, cid in enumerate(got["정체"][: len(items)]):
|
||||
if cid.startswith("add:#") and int(cid[5:]) in lack:
|
||||
items[at] = calc._gap(items[at], lack[int(cid[5:])])
|
||||
row = {**got["줄"], "호표": [dict(x) for x in items]}
|
||||
calc._bundles(row, w, None, ()) # 더한줄 고정 줄 = 줄 값 · 이은 노임 · 자재(엔진 아님)
|
||||
key = str(doc.get("키") or "SK-000000")
|
||||
names = {str(i.get("이름")) for i in row.get("입력") or []}
|
||||
values = {k: v for k, v in (doc.get("입력값") or {}).items() if k in names}
|
||||
return w, key, values, {"정체": got["정체"], ROW: {**row, "키": key}}, None
|
||||
def bare_row(row: dict, key: str = "SK-000000") -> dict:
|
||||
"""가져온 줄(읽기기 꼴 · 엑셀 판) → 문서 짓는 줄 — 요소 = 이음 | {이름}(로직 줄 = 이음 | None) ·
|
||||
안쪽 산근(형제 SK) 줄 = 0 자리값(`_attach` 가 형제 SK 연결 + 엑셀 값으로 갈음)."""
|
||||
items = []
|
||||
for one in row.get("호표") or []:
|
||||
link = one.get("이음")
|
||||
item = {k: v for k, v in one.items() if k != "이음"}
|
||||
item["요소"] = link or (None if one.get("종류") == "로직" else {"이름": one.get("이름")})
|
||||
if one.get("참조"):
|
||||
item |= {"요소": None, "값묶음": dict.fromkeys(imp.COSTS, Decimal(0)), "기준": "엑셀"}
|
||||
items.append(item)
|
||||
return {"입력": [], "중간": [], "덧줄": [], **row, "키": key, "호표": items}
|
||||
|
||||
|
||||
ROW = "고친줄" # `_ctx` 가 넘기는 엑셀 단가 기준 고친 줄(857-3a — 색인 `.logic` 안 부름)
|
||||
def _unlinked(row: dict) -> list[dict]:
|
||||
"""이음 없는 자원 줄 — 자리 = 가져온 줄 자리(`호표:i`) · 까닭 = 814-1 `M02_San_Link.why` ·
|
||||
견적 = 815-1 K5 그대로 쓰는 견적 · 운임 · 수수료 줄 · 종 = 827-3 재료 종 열쇠."""
|
||||
from M02_MasterTemplete import M02_San_Link as link
|
||||
|
||||
|
||||
# ── 소요량 · 계수 고른 칸 → 수 자리에 기호 ──────────────────────────────
|
||||
CMP = ("<=", ">=", "==", "!=", "<", ">") # 비교 글자 — 수 세기에서 뺌(`QtyLinks._literals`)
|
||||
|
||||
|
||||
def _swap_nth(node: Any, n: int, new: tuple, seen: list) -> Any:
|
||||
"""`M02_Sangeun_QtyLinks._literals` 차례의 n 번째 수 → `new` 마디(같은 걸음 규칙 · 문서 식 나무) ·
|
||||
다른 수 = 끝 0 뗀 글(옛 엔진 글과 같게)."""
|
||||
if not isinstance(node, tuple):
|
||||
return node
|
||||
kind = node[0]
|
||||
if kind == "num":
|
||||
seen[0] += 1
|
||||
return new if seen[0] - 1 == n else ("num", node[1].normalize())
|
||||
if kind == "bin":
|
||||
cmp_ = node[1] in CMP
|
||||
sides = [
|
||||
("num", side[1].normalize())
|
||||
if cmp_ and side[0] == "num"
|
||||
else _swap_nth(side, n, new, seen)
|
||||
for side in node[2:]
|
||||
]
|
||||
return (kind, node[1], *sides)
|
||||
if kind in ("neg", "pct", "field"):
|
||||
return (kind, _swap_nth(node[1], n, new, seen), *node[2:])
|
||||
if kind == "call":
|
||||
return ("call", node[1], [_swap_nth(a, n, new, seen) for a in node[2]])
|
||||
return node
|
||||
|
||||
|
||||
def _conds(table: dict, at: int) -> dict | None:
|
||||
"""표 줄 차례 → 그 줄 하나만 맞는 조건 {조건: 값}(범위 = 위 끝 › 아래 끝) · 못 가림 = None."""
|
||||
rows = table.get("줄") or []
|
||||
if not (0 <= at < len(rows)):
|
||||
return None
|
||||
row, out = rows[at], {}
|
||||
for cond, how in (table.get("조건") or {}).items():
|
||||
if cond not in row:
|
||||
continue
|
||||
have = row[cond]
|
||||
if how == "범위":
|
||||
low, high = have
|
||||
have = high if high is not None else low
|
||||
if have is None:
|
||||
return None
|
||||
out[cond] = have
|
||||
try:
|
||||
hit = dc.ml.find(table, out)
|
||||
except Exception: # noqa: BLE001 — 못 가림 = 수 그대로
|
||||
return None
|
||||
return out if hit is row else None
|
||||
|
||||
|
||||
def _picks(row: dict, ids: list[str], base: list[str], meta: dict, master: Any) -> dict:
|
||||
"""고른 칸(`가져온.연결.고름`) → 중간 줄(표 연결 바로 · `San_ToDoc`) · 수 자리에 그 기호 ÷ 배 ·
|
||||
돌려줌 = {중간 이름: 엑셀 칸 값}. 자리 줄이 SK 고침으로 바뀌었으면 건너뜀."""
|
||||
src = meta["로직"]
|
||||
picked = ((meta.get("연결") or {}).get("고름")) or []
|
||||
out: dict[str, Any] = {}
|
||||
mids = row.setdefault("중간", [])
|
||||
taken = {str(x.get("이름")) for x in [*(row.get("입력") or []), *mids]}
|
||||
for one in picked:
|
||||
part, i, n = str(one.get("자리") or "::").split(":")[:3]
|
||||
field = "수량" if part == "호표" else "식"
|
||||
lines = src.get(part) or []
|
||||
if not (i.isdigit() and n.isdigit() and int(i) < len(lines)):
|
||||
continue
|
||||
cid = base[int(i) + (len(src.get("호표") or []) if part == "덧줄" else 0)]
|
||||
if cid not in ids:
|
||||
continue
|
||||
at = ids.index(cid)
|
||||
mine = (row["호표"] if at < len(row["호표"]) else row.get("덧줄") or [])[
|
||||
at if at < len(row["호표"]) else at - len(row["호표"])
|
||||
]
|
||||
if str(mine.get(field)) != str(lines[int(i)].get(field)):
|
||||
continue # SK 덮개가 그 식을 바꿈 — 수 자리 어긋남
|
||||
try:
|
||||
table = master.get(str(one.get("표")))
|
||||
conds = _conds(table, int(one.get("줄")))
|
||||
node = dc.md.parse(str(mine[field]))
|
||||
except Exception: # noqa: BLE001 — 표 · 식 못 읽음 = 수 그대로
|
||||
continue
|
||||
if conds is None:
|
||||
continue
|
||||
name = next(f"{PICK}{k}" for k in range(1, 999) if f"{PICK}{k}" not in taken)
|
||||
taken.add(name)
|
||||
scale = next(
|
||||
(m for m in _SCALE.get(str(one.get("꼴")), (1,)) if _near(one, m)), None
|
||||
) # 엑셀 수 = 칸 값 ÷ 배
|
||||
if scale is None:
|
||||
continue
|
||||
ref = (
|
||||
("var", name)
|
||||
if scale == 1
|
||||
else ("bin", "/", ("var", name), ("num", Decimal(str(scale))))
|
||||
)
|
||||
mine[field] = dc.md.text_of(_swap_nth(node, int(n), ref, [0]))
|
||||
link = {"갈래": "표", "표": str(one["표"]).strip()}
|
||||
link |= {"조건": {k: _lit(v) for k, v in conds.items()}, "칸": str(one["칸"])}
|
||||
mids.append({"이름": name, "연결": link})
|
||||
out[name] = Decimal(str(one.get("값")))
|
||||
return out
|
||||
|
||||
|
||||
def _near(one: dict, m: float) -> bool:
|
||||
cell, v = float(one.get("값") or 0), float(one.get("수") or 0)
|
||||
return abs(cell - v * m) <= 1e-9 * max(1.0, abs(cell))
|
||||
return [
|
||||
{"자리": f"호표:{n}", "이름": one.get("이름") or "", "까닭": link.why(one)}
|
||||
| ({"견적": True} if (one.get("자원") or {}).get("갈래") == "고정" else {})
|
||||
| ({"종": mp.kind_of(one["자원"])} if (one.get("자원") or {}).get("재료찾기") else {})
|
||||
for n, one in enumerate(row.get("호표") or [])
|
||||
if not one.get("이음") and not one.get("참조") and not (one.get("자원") or {}).get("내기계")
|
||||
]
|
||||
|
||||
|
||||
def _lit(v: Any) -> str:
|
||||
@@ -447,41 +324,43 @@ def _numbers(doc: dict, keep: dict) -> None:
|
||||
|
||||
|
||||
def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict:
|
||||
"""가져온 식 SK → 수식 문서(키 = SK 키) — `ctx` = 엑셀 단가 기준 고친 줄(`_ctx` · 옛 SK 셈 길이 넘긴 것도 같은 꼴)."""
|
||||
"""가져온 식 SK → 수식 문서(키 = SK 키) = 불러온 그대로 문서(`가져온.문서` · 857-3b) ·
|
||||
옛 꼴(`가져온.로직`) = 읽지 않음(`OLD_FORM`)."""
|
||||
meta = sk[imp.KEY]
|
||||
if ctx is None:
|
||||
ctx = _ctx(sk, whole or imp._whole())
|
||||
master, key, values, got, _ = ctx
|
||||
row = cp.deepcopy(got.get(ROW) or master.logic(key)) # 옛 셈 길이 넘긴 ctx = 그 색인 줄
|
||||
ids = list(got.get("정체") or [])
|
||||
bare = imp.row_of({**sk, imp.KEY: {**meta, "단가기준": "엑셀"}}) or {}
|
||||
base = sd.line_ids(bare)
|
||||
src = dict(zip(base, meta["로직"].get("호표") or []))
|
||||
src |= { # 더한 형제 SK 줄 = 그 줄 스스로(연결 · 엑셀 값 없음)
|
||||
cid: one
|
||||
for cid, one in zip(ids, row["호표"])
|
||||
if cid.startswith("add:#") and one.get("참조")
|
||||
got = meta.get(FIRST)
|
||||
if not isinstance(got, dict):
|
||||
raise sd.DocError(OLD_FORM)
|
||||
doc = cp.deepcopy(got)
|
||||
return {
|
||||
**doc,
|
||||
"키": str(sk.get("키") or doc.get("키")),
|
||||
"이름": str(sk.get("이름") or doc.get("이름")),
|
||||
}
|
||||
keep = _picks(row, ids, base, meta, master)
|
||||
doc, notes = todoc.build(row, master, values) # 857-3a 불러오기 자기 문서 짓기(변환기 안 부름)
|
||||
_attach(doc, row, ids, src)
|
||||
_numbers(doc, keep)
|
||||
native = bool((meta.get("원본") or {}).get("원파일"))
|
||||
if native or (meta.get("원본") or {}).get(
|
||||
"엑셀"
|
||||
): # 810-2 · 812-1 — 소계 비목 칸 비움 · 값 변수 출처
|
||||
|
||||
|
||||
def build(row: dict, src: dict, whole: Any = None) -> dict:
|
||||
"""가져온 줄(읽기기 꼴 · 깨끗한 줄) + 원본 → 불러온 그대로 수식 문서 — 불러올 때 한 번(857-3b ·
|
||||
`M02_San_ToDoc` · 변환기 · 색인 `.logic` · 옛 식 파서 안 부름)."""
|
||||
whole = whole or imp._whole()
|
||||
row, src = cp.deepcopy(row), cp.deepcopy(src) # 다듬기가 단계 · 글줄을 제자리에서 고침
|
||||
meta = {"로직": row, "원본": src}
|
||||
bare = bare_row(row)
|
||||
ids = sd.line_ids(bare)
|
||||
doc, notes = todoc.build(bare, whole, {})
|
||||
_attach(doc, bare, ids, dict(zip(ids, row.get("호표") or [])))
|
||||
_numbers(doc, {})
|
||||
native = bool(src.get("원파일"))
|
||||
if native or src.get("엑셀"): # 810-2 · 812-1 — 소계 비목 칸 비움 · 값 변수 출처
|
||||
_native(doc, native)
|
||||
head = {k: (meta.get("원본") or {}).get(k) for k in HEAD if (meta.get("원본") or {}).get(k)}
|
||||
marks = list((meta.get("원본") or {}).get("표지") or [])
|
||||
if native or (meta.get("원본") or {}).get(
|
||||
"엑셀"
|
||||
): # 810-3 — 품셈 조건 글(값 없음) = 「추정」 칸
|
||||
head = {k: src.get(k) for k in HEAD if src.get(k)}
|
||||
marks = list(src.get("표지") or [])
|
||||
if native or src.get("엑셀"): # 810-3 — 품셈 조건 글(값 없음) = 「추정」 칸
|
||||
head["추정"] = [
|
||||
{"행": x.get("행"), "글": " ".join(str(x.get("글") or "").split())}
|
||||
for x in meta["원본"].get("글줄") or []
|
||||
for x in src.get("글줄") or []
|
||||
if GUESS in str(x.get("표지") or "")
|
||||
]
|
||||
if not (doc.get("금액") or doc.get("결과") or row["호표"] or row.get("덧줄")):
|
||||
if not (doc.get("금액") or doc.get("결과") or bare["호표"] or bare.get("덧줄")):
|
||||
_empty(doc) # 빈 산근 = 엑셀 0 원(줄 없음 합) — 「—」 아님
|
||||
marks.append(EMPTY)
|
||||
found = doc.pop(MACHINES, None)
|
||||
@@ -489,14 +368,19 @@ def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict:
|
||||
head |= {"기계": found} if found else {} # 812-9 기계 찾기 판정(줄 쌓기 고르기 · 저장 때 별칭)
|
||||
doc["가져온"] = head | {"표지": marks} | ({"알림": notes} if notes else {})
|
||||
shape.shape(doc, meta) # 809-1 · 요구 704 — 지은 이름 → 엑셀 글 머리 · EST 기계 세 줄 = 한 줄
|
||||
alive = {dc.md.var_id(v) for v in doc.get("변수") or []}
|
||||
if found: # 세 줄을 한 줄로 합쳐 사라진 기호의 기계 판정은 뺌
|
||||
alive = {dc.md.var_id(v) for v in doc.get("변수") or []}
|
||||
doc["가져온"]["기계"] = [x for x in found if x["기호"] in alive]
|
||||
if mats: # 827-3 재료 찾기 판정(줄 쌓기 풍선말 · 이미 만든 SK 고름 얹기)
|
||||
alive = {dc.md.var_id(v) for v in doc.get("변수") or []}
|
||||
doc["가져온"]["재료"] = [x for x in mats if x["기호"] in alive]
|
||||
if gaps := _unlinked(row):
|
||||
doc["가져온"][LIST] = gaps
|
||||
from M02_MasterTemplete import M02_Sangeun_QtyLinks as qty # 서로 부름 — 늦게
|
||||
|
||||
if spots := qty.slots(row): # 797-2 소요량 · 계수 자리(가져온 줄 수 차례 · 고름 = 문서 고침)
|
||||
doc["가져온"]["자리"] = spots
|
||||
qt.tidy(doc, meta) # 848-6 원문 단위 · Q 값 글자
|
||||
return {**doc, "키": str(sk.get("키") or key), "이름": str(sk.get("이름") or doc.get("이름"))}
|
||||
return doc
|
||||
|
||||
|
||||
def _native(doc: dict, native: bool = True) -> None:
|
||||
|
||||
@@ -63,12 +63,10 @@ def apply(doc: dict, meta: dict) -> None:
|
||||
src = meta.get("원본") or {}
|
||||
if not src.get(TAG) or not money or None in keys:
|
||||
return
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||||
|
||||
row = meta.get("로직") or {}
|
||||
ids = sd.line_ids(
|
||||
imp.row_of({imp.KEY: {"로직": row}}) or {}
|
||||
) # 글줄 자리 = 줄 정체(`imp._named`)
|
||||
row = meta.get("로직") or {} # 불러올 때 지은 가져온 줄(`Doc_Import.build` · 저장 안 함)
|
||||
ids = sd.line_ids(dim.bare_row(row)) # 글줄 자리 = 줄 정체(`imp._named`)
|
||||
lines = [*(row.get("호표") or []), *(row.get("덧줄") or [])]
|
||||
by: dict[str, int] = {}
|
||||
for k, (cid, one) in enumerate(zip(ids, lines)):
|
||||
|
||||
@@ -72,7 +72,7 @@ def old_fp(doc: dict) -> str:
|
||||
"""옛 칸 지문 — 따로 문서 위 옛 칸 고침 막음(가져온 식 = 가져온 줄 · 고른 칸 · 이음도)."""
|
||||
got = {k: doc.get(k) for k in OLD_FIELDS if doc.get(k) not in (None, {}, [])}
|
||||
if dim.is_imported(doc):
|
||||
got["가져온"] = {k: doc["가져온"].get(k) for k in ("로직", "연결")}
|
||||
got["가져온"] = {"로직": doc["가져온"].get("로직")} # 옛 꼴만(857-3b 문서 = 수식 고침)
|
||||
return dc.fp(_strip(got))
|
||||
|
||||
|
||||
@@ -127,12 +127,14 @@ def frozen(sk: dict) -> bool:
|
||||
"""굳힌 사본 SK(B09 · 구조물 사본 `GX9…` 굳힌 줄 · 수식 사본 없음) — 바탕 로직에 M01 수식 문서
|
||||
없음 · 셈 = 옛 길(B9 걸음 몫 · 855 2-C1 은 안 건드림)."""
|
||||
key = str((sk.get("바탕") or {}).get("로직") or "")
|
||||
if dim.is_imported(sk): # 857-3b 가져온 식 굳힌 사본 = 불러온 그대로 문서 셈(굳힌 줄 없음)
|
||||
return False
|
||||
return bool(key) and not dc.has(sk) and key not in dc.folder()
|
||||
|
||||
|
||||
def old_only(sk: dict) -> bool:
|
||||
"""옛 칸 고침이 든 파생 SK(가져온 식 빼고 — 그 문서는 `M02_Doc_Import` 가 지음) — 셈 안 함."""
|
||||
return not dim.is_imported(sk) and any(sk.get(k) not in (None, {}, []) for k in OLD_PATCH)
|
||||
"""옛 칸 고침이 든 파생 SK(가져온 식도 — 857-3b 문서 = 불러온 그대로 · 고침 = 줄 쌓기) — 셈 안 함."""
|
||||
return any(sk.get(k) not in (None, {}, []) for k in OLD_PATCH)
|
||||
|
||||
|
||||
def derive(sk: dict, whole: Any) -> dict:
|
||||
|
||||
@@ -88,9 +88,8 @@ def freeze(copies: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]:
|
||||
frozen["켜쌓기율"] = prices.to_json(got["켜쌓기율"])
|
||||
if isinstance(doc.get("수식"), dict): # 841-1 수식 문서(기계덮음) — 사본 셈 = M02
|
||||
frozen["수식"] = _upper(doc) # 848-1 ① 위덮음 = 굳힐 때 기초 것
|
||||
# 848-7 가져온 식 수식 고침(저장 문서) = 사본도 가져온 식 셈(단가기준 · 가져온 값 층)
|
||||
if doc.get(_IMPORTED) and doc["수식"].get("따로"):
|
||||
frozen[_IMPORTED] = doc[_IMPORTED]
|
||||
if doc.get(_IMPORTED): # 848-7 · 857-3b 가져온 식 = 사본도 가져온 식 셈(불러온 그대로 문서)
|
||||
frozen[_IMPORTED] = doc[_IMPORTED]
|
||||
out[rid] = frozen
|
||||
for rid in sorted(rid for rid, doc in copies.items() if _patched(doc)):
|
||||
out[rid] = _freeze_lines(rid, copies[rid], whole, read, taken)
|
||||
@@ -173,4 +172,17 @@ def materials(copies: dict[str, Any]) -> list[str]:
|
||||
for doc in copies.values():
|
||||
lines = [x for x in doc.get("담은로직") or [] if isinstance(x, dict) and x.get(FROZEN)]
|
||||
out += [str(mt) for x in lines for mt in (x[FROZEN].get("고름") or {}).values()]
|
||||
return out + _imported_reach(copies)
|
||||
|
||||
|
||||
def _imported_reach(copies: dict[str, Any]) -> list[str]:
|
||||
"""857-3b 가져온 식 SK = 값 사본 줄이 닿는 요소 · 표(문서 셈이 읽음 · 로직 줄 뺌) — 굳힌 줄이 없음."""
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
|
||||
out = []
|
||||
for doc in copies.values():
|
||||
src = doc.get("원본") if is_sangeun(doc) and doc.get(_IMPORTED) else None
|
||||
if skc.has(src):
|
||||
rows = [*src[skc.KEY]["로직"], *(src[skc.KEY].get("단가") or [])]
|
||||
out += [str(r.get("키")) for r in rows if str(r.get("키"))[:1] != "G"]
|
||||
return out
|
||||
|
||||
@@ -72,7 +72,9 @@ class Expand:
|
||||
if refs.kind_of(ref["키"]) == "promote":
|
||||
self.memo[memo] = self._promote(doc)
|
||||
elif refs.kind_of(ref["키"]) == "sangeun": # 단가산출(715-2) = 고친 줄 셈 1 단위
|
||||
if basis and isinstance((doc.get("가져온") or {}).get("로직"), dict):
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
||||
|
||||
if basis and imp.is_imported(doc):
|
||||
doc = {**doc, "가져온": {**doc["가져온"], "단가기준": basis}}
|
||||
self.memo[memo] = calc.unit(doc, self.whole, self, (*trail, rid))
|
||||
else: # 사전조합 = 그 SC 로직 사본(795-2)
|
||||
|
||||
@@ -61,11 +61,11 @@ def refs_in(doc: Any) -> list[Ref]:
|
||||
return []
|
||||
base = doc.get("바탕")
|
||||
lines = [*(doc.get("담은로직") or []), *(doc.get("더한줄") or []), base]
|
||||
own = ((doc.get("가져온") or {}).get("로직") or {}).get("호표") # 가져온 식 산근 속 산근(797-1)
|
||||
lines += own if isinstance(own, list) else []
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp # 가져온 식 산근 속 산근(797-1)
|
||||
|
||||
return [
|
||||
one["참조"] for one in lines if isinstance(one, dict) and isinstance(one.get("참조"), dict)
|
||||
]
|
||||
] + imp.refs_of(doc)
|
||||
|
||||
|
||||
def ref_id(ref: Ref) -> str:
|
||||
@@ -567,13 +567,9 @@ def _move_doc(doc: dict[str, Any], move: Callable[[Ref, int], Ref], depth: int)
|
||||
out = {**doc, "더한줄": _moved(doc.get("더한줄"), move, depth)}
|
||||
if isinstance(base, dict) and isinstance(base.get("참조"), dict):
|
||||
out["바탕"] = {"참조": move(base["참조"], depth)}
|
||||
own = (doc.get("가져온") or {}).get("로직")
|
||||
if isinstance(own, dict): # 가져온 식 산근 속 산근(797-1)
|
||||
out["가져온"] = {
|
||||
**doc["가져온"],
|
||||
"로직": {**own, "호표": _moved(own.get("호표"), move, depth)},
|
||||
}
|
||||
return out
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp # 가져온 식 산근 속 산근(797-1)
|
||||
|
||||
return imp.move_refs(out, lambda ref: move(ref, depth))
|
||||
|
||||
|
||||
def _spec_moved(doc: dict[str, Any], done: dict[str, Ref]) -> dict[str, Any]:
|
||||
|
||||
@@ -24,7 +24,12 @@ import { at, type HopyoScope } from "./M02_MasterTemplete_Hopyo_Api";
|
||||
import { importedPanel, type PanelState } from "./M02_MasterTemplete_Hopyo_ImportedPanel";
|
||||
import { openQtyLinks, type QtyRow, type QtyTally } from "./M02_MasterTemplete_Hopyo_QtyLinks";
|
||||
import { mountSangeunDetail } from "./M02_MasterTemplete_Sangeun_Detail";
|
||||
import { type ImportedDoc, type Money4 } from "./logic/M02_Hopyo_Imported_Model";
|
||||
import {
|
||||
isImported,
|
||||
isOldForm,
|
||||
type ImportedDoc,
|
||||
type Money4,
|
||||
} from "./logic/M02_Hopyo_Imported_Model";
|
||||
|
||||
const TEXT = {
|
||||
Title: ["가져온 식 단가산출 — 단산{n}", "Imported build-up — block {n}"],
|
||||
@@ -147,15 +152,15 @@ export function openImported(o: ImportedOptions): void {
|
||||
|
||||
/** 이음 없는 자원 — 단가 기준 그대로 price 답(전 · 후 = 지금) */
|
||||
async function unlinked(): Promise<void> {
|
||||
if (!st.doc.가져온?.로직) return void (st.unlinked = []);
|
||||
const got = await edit("price", { 문서: st.doc, 기준: st.doc.가져온.단가기준 ?? "엑셀" }).catch(() => null); // prettier-ignore
|
||||
if (!isImported(st.doc) || isOldForm(st.doc)) return void (st.unlinked = []);
|
||||
const got = await edit("price", { 문서: st.doc, 기준: st.doc.가져온?.단가기준 ?? "엑셀" }).catch(() => null); // prettier-ignore
|
||||
st.unlinked = got?.이음없음 ?? [];
|
||||
draw();
|
||||
}
|
||||
|
||||
/** 소요량 · 계수 이음 집계(797-2) — 가져온 식일 때만 */
|
||||
async function qtyTally(): Promise<void> {
|
||||
if (!st.doc.가져온?.로직) return void (st.qty = null);
|
||||
if (!isImported(st.doc) || isOldForm(st.doc)) return void (st.qty = null);
|
||||
const got = await edit("qty", { 문서: st.doc }).catch(() => null);
|
||||
st.qty = got?.집계 ?? null;
|
||||
draw();
|
||||
|
||||
@@ -12,7 +12,8 @@ N6 표 기준 · N7 식 속 수 · N8 단위 성격(N9 · N10 옛 근거 제안
|
||||
쓰는 곳 = 소요량 · 계수 이음 `M02_Sangeun_QtyLinks`).
|
||||
우연 보정(`q_of` · `pb_sig`) = 보정 자료(실무 여덟 파일 상수 · `M02_San_Basis_corpus.json`) 몫 ·
|
||||
포아송 이항 꼬리 −log10.
|
||||
짓기 = M01 폴더 지문(`stamp`)마다 한 번(`get` · 프로세스 안 캐시 · 지문 바뀌면 다시).
|
||||
짓기 = M01 폴더 지문(`stamp`)마다 한 번(`get` · 프로세스 안 캐시 · 지문 바뀌면 다시) ·
|
||||
로직 = M01 수식 문서(857-3b · 옛 로직 줄 · 옛 식 파서 안 읽음 · 문서 파서).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -34,8 +35,12 @@ from common_util import common_util_derived_store as derived
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Hopyo_ReadEst as est
|
||||
|
||||
mf = m01.cm.mf
|
||||
import master_auto as ma # noqa: E402 — mf 를 불러 scripts 경로가 깔린 뒤
|
||||
m01.cm.mf # noqa: B018 — scripts 경로를 깖(M01 저장 모듈이 부름)
|
||||
import master_doc as md # noqa: E402
|
||||
import master_doc_link as ml # noqa: E402
|
||||
|
||||
DOCS = "수식문서" # M01 폴더 아래 수식 문서 폴더(`master_doc_link.FOLDER`)
|
||||
CMP = ("<=", ">=", "==", "!=", "<", ">") # 비교 글자
|
||||
|
||||
CORPUS = Path(__file__).with_name("M02_San_Basis_corpus.json")
|
||||
INLINE_MAX = 20 # 식 속 수가 이보다 많은 로직(표를 식으로 펼친 것)은 식 속 수 맞음을 안 셈
|
||||
@@ -149,6 +154,8 @@ def stamp() -> str:
|
||||
}
|
||||
if m01.cm.mmf.here(folder()): # 기계 = 폴더(826-2)
|
||||
files[m01.cm.mmf.NAME] = m01.version_of(m01.cm.mmf.raw(folder(), m01.cm.mmf.NAME))
|
||||
for p in sorted((folder() / DOCS).glob("수식_*.json")): # 857-3b 로직 = 수식 문서
|
||||
files[f"{DOCS}/{p.name}"] = derived.file_digest(p)
|
||||
return derived.derived_key("san-basis-index", files, derived.file_digest(CORPUS))
|
||||
|
||||
|
||||
@@ -157,9 +164,8 @@ def load(root: Path) -> tuple[dict, dict, dict, dict]:
|
||||
for f in glob.glob(str(root / "소요량_*.json")) + glob.glob(str(root / "계수_*.json")):
|
||||
for t in json.loads(Path(f).read_text(encoding="utf-8")).get("표", []):
|
||||
tables[t["키"]] = t
|
||||
for f in glob.glob(str(root / "로직_*.json")):
|
||||
for it in json.loads(Path(f).read_text(encoding="utf-8"))["줄"]:
|
||||
logic[it["키"]] = it
|
||||
if (root / DOCS).is_dir(): # 857-3b 로직 = 수식 문서(옛 로직 줄 안 읽음)
|
||||
logic = ml.load_all(root / DOCS)
|
||||
for r in m01.cm.mmf.table(root)[0]["줄"]: # 기계 = 폴더(826-2)
|
||||
eq[r["키"]] = r
|
||||
by_no: dict = {}
|
||||
@@ -178,63 +184,82 @@ def _resolve(ref: str, tables: dict, by_no: dict) -> str | None:
|
||||
return hit[0] if len(hit) == 1 else None
|
||||
|
||||
|
||||
def scan(item: dict, tables: dict, by_no: dict) -> tuple:
|
||||
"""로직 하나 → (찾기 부름, 식 속 수, 하위 로직 부름, 기계 부름, 호표 수량 속 수)."""
|
||||
names = {s["이름"] for s in item.get("입력", [])}
|
||||
def inputs_of(doc: dict) -> dict[str, str]:
|
||||
"""문서 입력 · 선택 변수 {기호: 열쇠(입력 이름)}."""
|
||||
return {
|
||||
md.var_id(v): str(v.get("열쇠"))
|
||||
for v in doc.get("변수") or []
|
||||
if (v.get("연결") or {}).get("갈래") in ("입력", "선택")
|
||||
}
|
||||
|
||||
|
||||
def scan(doc: dict, tables: dict, by_no: dict) -> tuple:
|
||||
"""수식 문서 하나 → (찾기 부름, 식 속 수, 하위 로직 부름, 기계 부름, 호표 수량 속 수) — 857-3b ·
|
||||
옛 로직 줄 훑기와 같은 꼴(이름 = 입력 이름 · 표 · 하위 로직 · 기계 = 변수 연결)."""
|
||||
names = inputs_of(doc)
|
||||
finds, nums, calls, eqs = [], [], [], []
|
||||
|
||||
def arg_of(node):
|
||||
def parse(text: Any) -> Any:
|
||||
try:
|
||||
return md.parse(text)
|
||||
except md.DocError:
|
||||
return None
|
||||
|
||||
def arg_of(text: Any) -> tuple:
|
||||
node = parse(text)
|
||||
if node is None:
|
||||
return ("expr", str(text)[:80])
|
||||
if node[0] == "str":
|
||||
return ("lit", node[1])
|
||||
if node[0] == "num":
|
||||
return ("lit", float(node[1]))
|
||||
if node[0] == "name":
|
||||
return ("name", node[1]) if node[1] in names else ("expr", node[1])
|
||||
if node[0] == "var":
|
||||
return ("name", names[node[1]]) if node[1] in names else ("expr", node[1])
|
||||
visit(node)
|
||||
return ("expr", str(node)[:80])
|
||||
|
||||
def visit(node, field=None):
|
||||
def visit(node: Any) -> None:
|
||||
kind = node[0]
|
||||
if kind == "field":
|
||||
visit(node[1], node[2])
|
||||
elif kind in ("find", "logic"):
|
||||
if kind == "find" and (ref := _resolve(node[1], tables, by_no)):
|
||||
finds.append((ref, field, {c: arg_of(a) for c, a in node[2]}))
|
||||
if kind == "logic" and isinstance(node[1], str) and "{" not in node[1]:
|
||||
calls.append((node[1], {c: arg_of(a) for c, a in node[2]}))
|
||||
for _, a in node[2]:
|
||||
if a[0] not in ("str", "num", "name"):
|
||||
visit(a)
|
||||
elif kind == "ref":
|
||||
if node[1].startswith("EQ") and field:
|
||||
eqs.append((node[1], field))
|
||||
elif kind == "num":
|
||||
if kind == "num":
|
||||
nums.append(float(node[1]))
|
||||
elif kind == "bin":
|
||||
for side in (node[2], node[3]): # 비교 글자(「SCH == 20」)는 셈 수가 아님
|
||||
if node[1] in mf._OPS and side[0] == "num":
|
||||
if node[1] in CMP and side[0] == "num":
|
||||
continue
|
||||
visit(side)
|
||||
elif kind == "neg":
|
||||
elif kind in ("neg", "pct", "field"):
|
||||
visit(node[1])
|
||||
elif kind == "call":
|
||||
for a in node[2]:
|
||||
visit(a)
|
||||
|
||||
for text in ma._texts(item):
|
||||
if any(text is h["수량"] for h in item.get("호표", [])):
|
||||
continue
|
||||
try:
|
||||
visit(mf.parse(text))
|
||||
except mf.FormulaError:
|
||||
pass
|
||||
def hole(key: str) -> str:
|
||||
"""`EQ:{기호}` → `EQ:{입력 이름}`(옛 로직 줄 꼴)."""
|
||||
return re.sub(r"\{([^{}]+)\}", lambda m: "{" + names.get(m.group(1), m.group(1)) + "}", key)
|
||||
|
||||
for var in doc.get("변수") or []:
|
||||
link = var.get("연결") or {}
|
||||
kind, key = link.get("갈래"), str(link.get("키") or link.get("표") or "")
|
||||
if kind == "표" and (ref := _resolve(key, tables, by_no)):
|
||||
args = {c: arg_of(a) for c, a in (link.get("조건") or {}).items()}
|
||||
finds.append((ref, link.get("칸"), args))
|
||||
elif kind == "단가산출" and key and "{" not in key and not key.startswith("SK-"):
|
||||
calls.append((key, {c: arg_of(a) for c, a in (link.get("입력") or {}).items()}))
|
||||
elif kind == "요소" and key.startswith("EQ") and link.get("칸"):
|
||||
eqs.append((hole(key), link["칸"]))
|
||||
texts = [x.get("식") for x in doc.get("식") or []]
|
||||
texts += [x.get("단가") for x in doc.get("금액") or [] if "수량" not in x] # 덧줄 식
|
||||
for text in texts:
|
||||
if (node := parse(text)) is not None:
|
||||
visit(node)
|
||||
trade_nums = [] # (호표 이름, 수량 식 속 수)
|
||||
for h in item.get("호표", []):
|
||||
before = len(nums)
|
||||
try:
|
||||
visit(mf.parse(h["수량"]))
|
||||
except mf.FormulaError:
|
||||
for line in doc.get("금액") or []:
|
||||
if "수량" not in line or (node := parse(line["수량"])) is None:
|
||||
continue
|
||||
trade_nums += [(h.get("이름") or "", x) for x in nums[before:]]
|
||||
before = len(nums)
|
||||
visit(node)
|
||||
trade_nums += [(line.get("이름") or "", x) for x in nums[before:]]
|
||||
|
||||
return finds, nums, calls, eqs, trade_nums
|
||||
|
||||
|
||||
@@ -371,7 +396,7 @@ class Index:
|
||||
m = re.match(r"EQ:\{(\w+)\}", ref)
|
||||
if m:
|
||||
arg = m.group(1)
|
||||
inputs = {sp["이름"] for sp in self.logic[key].get("입력", [])}
|
||||
inputs = set(inputs_of(self.logic[key]).values())
|
||||
if depth == 0 and arg in inputs:
|
||||
use = ("입력", arg)
|
||||
elif depth > 0 and arg in rename:
|
||||
|
||||
@@ -357,8 +357,8 @@ def uses(fp: str, kind: str, skip: tuple = ()) -> list[str]:
|
||||
if key in skip:
|
||||
continue
|
||||
doc = json.loads((store.root() / sd.KIND / f"{key}.json").read_bytes())
|
||||
lines = ((doc.get("가져온") or {}).get("로직") or {}).get("호표") or []
|
||||
if any(kind_of(x.get("자원") or {}) == kind for x in lines if (x.get("자원") or {}).get("재료찾기")): # fmt: skip
|
||||
first = (doc.get("가져온") or {}).get("문서") or {} # 불러온 그대로 문서(857-3b)
|
||||
if any(e.get("종") == kind for e in (first.get("가져온") or {}).get("재료") or []):
|
||||
out.append(key)
|
||||
return out
|
||||
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
"""M02 가져온 식 로직 줄 → 수식 문서(PLAN 857-3a · 걸음 4 설계 3 절) — 서버 단독.
|
||||
"""M02 가져온 식 로직 줄 → 수식 문서(PLAN 857-3a · 857-3b · 걸음 4 설계 3 절) — 서버 단독.
|
||||
|
||||
불러오기 읽기기(둘 꼴 · 로직 줄 꼴 블록)가 낸 `가져온.로직` 줄(+ SK 고침 · 고른 칸 중간)을 불러오기
|
||||
자기 모듈에서 문서로 지음 — 옛 변환기(`master_doc_convert`) · 색인 `.logic` · 옛 식 파서
|
||||
(`master_formula.parse`) 안 부름 · 식 글 = 문서 파서(`master_doc.parse`).
|
||||
가져온 줄 꼴: 입력 · 결과 없음 · 호표 = 손 값(값묶음 · 단가) = 숫자 연결 · 사람이 더한 줄 =
|
||||
요소 키(인력 · 재료 · 기계 — 요소 연결 · M01 값) · 로직 부름(단가산출 연결) ·
|
||||
중간 = 식 줄(표시 = 반올림) · 고른 칸 중간(`연결` 든 줄) = 그 기호에 바로 연결 ·
|
||||
불러오기 읽기기(둘 꼴 · 로직 줄 꼴 블록)가 낸 가져온 줄을 불러올 때 한 번 문서로 지음
|
||||
(저장 = 그 문서) — 옛 변환기(`master_doc_convert`) · 색인 `.logic` ·
|
||||
옛 식 파서(`master_formula.parse`) 안 부름 · 식 글 = 문서 파서(`master_doc.parse`) ·
|
||||
사람 고침 = 줄 쌓기(문서).
|
||||
가져온 줄 꼴: 입력 · 결과 없음 · 호표 = 손 값(값묶음 · 단가) = 숫자 연결 ·
|
||||
중간 = 식 줄(표시 = 반올림) ·
|
||||
덧줄 = 금액 줄(단가 = 식) · `줄.'이름'` · 앞 덧줄 이름 = 그 금액 줄 기호 ·
|
||||
끝수 · 끝전 · 단계 · 조정 그대로.
|
||||
기호 = `master_symbol` 규칙(이름 끝말) · 한 문서 안 겹침 = 아래첨자 끝 숫자.
|
||||
@@ -30,6 +30,8 @@ import master_doc_unit as mdu # noqa: E402
|
||||
import master_doc_unit_rule as mdr # noqa: E402
|
||||
import master_symbol as msym # noqa: E402
|
||||
|
||||
FROM = "가져온줄" # 857-3b 문서 금액 줄 · 값 변수 ↔ 가져온 줄 자리(`호표:i` · `덧줄:i`)
|
||||
KIND = "가져온종류" # 금액 줄 ↔ 가져온 줄 종류(인력 · 재료 · 기계 · 로직)
|
||||
LINE_KEYS = ("번지", "합밖", "자리", "출처", "부착") # 호표 → 금액 줄 그대로 옮기는 칸
|
||||
ADD_KEYS = ("번지", "합밖", "자리", "출처") # 덧줄 → 금액 줄
|
||||
|
||||
@@ -88,8 +90,6 @@ class _Reg:
|
||||
|
||||
_HEAD = re.compile(r"\s*로직\(\s*([^,()'{}]+?)\s*(?=[,)])")
|
||||
_ARG = re.compile(r"\s*,\s*(?:'([^']*)'|(\w+))\s*=\s*(?:'([^']*)'|(\d+(?:\.\d+)?))")
|
||||
_CODE = re.compile(r"^(?:EQ|MT|LB)\d") # 요소 키가 아래첨자로 샌 것(804-7)
|
||||
LINKED = "MP" # 품셈재료 — 줄 단위로 값이 갈림(`master_material.LINKED`)
|
||||
|
||||
|
||||
def logic_call(text: Any) -> tuple[str, list[tuple[str, tuple]]] | None:
|
||||
@@ -161,58 +161,19 @@ class _Doc:
|
||||
value: Any = {k: Decimal(str(given.get(k) or 0)) for k in md.COSTS}
|
||||
else:
|
||||
value = Decimal(str(item["단가"]))
|
||||
return self.var(("손", at), f"{name}단가", {"갈래": "숫자", "값": value})
|
||||
got = self.var(("손", at), f"{name}단가", {"갈래": "숫자", "값": value})
|
||||
self.links[("손", at)][FROM] = f"호표:{at}" # 857-3b 가져온 줄 자리(이음 · 소요량 고침)
|
||||
return got
|
||||
|
||||
def var(self, key: tuple, label: str, link: dict, unit: str = "") -> str:
|
||||
"""값 변수 하나(열쇠마다 한 기호) — 기호 = 이름 끝말 규칙."""
|
||||
if key not in self.links:
|
||||
sign, low, up = msym.lookup(label, "요소")
|
||||
self.reg.want(key, (sign, self._low(link, low), up))
|
||||
self.reg.want(key, msym.lookup(label, "요소"))
|
||||
self.order.append(key)
|
||||
self.links[key] = {"이름": label, "단위": unit, "연결": link}
|
||||
self.links[key]["연결"] = link
|
||||
return self.reg.id(key)
|
||||
|
||||
def _low(self, link: dict, low: str) -> str:
|
||||
"""요소 키가 아래첨자로 샌 것(`k_EQ0006`) → 자원 이름 끝 낱말."""
|
||||
if not _CODE.match(low or "") or link.get("갈래") != "요소":
|
||||
return low
|
||||
try:
|
||||
row = self.master.get(str(link.get("키") or ""))
|
||||
except Exception: # noqa: BLE001 — 없는 키 = 그대로
|
||||
return low
|
||||
name = re.sub(r"\(.*?\)", "", str(row.get("이름") or "")).split(",")[0]
|
||||
words = [w for w in name.split() if not w[:1].isdigit()]
|
||||
got = msym.short(words[-1]) if words else ""
|
||||
return got if got and got != "·" else low
|
||||
|
||||
def element(self, ref: str, unit: str | None, part: str = "") -> str:
|
||||
"""사람이 더한 요소 줄(인력 · 재료 · 기계 키) — 요소 연결(M01 값 · 품셈재료 = 줄 단위) ·
|
||||
기계 = 시간당 기계경비 단가산출의 그 비목(가져온 기계 줄과 같은 짝 · 자료 없음 = 요소)."""
|
||||
from M02_MasterTemplete.M02_Doc_Import import hourly_link # 서로 부름 — 늦게
|
||||
|
||||
link = {"갈래": "요소", "키": ref} | ({"단위": unit} if unit is not None else {})
|
||||
try:
|
||||
label = self.master.label(ref)
|
||||
except Exception: # noqa: BLE001 — 없는 키 = 셈이 끊김 표지
|
||||
label = ref
|
||||
if ref[:2] == "EQ" and (hourly := hourly_link(ref, part)):
|
||||
return self.var(("기계", ref, part), label, hourly)
|
||||
return self.var(("요소", ref, unit), label, link)
|
||||
|
||||
def logic(self, text: str) -> str | None:
|
||||
"""사람이 더한 로직 부름 줄 — 단가산출 연결(이름 · 결과단위 = M01 수식 문서 머리)."""
|
||||
got = logic_call(text)
|
||||
if got is None:
|
||||
return None
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
|
||||
code, args = got
|
||||
link = {"갈래": "단가산출", "키": code, "입력": {k: md.text_of(v) for k, v in args}}
|
||||
head = dc.folder().get(code) or {}
|
||||
label = str(head.get("이름") or code)
|
||||
return self.var(("블록", text), label, link, str(head.get("결과단위") or ""))
|
||||
|
||||
|
||||
def build(row: dict, master: Any, given: dict | None = None) -> tuple[dict, list[str]]:
|
||||
"""가져온 로직 줄 → (수식 문서, 알림) · `master` = 단위 채움 색인 · given = 입력 값."""
|
||||
@@ -315,23 +276,12 @@ def _money(c: _Doc, row: dict) -> list[dict]:
|
||||
except md.DocError as e:
|
||||
c.notes.append(f"호표 「{name}」 수량 못 읽음 — {e}")
|
||||
qty = str(item["수량"])
|
||||
if item.get("값묶음") or item.get("단가") is not None: # 손 값(가져온 줄 · 고정 줄)
|
||||
price, line["비목"] = c.hand(at, item), item.get("비목") or "묶음"
|
||||
if line["비목"] != "묶음" and item.get("값묶음"):
|
||||
price = f"{price}.계"
|
||||
elif item.get("종류") == "로직":
|
||||
price = c.logic(str(item.get("요소") or ""))
|
||||
if price is None:
|
||||
raise ValueError(f"호표 「{name}」 로직 부름 꼴 아님 「{item.get('요소')}」")
|
||||
line["비목"] = item.get("비목") or "묶음"
|
||||
price = f"{price}.계" if "비목" in item else price
|
||||
else:
|
||||
ref = str(item["요소"])
|
||||
line["비목"] = item["비목"]
|
||||
unit = str(item.get("단위") or "") if ref[:2] == LINKED else None
|
||||
price = c.element(ref, unit, str(line["비목"]))
|
||||
price, line["비목"] = c.hand(at, item), item.get("비목") or "묶음"
|
||||
if line["비목"] != "묶음" and item.get("값묶음"):
|
||||
price = f"{price}.계"
|
||||
line |= {"수량": qty, "단가": price}
|
||||
line |= {k: item[k] for k in LINE_KEYS if k in item}
|
||||
line |= {FROM: f"호표:{at}", KIND: str(item.get("종류") or "")}
|
||||
out.append(line)
|
||||
seen: dict[str, tuple] = {}
|
||||
for add in adds:
|
||||
@@ -343,6 +293,7 @@ def _money(c: _Doc, row: dict) -> list[dict]:
|
||||
price = str(add["식"])
|
||||
line = {"이름": name, "단위": "식", "비목": add["비목"], "단가": price}
|
||||
line |= {k: add[k] for k in ADD_KEYS if k in add}
|
||||
line[FROM] = f"덧줄:{len(out) - len(items)}"
|
||||
out.append(line)
|
||||
seen[name] = ("덧", name)
|
||||
last = {str(x.get("이름") or ""): i for i, x in enumerate(items)} # 같은 이름 = 뒤 줄
|
||||
|
||||
@@ -201,8 +201,8 @@ def stamp(doc: dict) -> dict | None:
|
||||
keys, links = reach(doc.get("더한줄"))
|
||||
keys = [str(base["로직"]), *keys] if base.get("로직") else keys
|
||||
links += mym.keys_in(doc) # 줄 쌓기 기계 입력 「개인 EQP…」(821-1)
|
||||
extra = [row] if (row := imp.row_of(doc)) else []
|
||||
return snap(keys, links, extra)
|
||||
more, near = imp.reach_of(doc) # 가져온 식 = 불러온 그대로 문서 연결(857-3b)
|
||||
return snap([*keys, *more], [*links, *near])
|
||||
|
||||
|
||||
def reach(adds: Any) -> tuple[list[str], list[str]]:
|
||||
|
||||
@@ -225,26 +225,20 @@ def make(
|
||||
source: Path, key: str, no: int, name: str = "", _trail: tuple = (), doc: dict | None = None
|
||||
) -> dict[str, Any]:
|
||||
"""지금 층(만들 층)에 가져온 식 SK — 같은 내용이 있으면 그 SK(`다시씀`) ·
|
||||
안쪽 산근 블록은 형제 SK 를 먼저 만들어 참조(797-1) · `doc` = 미리 보기에서 고친 문서([저장] · 835-1 —
|
||||
그 문서 로직 줄에 안쪽 참조 · 내 기계를 이어 저장)."""
|
||||
안쪽 산근 블록은 형제 SK 를 먼저 만들어 참조(797-1) · 못 이은 기계 = 내 기계(821-4) ·
|
||||
`doc` = 미리 보기에서 고친 문서([저장] · 835-1 — 다시 읽은 가져온 줄로 안쪽 참조 · 내 기계만 그 문서에 얹음)."""
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
||||
|
||||
if doc is None:
|
||||
out, makes = _prep(source, key, no)
|
||||
else:
|
||||
meta = doc.get(imp.KEY) if isinstance(doc, dict) else None
|
||||
if not isinstance(meta, dict) or not isinstance(meta.get("로직"), dict):
|
||||
raise store.StoreError(400, "가져온 식 문서 아님")
|
||||
meta["원본"] = {**(meta.get("원본") or {}), "표지": list((meta.get("원본") or {}).get("표지") or [])} # fmt: skip
|
||||
meta["원본"].pop("내기계예정", None)
|
||||
out, makes = {"로직": meta["로직"], "원본": meta["원본"]}, _emit(source, key, no)[1]
|
||||
if doc is not None and (not imp.is_imported(doc) or imp.old_form(doc)):
|
||||
raise store.StoreError(400, "가져온 식 문서 아님")
|
||||
out, makes = _prep(source, key, no)
|
||||
_link_inner(source, key, no, out, _trail)
|
||||
if doc is None:
|
||||
_flag(out) # 고친 문서 = 미리 보기 때 붙은 표지 그대로
|
||||
_flag(out)
|
||||
made = mm.attach(out, makes) # 821-4 못 이은 기계 = 내 기계(그 층 같은 것 · 새로)
|
||||
mine = {"내기계": made} if made else {}
|
||||
if doc is None:
|
||||
doc = imp.new_doc(out["로직"], out["원본"], _title(out, no, name))
|
||||
fresh = imp.new_doc(out["로직"], out["원본"], _title(out, no, name))
|
||||
doc = fresh if doc is None else _onto(doc, fresh)
|
||||
try:
|
||||
return {**imp.keep(doc), "다시씀": False, **mine}
|
||||
except store.StoreError as e:
|
||||
@@ -252,3 +246,34 @@ def make(
|
||||
if e.status != 409 or not same:
|
||||
raise
|
||||
return {**imp.keep(doc, use=same[0]["키"]), "다시씀": True, **mine}
|
||||
|
||||
|
||||
def _onto(doc: dict, fresh: dict) -> dict:
|
||||
"""미리 보기에서 고친 문서 위에 [저장] 때 이은 것(안쪽 산근 참조 · 내 기계)만 — 아직 이음 없는 값
|
||||
변수(같은 가져온 줄 자리)에 새 문서 연결 · 원본 · 검산 · 머리 표지 · 기계 = 새 것(857-3b)."""
|
||||
import copy as cp
|
||||
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
||||
|
||||
doc = cp.deepcopy(doc)
|
||||
new = fresh[imp.KEY][imp.FIRST]
|
||||
by = {v.get(imp.FROM): v for v in new.get("변수") or [] if v.get(imp.FROM)}
|
||||
for one in imp.docs_of(doc):
|
||||
for var in one.get("변수") or []:
|
||||
got = by.get(var.get(imp.FROM))
|
||||
if got is None or not imp._bare_value(var) or imp._bare_value(got):
|
||||
continue
|
||||
var["연결"] = cp.deepcopy(got["연결"])
|
||||
var.pop("설명", None)
|
||||
var |= {"설명": got["설명"]} if got.get("설명") else {}
|
||||
head = one.setdefault(imp.KEY, {})
|
||||
for k in ("표지", "기계"):
|
||||
if (new.get(imp.KEY) or {}).get(k) is not None:
|
||||
head[k] = cp.deepcopy(new[imp.KEY][k])
|
||||
gaps = {x["자리"] for x in (new.get(imp.KEY) or {}).get(imp.LIST) or []}
|
||||
if head.get(imp.LIST):
|
||||
head[imp.LIST] = [x for x in head[imp.LIST] if x.get("자리") in gaps]
|
||||
src = fresh[imp.KEY].get("원본") or {}
|
||||
when = ((doc[imp.KEY].get("원본") or {}).get("가져온때")) or src.get("가져온때")
|
||||
doc[imp.KEY] |= {"원본": {**src, "가져온때": when}, "검산": fresh[imp.KEY]["검산"]}
|
||||
return doc
|
||||
|
||||
@@ -1,39 +1,30 @@
|
||||
"""M02 가져온 식 단가산출(SK 바탕 갈래 · PLAN 793-2 · 요구 649 · 652 갈래 C) — 서버 단독.
|
||||
"""M02 가져온 식 단가산출(SK 바탕 갈래 · PLAN 793-2 · 857-3b · 요구 649 · 652 갈래 C) — 서버 단독.
|
||||
|
||||
경쟁사 엑셀 산근 블록 = 엔진 로직 줄 하나(`_틀.md` 7 장 꼴 · sub4 793-2a 내보내기)를 SK 가 품음 ·
|
||||
셈 = 그 줄을 바탕 줄로(`M02_Sangeun_Doc.empty_row` → `row_of`) → `_Over` 로 얹어 같은 엔진 한 벌 ·
|
||||
790-2 · 792-1 고침(덮개 · 상수 · 표값 · 식 덮개 · 변수 줄 · 글 줄 · 까닭 · 더한줄)이 그대로 먹음.
|
||||
경쟁사 엑셀 · 원파일 산근 블록 = 읽기기가 낸 가져온 줄(아래 꼴 · sub4 793-2a 내보내기) → 불러올 때 한 번
|
||||
수식 문서로 지음(`M02_Doc_Import.build` · `M02_San_ToDoc`) · 정본 = 그 문서(857-3b · 요구 898 · 899).
|
||||
|
||||
가져온 로직 줄(만들기 몸 `로직`) = {이름, 결과단위 「원/단위」, 입력?, 중간? [{이름, 식, 표시?}],
|
||||
가져온 줄(만들기 몸 `로직` · 저장 안 함) = {이름, 결과단위 「원/단위」, 입력?, 중간? [{이름, 식, 표시?}],
|
||||
호표 [줄], 덧줄? [{이름, 식, 비목, 번지?, 합밖?, 자리?}], 단계?, 끝전?, 조정?, 끝수?}
|
||||
호표 줄 = {종류 인력|재료|기계|로직, 이름, 규격?, 단위, 수량(엔진 식 글),
|
||||
비목(로직 줄은 없으면 노 · 재 · 경 나눠 얹음),
|
||||
단가?(엑셀 단가 · 인력 · 재료 · 기계) | 값묶음? {노무비, 재료비, 경비}(엑셀 · 로직 줄),
|
||||
호표 줄 = {종류 인력|재료|기계|로직, 이름, 규격?, 단위, 수량(식 글), 비목(로직 줄은 없으면 묶음),
|
||||
단가?(엑셀 단가) | 값묶음? {노무비, 재료비, 경비}(엑셀 · 로직 줄),
|
||||
이음?(M01 요소 키 LB · MT · EQ … | 로직 줄 = 「로직(GC…, 이름='값')」 글 | null),
|
||||
번지?, 합밖?, 자리?} · `요소` 칸은 서버가 채움(이음 | {이름}) ·
|
||||
줄 정체 cid 머리 = 이음 키 | 이름.
|
||||
원본(만들기 몸 `원본`) = {파일, 시트, 행 [처음, 끝], 갈래 STmate|EST,
|
||||
엑셀금액 {노무비, 재료비, 경비, 계}(1 단위),
|
||||
글줄 [{행, 글, 자리?(셈 줄 cid | mid:이름), 값?(그 줄 엑셀 금액)}]}.
|
||||
SK 문서 덧칸 `가져온` = {로직(엑셀 단가 그대로 · 고치지 않음), 단가기준 엑셀|우리, 원본,
|
||||
검산 {같음, 까닭, 셈 {노..계}, 엑셀 {노..계}, 줄 [{자리, 행, 셈, 엑셀, 같음, 까닭?}]},
|
||||
근거후보 · 바꿈(옛 문서 읽기만 · 809-1 부터 안 씀)} ·
|
||||
바탕 = null · 가져온 식 SK = `가져온.로직` 있음 · 검산 = 저장 때 서버가 다시.
|
||||
단가기준 엑셀 = 줄 단가 · 값묶음 그대로 /
|
||||
우리 = 이음 있는 줄만 단가 · 값묶음 떼고 M01(B09 = 사본 단가) 지금 값 ·
|
||||
이음 없는 줄 = 엑셀 단가 그대로 + 표지(`이음없음`).
|
||||
길(`M02_Sangeun_Router` · 저장 없음 = 화면 캐시 · 만들기만 층 쓰기):
|
||||
POST …/sangeun/imported 몸 {로직, 원본, 이름?, 단위?, 구분?, 상세구분?, 새로?, 씀?}
|
||||
→ {이름(SK 키), 검산, 단가기준}(서버가 다시 셈해 엑셀과 맞댐 · 같은 내용 409 = 기존 길)
|
||||
참조?(같은 엑셀의 형제 가져온 식 SK · 797-1) · 번지?, 합밖?, 자리?, 자원?}.
|
||||
원본(만들기 몸 `원본`) = {파일, 시트, 행 [처음, 끝], 갈래 STmate|EST, 엑셀금액 {노..계}(1 단위),
|
||||
글줄 [{행, 글, 자리?(셈 줄 cid | mid:이름), 값?}]}.
|
||||
SK 문서 덧칸 `가져온` = {문서(불러온 그대로 수식 문서 · 정본), 단가기준 엑셀|우리, 원본,
|
||||
검산 {같음, 까닭, 셈, 엑셀, 줄}(불러올 때 한 번 · 엑셀 단가 · 고침 없음), 연결?(소요량 이음 기록 · 797-2),
|
||||
근거후보 · 바꿈(옛 문서 읽기만)} · 바탕 = null · 고침 = `수식` 따로 사본(줄 쌓기) · [초기화] = `문서`.
|
||||
옛 꼴(`가져온.로직` · 857-3b 앞 저장본) = 읽지 않음 · 지우지 않음 — 셈 · 열기 = 까닭 하나(`OLD_FORM`).
|
||||
단가기준 엑셀 = 연결의 엑셀 값 기억 · 우리 = 연결 값(`M02_Doc_Import.view`).
|
||||
길(`M02_Sangeun_Router` · 저장 없음 = 화면 캐시):
|
||||
POST …/sangeun/imported/price 몸 {문서, 기준} → {문서, 전, 후, 이음없음 [{자리, 이름}]}
|
||||
POST …/sangeun/imported/link 몸 {문서, 자리, 이음} → {문서}(이음 고름 · 덮개 열쇠 옮김)
|
||||
(우리 기초로 바꾸기 `to-base` 는 809-1 에서 지움 — 경쟁사 로직 인정 · 요구 703)
|
||||
셈 답(`…/sangeun/calc`) = 옛 꼴 그대로 · `원래` = 엑셀 금액(「M01 원래」 자리) · 덧칸 `가져온`
|
||||
{단가기준, 파일, 시트, 행, 갈래, 엑셀금액, 글줄 [{행, 글, 자리, 엑셀, 지금, 같음}], 이음없음}.
|
||||
POST …/sangeun/imported/link 몸 {문서, 자리(가져온 줄 `호표:i`), 이음} → {문서}(문서 연결 고침)
|
||||
셈 답(`…/sangeun/calc`) 덧칸 `가져온` {단가기준, 파일, 시트, 행, 갈래, 엑셀금액, 글줄, 이음없음} · `원래` = 엑셀 금액.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy as cp
|
||||
import json
|
||||
import math
|
||||
import re
|
||||
@@ -43,6 +34,7 @@ from typing import Any
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
|
||||
KEY = "가져온"
|
||||
FIRST = "문서" # `가져온` 칸 — 불러온 그대로 문서(`M02_Doc_Import.FIRST`)
|
||||
BASIS = ("엑셀", "우리")
|
||||
COSTS = ("노무비", "재료비", "경비")
|
||||
KINDS = ("인력", "재료", "기계", "로직")
|
||||
@@ -51,16 +43,11 @@ LINE = ("종류", "이름", "규격", "단위", "수량", "비목", "단가", "
|
||||
LINE += ("자리", "출처", "비고", "자원") # 자원 = 경쟁사 코드 · 엑셀 단가 원본(793-2a · 셈 안 씀)
|
||||
LINE += ("참조", "참조비목") # 산근 속 산근 = 같은 엑셀의 형제 가져온 식 SK(797-1 · 로직 줄만)
|
||||
EXTRA = ("이름", "식", "비목", "번지", "합밖", "자리", "출처", "비고")
|
||||
META = ("원본", "검산", "근거후보", "바꿈", "연결") # 검산 = 저장 때 서버가 다시 적음(`stamp`)
|
||||
META = ("원본", "검산", "근거후보", "바꿈", "연결")
|
||||
MANY = 300 # 호표 · 덧줄 · 중간 줄 수
|
||||
BIG = 400_000 # 메타 글 크기(바이트)
|
||||
_KEYED = ("덮개", "고름", "자재표시", "상수덮개", "표값덮개", "식덮개", "까닭", "M01판")
|
||||
|
||||
|
||||
def _mf() -> Any:
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
|
||||
return labor.m01.cm.mf
|
||||
DOC_BIG = 4_000_000 # 불러온 그대로 문서 크기(바이트)
|
||||
FROZEN = "GX9" # 굳힌 사본 바탕 로직 키 머리(`M02_Item_Sangeun.frozen_key`)
|
||||
|
||||
|
||||
def _whole() -> Any:
|
||||
@@ -70,11 +57,26 @@ def _whole() -> Any:
|
||||
return mym.whole()
|
||||
|
||||
|
||||
def _dim() -> Any:
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim # 서로 부름 — 늦게
|
||||
|
||||
return dim
|
||||
|
||||
|
||||
def is_imported(doc: Any) -> bool:
|
||||
return isinstance(doc, dict) and isinstance((doc.get(KEY) or {}).get("로직"), dict)
|
||||
"""가져온 식 SK — 불러온 그대로 문서(857-3b) · 옛 꼴(`로직`)도 가져온 식(읽지 않음 · 까닭)."""
|
||||
meta = doc.get(KEY) if isinstance(doc, dict) else None
|
||||
return isinstance(meta, dict) and (
|
||||
isinstance(meta.get(FIRST), dict) or isinstance(meta.get("로직"), dict)
|
||||
)
|
||||
|
||||
|
||||
# ── 바탕 줄 ───────────────────────────────────────────────────────────
|
||||
def old_form(doc: Any) -> bool:
|
||||
"""857-3b 앞 옛 꼴 저장본(`가져온.로직` · 문서 없음)."""
|
||||
return is_imported(doc) and not isinstance(doc[KEY].get(FIRST), dict)
|
||||
|
||||
|
||||
# ── 이음 기계 시간당 ───────────────────────────────────────────────────
|
||||
_HOURLY: dict[str, Any] = {"whole": None, "rows": {}}
|
||||
|
||||
|
||||
@@ -90,93 +92,54 @@ def hourly_of(key: str) -> dict:
|
||||
return _HOURLY["rows"][key]
|
||||
|
||||
|
||||
def machine_price(link: str, part: Any, excel: Any) -> Any:
|
||||
"""[우리 단가로] 기계 이음 줄 값 — 시간당 경비의 그 비목 · 시간당 자료 없으면 엑셀 단가 그대로."""
|
||||
got = hourly_of(link)
|
||||
if got.get("ok") and part in COSTS:
|
||||
return sd.plain(Decimal(str(got[part])))
|
||||
return excel
|
||||
|
||||
|
||||
def row_of(doc: Any) -> dict | None:
|
||||
"""가져온 식 바탕 줄(엔진 로직 줄) — 단가기준 우리 = 이음 있는 줄의 단가 · 값묶음 뗌 · 요소 =
|
||||
이음 | {이름}(로직 줄 = 이음 | None) · 가져온 식 아님 = None."""
|
||||
if not is_imported(doc):
|
||||
return None
|
||||
meta = doc[KEY]
|
||||
ours = meta.get("단가기준") == "우리"
|
||||
items = []
|
||||
for one in meta["로직"].get("호표") or []:
|
||||
link = one.get("이음")
|
||||
item = {k: v for k, v in one.items() if k != "이음"}
|
||||
item["요소"] = link or (None if one.get("종류") == "로직" else {"이름": one.get("이름")})
|
||||
if one.get(
|
||||
"참조"
|
||||
): # 안쪽 산근 = 형제 SK 1 단위 값(셈이 채움 · 엑셀 값묶음은 얼린 사본으로 둠)
|
||||
item |= {"요소": None, "값묶음": None, "기준": "우리" if ours else "엑셀"}
|
||||
if ours and not link and (mine := (one.get("자원") or {}).get("내기계")):
|
||||
_direct(item, one, mine) # 821-4 시간당 값 직접 내기계 = 그 줄 값
|
||||
if ours and link:
|
||||
item.pop("단가", None)
|
||||
item.pop("값묶음", None)
|
||||
if str(link).startswith(
|
||||
"EQ"
|
||||
): # EQ = 기계 제원 묶음 — 줄 값은 시간당 기계경비의 그 비목
|
||||
item["단가"] = machine_price(link, one.get("비목"), one.get("단가"))
|
||||
items.append(item)
|
||||
row = {"입력": [], "중간": [], "덧줄": [], **meta["로직"]}
|
||||
return {**row, "키": doc.get("키"), "호표": items}
|
||||
|
||||
|
||||
def _direct(item: dict, one: dict, key: str) -> None:
|
||||
"""[우리 단가로] 이음 없이 이은 내 기계(시간당 값 직접 · 821-4) — 단가 = 그 비목 · 값묶음 = 셋 ·
|
||||
지운 내 기계 = 엑셀 값 그대로."""
|
||||
got = hourly_of(key)
|
||||
if not got.get("ok"):
|
||||
return
|
||||
if "단가" in item and one.get("비목") in COSTS:
|
||||
item["단가"] = sd.plain(Decimal(str(got[one["비목"]])))
|
||||
elif "값묶음" in item:
|
||||
item["값묶음"] = {k: sd.plain(Decimal(str(got[k]))) for k in COSTS}
|
||||
def row_of(doc: Any) -> None:
|
||||
"""옛 가져온 줄(엔진 로직 줄) — 857-3b 부터 저장 안 함 · 읽지 않음(늘 None · 2-D 가 부름 걷음)."""
|
||||
return None
|
||||
|
||||
|
||||
def base_row(doc: dict) -> dict[str, Any]:
|
||||
"""바탕 없는 SK 바탕 줄(`sd.empty_row`) — 가져온 식 = 그 줄 · 아니면 입력 · 줄 없음."""
|
||||
return row_of(doc) or {
|
||||
"""바탕 없는 SK 바탕 줄(`sd.empty_row`) — 입력 · 줄 없음 · 가져온 식 결과단위 = 문서 결과단위(1 단위 배)."""
|
||||
first = (doc.get(KEY) or {}).get(FIRST) if isinstance(doc.get(KEY), dict) else None
|
||||
unit = (first or {}).get("결과단위") or f"원/{doc.get('단위') or ''}"
|
||||
return {
|
||||
"키": doc.get("키"),
|
||||
"이름": doc.get("이름"),
|
||||
"결과단위": f"원/{doc.get('단위') or ''}",
|
||||
"결과단위": unit,
|
||||
**{k: [] for k in ("입력", "중간", "호표", "덧줄")},
|
||||
}
|
||||
|
||||
|
||||
# ── 꼴 검사 ───────────────────────────────────────────────────────────
|
||||
# ── 가져온 줄 꼴 검사(불러올 때 · 문서 파서) ─────────────────────────────
|
||||
def _formula(raw: Any, where: str) -> str:
|
||||
from M02_MasterTemplete import M02_Sangeun_Formula as fx
|
||||
from M02_MasterTemplete import M02_San_ToDoc as todoc
|
||||
|
||||
text = str(raw if raw is not None else "").strip()
|
||||
if not text:
|
||||
raise sd.DocError(f"{where} · 식이 빔")
|
||||
if bad := fx.limits(text):
|
||||
raise sd.DocError(f"{where} · {bad[0]}")
|
||||
if len(text) > 2000:
|
||||
raise sd.DocError(f"{where} · 식이 너무 김")
|
||||
try:
|
||||
_mf().parse(text)
|
||||
except Exception as e: # noqa: BLE001 — 엔진 FormulaError
|
||||
todoc.md.parse(text)
|
||||
except todoc.md.DocError as e:
|
||||
raise sd.DocError(f"{where} · {e}") from e
|
||||
return text
|
||||
|
||||
|
||||
def _link(raw: Any, kind: str, where: str, whole: Any) -> str | None:
|
||||
"""이음 — 로직 줄 = 「로직(GC…)」 글(부르는 로직 있음) · 그 밖 = M01 요소 키(있음)."""
|
||||
"""이음 — 로직 줄 = 「로직(GC…)」 글(부르는 수식 문서 있음) · 그 밖 = M01 요소 키(있음)."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_San_ToDoc as todoc
|
||||
|
||||
if raw in (None, ""):
|
||||
return None
|
||||
text = str(raw).strip()
|
||||
try:
|
||||
if kind == "로직":
|
||||
node = _mf().parse(text)
|
||||
if node[0] != "logic":
|
||||
got = todoc.logic_call(text)
|
||||
if got is None:
|
||||
raise ValueError("로직(…) 꼴 아님")
|
||||
whole.logic(node[1])
|
||||
if dc.folder().get(got[0]) is None:
|
||||
raise ValueError("없는 단가산출")
|
||||
else:
|
||||
whole.get(text)
|
||||
except Exception as e: # noqa: BLE001
|
||||
@@ -221,7 +184,7 @@ def _line(raw: Any, where: str, whole: Any) -> dict:
|
||||
|
||||
|
||||
def clean_row(raw: Any, whole: Any = None) -> dict[str, Any]:
|
||||
"""가져온 로직 줄 꼴 — 줄 수 · 식(엔진 파서 · 상한) · 이음 키 · 엑셀 값 · 틀리면 `DocError`."""
|
||||
"""가져온 줄 꼴 — 줄 수 · 식(문서 파서) · 이음 키 · 엑셀 값 · 틀리면 `DocError`."""
|
||||
whole = whole or _whole()
|
||||
if not isinstance(raw, dict):
|
||||
raise sd.DocError("가져온 로직 · 묶음 아님")
|
||||
@@ -253,13 +216,13 @@ def _extra(raw: Any, where: str) -> dict:
|
||||
return {**out, "이름": str(raw.get("이름") or where), "식": _formula(raw.get("식"), where)}
|
||||
|
||||
|
||||
def _meta(raw: Any, name: str) -> Any:
|
||||
def _meta(raw: Any, name: str, big: int = BIG) -> Any:
|
||||
try:
|
||||
size = len(json.dumps(raw, ensure_ascii=False, default=str).encode("utf-8"))
|
||||
except (TypeError, ValueError) as e:
|
||||
raise sd.DocError(f"가져온 {name} · 글로 못 담음") from e
|
||||
if size > BIG:
|
||||
raise sd.DocError(f"가져온 {name} · {BIG} 바이트를 넘음")
|
||||
if size > big:
|
||||
raise sd.DocError(f"가져온 {name} · {big} 바이트를 넘음")
|
||||
want = list if name == "근거후보" else dict
|
||||
if not isinstance(raw, want):
|
||||
raise sd.DocError(f"가져온 {name} · {'목록' if want is list else '묶음'} 아님")
|
||||
@@ -268,7 +231,8 @@ def _meta(raw: Any, name: str) -> Any:
|
||||
|
||||
def clean(raw: Any, out: dict) -> dict:
|
||||
"""`sd.clean` 끝(`const.clean_more`) — `가져온` 칸 · 바탕과 같이 못 둠 ·
|
||||
`가져온보관` = 우리 기초 사본으로 바꾼 SK 의 원래 가져온 식 몸(810-4 되돌리기)."""
|
||||
`가져온보관` = 우리 기초 사본으로 바꾼 SK 의 원래 가져온 식 몸(810-4 되돌리기) ·
|
||||
옛 꼴(`로직`) = 그대로 둠(읽지 않음 · 지우지 않음)."""
|
||||
kept = raw.get("가져온보관") if isinstance(raw, dict) else None
|
||||
if isinstance(kept, dict) and isinstance(kept.get(KEY), dict):
|
||||
out = {**out, "가져온보관": _meta(kept, "가져온보관")}
|
||||
@@ -278,27 +242,28 @@ def clean(raw: Any, out: dict) -> dict:
|
||||
if not isinstance(meta, dict):
|
||||
raise sd.DocError("가져온 · 묶음 아님")
|
||||
got = {k: _meta(meta[k], k) for k in META if meta.get(k) not in (None, {}, [])}
|
||||
if meta.get("로직") is not None:
|
||||
if out.get("바탕"):
|
||||
raise sd.DocError("가져온 식 단가산출은 바탕 없음")
|
||||
if meta.get(FIRST) is not None or meta.get("로직") is not None:
|
||||
if out.get("바탕") and not str((out["바탕"] or {}).get("로직") or "").startswith(FROZEN):
|
||||
raise sd.DocError("가져온 식 단가산출은 바탕 없음") # 굳힌 사본(B09 · `GX9…`)만 바탕
|
||||
basis = meta.get("단가기준") or "엑셀"
|
||||
if basis not in BASIS:
|
||||
raise sd.DocError("단가기준은 엑셀 · 우리")
|
||||
got |= {"로직": clean_row(meta["로직"]), "단가기준": basis}
|
||||
if got.get("원본"):
|
||||
got["원본"] = _named(got["원본"], got["로직"])
|
||||
if got.get("연결"): # 소요량 · 계수 이음 기록(797-2) — 자리 · 수 맞는 것만
|
||||
from M02_MasterTemplete import M02_Sangeun_QtyLinks as qty
|
||||
|
||||
got["연결"] = qty.tidy(got["연결"], got["로직"])
|
||||
got = {k: v for k, v in got.items() if v or k != "연결"}
|
||||
got["단가기준"] = basis
|
||||
if meta.get(FIRST) is not None:
|
||||
first = _meta(meta[FIRST], FIRST, DOC_BIG)
|
||||
for name in ("변수", "식", "금액"):
|
||||
if not isinstance(first.get(name, []), list):
|
||||
raise sd.DocError(f"가져온 문서 · 「{name}」 목록 아님")
|
||||
got[FIRST] = first
|
||||
else:
|
||||
got["로직"] = meta["로직"] # 옛 꼴 — 그대로(읽지 않음)
|
||||
return out | ({KEY: got} if got else {})
|
||||
|
||||
|
||||
def _named(src: dict, row: dict) -> dict:
|
||||
"""원본 글줄 `자리` · `자리들` = 셈 줄 이름(793-2a) → 줄 정체 cid(이미 cid · `mid:` · `단계:` =
|
||||
그대로 · 블록 안 줄 이름은 겹치지 않음)."""
|
||||
ids = sd.line_ids(row_of({KEY: {"로직": row}}) or {})
|
||||
ids = sd.line_ids(_dim().bare_row(row))
|
||||
by: dict[str, str] = {}
|
||||
for one, cid in zip([*row["호표"], *(row.get("덧줄") or [])], ids):
|
||||
by.setdefault(str(one.get("이름")), cid)
|
||||
@@ -313,65 +278,56 @@ def _named(src: dict, row: dict) -> dict:
|
||||
|
||||
|
||||
def same_part(doc: Any) -> dict | None:
|
||||
"""같은 내용 지문 몫(`M02_Library_Same`) — 로직 · 단가기준(원본 · 검산 · 근거후보 뺌)."""
|
||||
"""같은 내용 지문 몫(`M02_Library_Same`) — 불러온 그대로 문서(머리 `가져온` = 파일 · 행 · 표지 뺌) ·
|
||||
단가기준(원본 · 검산 뺌)."""
|
||||
if not is_imported(doc):
|
||||
return None
|
||||
return {k: doc[KEY].get(k) for k in ("로직", "단가기준")}
|
||||
meta = doc[KEY]
|
||||
first = meta.get(FIRST)
|
||||
out = {k: meta.get(k) for k in ("로직", "단가기준") if meta.get(k) is not None}
|
||||
if isinstance(first, dict):
|
||||
out[FIRST] = {k: v for k, v in first.items() if k != KEY}
|
||||
return out
|
||||
|
||||
|
||||
def unlinked(doc: dict) -> list[dict]:
|
||||
"""이음 없는 자원 줄(표지 · 사람이 고름) `[{자리, 이름, 까닭, 견적?, 종?}]`(까닭 = 814-1 `M02_San_Link.why` ·
|
||||
견적 = 815-1 K5 그대로 쓰는 견적 · 운임 · 수수료 줄 — 못 이음 수에서 뺌 · 종 = 827-3 재료 종 열쇠)."""
|
||||
from M02_MasterTemplete import M02_San_Link as link
|
||||
from M02_MasterTemplete import M02_San_MatPick as mp
|
||||
|
||||
row = row_of(doc) or {}
|
||||
ids = sd.line_ids(row)
|
||||
return [
|
||||
{"자리": ids[n], "이름": one.get("이름") or "", "까닭": link.why(one)}
|
||||
| ({"견적": True} if (one.get("자원") or {}).get("갈래") == "고정" else {})
|
||||
| ({"종": mp.kind_of(one["자원"])} if (one.get("자원") or {}).get("재료찾기") else {})
|
||||
for n, one in enumerate(doc[KEY]["로직"].get("호표") or [])
|
||||
if not one.get("이음") and not one.get("참조") and not (one.get("자원") or {}).get("내기계")
|
||||
]
|
||||
"""이음 없는 자원 줄 `[{자리, 이름, 까닭, 견적?, 종?}]` — 불러올 때 문서 머리 목록(`Doc_Import.LIST`)
|
||||
가운데 아직 이음 없는 것(자리 = 가져온 줄 `호표:i`)."""
|
||||
first = (doc.get(KEY) or {}).get(FIRST)
|
||||
if not isinstance(first, dict):
|
||||
return []
|
||||
have = {v.get(FROM) for v in first.get("변수") or [] if _bare_value(v)}
|
||||
return [x for x in (first.get(KEY) or {}).get(LIST) or [] if x.get("자리") in have]
|
||||
|
||||
|
||||
# ── 셈 · 검산 ─────────────────────────────────────────────────────────
|
||||
FROM = "가져온줄" # `M02_San_ToDoc.FROM`
|
||||
LIST = "이음없음" # `M02_Doc_Import.LIST`
|
||||
XL = "엑셀" # `M02_Doc_Import.XL`
|
||||
|
||||
|
||||
def _bare_value(var: dict) -> bool:
|
||||
"""이음 없는 가져온 값 변수 — 숫자 연결(엑셀 값 그대로)."""
|
||||
return isinstance(var, dict) and (var.get("연결") or {}).get("갈래") == "숫자"
|
||||
|
||||
|
||||
# ── 검산(불러올 때 한 번 · 엑셀 단가 · 고침 없음) ────────────────────────
|
||||
def _json(value: Any) -> Any:
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
|
||||
return labor._json(value)
|
||||
|
||||
|
||||
class _One:
|
||||
"""M01 색인 위에 가져온 줄 하나 — `logic(키)` 만 가로챔(문서 변환 색인 · 그 밖 그대로)."""
|
||||
|
||||
def __init__(self, whole: Any, key: str, row: dict) -> None:
|
||||
self._whole, self._key, self._row = whole, key, row
|
||||
|
||||
def logic(self, ref: str) -> dict:
|
||||
return self._row if ref == self._key else self._whole.logic(ref)
|
||||
|
||||
def __getattr__(self, name: str) -> Any:
|
||||
return getattr(self._whole, name)
|
||||
|
||||
|
||||
def _doc_of(bare: dict, whole: Any) -> tuple[dict, list[str], dict]:
|
||||
"""검산 문서(855 2-C3) — 가져온 줄(엑셀 단가 · 고침 없음)을 줄 차례 그대로 문서로(다듬기 없음 ·
|
||||
금액 줄 k = 줄 정체 k) · 안쪽 산근 줄 = 형제 SK 연결(문서 셈 · 부르는 쪽 단가기준) →
|
||||
(문서, 줄 정체, {중간 이름: 기호})."""
|
||||
def _doc_of(row: dict, whole: Any) -> tuple[dict, list[str], dict]:
|
||||
"""검산 문서(855 2-C3 · 857-3b) — 가져온 줄(엑셀 단가 · 고침 없음)을 줄 차례 그대로 문서로
|
||||
(`M02_San_ToDoc` · 다듬기 없음 · 금액 줄 k = 줄 정체 k) · 안쪽 산근 줄 = 형제 SK 연결(문서 셈 ·
|
||||
부르는 쪽 단가기준) → (문서, 줄 정체, {중간 이름: 기호})."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_San_ToDoc as todoc
|
||||
|
||||
key = str(bare.get("키") or "SK-000000")
|
||||
row = {**row_of(bare), "키": key}
|
||||
row["호표"] = [dict(x) for x in row["호표"]]
|
||||
for item in row["호표"]: # 형제 SK 줄 = 아래에서 연결로 갈음 — 변환 자리값
|
||||
if item.get("참조") and item.get("값묶음") is None:
|
||||
item["값묶음"] = dict.fromkeys(COSTS, Decimal(0))
|
||||
master = _One(whole, key, row)
|
||||
doc, _ = dc.cv.convert(master, row, dc.given_of(master, key, bare.get("입력값")))
|
||||
bare = _dim().bare_row(row)
|
||||
doc, _ = todoc.build(bare, whole, {})
|
||||
by = {dc.md.var_id(v): v for v in doc.get("변수") or []}
|
||||
for item, line in zip(row["호표"], doc.get("금액") or []):
|
||||
for item, line in zip(bare["호표"], doc.get("금액") or []):
|
||||
var = by.get(str(line.get("단가") or "").removesuffix(".계"))
|
||||
if not item.get("참조") or var is None:
|
||||
continue
|
||||
@@ -386,11 +342,11 @@ def _doc_of(bare: dict, whole: Any) -> tuple[dict, list[str], dict]:
|
||||
line["단가"], line["비목"] = dc.md.var_id(var), item["참조비목"]
|
||||
var["연결"] = link
|
||||
mids = {str(v.get("열쇠")): dc.md.var_id(v) for v in doc.get("변수") or []}
|
||||
return doc, sd.line_ids(row), mids
|
||||
return doc, sd.line_ids(bare), mids
|
||||
|
||||
|
||||
def _run(doc: dict, whole: Any) -> dict:
|
||||
"""SK 셈(`to_price` 전 · 후 1 단위) — `Sangeun_Calc.run` 한 길(2-C1 몫 · 검산은 `_doc_of`)."""
|
||||
"""SK 셈(`to_price` 전 · 후 1 단위) — `Sangeun_Calc.run` 한 길(2-C1)."""
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
|
||||
return calc.run(sd.clean(doc, None, whole), whole)
|
||||
@@ -412,28 +368,23 @@ def _same(mine: Any, excel: Any) -> bool:
|
||||
return abs(Decimal(str(mine)) - want) < step
|
||||
|
||||
|
||||
def check(doc: dict, whole: Any = None) -> dict[str, Any]:
|
||||
"""검산 — 가져온 줄(엑셀 단가 · 고침 없음)을 문서 계산기로 다시 셈(855 2-C3 · 옛 엔진 안 돎) →
|
||||
엑셀 금액 · 글줄마다 맞댐(글줄 `자리` = 줄 정체 cid ↔ 검산 문서 금액 줄 같은 차례 · `mid:이름` =
|
||||
중간 변수 값 · `단계:이름` = 단계 계) · 못 셈 = {같음 False, 까닭}."""
|
||||
def check_row(row: dict, src: dict, head: dict, whole: Any = None) -> dict[str, Any]:
|
||||
"""검산 — 가져온 줄(엑셀 단가 · 고침 없음)을 문서 계산기로 다시 셈(855 2-C3) → 엑셀 금액 ·
|
||||
글줄마다 맞댐(글줄 `자리` = 줄 정체 cid ↔ 검산 문서 금액 줄 같은 차례 · `mid:이름` = 중간 변수 값 ·
|
||||
`단계:이름` = 단계 계) · 못 셈 = {같음 False, 까닭} · `head` = SK {키, 단위, 환산}(1 단위 배)."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
|
||||
whole = whole or _whole()
|
||||
meta = doc[KEY]
|
||||
bare = {k: doc.get(k) for k in ("키", "이름", "단위", "입력값", "환산")}
|
||||
bare |= {"바탕": None, KEY: {"로직": meta["로직"], "단가기준": "엑셀"}}
|
||||
src = meta.get("원본") or {}
|
||||
excel = src.get("엑셀금액") or {}
|
||||
sk = {"키": head.get("키") or "SK-000000", KEY: {"단가기준": "엑셀"}}
|
||||
try:
|
||||
bare = sd.clean(bare, None, whole)
|
||||
times = calc.ratio_of(bare, row_of(bare), whole) # 1 단위 = 문서 셈 ÷ 배(옛 `1단위`)
|
||||
times = calc.ratio_of(head, {"결과단위": row.get("결과단위")}, whole) # 1 단위 = 셈 ÷ 배
|
||||
except sd.DocError as e:
|
||||
return {"같음": False, "까닭": str(e), "셈": None, "엑셀": excel, "줄": []}
|
||||
try:
|
||||
mine_doc, ids, mids = _doc_of(bare, whole)
|
||||
got = dim.run(mine_doc, bare, whole)
|
||||
mine_doc, ids, mids = _doc_of(row, whole)
|
||||
got = _dim().run(mine_doc, sk, whole)
|
||||
except Exception as e: # noqa: BLE001 — 변환 · 셈 틀림 = 맞댈 값 없음
|
||||
got, ids, mids, mine_doc = {"셈됨": False, "까닭": str(e)}, [], {}, None
|
||||
money = dc.money(got) if got.get("셈됨") else None
|
||||
@@ -470,6 +421,25 @@ def check(doc: dict, whole: Any = None) -> dict[str, Any]:
|
||||
return _json({"같음": ok, "까닭": why, "셈": mine, "엑셀": excel, "줄": lines})
|
||||
|
||||
|
||||
def check(doc: dict, whole: Any = None) -> dict[str, Any]:
|
||||
"""검산 — 불러올 때 적은 것(가져온 줄은 저장 안 함 · 857-3b) · 이미 저장된 SK = 그 파일 것(화면 값
|
||||
안 받음) · 옛 꼴 = 까닭 하나."""
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
|
||||
if old_form(doc):
|
||||
return {"같음": False, "까닭": _dim().OLD_FORM, "셈": None, "엑셀": None, "줄": []}
|
||||
have = skc.stored_doc(doc.get("키"))
|
||||
if is_imported(have) and not old_form(have) and (have[KEY].get("검산")):
|
||||
return have[KEY]["검산"]
|
||||
return (doc.get(KEY) or {}).get("검산") or {
|
||||
"같음": False,
|
||||
"까닭": "검산 없음",
|
||||
"셈": None,
|
||||
"엑셀": None,
|
||||
"줄": [],
|
||||
}
|
||||
|
||||
|
||||
def _all_same(mine: dict, excel: dict) -> bool:
|
||||
return all(_same(mine.get(k), excel.get(k)) for k in excel)
|
||||
|
||||
@@ -539,6 +509,8 @@ def more(out: dict, clean_: dict) -> dict:
|
||||
def _need(doc: Any) -> dict:
|
||||
if not is_imported(doc):
|
||||
raise sd.DocError("가져온 식 단가산출 아님")
|
||||
if old_form(doc):
|
||||
raise sd.DocError(_dim().OLD_FORM)
|
||||
return doc
|
||||
|
||||
|
||||
@@ -553,64 +525,53 @@ def to_price(doc: Any, basis: str) -> dict[str, Any]:
|
||||
raise sd.DocError("단가기준은 엑셀 · 우리")
|
||||
whole = _whole()
|
||||
after = _with(doc, 단가기준=basis)
|
||||
before = _money(_run(doc, whole))
|
||||
return {
|
||||
"문서": after,
|
||||
"전": before,
|
||||
"전": _money(_run(doc, whole)),
|
||||
"후": _money(_run(after, whole)),
|
||||
"이음없음": unlinked(doc),
|
||||
}
|
||||
|
||||
|
||||
def link(doc: Any, spot: str, key: Any) -> dict[str, Any]:
|
||||
"""자원 줄 이음 고름 — 그 줄 `이음` · 줄 정체가 바뀐 만큼 덮개 · 뺀줄 · 글줄 · 까닭 열쇠
|
||||
옮김."""
|
||||
doc = _need(doc)
|
||||
whole = _whole()
|
||||
old = sd.line_ids(row_of(doc))
|
||||
if spot not in old[: len(doc[KEY]["로직"]["호표"])]:
|
||||
raise sd.DocError(f"없는 자원 줄 「{spot}」")
|
||||
items = [dict(x) for x in doc[KEY]["로직"]["호표"]]
|
||||
at = old.index(spot)
|
||||
items[at]["이음"] = _link(key, items[at]["종류"], f"「{spot}」", whole)
|
||||
after = _with(doc, 로직={**doc[KEY]["로직"], "호표": items})
|
||||
move = dict(zip(old, sd.line_ids(row_of(after))))
|
||||
return {"문서": _rekey(after, {a: b for a, b in move.items() if a != b})}
|
||||
def docs_of(doc: dict) -> list[dict]:
|
||||
"""가져온 줄 고침을 얹을 문서 — 불러온 그대로(`가져온.문서`) + 줄 쌓기 따로 사본(있으면 · 같은 기호)."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
|
||||
|
||||
def _rekey(doc: dict, move: dict) -> dict:
|
||||
if not move:
|
||||
return doc
|
||||
out = dict(doc)
|
||||
for name in _KEYED:
|
||||
if isinstance(doc.get(name), dict):
|
||||
out[name] = {move.get(c, c): v for c, v in doc[name].items()}
|
||||
if isinstance(doc.get("뺀줄"), list):
|
||||
out["뺀줄"] = [move.get(c, c) for c in doc["뺀줄"]]
|
||||
if isinstance(doc.get("글줄"), list):
|
||||
out["글줄"] = [{**t, "자리": move.get(t.get("자리"), t.get("자리"))} for t in doc["글줄"]]
|
||||
out["더한줄"] = [_rate_rekey(x, move) for x in doc.get("더한줄") or []]
|
||||
src = doc[KEY].get("원본") or {}
|
||||
if src.get("글줄"):
|
||||
lines = [
|
||||
{**t, "자리": move.get(t.get("자리"), t.get("자리"))}
|
||||
| ({"자리들": [move.get(x, x) for x in t["자리들"]]} if t.get("자리들") else {})
|
||||
for t in src["글줄"]
|
||||
]
|
||||
out[KEY] = {**out[KEY], "원본": {**src, "글줄": lines}}
|
||||
out = [doc[KEY][FIRST]]
|
||||
got = doc.get(dc.KEY) if isinstance(doc.get(dc.KEY), dict) else {}
|
||||
if got.get("따로") and isinstance(got.get("문서"), dict):
|
||||
out.append(got["문서"])
|
||||
return out
|
||||
|
||||
|
||||
def _rate_rekey(one: Any, move: dict) -> Any:
|
||||
"""율 더한줄 기준 줄 목록(778-4 · `열쇠@비목`) 열쇠 옮김."""
|
||||
rate = ((one.get("고정") or {}).get("비율") or {}) if isinstance(one, dict) else {}
|
||||
if not isinstance(rate.get("기준"), list):
|
||||
return one
|
||||
keys = []
|
||||
for k in rate["기준"]:
|
||||
head, _, part = str(k).partition("@")
|
||||
keys.append(move.get(head, head) + (f"@{part}" if part else ""))
|
||||
return {**one, "고정": {**one["고정"], "비율": {**rate, "기준": keys}}}
|
||||
def link(doc: Any, spot: str, key: Any) -> dict[str, Any]:
|
||||
"""이음 없는 자원 줄 이음 고름(857-3b) — 그 가져온 줄 값 변수 연결 = 고른 이음(엑셀 값 기억) ·
|
||||
자리 = 가져온 줄 `호표:i`(문서 머리 `이음없음`)."""
|
||||
dim = _dim()
|
||||
doc = cp.deepcopy(_need(doc))
|
||||
first = doc[KEY][FIRST]
|
||||
var = next((v for v in first.get("변수") or [] if v.get(FROM) == spot), None)
|
||||
line = next((x for x in first.get("금액") or [] if x.get(FROM) == spot), None)
|
||||
if var is None or line is None:
|
||||
raise sd.DocError(f"없는 자원 줄 「{spot}」")
|
||||
kind = str(line.get("가져온종류") or "")
|
||||
code = _link(key, kind, f"「{spot}」", _whole())
|
||||
if code is None:
|
||||
raise sd.DocError(f"「{spot}」 · 이음 키 없음")
|
||||
item = {"이음": code, "종류": kind, "비목": line.get("비목"), "단위": line.get("단위")}
|
||||
got, note = dim._link_of(item)
|
||||
if got is None:
|
||||
raise sd.DocError(f"「{spot}」 · {note or '이을 수 없음'}")
|
||||
sym, opt = dim.dc.md.var_id(var), got.pop(dim.OPTION, None)
|
||||
for one in docs_of(doc):
|
||||
mine = next((v for v in one.get("변수") or [] if dim.dc.md.var_id(v) == sym), None)
|
||||
if mine is None or not _bare_value(mine):
|
||||
continue
|
||||
if opt and opt["열쇠"] not in {v.get("열쇠") for v in one["변수"]}:
|
||||
one["변수"].append(opt)
|
||||
mine["연결"] = {**cp.deepcopy(got), XL: mine["연결"].get("값")}
|
||||
mine.pop("설명", None) if not note else mine.__setitem__("설명", note)
|
||||
return {"문서": doc}
|
||||
|
||||
|
||||
# ── 만들기(개인 층) ───────────────────────────────────────────────────
|
||||
@@ -618,37 +579,43 @@ def create(
|
||||
logic: Any, source: Any, name: str = "", unit: str = "", head: dict | None = None,
|
||||
new: bool = False, use: str | None = None,
|
||||
) -> dict[str, Any]: # fmt: skip
|
||||
"""엔진 로직 줄 + 원본 → 지금 층 새 가져온 식 SK — 서버가 다시 셈해 엑셀과 맞댐(검산 ·
|
||||
다르면 `같음` False 로 표지 · 막지 않음) · 같은 층 같은 내용 = 409(`ask` · 733-2) ·
|
||||
서버 길(POST sangeun/imported)은 853-3 에서 걷음 — 시험이 가져온 식 SK 바탕으로 씀."""
|
||||
"""가져온 줄 + 원본 → 지금 층 새 가져온 식 SK(불러온 그대로 문서 · 검산) · 같은 층 같은 내용 = 409
|
||||
(`ask` · 733-2)."""
|
||||
return keep(new_doc(logic, source, name, unit, head), new, use)
|
||||
|
||||
|
||||
def new_doc(
|
||||
logic: Any, source: Any, name: str = "", unit: str = "", head: dict | None = None
|
||||
) -> dict[str, Any]:
|
||||
"""가져온 식 SK 문서(키 없음 · 층에 안 씀)."""
|
||||
row = clean_row(logic, _whole())
|
||||
"""가져온 식 SK 문서(키 없음 · 층에 안 씀) — 불러온 그대로 문서를 한 번 지음(857-3b · 가져온 줄 안 둠)."""
|
||||
whole = _whole()
|
||||
row = clean_row(logic, whole)
|
||||
unit = str(unit or "").strip() or row["결과단위"].split("/", 1)[1]
|
||||
doc = {"키": "SK-000000", "이름": str(name or "").strip() or row["이름"], "단위": unit}
|
||||
doc |= {k: str((head or {}).get(k) or "") for k in ("구분", "상세구분")}
|
||||
doc |= {"바탕": None, "입력값": {}, "덮개": {}, "뺀줄": [], "더한줄": []}
|
||||
meta = {"로직": row, "단가기준": "엑셀"}
|
||||
if source not in (None, {}):
|
||||
meta["원본"] = _meta(source, "원본")
|
||||
doc[KEY] = meta
|
||||
raw = _meta(source, "원본") if source not in (None, {}) else {}
|
||||
src = _named(raw, row) if raw else {} # 글줄 자리 = 줄 정체 cid(검산 · 셈 답 맞댐)
|
||||
first = _norm(_dim().build(row, raw, whole)) # 다듬기 = 글줄 자리 이름 그대로(704) · JSON 꼴
|
||||
meta = {FIRST: first, "단가기준": "엑셀", "검산": check_row(row, src, doc, whole)}
|
||||
doc[KEY] = meta | ({"원본": src} if src else {})
|
||||
return doc
|
||||
|
||||
|
||||
def _norm(doc: dict) -> dict:
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
|
||||
return json.loads(json.dumps(dc.ml._norm(doc), ensure_ascii=False, default=str))
|
||||
|
||||
|
||||
def keep(doc: dict, new: bool = False, use: str | None = None) -> dict[str, Any]:
|
||||
"""문서 → 지금 층 SK(같은 내용 = 409 · `use` = 그것을 씀 · 안 씀)."""
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Library_Ask as ask
|
||||
|
||||
whole = _whole()
|
||||
got = check(sd.clean(doc, None, whole), whole)
|
||||
key = ask.ask(sd.KIND, doc, new, use) or refs.create(sd.KIND, doc)["이름"]
|
||||
return {"이름": key, "검산": got, "단가기준": (doc.get(KEY) or {}).get("단가기준") or "엑셀"}
|
||||
meta = doc.get(KEY) or {}
|
||||
return {"이름": key, "검산": check(doc), "단가기준": meta.get("단가기준") or "엑셀"}
|
||||
|
||||
|
||||
def draft(doc: dict) -> dict[str, Any]:
|
||||
@@ -657,8 +624,6 @@ def draft(doc: dict) -> dict[str, Any]:
|
||||
from M02_MasterTemplete import M02_Library_Ask as ask
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
|
||||
whole = _whole()
|
||||
got = check(sd.clean(doc, None, whole), whole)
|
||||
try:
|
||||
ask.ask(sd.KIND, doc)
|
||||
same = None
|
||||
@@ -667,4 +632,54 @@ def draft(doc: dict) -> dict[str, Any]:
|
||||
if e.status != 409 or not rows:
|
||||
raise
|
||||
same = rows[0]["키"]
|
||||
return {"문서": refs.clean_doc(sd.KIND, doc), "검산": got, "같은것": same}
|
||||
return {"문서": refs.clean_doc(sd.KIND, doc), "검산": check(doc), "같은것": same}
|
||||
|
||||
|
||||
# ── 산근 속 산근 참조(797-1 · `M02_Labor_Ref`) ──────────────────────────
|
||||
def refs_of(doc: Any) -> list[dict]:
|
||||
"""가져온 식이 부르는 형제 SK 참조 `[{층, 주인, 키}]` — 불러온 그대로 · 따로 사본 문서의 단가산출 연결."""
|
||||
if not is_imported(doc) or old_form(doc):
|
||||
return []
|
||||
out = []
|
||||
for one in docs_of(doc):
|
||||
for var in one.get("변수") or []:
|
||||
link = var.get("연결") or {}
|
||||
if link.get("갈래") == "단가산출" and isinstance(link.get("참조"), dict):
|
||||
out.append({**link["참조"], "키": link.get("키")})
|
||||
return out
|
||||
|
||||
|
||||
def move_refs(doc: dict, move: Any) -> dict:
|
||||
"""형제 SK 참조 자리를 `move(참조) → 새 참조` 로(층 옮김 · 복사) — 문서 사본을 고침."""
|
||||
if not is_imported(doc) or old_form(doc):
|
||||
return doc
|
||||
doc = cp.deepcopy(doc)
|
||||
for one in docs_of(doc):
|
||||
for var in one.get("변수") or []:
|
||||
link = var.get("연결") or {}
|
||||
if link.get("갈래") == "단가산출" and isinstance(link.get("참조"), dict):
|
||||
new = move({**link["참조"], "키": link.get("키")})
|
||||
link["키"], link["참조"] = new["키"], {k: new.get(k) for k in ("층", "주인")}
|
||||
return doc
|
||||
|
||||
|
||||
def reach_of(doc: Any) -> tuple[list[str], list[str]]:
|
||||
"""값 사본이 닿을 것(`M02_Sangeun_Copy.stamp`) — 문서 연결의 (단가산출 키, 요소 키) ·
|
||||
형제 SK · 입력 든 키(유가 지역 등) 뺌."""
|
||||
if not is_imported(doc) or old_form(doc):
|
||||
return [], []
|
||||
keys, links = [], []
|
||||
for one in docs_of(doc):
|
||||
for var in one.get("변수") or []:
|
||||
link = var.get("연결") or {}
|
||||
key = str(link.get("키") or "")
|
||||
if not key or "{" in key or key.startswith("SK-"):
|
||||
continue
|
||||
if link.get("갈래") == "단가산출":
|
||||
keys.append(key)
|
||||
elif link.get("갈래") == "요소":
|
||||
links.append(key)
|
||||
for one_ in (one.get(KEY) or {}).get("기계") or []: # 시간당 연결 기계 = 판정 키(EQ)
|
||||
if str(one_.get("키") or "")[:2] == "EQ":
|
||||
links.append(str(one_["키"]))
|
||||
return list(dict.fromkeys(keys)), list(dict.fromkeys(links))
|
||||
|
||||
@@ -8,8 +8,9 @@
|
||||
이름 문맥이 없어 자리 아님). 일반 수(1 · 10 · 60 · 100 · 1000 · 8) · 비교 글자 · 찾기 · 로직 부름
|
||||
인자는 안 셈.
|
||||
- 고름 = 엑셀 수와 표 칸 값이 같을 때만(같은 값 · 율 ↔ 소수 · t ↔ kg) — 다르면 못 고름 + 까닭.
|
||||
기록(`가져온.연결` = {고름 [..], 버림 [..]})만 — 셈 · 금액 · 엔진 안 건드림 · [단가 갱신]은 자원
|
||||
단가만(요구 656-1) · [재생성]이 이 기록을 따라가는 길은 아직 없음(기록만).
|
||||
기록(`가져온.연결` = {고름 [..], 버림 [..]}) + 문서 고침(857-3b) — 그 금액 줄 식의 그 수 자리 = 표 연결
|
||||
변수(`소요량k` · 엑셀 칸 값 기억 · 금액 그대로) · 풂 = 수로 되돌림 · 자리 = 불러올 때 문서 머리
|
||||
`가져온.자리`(가져온 줄 수 차례 · 앞 수 `앞` → 문서 식 수 차례로 맞춤).
|
||||
- 고름 = {자리, 수, 층 「M01」, 표, 줄, 칸, 값, 꼴 eq|pct|kgt} · 로직이 바뀌어 자리의 수가 달라지면
|
||||
그 기록은 버려진 것으로 보고 화면에 안 내놓음.
|
||||
|
||||
@@ -18,12 +19,14 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy as cp
|
||||
import re
|
||||
from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from M02_MasterTemplete import M02_San_Basis_Index as bi
|
||||
from M02_MasterTemplete import M02_San_Emit as em
|
||||
from M02_MasterTemplete import M02_San_ToDoc as todoc
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
||||
|
||||
@@ -40,19 +43,22 @@ def _flat(s: Any) -> str:
|
||||
return re.sub(r"[^가-힣A-Za-z0-9]", "", str(s or ""))
|
||||
|
||||
|
||||
CMP = ("<=", ">=", "==", "!=", "<", ">") # 비교 글자
|
||||
|
||||
|
||||
def _literals(node: Any, out: list[Decimal]) -> None:
|
||||
"""식 나무 → 수 글자(차례대로) — 비교 글자 · 찾기 · 로직 부름 인자는 뺌."""
|
||||
"""식 나무(문서 파서) → 수 글자(차례대로) — 비교 글자는 뺌."""
|
||||
if not isinstance(node, tuple):
|
||||
return
|
||||
kind = node[0]
|
||||
if kind == "num":
|
||||
out.append(node[1])
|
||||
elif kind == "bin":
|
||||
cmp_ = node[1] in bi.mf._OPS
|
||||
cmp_ = node[1] in CMP
|
||||
for side in node[2:]:
|
||||
if not (cmp_ and isinstance(side, tuple) and side[0] == "num"):
|
||||
_literals(side, out)
|
||||
elif kind in ("neg", "field"):
|
||||
elif kind in ("neg", "pct", "field"):
|
||||
_literals(node[1], out)
|
||||
elif kind == "call":
|
||||
for arg in node[2]:
|
||||
@@ -62,8 +68,8 @@ def _literals(node: Any, out: list[Decimal]) -> None:
|
||||
def literals(text: Any) -> list[Decimal]:
|
||||
out: list[Decimal] = []
|
||||
try:
|
||||
_literals(bi.mf.parse(str(text)), out)
|
||||
except bi.mf.FormulaError:
|
||||
_literals(todoc.md.parse(str(text)), out)
|
||||
except todoc.md.DocError:
|
||||
pass
|
||||
return out
|
||||
|
||||
@@ -76,12 +82,14 @@ def slots(row: dict) -> list[dict]:
|
||||
if not isinstance(one, dict):
|
||||
continue
|
||||
labor = kind == "호표" and one.get("종류") == "인력"
|
||||
for n, x in enumerate(literals(one.get(field))):
|
||||
nums = literals(one.get(field))
|
||||
for n, x in enumerate(nums):
|
||||
if float(x) in GENERAL:
|
||||
continue
|
||||
out.append(
|
||||
{
|
||||
"자리": f"{kind}:{i}:{n}",
|
||||
"앞": [str(v) for v in nums[:n]],
|
||||
"갈래": kind,
|
||||
"종류": str(one.get("종류") or ""),
|
||||
"줄": str(one.get("이름") or ""),
|
||||
@@ -218,11 +226,16 @@ def tally(scanned: list[dict]) -> dict[str, int]:
|
||||
|
||||
# ── 고름 · 버림(문서 기록) ─────────────────────────────────────────────
|
||||
def _need(doc: Any) -> dict:
|
||||
if not imp.is_imported(doc):
|
||||
raise sd.DocError("가져온 식 단가산출만")
|
||||
if not imp.is_imported(doc) or imp.old_form(doc):
|
||||
raise sd.DocError("가져온 식 단가산출만(옛 꼴 = 다시 불러오기)")
|
||||
return doc
|
||||
|
||||
|
||||
def _slots(doc: dict) -> list[dict]:
|
||||
"""불러올 때 적은 자리(문서 머리 `가져온.자리`)."""
|
||||
return list(((doc[imp.KEY][imp.FIRST].get(imp.KEY) or {}).get("자리")) or [])
|
||||
|
||||
|
||||
def _state(doc: dict) -> dict[str, list]:
|
||||
meta = doc[imp.KEY].get(KEY) or {}
|
||||
return {"고름": list(meta.get("고름") or []), "버림": list(meta.get("버림") or [])}
|
||||
@@ -238,18 +251,18 @@ def view(doc: Any, idx: bi.Index | None = None) -> dict[str, Any]:
|
||||
"""화면 답 — 자리마다 {자리, 줄, 수, 단위, 후보수, 후보, 상태 후보|없음|고름|버림, 고른}."""
|
||||
doc = _need(doc)
|
||||
state, rows = _state(doc), []
|
||||
scanned = scan(doc[imp.KEY]["로직"], idx)
|
||||
idx = idx or bi.get()
|
||||
title = str(doc[imp.KEY][imp.FIRST].get("이름") or "")
|
||||
scanned = [{**s, "후보": find(idx, s, title)} for s in _slots(doc)]
|
||||
picked = {x["자리"]: x for x in state["고름"] if x.get("수") is not None}
|
||||
dropped = set(state["버림"])
|
||||
for s in scanned:
|
||||
mine = picked.get(s["자리"])
|
||||
if mine and abs(mine["수"] - s["수"]) > 1e-12:
|
||||
mine = None # 로직이 바뀜 — 옛 기록 안 씀
|
||||
if mine: # M01 칸 값이 그새 바뀌었으면 알림(기록은 그대로)
|
||||
now = next(
|
||||
(
|
||||
c["v"]
|
||||
for c in (idx or bi.get()).cells_of_table.get(mine["표"], [])
|
||||
for c in idx.cells_of_table.get(mine["표"], [])
|
||||
if c["줄"] == mine["줄"] and c["칸"] == mine["칸"]
|
||||
),
|
||||
None,
|
||||
@@ -284,10 +297,11 @@ def view(doc: Any, idx: bi.Index | None = None) -> dict[str, Any]:
|
||||
|
||||
|
||||
def pick(doc: Any, spot: str, cell: dict, idx: bi.Index | None = None) -> dict[str, Any]:
|
||||
"""후보 칸 고름 — 엑셀 수 = 칸 값일 때만(다르면 400 까닭) · 기록만 · 금액 그대로."""
|
||||
doc = _need(doc)
|
||||
"""후보 칸 고름 — 엑셀 수 = 칸 값일 때만(다르면 400 까닭) · 기록 + 문서 그 수 자리 = 표 연결 변수
|
||||
(엑셀 칸 값 기억 · 금액 그대로)."""
|
||||
doc = cp.deepcopy(_need(doc))
|
||||
idx = idx or bi.get()
|
||||
slot = next((s for s in slots(doc[imp.KEY]["로직"]) if s["자리"] == spot), None)
|
||||
slot = next((s for s in _slots(doc) if s["자리"] == spot), None)
|
||||
if slot is None:
|
||||
raise sd.DocError(f"없는 자리 「{spot}」")
|
||||
table = idx.tables.get(str((cell or {}).get("표")))
|
||||
@@ -318,6 +332,11 @@ def pick(doc: Any, spot: str, cell: dict, idx: bi.Index | None = None) -> dict[s
|
||||
"값": found["v"],
|
||||
"꼴": how,
|
||||
}
|
||||
conds = _conds(table, at)
|
||||
for target in imp.docs_of(doc):
|
||||
_unpick(target, spot)
|
||||
if conds is not None:
|
||||
_apply(target, slot, one, conds)
|
||||
state = _state(doc)
|
||||
state["고름"] = [x for x in state["고름"] if x.get("자리") != spot] + [one]
|
||||
state["버림"] = [x for x in state["버림"] if x != spot]
|
||||
@@ -325,33 +344,151 @@ def pick(doc: Any, spot: str, cell: dict, idx: bi.Index | None = None) -> dict[s
|
||||
|
||||
|
||||
def drop(doc: Any, spot: str, undo: bool = False) -> dict[str, Any]:
|
||||
"""자리 후보 버림(또는 [되돌리기]) — 고른 것이 있으면 같이 풂 · 기록만."""
|
||||
doc = _need(doc)
|
||||
if not any(s["자리"] == spot for s in slots(doc[imp.KEY]["로직"])):
|
||||
"""자리 후보 버림(또는 [되돌리기]) — 고른 것이 있으면 같이 풂(문서 수 되돌림)."""
|
||||
doc = cp.deepcopy(_need(doc))
|
||||
if not any(s["자리"] == spot for s in _slots(doc)):
|
||||
raise sd.DocError(f"없는 자리 「{spot}」")
|
||||
for target in imp.docs_of(doc):
|
||||
_unpick(target, spot)
|
||||
state = _state(doc)
|
||||
state["고름"] = [x for x in state["고름"] if x.get("자리") != spot]
|
||||
state["버림"] = [x for x in state["버림"] if x != spot] + ([] if undo else [spot])
|
||||
return {"문서": _with(doc, state)}
|
||||
|
||||
|
||||
def tidy(raw: Any, row: dict) -> dict[str, list]:
|
||||
"""저장 때 서버가 다시 거름(`M02_Sangeun_Imported.clean`) — 자리가 있고 수가 같은 기록만 ·
|
||||
칸 값 대조는 고를 때(`pick`)만(M01 이 바뀌었으면 화면이 알림)."""
|
||||
have = {s["자리"]: s["수"] for s in slots(row)}
|
||||
raw = raw if isinstance(raw, dict) else {}
|
||||
keep = ("자리", "수", "층", "표", "줄", "칸", "값", "꼴")
|
||||
picked = []
|
||||
for x in raw.get("고름") or []:
|
||||
if not (isinstance(x, dict) and x.get("자리") in have and x.get("꼴") in FORMS):
|
||||
# ── 문서 고침(857-3b) — 그 수 자리 ↔ 표 연결 변수 ─────────────────────────
|
||||
SPOT = "가져온자리" # 고른 칸 변수 — 자리 · 되돌릴 수 글
|
||||
SCALE = {"eq": (1,), "pct": (100, 0.01), "kgt": (1000, 0.001)}
|
||||
|
||||
|
||||
def _field(spot: str) -> str:
|
||||
return "수량" if spot.startswith("호표:") else "단가"
|
||||
|
||||
|
||||
def _line_of(doc: dict, spot: str) -> dict | None:
|
||||
head = spot.rsplit(":", 1)[0]
|
||||
return next((x for x in doc.get("금액") or [] if x.get(todoc.FROM) == head), None)
|
||||
|
||||
|
||||
def _doc_nth(node: Any, before: list[str]) -> int | None:
|
||||
"""가져온 줄 n 번째 수(앞 수 `before`) → 문서 식 수 차례 — 문서 = 가져온 줄 수에서 군더더기
|
||||
(0 · 1 · 100)만 빠진 차례."""
|
||||
doc_nums: list[Decimal] = []
|
||||
_literals(node, doc_nums)
|
||||
j = 0
|
||||
for v in (Decimal(x) for x in before):
|
||||
if j < len(doc_nums) and doc_nums[j] == v:
|
||||
j += 1
|
||||
return j if j < len(doc_nums) else None
|
||||
|
||||
|
||||
def _swap(node: Any, n: int, new: tuple, seen: list) -> Any:
|
||||
"""`_literals` 차례의 n 번째 수 → `new` 마디."""
|
||||
if not isinstance(node, tuple):
|
||||
return node
|
||||
kind = node[0]
|
||||
if kind == "num":
|
||||
seen[0] += 1
|
||||
return new if seen[0] - 1 == n else node
|
||||
if kind == "bin":
|
||||
cmp_ = node[1] in CMP
|
||||
sides = [
|
||||
side if cmp_ and side[0] == "num" else _swap(side, n, new, seen) for side in node[2:]
|
||||
]
|
||||
return (kind, node[1], *sides)
|
||||
if kind in ("neg", "pct", "field"):
|
||||
return (kind, _swap(node[1], n, new, seen), *node[2:])
|
||||
if kind == "call":
|
||||
return ("call", node[1], [_swap(a, n, new, seen) for a in node[2]])
|
||||
return node
|
||||
|
||||
|
||||
def _conds(table: dict, at: int) -> dict | None:
|
||||
"""표 줄 차례 → 그 줄 하나만 맞는 조건 {조건: 값}(범위 = 위 끝 › 아래 끝) · 못 가림 = None."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
|
||||
rows = table.get("줄") or []
|
||||
if not (0 <= at < len(rows)):
|
||||
return None
|
||||
row, out = rows[at], {}
|
||||
for cond, how in (table.get("조건") or {}).items():
|
||||
if cond not in row:
|
||||
continue
|
||||
num = x.get("수")
|
||||
if (
|
||||
isinstance(num, (int, float))
|
||||
and abs(num - have[x["자리"]]) <= 1e-12
|
||||
and x.get("층") == LAYER
|
||||
):
|
||||
picked.append({k: x[k] for k in keep if k in x})
|
||||
done = {p["자리"] for p in picked}
|
||||
gone = [x for x in raw.get("버림") or [] if isinstance(x, str) and x in have and x not in done]
|
||||
return {k: v for k, v in (("고름", picked), ("버림", gone)) if v}
|
||||
have = row[cond]
|
||||
if how == "범위":
|
||||
low, high = have
|
||||
have = high if high is not None else low
|
||||
if have is None:
|
||||
return None
|
||||
out[cond] = have
|
||||
try:
|
||||
hit = dc.ml.find(table, out)
|
||||
except Exception: # noqa: BLE001 — 못 가림 = 수 그대로
|
||||
return None
|
||||
return out if hit is row else None
|
||||
|
||||
|
||||
def _times(one: dict, m: float) -> bool:
|
||||
"""칸 값 = 엑셀 수 × 배 m."""
|
||||
cell, v = float(one.get("값") or 0), float(one.get("수") or 0)
|
||||
return abs(cell - v * m) <= 1e-9 * max(1.0, abs(cell))
|
||||
|
||||
|
||||
def _apply(doc: dict, slot: dict, one: dict, conds: dict) -> None:
|
||||
"""문서 그 금액 줄 식의 그 수 → 표 연결 변수(÷ 배) · 줄 · 수가 안 맞으면 그대로(기록만)."""
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||||
|
||||
spot = slot["자리"]
|
||||
line, field = _line_of(doc, spot), _field(spot)
|
||||
if line is None:
|
||||
return
|
||||
try:
|
||||
node = todoc.md.parse(str(line.get(field)))
|
||||
except todoc.md.DocError:
|
||||
return
|
||||
n = _doc_nth(node, list(slot.get("앞") or []))
|
||||
nums: list[Decimal] = []
|
||||
_literals(node, nums)
|
||||
scale = next((m for m in SCALE.get(str(one["꼴"]), (1,)) if _times(one, m)), None)
|
||||
if n is None or float(nums[n]) != float(slot["수"]) or scale is None:
|
||||
return
|
||||
taken = {str(v.get("열쇠")) for v in doc.get("변수") or []}
|
||||
taken |= {todoc.md.var_id(v) for v in doc.get("변수") or []}
|
||||
name = next(f"{dim.PICK}{k}" for k in range(1, 999) if f"{dim.PICK}{k}" not in taken)
|
||||
ref = ("var", name) if scale == 1 else ("bin", "/", ("var", name), ("num", Decimal(str(scale))))
|
||||
line[field] = todoc.md.text_of(_swap(node, n, ref, [0]))
|
||||
link = {"갈래": "표", "표": str(one["표"]), "조건": {k: dim._lit(v) for k, v in conds.items()}}
|
||||
link |= {"칸": str(one["칸"]), dim.XL: Decimal(str(one["값"]))}
|
||||
var = {"열쇠": name, "기호": name, "아래": "", "위": "", "이름": name, "단위": "", "연결": link}
|
||||
doc.setdefault("변수", []).append(var | {SPOT: {"자리": spot, "수": str(nums[n])}})
|
||||
|
||||
|
||||
def _unpick(doc: dict, spot: str) -> None:
|
||||
"""그 자리 고른 칸 변수 → 원래 수로 되돌림 · 변수 지움."""
|
||||
mine = [v for v in doc.get("변수") or [] if (v.get(SPOT) or {}).get("자리") == spot]
|
||||
if not mine:
|
||||
return
|
||||
line, field = _line_of(doc, spot), _field(spot)
|
||||
for var in mine:
|
||||
name, num = todoc.md.var_id(var), ("num", Decimal(var[SPOT]["수"]))
|
||||
if line is not None:
|
||||
try:
|
||||
node = todoc.md.parse(str(line.get(field)))
|
||||
line[field] = todoc.md.text_of(_back(node, name, num))
|
||||
except todoc.md.DocError:
|
||||
pass
|
||||
doc["변수"] = [v for v in doc["변수"] if v is not var]
|
||||
|
||||
|
||||
def _back(node: Any, name: str, num: tuple) -> Any:
|
||||
if not isinstance(node, tuple):
|
||||
return node
|
||||
if node == ("var", name) or (node[0] == "bin" and node[1] == "/" and node[2] == ("var", name)):
|
||||
return num
|
||||
if node[0] == "bin":
|
||||
return ("bin", node[1], _back(node[2], name, num), _back(node[3], name, num))
|
||||
if node[0] in ("neg", "pct", "field"):
|
||||
return (node[0], _back(node[1], name, num), *node[2:])
|
||||
if node[0] == "call":
|
||||
return ("call", node[1], [_back(a, name, num) for a in node[2]])
|
||||
return node
|
||||
|
||||
@@ -18,7 +18,10 @@ export interface CheckLine {
|
||||
|
||||
/** SK 문서 덧칸 `가져온` */
|
||||
export interface ImportedMeta {
|
||||
로직?: { 이름?: string; 호표?: { 이름?: string; 이음?: string | null }[] };
|
||||
/** 불러온 그대로 수식 문서(857-3b · 정본) */
|
||||
문서?: Record<string, unknown>;
|
||||
/** 옛 꼴(857-3b 앞 저장본 — 읽지 않음) */
|
||||
로직?: unknown;
|
||||
단가기준?: "엑셀" | "우리";
|
||||
원본?: {
|
||||
파일?: string;
|
||||
@@ -50,7 +53,12 @@ export interface ImportedDoc {
|
||||
}
|
||||
|
||||
/** 가져온 식(경쟁사 로직이 든 SK) */
|
||||
export const isImported = (d: ImportedDoc | null | undefined): boolean => !!d?.가져온?.로직;
|
||||
export const isImported = (d: ImportedDoc | null | undefined): boolean =>
|
||||
!!(d?.가져온?.문서 || d?.가져온?.로직);
|
||||
|
||||
/** 857-3b 앞 옛 꼴 저장본(읽지 않음 · 다시 불러오기) */
|
||||
export const isOldForm = (d: ImportedDoc | null | undefined): boolean =>
|
||||
!!d?.가져온?.로직 && !d?.가져온?.문서;
|
||||
|
||||
/** 검산 다른 줄 */
|
||||
export const wrongLines = (d: ImportedDoc): CheckLine[] =>
|
||||
|
||||
@@ -7,6 +7,8 @@
|
||||
* ========================================================================== */
|
||||
|
||||
export interface OriginMeta {
|
||||
/** 불러온 그대로 문서(857-3b) · 옛 꼴 = 로직 */
|
||||
문서?: unknown;
|
||||
로직?: unknown;
|
||||
원본?: {
|
||||
파일?: string;
|
||||
@@ -84,7 +86,7 @@ const localTime = (s?: string): string => {
|
||||
|
||||
/** 가져온 식이 아니면 null */
|
||||
export function originOf(meta: OriginMeta | null | undefined): Origin | null {
|
||||
if (!meta?.로직 || !meta.원본) return null;
|
||||
if (!(meta?.문서 || meta?.로직) || !meta.원본) return null;
|
||||
const src = meta.원본;
|
||||
const code = src.코드 ?? "";
|
||||
const block = src.갈래 === "EST" && code !== "" ? `단산${code}` : String(code);
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
"""857-0 지킴 도우미 — 불러오기 지문(블록 × 두 판 · 검산 · 이음 / 엑셀 올림 · 호표 목록 · 칠 ·
|
||||
고정 줄 / 재료 이음 표).
|
||||
|
||||
- 블록 = 견본(원파일 EST · STC · 실무 엑셀)마다 `Doc_FromNative.emit` → 가져온 식 SK(저장 없음) →
|
||||
- 블록 = 견본(원파일 EST · STC · 실무 엑셀)마다 `Doc_FromNative.emit` → 가져온 식 SK(`new_doc` · 저장 없음) →
|
||||
엑셀 판 · 우리 판 문서 셈(`Doc_Import.derive` + `run`) 노 · 재 · 경 · 계 +
|
||||
검산(`Sangeun_Imported.check` 같음 · 줄 같음 수) + 줄마다 이음(종류 · 이음 · 기계 찾기 ·
|
||||
재료 찾기 판정 · 키).
|
||||
@@ -143,12 +143,9 @@ def block(saved: dict, no: int) -> dict:
|
||||
out = fn.emit(saved, no)
|
||||
row = out["로직"]
|
||||
sk = {
|
||||
**imp.new_doc(row, out["원본"], row["이름"]),
|
||||
"키": "SK-999999",
|
||||
"이름": row["이름"],
|
||||
"단위": str(row.get("결과단위", "/")).split("/", 1)[-1],
|
||||
}
|
||||
sk |= {"바탕": None, "입력값": {}, "덮개": {}, "뺀줄": [], "더한줄": []}
|
||||
sk[imp.KEY] = {"로직": row, "원본": out["원본"], "단가기준": "엑셀"}
|
||||
} # 857-3b 불러온 그대로 문서
|
||||
sk = sd.clean(sk, None, whole)
|
||||
got: dict[str, Any] = {"이음": _links(row)}
|
||||
for basis in ("엑셀", "우리"):
|
||||
|
||||
@@ -181,10 +181,13 @@ def test_실무_가져온_식_SK_대가_내역_엑셀(tag, code, world):
|
||||
whole = m01.loaded()[1]
|
||||
rid = "project||SK-990001"
|
||||
frozen = item_sk.freeze({rid: sd.clean(doc, None, whole)})[rid]
|
||||
key, row = frozen["바탕"]["로직"], json.loads(json.dumps(frozen[item_sk.ROW]))
|
||||
assert ms_uses(row) # 새 의미 로직(줄 자리 · 번지 · 단계)
|
||||
books = {"labor": [], "material": [], "machine": [], "gaps": []} # 엑셀 단가 = 고정 줄
|
||||
got = _daega(sc._Over(whole, key, row), frozen, books)
|
||||
# 857-3b 가져온 식 = 수식 문서만(가져온 줄 없음) → 굳힌 사본도 문서 셈(옛 굳힘 ROW 번지 · 단계 없음 ·
|
||||
# B09 대가 블록 줄 = B9-5 문서 셈 줄 뒤 다시 확인)
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
|
||||
over = sc._Over(whole, frozen["바탕"]["로직"], json.loads(json.dumps(frozen[item_sk.ROW])))
|
||||
unit = calc.run(sd.clean(frozen, None, over), over)["1단위"]
|
||||
got = {k: D(str(round(float(v)))) for k, v in unit.items()}
|
||||
excel = {k: D(str(round(v))) for k, v in out["원본"]["엑셀금액"].items()}
|
||||
assert got == excel
|
||||
|
||||
|
||||
@@ -3,9 +3,9 @@
|
||||
|
||||
- 견본 둘 = 791-1 손 옮김 견본(봉화 D00102 합판거푸집 STmate 번지 · 율 / 북부청임도 18 문양거푸집
|
||||
EST 줄 자리) · 단가 = 엑셀 목록표 값 → 셈 = 엑셀 금액 · 줄마다 검산
|
||||
- 덮개 · 상수 덮개 · 식 칸 · 변수 줄이 가져온 줄에도 먹음
|
||||
- 857-3b 저장 = 불러온 그대로 문서(`가져온.문서`) · 가져온 줄 안 둠 · 옛 칸 고침(덮개 · 더한줄 …) = 못 셈
|
||||
- 셈 답 `원래` = 엑셀 금액 · `가져온` 원본 글
|
||||
- [우리 단가로] · [엑셀 단가로] · 이음 고름(덮개 열쇠 옮김) · [우리 기초로 바꾸기] 없음(809-1)
|
||||
- [우리 단가로] · [엑셀 단가로] · 이음 고름(문서 연결) · [우리 기초로 바꾸기] 없음(809-1)
|
||||
- 만들기(임시 층) · 같은 내용 409 · 옛 SK 지문 그대로 · 펼침 막음 · B09 굳힘 · 단가 전파
|
||||
"""
|
||||
|
||||
@@ -117,10 +117,12 @@ def _bukbu() -> tuple[dict, dict]:
|
||||
return row, src
|
||||
|
||||
|
||||
def _doc(sample=_bonghwa, **more):
|
||||
def _doc(sample=_bonghwa, src_fix=None, **more):
|
||||
row, src = sample()
|
||||
meta = {"로직": row, "단가기준": "엑셀", "원본": src}
|
||||
return {"키": "SK-000001", "이름": "가져온", "단위": "㎡", "바탕": None, imp.KEY: meta, **more}
|
||||
if src_fix:
|
||||
src_fix(src)
|
||||
doc = imp.new_doc(row, src, "가져온", "㎡") # 857-3b 불러온 그대로 문서
|
||||
return {**doc, "키": "SK-000001", **more}
|
||||
|
||||
|
||||
def _run(doc, whole=None):
|
||||
@@ -141,10 +143,12 @@ def test_봉화_셈_엑셀_검산():
|
||||
assert _sum(_doc()) == {"노무비": 34119, "재료비": 11192, "경비": 341, "계": 45652}
|
||||
got = imp.check(sd.clean(_doc(), None, _whole()))
|
||||
assert got["같음"] is True and len(got["줄"]) == 4 and all(x["같음"] for x in got["줄"])
|
||||
bad = _doc()
|
||||
bad[imp.KEY]["원본"]["엑셀금액"]["계"] = 45653
|
||||
bad[imp.KEY]["원본"]["글줄"][1]["값"] = 3870
|
||||
got = imp.check(sd.clean(bad, None, _whole()))
|
||||
|
||||
def lie(src):
|
||||
src["엑셀금액"]["계"] = 45653
|
||||
src["글줄"][1]["값"] = 3870
|
||||
|
||||
got = imp.check(sd.clean(_doc(src_fix=lie), None, _whole()))
|
||||
assert got["같음"] is False and got["까닭"] == "금액 다름"
|
||||
assert got["줄"][0]["까닭"] == "셈 3862.5 · 엑셀 3870"
|
||||
|
||||
@@ -154,28 +158,30 @@ def test_북부청_18_줄_자리_셈_엑셀():
|
||||
assert imp.check(sd.clean(_doc(_bukbu), None, _whole()))["같음"] is True
|
||||
|
||||
|
||||
# ── 덮개 · 식 칸 · 셈 답 ─────────────────────────────────────────────
|
||||
def test_덮개_상수_식칸_가져온_줄에_먹음():
|
||||
base = _total(_doc())
|
||||
covered = _doc(덮개={"labor:형틀목공#0": {"qty": 0.2}})
|
||||
assert _total(covered) > base # 형틀목공 5/50 → 0.2 인
|
||||
assert (
|
||||
_total(_doc(상수덮개={BURN: {"0": 12}})) == 45652 + 101
|
||||
) # 소모자재 11 → 12 %(A01 재료 10,083.7 × 1 %)
|
||||
assert _total(_doc(식덮개={"labor:형틀목공#0": "6 / 50"})) > base
|
||||
var = [{"이름": "할증", "식": "1.2", "자리": ""}]
|
||||
assert _total(_doc(변수줄=var, 식덮개={"labor:형틀목공#0": "5 / 50 * 할증"})) > base
|
||||
assert _total(_doc(뺀줄=[PLY])) < base
|
||||
adds = [{"종류": "인력", "요소": MAN, "수량": 0.01}]
|
||||
assert _total(_doc(더한줄=adds)) > base
|
||||
# ── 옛 칸 고침 · 셈 답 ────────────────────────────────────────────────
|
||||
@pytest.mark.parametrize(
|
||||
"more",
|
||||
[
|
||||
{"덮개": {"labor:형틀목공#0": {"qty": 0.2}}},
|
||||
{"상수덮개": {BURN: {"0": 12}}},
|
||||
{"뺀줄": [PLY]},
|
||||
{"더한줄": [{"종류": "인력", "요소": MAN, "수량": 0.01}]},
|
||||
],
|
||||
)
|
||||
def test_옛_칸_고침_못_셈(more):
|
||||
"""857-3b — 가져온 식도 옛 칸 고침 = 셈 안 함(2-C1 · 고침 = 줄 쌓기 문서)."""
|
||||
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
||||
|
||||
got = _run(_doc(**more))
|
||||
assert got["1단위"] is None and got["까닭"] == dsk.OLD_WHY
|
||||
|
||||
|
||||
def test_셈_답_원래_엑셀_원본_글(world):
|
||||
doc = _doc(덮개={"labor:형틀목공#0": {"qty": 0.2}}, 까닭={"labor:형틀목공#0": "현장 품"})
|
||||
doc = _doc()
|
||||
with store.at(world["personal"]):
|
||||
got = calc.calc_doc(doc)
|
||||
assert got["원래"] == {"노무비": 34119, "재료비": 11192, "경비": 341, "계": 45652}
|
||||
assert got["기준"]["계"] > 45652
|
||||
assert got["기준"]["계"] == 45652
|
||||
view = got[imp.KEY]
|
||||
assert view["단가기준"] == "엑셀" and view["파일"] == "봉화.xlsx" and view["행"] == [2909, 2943]
|
||||
lines = view["글줄"]
|
||||
@@ -198,21 +204,23 @@ def test_우리_단가로_엑셀_단가로():
|
||||
imp.to_price({"키": "SK-000001", "바탕": {"로직": FORM}}, "우리")
|
||||
|
||||
|
||||
def test_이음_고름_덮개_열쇠_옮김():
|
||||
doc = _doc(덮개={"labor:형틀목공#0": {"qty": 0.2}}, 까닭={"labor:형틀목공#0": "현장"})
|
||||
doc["글줄"] = [{"자리": "labor:형틀목공#0", "글": "※ 현장 조정"}]
|
||||
got = imp.link(doc, "labor:형틀목공#0", CARP)["문서"]
|
||||
new = f"labor:{CARP}#0"
|
||||
assert got["덮개"] == {new: {"qty": 0.2}} and got["까닭"] == {new: "현장"}
|
||||
assert got["글줄"][0]["자리"] == new
|
||||
assert got[imp.KEY]["원본"]["글줄"][2]["자리"] == new
|
||||
def test_이음_고름_문서_연결():
|
||||
"""857-3b — 이음 고름 = 그 가져온 줄 값 변수 연결(엑셀 값 기억 · 엑셀 판 금액 그대로)."""
|
||||
doc = _doc()
|
||||
spot = "호표:2" # 형틀목공
|
||||
assert spot in {x["자리"] for x in imp.unlinked(doc)}
|
||||
got = imp.link(doc, spot, CARP)["문서"]
|
||||
var = next(v for v in got[imp.KEY]["문서"]["변수"] if v.get(imp.FROM) == spot)
|
||||
assert var["연결"]["갈래"] == "요소" and var["연결"]["키"] == CARP
|
||||
assert var["연결"]["엑셀"] == 274978 # 엑셀 단가 기억
|
||||
assert spot not in {x["자리"] for x in imp.unlinked(got)}
|
||||
assert _total(got) == _total(doc) # 엑셀 단가 그대로 = 금액 그대로
|
||||
ours = imp.to_price(got, "우리")
|
||||
assert len(ours["이음없음"]) == 2 and ours["후"]["계"] != ours["전"]["계"]
|
||||
with pytest.raises(sd.DocError):
|
||||
imp.link(doc, "labor:형틀목공#0", "LB999999")
|
||||
imp.link(doc, spot, "LB999999")
|
||||
with pytest.raises(sd.DocError):
|
||||
imp.link(doc, "labor:없는줄#0", CARP)
|
||||
imp.link(doc, "호표:99", CARP)
|
||||
|
||||
|
||||
def test_우리_기초로_바꾸기_없음():
|
||||
@@ -234,10 +242,10 @@ def test_우리_기초로_바꾸기_없음():
|
||||
],
|
||||
)
|
||||
def test_틀린_가져온_로직(change, why):
|
||||
doc = _doc()
|
||||
change(doc[imp.KEY]["로직"])
|
||||
row, src = _bonghwa()
|
||||
change(row)
|
||||
with pytest.raises(sd.DocError, match=why):
|
||||
sd.clean(doc, None, _whole())
|
||||
imp.new_doc(row, src, "가져온", "㎡")
|
||||
|
||||
|
||||
def test_바탕과_같이_못_둠_펼침_막음():
|
||||
@@ -262,7 +270,9 @@ def test_만들기_저장_같은_내용(world):
|
||||
assert made["검산"]["같음"] is True and made["단가기준"] == "엑셀"
|
||||
meta = doc[imp.KEY]
|
||||
assert doc["바탕"] is None and doc["단위"] == "㎡" and meta["원본"] == src
|
||||
assert meta["검산"]["같음"] is True and meta["로직"]["호표"][3]["이음"] == MAN
|
||||
assert "로직" not in meta # 857-3b 가져온 줄 안 둠 · 정본 = 문서
|
||||
man = next(v for v in meta["문서"]["변수"] if v.get(imp.FROM) == "호표:3")
|
||||
assert meta["검산"]["같음"] is True and man["연결"]["키"] == MAN
|
||||
assert again != made["이름"] != ours
|
||||
plain = {"키": "SK-000009", "이름": "x", "단위": "식", "바탕": {"로직": FORM}, "입력값": F211}
|
||||
one = same.finger("sangeun", doc)
|
||||
@@ -304,7 +314,7 @@ def _frozen_total(doc, whole):
|
||||
rid = "personal|7/42|SK-000001"
|
||||
frozen = sk.freeze({rid: sd.clean(doc, None, _whole())})[rid]
|
||||
key, row = frozen["바탕"]["로직"], json.loads(json.dumps(frozen[sk.ROW]))
|
||||
assert key.startswith("GX9") and frozen["원본"][imp.KEY]["로직"]
|
||||
assert key.startswith("GX9") and frozen["원본"][imp.KEY]["문서"]
|
||||
over = calc._Over(whole, key, row)
|
||||
return float(calc.run(sd.clean(frozen, None, over), over)["1단위"]["계"])
|
||||
|
||||
@@ -318,15 +328,13 @@ def test_B09_굳힘_단가_전파():
|
||||
up = _Priced(whole, MAN, float(whole.get(MAN)["값"]) + 50000)
|
||||
assert _frozen_total(excel, up) == 45652 # 엑셀 단가 그대로 = 안 바뀜
|
||||
assert _frozen_total(ours, up) == pytest.approx(live + 50000 * 2 / 50 * 1.01, abs=2)
|
||||
covered = _doc(덮개={"labor:형틀목공#0": {"qty": 0.2}})
|
||||
assert _frozen_total(covered, whole) == _total(covered)
|
||||
|
||||
|
||||
def test_원본_보존_사본():
|
||||
doc = _doc()
|
||||
keep = copy.deepcopy(doc)
|
||||
imp.to_price(doc, "우리")
|
||||
imp.link(doc, "labor:형틀목공#0", CARP)
|
||||
imp.link(doc, "호표:2", CARP)
|
||||
assert doc == keep # 받은 문서 안 고침(화면 캐시 = 답 문서로 바꿈)
|
||||
assert refs.kind_of("SK-000001") == "sangeun" and MINE["층"] == "personal"
|
||||
assert flat.flat_doc("sangeun", doc) == doc # 참조 없음 = 그대로
|
||||
@@ -382,4 +390,38 @@ def test_실무_블록_가져온_식(tag, code, world):
|
||||
assert _frozen_total(doc, _whole()) == excel["계"]
|
||||
ours = imp.to_price(doc, "우리")
|
||||
assert {k: round(float(v)) for k, v in ours["전"].items()} == excel
|
||||
assert len(ours["이음없음"]) < len(doc[imp.KEY]["로직"]["호표"]) # 1차 줄 판정 이음
|
||||
assert len(ours["이음없음"]) < len(out["로직"]["호표"]) # 1차 줄 판정 이음
|
||||
|
||||
|
||||
# ── 857-3b 옛 꼴 저장본(`가져온.로직`) = 읽지 않음 · 까닭 하나 ──────────────────
|
||||
def test_옛_꼴_저장본_까닭_하나(world):
|
||||
"""857-3b — 옛 꼴(가져온 줄만 · 문서 없음) = 셈 · 검산 · 고침 모두 까닭 하나 · 파일 그대로."""
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_Sangeun_QtyLinks as qty
|
||||
|
||||
row, src = _bonghwa()
|
||||
old = {"키": "SK-000001", "이름": "옛 꼴", "단위": "㎡", "바탕": None, "입력값": {}}
|
||||
old[imp.KEY] = {"로직": row, "단가기준": "엑셀", "원본": src}
|
||||
assert imp.is_imported(old) and imp.old_form(old)
|
||||
got = _run(old)
|
||||
assert got["1단위"] is None and got["수식셈"]["까닭"] == dim.OLD_FORM
|
||||
assert imp.check(old)["까닭"] == dim.OLD_FORM
|
||||
for edit in (
|
||||
lambda: imp.to_price(old, "우리"),
|
||||
lambda: imp.link(old, "호표:2", CARP),
|
||||
lambda: qty.view(old),
|
||||
):
|
||||
with pytest.raises(sd.DocError):
|
||||
edit()
|
||||
with store.at(
|
||||
world["personal"]
|
||||
): # 857-3b 앞 저장본 = 그대로(지우지 않음 · 고치지 않음) · 열기 = 까닭
|
||||
file = store.root() / "sangeun" / "SK-000777.json"
|
||||
file.parent.mkdir(parents=True, exist_ok=True)
|
||||
body = {"종류": sd.TITLE, **old, "키": "SK-000777", "덮개": {}, "뺀줄": [], "더한줄": []}
|
||||
file.write_text(json.dumps(body, ensure_ascii=False, default=str), "utf-8")
|
||||
before = file.read_bytes()
|
||||
read = path.read("SK-000777")
|
||||
assert read["셈"]["셈됨"] is False and dim.OLD_FORM in json.dumps(read, ensure_ascii=False)
|
||||
assert file.read_bytes() == before
|
||||
|
||||
@@ -69,7 +69,7 @@ def test_단산_블록_가져온_식_만들기_다시씀_지움(client):
|
||||
ten = _open(client, 10).json() # 야면석소운반 — 근거 기초 제안 없음(809-1 · 요구 703)
|
||||
with store.at(folder):
|
||||
meta = store.read("sangeun", ten["이름"])["문서"]["가져온"]
|
||||
assert meta["로직"] and "근거후보" not in meta
|
||||
assert meta["문서"] and "로직" not in meta and "근거후보" not in meta # 857-3b 문서 정본
|
||||
assert _open(client, 99999).status_code == 404
|
||||
fh._path(folder, KEY).unlink() # 산근 없는 옛 HP = 다시 올림
|
||||
old = _open(client)
|
||||
|
||||
@@ -15,7 +15,6 @@ from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Equation as eqm
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
||||
from resources.tester.test_795_1_sk_copy import (
|
||||
_calc,
|
||||
_doc,
|
||||
_imported_row,
|
||||
_save,
|
||||
@@ -35,18 +34,16 @@ KEY = "GC000211" # 합판거푸집 — 중간 시공량 · 형틀목공 · 보
|
||||
DOUBLE = [{"할일": "식", "자리": "호표:0", "식": "형틀목공 × 2", "까닭": "sub2임시 시험"}]
|
||||
|
||||
|
||||
def test_imported_same_path(world):
|
||||
"""⑥ 가져온 식 SK(바탕 null · 가져온.로직) — 같은 고침 · 저장."""
|
||||
def test_imported_old_equation_edit_refused(world):
|
||||
"""⑥ 857-3b 가져온 식 SK(불러온 그대로 문서 · 가져온 줄 안 둠) — 옛 식 칸 고침은 얹을 줄 없음(고침 = 줄 쌓기)."""
|
||||
me = world["personal"]
|
||||
with store.at(me):
|
||||
key = imp.create(_imported_row(), None, "sub2임시 가져온")["이름"]
|
||||
doc = _doc(me, key)
|
||||
was = _calc(me, doc)["기준"]["노무비"]
|
||||
assert "로직" not in doc["가져온"] and doc["가져온"]["문서"]["금액"]
|
||||
edit = [{"할일": "식", "자리": "호표:0", "식": "0.5 × 2"}]
|
||||
_save(me, key, {**doc, eqm.KEY: edit})
|
||||
now = _calc(me, _doc(me, key))
|
||||
assert now["기준"]["노무비"] == pytest.approx(was * 2, abs=1)
|
||||
assert _doc(me, key)["가져온"]["로직"]["호표"][0]["수량"] == "0.5" # 엑셀 줄 그대로
|
||||
with pytest.raises(Exception, match="수식 고침 못 얹음"):
|
||||
_save(me, key, {**doc, eqm.KEY: edit})
|
||||
|
||||
|
||||
def test_screen_same_part_first_tab():
|
||||
|
||||
@@ -33,8 +33,21 @@ KEY = "HP-000001"
|
||||
|
||||
def _doc(items: list[dict], excel: dict | None = None) -> dict:
|
||||
row = {"이름": "연결 견본", "결과단위": "원/식", "호표": items}
|
||||
meta = {"로직": row, "단가기준": "엑셀", "원본": {"엑셀금액": excel or {}}}
|
||||
return {"키": "SK-000001", "이름": "견본", "단위": "식", "바탕": None, imp.KEY: meta}
|
||||
doc = imp.new_doc(row, {"엑셀금액": excel or {}}, "견본", "식") # 857-3b 불러온 그대로 문서
|
||||
return {**doc, "키": "SK-000001"}
|
||||
|
||||
|
||||
def _money(doc: dict) -> float:
|
||||
"""저장 SK 셈(단가기준 그대로 · 형제 SK 연결 따라감)."""
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||||
|
||||
return float(dim.run(dim.derive(doc), doc)["계"])
|
||||
|
||||
|
||||
def _inner(doc: dict) -> list[dict]:
|
||||
"""형제 SK 연결 변수(산근 속 산근 797-1)."""
|
||||
first = doc[imp.KEY]["문서"]
|
||||
return [v for v in first["변수"] if (v.get("연결") or {}).get("참조")]
|
||||
|
||||
|
||||
def _item(kind: str, name: str, price: float, part: str, link: str | None, qty: str = "1"):
|
||||
@@ -123,10 +136,11 @@ def test_nested_stmate_follows_inner(world) -> None:
|
||||
with store.at(folder):
|
||||
made = fh.make(folder, KEY, 2200) # D02200 안에 D00075 콘크리트믹서사용
|
||||
doc = _read(made["이름"])
|
||||
inner = [x for x in doc[imp.KEY]["로직"]["호표"] if x.get("참조")]
|
||||
assert len(inner) == 1 and inner[0]["값묶음"]["노무비"] == 6216 # 엑셀 얼린 값은 곁에 남음
|
||||
ref = inner[0]["참조"]
|
||||
inner = _inner(doc)
|
||||
assert len(inner) == 1 and inner[0]["연결"]["엑셀"]["노무비"] == 6216 # 엑셀 값 기억
|
||||
ref = {**inner[0]["연결"]["참조"], "키": inner[0]["연결"]["키"]}
|
||||
assert made["검산"]["같음"] is True and made["검산"]["셈"]["계"] == 67383
|
||||
assert _money(doc) == 67383
|
||||
assert fh.make(folder, KEY, 2200)["이름"] == made["이름"] # 다시 올려도 같은 SK
|
||||
assert refs.users(ref) # 쓰는 곳에 바깥 SK
|
||||
with pytest.raises(store.StoreError) as why:
|
||||
@@ -134,18 +148,22 @@ def test_nested_stmate_follows_inner(world) -> None:
|
||||
assert why.value.status == 409
|
||||
# 안쪽이 바뀌면 따라감 — 안쪽 단가 줄 하나 두 배
|
||||
sub = _read(ref["키"])
|
||||
one = next(
|
||||
x for x in sub[imp.KEY]["로직"]["호표"] if "값묶음" in x
|
||||
) # 814-1 기계 세 줄 = 값묶음 한 줄
|
||||
one["값묶음"] = {k: v * 2 for k, v in one["값묶음"].items()}
|
||||
link = next( # 엑셀 값(숫자 연결 값 · 이은 줄 엑셀 기억) 한 칸 두 배
|
||||
v["연결"]
|
||||
for v in sub[imp.KEY]["문서"]["변수"]
|
||||
if (v.get("연결") or {}).get("갈래") == "숫자" or "엑셀" in (v.get("연결") or {})
|
||||
)
|
||||
at = "값" if link.get("갈래") == "숫자" else "엑셀"
|
||||
got = link[at]
|
||||
link[at] = {k: x * 2 for k, x in got.items()} if isinstance(got, dict) else got * 2
|
||||
store.write("sangeun", ref["키"], store.read("sangeun", ref["키"])["판"], sub)
|
||||
inner_now = imp.check(_read(ref["키"]))["셈"]["계"]
|
||||
inner_now = _money(_read(ref["키"]))
|
||||
assert inner_now != 7528
|
||||
assert imp.check(doc)["셈"]["계"] == pytest.approx(67383 - 7528 + inner_now, abs=1)
|
||||
assert _money(doc) == pytest.approx(67383 - 7528 + inner_now, abs=1) # 바깥이 따라감
|
||||
# 단가기준 따라감 — 안쪽 SK 가 우리 단가로 저장돼도 엑셀 기준 바깥은 엑셀 값
|
||||
ours_sub = imp.to_price(_read(ref["키"]), "우리")["문서"]
|
||||
store.write("sangeun", ref["키"], store.read("sangeun", ref["키"])["판"], ours_sub)
|
||||
assert imp.check(doc)["셈"]["계"] == pytest.approx(67383 - 7528 + inner_now, abs=1)
|
||||
assert _money(doc) == pytest.approx(67383 - 7528 + inner_now, abs=1)
|
||||
assert imp.to_price(doc, "우리")["후"] is not None
|
||||
|
||||
|
||||
@@ -154,11 +172,11 @@ def test_nested_est_by_part_matches_excel(world) -> None:
|
||||
with store.at(folder):
|
||||
made = fh.make(folder, KEY, 67) # 단산68 세 줄 = 묶음 한 줄로 부름(812-1 · 원파일 길)
|
||||
doc = _read(made["이름"])
|
||||
inner = [x for x in doc[imp.KEY]["로직"]["호표"] if x.get("참조")]
|
||||
assert len(inner) == 1 and "참조비목" not in inner[0]
|
||||
inner = _inner(doc)
|
||||
assert len(inner) == 1 and "칸" not in inner[0]["연결"]
|
||||
assert made["검산"]["같음"] is True
|
||||
# 엑셀 단가 그대로 금액 = 굳힌 값 합과 같음
|
||||
frozen = sum(float(v) for v in inner[0]["값묶음"].values())
|
||||
frozen = sum(float(v) for v in inner[0]["연결"]["엑셀"].values())
|
||||
assert float(made["검산"]["셈"]["계"]) == pytest.approx(
|
||||
float(made["검산"]["엑셀"]["계"]), abs=1
|
||||
)
|
||||
|
||||
@@ -97,8 +97,8 @@ def _line(kind: str, name: str, qty_: str, unit: str = "", price: float = 1000.0
|
||||
|
||||
|
||||
def _doc(row: dict) -> dict:
|
||||
meta = {"로직": row, "단가기준": "엑셀", "원본": {"엑셀금액": {}}}
|
||||
return {"키": "SK-000001", "이름": "견본", "단위": "식", "바탕": None, imp.KEY: meta}
|
||||
"""857-3b 가져온 식 SK = 불러온 그대로 문서(자리 = 문서 머리 `가져온.자리`)."""
|
||||
return {**imp.new_doc(row, {"엑셀금액": {}}, "견본", "식"), "키": "SK-000001"}
|
||||
|
||||
|
||||
ROW = _row(
|
||||
@@ -169,8 +169,7 @@ def test_pick_records_cell_and_money_unchanged(idx) -> None:
|
||||
"eq",
|
||||
)
|
||||
assert one["수"] == one["값"] == 0.05
|
||||
assert _money(got) == _money(doc) # 기록만 — 금액 그대로
|
||||
assert got[imp.KEY]["로직"] == doc[imp.KEY]["로직"] # 엑셀 줄 안 건드림
|
||||
assert _money(got) == _money(doc) # 엑셀 칸 값 기억 — 금액 그대로
|
||||
view = {x["자리"]: x for x in qty.view(got, idx)["줄"]}
|
||||
assert view["호표:1:0"]["상태"] == "고름" and view["호표:1:0"]["고른"]["같음"] is True
|
||||
assert view["호표:0:0"]["상태"] == "후보" and view["호표:2:0"]["상태"] == "없음"
|
||||
@@ -213,17 +212,14 @@ def test_pick_twice_replaces_and_drop_undo(idx) -> None:
|
||||
|
||||
|
||||
# ── ③ 저장 거름 · 서버 길 ──────────────────────────────────────────────
|
||||
def test_clean_keeps_valid_and_drops_stale(idx) -> None:
|
||||
def test_clean_keeps_record(idx) -> None:
|
||||
"""857-3b — 저장 거름 = 기록 꼴만(자리는 불러올 때 문서 머리에 굳음 · 가져온 줄이 안 바뀜)."""
|
||||
whole = m01.loaded()[1]
|
||||
got = qty.pick(_doc(ROW), "호표:1:0", {"표": "QC900001", "줄": 0, "칸": "특별인부"}, idx)[
|
||||
"문서"
|
||||
]
|
||||
kept = sd.clean(got, None, whole)[imp.KEY]["연결"]
|
||||
assert kept["고름"][0]["표"] == "QC900001"
|
||||
got[imp.KEY]["연결"]["고름"][0]["수"] = 0.5 # 로직 수와 안 맞음 → 거름
|
||||
got[imp.KEY]["연결"]["버림"] = ["호표:0:0", "호표:99:0", {"x": 1}]
|
||||
again = sd.clean(got, None, whole)[imp.KEY]["연결"]
|
||||
assert "고름" not in again and again["버림"] == ["호표:0:0"]
|
||||
got[imp.KEY]["연결"] = "엉뚱"
|
||||
with pytest.raises(sd.DocError):
|
||||
sd.clean(got, None, whole)
|
||||
|
||||
@@ -23,7 +23,6 @@ import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||||
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_Hopyo_Store as hs
|
||||
from M02_MasterTemplete import M02_Machine_Hourly as machine
|
||||
@@ -36,10 +35,14 @@ from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은
|
||||
KEY = "HP-000001"
|
||||
|
||||
|
||||
def _row(items: list[dict], extra: dict | None = None) -> dict:
|
||||
return {"이름": "견본 sub2임시", "결과단위": "원/식", "호표": items, **(extra or {})}
|
||||
|
||||
|
||||
def _doc(items: list[dict], extra: dict | None = None, src: dict | None = None) -> dict:
|
||||
row = {"이름": "견본 sub2임시", "결과단위": "원/식", "호표": items, **(extra or {})}
|
||||
meta = {"로직": row, "단가기준": "엑셀", "원본": {"엑셀금액": {}, **(src or {})}}
|
||||
return {"키": "SK-000001", "이름": "견본", "단위": "식", "바탕": None, imp.KEY: meta}
|
||||
"""857-3b 가져온 식 SK = 불러온 그대로 문서(가져온 줄 안 둠)."""
|
||||
doc = imp.new_doc(_row(items, extra), {"엑셀금액": {}, **(src or {})}, "견본", "식")
|
||||
return {**doc, "키": "SK-000001"}
|
||||
|
||||
|
||||
def _item(kind: str, name: str, price: float, part: str, link: str | None = None, qty_="1"):
|
||||
@@ -104,8 +107,9 @@ def test_machine_without_hourly_keeps_number_with_note() -> None:
|
||||
assert dim.run(dim.derive(doc), _ours(doc))["계"] == 5000
|
||||
|
||||
|
||||
def test_sk_money_is_doc_calc_and_equals_old_engine(world) -> None:
|
||||
"""⑤ SK 금액 = 문서 셈(수식셈 표지) = 옛 엔진 셈 — 엑셀 · 우리 둘 다 · 덧줄 율 · 합밖."""
|
||||
def test_sk_money_is_doc_calc(world) -> None:
|
||||
"""⑤ SK 금액 = 문서 셈 — 엑셀 · 우리 둘 다 · 덧줄 율 · 합밖(옛 엔진 대조는 857-3b 에서 걷음 —
|
||||
가져온 줄을 안 두어 옛 엔진이 읽을 줄 없음)."""
|
||||
items = [
|
||||
_item("인력", "보통인부", 100000, "노무비", "LB000002", "0.33"),
|
||||
_item("재료", "경유", 1700, "재료비", "MO000002", "3") | {"합밖": True},
|
||||
@@ -114,13 +118,7 @@ def test_sk_money_is_doc_calc_and_equals_old_engine(world) -> None:
|
||||
doc = _doc(items, extra)
|
||||
for basis in ("엑셀", "우리"):
|
||||
mine = imp._with(doc, 단가기준=basis)
|
||||
new = imp._money(imp._run(mine, imp._whole()))
|
||||
token = dsk.OLD.set(True)
|
||||
try:
|
||||
old = imp._money(imp._run(mine, imp._whole()))
|
||||
finally:
|
||||
dsk.OLD.reset(token)
|
||||
assert new == old, basis
|
||||
assert imp._money(imp._run(mine, imp._whole())) is not None, basis
|
||||
got = imp.to_price(doc, "우리")
|
||||
assert got["전"]["계"] == 33000 + 990 and got["후"]["계"] != got["전"]["계"]
|
||||
|
||||
@@ -154,11 +152,11 @@ def test_stmate_nested_is_sibling_link(world) -> None:
|
||||
assert dim.run(root, doc)["계"] == 67383 == made["검산"]["엑셀"]["계"]
|
||||
assert dim.run(root, _ours(doc))["셈됨"] is True
|
||||
sub = _read(inner["키"]) # 안쪽 단가 줄 하나 두 배 → 바깥이 따라감(엑셀 기준도)
|
||||
one = sub[imp.KEY]["로직"]["호표"][0] # 단가 한 칸 · 값 묶음(노 · 재 · 경) 한 줄 둘 다 있음
|
||||
if "단가" in one:
|
||||
one["단가"] = one["단가"] * 2
|
||||
else:
|
||||
one["값묶음"] = {k: v * 2 for k, v in one["값묶음"].items()}
|
||||
one = next( # 가져온 값 변수 하나(단가 한 칸 · 값 묶음) 두 배
|
||||
v for v in sub[imp.KEY]["문서"]["변수"] if (v.get("연결") or {}).get("갈래") == "숫자"
|
||||
)
|
||||
got = one["연결"]["값"]
|
||||
one["연결"]["값"] = {k: x * 2 for k, x in got.items()} if isinstance(got, dict) else got * 2
|
||||
store.write("sangeun", inner["키"], store.read("sangeun", inner["키"])["판"], sub)
|
||||
now = dim.run(dim.derive(_read(inner["키"])), _read(inner["키"]))["계"]
|
||||
assert now != 7528
|
||||
@@ -200,8 +198,7 @@ def test_qty_pick_becomes_table_link(world) -> None:
|
||||
if found is None:
|
||||
pytest.skip("야면석채집및운반(계곡내) 블록 없음")
|
||||
row = found["로직"]
|
||||
doc = _doc(row["호표"], {k: row[k] for k in ("중간", "덧줄", "단계", "끝전") if row.get(k)})
|
||||
doc[imp.KEY]["로직"] |= {k: row[k] for k in ("이름", "결과단위")}
|
||||
doc = {**imp.new_doc(row, {"엑셀금액": {}}, "견본", "식"), "키": "SK-000001"}
|
||||
at = next(i for i, x in enumerate(row["호표"]) if x["이름"] == "보통인부")
|
||||
cell = next(c for c in qty.view(doc)["줄"] if c["자리"] == f"호표:{at}:0")["후보"][0]
|
||||
kept = qty.pick(doc, f"호표:{at}:0", {k: cell[k] for k in ("표", "줄", "칸")})["문서"]
|
||||
@@ -219,9 +216,9 @@ def test_qty_pick_becomes_table_link(world) -> None:
|
||||
# ── ⑤ 수식 길 · 옮기기 ───────────────────────────────────────────────────
|
||||
def test_formula_route_edit_then_old_edit_409_and_regen(world) -> None:
|
||||
folder = world["personal"]
|
||||
doc = _doc([_item("인력", "보통인부", 100000, "노무비", "LB000002", "0.5")])
|
||||
with store.at(folder):
|
||||
key = imp.create(doc[imp.KEY]["로직"], {"엑셀금액": {"계": 50000}}, "sub2임시 견본")["이름"]
|
||||
row = _row([_item("인력", "보통인부", 100000, "노무비", "LB000002", "0.5")])
|
||||
key = imp.create(row, {"엑셀금액": {"계": 50000}}, "sub2임시 견본")["이름"]
|
||||
read = path.read(key)
|
||||
assert read["셈"]["계"] == 50000 and read["사본"]["단가기준"] == "엑셀"
|
||||
edit = copy.deepcopy(read["문서"])
|
||||
@@ -232,9 +229,9 @@ def test_formula_route_edit_then_old_edit_409_and_regen(world) -> None:
|
||||
again = path.read(key)
|
||||
assert again["사본"]["따로"] is True and again["셈"]["계"] == 100000
|
||||
sk = _read(key)
|
||||
moved = imp.link(sk, sd_id(sk), None)["문서"] # 이음 풂 = 옛 칸 고침 → 409
|
||||
old = {**sk, "덮개": {"labor:LB000002#0": {"qty": 1}}} # 옛 칸 고침 → 409
|
||||
with pytest.raises(store.StoreError) as why:
|
||||
store.write("sangeun", key, store.read("sangeun", key)["판"], moved)
|
||||
store.write("sangeun", key, store.read("sangeun", key)["판"], old)
|
||||
assert why.value.status == 409
|
||||
ours = imp.to_price(sk, "우리")["문서"] # 단가기준만 바꿈 = 됨(문서 그대로 · 연결 값)
|
||||
store.write("sangeun", key, store.read("sangeun", key)["판"], ours)
|
||||
@@ -242,10 +239,6 @@ def test_formula_route_edit_then_old_edit_409_and_regen(world) -> None:
|
||||
assert path.read(key)["셈"]["노무비"] == int(lb * 10) / Decimal(10)
|
||||
|
||||
|
||||
def sd_id(sk: dict) -> str:
|
||||
return imp.sd.line_ids(imp.row_of(sk))[0]
|
||||
|
||||
|
||||
# ── TS 짝(importView) 거울 ─────────────────────────────────────────────
|
||||
_NODE = """
|
||||
const fs = require("fs"), path = require("path");
|
||||
|
||||
@@ -149,9 +149,7 @@ def test_imported_doc_names_and_machine_line(world) -> None:
|
||||
out = fh.emit(
|
||||
folder, hp, 8
|
||||
) # 배수관부설(파형강관)(D=800mm) — 크레인 세 줄 · 줄_2 · 노무비_2 · 계_2
|
||||
unit = out["로직"]["결과단위"].split("/", 1)[1]
|
||||
sk = {"키": "SK-000000", "이름": "x", "단위": unit, "바탕": None, "입력값": {}}
|
||||
sk[imp.KEY] = {"로직": out["로직"], "단가기준": "엑셀", "원본": out["원본"]}
|
||||
sk = imp.new_doc(out["로직"], out["원본"], "x") # 857-3b 불러온 그대로 문서
|
||||
new = dim.derive(sk)
|
||||
names = [x["이름"] for x in new["금액"]]
|
||||
assert "공구손료 및 잡재료비(노무비의 2%)" in names # 읽기기 지은 「율」 → 엑셀 글 머리
|
||||
|
||||
@@ -71,11 +71,8 @@ def picked(saved: dict, few: int = 8) -> dict:
|
||||
|
||||
|
||||
def sk_of(out: dict) -> dict:
|
||||
"""{로직, 원본} → 저장 없는 가져온 식 SK(만들기 몸과 같은 꼴 · 키 = 시험용)."""
|
||||
row = out["로직"]
|
||||
sk = {"키": "SK-999999", "이름": row["이름"], "단위": row["결과단위"].split("/", 1)[1]}
|
||||
sk |= {"바탕": None, "입력값": {}, "덮개": {}, "뺀줄": [], "더한줄": []}
|
||||
sk[imp.KEY] = {"로직": row, "원본": out["원본"], "단가기준": "엑셀"}
|
||||
"""{로직, 원본} → 저장 없는 가져온 식 SK(만들기 몸 · 불러온 그대로 문서 857-3b · 키 = 시험용)."""
|
||||
sk = {**imp.new_doc(out["로직"], out["원본"], out["로직"]["이름"]), "키": "SK-999999"}
|
||||
return sd.clean(sk, None, whole())
|
||||
|
||||
|
||||
@@ -224,7 +221,7 @@ def test_upload_native_one_file_list_only(world) -> None:
|
||||
made = fh.make(folder, got["키"], 15) # 전석 메쌓기 — 안쪽 산근 둘 + 굴삭기
|
||||
sk = store.read("sangeun", made["이름"])["문서"]
|
||||
assert sk["가져온"]["원본"]["원파일"] and made["검산"]["같음"]
|
||||
assert len([x for x in sk["가져온"]["로직"]["호표"] if x.get("참조")]) == 2
|
||||
assert len(imp.refs_of(sk)) == 2 # 안쪽 산근 둘 = 형제 SK 연결(857-3b 문서)
|
||||
ans = dim.run(dim.of(sk), sk)
|
||||
assert (ans["노무비"], ans["재료비"], ans["경비"]) == (74880, 7029, 12306)
|
||||
st = fh.upload_native(folder, stc.name, stc.read_bytes(), WHO)
|
||||
|
||||
@@ -104,16 +104,19 @@ def test_sample_formwork_text_rate_subtotal() -> None:
|
||||
False,
|
||||
["#< 토목품셈 6-3-1 합판거푸집(2022개정) >", "#※ 사용횟수 4회 : 보통"],
|
||||
)
|
||||
assert got[1] == (
|
||||
"재료비",
|
||||
False,
|
||||
[
|
||||
"합판(내수),대전",
|
||||
"외송각재,대전",
|
||||
"주자재소계",
|
||||
"#소모자재(박리재등) (주자재비의 9%)",
|
||||
"율",
|
||||
],
|
||||
assert (
|
||||
got[1]
|
||||
== (
|
||||
"재료비",
|
||||
False,
|
||||
[
|
||||
"합판(내수),대전",
|
||||
"외송각재,대전",
|
||||
"주자재소계",
|
||||
"#소모자재(박리재등) (주자재비의 9%)",
|
||||
"소모자재(박리재등) (주자재비의 9%)", # 857-3b 지은 「율」 → 엑셀 글 머리(704 · 저장 길도)
|
||||
],
|
||||
)
|
||||
)
|
||||
assert got[2][0] == "인건비 (24년 품셈 개정)" and got[2][2][:3] == [
|
||||
"형틀목공",
|
||||
|
||||
@@ -156,9 +156,9 @@ def test_make_flow(world) -> None:
|
||||
assert not any(m["새로"] for m in again["내기계"])
|
||||
doc = store.read("sangeun", got["이름"])["문서"]
|
||||
assert doc[imp.KEY]["원본"]["내기계"][0]["키"] == one["키"]
|
||||
items = doc[imp.KEY]["로직"]["호표"]
|
||||
mine = [x for x in items if (x.get("자원") or {}).get("내기계") == one["키"]]
|
||||
assert mine and all(f"개인 {one['키']}" in str(x.get("이음")) for x in mine)
|
||||
first = doc[imp.KEY]["문서"] # 857-3b 불러온 그대로 문서 — 내 기계 연결 · 설명
|
||||
mine = [v for v in first["변수"] if f"내 기계 {one['키']}" in str(v.get("설명") or "")]
|
||||
assert mine and all(one["키"] in str(v.get("연결")) for v in mine)
|
||||
assert not [
|
||||
u for u in imp.unlinked(doc) if "파워트로웰" in u["이름"]
|
||||
] # 「못 이음」 에서 빠짐
|
||||
|
||||
@@ -44,7 +44,9 @@ def _upload(folder: Path, tag: str) -> str:
|
||||
|
||||
|
||||
def _lines(doc: dict, kind: str) -> list[dict]:
|
||||
return [x for x in doc[imp.KEY]["로직"]["호표"] if mp.kind_of(x.get("자원") or {}) == kind]
|
||||
"""857-3b — 그 종 재료 줄 판정(불러온 그대로 문서 머리 `가져온.재료` · 가져온 줄 안 둠)."""
|
||||
first = doc[imp.KEY]["문서"]
|
||||
return [e for e in (first.get(imp.KEY) or {}).get("재료") or [] if e.get("종") == kind]
|
||||
|
||||
|
||||
def _var(conv: dict, sym: str) -> dict:
|
||||
@@ -75,11 +77,8 @@ def test_pick_whole_file(world) -> None:
|
||||
doc = store.read("sangeun", key)["문서"]
|
||||
assert doc[imp.KEY]["원본"]["지문"] == fp
|
||||
lines = _lines(doc, WIRE)
|
||||
assert lines and all(x["이음"] == pick["키"] for x in lines)
|
||||
assert all(x["자원"]["재료찾기"]["고름"]["키"] == pick["키"] for x in lines)
|
||||
assert all(
|
||||
x["자원"]["재료찾기"]["판정"] == "후보 여럿" for x in lines
|
||||
) # 엔진 판정 그대로
|
||||
assert lines and all(x["고름"]["키"] == pick["키"] for x in lines)
|
||||
assert all(x["판정"] == "후보 여럿" for x in lines) # 엔진 판정 그대로
|
||||
conv = dim.derive(doc, None, imp._whole())
|
||||
e = _entry(conv, WIRE)
|
||||
assert e["고름"]["키"] == pick["키"] and e["처음"]["갈래"] == "숫자"
|
||||
@@ -167,7 +166,7 @@ def test_apart_item_zero(world) -> None:
|
||||
assert got["이름"] != plain["이름"] and got["검산"] == plain["검산"] # 금액 그대로(단가 0)
|
||||
doc = store.read("sangeun", got["이름"])["문서"]
|
||||
mine = _lines(doc, kind)[0]
|
||||
assert mine["이음"] is None and mine["자원"]["재료찾기"]["고름"]["키"] == gov["키"]
|
||||
assert mine["별도계상"] and mine["고름"]["키"] == gov["키"]
|
||||
conv = dim.derive(doc, None, imp._whole())
|
||||
e = _entry(conv, kind)
|
||||
var = _var(conv, e["기호"])
|
||||
|
||||
@@ -43,7 +43,7 @@ def test_preview_writes_nothing_save_makes_same(world) -> None:
|
||||
before = _files(folder)
|
||||
seen = fh.draft(folder, row["키"], 3) # 단산3 깬잡석채집 — 기계 줄
|
||||
assert _files(folder) == before # 보기 = 디스크 쓰기 0
|
||||
assert seen["같은것"] is None and seen["문서"]["가져온"]["로직"]["호표"]
|
||||
assert seen["같은것"] is None and seen["문서"]["가져온"]["문서"]["금액"] # 857-3b 문서
|
||||
assert seen["검산"]["같음"] is True
|
||||
made = fh.make(folder, row["키"], 3, doc=seen["문서"]) # [저장]
|
||||
assert made["다시씀"] is False and (folder / "sangeun" / f"{made['이름']}.json").is_file()
|
||||
|
||||
@@ -1,129 +0,0 @@
|
||||
"""857-3a 지킴 — 가져온 식 단가산출에 사람이 더한 줄(`더한줄`) 갈래마다 문서로 지어지고 셈됨.
|
||||
|
||||
- 요소 줄(인력 · 재료 · 기계 키) = 요소 연결 · 금액 = 수량 × M01 값(두 판 같음).
|
||||
- 손 단가 요소 줄 = 그 단가 · 고정 줄 = 줄 단가 · 로직 부름 = 그 단가산출 값.
|
||||
- 형제 SK 부름 = 단가산출 연결 · 금액 = 수량 × 그 SK 값.
|
||||
- 율 줄 = 옛 엔진 셈 은퇴(855 2-C1) — 못 셈 까닭이 남음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from decimal import Decimal
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
||||
from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층
|
||||
|
||||
MAN = "LB000002" # 보통인부
|
||||
|
||||
|
||||
def _whole():
|
||||
return m01.loaded()[1]
|
||||
|
||||
|
||||
def _sk(adds: list | None = None, key: str = "SK-000001") -> dict:
|
||||
row = {
|
||||
"이름": "더한줄 sub8임시",
|
||||
"결과단위": "원/식",
|
||||
"호표": [
|
||||
{"종류": "인력", "이름": "작업반장", "단위": "인", "수량": "0.1"}
|
||||
| {"비목": "노무비", "단가": 200000},
|
||||
{
|
||||
"종류": "재료",
|
||||
"이름": "모래",
|
||||
"단위": "㎥",
|
||||
"수량": "2",
|
||||
"비목": "재료비",
|
||||
"단가": 30000,
|
||||
},
|
||||
],
|
||||
}
|
||||
meta = {"로직": row, "단가기준": "엑셀", "원본": {"엑셀금액": {}}}
|
||||
doc = {"키": key, "이름": "더한줄", "단위": "식", "바탕": None, imp.KEY: meta}
|
||||
return sd.clean({**doc, "더한줄": adds or []}, None, _whole())
|
||||
|
||||
|
||||
def _total(sk: dict, basis: str = "엑셀") -> Decimal:
|
||||
one = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": basis}}
|
||||
got = dim.run(dim.derive(one, None, _whole()), one)
|
||||
assert got["셈됨"], got.get("표지")
|
||||
return Decimal(str(got["계"]))
|
||||
|
||||
|
||||
def _m01(code: str, unit: str | None = None) -> Decimal:
|
||||
import master_material as mm # `M02_Doc_Copy` 가 scripts 를 길에 둠
|
||||
|
||||
return Decimal(str(mm.element(_whole(), code, {}, unit)[0]))
|
||||
|
||||
|
||||
BASE = Decimal(20000 + 60000)
|
||||
|
||||
|
||||
def test_바탕_엑셀_값():
|
||||
assert _total(_sk()) == BASE
|
||||
|
||||
|
||||
@pytest.mark.parametrize("basis", ["엑셀", "우리"])
|
||||
def test_인력_요소_줄_수량x_M01_노임(basis):
|
||||
got = _total(_sk([{"종류": "인력", "요소": MAN, "수량": 0.5}]), basis)
|
||||
assert got - BASE == pytest.approx(Decimal("0.5") * _m01(MAN), abs=1)
|
||||
doc = dim.derive(_sk([{"종류": "인력", "요소": MAN, "수량": 0.5}]), None, _whole())
|
||||
var = next(v for v in doc["변수"] if (v.get("연결") or {}).get("키") == MAN)
|
||||
assert var["연결"]["갈래"] == "요소"
|
||||
|
||||
|
||||
def _first(head: str) -> str:
|
||||
return next(iter(_whole().index[head]))
|
||||
|
||||
|
||||
def test_재료_요소_줄_수량x_M01_값():
|
||||
code = _first("MT")
|
||||
got = _total(_sk([{"종류": "재료", "요소": code, "수량": 3}]))
|
||||
assert got - BASE == pytest.approx(3 * _m01(code), abs=1)
|
||||
|
||||
|
||||
def test_기계_요소_줄_시간당_경비_그_비목():
|
||||
code = next(k for k in _whole().index["EQ"] if imp.hourly_of(k).get("ok"))
|
||||
sk = _sk([{"종류": "기계", "요소": code, "수량": 2, "비목": "경비"}])
|
||||
var = next(v for v in dim.derive(sk, None, _whole())["변수"] if "기계" in str(v["연결"]))
|
||||
assert var["연결"]["갈래"] == "단가산출" and var["연결"]["칸"] == "경비"
|
||||
assert _total(sk) > BASE
|
||||
|
||||
|
||||
def test_손_단가_요소_줄_그_단가():
|
||||
adds = [{"종류": "인력", "요소": MAN, "수량": 2, "단가": 1000}]
|
||||
assert _total(_sk(adds)) == BASE + 2000
|
||||
|
||||
|
||||
def test_고정_줄_줄_단가():
|
||||
fixed = {"이름": "잡비 sub8임시", "단위": "식", "단가": {"노무비": 0, "재료비": 700, "경비": 0}}
|
||||
assert _total(_sk([{"고정": fixed, "수량": 3}])) == BASE + 2100
|
||||
|
||||
|
||||
def test_로직_부름_줄_단가산출_값():
|
||||
code = "GC000206"
|
||||
alone = _sk([{"종류": "로직", "로직": code, "입력값": {}, "수량": 1}])
|
||||
doc = dim.derive(alone, None, _whole())
|
||||
var = next(v for v in doc["변수"] if (v.get("연결") or {}).get("키") == code)
|
||||
assert var["연결"]["갈래"] == "단가산출"
|
||||
assert _total(alone) > BASE
|
||||
|
||||
|
||||
def test_형제_SK_부름_수량x_그_SK(world): # noqa: F811 — 같은 임시 층 fixture
|
||||
with store.at(world["personal"]):
|
||||
store.write("sangeun", "SK-000002", "", _sk(key="SK-000002"))
|
||||
ref = {"층": MINE["층"], "주인": MINE["주인"], "키": "SK-000002"}
|
||||
got = _total(_sk([{"참조": ref, "수량": 2}]))
|
||||
assert got == BASE * 3
|
||||
|
||||
|
||||
def test_율_줄_못_셈_까닭():
|
||||
rate = {"이름": "공구손료", "단위": "%", "단가": {}, "비율": {"기준": "노무비", "비목": "경비"}}
|
||||
sk = _sk([{"고정": rate, "수량": 3}])
|
||||
with pytest.raises(ValueError, match="율"):
|
||||
dim.derive(sk, None, _whole())
|
||||
Reference in New Issue
Block a user