feat(851-1): 작업량 식 「○○ 직접」 칸 · 덤프트럭 운반 구간 셋 · 속도 · t2 ~ t5 직접

- 옛 로직 JSON(한 번 돌림 build_로직_직접칸_851_1.py) → 빌더 → 수식 문서
  · 목록 276 변수 = 더함 106(직접 칸 81 개 · 식 31) · 뺌 170(값 하나 154 · 이미 직접 칸이 덮음 16)
  · 꼴 = 「만약(X입력 > 0, X입력, 표)」(비우거나 0 = 고르기 값 · 넣으면 그 값) · 칸 자리 = 그 값을 정하는 고르기 칸 바로 아래
  · 보이는 이름 「○○ 직접」(변수표 이름) · 기호 = 이름 규칙 · 범위 = 표 값이 다 1 이하인 작업효율만 [0, 1]
  · 지금 직접 칸(E입력 · 싸이클입력 · K입력 · α입력 · f입력 · k입력 · q입력 · 하역 · 대기 · 배출 · 적재시간입력) = 열쇠 그대로 · 보이는 이름만 「○○ 직접」(33 칸)
- 덤프트럭 8-2-8 t2 = 구간 셋(구간 1 = 운반거리 · 도로상태 그대로 · 구간2거리 · 구간3거리 0 = 안 씀) · 구간마다 적재 · 공차 속도 직접(원문 3 [주] 측정값) · t2 · t3 · t4 · t5 직접
- 입력 다 넘겨 부르는 로직(로직_자체 GC001155 · 10장 GF000148) = 새 입력 0
- 가져온 값 층(848-7) 표 찾기 = 변수 열쇠 대신 표 번호(t3 줄이 막이로 바뀌어도 그대로)
- 낡은 시험 고침 — test_782_3 · test_masterdata_check 옛 엔진 부름에 새 입력 0(옛 엔진은 입력을 다 받음) · 가드 칸 자동값 = 「○○ 직접」 칸은 견본 0(표 밖 값도 받는 칸이라 「1 이어도 10배 안」 대신) · test_846_2 E입력 보이는 이름
- 시험 test_851_1 새로(직접 칸 124 전수 — 고르기 값 같은 수 = 결과 같음 · 다른 수 = 그 자리에 그 수를 박은 식과 같음 · 덤프 구간 하나 26.209 · 둘 · 셋 · 속도 · t2 ~ t5 직접 손셈 · TS 거울)
- 전후 = 수식 문서 21,900 대조 다름 0 · 빌더 1,521 같음(옵션 표본 18,900 → 18,926 = 구간 도로상태 갈래) · --check 같음 · 기계 655 대 · 작업량 칸 286 · 견본 SK 5 다름 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 08:40:56 +09:00
co-authored by Claude Opus 5.5
parent 9844cab5de
commit dec9294d76
13 changed files with 1770 additions and 342 deletions
@@ -0,0 +1,515 @@
# -*- coding: utf-8 -*-
"""작업량 식 직접 칸 · 덤프 운반 구간 여럿(PLAN 851-1 · 요구 893) — 옛 로직 JSON 고침(한 번 돌림).
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_직접칸_851_1.py
그 뒤 `build_수식문서_802_2.py` 로 수식 문서를 다시 지음(정본 길).
- 고르기(표 값)로만 정해지는 수 = 그 중간 줄(또는 식 속 그 찾기)을 「만약(X입력 > 0, X입력, 표)」 로 —
비우거나 0 = 고르기 값 · 넣으면 그 값이 이김 · 입력 칸 자리 = 그 값을 정하는 고르기 칸 바로 아래 ·
보이는 이름 = 「○○ 직접」(변수표 이름) · 열쇠 = 「X입력」 · 범위 = 표 값이 다 1 이하인 작업효율만 [0, 1](지금 E입력 과 같음).
- 지금 「0 = 표」 직접 칸(E입력 · 싸이클입력 · K입력 · α입력 …) = 열쇠 그대로 · 보이는 이름만 「○○ 직접」.
- 덤프트럭(8-2-8) t2 = 구간 셋(구간 1 = 지금 운반거리 · 도로상태 · 구간2거리 · 구간3거리 = 0 이면 안 탐) ·
구간마다 적재 · 공차 주행속도 직접(원문 3 [주] 「주행속도를 측정하여 사용할 수 있다」) · t2 · t3 · t4 · t5 직접.
- 직접 칸을 더한 식을 입력 다 넘겨 부르는 로직(옛 엔진은 입력을 다 받음) = 새 입력 0 · 구간 도로상태 = 구간 1 값.
- 목록 276 변수 중 뺀 것(값 하나 · 이미 직접 칸이 덮음 · 글 값) = 851-1 보고 표.
- 이미 돌렸으면(덤프 V1 있음) 멈춤.
"""
from __future__ import annotations
import copy
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)
C08 = "로직_건설품셈_08장_건설기계.json"
F10 = "로직_산림품셈_10장_자재․장비_운반.json"
SELF = "로직_자체.json"
DUMP = "GC001155"
EFF = [
0,
1,
] # 작업효율 직접 칸 범위(지금 E입력 과 같음 · 원문 표 값이 1 넘는 효율 표(준설선 · 임목파쇄기)는 범위 없음)
# (식, 중간 줄 | 결과, 감쌀 글(None = 줄 통째), 열쇠, 보이는 이름, 자리(이 입력 아래), 단위, 범위) · 기호 = 이름 규칙
OPS: list[tuple] = [
("GC001144", "q0", None, "q0입력", "삽날용량 직접", "급수", "㎥", None),
("GC001144", "e", None, "e입력", "운반거리계수 직접", "거리구분", "", None),
("GC001144", "V1", None, "V1입력", "전진속도 직접", "전진단", "m/분", None),
("GC001144", "V2", None, "V2입력", "후진속도 직접", "후진단", "m/분", None),
("GC001146", "An", None, "An입력", "리핑 단면적 직접", "발톱수", "㎡", None),
("GC001149", "d", None, "d입력", "굴착심도계수 직접", "굴착심도", "", None),
("GC001150", "m", None, "m입력", "주행계수 직접", "기종", "sec/m", None),
(
"GC001150",
"cm",
"t1",
"t1입력",
"적재시간 직접",
"적재조건",
"sec",
None,
), # 줄 t1 = 표 한 마디(열쇠 겹침 피함)
("GC001150", "K", None, "K입력", "버킷계수 직접", "K조건", "", None),
("GC001152", "K", None, "K입력", "적재계수 직접", "토질상태", "", None),
("GC001152", "V1", None, "V1입력", "적재 주행속도 직접", "도로상태", "m/분", None),
("GC001152", "V2", None, "V2입력", "공차 주행속도 직접", "V1입력", "m/분", None),
("GC001152", "t", None, "t입력", "적토·사토·기어변속시간 직접", "푸쉬도우저", "분", None),
*[
op
for key in ("GC001153", "GC001154")
for op in (
(key, "V1", None, "V1입력", "작업속도 직접", "현장조건", "㎞/hr", None),
(key, "V2", None, "V2입력", "후진·회송속도 직접", "되돌림조건", "㎞/hr", None),
(key, "t", None, "t입력", "방향변환시간 직접", "t작업", "분", None),
)
],
("GC001154", "l", None, "l입력", "블레이드 유효길이 직접", "l작업", "m", None),
*[
op
for key in ("GC001157", "GC001158")
for op in (
(key, "W", None, "W입력", "유효다짐폭 직접", "규격", "m", None),
(key, "V", None, "V입력", "다짐속도 직접", "다짐층", "㎞/hr", None),
)
],
("GC001160", "결과", None, "Q입력", "생산능력 직접", "혼합재", "ton/hr", None),
("GC001162", "결과", None, "Q입력", "생산능력 직접", "작업조건", "ton/hr", None),
(
"GC001163",
"결과",
"찾기(CC000375, 출구간격=출구간격, 규격=규격).생산능력",
"q입력",
"생산능력 직접",
"출구간격",
"ton/hr",
None,
), # fmt: skip
("GC001163", "효율", None, "E효율입력", "효율 직접", "작업조건", "%", None),
(
"GC001164",
"결과",
"찾기(CC000383, 규격=규격, 출구간격=출구간격).생산능력",
"q입력",
"생산능력 직접",
"출구간격",
"ton/hr",
None,
), # fmt: skip
("GC001164", "E", None, "E입력", "작업효율 직접", "작업조건", "", EFF),
(
"GC001165",
"통과능력",
None,
"q통과입력",
"통과능력 직접",
"조합방법",
"ton/hr",
None,
), # fmt: skip
("GC001165", "A", None, "A입력", "택수 계수(A) 직접", "택의수", "", None),
("GC001165", "B", None, "B입력", "작은 골재량 계수(B) 직접", "B골재량", "", None),
("GC001165", "C", None, "C입력", "스크린 규격 계수(C) 직접", "C규격", "", None),
("GC001165", "D", None, "D입력", "큰 골재량 계수(D) 직접", "D골재량", "", None),
("GC001165", "E", None, "E입력", "재료 계수(E) 직접", "재료", "", None),
("GC001168", "결과", None, "Q입력", "작업량 직접", "구분", "㎡/h", None),
("GC001171", "q", None, "q입력", "실용량 직접", "슬럼프", "㎥", None),
("GC001171", "cm", None, "cm입력", "싸이클시간 직접", "싸이클", "분", None),
("GC001173", "W", None, "W입력", "적재용량 직접", "규격", "㎥", None),
("GC001174", "n", None, "n입력", "대차수 직접", "기관차", "대", None),
("GC001174", "t2", None, "t2입력", "적재적하시간 직접", "재료", "분", None),
("GC001175", "t", None, "t입력", "적재적하시간 직접", "종류", "분", None),
("GC001175", "V1", None, "V1입력", "적재시 속도 직접", "작업로", "m/분", None),
("GC001175", "V2", None, "V2입력", "공차시 속도 직접", "V1입력", "m/분", None),
("GC001176", "β", None, "β입력", "해머계수 직접", "해머", "", None),
("GC001176", "Te", None, "Te입력", "기타시간 직접", "β입력", "분", None),
("GC001176", "F", None, "F입력", "작업계수 직접", "현장", "", None),
("GC001176", "tw", None, "tw입력", "용접시간 직접", "관두께", "분", None),
("GC001177", "β", None, "β입력", "해머계수 직접", "해머", "", None),
("GC001177", "Te", None, "Te입력", "기타시간 직접", "β입력", "분", None),
(
"GC001177",
"Ts",
"만약(파일경 <= 300, 찾기(CC000410, 항목='세우기 및 위치조정 — 콘크리트 파일 250·300㎜').값, 찾기(CC000410, 항목='세우기 및 위치조정 — 콘크리트 파일 350∼500㎜').값)",
"Ts입력",
"세우기·위치조정 시간 직접",
"파일경",
"분/회",
None,
), # fmt: skip
("GC001177", "F", None, "F입력", "작업계수 직접", "현장", "", None),
("GC001178", "β", None, "β입력", "판두께계수 직접", "판두께", "", None),
("GC001178", "Ta", None, "Ta입력", "시공시간 직접", "파일경", "분/본", None),
("GC001179", "Ta", None, "Ta입력", "시공시간 직접", "파일경", "분/본", None),
("GC001180", "Ts", None, "Ts입력", "준비시간 직접", "작업", "분", None),
(
"GC001180",
"F",
"찾기(CC000423, 작업=작업).F0",
"F0입력",
"작업계수 F0 직접",
"Ts입력",
"",
None,
), # fmt: skip
("GC001180", "k", None, "k입력", "해머계수 직접", "파일", "", None),
("GC001180", "r1", None, "r1입력", "사질토 단위시간 직접", "사질N", "분/m", None),
("GC001180", "r2", None, "r2입력", "점질토 단위시간 직접", "점질N", "분/m", None),
("GC001181", "α", None, "α입력", "α 직접", "해머", "", None),
("GC001181", "K", None, "K입력", "K 직접", "α입력", "", None),
("GC001181", "γ", None, "γ입력", "γ 직접", "작업", "", None),
(
"GC001181",
"F",
"찾기(CC000430, 작업='항타').F0",
"F0입력",
"작업계수 F0 직접",
"γ입력",
"",
None,
), # fmt: skip
("GC001181", "F인발", "찾기(CC000430, 작업='항발').F0", "F0입력", "", "", "", None), # 같은 칸
(
"GC001186",
"E",
"찾기(CC000466, 구분=E1).E",
"E1입력",
"흙의 두께 효율 직접",
"E1",
"",
None,
), # fmt: skip
(
"GC001186",
"E",
"찾기(CC000468, 구분=E2).E",
"E2입력",
"평면형상 효율 직접",
"E2",
"",
None,
), # fmt: skip
(
"GC001186",
"E",
"찾기(CC000470, 구분=E3).E",
"E3입력",
"단면형상 효율 직접",
"E3",
"",
None,
), # fmt: skip
(
"GC001186",
"E",
"찾기(CC000472, 구분=E4).E",
"E4입력",
"해상조건 효율 직접",
"E4",
"",
None,
), # fmt: skip
(
"GC001187",
"cm",
"찾기(CC000476, 버킷용량=버킷용량).싸이클시간",
"싸이클입력",
"기준 싸이클시간 직접",
"버킷용량",
"sec",
None,
), # fmt: skip
(
"GC001187",
"E",
"찾기(CC000477, 구분=E1).E",
"E1입력",
"흙의 두께 효율 직접",
"E1",
"",
EFF,
), # fmt: skip
(
"GC001187",
"E",
"찾기(CC000479, 구분=E2).E",
"E2입력",
"해상조건 효율 직접",
"E2",
"",
EFF,
), # fmt: skip
("GC001188", "S", None, "S입력", "쇄암면적 직접", "중추중량", "㎡", None),
("GC001188", "n", None, "n입력", "낙추횟수 직접", "S입력", "회", None),
(
"GC001189",
"결과",
"찾기(CC000486, 규격=규격).K",
"K입력",
"능력계수 직접",
"규격",
"",
None,
), # fmt: skip
(
"GC001189",
"결과",
"찾기(CC000487, 스크린=스크린).S",
"S입력",
"스크린계수 직접",
"스크린",
"",
None,
), # fmt: skip
(
"GC001189",
"결과",
"찾기(CC000488, 작업조건=작업조건).E",
"E입력",
"작업효율 직접",
"작업조건",
"",
None,
), # fmt: skip
("GC001190", "q", None, "q입력", "준설량 직접", "배송거리", "㎥/hr", None),
("GC001190", "E", None, "E입력", "작업효율 직접", "유속", "", EFF),
("GF000148", "f", None, "f입력", "체적환산계수 직접", "재료", "", None),
("GF000148", "E", None, "E입력", "작업효율 직접", "f입력", "", EFF),
]
# 지금 「0 = 표」 직접 칸 — 보이는 이름만(열쇠 · 기호 그대로)
RENAME = {
"E입력": "작업효율 직접",
"싸이클입력": "싸이클시간 직접",
"K입력": "버킷계수 직접",
"α입력": "토질계수 직접",
"f입력": "체적환산계수 직접",
"k입력": "버킷계수 직접",
"하역시간입력": "하역시간 직접",
"대기시간입력": "대기시간 직접",
"배출시간입력": "배출시간 직접",
"적재시간입력": "적재시간 직접",
}
RENAME_ROW = {("GC001186", "q입력"): "준설능력 직접"}
ROAD = "찾기(CC000054, 도로상태={road}).{col}"
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 _guard(key: str, body: str) -> str:
return f"만약({key} > 0, {key}, {body})"
def _is_guard(row: dict, name: str) -> bool:
return any(re.search(rf"만약\({re.escape(name)} > 0, {re.escape(name)}, ", s["식"]) for s in row.get("중간") or []) # fmt: skip
def _add_input(row: dict, spec: dict, after: str) -> None:
ins = row["입력"]
at = next(i for i, x in enumerate(ins) if x["이름"] == after)
ins.insert(at + 1, spec)
if isinstance(row.get("시험입력"), dict):
row["시험입력"][spec["이름"]] = spec.pop("_시험", Decimal(0))
spec.pop("_시험", None)
def _table(row: dict, key: str, name: str, pick: bool = False) -> None:
"""변수표 — 기호 · 아래 = 이름 규칙(`master_symbol.rule` · 같은 열쇠 = 같은 기호) · 이름 = 보이는 이름."""
import master_symbol as msym
sign, sub = msym.rule(key, "변수", "고름" if pick else "")[:2]
row.setdefault("변수표", {})[key] = {"기호": sign, "아래": sub, "이름": name}
def apply_op(row: dict, op: tuple) -> None:
_, step, sub, key, name, after, unit, rng = op
target = row["결과"] if step == "결과" else next(s for s in row["중간"] if s["이름"] == step)
text = target["식"]
if sub is None:
target["식"] = _guard(key, text)
else:
assert sub in text, (row["키"], step, sub)
target["식"] = text.replace(sub, _guard(key, sub))
if not name: # 같은 칸을 둘째 줄에도
return
assert key not in {x["이름"] for x in row["입력"]} | {x["이름"] for x in row.get("중간") or []}, key # fmt: skip
spec = {
"이름": key,
"설명": f"{name.removesuffix(' 직접')} — 직접 넣을 때 · 0 이면 고르기(표) 값",
}
if unit:
spec["단위"] = unit
if rng:
spec["범위"] = [Decimal(str(x)) for x in rng]
spec["출처"] = row.get("출처") or ""
_add_input(row, spec, after)
_table(row, key, name)
def rename(row: dict, docs: dict) -> int:
"""지금 직접 칸 보이는 이름 — 기호 · 아래는 지금 수식 문서 그대로 옮겨 적음."""
n = 0
doc = docs.get(str(row["키"])) or {}
for spec in row.get("입력") or []:
key = spec["이름"]
name = RENAME_ROW.get((row["키"], key)) or RENAME.get(key)
if not name or not (_is_guard(row, key) or key == "적재시간입력"):
continue
now = next((v for v in doc.get("변수") or [] if v.get("열쇠") == key), None)
assert now, (row["키"], key)
look = row.setdefault("변수표", {}).setdefault(key, {})
look |= {"기호": now["기호"], "아래": now.get("아래") or "", "이름": name}
if now.get("위"):
look["위"] = now["위"]
n += 1
return n
def dump(row: dict) -> None:
"""덤프 t2 = 구간 셋 · 속도 직접 · t2 ~ t5 직접."""
mids = row["중간"]
names = [m["이름"] for m in mids]
assert "V1" not in names
road = next(i for i in row["입력"] if i["이름"] == "도로상태")
base_road = row["시험입력"]["도로상태"]
speeds = []
after = "도로상태"
for n in (1, 2, 3):
dist, rd = ("운반거리", "도로상태") if n == 1 else (f"구간{n}거리", f"구간{n}도로상태")
tag = "" if n == 1 else f" {n}"
if n > 1:
_add_input(row, {"이름": dist, "설명": f"운반 구간 {n} 거리(편도) — 0 이면 안 씀", "단위": "㎞", "출처": "건설품셈 공통 8-2-8 2"}, after) # fmt: skip
_table(row, dist, f"운반거리{tag}")
_add_input(row, {"이름": rd, "설명": f"운반 구간 {n} 도로 상태", "고르기": list(road["고르기"]), "출처": "건설품셈 공통 8-2-8 3", "_시험": base_road}, dist) # fmt: skip
_table(row, rd, f"도로상태{tag}", pick=True)
after = rd
for k, col, what in ((2 * n - 1, "적재", "적재속도"), (2 * n, "공차", "공차속도")):
key = f"V{k}입력"
_add_input(row, {"이름": key, "설명": f"구간 {n} {col}시 평균주행속도를 직접 넣을 때(측정값 · 3 [주]) — 0 이면 도로상태 표", "단위": "㎞/hr", "출처": "건설품셈 공통 8-2-8 3"}, after) # fmt: skip
_table(row, key, f"{what}{tag} 직접")
after = key
speeds.append({"이름": f"V{k}", "식": _guard(key, ROAD.format(road=rd, col=col)), "단위": "㎞/hr"}) # fmt: skip
row["변수표"][f"V{k}"] = {"기호": "V", "아래": str(k), "이름": f"{col}시 평균주행속도{tag}"} # fmt: skip
_add_input(row, {"이름": "t2입력", "설명": "왕복시간(t2)을 직접 넣을 때 — 0 이면 구간 거리 · 속도로 셈", "단위": "분", "출처": "건설품셈 공통 8-2-8 2"}, after) # fmt: skip
_table(row, "t2입력", "왕복시간(t2) 직접")
legs = ["운반거리 / V1 * 60 + 운반거리 / V2 * 60"] + [
f"만약(구간{n}거리 > 0, 구간{n}거리 / V{2 * n - 1} * 60 + 구간{n}거리 / V{2 * n} * 60, 0)" for n in (2, 3)
] # fmt: skip
t2 = next(m for m in mids if m["이름"] == "t2")
t2["식"] = _guard("t2입력", " + ".join(legs))
at = names.index("t2")
mids[at:at] = speeds
for step, key, name, after_ in (
("t3", "t3입력", "적하시간(t3) 직접", "적하조건"),
("t4", "t4입력", "진입시간(t4) 직접", "적재장소"),
("t5", "t5입력", "덮개시간(t5) 직접", "덮개"),
):
apply_op(row, (DUMP, step, None, key, name, after_, "분", None))
row["비고"] = (
str(row["비고"])
+ " · t2 = 구간 셋(구간 2 · 3 거리 0 = 안 씀) · 속도 · t2 ~ t5 직접 칸 0 = 표"
)
def _call_fill(text: str, key: str, extra: str) -> str:
pat = re.compile(rf"로직\({key},([^()]*(?:\([^()]*\)[^()]*)*)\)")
return pat.sub(lambda m: f"로직({key},{m[1]}{extra})", text)
def main() -> None:
import master_doc_link as ml
docs = ml.load_all()
text, before = _load(C08)
after = copy.deepcopy(before)
rows = {str(r["키"]): r for r in after["줄"]}
if any(m["이름"] == "V1" for m in rows[DUMP]["중간"]):
print("이미 돌림 — 멈춤")
return
renamed = sum(rename(r, docs) for r in rows.values() if (r.get("부품") or {}).get("갈래") == "작업량 틀") # fmt: skip
added: dict[str, list[str]] = {}
for op in OPS:
if op[0] in rows:
apply_op(rows[op[0]], op)
if op[4]:
added.setdefault(op[0], []).append(op[3])
dump(rows[DUMP])
for k, keys in added.items():
rows[k]["비고"] = (
str(rows[k].get("비고") or "") + f" · 직접 칸 {' · '.join(keys)} 0 = 표(851-1)"
)
_save(C08, text, before, after)
print("08장 — 이름만", renamed, "· 직접 칸", sum(map(len, added.values())), "식", len(added))
text, before = _load(F10)
after = copy.deepcopy(before)
rows = {str(r["키"]): r for r in after["줄"]}
for op in OPS:
if op[0] in rows:
apply_op(rows[op[0]], op)
_save(F10, text, before, after)
print("10장 — GF000148 직접 칸 f입력 · E입력")
road = "'교차가 힘든 산간지도로 및 제방 등의 도로'"
dump_extra = (
", V1입력=0, V2입력=0, 구간2거리=0, 구간2도로상태=__R__, V3입력=0, V4입력=0, 구간3거리=0, 구간3도로상태=__R__,"
" V5입력=0, V6입력=0, t2입력=0, t3입력=0, t4입력=0, t5입력=0"
)
extra = {k: "".join(f", {x}=0" for x in keys) for k, keys in added.items()}
extra |= {"GF000148": ", f입력=0, E입력=0", DUMP: dump_extra}
for name in sorted(p.name for p in MASTER.glob("로직_*.json")):
text, before = _load(name)
raw = json.dumps(before, ensure_ascii=False, default=str)
hits = [k for k in extra if f"로직({k}," in raw or f"로직({k})" in raw]
if not hits:
continue
after = copy.deepcopy(before)
def walk(x):
if isinstance(x, dict):
for k, v in x.items():
if isinstance(v, str):
for key in hits:
first = extra[key].split("=")[0].lstrip(", ")
if f"로직({key}" in v and f"{first}=" not in v:
assert f"로직({key})" not in v, (
name,
key,
) # 입력 없는 부름 — 손으로
m = re.search(r"도로상태=('[^']*'|[^,()]+)", v)
v = _call_fill(
v, key, extra[key].replace("__R__", m[1] if m else road)
)
x[k] = v
else:
walk(v)
elif isinstance(x, list):
for v in x:
walk(v)
walk(after)
_save(name, text, before, after)
print("부름 새 입력 0 —", name, " · ".join(hits))
if __name__ == "__main__":
main()