feat(848-4): 기계 한 대 = 줄 하나 — 조합 줄 나눔 · 부착 줄 따름 · 묶음 끝수 · 버킷계수 직접 칸 · 빌더 모르는 문서 지킴
- 옛 로직 JSON(한 번 돌림 build_로직_기계줄나눔_848_4.py) → 빌더 → 수식 문서 · 새 식 GC001202 굴착기(무한궤도) 부착 조합 시간당 기계경비(잡재료 16 % · 8-4 주⑤ · 부품 조합 = 기계 식 고름에서 뺌) · 조합 식 부름 69 줄(문서 67) → 같은 묶음 아래 주 기계 줄(GC001202) + 부착 손료 줄(GC000273 · 부착 true) · 치즐 소모재료 6 문서 = 두 식 값의 합 · GF000011 · 012 · 320 덧줄 두 기계 손료 = 줄 둘(GF000312 · 313 = 기종 고르기 한 대 — 안 나눔) · GC001147 K입력(0 = 표) · GX000004 부름에 K입력=0 - 엔진 짝(master_doc_work ↔ TS) 부착 줄 = 같은 묶음 주 기계 줄 수량 · 답 꼴 따름 · 부착 줄 작업량 고침 안 걸림(저장 정리에서 지움) - 계산기 짝 · 옛 엔진(master_cut) 부착 줄 끝수 = 묶음 한 덩이 끝수 − 주 기계 줄 몫(줄 둘로 1 원 흔들림 없앰) - 변환 호표 묶음 · 부착 칸 · 빌더 = 옛 로직 줄 없는 저장본 문서를 안 지우고 제 파일 그대로 · 목록 알림 - 불러오기 조합 첫 줄 = GC001202 부름 · 둘째 줄 값 0 분기 걷음(두 줄 각자 셈) - 시험 test_848_4 새로 · test_848_1 바이트 비교 → 글 비교(CRLF 체크아웃) - 금액 전후 = 수식 문서 15 파일 493 문서 9,018 대조 다름 0 · 빌더 1,521 같음(채택 3 그대로) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,249 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""기계 한 대 = 줄 하나(PLAN 848-4 · 요구 887 · 888 · 요구서_889 7 장) — 옛 로직 JSON 고침(한 번 돌림).
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_기계줄나눔_848_4.py
|
||||
그 뒤 `build_수식문서_802_2.py` 로 수식 문서를 다시 지음(정본 길).
|
||||
- 새 식 = 「굴착기(무한궤도) 부착 조합 시간당 기계경비」(GC000271 에서 부착 몫만 뺌 · 잡재료 비율 16 % ·
|
||||
건설 공통 8-4 [70] 주⑤) · 08장 GC000271 뒤 · 키 = `_키대장.json` 다음 GC · 부품 `조합: 부착`(기계 식 고름에서 뺌).
|
||||
- 조합 식 부름 호표(GC000270 집게 · GC000271 브레이커) = 줄 둘 — 주 기계(새 식) + 부착 기계 손료(GC000273 ·
|
||||
`부착: true`) · 두 줄 `묶음` = 옛 줄 이름(묶음 제목 그대로) · 수량 같음.
|
||||
- 중간 식이 조합 값 전체를 밑으로 쓰는 6 문서(치즐 소모재료) = 두 식 값의 합.
|
||||
- 덧줄 단가가 두 기계 손료를 더하는 GF000011 · GF000012(하베스터 + 굴착기) · GF000320(멀티콥터 + 배터리) = 줄 둘.
|
||||
GF000312 · GF000313 = 기종 고르기로 한 대만 셈(더하지 않음) — 안 나눔.
|
||||
- GC000270 · GC000271 = 남김(옛 사본이 부름 · 틀 문서 9 절).
|
||||
- 이미 돌렸으면(새 식 있음) 멈춤.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
MASTER = HERE.parent
|
||||
ROOT = MASTER.parents[1]
|
||||
for p in (str(ROOT), str(HERE)):
|
||||
if p not in sys.path:
|
||||
sys.path.insert(0, p)
|
||||
import master_keys as mk # noqa: E402
|
||||
|
||||
LOGIC = "로직_건설품셈_08장_건설기계.json"
|
||||
NAME = "굴착기(무한궤도) 부착 조합 시간당 기계경비"
|
||||
LOSS = "GC000273" # 기계 시간당 손료(연료 · 조종원 없는 기종)
|
||||
CALL = re.compile(
|
||||
r"로직\((GC00027[01]), 기계=([^,()]+), (?:집게|브레이커)=([^,()]+), 지역=([^,()]+), 보정작업=([^,()]+)\)"
|
||||
)
|
||||
SPLIT = { # 덧줄 단가가 두 기계를 더함 — (로직, 덧줄 이름) → [(새 이름, 식)]
|
||||
("GF000011", "기계손료"): [
|
||||
("기계손료(하베스터 헤드)", "EQ000634.손료계수 * EQ000634.장비가격 * 1000 / 공정량"),
|
||||
("기계손료(굴착기)", "EQ000635.손료계수 * EQ000635.장비가격 * 1000 / 공정량"),
|
||||
],
|
||||
("GF000012", "기계손료"): [
|
||||
("기계손료(하베스터 헤드)", "EQ000634.손료계수 * EQ000634.장비가격 * 1000 / 공정량"),
|
||||
("기계손료(굴착기)", "EQ000635.손료계수 * EQ000635.장비가격 * 1000 / 공정량"),
|
||||
],
|
||||
("GF000320", "드론 손료"): [
|
||||
(
|
||||
"드론 손료",
|
||||
"만약(기종 == '무인헬기', EQ000645.손료계수 * EQ000645.취득가액, "
|
||||
"EQ000646.손료계수 * EQ000646.취득가액) / 일방제면적",
|
||||
),
|
||||
(
|
||||
"배터리 손료",
|
||||
"만약(기종 == '무인헬기', 0, EQ000647.손료계수 * EQ000647.취득가액) / 일방제면적",
|
||||
),
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def _load(name: str) -> tuple[str, dict]:
|
||||
text = (MASTER / name).read_text(encoding="utf-8")
|
||||
return text, json.loads(text, parse_float=Decimal, parse_int=Decimal)
|
||||
|
||||
|
||||
def _save(name: str, text: str, before: dict, after: dict) -> None:
|
||||
from M01_MasterData import M01_MasterData_Store_Shape as shape
|
||||
|
||||
out = shape.keep_shape(text, before, after, "줄") or shape.dump(after)
|
||||
assert json.loads(out, parse_float=Decimal, parse_int=Decimal) == after
|
||||
(MASTER / name).write_text(out, encoding="utf-8", newline="\n")
|
||||
|
||||
|
||||
def new_row(base: dict, keep: dict, key: str) -> dict:
|
||||
"""GC000271 → 부착 몫 뺀 굴착기 식(기계 고르기 = GC000267 목록)."""
|
||||
row = json.loads(json.dumps(base, default=str), parse_float=Decimal)
|
||||
row |= {"키": key, "이름": NAME, "부품": {"갈래": "기계경비식", "조합": "부착"}}
|
||||
row["출처"] = "건설품셈 공통 8-1-5 · 8-1-6 · 8-1-7 · 8-4 주⑤"
|
||||
row["비고"] = (
|
||||
"굴착기에 브레이커 · 부착용 집게를 조합할 때 굴착기 몫 — 잡재료 비율 16 %(8-4 [70] 주⑤) · "
|
||||
"부착 기계 손료는 같은 묶음 다음 줄(GC000273) · 수량은 이 줄을 따름"
|
||||
)
|
||||
row["입력"] = [i for i in row["입력"] if i["이름"] != "브레이커"]
|
||||
next(i for i in row["입력"] if i["이름"] == "기계")["고르기"] = list(
|
||||
next(i for i in keep["입력"] if i["이름"] == "기계")["고르기"]
|
||||
)
|
||||
row["중간"] = [x for x in row["중간"] if x["이름"] != "브레이커손료"]
|
||||
row["덧줄"] = [x for x in row["덧줄"] if x["이름"] != "브레이커손료"]
|
||||
row["변수표"] = {
|
||||
k: v for k, v in row["변수표"].items() if k not in ("브레이커", "브레이커손료")
|
||||
}
|
||||
return row
|
||||
|
||||
|
||||
def _name(eq: dict, code: str, fallback: str) -> str:
|
||||
"""기계 줄 이름 — 박힌 원문번호 = 「이름 규격」 · 변수 = 기종 이름."""
|
||||
t = code.strip()
|
||||
if t.startswith("'") and (r := eq.get(t.strip("'"))):
|
||||
return f"{r.get('이름')} {r.get('규격') or ''}".strip()
|
||||
return fallback
|
||||
|
||||
|
||||
def split_item(item: dict, eq: dict, key: str) -> list[dict]:
|
||||
m = CALL.fullmatch(str(item["요소"]))
|
||||
assert m, item
|
||||
_, main, part, region, rock = m.groups()
|
||||
title = str(item["이름"])
|
||||
common = {k: item[k] for k in ("단위", "수량") if k in item}
|
||||
first = {
|
||||
"종류": "로직",
|
||||
"요소": f"로직({key}, 기계={main}, 지역={region}, 보정작업={rock})",
|
||||
"이름": _name(eq, main, "굴착기(무한궤도)"),
|
||||
**common,
|
||||
"묶음": title,
|
||||
**{k: item[k] for k in item if k not in ("종류", "요소", "이름", "단위", "수량")},
|
||||
}
|
||||
attach = "부착용 집게" if m.group(1) == "GC000270" else "대형 브레이커"
|
||||
second = {
|
||||
"종류": "로직",
|
||||
"요소": f"로직({LOSS}, 기계={part})",
|
||||
"이름": _name(eq, part, attach),
|
||||
**common,
|
||||
"묶음": title,
|
||||
"부착": True,
|
||||
"출처": "건설품셈 공통 8-4 주⑤",
|
||||
}
|
||||
return [first, second]
|
||||
|
||||
|
||||
def _sum_call(text: str, key: str) -> str:
|
||||
"""중간 식 속 조합 식 값 `.계` = 두 식 값의 합."""
|
||||
|
||||
def one(m):
|
||||
_, main, part, region, rock = m.groups()
|
||||
return (
|
||||
f"(로직({key}, 기계={main}, 지역={region}, 보정작업={rock}).계 + "
|
||||
f"로직({LOSS}, 기계={part}).계)"
|
||||
)
|
||||
|
||||
out = re.sub(CALL.pattern + r"\.계", one, text)
|
||||
assert "GC000270" not in out and "GC000271" not in out, text
|
||||
return out
|
||||
|
||||
|
||||
BUCKET = { # 굴착기 작업량 식(8-2-3) 버킷계수 직접 칸 — E입력 · 싸이클입력 과 같은 꼴(0 = 표)
|
||||
"이름": "K입력",
|
||||
"설명": "버킷계수(K)를 직접 넣을 때 — 0 이면 표(버킷조건)",
|
||||
"범위": [0, 2],
|
||||
"출처": "건설품셈 공통 8-2-3 1",
|
||||
}
|
||||
|
||||
|
||||
def bucket() -> None:
|
||||
"""GC001147 에 `K입력` — 이미 있으면 그대로."""
|
||||
text, before = _load(LOGIC)
|
||||
after = json.loads(text, parse_float=Decimal, parse_int=Decimal)
|
||||
row = next(r for r in after["줄"] if r["키"] == "GC001147")
|
||||
if any(i["이름"] == BUCKET["이름"] for i in row["입력"]):
|
||||
return
|
||||
at = next(n for n, i in enumerate(row["입력"]) if i["이름"] == "싸이클입력") + 1
|
||||
row["입력"].insert(at, {**BUCKET, "범위": [Decimal(0), Decimal(2)]})
|
||||
step = next(x for x in row["중간"] if x["이름"] == "K")
|
||||
assert step["식"] == "찾기(CC000042, 현장조건=버킷조건).K", step
|
||||
step["식"] = "만약(K입력 > 0, K입력, 찾기(CC000042, 현장조건=버킷조건).K)"
|
||||
row["변수표"]["K입력"] = {"기호": "K", "아래": "입력"}
|
||||
row["시험입력"]["K입력"] = Decimal(0)
|
||||
row["비고"] = str(row["비고"]) + " · K입력 0 = 표(버킷조건)"
|
||||
_save(LOGIC, text, before, after)
|
||||
print("GC001147 K입력")
|
||||
|
||||
|
||||
_BUCKET_CALL = re.compile(r"로직\(GC001147,((?:[^()']|'[^']*')*)\)")
|
||||
|
||||
|
||||
def bucket_calls() -> None:
|
||||
"""GC001147 를 입력 다 넘겨 부르는 로직(옛 엔진은 입력을 다 받음)에 `K입력=0` — 이미 있으면 그대로."""
|
||||
for path in sorted(MASTER.glob("로직_*.json")):
|
||||
text, before = _load(path.name)
|
||||
if "로직(GC001147," not in text:
|
||||
continue
|
||||
after = json.loads(text, parse_float=Decimal, parse_int=Decimal)
|
||||
hit = False
|
||||
for row in after["줄"]:
|
||||
for part in ("중간", "호표", "덧줄"):
|
||||
for x in row.get(part) or []:
|
||||
for k in ("식", "요소", "수량"):
|
||||
v = x.get(k)
|
||||
if isinstance(v, str) and "로직(GC001147," in v and "K입력=" not in v:
|
||||
x[k] = _BUCKET_CALL.sub(lambda m: f"로직(GC001147,{m[1]}, K입력=0)", v)
|
||||
hit = True
|
||||
if hit:
|
||||
_save(path.name, text, before, after)
|
||||
print("K입력=0 부름", path.name)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
|
||||
bucket()
|
||||
bucket_calls()
|
||||
_, head = _load(LOGIC)
|
||||
if any(r.get("이름") == NAME for r in head["줄"]):
|
||||
raise SystemExit("나눔은 이미 넣음 — 멈춤")
|
||||
book = mk.load_book()
|
||||
key = mk.issue(book, "GC", "공통 8 굴착기 부착 조합 시간당 경비", LOGIC)
|
||||
eq = store.loaded()[1].numbers.get("EQ") or {}
|
||||
lines = splits = sums = 0
|
||||
for path in sorted(MASTER.glob("로직_*.json")):
|
||||
text, before = _load(path.name)
|
||||
after = json.loads(text, parse_float=Decimal, parse_int=Decimal)
|
||||
hit = False
|
||||
for row in after.get("줄") or []:
|
||||
if row["키"] in ("GC000270", "GC000271"):
|
||||
continue
|
||||
items = []
|
||||
for item in row.get("호표") or []:
|
||||
if item.get("종류") == "로직" and CALL.fullmatch(str(item.get("요소"))):
|
||||
items += split_item(item, eq, key)
|
||||
lines += 1
|
||||
else:
|
||||
items.append(item)
|
||||
if len(items) != len(row.get("호표") or []):
|
||||
row["호표"], hit = items, True
|
||||
for step in row.get("중간") or []:
|
||||
if "GC000270" in step["식"] or "GC000271" in step["식"]:
|
||||
step["식"], hit = _sum_call(step["식"], key), True
|
||||
sums += 1
|
||||
adds = []
|
||||
for add in row.get("덧줄") or []:
|
||||
got = SPLIT.get((row["키"], add.get("이름")))
|
||||
adds += [{**add, "이름": n, "식": f} for n, f in got] if got else [add]
|
||||
splits += bool(got)
|
||||
if len(adds) != len(row.get("덧줄") or []):
|
||||
row["덧줄"], hit = adds, True
|
||||
if path.name == LOGIC:
|
||||
rows = after["줄"]
|
||||
by = {r["키"]: r for r in rows}
|
||||
at = rows.index(by["GC000271"]) + 1
|
||||
rows.insert(at, new_row(by["GC000271"], by["GC000267"], key))
|
||||
hit = True
|
||||
if hit:
|
||||
_save(path.name, text, before, after)
|
||||
mk.save_book(mk.finish(book))
|
||||
print(f"새 식 {key} · 조합 줄 {lines} → 줄 둘 · 중간 합 {sums} · 덧줄 나눔 {splits}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -21,6 +21,8 @@
|
||||
- 이미 저장된 문서가 이번에 저장 밖(다름 · 부르는 문서 빠짐)이면 멈춤 — 안 씀 · 그 문서와 까닭을 알림(`lost`).
|
||||
- 화면 고침 이어받기(848-1) — 저장본 `기계덮음`(그 기초의 ① 위 층 고침) = 키별로 새 문서에 얹음 ·
|
||||
`손고침` 문서(M01 화면이 셈 칸을 고쳐 저장) = 저장본 그대로 · 실행 · `--check` 때 목록으로 알림.
|
||||
- 빌더가 짓지 않는 저장본 문서(848-4 · 옛 로직 줄 없는 키 — 화면에서 만든 자체 로직 등) = 지우거나 덮지 않음 ·
|
||||
제 파일 끝에 그대로(`foreign`) · 실행 · `--check` 때 목록 · `--check` 는 그대로면 같음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -243,23 +245,44 @@ def saved_keys() -> set[str]:
|
||||
}
|
||||
|
||||
|
||||
def foreign(result: dict) -> dict[str, dict]:
|
||||
"""빌더가 짓지 않는 저장본 문서(옛 로직 줄 없는 키) {파일 이름: {머리 · 줄}} — 그대로 둠(848-4)."""
|
||||
out: dict[str, dict] = {}
|
||||
for path in sorted(ml.FOLDER.glob("수식_*.json")) if ml.FOLDER.exists() else []:
|
||||
data = ml.load_file(path)
|
||||
rows = [d for d in data.get("줄") or [] if str(d.get("키")) not in result["문서"]]
|
||||
if rows:
|
||||
out[path.name] = {**{k: v for k, v in data.items() if k != "줄"}, "줄": rows}
|
||||
return out
|
||||
|
||||
|
||||
def foreign_keys(result: dict) -> list[str]:
|
||||
return sorted(str(d.get("키")) for x in foreign(result).values() for d in x["줄"])
|
||||
|
||||
|
||||
def lost(result: dict) -> list[str]:
|
||||
"""저장본에 있는데 이번 빌드가 저장 밖으로 뺀 문서 — 「키 까닭」(빌더가 조용히 지우지 않게)."""
|
||||
"""저장본에 있는데 이번 빌드가 저장 밖으로 뺀 문서 — 「키 까닭」(빌더가 조용히 지우지 않게) ·
|
||||
빌더가 짓지 않는 문서는 그대로 두므로 뺌."""
|
||||
why = {}
|
||||
for one in result["대조"]:
|
||||
if one["로직"] not in result["저장"]:
|
||||
why.setdefault(one["로직"], one.get("까닭") or one.get("빠짐") or "")
|
||||
return [f"{k} {why.get(k) or '저장 밖'}" for k in sorted(saved_keys() - result["저장"])]
|
||||
gone = saved_keys() - result["저장"] - set(foreign_keys(result))
|
||||
return [f"{k} {why.get(k) or '저장 밖'}" for k in sorted(gone)]
|
||||
|
||||
|
||||
def files_of(result: dict) -> dict[str, str]:
|
||||
"""저장 파일 이름 → 글."""
|
||||
out = {}
|
||||
"""저장 파일 이름 → 글 · 빌더가 짓지 않는 저장본 문서 = 제 파일 끝에 그대로."""
|
||||
bodies = {}
|
||||
for name, keys in result["파일"].items():
|
||||
kept = [_out_doc(result, k) for k in keys if k in result["저장"]]
|
||||
body = {"그룹": "수식문서", "로직파일": name, "줄": kept}
|
||||
out[ml.file_of(name)] = ml.dump(body)
|
||||
return out
|
||||
bodies[ml.file_of(name)] = {"그룹": "수식문서", "로직파일": name, "줄": kept}
|
||||
for file, data in foreign(result).items():
|
||||
if file in bodies:
|
||||
bodies[file]["줄"] += data["줄"]
|
||||
else:
|
||||
bodies[file] = data
|
||||
return {file: ml.dump(body) for file, body in bodies.items()}
|
||||
|
||||
|
||||
def table_rows(result: dict) -> list[list[str]]:
|
||||
@@ -352,6 +375,8 @@ def main() -> int:
|
||||
result = build()
|
||||
if hand := hand_kept(result):
|
||||
print(f"손고침 {len(hand)} 장 — 저장본 그대로(빌더 안 덮음): {' · '.join(hand)}")
|
||||
if own := foreign_keys(result):
|
||||
print(f"빌더가 짓지 않는 문서 {len(own)} 장 — 저장본 그대로(안 지움): {' · '.join(own)}")
|
||||
if args.check:
|
||||
bad = check(result)
|
||||
for line in bad:
|
||||
|
||||
@@ -50,6 +50,32 @@ def _line(value, rule: dict | None):
|
||||
return mf._round(Decimal(str(value)), places, mf.ROUND_WAYS[way])
|
||||
|
||||
|
||||
def _host(items: list[dict], n: int) -> int | None:
|
||||
"""부착 호표(848-4 · `부착: true`) → 같은 묶음 앞쪽 주 기계 로직 줄 차례 · 아님 = None."""
|
||||
item = items[n] if n < len(items) else {}
|
||||
if not item.get("부착"):
|
||||
return None
|
||||
for j in range(n - 1, -1, -1):
|
||||
x = items[j]
|
||||
if not x.get("부착") and x.get("묶음") == item.get("묶음") and x.get("종류") == "로직":
|
||||
return j
|
||||
return None
|
||||
|
||||
|
||||
def _joined(split: dict, rule, held: tuple) -> tuple[dict, Decimal | None]:
|
||||
"""부착 줄 끝수 = 묶음 한 덩이(주 기계 줄 + 이 줄) 끝수 − 주 기계 줄 끝수(848-4 · 계산기와 같음)."""
|
||||
h, h_rule = held
|
||||
zero = Decimal(0)
|
||||
cut = {
|
||||
k: None
|
||||
if v is None
|
||||
else _line((h.get(k) or zero) + v, rule) - _line(h.get(k) or zero, h_rule)
|
||||
for k, v in split.items()
|
||||
}
|
||||
kept = [v for v in cut.values() if v is not None]
|
||||
return cut, (sum(kept, zero) if kept else None)
|
||||
|
||||
|
||||
def _parts(split: dict, rule: dict | None = None) -> tuple[dict, Decimal | None]:
|
||||
"""줄 비목 → (비목마다 0.1 원 버림 · 줄 `자리` 면 그것, 금액 = 그 합 · 모두 빈 = None)."""
|
||||
cut = {k: _line(v, rule) for k, v in split.items()}
|
||||
@@ -100,7 +126,7 @@ def engine(master, ref: str, got: dict, depth: int = 0) -> dict:
|
||||
skip = ms.skipped(logic) if new else set()
|
||||
env = dict(got.get("중간") or {})
|
||||
total = dict.fromkeys(COSTS, Decimal(0))
|
||||
lines = []
|
||||
lines, raws = [], {} # raws = 줄 차례 → (끝수 전 비목, 줄 자리) — 848-4 부착 줄 묶음 끝수
|
||||
for n, line in enumerate(got["줄"]):
|
||||
split, more = dict(line.get("비목") or {}), {}
|
||||
if n == len(items): # 덧줄이 부르는 `줄.'이름'` = 버린 호표 줄 금액(엔진과 같이 한 번)
|
||||
@@ -122,7 +148,10 @@ def engine(master, ref: str, got: dict, depth: int = 0) -> dict:
|
||||
value = line["금액"]
|
||||
env[add["이름"]] = _line(value, rules[n]) # 뒤 덧줄 · 중간 칸 = 버린 값
|
||||
split = {add["비목"]: value}
|
||||
cut, money = _parts(split, rules[n] if n < len(rules) else None)
|
||||
rule = rules[n] if n < len(rules) else None
|
||||
host = _host(items, n)
|
||||
cut, money = _joined(split, rule, raws[host]) if host in raws else _parts(split, rule)
|
||||
raws[n] = (split, rule)
|
||||
for k, v in cut.items():
|
||||
total[k] += 0 if n in skip else v or 0
|
||||
if n >= len(items) and money is not None:
|
||||
|
||||
@@ -402,6 +402,7 @@ def _money(run: _Run, doc: dict, rules: dict):
|
||||
if st.get("제외"):
|
||||
skip |= mine
|
||||
running, syms, outs, stopped = _zero(), {}, [], False
|
||||
raws: dict[int, tuple] = {} # 848-4 줄 → (끝수 전 비목, 끝수) — 부착 줄 묶음 끝수
|
||||
for i, line in enumerate(lines):
|
||||
scope = _scope(doc, outs, dict(running), cover, syms)
|
||||
where = str(line.get("이름") or f"금액 {i + 1}")
|
||||
@@ -451,7 +452,16 @@ def _money(run: _Run, doc: dict, rules: dict):
|
||||
)
|
||||
stopped, why = True, run.mark(Stop(f"{where} {what}", "셈 틀림", where)).why
|
||||
rule = line.get("자리") or rules["줄"]
|
||||
parts = {k: cut(v, rule) for k, v in parts.items()}
|
||||
raw, host = dict(parts), mw.host_of(run, line)
|
||||
if (
|
||||
host is not None and id(host) in raws
|
||||
): # 848-4 부착 줄 = 묶음 한 덩이 끝수 − 주 기계 줄 몫
|
||||
h, h_rule = raws[id(host)]
|
||||
zero = Decimal(0)
|
||||
parts = {k: cut(h.get(k, zero) + v, rule) - cut(h.get(k, zero), h_rule) for k, v in parts.items()} # fmt: skip
|
||||
else:
|
||||
parts = {k: cut(v, rule) for k, v in parts.items()}
|
||||
raws[id(line)] = (raw, rule)
|
||||
amount = sum(parts.values(), Decimal(0)) if parts else None
|
||||
if bare is not None:
|
||||
amount = cut(bare, rule)
|
||||
|
||||
@@ -592,7 +592,13 @@ def _money(c: _Conv, row: dict) -> list[dict]:
|
||||
ref, None, str(item.get("단위") or "") if ref[:2] == mm.LINKED else None
|
||||
)
|
||||
line |= {"수량": qty, "단가": price}
|
||||
for k in ("번지", "합밖", "자리", "출처"):
|
||||
for k in (
|
||||
"번지",
|
||||
"합밖",
|
||||
"자리",
|
||||
"출처",
|
||||
"부착",
|
||||
): # 부착 = 같은 묶음 주 기계 줄을 따름(848-4)
|
||||
if k in item:
|
||||
line[k] = item[k]
|
||||
out.append(line)
|
||||
@@ -622,11 +628,15 @@ def _money(c: _Conv, row: dict) -> list[dict]:
|
||||
|
||||
|
||||
def _groups(out: list[dict], items: list[dict]) -> None:
|
||||
"""묶음 — 단가산출 부름 줄마다 한 묶음 · 그 사이 다른 줄은 이어진 것끼리 · 묶음 하나면 안 둠."""
|
||||
"""묶음 — 단가산출 부름 줄마다 한 묶음 · 그 사이 다른 줄은 이어진 것끼리 · 묶음 하나면 안 둠 ·
|
||||
호표 `묶음`(848-4 · 기계 한 대 = 줄 하나) = 그 제목 · 이어진 같은 제목 부름 줄은 한 묶음."""
|
||||
runs: list[tuple[str, list[int]]] = []
|
||||
for i, item in enumerate(items):
|
||||
if item.get("종류") == "로직":
|
||||
runs.append((str(item.get("이름") or ""), [i]))
|
||||
title = str(item.get("묶음") or "")
|
||||
if item.get("종류") == "로직" and title and runs and runs[-1][0] == title:
|
||||
runs[-1][1].append(i)
|
||||
elif item.get("종류") == "로직":
|
||||
runs.append((title or str(item.get("이름") or ""), [i]))
|
||||
elif runs and runs[-1][0] == "" and items[runs[-1][1][-1]].get("종류") != "로직":
|
||||
runs[-1][1].append(i)
|
||||
else:
|
||||
|
||||
@@ -610,7 +610,7 @@ def prune_doc(doc: dict, links, upper: dict | None = None) -> dict:
|
||||
works: dict = {} # 작업량(846-1) = 기계 줄 답이 읽은 작업 기계(부착 기계 포함) · 847-1 단가 기호 열쇠도
|
||||
for a in (top, *memo.values()):
|
||||
for x in a.get("줄") or []:
|
||||
if w := x.get(mw.WORK):
|
||||
if (w := x.get(mw.WORK)) and w.get("꼴") != mw.FOLLOW: # 848-4 부착 줄 = 주 줄 따름
|
||||
works.setdefault(w["기계"], w["기계"])
|
||||
if w.get("기호"):
|
||||
works.setdefault(w["기호"], w["기계"])
|
||||
@@ -628,10 +628,13 @@ def prune_doc(doc: dict, links, upper: dict | None = None) -> dict:
|
||||
names = listed(rest) | {
|
||||
str(e[mw.WORK]["기계"]) for e in steer.values() if e[mw.WORK].get("기계")
|
||||
}
|
||||
follow = { # 848-4 부착 줄 단가 기호 — 작업량 고침이 안 걸림(지움)
|
||||
n for x in rest.get("금액") or [] if x.get(mw.ATTACH) for n in _names(x.get("단가"))
|
||||
}
|
||||
for m in [m for m in cover if m in names]: # 안 부른 열쇠 — 문서 안에 들면 그대로
|
||||
if m not in seen and (vals := {k: v for k, v in cover[m].items() if k != mw.WORK}):
|
||||
kept[m] = {**vals, **kept.get(m, {})}
|
||||
if f"{m}\n{mw.WORK}" not in seen and cover[m].get(mw.WORK):
|
||||
if f"{m}\n{mw.WORK}" not in seen and cover[m].get(mw.WORK) and m not in follow:
|
||||
kept[m] = {**kept.get(m, {}), mw.WORK: cover[m][mw.WORK]}
|
||||
return {**rest, COVER: kept} if kept else rest
|
||||
|
||||
|
||||
@@ -13,6 +13,8 @@
|
||||
굳은 기계(847-1 · 요구 885) = 덮음 `기계`(시간당으로 바꿀 때 그 줄 기계 · 기계 창으로 바꾼 기계) — 그 줄 단가를
|
||||
그 기계(`키` = 기계 식 문서가 다를 때)로 다시 부르고 작업량 식 · 변수도 그 기계 것 · `이름` = 화면 이름만 ·
|
||||
부착 기계 줄 = 굳힘 없음 · 덮음 열쇠 = 그 줄 단가 기호 › 기계 열쇠(846-1 옛 꼴).
|
||||
부착 줄(848-4 · 금액 줄 칸 `부착: true`) = 같은 묶음 앞쪽 주 기계 줄의 수량을 그대로 씀(품셈 일당 · 시간당 식
|
||||
모두 · 그 줄 작업량 덮음은 안 읽음) · 답 칸 꼴 「따름」 + `따름` {기호, 이름, 꼴}.
|
||||
셈 답 기계 줄 칸 `작업량` = {기계, 꼴(일당 · 식 · 시간당), 율, 값, 단위, 식들, 변수?, 까닭?}(산출근거 자료).
|
||||
파이썬 · TS 짝 — 짝 = `common_util/common_util_formula_doc_work.ts` · 거울 시험
|
||||
`resources/tester/test_846_1_machine_work.py`.
|
||||
@@ -27,6 +29,7 @@ import master_doc as md
|
||||
|
||||
WORK = "작업량"
|
||||
FIXED = ("기계", "키", "이름") # 847-1 굳은 기계 · 기계 식 문서 · 화면 이름
|
||||
ATTACH, FOLLOW = "부착", "따름" # 848-4 금액 줄 칸 · 부착 줄 답 꼴
|
||||
HOURLY, DAILY = "시간당", "일당"
|
||||
Q_NEW = "Q_시간당작업량" # 셈 범위 이름(문서 기호 아님)
|
||||
EIGHT = Decimal(8)
|
||||
@@ -348,6 +351,42 @@ def fixed_var(var: dict, want: dict) -> dict:
|
||||
} # fmt: skip
|
||||
|
||||
|
||||
def host_of(run, line: dict) -> dict | None:
|
||||
"""부착 줄 → 같은 묶음 앞쪽 주 기계 줄(부착 아님 · 기계 줄) · 아님 = None."""
|
||||
if not line.get(ATTACH):
|
||||
return None
|
||||
lines = run.doc.get("금액") or []
|
||||
at = next((i for i, x in enumerate(lines) if x is line), None)
|
||||
for x in reversed(lines[:at] if at is not None else []):
|
||||
if not x.get(ATTACH) and x.get("묶음") == line.get("묶음") and _machine_of(run, x):
|
||||
return x
|
||||
return None
|
||||
|
||||
|
||||
def _follow(run, line: dict, host: dict, scope: dict, key: str, sym: str):
|
||||
"""부착 줄 = 주 기계 줄 수량 그대로 · 답 칸 꼴 「따름」(주 기계 줄 작업량 답이 있을 때)."""
|
||||
import master_doc_calc as mc
|
||||
|
||||
n, seen = len(run.marks), set(run.values)
|
||||
try:
|
||||
swapped, more, info = line_work(run, host, scope)
|
||||
finally: # 주 기계 줄 셈의 흔적 = 그 줄이 냄
|
||||
del run.marks[n:]
|
||||
for k in set(run.values) - seen:
|
||||
del run.values[k]
|
||||
where = str(line.get("이름") or "")
|
||||
if isinstance(swapped, mc.Stop):
|
||||
swapped = mc.Stop(f"{where} 주 기계 줄을 따름 — {swapped.why}", "시간당 거절", where)
|
||||
text = host.get("수량") if swapped is None else swapped
|
||||
mine = None
|
||||
if info:
|
||||
mine = {"기계": key, "기호": sym, "꼴": FOLLOW, "율": info.get("율") or "", "값": info.get("값"),
|
||||
"단위": info.get("단위") or "", "식들": [],
|
||||
FOLLOW: {"기호": info.get("기호") or "", "이름": str(host.get("이름") or ""), "꼴": info.get("꼴") or ""}} # fmt: skip
|
||||
same = text == line.get("수량")
|
||||
return (None if same else text), {k: v for k, v in more.items() if k == Q_NEW}, mine
|
||||
|
||||
|
||||
def line_work(run, line: dict, scope: dict):
|
||||
"""기계 줄 하나 → (바꾼 수량 글 | 멈춤(표지는 계산기가 담) | None, 범위 더함 {}, 답 칸 | None) —
|
||||
계산기 `_money` 가 부름."""
|
||||
@@ -373,6 +412,8 @@ def line_work(run, line: dict, scope: dict):
|
||||
if mc._bad(key_val):
|
||||
return None, {}, None
|
||||
key = mcv.machine_key({"기계": mc.plain_text(key_val)})
|
||||
if (host := host_of(run, line)) is not None: # 848-4 부착 줄
|
||||
return _follow(run, line, host, scope, key, got[1])
|
||||
|
||||
def test(cond):
|
||||
v = quiet(lambda: run.ev(cond, scope, where))
|
||||
|
||||
Reference in New Issue
Block a user