Merge branch 'sub_laptop_4' of C:/Aislo_wt/sub_laptop_4 into main_laptop_1
This commit is contained in:
@@ -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)
|
||||
|
||||
@@ -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["빠진줄"]}
|
||||
@@ -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
|
||||
|
||||
@@ -1,19 +1,9 @@
|
||||
"""M02 일위대가 실무자료 별칭 장부(PLAN 338-3 · 설계 3-5) — 층 `실무자료/맞춤.json` 을 키움.
|
||||
"""M02 일위대가 짝 검사 · 불러오기 열쇠(PLAN 338-3 · 739-1 · 815-2) — `M02_Hopyo_Build` 가 부름.
|
||||
|
||||
줄 = {열쇠(품명|규격|단위 정규화): {원래 {품명, 규격, 단위},
|
||||
갈래 「짝」 · 「우리에 없음」 · 「안 씀」, 짝 [{로직|자재, 입력값, 배, 몫}
|
||||
| 고른 것 꼴 {갈래, 키?, 입력값, 배, 몫, 이름?, 단위?, 비목?, 기준?, 별도계상?}(785-3)],
|
||||
누가, 때, 처음파일, 엑셀조항, 판}} ·
|
||||
직접 줄 호표 통째 = 열쇠 「호표|품명|규격|단위」.
|
||||
옛 줄 {로직|자재|빼기, 입력값, 환산, 확정} = 읽을 때 새 꼴로 바꿔 읽음(빼기 = 「안 씀」 ·
|
||||
파일은 다음 쓰기 때 새 꼴).
|
||||
중앙 관리(739-1) — 자동 짝 = 마스터 층(M01 별칭 장부 승인) · 이 불러오기에서 이은 짝
|
||||
(줄 `불러오기` = `doc_id`)만 · 회사 · 개인 층 짝 = 「내 제안」(`제안` True · 자동 아님 ·
|
||||
후보 맨 위 · M01 승인 대기).
|
||||
읽는 차례 = 자동 정확 열쇠(같은 층 → 위 층) → 제안 정확 열쇠 → 품명|단위 느슨 열쇠(`규격다름`).
|
||||
⚠ 815-2 — 장부 화면 · M01 승인 · 불러오기 확인 때 쓰기는 걷음(별칭 = M01 요소 「별칭」 칸) ·
|
||||
남은 것 = 짝 검사 · 열쇠 도우미 · 요소 잇기의 옛 장부 읽기(sub3 815-1 이 뗌) · 쓰기 = 그 층만 ·
|
||||
짝은 서버가 다시 검사(돈 로직 · 그 로직 입력 이름 · M01 자재품목 · 배 0 넘음 · 몫 (0, 1]).
|
||||
남은 것 = 짝 재검사(`check_pair` · 고른 것 꼴 · 돈 로직 · 그 로직 입력 이름 · M01 자재품목 · 배 0 넘음 ·
|
||||
몫 (0, 1]) · `times_of` · `KINDS` · 불러오기 하나 열쇠 `doc_id`.
|
||||
옛 별칭 장부(층 `실무자료/맞춤.json` 읽기 · 쓰기 · 찾기)는 815-2 에 화면 · 길을 걷고 853-3 에서 지움
|
||||
(별칭 = M01 요소 「별칭」 칸).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -22,87 +12,12 @@ 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_Store as hopyo_store
|
||||
from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
|
||||
mm = m01.cm.mf.mp.mm
|
||||
KINDS = ("짝", "우리에 없음", "안 씀")
|
||||
HOPYO = "호표|"
|
||||
|
||||
|
||||
# ── 열쇠 ─────────────────────────────────────────────────────────────
|
||||
def key(line: dict[str, Any]) -> str:
|
||||
"""줄 열쇠 = 품명 | 규격 | 단위(정규화 · `M02_Hopyo_Match.line_key` 와 같음)."""
|
||||
return "|".join(
|
||||
(
|
||||
mm.plain(line.get("이름")),
|
||||
mm.plain_spec(line.get("규격")),
|
||||
mm.plain_unit(line.get("단위")),
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def hopyo_key(hopyo: dict[str, Any]) -> str:
|
||||
"""직접 줄 호표 통째 열쇠 — 「호표|품명|규격|단위」."""
|
||||
return HOPYO + key(hopyo)
|
||||
|
||||
|
||||
def _loose(full: str) -> str:
|
||||
"""느슨 열쇠 = 품명 | 단위(규격 뺌)."""
|
||||
head, _, rest = full.rpartition("|")
|
||||
return f"{head.rsplit('|', 1)[0]}|{rest}"
|
||||
|
||||
|
||||
# ── 옛 꼴 → 새 꼴 ─────────────────────────────────────────────────────
|
||||
def _plain_of(full: str) -> dict[str, str]:
|
||||
name, spec, unit = full.removeprefix(HOPYO).split("|")
|
||||
return {"품명": name, "규격": spec, "단위": unit}
|
||||
|
||||
|
||||
def upgrade(full: str, raw: Any) -> dict[str, Any] | None:
|
||||
"""장부 한 줄을 새 꼴로 — 옛 기억 줄 · 새 꼴 · 모르는 꼴(None)."""
|
||||
if not isinstance(raw, dict):
|
||||
return None
|
||||
if raw.get("갈래") in KINDS:
|
||||
return {"원래": _plain_of(full), "짝": [], **raw}
|
||||
head = {"원래": _plain_of(full), "때": raw.get("확정"), "누가": None, "처음파일": None}
|
||||
if raw.get("빼기"):
|
||||
return {**head, "갈래": "안 씀", "짝": []}
|
||||
pair = {"로직": raw["로직"]} if raw.get("로직") else {"자재": raw.get("자재")}
|
||||
if not any(pair.values()):
|
||||
return None
|
||||
pair.update(입력값=raw.get("입력값") or {}, 배=raw.get("환산"), 몫=None)
|
||||
return {**head, "갈래": "짝", "짝": [pair]}
|
||||
|
||||
|
||||
def read(folder: str | Path) -> dict[str, dict[str, Any]]:
|
||||
"""한 층 장부 `{열쇠: 새 꼴 줄}`(옛 꼴은 바꿔 읽음 · 모르는 줄 뺌)."""
|
||||
out = {}
|
||||
for full, raw in hopyo_store.memory(folder).items():
|
||||
if str(full).removeprefix(HOPYO).count("|") == 2 and (got := upgrade(str(full), raw)):
|
||||
out[str(full)] = got
|
||||
return out
|
||||
|
||||
|
||||
# ── 층 ───────────────────────────────────────────────────────────────
|
||||
def chain(folder: str | Path) -> list[Path]:
|
||||
"""장부를 볼 층 폴더 — 같은 층 → 위 층(개인 → 회사 → 마스터)."""
|
||||
layer, owner = refs.where(folder)
|
||||
out = [Path(folder)]
|
||||
if layer == "personal":
|
||||
out.append(refs.folder_of("company", str(owner).split("/")[0]))
|
||||
if layer in ("personal", "company"):
|
||||
out.append(Path(store.FOLDER))
|
||||
return out
|
||||
|
||||
|
||||
def books(folder: str | Path) -> list[tuple[str, str | None, dict[str, dict[str, Any]]]]:
|
||||
"""층마다 `(층, 주인, 장부)` — 같은 층부터(줄 여럿을 찾을 때 한 번 읽어 넘김)."""
|
||||
return [(*refs.where(one), read(one)) for one in chain(folder)]
|
||||
|
||||
|
||||
def doc_id(folder: str | Path, doc: str) -> str:
|
||||
@@ -111,33 +26,6 @@ def doc_id(folder: str | Path, doc: str) -> str:
|
||||
return f"{layer}/{owner or ''}/{doc}"
|
||||
|
||||
|
||||
def recall(
|
||||
line: dict[str, Any],
|
||||
folder: str | Path,
|
||||
got: list | None = None,
|
||||
whole: bool = False,
|
||||
doc: str | None = None,
|
||||
) -> dict[str, Any] | None:
|
||||
"""줄(`whole` = 호표 통째)의 장부 짝 — `{…줄, 층, 주인, 규격다름, 제안}` · 없으면 None.
|
||||
자동 정확 열쇠(마스터 · `doc` 불러오기에서 이은 짝) → 제안 정확 열쇠(회사 · 개인 층 ·
|
||||
`제안` True · 자동 아님) → 품명|단위 느슨(규격다름 True · 체크 안 함)."""
|
||||
full = hopyo_key(line) if whole else key(line)
|
||||
got = books(folder) if got is None else got
|
||||
hits = [(layer, owner, book[full]) for layer, owner, book in got if full in book]
|
||||
for layer, owner, row in hits:
|
||||
if layer == "system" or (doc and row.get("불러오기") == doc):
|
||||
return {**row, "층": layer, "주인": owner, "규격다름": False, "제안": False}
|
||||
if hits:
|
||||
layer, owner, row = hits[0]
|
||||
return {**row, "층": layer, "주인": owner, "규격다름": False, "제안": True}
|
||||
loose = _loose(full)
|
||||
for layer, owner, book in got:
|
||||
for one, row in book.items():
|
||||
if one.startswith(HOPYO) == whole and _loose(one) == loose:
|
||||
return {**row, "층": layer, "주인": owner, "규격다름": True, "제안": False}
|
||||
return None
|
||||
|
||||
|
||||
# ── 검사 · 쓰기 ───────────────────────────────────────────────────────
|
||||
def _bad(text: str) -> store.StoreError:
|
||||
return store.StoreError(400, text)
|
||||
@@ -267,60 +155,3 @@ def times_of(raw: dict[str, Any], where: str) -> tuple[int | float, int | float
|
||||
if share is not None and (part is None or not 0 < part <= 1):
|
||||
raise _bad(f"몫은 0 넘고 1 이하 「{where}」")
|
||||
return _json(times), None if part is None else _json(part)
|
||||
|
||||
|
||||
def check(full: str, raw: Any, known: tuple[set[str], set[str]] | None = None) -> dict[str, Any]:
|
||||
"""장부 한 줄 재검사(장부 화면 [저장]) → 쓸 꼴(누가 · 때 빼고)."""
|
||||
if str(full).removeprefix(HOPYO).count("|") != 2 or not isinstance(raw, dict):
|
||||
raise _bad(f"장부 꼴이 틀림 「{full}」")
|
||||
kind = raw.get("갈래")
|
||||
if kind not in KINDS:
|
||||
raise _bad(f"갈래는 {' · '.join(KINDS)} 「{full}」")
|
||||
pairs = raw.get("짝") or []
|
||||
if kind != "짝" and pairs:
|
||||
raise _bad(f"「{kind}」 줄은 짝 없음 「{full}」")
|
||||
if kind == "짝" and (not isinstance(pairs, list) or not pairs or len(pairs) > 20):
|
||||
raise _bad(f"짝은 하나 넘고 스물 이하 「{full}」")
|
||||
known = known or _known()
|
||||
origin = raw.get("원래") if isinstance(raw.get("원래"), dict) else _plain_of(full)
|
||||
return {
|
||||
"원래": {k: str(origin.get(k) or "") for k in ("품명", "규격", "단위")},
|
||||
"갈래": kind,
|
||||
"짝": [check_pair(p, full, known) for p in pairs],
|
||||
"엑셀조항": raw.get("엑셀조항") if isinstance(raw.get("엑셀조항"), list) else [],
|
||||
}
|
||||
|
||||
|
||||
def write(
|
||||
folder: str | Path,
|
||||
entries: dict[str, dict[str, Any] | None],
|
||||
who: Any,
|
||||
file: str | None = None,
|
||||
doc: str | None = None,
|
||||
) -> int:
|
||||
"""검사 끝난 줄을 층 장부에 씀(None = 지움) — 같은 열쇠는 덮음 · 처음파일은 있던 값 둠 ·
|
||||
`doc` = 이은 불러오기(`doc_id` · 없으면 있던 값) · 옛 꼴 줄은 이때 새 꼴로 → 쓴 줄 수."""
|
||||
if not entries:
|
||||
return 0
|
||||
have = read(folder)
|
||||
stamp = utc_now_text()
|
||||
out: dict[str, dict[str, Any] | None] = dict(have) # 옛 꼴도 새 꼴로 다시 씀
|
||||
for full, row in entries.items():
|
||||
if row is None:
|
||||
out[full] = None
|
||||
continue
|
||||
first = (have.get(full) or {}).get("처음파일") or file
|
||||
out[full] = {**row, "누가": who, "때": stamp, "처음파일": first}
|
||||
if came := doc or (have.get(full) or {}).get("불러오기"):
|
||||
out[full]["불러오기"] = came
|
||||
hopyo_store.remember(folder, out)
|
||||
return len(entries)
|
||||
|
||||
|
||||
def put(folder: str | Path, entries: Any, who: Any) -> dict[str, Any]:
|
||||
"""`{열쇠: 줄 | None}` 재검사 뒤 이 층에 씀 → `{씀}`(장부 화면 · M01 승인은 걷음 · 815-2)."""
|
||||
if not isinstance(entries, dict) or not entries or len(entries) > 2000:
|
||||
raise _bad("저장할 줄이 없음")
|
||||
known = _known()
|
||||
clean = {str(k): None if v is None else check(str(k), v, known) for k, v in entries.items()}
|
||||
return {"씀": write(folder, clean, who)}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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 {})
|
||||
@@ -1,8 +1,8 @@
|
||||
"""M02 일위대가 실무자료 저장(PLAN 324-1) — 층 폴더 `실무자료/<키>.json` ·
|
||||
맞춤 기억 `실무자료/맞춤.json` · 엑셀꼴 격자 `실무자료/격자/<키>.json`(329-1 · 파일과 같이 지움).
|
||||
엑셀꼴 격자 `실무자료/격자/<키>.json`(329-1 · 파일과 같이 지움).
|
||||
|
||||
파일 = 읽은 결과만(원본 엑셀 안 둠) `{키, 파일, 올린때, 올린이, 시트, 호표, 검산}` · 키 `HP-######`
|
||||
(층마다 다음 번호) · 맞춤 기억 = `{줄: {줄 열쇠: {로직?|자재?|빼기?, 입력값, 환산, 확정}}}`.
|
||||
(층마다 다음 번호) · 옛 맞춤 기억(`맞춤.json` · 별칭 장부)은 853-3 에서 지움.
|
||||
층 종류(`layers.KINDS`) 밖 폴더 — 양식 목록 · 복사 · 프로젝트 씨앗에 안 섞임 · 권한은 길 몫.
|
||||
한시 불러오기(718-1 · 743-1) — 파일에 `지문`(올린 엑셀 sha256) · 목록 = 지문 있고 하루 안 지난 것
|
||||
(작업 중)만 · 옛 HP · 하루 지난 HP 는 목록에서 숨김(지움 = `M02_Hopyo_Forget`) ·
|
||||
@@ -26,7 +26,6 @@ from common_util.common_util_time import utc_now_text
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
|
||||
DIRNAME = "실무자료"
|
||||
MEMORY = "맞춤"
|
||||
GRID = "격자"
|
||||
DONE = "불러옴"
|
||||
NO_GRID = "격자 없음 — 다시 올리면 보임"
|
||||
@@ -174,27 +173,3 @@ def delete(folder: str | Path, key: str) -> None:
|
||||
path.unlink()
|
||||
_grid_path(folder, key).unlink(missing_ok=True)
|
||||
(_dir(folder) / "산근" / f"{key}.json").unlink(missing_ok=True) # 793-3b 산근 시트
|
||||
|
||||
|
||||
# ── 맞춤 기억 ─────────────────────────────────────────────────────────
|
||||
def memory(folder: str | Path, name: str = MEMORY) -> dict[str, dict[str, Any]]:
|
||||
"""층 맞춤 기억 `{줄 열쇠: 확정}` — 없으면 빈 것 ·
|
||||
`name` = 기억 파일(내역 잇기 707-4 = 「내역맞춤」)."""
|
||||
doc = _load(_dir(folder) / f"{name}.json")
|
||||
got = doc.get("줄") if isinstance(doc, dict) else None
|
||||
return got if isinstance(got, dict) else {}
|
||||
|
||||
|
||||
def remember(
|
||||
folder: str | Path, entries: dict[str, dict[str, Any] | None], name: str = MEMORY
|
||||
) -> dict[str, Any]:
|
||||
"""기억 더함 · 바꿈(값 None = 지움) → 새 기억 전부."""
|
||||
with _LOCK:
|
||||
got = memory(folder, name)
|
||||
for key, value in entries.items():
|
||||
if value is None:
|
||||
got.pop(key, None)
|
||||
else:
|
||||
got[key] = value
|
||||
atomic_write_json(_dir(folder) / f"{name}.json", {"줄": got})
|
||||
return got
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -352,11 +352,34 @@ def _no_loop(ref: Ref, trail: list[Ref]) -> None:
|
||||
_no_loop(child, [*trail, child])
|
||||
|
||||
|
||||
#: 층 뿌리 번호 장부 {종류: 발급한 가장 큰 번호} — 지운 끝 번호를 다시 안 씀(854-1 · M01 키대장 규칙과 같은 뜻)
|
||||
ISSUED = "_번호.json"
|
||||
|
||||
|
||||
def _issued() -> dict[str, Any]:
|
||||
try:
|
||||
got = json.loads((store.root() / ISSUED).read_bytes())
|
||||
except (OSError, ValueError):
|
||||
return {}
|
||||
return got if isinstance(got, dict) else {}
|
||||
|
||||
|
||||
def next_key(kind: str) -> str:
|
||||
"""지금 층 그 종류의 다음 키(가장 큰 번호 + 1)."""
|
||||
"""지금 층 그 종류의 다음 키(파일 · 장부 가운데 가장 큰 번호 + 1)."""
|
||||
folder = store.root() / kind
|
||||
have = [int(m.group(2)) for p in folder.glob("*.json") if (m := _KEY.match(p.stem))]
|
||||
return f"{PREFIX[kind]}-{max(have, default=0) + 1:06d}"
|
||||
return f"{PREFIX[kind]}-{max(*have, int(_issued().get(kind) or 0), 0) + 1:06d}"
|
||||
|
||||
|
||||
def _keep_issued(kind: str, key: str) -> None:
|
||||
"""장부에 발급한 번호(더 클 때만)."""
|
||||
from common_util.common_util_json import atomic_write_json
|
||||
|
||||
n = int(_KEY.match(key).group(2))
|
||||
with store._LOCK:
|
||||
got = _issued()
|
||||
if int(got.get(kind) or 0) < n:
|
||||
atomic_write_json(store.root() / ISSUED, {**got, kind: n})
|
||||
|
||||
|
||||
def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]:
|
||||
@@ -364,10 +387,13 @@ def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]:
|
||||
for _ in range(5):
|
||||
key = next_key(kind)
|
||||
try:
|
||||
return store.write(kind, key, "", {**doc, "키": key})
|
||||
got = store.write(kind, key, "", {**doc, "키": key})
|
||||
except store.StoreError as e:
|
||||
if e.status != 409 or not isinstance(e.detail, dict):
|
||||
raise
|
||||
else:
|
||||
_keep_issued(kind, key)
|
||||
return got
|
||||
raise _bad("새 키를 못 잡음 — 다시 누름", 409)
|
||||
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -235,7 +235,9 @@ def doc_sums(row: dict, logic: dict, index: Any) -> dict | None:
|
||||
return {"ok": True, "합": {k: float(got[k]) for k in (*cm.mf.COST_ITEMS, "계")}}
|
||||
|
||||
|
||||
_BRIEF: dict[tuple, dict] = {}
|
||||
#: {키: (색인, 줄)} — 색인이 바뀌면 비움 · 꺼낼 때 `is` 확인(옛 색인 주소 재사용 · 옛 값 막음 · 854-1)
|
||||
_BRIEF: dict[str, tuple[Any, dict]] = {}
|
||||
_BRIEF_OF: list[Any] = [None]
|
||||
|
||||
|
||||
def brief(keys: list[str]) -> list[dict[str, Any]]:
|
||||
@@ -246,11 +248,15 @@ def brief(keys: list[str]) -> list[dict[str, Any]]:
|
||||
from M02_MasterTemplete.M02_Item_Prices import to_json
|
||||
|
||||
index, mf = store.loaded()[1], cm.mf
|
||||
if len(_BRIEF) > 2000: # ponytail: 통째 비움 · 기계 수(655)의 세 배
|
||||
# ponytail: 통째 비움 · 기계 수(655)의 세 배
|
||||
if _BRIEF_OF[0] is not index or len(_BRIEF) > 2000:
|
||||
_BRIEF.clear()
|
||||
_BRIEF_OF[0] = index
|
||||
out = []
|
||||
for key in keys[:60]:
|
||||
if (got := _BRIEF.get((id(index), key))) is None:
|
||||
hit = _BRIEF.get(key)
|
||||
got = hit[1] if hit and hit[0] is index else None
|
||||
if got is None:
|
||||
try:
|
||||
row = (index.numbers.get("EQ") or {}).get(key) or index.get(key)
|
||||
except mf.FormulaError:
|
||||
@@ -272,7 +278,8 @@ def brief(keys: list[str]) -> list[dict[str, Any]]:
|
||||
)
|
||||
hour = {"ok": True, "로직": logic["키"]}
|
||||
hour |= {k: float(sums[k]) for k in (*cm.mf.COST_ITEMS, "계")}
|
||||
got = _BRIEF[(id(index), key)] = {**head, "값": to_json(row.get("값")), "시간당": hour}
|
||||
got = {**head, "값": to_json(row.get("값")), "시간당": hour}
|
||||
_BRIEF[key] = (index, got)
|
||||
out.append(got)
|
||||
return out
|
||||
|
||||
|
||||
@@ -49,14 +49,14 @@ def rows(folder: str | Path) -> list[dict[str, Any]]:
|
||||
|
||||
|
||||
def _last() -> int:
|
||||
"""모든 개인 층 파일의 가장 큰 PM 번호 — 사람 사이 번호 안 겹침."""
|
||||
found = [
|
||||
int(m.group(1))
|
||||
for path in layers.storage_root().glob(f"*/*/{layers.TEMPLATES_DIRNAME}/{FILE}")
|
||||
for row in read(path.parent)["줄"]
|
||||
if (m := KEY.match(str(row.get("키") or "")))
|
||||
]
|
||||
return max(found, default=0)
|
||||
"""모든 개인 층 파일의 가장 큰 PM 번호 — 사람 사이 번호 안 겹침 · 파일마다 `마지막`(발급한 가장 큰 번호)도
|
||||
셈(지운 끝 번호를 다시 안 씀 · 854-1)."""
|
||||
found = [0]
|
||||
for path in layers.storage_root().glob(f"*/*/{layers.TEMPLATES_DIRNAME}/{FILE}"):
|
||||
doc = read(path.parent)
|
||||
found.append(int(doc.get("마지막") or 0))
|
||||
found += [int(m.group(1)) for r in doc["줄"] if (m := KEY.match(str(r.get("키") or "")))]
|
||||
return max(found)
|
||||
|
||||
|
||||
def _text(v: Any) -> str:
|
||||
@@ -114,8 +114,10 @@ def add(folder: str | Path, body: dict[str, Any]) -> dict[str, Any]:
|
||||
with store._LOCK:
|
||||
doc = read(folder)
|
||||
row = _checked(body, doc["줄"])
|
||||
got = {"키": f"{PREFIX}{_last() + 1:06d}", **row}
|
||||
n = _last() + 1
|
||||
got = {"키": f"{PREFIX}{n:06d}", **row}
|
||||
doc["줄"].append(got)
|
||||
doc["마지막"] = n
|
||||
atomic_write_json(Path(folder) / FILE, doc)
|
||||
return got
|
||||
|
||||
|
||||
@@ -23,6 +23,8 @@ from __future__ import annotations
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import threading
|
||||
from collections.abc import Callable
|
||||
from contextvars import ContextVar
|
||||
from datetime import datetime
|
||||
from decimal import Decimal
|
||||
@@ -53,6 +55,11 @@ POWER, POWER_CREW, DIRECT_KEY = "GC001196", "GC001197", "GC001199"
|
||||
FUEL_POWER, FUEL_POWER_CREW = "GC001200", "GC001201" # 연료 + 전력(+ 조종원) — 경쟁사 구성(822-2b)
|
||||
|
||||
|
||||
#: 번호 발급 · 고치기 · 지우기 한 번에 하나(854-1) — 자기 잠금(`store._LOCK` 안에서 불려도 교착 없게)
|
||||
# ponytail: 프로세스 안 잠금 · 서버를 여럿 띄우면 파일 잠금으로
|
||||
_LOCK = threading.RLock()
|
||||
|
||||
|
||||
#: 단가산출 기계 창 초안(827-1 · `M02_MyMachine_Draft`) — 셈 꼴 줄 · 미리 셈 · 저장 한 요청 안만 `whole()` 위에 얹음
|
||||
DRAFT: ContextVar[tuple] = ContextVar("내기계초안", default=())
|
||||
|
||||
@@ -106,6 +113,26 @@ def _put(row: dict) -> None:
|
||||
atomic_write_json(_dir() / f"{row['키']}.json", row)
|
||||
|
||||
|
||||
def version(key: str) -> str:
|
||||
"""내 기계 한 대 판(파일 바이트 지문 · 없으면 빈 글)."""
|
||||
path = _dir() / f"{key}.json"
|
||||
return store.version_of(path.read_bytes()) if path.is_file() else ""
|
||||
|
||||
|
||||
def add(build: Callable[[str], dict]) -> dict:
|
||||
"""새 번호 발급 + 쓰기를 한 잠금 안에서(854-1) — `_다음` 번호 · 이미 있는 파일 번호는 건너뜀(덮어쓰기 없음) ·
|
||||
`build(키)` = 저장 줄."""
|
||||
with _LOCK:
|
||||
_move()
|
||||
user, n = _user(), int(_load(_dir() / NEXT).get("다음") or 1)
|
||||
while (_dir() / f"{PREFIX}{user}-{n:04d}.json").exists():
|
||||
n += 1
|
||||
row = build(f"{PREFIX}{user}-{n:04d}")
|
||||
atomic_write_json(_dir() / NEXT, {"다음": n + 1}) # 번호 먼저 — 겹쳐 쓰지 않게
|
||||
_put(row)
|
||||
return row
|
||||
|
||||
|
||||
def _read(folder: Path | None = None) -> dict[str, Any]:
|
||||
_move(folder)
|
||||
base = _dir(folder)
|
||||
@@ -420,9 +447,9 @@ def create_own(raw: Any = None, base: str | None = None) -> dict[str, Any]:
|
||||
return create(raw, base)
|
||||
|
||||
|
||||
def update_own(key: str, raw: Any) -> dict[str, Any]:
|
||||
def update_own(key: str, raw: Any, ver: str | None = None) -> dict[str, Any]:
|
||||
not_m01(raw, key)
|
||||
return update(key, raw)
|
||||
return update(key, raw, ver)
|
||||
|
||||
|
||||
def create(raw: Any = None, base: str | None = None) -> dict[str, Any]:
|
||||
@@ -430,37 +457,44 @@ def create(raw: Any = None, base: str | None = None) -> dict[str, Any]:
|
||||
seed = _seed(base) if base else {}
|
||||
raw = raw if isinstance(raw, dict) else {}
|
||||
body = clean({**seed, **raw, "값": {**seed.get("값", {}), **(raw.get("값") or {})}})
|
||||
data = _read()
|
||||
key = f"{PREFIX}{_user()}-{data['다음']:04d}"
|
||||
when = _now()
|
||||
row = {"키": key, "원문번호": f"{NO}{key}", "원문": "개인", "구분": "개인", "상세구분": body["이름"],
|
||||
**body, "넣은날": when, "고친날": when, **({"본뜬": base} if base else {})} # fmt: skip
|
||||
atomic_write_json(_dir() / NEXT, {"다음": data["다음"] + 1}) # 번호 먼저 — 겹쳐 쓰지 않게
|
||||
_put(row)
|
||||
row = add(lambda key: {"키": key, "원문번호": f"{NO}{key}", "원문": "개인", "구분": "개인",
|
||||
"상세구분": body["이름"], **body, "넣은날": when, "고친날": when,
|
||||
**({"본뜬": base} if base else {})}) # fmt: skip
|
||||
return answer(row)
|
||||
|
||||
|
||||
def update(key: str, raw: Any) -> dict[str, Any]:
|
||||
_user()
|
||||
data = _read()
|
||||
old = next((r for r in data["줄"] if r["키"] == key), None)
|
||||
def _old(key: str) -> dict:
|
||||
old = next((r for r in rows() if r["키"] == key), None)
|
||||
if old is None:
|
||||
raise _bad(f"없는 내 기계 「{key}」", 404)
|
||||
return old
|
||||
|
||||
|
||||
def update(key: str, raw: Any, ver: str | None = None) -> dict[str, Any]:
|
||||
"""고침 — `ver`(화면이 연 판)가 지금 판과 다르면 409 {stale, 판} · None = 대조 없음(초안 저장 등 서버 길)."""
|
||||
_user()
|
||||
_old(key)
|
||||
body = clean(raw)
|
||||
keep = {k: old[k] for k in ("키", "원문번호", "원문", "구분", "넣은날", "본뜬") if k in old}
|
||||
row = {**keep, "상세구분": body["이름"], **body, "고친날": _now()}
|
||||
_put(row)
|
||||
return answer(row)
|
||||
with _LOCK:
|
||||
old = _old(key)
|
||||
if ver is not None and (have := version(key)) != ver:
|
||||
raise store.StoreError(409, {"stale": [key], "판": have})
|
||||
keep = {k: old[k] for k in ("키", "원문번호", "원문", "구분", "넣은날", "본뜬") if k in old}
|
||||
row = {**keep, "상세구분": body["이름"], **body, "고친날": _now()}
|
||||
_put(row)
|
||||
now = version(key) # 잠금 안 판 — 뒤 고침이 끼어도 화면이 그 고침을 덮지 않게
|
||||
return {**answer(row), "판": now}
|
||||
|
||||
|
||||
def delete(key: str) -> dict[str, Any]:
|
||||
"""지움 — 이미 만든 단가산출은 사본의 마지막 값 그대로(「지운키」)."""
|
||||
_user()
|
||||
data = _read()
|
||||
if not any(r["키"] == key for r in data["줄"]):
|
||||
raise _bad(f"없는 내 기계 「{key}」", 404)
|
||||
_old(key)
|
||||
used = uses().get(key, [])
|
||||
(_dir() / f"{key}.json").unlink(missing_ok=True)
|
||||
with _LOCK:
|
||||
_old(key)
|
||||
(_dir() / f"{key}.json").unlink(missing_ok=True)
|
||||
return {"지움": key, "쓰는곳": used}
|
||||
|
||||
|
||||
@@ -509,6 +543,7 @@ def same(name: Any, spec: Any, skip: str = "") -> list[dict]:
|
||||
def answer(row: dict, used: list | None = None) -> dict[str, Any]:
|
||||
out = {
|
||||
"줄": row,
|
||||
"판": version(row["키"]),
|
||||
"시간당": hourly(engine(row), whole()),
|
||||
"같은이름": same(row["이름"], row["규격"], row["키"]),
|
||||
}
|
||||
|
||||
@@ -48,6 +48,8 @@ export interface Use {
|
||||
|
||||
export interface MyMachineOne {
|
||||
줄: MyMachine;
|
||||
/** 연 판(854-1) — 고치기 때 보냄 · 다르면 409(`StaleError`) */
|
||||
판?: string;
|
||||
시간당: MyHourly;
|
||||
같은이름: { 키: string; 이름: string; 규격: string; 출처: string }[];
|
||||
쓰는곳?: Use[];
|
||||
@@ -116,8 +118,9 @@ export const updateMyMachine = (
|
||||
owner: string | null,
|
||||
k: string,
|
||||
body: MyMachineBody,
|
||||
ver?: string,
|
||||
): Promise<MyMachineOne> =>
|
||||
call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body }) });
|
||||
call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body, 판: ver ?? null }) });
|
||||
|
||||
/** 저장 전 영향(848-5) — 바뀐 칸 · 이 층 쓰는 단가산출(그 칸을 따로 고쳐 둠?) · 쓰기 없음 */
|
||||
export interface MyMachineImpact {
|
||||
|
||||
@@ -140,15 +140,19 @@ def renew(copy: Any) -> Any:
|
||||
|
||||
def _new(row: dict) -> str:
|
||||
"""새 내 기계 파일(`mym.create` 와 같은 꼴 · 값은 초안 그대로 — 본뜬 값을 다시 섞지 않음)."""
|
||||
data = mym._read()
|
||||
key = f"{mym.PREFIX}{mym._user()}-{data['다음']:04d}"
|
||||
when = mym._now()
|
||||
head = {"키": key, "원문번호": f"{mym.NO}{key}", "원문": "개인", "구분": "개인"}
|
||||
body = {k: row[k] for k in ("상세구분", *BODY, "단위", "출처") if k in row}
|
||||
tail = {"넣은날": when, "고친날": when, **({"본뜬": row["본뜬"]} if row.get("본뜬") else {})}
|
||||
mym.atomic_write_json(mym._dir() / mym.NEXT, {"다음": data["다음"] + 1}) # 번호 먼저
|
||||
mym._put({**head, **body, **tail})
|
||||
return key
|
||||
return mym.add( # 번호 발급 + 쓰기 한 잠금(854-1)
|
||||
lambda key: {
|
||||
"키": key,
|
||||
"원문번호": f"{mym.NO}{key}",
|
||||
"원문": "개인",
|
||||
"구분": "개인",
|
||||
**body,
|
||||
**tail,
|
||||
} # fmt: skip
|
||||
)["키"]
|
||||
|
||||
|
||||
def saving(body: dict, inner: Callable[[dict], Any]) -> Any:
|
||||
|
||||
@@ -33,6 +33,7 @@ import {
|
||||
type MyMachineOne,
|
||||
type SimilarRow,
|
||||
} from "./M02_MyMachine_Api";
|
||||
import { StaleError } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import { confirmMyMachineImpact } from "./M02_MyMachine_Impact";
|
||||
import { mt } from "./M02_MyMachine_Text";
|
||||
import "./M02_MyMachine.css";
|
||||
@@ -97,6 +98,7 @@ export async function mountMyMachineForm(
|
||||
opt.key ? readMyMachine(opt.owner, opt.key) : Promise.resolve(null),
|
||||
]);
|
||||
const row = one?.줄;
|
||||
let ver = one?.판; // 연 판(854-1) — 고치기 때 보냄 · 저장마다 새 판
|
||||
let base: string | undefined; // 서버 `본뜬`
|
||||
const notice = el("div", { className: "m02-mymach__notice" });
|
||||
const server = el("div", { className: "m02-mymach__server" });
|
||||
@@ -173,16 +175,16 @@ export async function mountMyMachineForm(
|
||||
// 정본 고침 = 영향 보고 저장(848-5)
|
||||
if (opt.key && !(await confirmMyMachineImpact(opt.owner, opt.key, body))) return;
|
||||
const got = opt.key
|
||||
? await updateMyMachine(opt.owner, opt.key, body)
|
||||
? await updateMyMachine(opt.owner, opt.key, body, ver)
|
||||
: await createMyMachine(opt.owner, body, base);
|
||||
ver = got.판;
|
||||
saved = true;
|
||||
opt.onDirty?.(false);
|
||||
showToast(mt("Saved"), "success");
|
||||
opt.onSaved(got);
|
||||
} catch (error) {
|
||||
notice.replaceChildren(
|
||||
createText(error instanceof Error ? error.message : mt("Failed"), "error"),
|
||||
);
|
||||
const why = error instanceof StaleError ? mt("Stale") : error instanceof Error ? error.message : mt("Failed"); // prettier-ignore
|
||||
notice.replaceChildren(createText(why, "error"));
|
||||
} finally {
|
||||
saveBtn.disabled = m01Same;
|
||||
}
|
||||
|
||||
@@ -2,7 +2,8 @@
|
||||
|
||||
GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) ·
|
||||
POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) ·
|
||||
PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
|
||||
PUT `/{키}` 몸 {줄, 판?}(판 = 연 판 · 다르면 409 {stale, 판} · 854-1) ·
|
||||
POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
|
||||
POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}.
|
||||
권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404).
|
||||
⚠ 등록은 `main.py`(로그인만).
|
||||
@@ -30,6 +31,7 @@ class MachineBody(BaseModel):
|
||||
본뜬: str | None = None
|
||||
키: str | None = None # 초안 확인(827-1) — 고칠 내 기계
|
||||
표지: str | None = None # 초안 확인(827-1) — 화면이 정한 표지(셈 기록 열쇠)
|
||||
판: str | None = None # 고치기 — 화면이 연 판(854-1 · 다르면 409)
|
||||
|
||||
|
||||
def _folder(session: Session, layer: str, owner: str | None, write: bool = False):
|
||||
@@ -78,7 +80,7 @@ def my_machine_update(
|
||||
owner: str | None = None,
|
||||
session: Session = Depends(verify_session),
|
||||
):
|
||||
return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄)
|
||||
return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄, body.판)
|
||||
|
||||
|
||||
@router.post(PATH + "/{key}/impact")
|
||||
|
||||
@@ -28,6 +28,7 @@ const TEXT = {
|
||||
Back: "목록",
|
||||
Close: "닫기",
|
||||
Failed: "못 함",
|
||||
Stale: "그 사이 다른 곳에서 바뀜 — 목록에서 다시 열어 고침",
|
||||
Name_Needed: "이름 · 비어 있음",
|
||||
Same: "같은 이름 · 규격 있음 — {value}",
|
||||
Copied: "「{value}」 값을 복사 — 고친 뒤 [저장]",
|
||||
|
||||
@@ -282,8 +282,8 @@
|
||||
"이름": "건설폐기물 발생량 — 건설 공통 1-5-4",
|
||||
"결과단위": "ton",
|
||||
"출처": "건설품셈 공통 1-5-4 2",
|
||||
"부품": { "갈래": "계수식" },
|
||||
"개정": [2011, 2014, 2017, 2020],
|
||||
"부품": { "갈래": "계수식" },
|
||||
"소유": "공용",
|
||||
"비고": "발생량 = 면적 × 단위면적당 발생량(TON/㎡) × (1 + 증가율 ÷ 100) · 증가율 = 폐콘크리트류만(주③ 파일 시공 15% · 20% 이내 · 주④ 세륜 시설 개소당 3% 이내 — 설계자가 넣음 · 0 = 증가 없음) · 원문 칸 「-」 = 줄 없음(멈춤) · 건축물 해체는 설계도서 산출 우선(원문 2) · 주⑤ 현장 여건 조정",
|
||||
"시험입력": { "공사": "신축", "구조": "철근콘크리트조", "폐기물": "폐콘크리트류", "면적": 1000, "증가율": 0 },
|
||||
|
||||
@@ -1543,8 +1543,8 @@
|
||||
"이름": "불도저 시간당 작업량 — 건설 공통 8-2-1",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-1",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
|
||||
"개정": [2025],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
|
||||
"소유": "공용",
|
||||
"비고": "q = q° × e · cm = L/V1 + L/V2 + t · 타이어형 속도 표는 규격이 수(15 · 28 · 33) · 직접 칸 q0입력 · e입력 · V1입력 · V2입력 0 = 표(851-1)",
|
||||
"시험입력": {
|
||||
@@ -1642,8 +1642,8 @@
|
||||
"이름": "리퍼(유압식) 시간당 파쇄량 — 건설 공통 8-2-2",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-2",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["유압식 리퍼"] },
|
||||
"개정": [2025],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["유압식 리퍼"] },
|
||||
"소유": "공용",
|
||||
"비고": "cm = 0.05ℓ + 0.25(원문 산정식) · 탄성파속도는 작업효율 표에 있는 값(규격별) · 직접 칸 An입력 0 = 표(851-1)",
|
||||
"시험입력": { "규격": 20, "발톱수": "3본", "작업거리": 30, "암질": "연질", "탄성파속도": 500, "f": 1, "E입력": 0, "An입력": 0 },
|
||||
@@ -1686,8 +1686,8 @@
|
||||
"이름": "굴착기 시간당 작업량 — 건설 공통 8-2-3",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-3",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "버킷용량" },
|
||||
"개정": [2004, 2007, 2009, 2025],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "버킷용량" },
|
||||
"소유": "공용",
|
||||
"비고": "Q = 3,600·q·K·f·E/cm · 협소현장 = 주⑦ 상하수도관로부설 등 별도 E 표 · 싸이클입력 0 = 표(규격 · 선회각도) · K입력 0 = 표(버킷조건)",
|
||||
"시험입력": {
|
||||
@@ -1817,8 +1817,8 @@
|
||||
"이름": "로더 운전시간당 작업량 — 건설 공통 8-2-5",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-5",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["로더"], "규격": "버킷용량" },
|
||||
"개정": [2007, 2020],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["로더"], "규격": "버킷용량" },
|
||||
"소유": "공용",
|
||||
"비고": "cm = m·ℓ + t1 + t2 · K 표 둘(산적상태 적재 · 자연상태·기타 적재) · 주행거리 0 = 표준 8m · 직접 칸 m입력 · t1입력 · K입력 0 = 표(851-1)",
|
||||
"시험입력": {
|
||||
@@ -2006,8 +2006,8 @@
|
||||
"이름": "모터 그레이더 1시간당 작업면적 — 건설 공통 8-2-7",
|
||||
"결과단위": "㎡/hr",
|
||||
"출처": "건설품셈 공통 8-2-7",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["모터그레이더"] },
|
||||
"개정": [2025],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["모터그레이더"] },
|
||||
"소유": "공용",
|
||||
"비고": "cm 가 = 0.06×D/V1 + t · 나 = 0.06×(D/V1 + D/V2) + 2t · 속도가 여럿이면(P1·Cm1 + P2·Cm2 …) 설계자가 나눠 셈 · 직접 칸 V1입력 · V2입력 · t입력 0 = 표(851-1)",
|
||||
"시험입력": {
|
||||
@@ -2081,8 +2081,8 @@
|
||||
"이름": "모터 그레이더 1시간당 작업토량 — 건설 공통 8-2-7",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-7",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["모터그레이더"] },
|
||||
"개정": [2025],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["모터그레이더"] },
|
||||
"소유": "공용",
|
||||
"비고": "cm 가 = 0.06×D/V1 + t · 나 = 0.06×(D/V1 + D/V2) + 2t · 속도가 여럿이면(P1·Cm1 + P2·Cm2 …) 설계자가 나눠 셈 · 직접 칸 V1입력 · V2입력 · t입력 · l입력 0 = 표(851-1)",
|
||||
"시험입력": {
|
||||
@@ -2167,8 +2167,8 @@
|
||||
"이름": "덤프트럭 1시간당 작업량 — 건설 공통 8-2-8",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-8",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"], "규격": "적재용량" },
|
||||
"개정": [2017],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"], "규격": "적재용량" },
|
||||
"소유": "공용",
|
||||
"비고": "q = T/γt × L · cm = t1 + … + t6 · 적재기계 t1 = cms·n/(60·Es) · n = q/(qs·k)(2자리) · 인력 t1 = 적재시간(분/㎥) × q · t2 = 거리/속도 × 60(분) · t2 = 구간 셋(구간 2 · 3 거리 0 = 안 씀) · 속도 · t2 ~ t5 직접 칸 0 = 표",
|
||||
"시험입력": {
|
||||
@@ -2390,8 +2390,8 @@
|
||||
"이름": "롤러 시간당 다짐토량 — 건설 공통 8-2-9",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-9",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] },
|
||||
"개정": [2004, 2017, 2025],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] },
|
||||
"소유": "공용",
|
||||
"비고": "Q = 1,000·V·W·D·E·f/N · 소요다짐횟수 · 두께는 2 표(CC000063) 참고 입력 · 직접 칸 W입력 · V입력 0 = 표(851-1)",
|
||||
"시험입력": {
|
||||
@@ -2467,8 +2467,8 @@
|
||||
"이름": "롤러 시간당 다짐면적 — 건설 공통 8-2-9",
|
||||
"결과단위": "㎡/hr",
|
||||
"출처": "건설품셈 공통 8-2-9",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] },
|
||||
"개정": [2004, 2017, 2025],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] },
|
||||
"소유": "공용",
|
||||
"비고": "A = 1,000·V·W·E·1/N · 직접 칸 W입력 · V입력 0 = 표(851-1)",
|
||||
"시험입력": { "다짐기계": "타이어롤러", "규격": "8∼15", "다짐층": "노체, 축제, 노상", "다짐횟수": 4, "E공종": "노체, 축제, 노상", "E기계": "불도저", "현장조건": "보통", "E입력": 0, "W입력": 0, "V입력": 0 },
|
||||
@@ -2745,8 +2745,8 @@
|
||||
"이름": "압쇄기(콘크리트 소할용) 시간당 작업량 — 건설 공통 8-2-14",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-14",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["압쇄기"] },
|
||||
"개정": [2004],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["압쇄기"] },
|
||||
"소유": "공용",
|
||||
"비고": "Q = q × E",
|
||||
"시험입력": { "E입력": 0 },
|
||||
@@ -2785,8 +2785,8 @@
|
||||
"이름": "골재세척설비 시간당 작업량 — 건설 공통 8-2-16",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-16",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["골재세척설비"] },
|
||||
"개정": [2001],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["골재세척설비"] },
|
||||
"소유": "공용",
|
||||
"비고": "Q = q × E",
|
||||
"시험입력": { "E입력": 0 },
|
||||
@@ -2825,8 +2825,8 @@
|
||||
"이름": "콘크리트 배치플랜트(강제 혼합식) 시간당 작업량 — 건설 공통 8-2-18",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-18",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["콘크리트 배치플랜트"] },
|
||||
"개정": [2000, 2002, 2011],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["콘크리트 배치플랜트"] },
|
||||
"소유": "공용",
|
||||
"비고": "Q = 60·q·E/cm · 터널 숏크리트 매우 불량은 E입력 0.40(주②) · 직접 칸 q입력 · cm입력 0 = 표(851-1)",
|
||||
"시험입력": { "규격": "60㎥/h (96㎾)", "슬럼프": "5㎝이상", "공종": "사방", "현장조건": "보통", "싸이클": "표준", "E입력": 0, "q입력": 0, "cm입력": 0 },
|
||||
@@ -3359,8 +3359,8 @@
|
||||
"이름": "진동파일 해머 파일 1본당 시공시간 — H파일 — 건설 공통 8-2-24",
|
||||
"결과단위": "분/본",
|
||||
"출처": "건설품셈 공통 8-2-24",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머"] },
|
||||
"개정": [1996, 2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머"] },
|
||||
"소유": "공용",
|
||||
"비고": "Tc = (Ts+Tb)/F · Tb = r×ℓ×k · r = (r1ℓ1 + r2ℓ2)/(ℓ1+ℓ2) · F = F0 + (f1+f2+f3+f4) · 직접 칸 Ts입력 · F0입력 · k입력 · r1입력 · r2입력 0 = 표(851-1)",
|
||||
"시험입력": {
|
||||
@@ -3451,8 +3451,8 @@
|
||||
"이름": "진동파일 해머 파일 1본당 시공시간 — 강널말뚝 — 건설 공통 8-2-24",
|
||||
"결과단위": "분/본",
|
||||
"출처": "건설품셈 공통 8-2-24",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머"] },
|
||||
"개정": [1996, 2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머"] },
|
||||
"소유": "공용",
|
||||
"비고": "Tc = {(0.75+γ·Nmax)·ℓ+α}·K/F · K = 원문 항타 · 인발 두 줄에 걸친 한 칸(항타 줄 값) · 인발 F0 = 원문 「항발」 칸 · 직접 칸 α입력 · K입력 · γ입력 · F0입력 0 = 표(851-1)",
|
||||
"시험입력": { "종류": "III-Type (400×150×13)", "작업": "항타", "해머": 45, "근입길이": 10, "Nmax": 20, "f1": 0, "f2": 0, "f3": 0, "α입력": 0, "K입력": 0, "γ입력": 0, "F0입력": 0 },
|
||||
@@ -3652,8 +3652,8 @@
|
||||
"이름": "펌프식 준설선 1시간당 준설능력 — 건설 공통 8-2-29",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-29",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["펌프 준설선"] },
|
||||
"개정": [2010, 2011],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["펌프 준설선"] },
|
||||
"소유": "공용",
|
||||
"비고": "Q = q·bo·E/746 · E = E1×E2×E3×E4 · bo = 디젤 공칭 × 0.8 · 터빈 × 0.9 · 직접 칸 E1입력 · E2입력 · E3입력 · E4입력 0 = 표(851-1)",
|
||||
"시험입력": {
|
||||
@@ -3757,8 +3757,8 @@
|
||||
"이름": "그래브 준설선 1시간당 준설량 — 건설 공통 8-2-30",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-30",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["그래브 준설선"] },
|
||||
"개정": [2010, 2011],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["그래브 준설선"] },
|
||||
"소유": "공용",
|
||||
"비고": "Q = 3,600·q·k·f·E/cm · E = E1×E2 · 수심 10m 기준 1m 증감마다 2초 증감 · 표의 괄호 값 = 쇄암 · 발파후 준설 · 직접 칸 싸이클입력 · E1입력 · E2입력 0 = 표(851-1)",
|
||||
"시험입력": {
|
||||
@@ -3847,8 +3847,8 @@
|
||||
"이름": "쇄암선(중추식) 시간당 작업능력 — 건설 공통 8-2-31",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-31",
|
||||
"부품": { "갈래": "작업량 틀", "기종": [] },
|
||||
"개정": [2011],
|
||||
"부품": { "갈래": "작업량 틀", "기종": [] },
|
||||
"소유": "공용",
|
||||
"비고": "Q = 60·d·S·E/(t + n/p) · 직접 칸 S입력 · n입력 0 = 표(851-1)",
|
||||
"시험입력": { "분류": "암반", "상태": "연질", "중추중량": 30, "E": 0.7, "S입력": 0, "n입력": 0 },
|
||||
@@ -3888,8 +3888,8 @@
|
||||
"이름": "이동식 임목파쇄기 시간당 파쇄능력 — 건설 공통 8-2-32",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-32",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["이동식 임목파쇄기"] },
|
||||
"개정": [2007, 2011],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["이동식 임목파쇄기"] },
|
||||
"소유": "공용",
|
||||
"비고": "93.25㎾ Q = 6.0 · 354.35∼402.84㎾ Q = q·K·S·E · 직접 칸 K입력 · S입력 · E입력 0 = 표(851-1)",
|
||||
"시험입력": { "규격": "354.35㎾", "스크린": "75㎜", "작업조건": "보통", "K입력": 0, "S입력": 0, "E입력": 0 },
|
||||
@@ -3924,8 +3924,8 @@
|
||||
"이름": "하천골재채취선 시간당 준설량 — 건설 공통 8-2-33",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "건설품셈 공통 8-2-33",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["하천골재채취선"] },
|
||||
"개정": [2005],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["하천골재채취선"] },
|
||||
"소유": "공용",
|
||||
"비고": "Q = q·b·E/746 · 직접 칸 q입력 · E입력 0 = 표(851-1)",
|
||||
"시험입력": { "분류": "모래질토사", "상태": "연질", "배송거리": 300, "출력": 746, "조건": "보통", "유속": "보통", "q입력": 0, "E입력": 0 },
|
||||
|
||||
@@ -12,12 +12,10 @@
|
||||
"이름": "체인톱 시간당 기계경비",
|
||||
"결과단위": "원/시간",
|
||||
"출처": "산림품셈 2-1-1 · 2-2-1",
|
||||
"개정": [2026],
|
||||
"부품": {
|
||||
"갈래": "기계경비식"
|
||||
},
|
||||
"개정": [
|
||||
2026
|
||||
],
|
||||
"소유": "공용",
|
||||
"비고": "1일 1대당(2-1-1 주연료 · 체인오일 · 잡품 · 2-2-1 손료계수) × 시간환산(1일 8시간) · 체인톱 가격 = 재료 「동력체인톱」 · 체인오일 = 재료 「작동유」(GF000076 체인톱 줄과 같음) · 가져온 시간당 「엔진톱」 줄을 잇는 식",
|
||||
"입력": [
|
||||
|
||||
@@ -83,8 +83,8 @@
|
||||
"이름": "임산물 운반로 신설 굴착기 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 3-4-2 1",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"비고": "해석: 원문 단가산출 예시의 값(q 0.2 · K 0.7 · f 0.71 · E 0.45 · Cm 18)을 표준 값으로 씀",
|
||||
"입력": [],
|
||||
|
||||
@@ -1199,8 +1199,8 @@
|
||||
"이름": "복사이식 굴착기 시간당 작업량(Q1)",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 5-29 주④",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"비고": "해석: q = 주③ 굴착기 용량 1.0㎥ · 주⑤ Q=Q1×T 는 단위가 안 맞아(㎥/시간 × m) 넣지 않음",
|
||||
"입력": [],
|
||||
|
||||
@@ -46,8 +46,8 @@
|
||||
"이름": "토사깍기(기계 · 굴착기 0.7㎥) 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-3-2",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"비고": "E 원문 「0.55∼0.45」 — 설계자 입력 · f 는 주④ 0.77",
|
||||
"입력": [{ "이름": "E입력", "범위": [0.45, 0.55], "출처": "산림품셈 9-3-2" }],
|
||||
@@ -170,8 +170,8 @@
|
||||
"이름": "암절취 집토(굴착기 0.7㎥) 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-4-2",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"비고": "f 원문 「1/1.40」 그대로 계산",
|
||||
"입력": [],
|
||||
@@ -323,8 +323,8 @@
|
||||
"이름": "발파암 집토(굴착기 0.7㎥) 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-5-3",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"비고": "f 원문 「1/1.625」 그대로 계산",
|
||||
"입력": [],
|
||||
@@ -424,8 +424,8 @@
|
||||
"이름": "콘크리트 깨기 집토(굴착기 0.7㎥) 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-7-1 주⑥",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"입력": [],
|
||||
"중간": [
|
||||
@@ -928,8 +928,8 @@
|
||||
"이름": "측구터파기 토사 굴착기 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-12-1",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"입력": [],
|
||||
"중간": [
|
||||
@@ -2286,8 +2286,8 @@
|
||||
"이름": "되메우기 굴착기 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-14-1",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"입력": [],
|
||||
"중간": [
|
||||
@@ -2339,8 +2339,8 @@
|
||||
"이름": "다짐(플레이트콤펙터) 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-14-2",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["플레이트 콤팩터"] },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["플레이트 콤팩터"] },
|
||||
"소유": "공용",
|
||||
"비고": "돈 로직 GF000249",
|
||||
"입력": [],
|
||||
@@ -2381,8 +2381,8 @@
|
||||
"이름": "표토제거 답(畓)구간(굴착기 0.7㎥) 시간당 작업량",
|
||||
"결과단위": "㎡/hr",
|
||||
"출처": "산림품셈 9-15-1",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"비고": "T(표토두께) 설계자 입력 · Q=Q1/T · f 원문 「1/1.30」 그대로 계산",
|
||||
"입력": [{ "이름": "T", "단위": "m", "출처": "산림품셈 9-15-1 주②" }],
|
||||
@@ -2426,8 +2426,8 @@
|
||||
"이름": "표토제거 답(畓)외구간(불도저 19ton) 시간당 작업량",
|
||||
"결과단위": "㎡/hr",
|
||||
"출처": "산림품셈 9-15-2",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
|
||||
"소유": "공용",
|
||||
"비고": "돈 로직 GF000250 · f 원문 「1/1.3」 그대로 계산",
|
||||
"입력": [],
|
||||
@@ -2486,8 +2486,8 @@
|
||||
"이름": "노체포설 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-16-1 주②",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"] },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"] },
|
||||
"소유": "공용",
|
||||
"입력": [],
|
||||
"중간": [
|
||||
@@ -2533,8 +2533,8 @@
|
||||
"이름": "노체다짐 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-16-2 주②",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] },
|
||||
"소유": "공용",
|
||||
"입력": [],
|
||||
"중간": [
|
||||
@@ -2605,8 +2605,8 @@
|
||||
"이름": "비다짐(정지 · 불도저 19ton) 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-17-2",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
|
||||
"소유": "공용",
|
||||
"비고": "돈 로직 GF000251 · E 원문 「(0.55-0.1)」 · f 원문 「1/1.3」 그대로 계산",
|
||||
"입력": [],
|
||||
@@ -2660,8 +2660,8 @@
|
||||
"이름": "층따기(굴착기 0.7㎥) 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-18",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"비고": "f 원문 「1/1.3」 그대로 계산",
|
||||
"입력": [],
|
||||
@@ -2907,8 +2907,8 @@
|
||||
"이름": "섞기(굴착기 0.7㎥) 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 9-22",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"비고": "f 원문 「1/1.25」 그대로 계산 · 주③ Q=Q1*T 는 단위가 맞지 않아 Q1 까지만",
|
||||
"입력": [],
|
||||
|
||||
@@ -12,8 +12,8 @@
|
||||
"이름": "골재운반 덤프트럭 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 10-3-1 주",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"] },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"] },
|
||||
"소유": "공용",
|
||||
"비고": "원문은 식만(Q=60×qt×f×E/㎝) — qt · f · E · ㎝ 값 없음 · 설계자 입력",
|
||||
"입력": [{ "이름": "qt", "단위": "㎥" }, { "이름": "f", "단위": "" }, { "이름": "E", "단위": "" }, { "이름": "Cm", "단위": "분" }],
|
||||
@@ -519,8 +519,8 @@
|
||||
"이름": "4륜구동 1톤 덤프트럭 시간당 기계경비",
|
||||
"결과단위": "원/시간",
|
||||
"출처": "산림품셈 10-9",
|
||||
"부품": { "갈래": "기계경비식" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "기계경비식" },
|
||||
"소유": "공용",
|
||||
"비고": "손료·운전경비는 2.5톤(0602-0025) · 주연료 2.5톤의 80% · 중기가격 조달청 등재가격 = 기계표 EQ000655 덤프트럭(4륜구동) 1ton 가격 · 작업량(건설품셈 덤프트럭 식)·10-9-1 운반량 쓰는 식 요소 없음 · 주② 제잡비 비율 원문에 없음",
|
||||
"입력": [
|
||||
@@ -679,8 +679,8 @@
|
||||
"이름": "불도저 운반 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 10-11 주②",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["불도저"] },
|
||||
"소유": "공용",
|
||||
"비고": "해석: 파쇄암·발파암의 E 는 「암석」 줄",
|
||||
"입력": [
|
||||
|
||||
@@ -93,8 +93,8 @@
|
||||
"이름": "쇄석·혼합석 부설 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 11-4 주①",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"비고": "해석: 원문 식 「3600×90×k×f×E/㎝」의 90 을 q(버킷용량)로 봄",
|
||||
"입력": [],
|
||||
|
||||
@@ -1367,8 +1367,8 @@
|
||||
"이름": "토양개량제 부설 굴착기 시간당 작업량",
|
||||
"결과단위": "㎥/hr",
|
||||
"출처": "산림품셈 13-13-2",
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"개정": [2026],
|
||||
"부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" },
|
||||
"소유": "공용",
|
||||
"비고": "식은 9장 같은 꼴 표(9-12-1 등)와 같이 Q=3600×q×k×f×E/㎝",
|
||||
"입력": [],
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -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
|
||||
@@ -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:
|
||||
|
||||
@@ -28,7 +28,6 @@ from B09_Estimation import B09_Estimation_Store as store # noqa: E402
|
||||
from B09_Estimation.B09_Estimation_Bill_Excel import read_bill # noqa: E402
|
||||
from B09_Estimation.B09_Estimation_Bill_Items import EARTH, earth_items # noqa: E402
|
||||
from B09_Estimation.B09_Estimation_Calc_Bill import compute_estimation # noqa: E402
|
||||
from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store # noqa: E402
|
||||
|
||||
K = ROOT / "resources" / "knowledge" / "original" / "실무문서"
|
||||
GEO = (
|
||||
@@ -122,9 +121,8 @@ def test_맞춤_기억_두_번째_공사_저절로(geo, tmp_path):
|
||||
user, rows = _load(geo)
|
||||
made, report, bill = _link(user, rows, _pick(lk.suggest(rows, {})))
|
||||
assert report["이음"] == 12 and report["못함"] == []
|
||||
hopyo_store.remember(tmp_path, report["기억"], lk.MEMORY)
|
||||
assert hopyo_store.memory(tmp_path) == {} # 실무자료 맞춤과 다른 파일
|
||||
memory = hopyo_store.memory(tmp_path, lk.MEMORY)
|
||||
# 기억 = 다음 공사 찾기 입력(옛 M02 맞춤 저장은 853-3 에서 걷음)
|
||||
memory = {k: v for k, v in report["기억"].items() if v is not None}
|
||||
assert memory["암석절취|보통암|m3"]["확정"] == "earth:6"
|
||||
for name, path in ESTX.items():
|
||||
parsed = ex.read_bill(path.name, path.read_bytes())
|
||||
|
||||
@@ -32,14 +32,12 @@ def test_이어서_끝내기_지움_겹침_막음(client):
|
||||
and n + len(made["실패"]) == 68
|
||||
and all(x.get("남은줄") or x.get("하위") for x in made["실패"])
|
||||
)
|
||||
hs.remember(folder, {"장부 줄": {"갈래": "안 씀"}}) # 별칭 장부 = 끝내기 뒤 남음
|
||||
sc_before = sorted((folder / "precombo").glob("SC-*.json"))
|
||||
|
||||
res = client.delete(URL.format("personal") + "/HP-000001")
|
||||
assert res.status_code == 200 and res.json() == {"지움": "HP-000001", "만든": n}
|
||||
assert not list((folder / hs.DIRNAME).glob("HP-*.json")) # 이번 HP 0
|
||||
assert not list((folder / hs.DIRNAME / hs.GRID).glob("HP-*.json"))
|
||||
assert hs.memory(folder) == {"장부 줄": {"갈래": "안 씀"}}
|
||||
assert sorted((folder / "precombo").glob("SC-*.json")) == sc_before # 만든 일위대가 그대로
|
||||
|
||||
again = _post(client) # 743-1 — 끝낸 같은 엑셀 = 다시 올림 됨(새 키)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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")}
|
||||
|
||||
@@ -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
|
||||
) # 빈 블록 = 밖
|
||||
|
||||
@@ -72,7 +72,7 @@ def test_거푸집_한_묶음_굴착기_한_묶음():
|
||||
eq = _export("GF000089")
|
||||
rows = eq["소계"]["줄"]
|
||||
assert [(r["갈래"], r["이름"]) for r in rows] == [("블록", "굴착기(무한궤도) 0.7㎥")]
|
||||
assert eq["합계"]["계"] == D("2190.0") and eq["소계"]["끝수"]["계"] == D("-1.0")
|
||||
assert eq["합계"]["계"] == rows[0]["계"] + eq["소계"]["끝수"]["계"] > 0 # 금액은 M01 값 따라감
|
||||
|
||||
|
||||
def test_M01_전수_묶음_합_끝수_합계_안쪽_말_0():
|
||||
|
||||
@@ -235,7 +235,5 @@ def test_걷은_파일_쓰는_곳_0() -> None:
|
||||
continue
|
||||
text = path.read_text(encoding="utf-8", errors="ignore")
|
||||
assert not [n for n in names if f"import {n}" in text or f'/{n}"' in text], path
|
||||
build = (ROOT / "M02_MasterTemplete" / "M02_Hopyo_Build.py").read_text(encoding="utf-8")
|
||||
assert "ledger.write(" not in build # 일위대가 불러오기 확인 = 장부에 안 적음
|
||||
doc = (ROOT / "M02_MasterTemplete" / "M02_Doc_Router.py").read_text(encoding="utf-8")
|
||||
assert "mfind.learn" not in doc # 가져온 식 저장 = 장부에 안 적음
|
||||
|
||||
@@ -133,12 +133,12 @@ def test_edit_delete_add_and_dep_change(fresh, reads):
|
||||
assert set(reads) == {f"sangeun/{a}", f"sangeun/{c}"} # 바뀐 항목만 다시 읽음
|
||||
assert rows == _old(mine)
|
||||
titles = {r["이름"]: r.get("제목") for r in rows if r["종류"] in index.layers.LIBRARY_KINDS}
|
||||
assert gone == c and titles == {
|
||||
assert gone != c and titles == {
|
||||
a: "가",
|
||||
b: "나",
|
||||
c: "다",
|
||||
sc: "일위대가",
|
||||
} # 지운 키를 새 것이 받음
|
||||
} # 지운 키는 빠지고 새 것은 새 번호(854-1 · 지운 번호 안 다시 씀)
|
||||
reads.clear()
|
||||
was = {r["이름"]: r.get("기준금액") for r in _new(mine)}
|
||||
assert reads == []
|
||||
|
||||
@@ -0,0 +1,119 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""854-1 안전 고침 — 내 기계 저장 잠금 · 판 대조 · 번호 겹침 없음(임시 storage · M01 정본 안 고침).
|
||||
|
||||
① 스레드 여럿이 동시에 만들기 → 번호 겹침 0 · 파일 수 = 요청 수 ② 옛 판으로 고치기 = 409 · 새 판 = 됨
|
||||
③ `_다음` 이 뒤처져도 있는 파일 번호를 덮지 않음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import time
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
import pytest
|
||||
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_MyMachine as mym
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
N = 8
|
||||
|
||||
|
||||
def _at(folder, fn, *args):
|
||||
with store.at(folder):
|
||||
return fn(*args)
|
||||
|
||||
|
||||
def _easy(name="sub4임시기계", **vals):
|
||||
base = {"가격": 1000, "손료계수": 2000, "주연료": 2, "주연료종류": "경유"}
|
||||
return {"이름": name, "규격": "1㎾", "방식": "바로", "값": base | vals}
|
||||
|
||||
|
||||
def test_parallel_create_no_clash(world, monkeypatch):
|
||||
"""① 동시 만들기 N 번 — 키 N 개 모두 다름 · 파일 N 개 · 줄마다 자기 이름(쓰기마다 늦춰 틈을 벌림)."""
|
||||
me = world["personal"]
|
||||
write = mym.atomic_write_json
|
||||
|
||||
def slow(path, value):
|
||||
time.sleep(0.02)
|
||||
write(path, value)
|
||||
|
||||
monkeypatch.setattr(mym, "atomic_write_json", slow)
|
||||
with ThreadPoolExecutor(N) as pool:
|
||||
got = list(pool.map(lambda i: _at(me, mym.create, _easy(f"sub4임시{i}"))["줄"], range(N)))
|
||||
keys = [r["키"] for r in got]
|
||||
assert len(set(keys)) == N
|
||||
files = sorted((me / mym.DIR).glob(f"{mym.PREFIX}*.json"))
|
||||
assert len(files) == N
|
||||
names = {json.loads(p.read_bytes())["이름"] for p in files}
|
||||
assert names == {f"sub4임시{i}" for i in range(N)}
|
||||
assert json.loads((me / mym.DIR / mym.NEXT).read_bytes())["다음"] == N + 1
|
||||
|
||||
|
||||
def test_stale_version_409(world):
|
||||
"""② 연 판으로 고침 = 됨(새 판 받음) · 옛 판으로 한 번 더 = 409 {stale, 판} · 판 없음 = 대조 없음."""
|
||||
me = world["personal"]
|
||||
made = _at(me, mym.create, _easy())
|
||||
key, old = made["줄"]["키"], made["판"]
|
||||
assert old
|
||||
fresh = _at(me, mym.update, key, _easy(가격=3000), old)
|
||||
assert fresh["판"] and fresh["판"] != old
|
||||
with pytest.raises(store.StoreError) as e:
|
||||
_at(me, mym.update, key, _easy(가격=4000), old)
|
||||
assert e.value.status == 409 and e.value.detail == {"stale": [key], "판": fresh["판"]}
|
||||
assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 3000 # 막힌 고침은 안 적힘
|
||||
_at(me, mym.update, key, _easy(가격=5000)) # 서버 길(초안 저장) = 대조 없음
|
||||
assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 5000
|
||||
|
||||
|
||||
def test_counter_behind_skips_file(world):
|
||||
"""③ `_다음` 이 옛 번호를 가리켜도 있는 파일은 안 덮음 — 다음 빈 번호."""
|
||||
me = world["personal"]
|
||||
first = _at(me, mym.create, _easy("sub4임시처음"))["줄"]["키"]
|
||||
(me / mym.DIR / mym.NEXT).write_text('{"다음": 1}', encoding="utf-8")
|
||||
second = _at(me, mym.create, _easy("sub4임시둘째"))["줄"]["키"]
|
||||
assert second != first
|
||||
assert _at(me, mym.one, first)["줄"]["이름"] == "sub4임시처음"
|
||||
|
||||
|
||||
def test_brief_cache_follows_index(monkeypatch):
|
||||
"""④ 기계 창 목록 메모(`Machine_Hourly.brief`) — 색인이 바뀌면 새 값 · 옛 색인 메모를 안 꺼냄 · 되돌리면 처음 값."""
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Machine_Hourly as mh
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
|
||||
key = "EQ000022" # 굴착기 — 가격 · 시간당 있음
|
||||
base = m01.loaded()
|
||||
first = mh.brief([key])[0]
|
||||
row = base[1].get(key)
|
||||
twice = {**row, "값": {**row["값"], "가격": row["값"]["가격"] * 2}}
|
||||
other = skc.Copy(base[1], [twice], ("시험854",))
|
||||
monkeypatch.setattr(m01, "loaded", lambda: (base[0], other))
|
||||
got = mh.brief([key])[0]
|
||||
assert got["값"]["가격"] == first["값"]["가격"] * 2
|
||||
assert got["시간당"]["계"] > first["시간당"]["계"]
|
||||
assert all(v[0] is other for v in mh._BRIEF.values())
|
||||
monkeypatch.setattr(m01, "loaded", lambda: base)
|
||||
assert mh.brief([key])[0] == first
|
||||
|
||||
|
||||
def test_deleted_last_key_not_reused(world):
|
||||
"""⑤ 단가산출(SK) · 내 재료(PM) — 끝 번호를 지운 뒤 새로 만들면 새 번호(지운 번호 안 다시 씀)."""
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Material_Own as own
|
||||
|
||||
me = world["personal"]
|
||||
body = {"단위": "시간", "더한줄": []}
|
||||
made = [
|
||||
_at(me, refs.create, "sangeun", {**body, "이름": f"sub4임시{i}"})["이름"] for i in range(2)
|
||||
]
|
||||
assert made == ["SK-000001", "SK-000002"]
|
||||
_at(me, store.delete, "sangeun", made[-1])
|
||||
assert _at(me, refs.create, "sangeun", {**body, "이름": "sub4임시3"})["이름"] == "SK-000003"
|
||||
|
||||
bolt = {"이름": "sub4임시볼트", "규격": "M16", "단위": "EA", "값": 1200}
|
||||
keys = [own.add(me, {**bolt, "규격": f"M{i}"})["키"] for i in (16, 20)]
|
||||
assert keys == ["PM000001", "PM000002"]
|
||||
own.remove(me, keys[-1])
|
||||
assert own.add(me, {**bolt, "규격": "M24"})["키"] == "PM000003"
|
||||
@@ -1,146 +1,33 @@
|
||||
"""일위대가 실무자료 별칭 장부(PLAN 338-3 · `M02_Hopyo_Ledger`) — 옛 꼴 바꿔 읽음 · 새 꼴 ·
|
||||
층 차례(739-1 자동 = 마스터 · 이 불러오기 짝 · 아래 층 = 제안) · 느슨 찾기(규격다름) · 우리에 없음 · 안 씀 · 호표 통째 열쇠 ·
|
||||
위 층 읽기만 · 재검사 · 쓰기(처음파일 둠 · 옛 꼴 새로 씀) · master_data 원본 그대로. 층은 임시 폴더.
|
||||
"""일위대가 짝 재검사(PLAN 338-3 · 739-1 · `M02_Hopyo_Ledger.check_pair`) — 불러오기 [내 일위대가로]가
|
||||
받은 짝을 서버가 다시 봄: 돈 로직 · 그 로직 입력 이름 · M01 자재품목 · 배 0 넘음 · 몫 (0, 1] · 금액 칸 안 받음.
|
||||
옛 별칭 장부 읽기 · 쓰기 시험은 853-3 에서 지움(장부 함수 걷음).
|
||||
"""
|
||||
|
||||
import json
|
||||
|
||||
import pytest
|
||||
|
||||
from M02_MasterTemplete import M02_Hopyo_Ledger as ledger
|
||||
from M02_MasterTemplete import M02_Hopyo_Match as hm
|
||||
from M02_MasterTemplete import M02_Hopyo_Store as hs
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
|
||||
# 올리기 길 시험의 `client` 마당을 같이 씀
|
||||
# ruff: noqa: F811
|
||||
from resources.tester.test_m02_hopyo_excel import client, master_hash # noqa: F401
|
||||
|
||||
DIG = {"이름": "구조물터파기(인력100%)", "규격": "토사", "단위": "㎥"}
|
||||
DIG_KEY = "구조물터파기(인력100%)|토사|m3"
|
||||
WHO = {"id": 42, "이름": "갑"}
|
||||
WHERE = "구조물터파기(인력100%)|토사|m3"
|
||||
|
||||
|
||||
def _put_raw(folder, rows):
|
||||
path = folder / hs.DIRNAME / f"{hs.MEMORY}.json"
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(json.dumps({"줄": rows}, ensure_ascii=False), encoding="utf-8")
|
||||
|
||||
|
||||
def _raw(folder):
|
||||
return json.loads((folder / hs.DIRNAME / f"{hs.MEMORY}.json").read_bytes())["줄"]
|
||||
|
||||
|
||||
def test_열쇠는_맞춤과_같음():
|
||||
assert ledger.key(DIG) == hm.line_key(DIG) == DIG_KEY
|
||||
assert ledger.hopyo_key(DIG) == "호표|" + DIG_KEY
|
||||
assert ledger._loose(DIG_KEY) == "구조물터파기(인력100%)|m3"
|
||||
assert ledger._loose("호표|" + DIG_KEY) == "호표|구조물터파기(인력100%)|m3"
|
||||
|
||||
|
||||
def test_옛_꼴_바꿔_읽음(client):
|
||||
mine = layers.personal_dir(7, 42)
|
||||
_put_raw(
|
||||
mine,
|
||||
{
|
||||
DIG_KEY: {"로직": "GF000101", "입력값": {"지역": "서울"}, "환산": 2, "확정": "t1"},
|
||||
"합판거푸집|4회|m2": {"빼기": True, "확정": "2026-10-02T10:00:00"},
|
||||
"표지석||개": {"자재": "MT004258", "입력값": {}, "환산": 1, "확정": "t"},
|
||||
"깨진|줄": {"로직": "X"},
|
||||
"빈|짝|m": {"입력값": {}},
|
||||
},
|
||||
) # fmt: skip
|
||||
got = ledger.read(mine)
|
||||
assert set(got) == {DIG_KEY, "합판거푸집|4회|m2", "표지석||개"} # 모르는 꼴 뺌
|
||||
assert got[DIG_KEY] == {
|
||||
"원래": {"품명": "구조물터파기(인력100%)", "규격": "토사", "단위": "m3"},
|
||||
"때": "t1",
|
||||
"누가": None,
|
||||
"처음파일": None,
|
||||
"갈래": "짝",
|
||||
"짝": [{"로직": "GF000101", "입력값": {"지역": "서울"}, "배": 2, "몫": None}],
|
||||
}
|
||||
assert got["합판거푸집|4회|m2"]["갈래"] == "안 씀" and got["합판거푸집|4회|m2"]["짝"] == []
|
||||
assert got["표지석||개"]["짝"] == [{"자재": "MT004258", "입력값": {}, "배": 1, "몫": None}]
|
||||
|
||||
|
||||
def test_층_차례_마스터만_자동_아래_층은_제안_느슨_찾기(client):
|
||||
mine, company, system = ledger.chain(layers.personal_dir(7, 42))
|
||||
assert (company, system) == (layers.company_dir(7), store.FOLDER)
|
||||
new = {"갈래": "짝", "짝": [{"로직": "GF000103", "입력값": {}, "배": 1, "몫": None}]}
|
||||
_put_raw(system, {DIG_KEY: new, "잔토처리(인력100%)||m3": {"갈래": "우리에 없음"}})
|
||||
_put_raw(company, {DIG_KEY: {**new, "짝": [{"로직": "GF000102", "배": 1}]}})
|
||||
got = ledger.recall(DIG, mine) # 739-1 — 회사 층 짝이 있어도 자동 = 마스터(승인)
|
||||
assert (got["층"], got["주인"], got["짝"][0]["로직"], got["규격다름"], got["제안"]) == (
|
||||
"system",
|
||||
None,
|
||||
"GF000103",
|
||||
False,
|
||||
False,
|
||||
)
|
||||
_put_raw(system, {"잔토처리(인력100%)||m3": {"갈래": "우리에 없음"}})
|
||||
got = ledger.recall(DIG, mine)
|
||||
assert (got["층"], got["짝"][0]["로직"], got["제안"]) == ("company", "GF000102", True)
|
||||
_put_raw(mine, {DIG_KEY: {"로직": "GF000101", "환산": 1}})
|
||||
got = ledger.recall(DIG, mine)
|
||||
assert (got["짝"][0]["로직"], got["제안"]) == ("GF000101", True) # 제안 = 같은 층 먼저
|
||||
rock = {**DIG, "규격": "경암"}
|
||||
loose = ledger.recall(rock, mine)
|
||||
assert loose["규격다름"] is True and loose["층"] == "personal" # 품명|단위 느슨
|
||||
soil = {"이름": "잔토처리(인력100%)", "규격": "", "단위": "M3"}
|
||||
assert ledger.recall(soil, mine)["갈래"] == "우리에 없음"
|
||||
assert ledger.recall({"이름": "없는 줄", "단위": "m"}, mine) is None
|
||||
assert ledger.recall(DIG, mine, whole=True) is None # 호표 통째 열쇠는 따로
|
||||
books = ledger.books(mine)
|
||||
assert ledger.recall(DIG, mine, books)["짝"][0]["로직"] == "GF000101" # 한 번 읽어 넘김
|
||||
|
||||
|
||||
def test_재검사(client):
|
||||
def test_짝_재검사():
|
||||
known = ledger._known()
|
||||
ok = {
|
||||
"갈래": "짝",
|
||||
"짝": [{"로직": "GF000101", "입력값": {"지역": "서울"}, "배": "2", "몫": 0.5}],
|
||||
}
|
||||
got = ledger.check(DIG_KEY, ok, known)
|
||||
assert got["짝"] == [{"로직": "GF000101", "입력값": {"지역": "서울"}, "배": 2, "몫": 0.5}]
|
||||
assert got["원래"] == {"품명": "구조물터파기(인력100%)", "규격": "토사", "단위": "m3"}
|
||||
assert ledger.check(DIG_KEY, {"갈래": "안 씀"}, known)["짝"] == []
|
||||
pair = ok["짝"][0]
|
||||
pair = {"로직": "GF000101", "입력값": {"지역": "서울"}, "배": "2", "몫": 0.5}
|
||||
got = ledger.check_pair(pair, WHERE, known)
|
||||
assert got == {"로직": "GF000101", "입력값": {"지역": "서울"}, "배": 2, "몫": 0.5}
|
||||
assert ledger.times_of({}, WHERE) == (1, None)
|
||||
bad = [
|
||||
("a|b", ok),
|
||||
(DIG_KEY, {"갈래": "같음", "짝": ok["짝"]}),
|
||||
(DIG_KEY, {"갈래": "짝", "짝": []}),
|
||||
(DIG_KEY, {"갈래": "안 씀", "짝": ok["짝"]}),
|
||||
(DIG_KEY, {"갈래": "짝", "짝": [{**pair, "로직": "GC000422"}]}), # 돈 아닌 로직
|
||||
(DIG_KEY, {"갈래": "짝", "짝": [{**pair, "입력값": {"없는칸": 1}}]}),
|
||||
(DIG_KEY, {"갈래": "짝", "짝": [{**pair, "배": 0}]}),
|
||||
(DIG_KEY, {"갈래": "짝", "짝": [{**pair, "배": "nan"}]}),
|
||||
(DIG_KEY, {"갈래": "짝", "짝": [{**pair, "몫": 1.5}]}),
|
||||
(DIG_KEY, {"갈래": "짝", "짝": [{**pair, "자재": "MT004258"}]}),
|
||||
(DIG_KEY, {"갈래": "짝", "짝": [{**pair, "금액": 100}]}), # 금액 칸 받지 않음
|
||||
(DIG_KEY, {"갈래": "짝", "짝": [{"자재": "MT000000", "배": 1}]}),
|
||||
{**pair, "로직": "GC000422"}, # 돈 아닌 로직
|
||||
{**pair, "입력값": {"없는칸": 1}},
|
||||
{**pair, "배": 0},
|
||||
{**pair, "배": "nan"},
|
||||
{**pair, "몫": 1.5},
|
||||
{**pair, "자재": "MT004258"},
|
||||
{**pair, "금액": 100}, # 금액 칸 받지 않음
|
||||
{"자재": "MT000000", "배": 1},
|
||||
]
|
||||
for full, raw in bad:
|
||||
for raw in bad:
|
||||
with pytest.raises(store.StoreError) as error:
|
||||
ledger.check(full, raw, known)
|
||||
ledger.check_pair(raw, WHERE, known)
|
||||
assert error.value.status == 400, raw
|
||||
|
||||
|
||||
def test_쓰기_처음파일_옛_꼴_새로(client):
|
||||
before = master_hash()
|
||||
mine = layers.personal_dir(7, 42)
|
||||
_put_raw(mine, {"합판거푸집|4회|m2": {"빼기": True, "확정": "t"}})
|
||||
row = ledger.check(DIG_KEY, {"갈래": "짝", "짝": [{"로직": "GF000101", "배": 1}]})
|
||||
assert ledger.write(mine, {DIG_KEY: row}, WHO, "가.xls") == 1
|
||||
raw = _raw(mine)
|
||||
assert raw["합판거푸집|4회|m2"]["갈래"] == "안 씀" # 옛 꼴 = 쓸 때 새 꼴
|
||||
assert raw[DIG_KEY]["누가"] == WHO and raw[DIG_KEY]["처음파일"] == "가.xls"
|
||||
assert raw[DIG_KEY]["때"]
|
||||
ledger.write(mine, {DIG_KEY: row}, WHO, "나.xls")
|
||||
assert _raw(mine)[DIG_KEY]["처음파일"] == "가.xls" # 처음파일은 있던 값
|
||||
got = ledger.put(mine, {DIG_KEY: None}, WHO)
|
||||
assert got["씀"] == 1 and DIG_KEY not in _raw(mine)
|
||||
with pytest.raises(store.StoreError):
|
||||
ledger.put(mine, {}, WHO)
|
||||
assert master_hash() == before
|
||||
|
||||
Reference in New Issue
Block a user