chore(853-3): 호표 계보 죽은 것 걷음 — 묶음 ①

- 지움(부르는 곳 다시 찾음 — 저장소 전체 · 조립 주소 · 라우터 · 시험 · 도우미)
  · M02_Hopyo_SkUnit(import 0 · 시험 778-5 · 780-1 만) · M02_Hopyo_Item(길 hopyo-item 하나만)
  · 길 GET hopyo/{키}/{번}/siblings · POST hopyo-item(TS · JS 0 — 화면 [구조물 조합으로]는 구조물 조합 길을 바로 부름) + 그 몸 Build* 다섯
  · Library_Ask.ask_item · labor_finger(Hopyo_Item 만 부름)
  · Hopyo_Sangeun.Maker · _doc(만드는 곳 0) · Hopyo_Elem.prices · Hopyo_Units.hopyo_unit · summary(부르는 곳 0 · 시험만)
- 시험: test_572_hopyo_same 지움(Maker 만 봄) · test_705_2 구조물 조합으로 넷 지움 · test_778_5 단위 SK 셈 줄 뺌(줄 잇기 결과는 그대로 · 연결 표 셈은 시험 안에서) · test_780_1 단위 SK 판정 뺌(블록 · 부름 수 · 빈 블록 밖은 그대로)
- helper_728_2_cover_unit.cjs 는 SkUnit 안 부름(Cover_Model 을 봄) — 남김
- 서버 길 484 → 482(뜻한 둘만)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 14:47:45 +09:00
co-authored by Claude Opus 5.5
parent df1f74bd63
commit 7fd47cf727
13 changed files with 21 additions and 890 deletions
-11
View File
@@ -20,7 +20,6 @@ from typing import Any
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Hopyo_Match as hm
from M02_MasterTemplete import M02_Hopyo_Material as hmat
from M02_MasterTemplete import M02_Hopyo_UnitLine as unit_line
from M02_MasterTemplete import M02_Machine_Find as mfind
from M02_MasterTemplete.M02_Hopyo_Words import nfkc
@@ -28,16 +27,6 @@ TOP = 3
POOL = 5
def prices(block: dict[str, Any] | None) -> dict[str, float]:
"""블록 단위 줄(노무 · 자재 · 값) → `{이름: 엑셀 단가}`(첫 것 · 776-3 — 글 다시 안 풂)."""
out: dict[str, float] = {}
for one in (block or {}).get("항목") or []:
price = unit_line.money(one.get("단가")) if one.get("묶음") in ("L", "M", "E") else None
if price:
out.setdefault(re.sub(r"^[0-9가-힣]\.", "", str(one.get("이름") or "")).strip(), price)
return out
def _gap(price: Any, want: float | None) -> float:
try:
p = float(price)
-155
View File
@@ -1,155 +0,0 @@
"""실무 호표 → 구조물 조합 항목 한 단계(PLAN 704-4 뒷부분 · `_제안_704-4_규격표.md` 6장 끝) — 사전조합 안 거침.
[구조물 조합으로] = 확인 창 몸(체크한 줄 · 통째 · `M02_Hopyo_Build.check` 그대로)으로 줄을 만들어(`build(save=False)` ·
사전조합 SC 문서 안 씀 · 옛 [사전조합 생성] 길은 그대로) 이 층 구조물집계표에 새 항목(SU · `M02_Item_Personal.create_item`
· 경로 「실무자료」) + 그 일위대가 문서에 줄을 담음(수량 = 1 단위 몫 `{손}`).
확인 안 된 하위 호표 = 고정 줄(하위 먼저 만들기는 옮기기 `M02_Hopyo_Make` 몫 · 785-7).
규격 묶음 = 같은 파일에서 이름 · 단위 같고 줄 구성(줄 이름 · 단위 차례) 같은 · 규격만 다른 호표(5-A 「구성 같은 묶음」) →
한 항목의 규격 열(704-4) — 열 이름 = 규격 글에서 달라지는 칸(「H=1.5」 → 이름 H · 열 1.5) · 아니면 이름 「규격」 ·
열마다 같은 몸으로 만든 줄 수량(줄 차례 같음 · 다르면 400) · 기본 열 = 연 호표.
"""
from __future__ import annotations
import re
from pathlib import Path
from typing import Any
from M02_MasterTemplete import M02_Hopyo_Build as hb
from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store
from M02_MasterTemplete import M02_Item_Personal as personal
from M02_MasterTemplete import M02_Labor_Spec as spec
from M02_MasterTemplete import M02_Library_Ask as ask
from M02_MasterTemplete import M02_MasterTemplete_Store as store
PATH = ["실무자료"]
_TOKEN = re.compile(r"[\s,]+")
_PAIR = re.compile(r"^([A-Za-z가-힣Φφ]+)\s*[=:]?\s*([\d.]+)\D{0,3}$")
def _flat(text: Any) -> str:
return re.sub(r"\s+", "", str(text or ""))
def _shape(h: dict[str, Any]) -> tuple:
return tuple((_flat(x.get("이름")), _flat(x.get("단위"))) for x in h.get("줄") or [])
def columns(specs: list[str]) -> tuple[str, list[str]]:
"""규격 글들 → (규격 이름, 열 이름) — 처음 달라지는 칸이 모두 「H=1.5」 꼴이면 (H, [1.5 …]) ·
아니면 (「규격」, 그 칸 글) · 20 자 자름 · 겹치면 뒤에 차례."""
parts = [[t for t in _TOKEN.split(s.strip()) if t] for s in specs]
width = max((len(p) for p in parts), default=0)
at = next((i for i in range(width) if len({p[i] if i < len(p) else "" for p in parts}) > 1), 0)
cells = [p[at] if at < len(p) else "" for p in parts]
hits = [_PAIR.match(c) for c in cells]
if all(hits) and len({h.group(1) for h in hits}) == 1:
name, cols = hits[0].group(1), [h.group(2) for h in hits]
else:
name, cols = "규격", [c or s for c, s in zip(cells, specs, strict=True)]
out: list[str] = []
for c in cols:
c = (c.strip() or "열")[: spec.NAME_MAX]
while c in out:
c = f"{c[: spec.NAME_MAX - 2]}·{len(out) + 1}"
out.append(c)
return name[: spec.NAME_MAX], out
def siblings(source: Path, key: str, no: int) -> dict[str, Any]:
"""규격 묶음 제안 — 같은 이름 · 단위 · 줄 구성 · 규격 다른 호표(연 호표 먼저) →
`{묶음 [{번, 규격, 열}], 이름}` · 없으면 묶음 빈 것."""
units = hopyo_store.read(source, key).get("호표") or []
me = next((h for h in units if int(h["번"]) == int(no)), None)
if me is None:
raise store.StoreError(404, f"없는 호표 「제{no}호표」")
same = [
h
for h in units
if _flat(h.get("이름")) == _flat(me.get("이름"))
and _flat(h.get("단위")) == _flat(me.get("단위"))
and _shape(h) == _shape(me)
]
same.sort(key=lambda h: (int(h["번"]) != int(no), int(h["번"])))
specs = list(dict.fromkeys(_flat(h.get("규격")) for h in same))
if len(same) < 2 or len(specs) != len(same):
return {"묶음": [], "이름": None}
name, cols = columns([str(h.get("규격") or "") for h in same])
rows = [
{"번": int(h["번"]), "규격": h.get("규격") or "", "열": c}
for h, c in zip(same, cols, strict=True)
]
return {"묶음": rows, "이름": name}
def _doc(folder: Path, source: Path, key: str, no: int, lines: list, whole: Any, who: Any) -> dict:
maker = hb.Builder(folder, source, key, no, who)
checked, pairs = maker.check(list(lines or []), whole)
return {**maker.build(checked, pairs, save=False), "호표": maker.hopyo}
def make_item(
folder: Path,
source: Path,
key: str,
no: int,
lines: list[dict[str, Any]] | None = None,
whole: dict[str, Any] | None = None,
bundle: list[int] | None = None,
name: str | None = None,
who: Any = None,
new: bool = False,
use: str | None = None,
) -> dict[str, Any]:
"""[구조물 조합으로] → `{key, 열, 이름, 줄수, 열수, 빠진줄}` —
`bundle` = 규격 열로 묶을 호표 번(연 호표 빼고) ·
이 층 같은 내용 항목 = 409(733-2) → `new` 그래도 새로 · `use` 그 항목(`씀` · 새로 안 만듦)."""
main = _doc(folder, source, key, no, lines, whole, who)
doc, hopyo = main["문서"], main["호표"]
title = (name or "").strip() or doc["이름"]
cols_doc = None
if bundle:
found = {r["번"]: r for r in siblings(source, key, no)["묶음"]}
want = [int(no), *(int(b) for b in bundle if int(b) != int(no))]
if any(b not in found for b in want):
raise store.StoreError(400, "규격 묶음은 이름 · 단위 · 줄 구성이 같은 호표만")
title = (name or "").strip() or str(hopyo.get("이름") or doc["이름"])
qty: dict[str, dict[str, Any]] = {}
for b in want:
got = (
main["문서"]
if b == int(no)
else _doc(folder, source, key, b, lines, whole, who)["문서"]
)
col = found[b]["열"]
for part in ("담은로직", "자재"):
mine, theirs = doc[part], got[part]
if len(mine) != len(theirs):
raise store.StoreError(400, f"제{b}호표 줄 구성이 다름 — 묶지 않고 따로 만듦")
for one, other in zip(mine, theirs, strict=True):
hand = (other.get("수량") or {}).get("손")
if hand is not None:
qty.setdefault(str(spec.line_key(one)), {})[col] = hand
cols_doc = {
"이름": siblings(source, key, no)["이름"],
"열": [found[b]["열"] for b in want],
"기본": found[int(no)]["열"],
"수량": qty,
}
count = {
"줄수": len(doc["담은로직"]) + len(doc["자재"]),
"열수": len(cols_doc["열"]) if cols_doc else 1,
}
want = {"담은로직": doc["담은로직"], "자재": doc["자재"], "단위": doc.get("단위")}
reuse = ask.ask_item(folder, {**want, "규격": cols_doc}, new, use)
if reuse:
return {**reuse, **count, "빠진줄": main["빠진줄"]}
with store.at(folder):
made = personal.create_item(folder, PATH, title, doc.get("단위"))
have = store.read("labor", made["열"])
body = {**have["문서"], "담은로직": doc["담은로직"], "자재": doc["자재"]}
body["단위"] = doc.get("단위") or body.get("단위")
if cols_doc:
body["규격"] = cols_doc
store.write("labor", made["열"], have["판"], body)
return {**made, **count, "빠진줄": main["빠진줄"]}
+1 -1
View File
@@ -4,7 +4,7 @@
부모 줄 = 하위 사본(740-1 그대로) · 옛 서버 체크 제안 하위 함께(`first` · `proposal`)는 785-7 에서 지움.
같은 내용 일위대가 재사용 `save` — 같은 본뜬(키 · 원본)이면 그 SC(혼자 쓰면 덮음 · 나눠 쓰면 내용 같을 때만) ·
아니면 이 층 같은 이름 · 같은 내용 SC(`M02_Library_Same.find_same` + 수량까지) 의 `본뜬.또` 에 출처를 더해 씀
(SK 꼴 `M02_Hopyo_Sangeun.Maker.write`) · 없으면 새로 → 다시 불러와도 SC 가 안 늚.
· 없으면 새로 → 다시 불러와도 SC 가 안 늚.
"""
from __future__ import annotations
+4 -83
View File
@@ -5,15 +5,16 @@
옛 판정 · 검산 · 옮기기 · 근거 제안 길(785-5 `hopyo-judge` · `check` · `move` · `price` · 793-3a `hopyo-basis`)은
809-1 에서 지움(요구 703 — 기초로 바꾸기 없음).
그대로 쓰는 길(목록 · 올림 · 엑셀 보기 머리 · 격자 · 지우기 · 모두 고정 · 붙여넣기 · 다시 잇기 ·
구조물 조합 · 칠 = B09 · M01 이 씀) · 옛 맞춤 길(호표 하나 맞춤 · 미리 셈 · 실무 호표 · 확인 만들기 · 안 이은 줄 ·
단가산출 만들기)은 785-7 에서 지움.
칠 = B09 · M01 이 씀) · 옛 맞춤 길(호표 하나 맞춤 · 미리 셈 · 실무 호표 · 확인 만들기 · 안 이은 줄 ·
단가산출 만들기)은 785-7 ·
옛 [구조물 조합으로] 길(`hopyo-item` · `siblings` — 화면은 구조물 조합 길을 바로 부름)은 853-3 에서 지움.
층 = 늘 개인(요구 855 · 위 `_root` 가 고정) · ⚠ 등록은 `main.py`(로그인만).
"""
from __future__ import annotations
from pathlib import Path
from typing import Any, Literal
from typing import Any
from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
from pydantic import BaseModel, ConfigDict, Field
@@ -24,7 +25,6 @@ from M02_MasterTemplete import M02_Hopyo_Build as hopyo_build
from M02_MasterTemplete import M02_Hopyo_Excel as hopyo_excel
from M02_MasterTemplete import M02_Hopyo_Forget as hopyo_forget
from M02_MasterTemplete import M02_Hopyo_Grid as hopyo_grid
from M02_MasterTemplete import M02_Hopyo_Item as hopyo_item
from M02_MasterTemplete import M02_Hopyo_Marks as hopyo_marks
from M02_MasterTemplete import M02_Hopyo_Paste as hopyo_paste
from M02_MasterTemplete import M02_Hopyo_Relink as hopyo_relink
@@ -141,45 +141,6 @@ class _Strict(BaseModel):
model_config = ConfigDict(extra="forbid") # 금액 · 품 칸 = 400(서버가 셈)
class BuildTarget(_Strict):
"""대상 하나 — 로직 · 자재 · 호표 중 하나 · 배 = 우리 수량 ÷ 엑셀 수량 · 몫 = 섞인 줄 몫."""
로직: str | None = None
자재: str | None = None
호표: int | None = None
전국: bool | None = None # 「전국」 자재(361-1 · 키 없음 · 서버가 줄에서 다시 셈)
노임: str | None = None # 729-2 사용자 이음 — LB 키(엑셀 숫자 + 이음)
기계: str | None = None # EQ 키
비율: Literal["노무비", "재료비", "경비"] | None = None # % 줄 밑수
입력값: dict[str, Any] = Field(default_factory=dict)
배: float = 1
몫: float | None = None
class BuildLine(_Strict):
"""확인한 줄 — `차례` = 호표 안 줄(0부터) · `대상` 목록 또는 `뺌` 까닭."""
차례: int
대상: list[BuildTarget] = Field(default_factory=list)
뺌: Literal["우리에 없음", "안 씀"] | None = None
class BuildWhole(_Strict):
대상: list[BuildTarget]
class BuildBody(_Strict):
"""실무 호표 → 이 층 사전조합 — 파일 층 `층` · `주인` · `키` + 호표 `번` + 확인한 `줄` ·
직접 줄 호표 = `통째` · 같은 본뜬은 늘 덮음."""
층: Layer
주인: str | None = None
키: str
번: int
줄: list[BuildLine] = Field(default_factory=list, max_length=500)
통째: BuildWhole | None = None
class BuildAllBody(_Strict):
"""시트 통째(705-3) — 파일 층 `층` · `주인` · `키` 만(숫자 · 줄 칸 없음 · 서버가 파일에서 읽음) ·
`번` = 그 호표 하나 + 하위(807-1 [내 일위대가로])."""
@@ -284,46 +245,6 @@ def hopyo_relink_apply(
return _call(folder, hopyo_relink.apply, body.바꿈)
@router.get("/layers/{layer}/hopyo/{key}/{no}/siblings")
def hopyo_siblings(
layer: Layer,
key: str,
no: int,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""규격 묶음 제안(704-4) — 이름 · 단위 · 줄 구성 같고 규격만 다른 호표 `{묶음 [{번, 규격, 열}], 이름}`."""
folder = _root(session, layer, owner)
return _call(folder, hopyo_item.siblings, folder, key, no)
class ItemBody(BuildBody):
"""[구조물 조합으로](704-4) — 확인 창 몸 그대로 + `묶음` = 규격 열로 묶을 호표 번 · `이름` = 항목 이름."""
묶음: list[int] = Field(default_factory=list, max_length=20)
이름: str | None = Field(None, max_length=120)
새로: bool = False # 같은 내용 항목 409 뒤 — 그래도 새로(733-2)
씀: str | None = Field(None, max_length=80) # 같은 내용 409 뒤 — 그 항목 씀
@router.post("/layers/{layer}/hopyo-item")
def hopyo_to_item(
layer: Layer,
body: ItemBody,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""실무 호표 → 이 층 구조물 조합 항목(사전조합 안 만듦 · 이 층 쓰기 · 파일 층 읽기) →
`{key, 열, 이름, 줄수, 열수, 빠진줄}`."""
folder = _root(session, layer, owner, write=True)
source = _root(session, body.층, body.주인)
lines = [one.model_dump(exclude_none=True) for one in body.줄]
whole = body.통째.model_dump(exclude_none=True) if body.통째 else None
args = (folder, source, body.키, body.번, lines, whole, body.묶음, body.이름, _who(session))
args += (body.새로, body.씀)
return _call(folder, hopyo_item.make_item, *args)
@router.get("/layers/{layer}/hopyo-marks/{key}")
def hopyo_marks_read(
layer: Layer,
+2 -114
View File
@@ -1,12 +1,7 @@
"""M02 일위대가 불러오기 → 단가산출(PLAN 718-1 · 729-1 · 778-5 · 785-5 · 785-7 · 요구 621 · 623 · 642) — SK 쓰기 · 이음.
SK 쓰기 = `Maker.write`(옮기기 `M02_Hopyo_Make` 가 부름 · 확인한 블록만) — 이름 블록 이름(없으면 줄 품명) ·
단위 = 줄 단위(없으면 블록 · 「식」) · 구분 「실무자료」 · 상세구분 = 파일 · 본뜬 = {층 「실무자료」,
키 「HP-###### 단산N」, 파일, 원본, 확인, 갈래, 근거, 못옮김 []} · 같은 본뜬(키 · 원본)이 이 층에 있으면 그 키에 덮음 ·
만드는 층 = 부르는 층.
같은 내용(733-1 · `M02_Library_Same` 지문) SK 가 이 층에 있으면 새로 안 만들고 그것을 씀 — 이름 = 먼저 만든 것 ·
뒤 출처 = 그 SK `본뜬.또 [그 블록 본뜬 + 이름]`(`made` · `origin_of` 가 읽음) · 다른 출처가 쓰는 SK 는 내용을
안 바꿈(바뀌면 떼고 다시 찾음) · 위 층 같은 것 = `Maker.above`(알림만).
SK 쓰기 · 같은 내용 재사용(`Maker`)은 853-3 에서 지움(만드는 곳 0 — 단산 블록 SK = `M02_Sangeun_FromHopyo`) ·
남은 것 = 본뜬 읽기(`made` · `origin_of`) · 부름 표(`calls` · `callers`) · 이음.
SK 이음(729-2 · 일위대가 모두 고정 길 · `M02_Hopyo_Build.Builder` · `M02_Hopyo_Make.Lines` 가 부름 — 옛 `SkLink`) =
확인 안 한 단가산출 줄 → 이 층 · 같은 원본 그 블록 SK 참조(`sk_line` · 없으면 「확인 전」 고름 대기 · 단위 다름 ·
못옮김 남음 = 못 이음) · 확인한 로직 줄이 차이 SK 의 바탕 = 그 SK 참조(`kept`) · 남은 줄 = `left`.
@@ -19,16 +14,11 @@ from decimal import Decimal
from pathlib import Path
from typing import Any
from common_util.common_util_time import utc_now_text
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Hopyo_Elem as elem
from M02_MasterTemplete import M02_Hopyo_Fixed as hfix
from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store
from M02_MasterTemplete import M02_Hopyo_Units as units
from M02_MasterTemplete import M02_Labor_Doc as labor
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.M02_Hopyo_Kids import _same_mark
ORIGIN = "실무자료"
@@ -107,108 +97,6 @@ def callers(hp: dict[str, Any]) -> dict[int, list]:
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 ("갈래", "엑셀품", "못옮김", "근거") if k in plan}
keep |= {"놓음": plan["놓음"]} if plan.get("놓음") else {}
return {
"종류": "단가산출",
"이름": name,
"단위": unit,
"구분": ORIGIN,
"상세구분": str(hp.get("파일") or ""),
"본뜬": {"층": ORIGIN, "키": mark(hp["키"], no), "파일": hp.get("파일"), **sure, **keep},
"바탕": plan["바탕"],
"입력값": plan["입력값"],
**({"환산": plan["환산"]} if plan.get("환산") else {}),
"열린입력": [],
"고름": {},
**{k: plan[k] for k in ("자재표시", "덮개", "더한줄", "뺀줄")},
}
class Maker:
"""한 번 만들기 — 파일 · 이 층 SK 를 한 번 읽음(`source` = 파일 층 · 쓰기 = `store.root()`)."""
def __init__(self, source: Path, key: str, who: Any = None) -> None:
self.source, self.key, self.who = Path(source), key, who
self.hp = hopyo_store.read(source, key)
self.blocks, self.first = calls(self.hp)
self.here = refs.where(source)
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._units: units.Units | None = None
def units(self) -> units.Units:
if self._units is None: # 815-1 — 옛 별칭 장부 안 읽음(M01 별칭 칸은 Units 가 읽음)
self._units = units.Units()
return self._units
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 → 여기 — 늦게 읽음
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 write(self, no: int, plan: dict, have: str | None) -> str:
"""그 블록 SK 를 씀 → 키 — 다른 출처(또)가 쓰는 SK 의 내용은 안 바꿈(바뀌면 떼고 다시 찾음)."""
doc = _doc(self.first.get(no) or {}, self.blocks[no], no, self.hp, plan, self.sure)
root, mine = store.root(), doc["본뜬"]
self.above += [{"번": no, **r} for r in self.same.find_above(root, KIND, doc)]
if have:
raw, old, own, rest = self._read(have, mine)
owner = _same_mark(own, mine)
if self.same.finger(KIND, old) == self.same.finger(KIND, doc): # 내용 같음 = 출처만
self._put(
have, raw, old, *((mine, rest) if owner else (own, [*rest, self._entry(doc)]))
)
return have
if owner and not rest: # 혼자 쓰던 SK — 제자리 덮음
store.write(KIND, have, store.version_of(raw), {**doc, "키": have})
self.same.add(root, KIND, have, doc)
return have
head = {k: v for k, v in rest[0].items() if k != "이름"} if owner else own
self._put(have, raw, old, head, rest[1:] if owner else rest) # 떼어 냄
found = self.same.find_same(root, KIND, doc)
if found:
raw, old, own, rest = self._read(found[0], mine)
self._put(found[0], raw, old, own, [*rest, self._entry(doc)])
self.reused.append({"번": no, "키": found[0]})
return found[0]
key = refs.create(KIND, doc)["이름"]
self.same.add(root, KIND, key, doc)
return key
@staticmethod
def _entry(doc: dict) -> dict[str, Any]:
return {**doc["본뜬"], "이름": doc["이름"]}
@staticmethod
def _read(key: str, mine: dict) -> tuple[bytes, dict, dict, list]:
"""(바이트, 문서, 제 본뜬(또 뺌), 또 가운데 `mine` 뺀 것)."""
raw = (store.root() / KIND / f"{key}.json").read_bytes()
doc = json.loads(raw)
got = doc.get("본뜬") or {}
own = {k: v for k, v in got.items() if k != "또"}
rest = [x for x in got.get("또") or [] if isinstance(x, dict) and not _same_mark(x, mine)]
return raw, doc, own, rest
@staticmethod
def _put(key: str, raw: bytes, doc: dict, own: dict, also: list) -> None:
body = {**doc, "본뜬": {**own, "또": also} if also else own}
if body != doc:
store.write(KIND, key, store.version_of(raw), body)
# ── SK 이음(일위대가 모두 고정 길 · 옛 `M02_Hopyo_SkLink`) ───────────────────────────
def _num(value: Decimal) -> int | float:
value = value.normalize()
-224
View File
@@ -1,224 +0,0 @@
"""M02 실무 단가산출 블록 = 줄 판정 모음 · 단위 SK(PLAN 778-5 · D-3 · 요구 623 · 624).
모두 줄로만 — 바탕 기초 안 씀(기초 = 근거 꼬리표만) · 자동 없음(사용자가 확인한 블록만 만듦).
줄 판정 = `M02_Hopyo_Units` 잇기(상태 · 방법 · 단위) + 매개값(품 · 시간 · 수량 · 율) · 사용자 고름
`{차례: 단위 | {뺌: 까닭}}`(그 줄만 · 꼬리표 「내가 고름」) · 단가 = M01 지금 값으로 다시 셈(`우리금액`) ·
엑셀 금액과의 `차` = 참고(엑셀 = 과거 값 · 판정에 안 씀) · 셈 밖 줄 = 상태 「밖」(SK 에 안 들임).
블록 판정 = 줄 모음 — 모두 이어짐 = 「옮길 수 있음」 · 아니면 「고를 줄 n」 · 줄 0 = 「줄 없음」(고를줄 1 · 빈 SK 막음).
단위 SK 더한줄(바탕 없음 · 778-4 꼴) = 인력 `{요소 LB, 수량 품}` · 기계경비 로직 `{로직 GC, 입력값 {기계},
수량 시간 × 할증}` · 재료 `{요소 MT, 수량(손료율 든), 별도계상?}`(못 찾은 별도계상 = 0 원 고정 줄) ·
율 `{고정 {비율 {기준, 비목}}, 수량 = 율 %}`(줄 목록 = 그 행 줄 `add:#k`) · 하위 `{참조 SK · SC}` · 값 고정 줄.
근거 꼬리표 = 조항 색인(`Sangeun.Maker.basis` · 참고) · 고른 것(785-5 `M02_Hopyo_Make`)도 `adds` 를 부름 ·
기계경비 기초 차례(`_mach_logics`) = 옛 SkPatch 에서 옮김. 서버 단독 · 쓰기 = `M02_Hopyo_Sangeun`.
"""
from __future__ import annotations
from typing import Any
from M02_MasterTemplete import M02_Hopyo_Fixed as hfix
from M02_MasterTemplete import M02_Hopyo_UnitLine as unit_line
from M02_MasterTemplete import M02_Hopyo_Units as units
from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete.M02_Hopyo_Words import mtypes
GOOD = "옮길 수 있음"
EMPTY = "줄 없음"
OUT, DROP = "밖", "뺌"
UNIT = "단위" # 본뜬 갈래
MINE = "내가 고름"
WORD = {"L": "품", "X": "시간", "M": "수량", "R": "율", "S": "수량"}
PICKS = {"L": ("노임", "LB"), "X": ("기계", "EQ"), "M": ("자재", ("MT", "MO"))}
MACH_IN = "기계" # 기계경비 기초 기계 입력 칸
MACHINE = {"굴착기": "GC000267"} # 굴착기(무한궤도) 시간당 기계경비 · 그 밖 장비 = GC000268
MACHINE_ANY = "GC000268"
MACHINE_SET = {"GC000267", "GC000268", "GC000269", "GC000275"}
# (주연료, 조종원) 없는 기종 → 그 기계경비 기초(M01 로직이 부르는 것과 같음 · 778-2)
SOLO = {(False, False): "GC000273", (True, False): "GC000272", (False, True): "GC000276"}
class PickError(ValueError):
"""고름 틀림 — 부르는 쪽이 400."""
def _mach_logics(whole: Any, kinds: set, eq: dict | None = None) -> list[str]:
"""기계경비 기초 차례 — 갈래 첫 기초(굴착기 = 무한궤도) › 그 밖 · `eq` 가 있으면
연료 · 조종원 없는 기종 = 그 기초 하나 · 아니면 그 기계(또는 같은 이름 기계)를 고르기에 둔 기초가 앞."""
first = next((c for k, c in MACHINE.items() if k in kinds), MACHINE_ANY)
order = [first, *sorted(MACHINE_SET - {first})]
if not eq:
return order
import master_machine_crew as mcrew # 인력 줄 → 조종원 수(842-3)
has = mcrew.view(eq.get("값")) if isinstance(eq.get("값"), dict) else {}
if solo := SOLO.get((bool(has.get("주연료")), bool(has.get("조종원")))):
return [solo]
eqs = whole.numbers.get("EQ", {})
def takes(code: str) -> bool:
ins = whole.logic(code).get("입력") or []
opts = next((s.get("고르기") or [] for s in ins if s.get("이름") == MACH_IN), [])
same = any((eqs.get(o) or {}).get("이름") == eq.get("이름") for o in opts)
return eq.get("원문번호") in opts or same
hit = [c for c in order if takes(c)]
return hit + [c for c in order if c not in hit]
def _picked(one: dict[str, Any], pick: Any, us: units.Units) -> dict[str, Any]:
"""사용자 고름 → 이어짐 단위 — 노임 LB · 기계 EQ(→ 기계경비 로직) · 자재 MT · 율 기준 · 뺌."""
if not isinstance(pick, dict):
raise PickError("고름은 {노임|기계|자재: 키} · {기준, 비목?} · {뺌}")
if pick.get("뺌"):
return {"상태": DROP, "단위": None, "글": str(pick["뺌"]), "꼬리표": [MINE]}
kind = one["묶음"]
if kind == "R" and pick.get("기준") is not None:
unit = {"기준": pick["기준"], "비목": pick.get("비목") or units.rate_part(one.get("이름"))}
hfix.fixed.clean({"이름": "율", "비율": unit}, "고름", us.whole)
return {"상태": units.LINKED, "단위": unit, "꼬리표": [MINE]}
field, head = PICKS.get(kind, ("", "?"))
code = str(pick.get(field) or "")
if not field or not code.startswith(head):
shown = head if isinstance(head, str) else head[0]
raise PickError(f"{units.HOW.get(kind, kind)} 줄 · {field or '뺌'} 키({shown}…)로 고름")
try:
row = us.whole.get(code)
except Exception as e: # noqa: BLE001 — 없는 키
raise PickError(f"없는 키 「{code}」") from e
unit: dict[str, Any] = {field: code}
if kind == "X":
kinds = mtypes(f"{row.get('상세구분')} {row.get('이름')}")
unit["로직"] = _mach_logics(us.whole, kinds, row)[0]
unit |= {"할증": one["할증"]} if one.get("할증") else {}
if kind == "M" and (one.get("어떻게") == "별도" or pick.get("별도계상")):
unit["별도계상"] = True
return {"상태": units.LINKED, "단위": unit, "꼬리표": [MINE]}
def lines(block: dict[str, Any], us: units.Units, picks: dict | None = None) -> list[dict]:
"""블록 단위 줄 → 줄 판정 `[{차례, 행, 묶음, 이름, 규격, 매개값, 엑셀금액, 재현, 상태, 방법, 단위, 후보,
꼬리표, 글}]`(재현 = 엑셀 단가 × 매개값 ≈ 엑셀 금액 · D-6 띠) · `picks` = `{차례: 고름}`."""
out = []
for at, one in enumerate(block.get("항목") or []):
q = one.get("품")
row = {"차례": at, "행": one.get("행"), "묶음": one["묶음"], "이름": one.get("이름")}
row |= {"규격": one.get("규격") or "", "엑셀금액": one.get("금액"), "재현": one.get("재현")}
row["매개값"] = {WORD[one["묶음"]]: q} if one["묶음"] in WORD and q is not None else {}
if one.get("밖"):
out.append({**row, "상태": OUT, "방법": "", "단위": None, "후보": [], "꼬리표": []})
continue
got = us.line(one)
pick = (picks or {}).get(at)
if pick is not None:
got = {**got, "후보": [], "글": "", **_picked(one, pick, us)}
out.append({**row, **got})
return out
def verdict(rows: list[dict]) -> tuple[str, int]:
"""블록 판정 — (「옮길 수 있음」 | 「고를 줄 n」 | 「줄 없음」, n) · 줄 0 = 1(확인해도 못 만듦)."""
if not rows:
return EMPTY, 1
n = sum(1 for r in rows if r["상태"] not in (units.LINKED, OUT, DROP))
return (GOOD if not n else f"고를 줄 {n}"), n
def adds(block: dict, rows: list[dict], us: units.Units, ref_of: Any) -> tuple[list, dict]:
"""이어진 줄 → 단위 SK 더한줄 · `{차례: add 번}` — `ref_of(하위)` = 참조 칸 | None(빠짐)."""
out: list[dict] = []
at_of: dict[int, int] = {}
by_row = {r.get("행"): r["차례"] for r in rows}
items = block.get("항목") or []
for r in rows:
if r["상태"] != units.LINKED:
continue
one, unit = items[r["차례"]], r["단위"] or {}
name = " ".join(str(one.get("이름") or "").split()) or "이름 없음"
q = float(one.get("품") or 0)
kind = one["묶음"]
if kind == "L":
add = {"종류": "인력", "요소": unit["노임"], "이름": name, "단위": "인", "수량": q}
elif kind == "X":
eq = us.whole.get(unit["기계"]) or {}
given = {MACH_IN: eq.get("원문번호")}
q *= float(unit.get("할증") or 1)
add = {
"종류": "로직",
"로직": unit["로직"],
"입력값": given,
"이름": name,
"단위": "시간",
}
add["수량"] = q
elif kind == "M" and unit.get("자재"):
add = {"종류": "재료", "요소": unit["자재"], "이름": name, "수량": q}
add |= {"별도계상": True} if unit.get("별도계상") else {}
elif kind == "R":
basis = unit["기준"]
if isinstance(basis, dict): # 줄 목록 = 그 행 줄
basis = [f"add:#{at_of[k]}" for h in basis.get("행") or []
if (k := by_row.get(h)) in at_of] # fmt: skip
fx = {
"이름": name,
"단가": {},
"이음": {},
"비율": {"기준": basis, "비목": unit["비목"]},
}
add = {"고정": fx, "이름": name, "단위": "%", "수량": round(q * 100, 9)}
elif kind == "S":
ref = ref_of(unit["하위"])
if ref is None:
continue
add = {"참조": ref, "이름": name, "수량": q or 1}
else: # 값 · 못 찾은 별도계상 = 고정 금액 줄
money = unit.get("값", 0)
fx = {
"이름": name,
"단가": {k: float(v) for k, v in hfix._parts({"계": money}).items()},
}
add = {"고정": {**fx, "이음": {}}, "이름": name, "수량": q if kind == "M" else 1}
at_of[r["차례"]] = len(out)
out.append(add)
return out, at_of
def priced(rows: list[dict], made: list[dict], at_of: dict, unit: str, whole: Any) -> Any:
"""M01 지금 값으로 다시 셈 → (저장 꼴 더한줄, 블록 1 단위 계 | None) · 줄 `우리금액` · `차`(참고) ·
셈 못 함 = 금액 칸 비움(판정은 그대로)."""
doc = {"키": "SK-000000", "이름": "판정", "단위": unit or "식", "바탕": None, "더한줄": made}
try:
doc = sd.clean(doc, None, whole) # 저장 꼴(같은 내용 SK 지문이 저장본과 같게)
got = calc.run(doc, whole)
except Exception: # noqa: BLE001
return made, None
money = {x.get("cid"): x.get("금액") for x in got.get("줄") or []}
for r in rows:
k = at_of.get(r["차례"])
mine = money.get(f"add:#{k}") if k is not None else None
r["우리금액"] = float(mine) if mine is not None else None
theirs = r.get("엑셀금액")
r["차"] = round(r["우리금액"] - float(theirs), 4) if mine is not None and theirs else None
total = (got.get("1단위") or {}).get("계")
return doc["더한줄"], float(total) if total is not None else None
def judge(
block: dict, us: units.Units, ref_of: Any, picks: dict | None = None, unit: str = ""
) -> dict[str, Any]:
"""블록 하나 → `{판정, 고를줄, 우리금액, 엑셀금액, 줄 [...], 더한줄, 담음}`(더한줄 = 단위 SK 몸 ·
담음 = 더한줄에 든 줄 차례 · 이어졌는데 빠진 줄 = 하위 SK · SC 아직 없음)."""
rows = lines(block, us, picks)
word, n = verdict(rows)
made, at_of = adds(block, rows, us, ref_of)
made, total = priced(rows, made, at_of, unit, us.whole)
head = {"판정": word, "고를줄": n, "우리금액": total}
head["엑셀금액"] = unit_line.money(block.get("금액"))
return {**head, "줄": rows, "더한줄": made, "담음": sorted(at_of)}
def plan(got: dict[str, Any], basis: dict | None) -> dict[str, Any]:
"""판정 → `Sangeun.Maker.write` 꼴 — 바탕 없음 · 덮개 · 뺀줄 없음 · 근거 꼬리표."""
keep = {"갈래": UNIT, "바탕": None, "입력값": {}, "덮개": {}, "자재표시": {}, "뺀줄": []}
out = {**keep, "더한줄": got["더한줄"], "못옮김": [], "놓음": []}
return out | ({"근거": basis} if basis else {})
-25
View File
@@ -276,28 +276,3 @@ class Units:
if got is None:
return {"상태": NONE, "단위": None, "글": "금액 없음"}
return {"상태": LINKED, "방법": HOW["E"], "단위": {"값": float(got)}}
def hopyo_unit(line: dict[str, Any]) -> dict[str, Any]:
"""일위대가 줄(`UnitLine.check_hopyo` 투영 뒤) → 단위 줄 꼴 — 이름 · 규격 · 단위 · 품 = 수량 · 별도."""
one = {k: line.get(k) for k in ("묶음", "이름", "규격", "단위", "할증")}
one.update(품=line.get("수량"), 금액=unit_line.money(line.get("금액")), 직종=None)
if line.get("갈래") == "별도계상":
one["어떻게"] = "별도"
if one["묶음"] == "R":
base = str(line.get("기준") or "노무비")
one.update(기준=base, 기준꼴={"주재료비": "자재"}.get(base, base))
one["품"] = float(line["수량"]) / 100 if line.get("수량") is not None else None
ref = line.get("참조") or {}
if one["묶음"] == "S" and ref.get("번"):
one["하위"] = {"종류": ref.get("종류"), "번": ref.get("번")}
return one
def summary(rows: list[dict[str, Any]]) -> dict[str, dict[str, int]]:
"""묶음별 `{묶음: {이어짐, 고를 것, 못 이음}}` — 줄 연결 표."""
out: dict[str, dict[str, int]] = {}
for kind, state in rows:
one = out.setdefault(kind, dict.fromkeys((LINKED, PICK, NONE), 0))
one[state] += 1
return out
+1 -56
View File
@@ -2,22 +2,18 @@
409 detail = `{같은것: [{키, 이름, 층, 주인}], 까닭}` → 다시 보냄 몸 `새로: true` = 그래도 새로 ·
`씀: <키>` = 그것을 씀(새로 안 만듦 · 그 키를 돌려줌 · 같은 내용이 아니면 다시 409).
지문 = `M02_Library_Same`(일위대가 SC · 단가산출 SK) · 구조물 조합(labor) = 같은 꼴 + 줄 수량 넣음.
지문 = `M02_Library_Same`(일위대가 SC · 단가산출 SK).
빈 문서(지문 없음) = 안 물음 · 같은 층 [복사] · 붙여넣기 = 안 물음(복사가 뜻).
부르는 쪽 = 지금 층(`store.at` 안).
"""
from __future__ import annotations
import json
from pathlib import Path
from typing import Any
from common_util.common_util_derived_store import derived_key
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_MasterTemplete_Tree as tree
WHY = "같은 층에 같은 내용 문서가 있음 — 그것을 씀 · 그래도 새로"
@@ -66,57 +62,6 @@ def ask(
return _pick(found, [{**r, "층": at[0], "주인": at[1]} for r in rows], new, use)
def labor_finger(doc: Any) -> str | None:
"""구조물 조합 일위대가 지문 — 담은로직 · 자재 · 단위 · 규격(줄 수량 넣음 · 차례 무시)."""
if not isinstance(doc, dict):
return None
s = same.Same()
mats = [same.norm(m) for m in doc.get("자재") or []]
body = {
"단위": same.unit(doc.get("단위")),
"담은로직": same._sorted([s._line(x, (), True) for x in doc.get("담은로직") or []]),
"자재": same._sorted(mats),
"규격": same.norm(doc.get("규격")),
}
body = {k: v for k, v in body.items() if v not in same.EMPTY}
if not body.get("담은로직") and not body.get("자재"):
return None
return f"SU:{derived_key(body)}"
def ask_item(
folder: Path, doc: dict[str, Any], new: bool = False, use: str | None = None
) -> dict[str, Any] | None:
"""구조물 조합 항목(실무 호표 [구조물 조합으로]) — 씀 = `{key, 열, 이름}` | None(새로) · 409."""
from M02_MasterTemplete import M02_Labor_Doc as labor
try:
doc = {**labor.clean(doc), "규격": doc.get("규격")} # 저장될 꼴로 견줌
except store.StoreError:
pass
want = labor_finger(doc)
if not want:
return None
at = refs.where(folder)
with store.at(folder):
table = store.read("table", store.STRUCTURE_TABLE)["문서"]
cols = {c["id"]: c for c in table.get("열") or [] if tree.is_item(c)}
found, rows = [], []
for key, col in cols.items():
try:
have = json.loads((Path(folder) / "labor" / f"{key}.json").read_bytes())
except (OSError, ValueError):
continue
if labor_finger(have) == want:
name = " / ".join(tree.path_of(col))
found.append(key)
rows.append({"키": key, "이름": name, "층": at[0], "주인": at[1]})
got = _pick(found, rows, new, use)
if got is None:
return None
return {"key": got, "열": got, "이름": rows[found.index(got)]["이름"], "씀": True}
def create(kind: str, doc: dict[str, Any], new: bool = False, use: str | None = None) -> dict:
"""[새로 만들기](733-2) — 같은 것 물음 뒤 `refs.create` · 씀 = `{이름: 그 키, 씀: true}`."""
got = ask(kind, doc, new, use)
-59
View File
@@ -1,59 +0,0 @@
"""불러오기 [단가산출 만들기] 같은 내용 SK 씀(PLAN 733-1b · 요구서_572 3장 2).
북부청 임도(실물)를 임시 층에 → 같은 파일 안 같은 내용 SK 한 벌 · 바이트만 다른 사본 다시 = 새 SK 0 ·
뒤 출처 = `본뜬.또` · 다시 = 그대로 · 위 층(회사) 같은 것 = `위층같음` 알림 ·
출처마다 못옮김 · 다른 출처가 쓰는 SK 내용은 안 바꿈(떼어 냄 · 넘겨줌).
"""
import io
import json
import zipfile
from M02_MasterTemplete import M02_Hopyo_Sangeun as sangeun
from M02_MasterTemplete import M02_Library_Same as same
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
from resources.tester.test_m02_hopyo_excel import NORTH, URL, _post, client # noqa: F401
def _sks(folder) -> dict[str, dict]:
paths = sorted((folder / "sangeun").glob("SK-*.json"))
return {p.stem: json.loads(p.read_bytes()) for p in paths}
def _maker(hp: str) -> sangeun.Maker:
"""블록 하나짜리 만들기(파일 · 맞춤셈 없이) — 쓰기 규칙만 봄."""
m = object.__new__(sangeun.Maker)
m.first, m.blocks = {1: {"이름": "줄", "단위": "㎥"}}, {1: {"이름": "블록"}}
m.hp, m.sure = {"키": hp, "파일": f"{hp}.xls"}, {"원본": ["personal", "7/42"]}
m.same, m.reused, m.above = same.Same(), [], []
return m
def _plan(code: str, lost: list) -> dict:
keep = {"갈래": "기초", "엑셀품": {}, "못옮김": lost, "바탕": {"로직": code}, "입력값": {}}
return {**keep, "자재표시": {}, "덮개": {}, "더한줄": [], "뺀줄": []}
def test_같은내용_SK_출처마다_못옮김_떼어냄_넘겨줌(client):
folder, at = layers.personal_dir(7, 42), ("personal", "7/42")
one, two = _maker("HP-000001"), _maker("HP-000002")
with store.at(folder):
key = one.write(1, _plan("GF000113", []), None)
assert two.write(1, _plan("GF000113", [{"id": "x"}]), None) == key # 같은 것 씀
assert two.reused == [{"번": 1, "키": key}]
doc = _sks(folder)[key]
assert sangeun.origin_of(doc, "HP-000002 단산1", at)["못옮김"] == [{"id": "x"}]
assert sangeun.origin_of(doc, "HP-000001 단산1", at)["못옮김"] == []
assert sangeun.made(folder, "HP-000002", at) == {"HP-000002 단산1": key}
# 뒤 출처가 바탕을 바꿈 = 떼어 냄 · 남의 SK 내용 그대로
moved = _maker("HP-000002").write(1, _plan("GF000114", []), key)
assert moved != key and "또" not in _sks(folder)[key]["본뜬"]
assert _sks(folder)[key]["바탕"]["로직"] == "GF000113"
# 앞 출처가 바탕을 바꿈 = 뒤 출처에게 넘겨줌
assert _maker("HP-000003").write(1, _plan("GF000113", []), None) == key
back = _maker("HP-000001").write(1, _plan("GF000114", []), key)
assert back == moved # 바꾼 내용 = 이미 있는 같은 것
left = _sks(folder)[key]
assert left["바탕"]["로직"] == "GF000113" and left["본뜬"]["키"] == "HP-000003 단산1"
assert "또" not in left["본뜬"] and len(_sks(folder)) == 2
-103
View File
@@ -280,109 +280,6 @@ def test_B09_붙인_줄_거울_정리_수요():
assert pct["amounts"]["expense"] > 0 and py["daega_orphans"] == []
# ── 704-4 뒷부분 — [구조물 조합으로] · 규격 묶음 ─────────────────────────────────
def _upload(client, tag):
from resources.tester.test_m02_hopyo_excel import _post
path = DOCS / FILES[tag][0]
res = _post(client, data=path.read_bytes(), name=path.name)
assert res.status_code == 200, res.text
return res.json()["키"]
def _item_doc(column):
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
with store.at(layers.personal_dir(7, 42)):
table = store.read("table", store.STRUCTURE_TABLE)["문서"]
col = next(c for c in table["열"] if c.get("id") == column)
return store.read("labor", column)["문서"], col
def _total(doc, col=None):
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Spec as spec
doc = {**doc, "규격": {**doc["규격"], "기본": col}} if col else doc # 셈 = 기본 열
return labor.calc(labor.clean(spec.at(doc, col)), {})["반영합"]["계"]
def layers_dir():
from M02_MasterTemplete import M02_Template_Layers as layers
return layers.personal_dir(7, 42)
def test_구조물_조합으로_규격_묶음_울진_돌기슭막이(client):
before = master_hash()
key = _upload(client, "대흥")
sib = client.get(f"/api/m02/layers/personal/hopyo/{key}/17/siblings").json()
assert sib["이름"] == "H" and [(r["번"], r["열"]) for r in sib["묶음"]] == [
(17, "1.5"), (24, "2.0"), (25, "2.5")
] # fmt: skip
body = {"층": "personal", "키": key, "번": 17, "묶음": [24, 25]}
res = client.post("/api/m02/layers/personal/hopyo-item", json=body)
assert res.status_code == 200, res.text
got = res.json()
assert got["열수"] == 3 and got["이름"].endswith("돌기슭막이(찰쌓기,기초무,구입)")
doc, col = _item_doc(got["열"])
assert col["경로"] == ["실무자료", "돌기슭막이(찰쌓기,기초무,구입)"] and doc["규격"]["열"] == [
"1.5",
"2.0",
"2.5",
]
assert doc["규격"]["기본"] == "1.5" and all("고정" in x for x in doc["담은로직"])
excel = {
h["번"]: h["금액"]["계"]
for h in client.get(f"/api/m02/layers/personal/hopyo/{key}").json()["호표"]
if h["번"] in (17, 24, 25)
}
for no, c in ((17, "1.5"), (24, "2.0"), (25, "2.5")):
assert (
abs(_total(doc, c) - excel[no]) <= excel[no] * 1e-4
) # 열마다 = 그 호표 엑셀 합계(끝수 차)
one = client.post("/api/m02/layers/personal/hopyo-item", json={**body, "묶음": []}).json()
single, _ = _item_doc(one["열"])
assert not single.get("규격") and one["이름"].endswith("H=1.5 L3=45cm")
bad = client.post("/api/m02/layers/personal/hopyo-item", json={**body, "묶음": [3]})
assert bad.status_code == 400 # 줄 구성 다른 호표
precombo = layers_dir() / "precombo"
assert not list(precombo.glob("SC-*.json")) # 사전조합 문서 안 만듦
assert master_hash() == before
def test_구조물_조합으로_경로_층_무시_늘_개인(client): # 837-1 · 요구 855 — 옛 「남의 층 403」 갈음
key = _upload(client, "대흥")
body = {"층": "personal", "키": key, "번": 17}
assert client.post("/api/m02/layers/company/hopyo-item", json=body).status_code == 200
assert list((layers_dir() / "labor").glob("*.json")) # 쓴 곳 = 개인 층(`layers_dir`)
def test_구조물_조합으로_같은_내용_409_씀_새로(client):
"""733-2 — 이 층 같은 내용 항목 = 409 `{같은것}` → `씀` = 새 항목 0 · `새로` = 새 항목 1."""
key = _upload(client, "대흥")
url, body = "/api/m02/layers/personal/hopyo-item", {"층": "personal", "키": key, "번": 17}
first = client.post(url, json=body).json()
count = len(list((layers_dir() / "labor").glob("*.json")))
res = client.post(url, json=body)
assert res.status_code == 409 and res.json()["detail"]["같은것"][0]["키"] == first["열"]
used = client.post(url, json={**body, "씀": first["열"]}).json()
assert used["열"] == first["열"] and used["씀"] is True
assert len(list((layers_dir() / "labor").glob("*.json"))) == count
made = client.post(url, json={**body, "새로": True}).json()
assert made["열"] != first["열"]
assert len(list((layers_dir() / "labor").glob("*.json"))) == count + 1
def test_규격_열_이름():
from M02_MasterTemplete import M02_Hopyo_Item as item
assert item.columns(["H=1.5 L3=45cm", "H=2.0 L3=45cm"]) == ("H", ["1.5", "2.0"])
assert item.columns(["일반형", "ㄷ형"]) == ("규격", ["일반형", "ㄷ형"])
assert item.columns(["D800", "D1000"]) == ("D", ["800", "1000"])
def test_줄만_첫_줄_수량_없음_별도계산은_줄():
rows = _block(_rows("거창"), 2)[
1:
+1 -2
View File
@@ -3,8 +3,7 @@
같은 층 같은 내용 = 409 `{같은것: [{키, 이름, 층, 주인}], 까닭}` →
`씀` = 새 문서 0 · `새로` = 새 문서 1.
길 = 새로 만들기 · [단가산출로 저장] from-line · 공유 요청 승인 · 복사 딸림 재사용(carry) ·
빈 문서 · 같은 층 복사 = 안 물음. B09 내 자료집 = `test_703_b09_daega_copy` · 구조물 조합으로 =
`test_705_2_hopyo_paste`.
빈 문서 · 같은 층 복사 = 안 물음. B09 내 자료집 = `test_703_b09_daega_copy`.
"""
from __future__ import annotations
+6 -30
View File
@@ -1,27 +1,18 @@
"""778-5 줄 잇기 한 벌 · 블록 = 줄 판정 모음 · 단위 SK(D-2 · D-3 · 요구 622 · 623 · 624).
"""778-5 줄 잇기 한 벌 · 블록 = 줄 판정 모음(D-2 · D-3 · 요구 622 · 623 · 624).
- 줄 잇기(`M02_Hopyo_Units`) — 작업반장 = 건설업 · 숫자 규격 치수 차례 · 구분자 무관 · 글자 규격 = 고를 것 ·
손료율 = 자재 줄 방법 · 우리에 없는 율 항목(설치비 · 제경비) = 율 줄 · 여덟 파일 묶음별 수 굳힘
- 단위 SK(`M02_Hopyo_SkUnit` · `M02_Hopyo_Sangeun`) — 확인 안 한 블록 안 만듦 · 확인 블록 = 바탕 없는 SK +
근거 꼬리표 · 고를 줄 남으면 못만듦 · 고르면 만듦 · 다시 올려도 같은 SK 재사용 · 일위대가 = 확인 전 못 이음
층 = 임시 폴더 · M01 · 마스터 읽기만.
"""
from __future__ import annotations
import json
import pytest
from M02_MasterTemplete import M02_Hopyo_Material as hmat
from M02_MasterTemplete import M02_Hopyo_Sangeun as sangeun
from M02_MasterTemplete import M02_Hopyo_SkUnit as skunit
from M02_MasterTemplete import M02_Hopyo_Units as units
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from resources.tester import helper_m02_hopyo_golden as golden
from resources.tester.test_m02_hopyo_excel import URL, _post, client, master_hash # noqa: F401
# 여덟 파일 불리는 블록 줄 연결 표(778-5 D-2 · 바닥값 — 이어짐은 이 수 이상 · 고를 것 · 못 이음은 이 수 이하 ·
# 마스터 · 기계 자료가 좋아지면 바닥이 오름 · 줄 수는 엑셀 몫이라 그대로)
@@ -74,21 +65,6 @@ def test_손료율_자재_줄_율_항목_율_줄(us):
assert us.line(rest)["단위"] == {"기준": "노무비", "비목": "경비"}
lost = us.line({"묶음": "R", "이름": "기구손료(노무비의 9%)", "기준": "노무비", "품": 0.09})
assert lost["상태"] == units.PICK and lost["후보"] == [{"기준": "노무비", "비목": "경비"}]
# 단위 SK 셈 — 설치비 = 재료 줄 × 5 % · 제경비 = 노무비 × 60 %
block = {"항목": [
{"묶음": "L", "이름": "보통인부", "직종": "보통인부", "품": 0.5, "행": 1},
{"묶음": "M", "이름": "유로폼패널", "규격": "600×1200", "단위": "매", "품": 2, "행": 2},
{**setup, "행": 3}, {**rest, "행": 4},
]} # fmt: skip
got = skunit.judge(block, us, lambda sub: None, None, "㎡")
assert got["판정"] == skunit.GOOD and [r["상태"] for r in got["줄"]] == [units.LINKED] * 4
labor_, mat = (got["줄"][0]["우리금액"], got["줄"][1]["우리금액"])
assert got["줄"][2]["우리금액"] == pytest.approx(mat * 0.05, abs=0.1)
assert got["줄"][3]["우리금액"] == pytest.approx(labor_ * 0.6, abs=0.1)
doc = {"키": "SK-000001", "이름": "t", "단위": "㎡", "바탕": None, "더한줄": got["더한줄"]}
whole = us.whole
ran = labor._json(calc.run(sd.clean(doc, None, whole), whole))
assert ran["1단위"]["계"] == pytest.approx(got["우리금액"])
def test_글_붙은_규격_수_배율_같이_씀_같은_수는_한_번(us):
@@ -118,7 +94,11 @@ def table(us):
rows += got
blocks += 1
full += all(s == units.LINKED for _, s in got)
return units.summary(rows), full, blocks
out: dict[str, dict[str, int]] = {}
for kind, state in rows:
one = out.setdefault(kind, dict.fromkeys((units.LINKED, units.PICK, units.NONE), 0))
one[state] += 1
return out, full, blocks
def _floor(got: dict, kind: str) -> None:
@@ -140,7 +120,3 @@ def test_여덟_파일_자재_줄_연결_표(table):
got, full, _ = table
_floor(got, "M")
assert full >= ALL_LINKED
def _sks(folder) -> dict[str, dict]:
return {p.stem: json.loads(p.read_bytes()) for p in (folder / "sangeun").glob("SK-*.json")}
+6 -27
View File
@@ -1,44 +1,23 @@
"""780-1 일위대가 밖 단가산출도 잇기(요구 627) — 판정 · 확인 = 모든 블록 · `부름 [호표 번]`([] = 일위대가 밖) ·
밖 블록 확인 = 단위 SK(이름 · 단위 = 블록 것 · 근거 없음) · 빈 블록(줄 0) = 「줄 없음」 확인해도 못만듦 ·
하위 밖 블록(울진소광 492 → 83) = 확인 목록에 함께 넣으면 하위 먼저 만듦 · 칠 재료 `줄` · `어긋남` 모든 블록 ·
여덟 파일 블록 459 판정 오류 0(빈 블록은 모두 밖 = 일위대가 안 판정 그대로). 층 = 임시 폴더 · 마스터 읽기만.
"""780-1 일위대가 밖 단가산출(요구 627) — 블록 · 부름 표 = 모든 블록 · `부름 [호표 번]`([] = 일위대가 밖) ·
여덟 파일 블록 수 · 부름 첫 줄 블록 수 굳힘(옛 단위 SK 판정 `M02_Hopyo_SkUnit` 은 853-3 에서 지움).
"""
from __future__ import annotations
import json
from M02_MasterTemplete import M02_Hopyo_Sangeun as sangeun
from M02_MasterTemplete import M02_Hopyo_SkUnit as skunit
from M02_MasterTemplete import M02_Hopyo_Units as units
from M02_MasterTemplete import M02_Template_Layers as layers
from resources.tester import helper_m02_hopyo_golden as golden
from resources.tester.test_m02_hopyo_excel import URL, _post, client, master_hash # noqa: F401
BLOCKS = {"북부청임도": (95, 49), "북부청사방": (67, 45), "거창": (61, 13), "봉화": (65, 31)}
BLOCKS |= {"동부청영월": (69, 35), "울진대흥": (47, 14), "영덕계류": (15, 2), "울진소광": (40, 17)}
def _sks(folder) -> dict[str, dict]:
return {p.stem: json.loads(p.read_bytes()) for p in (folder / "sangeun").glob("SK-*.json")}
def _ready(client, tag="북부청임도"):
path = golden.FILES[tag]
key = _post(client, data=path.read_bytes(), name=path.name).json()["키"]
folder = layers.personal_dir(7, 42)
return folder, key, f"{URL.format('personal')}/{key}/sangeun"
def test_여덟_파일_모든_블록_판정():
us = units.Units()
def test_여덟_파일_모든_블록_부름():
for tag, (n, called) in BLOCKS.items():
hp = golden.read(tag)
blocks, first = sangeun.calls(hp)
call = sangeun.callers(hp)
assert (len(blocks), len(first)) == (n, called), tag
assert {b for b in blocks if call.get(b)} == set(first), tag # 부름 = 첫 줄과 같은 블록
for no, block in blocks.items():
got = skunit.judge(block, us, lambda sub: None, None, str(block.get("단위") or ""))
if not block.get("항목"): # 빈 블록 = 모두 밖
assert no not in first and got["판정"] == skunit.EMPTY, (tag, no)
assert not {no for no, b in blocks.items() if not b.get("항목")} & set(first), (
tag
) # 빈 블록 = 밖