diff --git a/M02_MasterTemplete/M02_Hopyo_Elem.py b/M02_MasterTemplete/M02_Hopyo_Elem.py index df8d48226..2dddaa79d 100644 --- a/M02_MasterTemplete/M02_Hopyo_Elem.py +++ b/M02_MasterTemplete/M02_Hopyo_Elem.py @@ -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) diff --git a/M02_MasterTemplete/M02_Hopyo_Item.py b/M02_MasterTemplete/M02_Hopyo_Item.py deleted file mode 100644 index c21b58b48..000000000 --- a/M02_MasterTemplete/M02_Hopyo_Item.py +++ /dev/null @@ -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["빠진줄"]} diff --git a/M02_MasterTemplete/M02_Hopyo_Kids.py b/M02_MasterTemplete/M02_Hopyo_Kids.py index 717252afc..b07d15217 100644 --- a/M02_MasterTemplete/M02_Hopyo_Kids.py +++ b/M02_MasterTemplete/M02_Hopyo_Kids.py @@ -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 diff --git a/M02_MasterTemplete/M02_Hopyo_Router.py b/M02_MasterTemplete/M02_Hopyo_Router.py index 9ff588aea..0ac096fc2 100644 --- a/M02_MasterTemplete/M02_Hopyo_Router.py +++ b/M02_MasterTemplete/M02_Hopyo_Router.py @@ -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, diff --git a/M02_MasterTemplete/M02_Hopyo_Sangeun.py b/M02_MasterTemplete/M02_Hopyo_Sangeun.py index 481ba6f28..87518e106 100644 --- a/M02_MasterTemplete/M02_Hopyo_Sangeun.py +++ b/M02_MasterTemplete/M02_Hopyo_Sangeun.py @@ -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() diff --git a/M02_MasterTemplete/M02_Hopyo_SkUnit.py b/M02_MasterTemplete/M02_Hopyo_SkUnit.py deleted file mode 100644 index e9332dffd..000000000 --- a/M02_MasterTemplete/M02_Hopyo_SkUnit.py +++ /dev/null @@ -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 {}) diff --git a/M02_MasterTemplete/M02_Hopyo_Units.py b/M02_MasterTemplete/M02_Hopyo_Units.py index 9da3a6d31..9afeee449 100644 --- a/M02_MasterTemplete/M02_Hopyo_Units.py +++ b/M02_MasterTemplete/M02_Hopyo_Units.py @@ -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 diff --git a/M02_MasterTemplete/M02_Library_Ask.py b/M02_MasterTemplete/M02_Library_Ask.py index ff3796196..480ce3a3a 100644 --- a/M02_MasterTemplete/M02_Library_Ask.py +++ b/M02_MasterTemplete/M02_Library_Ask.py @@ -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) diff --git a/resources/tester/test_572_hopyo_same.py b/resources/tester/test_572_hopyo_same.py deleted file mode 100644 index 886d875bb..000000000 --- a/resources/tester/test_572_hopyo_same.py +++ /dev/null @@ -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 diff --git a/resources/tester/test_705_2_hopyo_paste.py b/resources/tester/test_705_2_hopyo_paste.py index 257ad1276..4ebc682de 100644 --- a/resources/tester/test_705_2_hopyo_paste.py +++ b/resources/tester/test_705_2_hopyo_paste.py @@ -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: diff --git a/resources/tester/test_733_2_library_ask.py b/resources/tester/test_733_2_library_ask.py index 99b9d7663..93d8c9a1a 100644 --- a/resources/tester/test_733_2_library_ask.py +++ b/resources/tester/test_733_2_library_ask.py @@ -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 diff --git a/resources/tester/test_778_5_hopyo_units.py b/resources/tester/test_778_5_hopyo_units.py index 99831f348..880b286be 100644 --- a/resources/tester/test_778_5_hopyo_units.py +++ b/resources/tester/test_778_5_hopyo_units.py @@ -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")} diff --git a/resources/tester/test_780_1_sangeun_outside.py b/resources/tester/test_780_1_sangeun_outside.py index bd2678557..32039ab69 100644 --- a/resources/tester/test_780_1_sangeun_outside.py +++ b/resources/tester/test_780_1_sangeun_outside.py @@ -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 + ) # 빈 블록 = 밖