feat(778-5): 블록 = 줄 판정 모음 · 확인한 블록만 단위 SK(바탕 없음 · 근거 꼬리표) · 확인 목록 받는 길(D-3 · 요구 623 · 624)
- 새 M02_Hopyo_SkUnit: 줄 판정(Units 잇기 + 매개값 · 사용자 고름 {차례: 노임|기계|자재|기준|뺌} · 꼬리표 「내가 고름」) · 단가 = M01 지금 값으로 다시 셈(우리금액) · 엑셀 금액 차 = 참고 · 블록 판정 「옮길 수 있음」 | 「고를 줄 n」 · 단위 SK 더한줄 = 인력 · 기계경비 로직 줄 · 재료(손료율 든 수량 · 별도계상) · 율 줄(778-4 꼴 · 줄 목록 = 그 행 add:#k) · 하위 참조 · 값 고정 줄 · 저장 꼴로 다듬어 같은 내용 SK 지문 같음
- Sangeun: 기초 · SK · 고름 대기 갈림(SkPatch.plan) 걷고 단위 SK 하나 · 확인 [{번, 고름?}] 에 든 블록만 만듦 · 하위 단산 먼저 · 고를 줄 남으면 못만듦 · 일위대가 만들기가 부르는 Maker.plan(번) = 「확인 전」 고름 대기(자동 없음) · 별칭 제안 걷음(바탕 기초 없음)
- Router: sangeun 몸 바탕 → 확인(줄 수 그대로)
- 시험 새 뜻: test_729(기초 · SK · 고름 대기 · 계수 · 못옮김 잇기 · 729-5 차이 SK 바탕 길 = 바탕 없는 단위 SK 로 사라짐 → 확인 블록 단위 SK · 줄 고름 · 뺌으로 갈음) · test_718_1 · test_572 · test_779_2 · test_m02_hopyo_flow(확인 목록을 보내야 SK 생김 · 같은 파일 안 같은 내용 단위 SK 없을 수 있음 · 바탕 없는 SK = SC 에 참조 그대로)
- 새 test_778_5: 작업반장 = 건설업 · 규격 차례 무관 · 글자 규격 = 후보 · 손료율 · 설치비 · 제경비 율 줄 · 여덟 파일 줄 연결 표 · 확인 안 한 블록 안 만듦 · 고름 · 400 · 404 · 다시 올림 같은 SK 재사용 · 일위대가 확인 전 못 이음
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -1,24 +1,16 @@
|
||||
"""M02 일위대가 불러오기 → 단가산출(PLAN 718-1 · 729-1 · 요구서 내역19 1장 7 · 3장 6) —
|
||||
산근(단산) 블록마다 매칭 → 비교 → 기초 · SK · 고름 대기.
|
||||
"""M02 일위대가 불러오기 → 단가산출(PLAN 718-1 · 729-1 · 778-5 D-3 · 요구 621 · 623) — 산근(단산) 블록마다
|
||||
줄 판정 모음(`M02_Hopyo_SkUnit`) → 사용자가 확인한 블록만 단위 SK.
|
||||
|
||||
블록마다 그 블록을 부르는 첫 엑셀 줄(「단산N참조」)의 맞춤셈(`M02_Hopyo_Fit` 캐시 · 없으면 그 블록만
|
||||
셈) → `M02_Hopyo_SkPatch.plan`:
|
||||
기초 = SK 바탕 = 1위 기초 · 입력값 · 덮개 없음 · SK = 바탕 기초 + 덮개 · 더한줄 · 뺀줄(엑셀 품 그대로) ·
|
||||
고름 대기 = SK 안 만듦(바탕 없는 SK 로 몰래 채우지 않음) · 후보 다섯(성격 다른 단위 = `계수` 칸 뜻) →
|
||||
사용자가 고른 기초 `바탕 {번: {로직?, 입력값?, 환산?, 잇기?}}` 로 다시 부르면 그 기초에 견줘 SK(이미 있으면
|
||||
그 키에 덮음) · 잇기 `[{id, 노임|기계|자재: 키} | {id, 뺌}]` = 못옮김 → SK 더한줄 · 남은 못옮김 = 응답
|
||||
`만듦[].못옮김` · 본뜬 그대로(그 SK 를 쓰는 일위대가 만들기 = 남은 줄 409 · `M02_Hopyo_SkLink`) ·
|
||||
그대로 SK 의 못옮김 = 응답 `남은못옮김 [{번, 이름, 키, 못옮김}]` · 잇기만 보냈는데 1위 기초가 고름 대기면
|
||||
그 SK 바탕(로직 · 입력값 · 환산)으로 다시 셈(729-5).
|
||||
모두 줄로만(바탕 기초 안 씀 · 맞춤셈 1위 기초 = 근거 꼬리표만) · 자동 없음 — `확인 [{번, 고름?: {차례: 고름}}]`
|
||||
(블록마다 [확인] · [옮기기])에 든 블록만 만듦 · 확인 안 한 블록 = 판정만(안 만듦) · 줄 다 이어지지 않은 확인 블록 =
|
||||
`못만듦` · 하위 단산 줄 = 그 블록 SK 참조(확인 목록에 있으면 먼저 만듦 · 없으면 못만듦).
|
||||
SK = 이름 블록 이름(없으면 줄 품명) · 단위 = 줄 단위(없으면 블록 · 「식」) · 구분 「실무자료」 · 상세구분 = 파일 ·
|
||||
본뜬 = {층 「실무자료」, 키 「HP-###### 단산N」, 파일, 원본, 확인, 갈래, 엑셀품, 못옮김} · 같은 본뜬(키 · 원본)이
|
||||
이 층에 있으면 그대로(겹침 없음) · 만드는 층 = 부르는 층.
|
||||
바탕 없음 · 본뜬 = {층 「실무자료」, 키 「HP-###### 단산N」, 파일, 원본, 확인, 갈래 「단위」, 근거 {로직, 이름}, 못옮김 []} ·
|
||||
같은 본뜬(키 · 원본)이 이 층에 있으면 그 키에 덮음 · 만드는 층 = 부르는 층.
|
||||
같은 내용(733-1 · `M02_Library_Same` 지문) SK 가 이 층에 있으면 새로 안 만들고 그것을 씀 — 이름 = 먼저 만든 것 ·
|
||||
뒤 출처 = 그 SK `본뜬.또 [그 블록 본뜬 + 이름]`(`made` · `origin_of` 가 읽음 · 갈래 · 못옮김은 출처마다) ·
|
||||
다른 출처가 쓰는 SK 는 내용을 안 바꿈(고른 기초 · 잇기로 바뀌면 떼고 다시 찾음) · 응답 `같은것씀 [{번, 키}]` ·
|
||||
위 층(회사 · 마스터) 같은 것 = 응답 `위층같음 [{번, 층, 주인, 키}]`(알림만 · 연결 안 함).
|
||||
별칭 제안 = 기초 · SK 만든 블록의 엑셀 줄 → 이 층 별칭 장부 짝 = 바탕 기초까지만(차이 SK 는 이 층 문서 ·
|
||||
요구서 3장 6) · 장부에 이미 짝 · 갈래가 있는 줄은 그대로 · 승인 길 = M01 별칭 장부(716).
|
||||
뒤 출처 = 그 SK `본뜬.또 [그 블록 본뜬 + 이름]`(`made` · `origin_of` 가 읽음) · 다른 출처가 쓰는 SK 는 내용을
|
||||
안 바꿈(바뀌면 떼고 다시 찾음) · 응답 `같은것씀 [{번, 키}]` · 위 층 같은 것 = `위층같음 [{번, 층, 주인, 키}]`(알림만).
|
||||
일위대가 만들기(`M02_Hopyo_SkLink`)가 부르는 `Maker.plan(번)`(확인 없음) = 고름 대기 「확인 전」 — 못 이음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -32,14 +24,16 @@ from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Hopyo_Fit as fit
|
||||
from M02_MasterTemplete import M02_Hopyo_Ledger as ledger
|
||||
from M02_MasterTemplete import M02_Hopyo_SkPatch as skpatch
|
||||
from M02_MasterTemplete import M02_Hopyo_SkUnit as skunit
|
||||
from M02_MasterTemplete import M02_Hopyo_Units as units
|
||||
from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Library_Same as same
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
|
||||
ORIGIN = "실무자료"
|
||||
KIND = "sangeun"
|
||||
WAIT_WHY = "확인 전 — [단가산출]에서 블록 [확인] 뒤 [옮기기]"
|
||||
|
||||
|
||||
def mark(key: str, no: int) -> str:
|
||||
@@ -99,50 +93,26 @@ def _bad(text: str, status: int = 400) -> store.StoreError:
|
||||
return store.StoreError(status, text)
|
||||
|
||||
|
||||
def _picks(raw: Any) -> dict[int, dict[str, Any]]:
|
||||
"""사용자 고름 `{번: {로직?, 입력값?, 환산?, 잇기?}}` 재검사 — 돈 로직만 · 입력 이름 = 그 로직 입력 ·
|
||||
환산 = SK 꼴(`M02_Sangeun_Doc`) · 잇기 = `[{id, …}]`(id 짝 · 키는 `M02_Hopyo_SkPatch` 가 봄)."""
|
||||
def _sure(raw: Any) -> dict[int, dict[int, Any]]:
|
||||
"""확인 목록 `[{번, 고름?: {차례: 고름}}]` → `{번: {차례: 고름}}`(고름 꼴은 `M02_Hopyo_SkUnit` 이 봄)."""
|
||||
if not raw:
|
||||
return {}
|
||||
if not isinstance(raw, dict) or len(raw) > 500:
|
||||
raise _bad("바탕은 {블록 번: {로직, 입력값}}")
|
||||
logics = ledger._known()[0]
|
||||
out = {}
|
||||
for no, one in raw.items():
|
||||
code = str((one or {}).get("로직") or "") if isinstance(one, dict) else "?"
|
||||
if code and code not in logics:
|
||||
raise _bad(f"단산{no} · 돈 로직이 아님 「{code}」")
|
||||
if not code and not (one.get("환산") or one.get("잇기")):
|
||||
raise _bad(f"단산{no} · 로직 · 환산 · 잇기 중 하나")
|
||||
pick: dict[str, Any] = {}
|
||||
given = one.get("입력값") if code else None
|
||||
if code:
|
||||
pick["로직"] = code
|
||||
if given is not None:
|
||||
bad = set(given) - ledger.input_names(code) if isinstance(given, dict) else {1}
|
||||
if bad:
|
||||
raise _bad(f"단산{no} · 모르는 입력 {sorted(map(str, bad))}")
|
||||
pick["입력값"] = given
|
||||
if one.get("환산"):
|
||||
try:
|
||||
pick["환산"] = sd._swap_how(one["환산"])
|
||||
except sd.DocError as e:
|
||||
raise _bad(f"단산{no} · {e}") from e
|
||||
links = one.get("잇기")
|
||||
if links:
|
||||
if not isinstance(links, list) or not all(
|
||||
isinstance(x, dict) and x.get("id") for x in links
|
||||
):
|
||||
raise _bad(f"단산{no} · 잇기는 [{{id, 노임|기계|자재: 키}}]")
|
||||
pick["잇기"] = links
|
||||
out[int(no)] = pick
|
||||
if not isinstance(raw, list) or len(raw) > 500:
|
||||
raise _bad("확인은 [{번, 고름?: {차례: 고름}}]")
|
||||
out: dict[int, dict[int, Any]] = {}
|
||||
for one in raw:
|
||||
try:
|
||||
picks = one.get("고름") or {}
|
||||
out[int(one["번"])] = {int(k): v for k, v in picks.items()}
|
||||
except (TypeError, ValueError, KeyError, AttributeError) as e:
|
||||
raise _bad("확인은 [{번, 고름?: {차례: 고름}}]") from e
|
||||
return out
|
||||
|
||||
|
||||
def _doc(line: dict, block: dict, no: int, hp: dict, plan: dict, sure: dict) -> dict[str, Any]:
|
||||
name = str(block.get("이름") or line.get("이름") or "").strip() or f"단산{no}"
|
||||
unit = str(line.get("단위") or block.get("단위") or "").strip() or "식"
|
||||
keep = {k: plan[k] for k in ("갈래", "엑셀품", "못옮김")}
|
||||
keep = {k: plan[k] for k in ("갈래", "엑셀품", "못옮김", "근거") if k in plan}
|
||||
keep |= {"놓음": plan["놓음"]} if plan.get("놓음") else {}
|
||||
return {
|
||||
"종류": "단가산출",
|
||||
@@ -160,32 +130,6 @@ def _doc(line: dict, block: dict, no: int, hp: dict, plan: dict, sure: dict) ->
|
||||
}
|
||||
|
||||
|
||||
def _old_base(folder: Path, key: str, mark_: str, source: refs.Here) -> dict[str, Any]:
|
||||
"""이미 있는 SK 의 바탕 고름 `{로직, 입력값, 환산?}` · `본뜬` — 읽기 실패 = 빈 것."""
|
||||
try:
|
||||
doc = json.loads((Path(folder) / KIND / f"{key}.json").read_bytes())
|
||||
except (OSError, ValueError):
|
||||
return {}
|
||||
base = {"로직": (doc.get("바탕") or {}).get("로직"), "입력값": doc.get("입력값") or {}}
|
||||
return {
|
||||
**base,
|
||||
**({"환산": doc["환산"]} if doc.get("환산") else {}),
|
||||
"본뜬": origin_of(doc, mark_, source),
|
||||
}
|
||||
|
||||
|
||||
def _alias(line: dict, plan: dict) -> dict[str, Any]:
|
||||
origin = {"품명": line.get("이름"), "규격": line.get("규격"), "단위": line.get("단위")}
|
||||
clauses = (line.get("근거") or {}).get("출처") or []
|
||||
pair = {"로직": plan["바탕"]["로직"], "입력값": plan["입력값"], "배": 1, "몫": None}
|
||||
return {
|
||||
"원래": {k: str(v or "") for k, v in origin.items()},
|
||||
"갈래": "짝",
|
||||
"짝": [pair],
|
||||
"엑셀조항": clauses if isinstance(clauses, list) else [],
|
||||
}
|
||||
|
||||
|
||||
class Maker:
|
||||
"""한 번 만들기 — 파일 · 맞춤셈 · 이 층 SK 를 한 번 읽음(`source` = 파일 층 · 쓰기 = `store.root()`)."""
|
||||
|
||||
@@ -199,16 +143,77 @@ class Maker:
|
||||
self.whole = m01.loaded()[1]
|
||||
self.sure = {"원본": list(self.here), "확인": {"누가": who, "때": utc_now_text()}}
|
||||
self.same, self.reused, self.above = same.Same(), [], []
|
||||
self.keys = made(source, key, self.here) # {본뜬 키: SK} — 만든 것 더해 감
|
||||
self.judged: dict[int, dict] = {}
|
||||
self._units: units.Units | None = None
|
||||
|
||||
def plan(self, no: int, pick: dict | None = None) -> dict[str, Any]:
|
||||
def units(self) -> units.Units:
|
||||
if self._units is None:
|
||||
books = ledger.books(self.source)
|
||||
self._units = units.Units(books, ledger.doc_id(self.source, self.key))
|
||||
return self._units
|
||||
|
||||
def basis(self, no: int) -> dict[str, Any] | None:
|
||||
"""근거 꼬리표 = 맞춤셈 1위 기초(참고)."""
|
||||
entry = self.cache.get(fit.unit_key(self.first[no])) or {}
|
||||
top = (entry.get("차례") or [None])[0]
|
||||
if not top:
|
||||
return None
|
||||
name = (self.whole.logic(top) or {}).get("이름")
|
||||
return {"로직": top, "이름": name, "판정": (entry.get("판정") or {}).get("상태")}
|
||||
|
||||
def ref_of(self, sub: dict[str, Any]) -> dict[str, Any] | None:
|
||||
"""하위 줄 → 참조 칸 — 단산 = 이 HP 그 블록 SK · 일위 = 확인된 그 호표 SC · 없으면 None."""
|
||||
from M02_MasterTemplete import M02_Hopyo_Build as hopyo_build # Build → SkLink → 여기
|
||||
|
||||
if sub.get("종류") == "단산":
|
||||
got = self.keys.get(mark(self.key, int(sub["번"])))
|
||||
else:
|
||||
done = hopyo_build.confirmed(store.root(), self.here)
|
||||
got = done.get(hopyo_build.mark(self.key, int(sub["번"])))
|
||||
layer, owner = refs.here()
|
||||
return {"층": layer, "주인": owner, "키": got} if got else None
|
||||
|
||||
def judge(self, no: int, picks: dict | None = None) -> dict[str, Any]:
|
||||
line, block = self.first[no], self.blocks[no]
|
||||
entry = self.cache.get(fit.unit_key(line))
|
||||
if entry is None and not (pick or {}).get("로직"):
|
||||
entry = fit.compute(block, line)
|
||||
unit = str(line.get("단위") or block.get("단위") or "").strip()
|
||||
try:
|
||||
return skpatch.plan(entry, block, line, self.whole, pick)
|
||||
except skpatch.LinkError as e:
|
||||
got = skunit.judge(block, self.units(), self.ref_of, picks, unit)
|
||||
except skunit.PickError as e:
|
||||
raise _bad(f"단산{no} · {e}") from e
|
||||
self.judged[no] = got
|
||||
return got
|
||||
|
||||
def plan(self, no: int, picks: dict | None = None) -> dict[str, Any]:
|
||||
"""확인한 블록 → 단위 SK 꼴 · 확인 없음(`picks` None) · 고를 줄 남음 = 고름 대기."""
|
||||
if picks is None:
|
||||
return {"갈래": skpatch.WAIT, "까닭": WAIT_WHY, "후보": []}
|
||||
got = self.judge(no, picks)
|
||||
if got["고를줄"]:
|
||||
return {"갈래": skpatch.WAIT, "까닭": got["판정"], "후보": []}
|
||||
return skunit.plan(got, self.basis(no))
|
||||
|
||||
def make(self, no: int, sure: dict[int, dict], out: dict, path: tuple = ()) -> None:
|
||||
"""확인한 블록 하나 — 확인 목록의 하위 단산 먼저 · 못 만들면 `못만듦`."""
|
||||
mark_ = mark(self.key, no)
|
||||
if no in path or any(x["번"] == no for x in out["만듦"] + out["못만듦"]):
|
||||
return
|
||||
for one in self.blocks[no].get("항목") or []:
|
||||
sub = one.get("하위") or {}
|
||||
m = int(sub.get("번") or 0)
|
||||
if sub.get("종류") == "단산" and m in sure and mark(self.key, m) not in self.keys:
|
||||
self.make(m, sure, out, (*path, no))
|
||||
plan = self.plan(no, sure[no])
|
||||
got = self.judged[no]
|
||||
lost = [r for r in got["줄"] if r["상태"] == units.LINKED and r["차례"] not in got["담음"]]
|
||||
name = self.blocks[no].get("이름") or self.first[no].get("이름")
|
||||
if plan["갈래"] == skpatch.WAIT or lost:
|
||||
why = plan.get("까닭") or f"하위 「{lost[0]['이름']}」 — 그 블록 먼저 확인"
|
||||
out["못만듦"].append({"번": no, "이름": name, "까닭": why})
|
||||
return
|
||||
key = self.write(no, plan, self.keys.get(mark_))
|
||||
self.keys[mark_] = key
|
||||
out["만듦"].append({"번": no, "이름": name, "키": key, "갈래": skunit.UNIT, "못옮김": []})
|
||||
|
||||
def write(self, no: int, plan: dict, have: str | None) -> str:
|
||||
"""그 블록 SK 를 씀 → 키 — 다른 출처(또)가 쓰는 SK 의 내용은 안 바꿈(바뀌면 떼고 다시 찾음)."""
|
||||
@@ -261,53 +266,29 @@ class Maker:
|
||||
|
||||
|
||||
def build(folder: Path, key: str, who: Any = None, picks: Any = None) -> dict[str, Any]:
|
||||
"""[단가산출 만들기] — 산근 블록마다 기초 · SK · 고름 대기 → `{블록, 만듦 [{번, 이름, 키, 갈래, 못옮김,
|
||||
환산?}], 그대로, 남은못옮김 [{번, 이름, 키, 못옮김}], 기초, SK, 고름대기 [{번, 이름, 단위, 까닭, 후보}],
|
||||
별칭, 같은것씀 [{번, 키}], 위층같음 [{번, 층, 주인, 키}]}` · `picks` = 고름."""
|
||||
chosen = _picks(picks)
|
||||
"""[단가산출] — 블록마다 줄 판정 · 확인한 블록만 단위 SK → `{블록, 판정 [{번, 이름, 단위, 판정, 고를줄,
|
||||
우리금액, 엑셀금액, 근거, 만든, 줄}], 만듦 [{번, 이름, 키, 갈래, 못옮김}], 못만듦 [{번, 이름, 까닭}], 그대로,
|
||||
같은것씀, 위층같음}` · `picks` = 확인 목록."""
|
||||
sure = _sure(picks)
|
||||
maker = Maker(folder, key, who)
|
||||
bad = sorted(set(chosen) - set(maker.first))
|
||||
bad = sorted(set(sure) - set(maker.first))
|
||||
if bad:
|
||||
raise _bad(f"없는 블록 · 부르는 줄 없음 「단산{bad[0]}」", 404)
|
||||
if not maker.done and set(maker.first) - set(chosen):
|
||||
if not maker.done:
|
||||
fit.ensure(folder, key)
|
||||
raise _bad("맞춤 셈 중 — 끝나면 다시 누름", 409)
|
||||
have = made(folder, key, maker.here)
|
||||
out: dict[str, Any] = {"블록": len(maker.first), "만듦": [], "그대로": 0, "고름대기": []}
|
||||
out["남은못옮김"] = []
|
||||
out.update({skpatch.BASE: 0, skpatch.SK: 0})
|
||||
books, alias = ledger.books(folder), {}
|
||||
out: dict[str, Any] = {"블록": len(maker.first), "만듦": [], "못만듦": []}
|
||||
for no in sorted(sure):
|
||||
maker.make(no, sure, out)
|
||||
rows = []
|
||||
for no in sorted(maker.first):
|
||||
old = have.get(mark(key, no))
|
||||
line = maker.first[no]
|
||||
name = maker.blocks[no].get("이름") or line.get("이름")
|
||||
if old and no not in chosen:
|
||||
out["그대로"] += 1
|
||||
lost = _old_base(folder, old, mark(key, no), maker.here)["본뜬"].get("못옮김")
|
||||
if lost:
|
||||
out["남은못옮김"].append({"번": no, "이름": name, "키": old, "못옮김": lost})
|
||||
continue
|
||||
plan = maker.plan(no, chosen.get(no))
|
||||
if plan["갈래"] == skpatch.WAIT and old and not chosen[no].get("로직"):
|
||||
base = _old_base(
|
||||
folder, old, mark(key, no), maker.here
|
||||
) # 고른 기초로 만든 SK 의 잇기 = 그 바탕 그대로
|
||||
if base.get("로직"):
|
||||
pick = {k: v for k, v in base.items() if k != "본뜬"}
|
||||
plan = maker.plan(no, {**pick, **chosen[no]})
|
||||
if plan["갈래"] == skpatch.WAIT:
|
||||
head = {"번": no, "이름": maker.blocks[no].get("이름") or line.get("이름")}
|
||||
out["고름대기"].append({**head, "단위": line.get("단위"), **plan})
|
||||
continue
|
||||
got = maker.write(no, plan, old)
|
||||
out[plan["갈래"]] += 1
|
||||
made_ = {"번": no, "이름": name, "키": got, "갈래": plan["갈래"], "못옮김": plan["못옮김"]}
|
||||
out["만듦"].append({**made_, **({"환산": plan["환산"]} if plan.get("환산") else {})})
|
||||
found = ledger.recall(line, folder, books)
|
||||
if no in chosen or found is None or found.get("규격다름"):
|
||||
alias[ledger.key(line)] = _alias(line, plan)
|
||||
out["별칭"] = ledger.write(
|
||||
folder, alias, who, maker.hp.get("파일") or None, ledger.doc_id(folder, key)
|
||||
)
|
||||
line, block = maker.first[no], maker.blocks[no]
|
||||
got = maker.judged.get(no) or maker.judge(no)
|
||||
head = {"번": no, "이름": block.get("이름") or line.get("이름"), "단위": line.get("단위")}
|
||||
keep = ("판정", "고를줄", "우리금액", "엑셀금액", "줄")
|
||||
head |= {k: got[k] for k in keep} | {"근거": maker.basis(no)}
|
||||
rows.append({**head, "만든": maker.keys.get(mark(key, no))})
|
||||
out["판정"] = rows
|
||||
out["그대로"] = sum(1 for r in rows if r["만든"] and r["번"] not in sure)
|
||||
out["같은것씀"], out["위층같음"] = maker.reused, maker.above
|
||||
return out
|
||||
|
||||
Reference in New Issue
Block a user