Merge remote-tracking branch 'origin/dev' into sub_laptop_7

This commit is contained in:
2026-11-18 07:19:27 +09:00
16 changed files with 445 additions and 179 deletions
+7 -1
View File
@@ -7,7 +7,7 @@
이 문서 셈 = 사본 줄 묶음이 이 문서 사본 안에 드는 색인(남의 SK · SC 참조 셈 = 제 사본 → 안 셈).
파일 꼴 그대로 — 옛 코드는 사본에 없는 줄을 지금 M01 로 읽음(지금 옵션에서 안 읽는 줄 = 금액 같음).
읽은 줄 없음(셈 안 돎) · 프로젝트 층 = 그대로 · 이미 저장된 파일은 다음 [저장] 때 줄어듦.
층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀) · 단가산출 빈 옛 칸 뺌.
층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀 · 단가산출 로직 줄 안 담음 855 L2 ⓑ) · 단가산출 빈 옛 칸 뺌.
"""
from __future__ import annotations
@@ -129,4 +129,10 @@ def trim(kind: str, doc: Any) -> Any:
form = out.get(dc.KEY) # 단가산출 · 일위대가 · 사전조합 같은 꼴(SC `수식` = 값 몫 + 부름)
if skc.has(out) and isinstance(form, dict) and isinstance(form.get("로직"), list):
out[dc.KEY] = {**form, **dc.values_of(out.pop(skc.KEY))}
form = out.get(dc.KEY)
if kind == "sangeun" and isinstance(form, dict) and isinstance(form.get("로직"), list):
out[dc.KEY] = {
**form,
**skc.held({"종류": "단가산출", dc.KEY: form}),
} # 로직 줄 안 씀(855 L2 ⓑ)
return out
+3 -1
View File
@@ -56,7 +56,8 @@ def gaps(copy: dict) -> list[str]:
except dc._ERR:
pass
have = _have(copy)
return sorted({*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have)
got = {*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have
return sorted(k for k in got if k[:2] not in skc.LOGIC) # 로직 줄 = 문서 사본(855 L2 ⓑ)
def fill(copy: dict) -> dict:
@@ -78,6 +79,7 @@ def fill_imported(sk: dict, doc: Any) -> dict:
seen = _Seen(dim._index(sk, None, doc))
dim.run(doc, sk, index=seen) # 셈 틀림 = 읽은 데까지(run 이 받음)
keys = sorted({*seen.keys, *mym.keys_in(doc), *own.keys_in(doc)} - _have(sk[skc.KEY]))
keys = [k for k in keys if k[:2] not in skc.LOGIC] # 로직 줄 안 담음(855 L2 ⓑ)
if not keys:
return sk
return {**sk, skc.KEY: skc.grow(sk[skc.KEY], skc.snap([], keys))}
+12 -10
View File
@@ -97,8 +97,8 @@ def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]:
if renew.on() and live is not None:
return dc.doc_of(whole, key), True
kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None
if kept:
return cp.deepcopy(kept), True
if kept: # 프로젝트 층 = 굳힐 때 문서 + 옛 자동값(855 L2 ⓑ — 전과 같은 옵션 값)
return cp.deepcopy(kept), renew.on()
if live is not None and live.get(mcv.HAND):
from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게
@@ -247,7 +247,8 @@ def copy_of(sk: dict, whole: Any = None) -> dict | None:
whole = dc.over(values)
calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름"))
base = str((sk.get("바탕") or {}).get("로직") or "")
seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지)
# 바탕 문서 판(「M01 새 판」 표지) = 셈에 쓴 기초 문서(층 = 지금 M01 · 프로젝트 = `바탕문서` · 855 L2 ⓑ)
seen = base_doc({**sk, KEY: got}, whole, base)[0] if base else None
origin = {"원본": {"키": base, "판": dc.doc_fp(seen)}} if seen else {}
return {**got, **values, "문서": root, "부름": calls, **origin}
@@ -315,17 +316,18 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict:
UPPER
): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1)
first[UPPER] = have[UPPER]
if not renew.on() and not patched(out): # 프로젝트 층 = 기초 문서 사본으로 굳힘(855 L2 ⓑ ㉣)
kept = None if job == skc.REGEN else (have or {}).get(BASE_DOC)
key = str((out.get("바탕") or {}).get("로직") or "")
if kept is None and key in dc.folder():
kept = base_doc({**out, KEY: {}}, whole, key)[0] # 굳히기 전과 같은 문서
if kept:
first[BASE_DOC] = norm(_bare_doc(kept))
copy = copy_of({**out, KEY: first}, whole)
if (
copy and skc.READS.get() is not None
): # 저장 관문 — 문서 셈 · 부름 줄이 읽은 줄을 적음(826-3)
): # 저장 관문 — 문서 셈이 읽은 줄을 적음(826-3 · 부름 = 문서 사본 · 로직 줄 안 둠 855 L2 ⓑ)
run({**out, KEY: copy}, copy, whole)
index = dc.over(copy)
for key in copy.get("부름") or {}: # 부름 문서를 가른 값 사본 줄(`dc.doc_of`)도 둠
try:
index.logic(key)
except dc._ERR:
pass
if (
copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy))
): # 파생 — 옛 로직 사본에 박음(822-1)
+2 -1
View File
@@ -271,7 +271,8 @@ def plain(mine: dict, sk: dict) -> dict:
def _rows(copy: dict) -> set[str]:
return {str(r.get("키")) for r in [*(copy.get("로직") or []), *(copy.get("단가") or [])]}
rows = [*skc.plain(copy.get("로직")), *(copy.get("단가") or [])] # 로직 줄 안 셈(855 L2 ⓑ)
return {str(r.get("키")) for r in rows}
def _basis(doc: dict, body: dict) -> dict:
+47 -8
View File
@@ -3,7 +3,9 @@
사본 = 저장 때 서버가 찍는 M01 닫힌 묶음(`M02_Item_Prices.collect` 다시 씀) — 셈 중 문서 칸 `사본` ·
층 저장 파일 = `수식` 의 값 몫 한 벌(`held` · 855 2-D — 파일엔 `사본` 안 씀 · 프로젝트 사본 꼴은 그대로):
{판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 줄], 빠진?}
로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직 · 찾기 표 · 그 밖 요소(요율 등)
로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직이 닿는 찾기 표 · 그 밖 요소(요율 등) —
단가산출 = 로직 줄(GF · GC · GX) 자체는 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름` · M01 바뀜 =
문서 지문) · 일위대가 · 사전조합 = 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 `Labor_Copy.stamp` 에서 뺌)
단가 = 자원 단가 줄(`RES` 노임 · 자재 · 기계 · 유가전력 · 환율) = 단가 기준 시점 묶음.
셈 = M01 색인 위에 사본 줄을 얹은 `Copy`(키 · 원문번호 찾기만 사본 먼저 · M01 색인 안 고침) —
`M02_Sangeun_Calc._base_of`(바탕 줄) · `run`(엔진 · 하위 로직 · 표 · 단가)이 `over` 로 부름 ·
@@ -67,16 +69,31 @@ def has(doc: Any) -> bool:
FORM = "수식" # 수식 사본 칸(`M02_Doc_Copy.KEY`) — 층 저장 파일의 값 사본 자리(855 2-D)
VALUES = ("판", "시점", "로직", "단가판", "단가시점", "단가")
#: M01 로직 줄 키 머리(GF · GC · GX) — 단가산출 값 사본에 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름`)
LOGIC = frozenset(t for t, g in prices.mf.mk.GROUP_OF.items() if g == "로직")
def plain(rows: Any) -> list:
"""값 사본 줄에서 로직 줄을 뺌(표 · 요율 · 자원 줄만)."""
return [r for r in rows or [] if not (isinstance(r, dict) and str(r.get("키"))[:2] in LOGIC)]
def _plain(copy: dict) -> dict:
"""단가산출 값 사본 — 로직 줄 뺀 꼴 · 판 다시(옛 저장본 = 읽을 때 뺌 · 파일은 다음 [저장] 때 새 꼴)."""
rows = plain(copy["로직"])
return copy if len(rows) == len(copy["로직"]) else {**copy, "로직": rows, "판": _fp(rows)}
def held(doc: Any) -> dict | None:
"""문서의 값 사본 — 셈 · 저장 중 `settle` 이 붙인 `사본` › 층 저장 파일 `수식` 의 값 몫(855 2-D ·
층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 없음 = None."""
층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 단가산출 = 로직 줄 뺌(855 L2 ⓑ) · 없음 = None."""
sk = isinstance(doc, dict) and doc.get("종류") == sd.TITLE
if has(doc):
return doc[KEY]
return _plain(doc[KEY]) if sk else doc[KEY]
form = doc.get(FORM) if isinstance(doc, dict) else None
if isinstance(form, dict) and isinstance(form.get("로직"), list):
return {k: form[k] for k in VALUES if k in form}
got = {k: form[k] for k in VALUES if k in form}
return _plain(got) if sk else got
return None
@@ -327,7 +344,7 @@ def settle(doc: Any, save: bool = False) -> Any:
if save and copy and READS.get() is None: # 읽은 줄만(826-3) = 저장 관문이 더함
copy = grow(copy, stamp(out))
out = _formula_job(out, job)
return {**out, KEY: copy} if copy else out
return {**out, KEY: _plain(copy)} if copy else out # 로직 줄 안 담음(855 L2 ⓑ)
def _formula_job(out: dict, job: Any) -> dict:
@@ -340,7 +357,14 @@ def _formula_job(out: dict, job: Any) -> dict:
if got is None or job not in (PRICE, REGEN):
return out
if job == REGEN: # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2)도 버림
drop = ("문서", "끊음", "따로", "처음", *renew.KEEP)
drop = (
"문서",
"끊음",
"따로",
"처음",
"바탕문서",
*renew.KEEP,
) # 바탕문서 = 프로젝트 굳힘(855 L2 ⓑ)
got = {k: v for k, v in got.items() if k not in drop} | {"부름": {}}
elif got.get("따로"):
got = dc.refresh(got)[0]
@@ -373,7 +397,22 @@ def mark(ans: dict, doc: dict) -> dict:
return ans
copy = doc[KEY]
head = {"시점": copy.get("시점"), "단가시점": copy.get("단가시점")}
return {**ans, KEY: {**head, **state(copy, whole_())}}
got = state(copy, whole_())
if not got["M01새판"] and _doc_moved(doc):
got = {**got, "M01새판": True}
return {**ans, KEY: {**head, **got}}
def _doc_moved(doc: dict) -> bool:
"""M01 바뀜 = 수식 사본 문서(부름 · 원본) 지문 ≠ 지금 M01 문서(855 L2 ⓑ · 로직 줄 값 사본 대신) ·
자동 따라옴 SK = 늘 지금 문서라 안 봄."""
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
form = doc.get(FORM)
if not dc.has(doc) or (renew.is_sk(doc) and renew.on() and not renew.frozen(form)):
return False
return bool(dc.state(form)["문서새판"])
def same_part(doc: Any) -> str | None:
@@ -382,5 +421,5 @@ def same_part(doc: Any) -> str | None:
if copy is None:
return None
seen = state(copy, whole_())
fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"])
fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"] or _doc_moved(doc))
return None if fresh else f"{copy.get('판')}:{copy.get('단가판')}"
+2 -2
View File
@@ -97,9 +97,9 @@ def rows(copy: Any) -> Any:
return {**copy, **hit}
got: dict = {}
for part, mark in (("로직", "판"), ("단가", "단가판")):
old = copy.get(part) or []
old = skc.plain(copy.get(part)) # 로직 줄 = 문서 사본 · 값 사본에 안 둠(855 L2 ⓑ)
new = [_fresh(r, live) if isinstance(r, dict) else r for r in old]
if any(a is not b for a, b in zip(old, new)):
if len(old) != len(copy.get(part) or []) or any(a is not b for a, b in zip(old, new)):
got |= {part: new, mark: skc._fp(new)}
if len(_MEMO) > 64: # ponytail: 통째 비움 · SK 가 많아 느려지면 LRU 로
_MEMO.clear()
@@ -0,0 +1,175 @@
# -*- coding: utf-8 -*-
"""마스터 바탕 기반 — 요소 · 표 색인(`Master`) · 표 줄 찾기(`find`) · 오류 · 비목 이름 · 재료 고르기 이음.
옛 엔진(`master_formula` — 식 읽기 · 셈 · 끝수)과 새 계산기(`master_doc_*`) · 불러오기 · 서고가 같이 씀.
`master_formula` 는 이 이름들을 그대로 다시 내보냄(855-E 2-E4 준비 — 엔진 몸을 지워도 이 모듈은 남음).
"""
from __future__ import annotations
from decimal import Decimal
import master_keys as mk
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
TABLE_GROUPS = ("소요량", "계수")
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
COST_ITEMS = ("노무비", "재료비", "경비")
BUNDLE = (*COST_ITEMS, "계")
class FormulaError(ValueError):
pass
class EmptyInput(FormulaError):
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
class NoRow(EmptyInput):
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
def _plain(v) -> str:
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
# ── 마스터 모음 ────────────────────────────────────────────────────────
class Master:
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
def __init__(self, files: dict[str, dict]):
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
for data in files.values():
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
for row in rows or []:
key = str(row.get("키"))
self.index.setdefault(key[:2], {}).setdefault(key, row)
if row.get("원문번호"):
number = str(row["원문번호"])
slot = self.numbers.setdefault(key[:2], {})
if number in slot:
self.twice.add((key[:2], number))
slot.setdefault(number, row)
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
def get(self, ref: str) -> dict:
tid, _, number = ref.partition(":")
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
elif number:
if (tid, number) in self.twice:
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
row = self.numbers.get(tid, {}).get(number)
else:
row = self.index.get(ref[:2], {}).get(ref)
if row is None:
raise FormulaError(f"없는 요소 「{ref}」")
return row
def label(self, ref) -> str:
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
if isinstance(ref, dict):
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
try:
row = self.get(ref)
except FormulaError:
return ref
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
def value(self, ref: str):
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
row = self.get(ref)
alias = row.get("준용")
if alias not in (None, ""):
target = self.get(str(alias))
name = target.get("이름") or alias
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
return row.get("값"), f"추정(준용: {name})"
return target.get("값"), f"준용: {name}"
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
def logic(self, ref: str) -> dict:
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
raise FormulaError(f"로직 아님 「{ref}」")
return self.get(ref)
# ── 표 줄 찾기 ────────────────────────────────────────────────────────
def _match(table: dict, row: dict, cond: str, want) -> bool:
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
return True
have = row[cond]
if table.get("조건", {}).get(cond) == "범위":
low, high = have
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
if rule == "이상·이하":
return (low is None or want >= low) and (high is None or want <= high)
if rule == "초과·이하":
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·미만":
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
closed = any("이하 포함" in x for x in more) and high == top
return (low is None or want >= low) and (
high is None or want < high or (closed and want == high)
)
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
return (low is None or want >= low) and (high is None or want <= high)
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
return have == want
def _name(row: dict) -> str:
return f"{row.get('키')} {row.get('원문번호')}"
def find(table: dict, conds: dict, want: str | None = None) -> dict:
for cond in conds:
if cond not in table.get("조건", {}):
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
for c in conds:
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
if ups and None not in ups:
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
hits = [row for row in hits if want in row]
if len(hits) != 1:
where = f"표 {table.get('키')}({table.get('원문번호')})"
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
raise NoRow(
f"{where}에 {what} 인 줄이 없음"
if not hits
else f"{where}에 {what} 인 줄이 {len(hits)}개"
)
return hits[0]
# 품셈재료 단가 · 고르기 — 서로 부르는 모듈이라 끝에서 읽음
from master_material import ( # noqa: E402, F401
LINKED,
PICK_KEYS,
REGION,
SLOTS,
TARIFF,
candidates,
check_pick,
check_unit,
static,
cond_text,
element,
pick,
)
import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위
@@ -11,7 +11,7 @@
from __future__ import annotations
import master_doc as md
import master_formula as mf # 마스터 색인(`Master.get`) — 없는 키 = FormulaError
import master_base as mf # 바탕 기반 · 마스터 색인(`Master.get`) — 없는 키 = FormulaError
import master_keys as mk
import master_material as mm # 재료 고르기 조건 검사(`check_pick`)
@@ -20,7 +20,7 @@ from pathlib import Path
import master_doc as md
import master_doc_calc as mc
import master_formula as mf
import master_base as mf # 바탕 기반(색인 · 오류)
import master_machine_crew as mcrew
import master_material as mm
import master_pick as mp
@@ -13,7 +13,7 @@
from __future__ import annotations
import master_doc_calc as mc
import master_formula as mf
import master_base as mf # 바탕 기반(색인 · 오류)
class Rec:
+16 -143
View File
@@ -3,6 +3,7 @@
식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게).
`check_master.py` 가 부름.
바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄.
"""
from __future__ import annotations
@@ -12,15 +13,22 @@ import re
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
import master_keys as mk
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
from master_base import ( # noqa: F401 — 바탕 기반(855-E 2-E4 준비) · 이름은 여기서 그대로
BUNDLE,
COST_ITEMS,
GROUPS,
TABLE_GROUPS,
TABLE_IDS,
EmptyInput,
FormulaError,
Master,
NoRow,
_match,
_name,
_plain,
find,
)
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
TABLE_GROUPS = ("소요량", "계수")
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
COST_ITEMS = ("노무비", "재료비", "경비")
BUNDLE = (*COST_ITEMS, "계")
FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대")
_NAME = re.compile(r"[\w가-힣]+")
_NUMBER = re.compile(r"\d+(?:\.\d+)?")
@@ -38,18 +46,6 @@ def inputs_of(row: dict) -> list[dict]:
raise FormulaError(FLOW_GONE)
class FormulaError(ValueError):
pass
class EmptyInput(FormulaError):
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
class NoRow(EmptyInput):
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
class Blank:
"""못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움."""
@@ -57,11 +53,6 @@ class Blank:
self.why = why
def _plain(v) -> str:
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
# ── 읽기 ──────────────────────────────────────────────────────────────
class _Parser:
def __init__(self, text: str):
@@ -257,70 +248,6 @@ def walk(node):
yield from walk(item)
# ── 마스터 모음 ────────────────────────────────────────────────────────
class Master:
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
def __init__(self, files: dict[str, dict]):
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
for data in files.values():
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
for row in rows or []:
key = str(row.get("키"))
self.index.setdefault(key[:2], {}).setdefault(key, row)
if row.get("원문번호"):
number = str(row["원문번호"])
slot = self.numbers.setdefault(key[:2], {})
if number in slot:
self.twice.add((key[:2], number))
slot.setdefault(number, row)
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
def get(self, ref: str) -> dict:
tid, _, number = ref.partition(":")
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
elif number:
if (tid, number) in self.twice:
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
row = self.numbers.get(tid, {}).get(number)
else:
row = self.index.get(ref[:2], {}).get(ref)
if row is None:
raise FormulaError(f"없는 요소 「{ref}」")
return row
def label(self, ref) -> str:
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
if isinstance(ref, dict):
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
try:
row = self.get(ref)
except FormulaError:
return ref
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
def value(self, ref: str):
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
row = self.get(ref)
alias = row.get("준용")
if alias not in (None, ""):
target = self.get(str(alias))
name = target.get("이름") or alias
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
return row.get("값"), f"추정(준용: {name})"
return target.get("값"), f"준용: {name}"
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
def logic(self, ref: str) -> dict:
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
raise FormulaError(f"로직 아님 「{ref}」")
return self.get(ref)
def fill(template: str, env: dict) -> str:
def one(m):
if m.group(1) not in env:
@@ -338,60 +265,6 @@ def _round(x: Decimal, places, mode) -> Decimal:
return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode)
def _match(table: dict, row: dict, cond: str, want) -> bool:
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
return True
have = row[cond]
if table.get("조건", {}).get(cond) == "범위":
low, high = have
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
if rule == "이상·이하":
return (low is None or want >= low) and (high is None or want <= high)
if rule == "초과·이하":
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·미만":
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
closed = any("이하 포함" in x for x in more) and high == top
return (low is None or want >= low) and (
high is None or want < high or (closed and want == high)
)
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
return (low is None or want >= low) and (high is None or want <= high)
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
return have == want
def _name(row: dict) -> str:
return f"{row.get('키')} {row.get('원문번호')}"
def find(table: dict, conds: dict, want: str | None = None) -> dict:
for cond in conds:
if cond not in table.get("조건", {}):
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
for c in conds:
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
if ups and None not in ups:
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
hits = [row for row in hits if want in row]
if len(hits) != 1:
where = f"표 {table.get('키')}({table.get('원문번호')})"
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
raise NoRow(
f"{where}에 {what} 인 줄이 없음"
if not hits
else f"{where}에 {what} 인 줄이 {len(hits)}개"
)
return hits[0]
def evaluate(node, env: dict, master: Master, depth: int = 0):
kind = node[0]
if kind in ("num", "str"):
@@ -284,5 +284,5 @@ def element(
return min(offers, key=lambda x: x[0]) if offers else (None, None)
import master_formula as mf # noqa: E402 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_base as mf # noqa: E402 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_pick as mp # noqa: E402 — 검색어 찾기
+1 -1
View File
@@ -230,4 +230,4 @@ def check_warn(master, where: str, cond: dict, unit: str | None) -> list[str]:
return []
import master_formula as mf # noqa: E402, F401 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_base as mf # noqa: E402, F401 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
+15 -8
View File
@@ -47,9 +47,18 @@ def _fake(monkeypatch, rows=(), drop=()):
from M02_MasterTemplete import M02_Doc_Copy as dc
files, live = m01.loaded()
fake = skc.Copy(live, [copy.deepcopy(r) for r in rows])
fake = copy.copy(
live
) # M01 꼴 그대로(값 사본 색인 `skc.Copy` 로 만들면 `dc.base` 가 벗김 · 855 L2 ⓑ)
fake.index = {t: dict(v) for t, v in live.index.items()}
fake.numbers = {t: dict(v) for t, v in live.numbers.items()}
for row in rows:
row, key = copy.deepcopy(row), str(row["키"])
fake.index.setdefault(key[:2], {})[key] = row
if row.get("원문번호"):
fake.numbers.setdefault(key[:2], {})[str(row["원문번호"])] = row
for key in drop:
skc.Copy._own(fake.index, live.index, key[:2]).pop(key, None)
fake.index.get(key[:2], {}).pop(key, None)
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
docs = {k: v for k, v in dc.folder().items() if k not in drop}
docs |= {str(r["키"]): dc.cv.convert(fake, copy.deepcopy(r))[0] for r in rows if "호표" in r}
@@ -93,7 +102,7 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch):
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
got = skc.held(_doc(me, key))
assert PCT in {r["키"] for r in got["로직"]}
assert PCT not in {r["키"] for r in got["로직"]} # 로직 줄 = 문서 사본(855 L2 ⓑ)
assert got["단가"] and all(r["키"][:2] in skc.RES for r in got["단가"])
assert not any(r["키"][:2] in skc.RES for r in got["로직"])
first = _calc(me, _doc(me, key))
@@ -130,17 +139,15 @@ def test_price_refresh_only_on_press(world, monkeypatch):
def test_deleted_keys_keep_last_value(world, monkeypatch):
"""⑤ 사본이 부르는 M01 키(바탕 로직 · 노임)가 지워져도 마지막 값 · 지운키 표지."""
"""⑤ 사본이 부르는 M01 노임이 지워져도 마지막 값 · 지운키 표지(바탕 로직 = M01 이 지우기 막음 409)."""
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
was = _sum(me, key)
lb = next(r["키"] for r in skc.held(_doc(me, key))["단가"] if r["키"].startswith("LB"))
_fake(monkeypatch, drop=[PCT, lb])
with pytest.raises(Exception):
m01.loaded()[1].logic(PCT)
_fake(monkeypatch, drop=[lb])
now = _calc(me, _doc(me, key))
assert now["기준"]["계"] == was
assert {PCT, lb} <= set(now["사본"]["지운키"])
assert {lb} <= set(now["사본"]["지운키"])
with store.at(me):
got = path.preview(key, {"할일": skc.PRICE})
assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"]
+111
View File
@@ -0,0 +1,111 @@
"""855-E 2-E4 준비 지킴 — 바탕 기반(`master_base`)만으로 새 계산기가 셈.
- 새 해석기(자식)가 scripts 길만 두고 `master_base` · `master_doc_link` · `master_doc_calc` 를 읽어
견본 로직(기본 + 옵션 표본)을 셈 → 옛 엔진 몸(`master_formula` 무리)이 한 번도 안 읽힘.
- 그 답 지문 = 골든(`golden_855_engine.json` · `test_855_golden` 과 같은 지문 규칙)과 같음.
"""
from __future__ import annotations
import hashlib
import json
import os
import subprocess
import sys
from decimal import Decimal
from pathlib import Path
HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[1]
SCRIPTS = ROOT / "resources" / "master_data" / "scripts"
N = 24 # 견본 로직 수(키 차례 고르게)
ENGINE = ( # 엔진 몸 — 자식에서 읽히면 실패
"master_formula",
"master_formula_check",
"master_formula_sum",
"master_cut",
"master_text",
"master_text_item",
"master_auto",
"master_combo",
"master_sheet_line",
"master_gate",
"master_equation",
"check_master",
)
def _enc(v):
if isinstance(v, Decimal):
return {"$d": str(v)}
raise TypeError(type(v).__name__)
def _dec(d: dict):
return Decimal(d["$d"]) if set(d) == {"$d"} else d
def _child() -> None:
"""자식 — 표준 입력 {키: [[옵션 글, 바뀐 입력]]} → {답: {키: [[옵션 글, 셈 답]]}, 읽힌 엔진: [...]}."""
sys.path.insert(0, str(SCRIPTS))
import master_base as mb
import master_doc_calc as mc
import master_doc_link as ml
import master_machine_files as mmf
folder = Path(os.environ.get("AISLO_MASTER_DIR") or SCRIPTS.parent).resolve()
files = {}
for name in mmf.names(folder): # `M01_MasterData_Store_Cache.loaded` 와 같은 읽기
if name == mmf.NAME and mmf.here(folder):
files[name] = mmf.table(folder)[0]
elif not name.startswith("_"):
raw = (folder / name).read_bytes()
files[name] = json.loads(raw, parse_float=Decimal, parse_int=Decimal)
docs = ml.load_all()
links = ml.Links(mb.Master(files), docs)
want = json.loads(sys.stdin.buffer.read().decode("utf-8"), object_hook=_dec)
out = {}
for key, cases in want.items():
rows = []
for label, changed in cases:
try:
got = mc.calc(docs[key], links, changed)
except Exception:
got = None
rows.append([label, got if got and got.get("셈됨") else None])
out[key] = rows
body = {"답": out, "읽힌 엔진": sorted(m for m in ENGINE if m in sys.modules)}
sys.stdout.buffer.write(json.dumps(body, ensure_ascii=False, default=str).encode("utf-8"))
def test_바탕_기반만으로_새_계산기_지문_골든과_같음():
import helper_855_engine as h
from helper_test_all import spread
rows, _, docs, _ = h.world()
rows = spread([r for r in rows if str(r["키"]) in docs], N)
want = {
str(r["키"]): [[label, changed] for label, _, changed in h.cases(r, True)] for r in rows
}
run = subprocess.run(
[sys.executable, str(Path(__file__)), "--child"],
input=json.dumps(want, ensure_ascii=False, default=_enc).encode("utf-8"),
capture_output=True,
cwd=str(ROOT),
timeout=600,
)
assert run.returncode == 0, run.stderr.decode("utf-8", "replace")[-2000:]
body = json.loads(run.stdout.decode("utf-8"))
assert body["읽힌 엔진"] == [], f"엔진 몸이 읽힘 {body['읽힌 엔진']}"
golden = json.loads((HERE / "golden_855_engine.json").read_text("utf-8"))["지문"]
diff = []
for key, cases in body["답"].items():
got = [[label, h.answer(g)] for label, g in cases]
raw = json.dumps(got, ensure_ascii=False, sort_keys=True)
if hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] != golden[key]:
diff.append(key)
assert len(body["답"]) == len(rows) and not diff, f"지문 다름 {diff}"
if __name__ == "__main__" and "--child" in sys.argv:
_child()
@@ -0,0 +1,50 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""855 L2 ⓑ-1 — 단가산출 값 사본에 M01 로직 줄(GF · GC · GX)을 안 담음 · 옛 저장본의 로직 줄은 안 읽음 ·
일위대가(SC) 값 사본은 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 뺌).
임시 storage · 개인 층. 셈 = 수식 문서 사본(`부름`) · 로직 줄 값 사본이 없어도 금액 같음.
"""
from __future__ import annotations
import copy
import json
from decimal import Decimal
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from resources.tester.test_795_1_sk_copy import _doc, _sk
from resources.tester.test_795_2_sc_copy import PCT, _read, _sc
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
def _logic_rows(doc: dict) -> list[str]:
rows = [r for slot in ("수식", "사본") for r in ((doc.get(slot) or {}).get("로직") or [])]
return [str(r["키"]) for r in rows if str(r["키"])[:2] in skc.LOGIC]
def _sum(folder, doc) -> Decimal:
with store.at(folder):
return Decimal(str(calc.run(doc, m01.loaded()[1])["기준"]["계"]))
def test_저장본에_로직줄_없음_금액_같음(world):
me = world["personal"]
sk = _doc(me, _sk(me, 바탕={"로직": PCT}))
sc = _read(me, "precombo", _sc(me, [{"로직": PCT, "수량": {"손": 1}}]))
assert _logic_rows(sk) == [] and PCT in _logic_rows(sc)
assert _sum(me, sk) > 0
def test_옛_저장본_로직줄은_안_읽음(world):
me = world["personal"]
sk = _doc(me, _sk(me, 바탕={"로직": PCT}))
was = _sum(me, sk)
old = copy.deepcopy(sk) # 옛 꼴 — 값 사본에 바탕 로직 줄(값을 틀리게 바꾼 것)
row = json.loads(json.dumps(m01.loaded()[1].logic(PCT), default=str))
row["호표"] = row["호표"][:1]
old["수식"]["로직"] = [*old["수식"]["로직"], row]
assert skc.held(old)["로직"] == skc.held(sk)["로직"]
assert _sum(me, old) == was