Merge remote-tracking branch 'origin/dev' into sub_laptop_3
This commit is contained in:
@@ -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
|
||||
|
||||
@@ -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))}
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
"""M02 일위대가 입력 목록(39-3).
|
||||
|
||||
담은 단가산출 로직마다 입력 전부 · 로직마다 갈라 보이고 이름이 같아도 합치지 않음 · 입력 목록은
|
||||
그 로직 줄의 `입력` 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직 입력으로만) · 자동값 =
|
||||
`master_auto.values`(보기용 · 저장 안 함). 일위대가 입력 모달(`GET /api/m02/logic-lib/inputs`)이
|
||||
씀. M01 은 읽기만 · 권한은 부르는 쪽 몫.
|
||||
그 수식 문서의 입력 변수(갈래 입력 · 선택) 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직
|
||||
입력으로만) · 자동값 = `M02_Doc_Copy.auto_of`(보기용 · 저장 안 함). 일위대가 입력 모달
|
||||
(`GET /api/m02/logic-lib/inputs`)이 씀. M01 은 읽기만(수식 문서 · 855 L2 ⓑ) · 권한은 부르는 쪽 몫.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -12,10 +12,10 @@ import re
|
||||
from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as m01doc
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
|
||||
|
||||
_SPEC = ("이름", "설명", "단위", "고르기", "범위")
|
||||
INPUTS = ("입력", "선택") # 문서 입력 변수 갈래
|
||||
_LAYERED = "골쌓기 기준" # 85-2 — 표 주문에 이 글이 있으면 켜쌓기율 대상 로직
|
||||
_NUMBER = re.compile(r"(?<![\d-])\d+(?:-\d+)+(?![\d-])") # 품셈 절 번호(「12-1-3」)
|
||||
|
||||
@@ -31,16 +31,27 @@ def _num(value: Any) -> Any:
|
||||
return value
|
||||
|
||||
|
||||
def _logics(codes: list[str]) -> tuple[list[dict], list[str]]:
|
||||
"""([로직 줄 …], 빠진 로직 키) — 키 차례 그대로."""
|
||||
whole = m01.loaded()[1]
|
||||
found, missing = [], []
|
||||
for code in codes:
|
||||
try:
|
||||
found.append(whole.logic(code))
|
||||
except combo_store.cm.mf.FormulaError:
|
||||
missing.append(code)
|
||||
return found, missing
|
||||
def _docs(codes: list[str]) -> tuple[list[dict], list[str]]:
|
||||
"""([수식 문서 …], 빠진 로직 키) — 키 차례 그대로."""
|
||||
docs = m01doc.docs()
|
||||
found = [docs[code] for code in codes if code in docs]
|
||||
return found, [code for code in codes if code not in docs]
|
||||
|
||||
|
||||
def specs(doc: dict) -> list[dict[str, Any]]:
|
||||
"""문서 입력 변수 → 입력 칸 `{이름: 열쇠, 설명, 단위, 고르기?(선택 목록), 범위?}`(변수 차례)."""
|
||||
out = []
|
||||
for v in doc.get("변수") or []:
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") not in INPUTS or not v.get("열쇠"):
|
||||
continue
|
||||
one = {"이름": v["열쇠"], "설명": v.get("설명") or None, "단위": v.get("단위") or None}
|
||||
if link.get("갈래") == "선택":
|
||||
one["고르기"] = list(link.get("목록") or [])
|
||||
if link.get("범위"):
|
||||
one["범위"] = list(link["범위"])
|
||||
out.append(one)
|
||||
return out
|
||||
|
||||
|
||||
def layered() -> set[str]:
|
||||
@@ -65,50 +76,51 @@ def _labels(whole: Any, spec: dict) -> dict[str, str]:
|
||||
return out
|
||||
|
||||
|
||||
def sources(logic: dict) -> Any:
|
||||
"""원문 출처(222-1) — 로직 `출처` + 호표 · 입력 · 중간 · 덧줄 `출처` 가운데 같은 책(번호 앞 글이
|
||||
같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이 절마다 찾음 · M01
|
||||
`make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로."""
|
||||
main = str(logic.get("출처") or "")
|
||||
def sources(doc: dict) -> Any:
|
||||
"""원문 출처(222-1) — 문서 `출처` + 금액 수량 줄 · 변수 · 금액 식 줄(수량 없음) `출처`
|
||||
가운데 같은 책(번호 앞 글이 같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이
|
||||
절마다 찾음 · M01 `make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로."""
|
||||
main = str(doc.get("출처") or "")
|
||||
head = _NUMBER.search(main)
|
||||
if not head:
|
||||
return logic.get("출처")
|
||||
return doc.get("출처")
|
||||
book, seen = main[: head.start()], set(_NUMBER.findall(main))
|
||||
money = [x for x in doc.get("금액") or [] if isinstance(x, dict)]
|
||||
rows = [x for x in money if "수량" in x] + list(doc.get("변수") or [])
|
||||
extra = []
|
||||
for part in ("호표", "입력", "중간", "덧줄"):
|
||||
for row in logic.get(part) or []:
|
||||
src = str(row.get("출처") or "") if isinstance(row, dict) else ""
|
||||
hit = _NUMBER.search(src)
|
||||
if hit and src[: hit.start()] == book and hit.group() not in seen:
|
||||
seen.add(hit.group())
|
||||
extra.append(hit.group())
|
||||
for row in rows + [x for x in money if "수량" not in x]:
|
||||
src = str(row.get("출처") or "") if isinstance(row, dict) else ""
|
||||
hit = _NUMBER.search(src)
|
||||
if hit and src[: hit.start()] == book and hit.group() not in seen:
|
||||
seen.add(hit.group())
|
||||
extra.append(hit.group())
|
||||
return " · ".join([main, *extra])
|
||||
|
||||
|
||||
def _listed(logics: list[dict]) -> list[dict[str, Any]]:
|
||||
"""로직 줄마다 `{로직, 이름, 결과단위, 출처, 켜쌓기, 입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`."""
|
||||
def _listed(docs: list[dict]) -> list[dict[str, Any]]:
|
||||
"""문서마다 `{로직, 이름, 결과단위, 출처, 켜쌓기,
|
||||
입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
|
||||
whole = m01.loaded()[1]
|
||||
layers = layered()
|
||||
out = []
|
||||
for logic in logics:
|
||||
auto = m01.mau.values(whole, logic)
|
||||
specs = []
|
||||
for spec in logic.get("입력") or []:
|
||||
one = {k: spec[k] for k in _SPEC if k in spec}
|
||||
one.setdefault("설명", None)
|
||||
one.setdefault("단위", None)
|
||||
labels = _labels(whole, spec)
|
||||
for doc in docs:
|
||||
auto = dc.auto_of(doc, whole)
|
||||
rows = []
|
||||
for one in specs(doc):
|
||||
labels = _labels(whole, one)
|
||||
if labels:
|
||||
one["고르기이름"] = labels
|
||||
specs.append({**one, "자동값": auto.get(spec["이름"])})
|
||||
rows.append({**one, "자동값": auto.get(one["이름"])})
|
||||
out.append(
|
||||
{
|
||||
"로직": logic.get("키"),
|
||||
"이름": logic.get("이름"),
|
||||
"결과단위": logic.get("결과단위"),
|
||||
"출처": sources(logic),
|
||||
"켜쌓기": logic.get("키") in layers,
|
||||
"입력": specs,
|
||||
"로직": doc.get("키"),
|
||||
"이름": doc.get("이름"),
|
||||
"결과단위": doc.get("결과단위"),
|
||||
"출처": sources(doc),
|
||||
"켜쌓기": doc.get("키") in layers,
|
||||
"입력": rows,
|
||||
}
|
||||
)
|
||||
return out
|
||||
@@ -116,5 +128,5 @@ def _listed(logics: list[dict]) -> list[dict[str, Any]]:
|
||||
|
||||
def logic_inputs(codes: list[str]) -> dict[str, Any]:
|
||||
"""일위대가 입력 모달 — 로직 키들의 입력 목록 `{로직: [...], 빠진로직}`(키 차례 · 겹침 한 번)"""
|
||||
found, missing = _logics(list(dict.fromkeys(c for c in codes if c)))
|
||||
found, missing = _docs(list(dict.fromkeys(c for c in codes if c)))
|
||||
return _num({"로직": _listed(found), "빠진로직": missing})
|
||||
|
||||
@@ -1,115 +0,0 @@
|
||||
"""M02 기준 목록 · 계산서 끝수(PLAN 704-2 딸림) — B09 산근 끝수 규칙으로 셈(③ 서버 단독 ·
|
||||
`B09_Estimation_Sangeun` 과 규칙 짝 · 거울 시험 `test_704_settle`).
|
||||
|
||||
줄 금액 = ROUNDDOWN(단가 × 수량, 1) 비목마다 · 비목 총계 = ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합 ·
|
||||
작업량 Q(중간 이름 Q · Q1 …) = ROUND(식, 2) 뒤 쓰임 · % 덧줄 밑수 = 그때까지 줄 합(줄 끝수 뒤).
|
||||
근거 = 지식DB `technical_info/01_임도/05_원가정보/단수처리_규칙.md`(행 금액 절사 · 관측 후보 규칙).
|
||||
M01 엔진(`master_formula.run`)의 구조 그대로 — 끝수 자리만 다름(엔진은 줄 끝수 없이 계에서 한 번).
|
||||
하위 로직(기계경비 포함)은 같은 규칙으로 다시 셈 · 흐름 · 결과 로직은 엔진 값 그대로.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from decimal import ROUND_DOWN, ROUND_HALF_UP, Decimal
|
||||
from typing import Any
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
|
||||
mf = m01.cm.mf
|
||||
_Q = re.compile(r"Q\d*")
|
||||
|
||||
|
||||
def _down(value: Any, places: int) -> Any:
|
||||
return None if value is None else mf._round(Decimal(value), places, ROUND_DOWN)
|
||||
|
||||
|
||||
def _bundle(whole: Any, item: dict, env: dict, depth: int) -> dict:
|
||||
"""로직 호표 줄이 부르는 하위 로직 — 같은 규칙으로 다시 셈(엔진 `logic` 마디 그대로)."""
|
||||
node = mf.parse(item["요소"])
|
||||
if node[0] != "logic":
|
||||
return mf.evaluate(node, env, whole, depth)
|
||||
given = {k: mf.evaluate(v, env, whole, depth) for k, v in node[2]}
|
||||
got = settle(whole, mf.fill(node[1], env), given, depth + 1)
|
||||
return got["결과"] if "결과" in got else {k: got[k] for k in mf.BUNDLE}
|
||||
|
||||
|
||||
def settle(whole: Any, ref: str, given: dict, depth: int = 0) -> dict:
|
||||
"""`master_formula.run` 과 같은 꼴 `{줄, 노무비, 재료비, 경비, 계, 중간}` — 끝수만 B09 규칙."""
|
||||
row = whole.logic(ref)
|
||||
if isinstance(row.get("흐름"), dict) or "결과" in row:
|
||||
return mf.run(whole, ref, given, depth)
|
||||
env = mf._inputs(row, given)
|
||||
for step in row.get("중간", []):
|
||||
try:
|
||||
value = mf.evaluate(mf.parse(step["식"]), env, whole, depth)
|
||||
except mf.EmptyInput as e:
|
||||
env[step["이름"]] = mf.Blank(str(e))
|
||||
continue
|
||||
if _Q.fullmatch(step["이름"]) and isinstance(value, Decimal):
|
||||
value = value.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
|
||||
env[step["이름"]] = value
|
||||
lines: list[dict] = []
|
||||
for n, item in enumerate(row.get("호표", [])):
|
||||
try:
|
||||
qty = mf.evaluate(mf.parse(item["수량"]), env, whole, depth)
|
||||
if item["종류"] == "로직":
|
||||
bundle = _bundle(whole, item, env, depth)
|
||||
price = bundle["계"]
|
||||
split = (
|
||||
{k: qty * bundle[k] for k in mf.COST_ITEMS}
|
||||
if "비목" not in item
|
||||
else {item["비목"]: qty * price}
|
||||
)
|
||||
else:
|
||||
ref_ = (
|
||||
{
|
||||
k: mf.fill(v, env) if isinstance(v, str) else v
|
||||
for k, v in item["요소"].items()
|
||||
}
|
||||
if isinstance(item["요소"], dict)
|
||||
else mf.fill(item["요소"], env)
|
||||
)
|
||||
if isinstance(ref_, str) and qty != 0:
|
||||
whole.get(ref_)
|
||||
price = mf.mp.priced(whole, item, ref_, env, n if depth == 0 else None)[0]
|
||||
if price is None and qty == 0:
|
||||
price = Decimal(0)
|
||||
split = {item["비목"]: None if price is None else qty * price}
|
||||
except mf.EmptyInput as e:
|
||||
lines.append(mf._blank_line(item, str(e)))
|
||||
continue
|
||||
lines.append(_line(item["이름"], split))
|
||||
sums = {k: sum((x["비목"].get(k) or 0 for x in lines), Decimal(0)) for k in mf.COST_ITEMS}
|
||||
env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None}
|
||||
for extra in row.get("덧줄", []):
|
||||
env.update(sums)
|
||||
try:
|
||||
value = mf.evaluate(mf.parse(extra["식"]), env, whole, depth)
|
||||
env[extra["이름"]] = value
|
||||
except mf.FormulaError:
|
||||
value = None
|
||||
sums[extra["비목"]] += _down(value, 1) or 0
|
||||
lines.append(_line(extra["이름"], {extra["비목"]: value}))
|
||||
if value is not None:
|
||||
env["줄"][extra["이름"]] = lines[-1]["금액"]
|
||||
sums = {k: mf.cut(row, _down(v, 0), "계") for k, v in sums.items()}
|
||||
return {"줄": lines, **sums, "계": sum(sums.values()), "중간": mf._shown(env)}
|
||||
|
||||
|
||||
def _line(name: str, split: dict) -> dict:
|
||||
cut = {k: _down(v, 1) for k, v in split.items()}
|
||||
whole_sum = None if all(v is None for v in cut.values()) else sum(v or 0 for v in cut.values())
|
||||
return {"이름": name, "비목": cut, "금액": whole_sum}
|
||||
|
||||
|
||||
def apply(groups: list[dict], engine: dict, done: dict) -> None:
|
||||
"""계산서 묶음의 줄 금액 · 소계를 `settle` 값으로 바꿈 — 줄 차례는 엔진과 같음."""
|
||||
seq: dict[str, list] = {k: [] for k in mf.COST_ITEMS}
|
||||
for eng, mine in zip(engine["줄"], done["줄"]):
|
||||
for part, _ in m01.mtx._shares(eng):
|
||||
seq[part].append(mine["비목"].get(part))
|
||||
for group in groups:
|
||||
for line, amount in zip(group["줄"], seq.get(group["비목"], [])):
|
||||
line["금액"] = amount
|
||||
group["소계"] = done[group["비목"]]
|
||||
@@ -8,13 +8,12 @@
|
||||
바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌).
|
||||
금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) ·
|
||||
계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판).
|
||||
(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.)
|
||||
목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본
|
||||
(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` ·
|
||||
같으면 안 셈 ·
|
||||
셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸).
|
||||
실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음.
|
||||
이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫).
|
||||
이름표(이름 · 구분 · 출처 · 별칭) · 기초 차례(장 차례) = 수식 문서(`M01_MasterData_Doc` · 855 L2 ⓑ).
|
||||
M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인).
|
||||
"""
|
||||
|
||||
@@ -196,8 +195,8 @@ def _spec(given: dict, ax: list) -> str:
|
||||
return " · ".join(parts)
|
||||
|
||||
|
||||
def _unit(logic: dict) -> str:
|
||||
unit = str(logic.get("결과단위") or "")
|
||||
def _unit(doc: dict) -> str:
|
||||
unit = str(doc.get("결과단위") or "")
|
||||
return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit)
|
||||
|
||||
|
||||
@@ -223,24 +222,21 @@ def _money(doc: dict, links: Any, given: dict) -> Decimal | None:
|
||||
return got.get("계") if got.get("계") is not None else got.get("결과")
|
||||
|
||||
|
||||
def _rows_of(whole: Any, logic: dict, blocked: bool, links: Any = None) -> list[dict]:
|
||||
doc = m01_doc.docs().get(str(logic.get("키")))
|
||||
if doc is None:
|
||||
return []
|
||||
def _rows_of(whole: Any, doc: dict, blocked: bool, links: Any = None) -> list[dict]:
|
||||
links = links or _links(whole)
|
||||
base, ax = axes(whole, doc)
|
||||
changes: list[dict] = [{}]
|
||||
for name, reps in ax:
|
||||
changes += [{name: v} for v, _ in reps if v != base.get(name)]
|
||||
head = {
|
||||
"키": logic.get("키"),
|
||||
"이름": logic.get("이름") or "",
|
||||
"단위": _unit(logic),
|
||||
"출처": logic.get("출처") or "",
|
||||
"공종": kind_of(logic),
|
||||
"별칭": ", ".join(x for x in [logic.get("별칭") or "", *words_of(logic)] if x),
|
||||
"구분": logic.get("구분") or "",
|
||||
"상세구분": logic.get("상세구분") or "",
|
||||
"키": doc.get("키"),
|
||||
"이름": doc.get("이름") or "",
|
||||
"단위": _unit(doc),
|
||||
"출처": doc.get("출처") or "",
|
||||
"공종": kind_of(doc),
|
||||
"별칭": ", ".join(x for x in [doc.get("별칭") or "", *words_of(doc)] if x),
|
||||
"구분": doc.get("구분") or "",
|
||||
"상세구분": doc.get("상세구분") or "",
|
||||
"막힘": blocked,
|
||||
}
|
||||
out = []
|
||||
@@ -283,12 +279,12 @@ def _stamp() -> str:
|
||||
|
||||
|
||||
def _chunk(keys: list[str], blocked: set[str]) -> list[dict]:
|
||||
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음)."""
|
||||
whole = m01.loaded()[1]
|
||||
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터 · 수식 문서는 그 프로세스가 읽음)."""
|
||||
whole, docs = m01.loaded()[1], m01_doc.docs()
|
||||
links = _links(whole)
|
||||
out = []
|
||||
for key in keys:
|
||||
out += _rows_of(whole, whole.logic(key), key in blocked, links)
|
||||
out += _rows_of(whole, docs[key], key in blocked, links)
|
||||
return out
|
||||
|
||||
|
||||
@@ -296,11 +292,8 @@ def build(files: dict, workers: int = 1) -> dict:
|
||||
"""기준 목록 통째 — 장 차례 · `workers` > 1 이면 로직을 나눠 프로세스 여럿이 셈(차례 그대로)."""
|
||||
why_of = m01.blocks()
|
||||
blocked = {k for k, why in why_of.items() if why}
|
||||
keys = [
|
||||
str(logic.get("키"))
|
||||
for _, data in sorted(m01._logic_files(files), key=lambda f: m01.chapter_order(f[1]))
|
||||
for logic in data.get("줄") or []
|
||||
]
|
||||
chapters = sorted(m01_doc.logic_files().values(), key=m01.chapter_order)
|
||||
keys = [str(doc.get("키")) for data in chapters for doc in data.get("줄") or []]
|
||||
size = max(1, len(keys) // (workers * 8))
|
||||
parts = [keys[i : i + size] for i in range(0, len(keys), size)]
|
||||
if workers > 1:
|
||||
@@ -379,13 +372,11 @@ def _given(whole: Any, doc: dict, change: dict) -> tuple[dict, list]:
|
||||
def sheet(key: str, change: dict) -> dict:
|
||||
"""계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(문서 셈)."""
|
||||
files, whole = m01.loaded()
|
||||
doc = m01_doc.docs().get(key)
|
||||
try:
|
||||
logic = whole.logic(key)
|
||||
m01_doc.head(key) # 없는 · 로직 아닌 키 = 옛 `Master.logic` 과 같은 까닭 글
|
||||
except m01.cm.mf.FormulaError as e:
|
||||
raise m01.StoreError(404, str(e)) from e
|
||||
if doc is None:
|
||||
raise m01.StoreError(404, f"수식 문서 없음 「{key}」")
|
||||
doc = m01_doc.docs()[key]
|
||||
given, ax = _given(whole, doc, change)
|
||||
links = _links(whole)
|
||||
got = _calc(doc, links, given) or {}
|
||||
@@ -393,14 +384,14 @@ def sheet(key: str, change: dict) -> dict:
|
||||
return labor_inputs._num(
|
||||
{
|
||||
"키": key,
|
||||
"이름": logic.get("이름") or "",
|
||||
"이름": doc.get("이름") or "",
|
||||
"규격": _spec(given, ax),
|
||||
"단위": _unit(logic),
|
||||
"출처": labor_inputs.sources(logic) or "",
|
||||
"단위": _unit(doc),
|
||||
"출처": labor_inputs.sources(doc) or "",
|
||||
"판": edition(files),
|
||||
"입력": given,
|
||||
"묶음": mdt.sheet_groups(doc, got, links) if got and money else [],
|
||||
"계": got.get("계") if money else got.get("결과"),
|
||||
"기준단위": _unit(logic) or None,
|
||||
"기준단위": _unit(doc) or None,
|
||||
}
|
||||
)
|
||||
|
||||
@@ -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('단가판')}"
|
||||
|
||||
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user