Merge remote-tracking branch 'origin/dev' into sub_laptop_3

This commit is contained in:
2026-11-17 18:01:35 +09:00
79 changed files with 4981 additions and 748 deletions
+29 -3
View File
@@ -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)
+103 -61
View File
@@ -1,17 +1,20 @@
"""M02 기준 목록 · 계산서 보기(PLAN 704-1 · 704-2 · 요구서 4장 8) — 로직 고르기 창이 읽음.
"""M02 기준 목록 · 계산서 보기(PLAN 704-1 · 704-2 · 855-C 2-C4 · 요구서 4장 8) — 로직 고르기 창.
기준 목록 = 단가산출 로직 하나를 대표 규격으로 펼친 줄(품명 · 규격 · 단위 · 금액 · 출처 · 공종).
대표 규격 = 고르기 입력 값 전부 · 표 찾기 조건으로 쓰이는 수 입력은 그 표 줄마다 값 하나(범위 줄은
위 끝) · 그 밖 연속 값 입력은 견본 자동값(`master_auto.values`) 한 줄 · 지역 = 자동값(전국평균).
펼침 = 바탕(자동값 · 규격 축은 첫 대표 값) 한 줄 + 규격 축마다 값 하나씩 바꾼 줄(곱하지 않음 ·
기준 목록 = 단가산출 기초 하나를 대표 규격으로 펼친 줄(품명 · 규격 · 단위 · 금액 · 출처 · 공종).
대표 규격 = 수식 문서 선택 변수(`선택 목록`) 값 전부 · 표 조건으로 바로 쓰이는 입력 변수는
그 표 줄마다 값 하나(범위 줄은 위 끝) · 지역 = 문서 기본값(전국평균) 한 벌 ·
바탕 = 문서 변수 기본값(`연결.값`).
펼침 = 바탕(규격 축은 첫 대표 값) 한 줄 + 규격 축마다 값 하나씩 바꾼 줄(곱하지 않음 ·
바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌).
금액 = M01 엔진 식 + B09 산근 끝수(줄마다 버림 · `M02_Logic_Settle` · 근거 지식DB
`technical_info/01_임도/05_원가정보/단수처리_규칙.md`) · 최신 판 노임(마스터 판).
목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개 · 수 분) → 프로세스 메모리 + 파생 저장본
(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 내용 지문 + `SHAPE` · 같으면 안 셈 ·
금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) ·
계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판).
(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.)
목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본
(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` ·
같으면 안 셈 ·
셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸).
실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음.
계산서 = `master_text.lines`(줄 「석공 | 268,908 * 0.1 = 26,891」 · 비목 소계 · 계) + 같은 끝수 값.
이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫).
M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인).
"""
@@ -26,15 +29,18 @@ from decimal import Decimal
from typing import Any
from common_util.common_util_derived_store import derived_key, read_derived, write_derived
from M01_MasterData import M01_MasterData_Doc as m01_doc
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs
from M02_MasterTemplete import M02_Logic_Settle as settle
from M02_MasterTemplete import M02_Template_Layers as layers
mf = m01.cm.mf
import master_sheet_line as msl # noqa: E402 — 계산서 줄 덧칸(714-1) · scripts 길은 `m01` 이 둠
import master_doc as md # noqa: E402 — scripts 길은 `m01` 이 둠
import master_doc_calc as mc # noqa: E402
import master_doc_link as ml # noqa: E402
import master_doc_text as mdt # noqa: E402 — 계산서 줄 글(줄 쌓기 산출근거와 같은 규칙)
SHAPE = 3 # 줄 꼴이 바뀌면 올림 — 옛 저장본을 안 씀
SHAPE = 4 # 줄 꼴 · 셈이 바뀌면 올림 — 옛 저장본을 안 씀(4 = 855-C 문서 셈)
KIND = "m02_logic_standard"
REGION = "지역" # 지역 = 자동값 한 벌(정함 8)
QUIET = ("해당 없음", "없음") # 규격 글에서 뺄 값
@@ -95,7 +101,7 @@ def words_of(row: dict) -> list[str]:
def _range_label(table: dict, low: Any, high: Any, unit: str) -> str:
f = m01.mtx.fmt
f = mdt.eq_text
if low is None:
return f"{f(high)}{unit} 이하"
if high is None:
@@ -118,29 +124,52 @@ def _table_reps(whole: Any, ref: str, cond: str, unit: str) -> list[tuple[Any, s
continue
if not ranged:
if isinstance(have, Decimal):
out.setdefault(have, f"{m01.mtx.fmt(have)}{unit}")
out.setdefault(have, f"{mdt.eq_text(have)}{unit}")
continue
low, high = have
tries = [v for v in (high, low, (low or 0) + 1) if isinstance(v, Decimal)]
got = next((v for v in tries if m01.cm.mf._match(table, r, cond, v)), None)
got = next((v for v in tries if ml._match(table, r, cond, v)), None)
if got is not None:
out.setdefault(got, _range_label(table, low, high, unit))
return sorted(out.items())
def axes(whole: Any, logic: dict) -> tuple[dict, list[tuple[str, list[tuple[Any, str]]]]]:
"""(바탕 입력, [(입력 이름, [(값, 글) …]) …]) — 규격 축 = 지역 뺀 고르기 · 표 찾기 수 입력."""
base = m01.mau.values(whole, logic)
finds, _ = m01.mau._uses(logic)
def _default(var: dict) -> Any:
"""문서 변수 기본값(`연결.값`) — 수 글은 수로."""
value = (var.get("연결") or {}).get("값")
if isinstance(value, str) and value.strip():
num = mdt._dec(value)
return value if num is None else num
return value
def axes(whole: Any, doc: dict) -> tuple[dict, list[tuple[str, list[tuple[Any, str]]]]]:
"""(바탕 입력, [(변수 열쇠, [(값, 글) …]) …]) — 규격 축 = 지역 뺀 선택 변수(`선택 목록`) ·
표 조건으로 바로 쓰이는 입력 변수(그 표 줄마다 값 하나) · 바탕 = 문서 기본값."""
found = [
v for v in doc.get("변수") or [] if (v.get("연결") or {}).get("갈래") in ("선택", "입력")
]
base = {str(v["열쇠"]): _default(v) for v in found}
ids = {md.var_id(v): str(v["열쇠"]) for v in found}
finds: dict[str, list[tuple[str, str]]] = {}
for v in doc.get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") != "표":
continue
for cond, expr in (link.get("조건") or {}).items():
node = mdt.node_of(expr)
if node and node[0] == "var" and node[1] in ids:
finds.setdefault(ids[node[1]], []).append((str(link.get("표")), cond))
out = []
for spec in logic.get("입력") or []:
name = spec["이름"]
for var in found:
name, link = str(var["열쇠"]), var["연결"]
if name == REGION:
continue
unit = str(spec.get("단위") or "")
if spec.get("고르기"):
unit = str(var.get("단위") or "")
if link["갈래"] == "선택":
spec = {"이름": name, "고르기": link.get("목록") or []}
labels = labor_inputs._labels(whole, spec)
reps = [(v, str(labels.get(v, m01.mtx.fmt(v) if isinstance(v, Decimal) else v)))
reps = [(v, str(labels.get(v, mdt.eq_text(v) if isinstance(v, Decimal) else v)))
for v in spec["고르기"]] # fmt: skip
elif name in finds:
seen: dict[Any, str] = {}
@@ -172,18 +201,34 @@ def _unit(logic: dict) -> str:
return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit)
def _money(whole: Any, logic: dict, given: dict) -> Decimal | None:
if not str(logic.get("결과단위") or "").startswith("원"):
return None
def _links(whole: Any) -> Any:
return ml.Links(whole, m01_doc.docs())
def _calc(doc: dict, links: Any, given: dict) -> dict | None:
try:
got = settle.settle(whole, str(logic["키"]), m01.cm.mf.fill_empty(logic, given))
except (m01.cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError):
got = mc.calc(doc, links, given)
except Exception: # noqa: BLE001 — 계산기는 예외 없음이 원칙 · 혹시 = 못 셈
return None
return got.get("계", got.get("결과"))
return got if got.get("셈됨") else None
def _rows_of(whole: Any, logic: dict, blocked: bool) -> list[dict]:
base, ax = axes(whole, logic)
def _money(doc: dict, links: Any, given: dict) -> Decimal | None:
"""돈 기초(결과단위 「원…」)의 계(돈 아닌 결과 문서 = 결과) — 못 셈 = None."""
if not str(doc.get("결과단위") or "").startswith("원"):
return None
got = _calc(doc, links, given)
if got is None:
return None
return got.get("계") if got.get("계") is not None else got.get("결과")
def _rows_of(whole: Any, logic: dict, blocked: bool, links: Any = None) -> list[dict]:
doc = m01_doc.docs().get(str(logic.get("키")))
if doc is None:
return []
links = links or _links(whole)
base, ax = axes(whole, doc)
changes: list[dict] = [{}]
for name, reps in ax:
changes += [{name: v} for v, _ in reps if v != base.get(name)]
@@ -201,7 +246,7 @@ def _rows_of(whole: Any, logic: dict, blocked: bool) -> list[dict]:
out = []
for change in changes:
given = {**base, **change}
money = _money(whole, logic, given)
money = _money(doc, links, given)
if change and money == 0: # 표에 없는 규격 조합(견치돌 · 뒷길이 25 따위) — 0 원 줄은 뺌
continue
out.append(
@@ -231,15 +276,19 @@ def _stamp() -> str:
if not name.startswith("_"):
sha.update(name.encode())
sha.update(hashlib.sha1(m01.cm.mmf.raw(m01.FOLDER, name)).digest())
for path in sorted(m01_doc.folder().glob("수식_*.json")): # 수식 문서(855-C · 셈 정본)
sha.update(path.name.encode())
sha.update(hashlib.sha1(path.read_bytes()).digest())
return sha.hexdigest()
def _chunk(keys: list[str], blocked: set[str]) -> list[dict]:
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음)."""
whole = m01.loaded()[1]
links = _links(whole)
out = []
for key in keys:
out += _rows_of(whole, whole.logic(key), key in blocked)
out += _rows_of(whole, whole.logic(key), key in blocked, links)
return out
@@ -268,23 +317,25 @@ def _make(files: dict, whole: Any, key: str) -> None:
value = build(files, WORKERS)
write_derived(layers.storage_root(), KIND, key, value)
with _LOCK:
if _MEMO.get("whole") is whole:
if _MEMO.get("key") == key:
_MEMO.update(value=value)
except Exception as e: # noqa: BLE001 — 다음 요청이 다시 셈
print(f"[M02 기준 목록] 셈 실패: {e}", file=sys.stderr)
finally:
with _LOCK:
if _MEMO.get("whole") is whole:
if _MEMO.get("key") == key:
_MEMO["job"] = None
def listing() -> dict:
"""기준 목록 `{판, 공종, 줄, 준비}` — 메모리 → 파생 저장본 → 뒤에서 셈(그동안 빈 줄)."""
files, whole = m01.loaded()
docs = m01_doc.docs() # 수식 문서를 고치면 새 묶음(같은 내용이면 같은 묶음)
with _LOCK:
if _MEMO.get("whole") is not whole:
if _MEMO.get("whole") is not whole or _MEMO.get("docs") is not docs:
_MEMO.clear()
_MEMO.update(whole=whole, key=derived_key(KIND, SHAPE, _stamp()), value=None, job=None)
key = derived_key(KIND, SHAPE, _stamp())
_MEMO.update(whole=whole, docs=docs, key=key, value=None, job=None)
if _MEMO["value"] is None and _MEMO["job"] is None:
got = read_derived(layers.storage_root(), KIND, _MEMO["key"])
if got:
@@ -312,8 +363,8 @@ def _quiet(fn) -> None:
print(f"[M02 기준 목록] 데움 실패: {e}", file=sys.stderr)
def _given(whole: Any, logic: dict, change: dict) -> tuple[dict, list]:
base, ax = axes(whole, logic)
def _given(whole: Any, doc: dict, change: dict) -> tuple[dict, list]:
base, ax = axes(whole, doc)
known = {name: dict(reps) for name, reps in ax}
for name, value in (change or {}).items():
if name not in known:
@@ -326,28 +377,19 @@ def _given(whole: Any, logic: dict, change: dict) -> tuple[dict, list]:
def sheet(key: str, change: dict) -> dict:
"""계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(엔진 값)."""
"""계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(문서 셈)."""
files, whole = m01.loaded()
doc = m01_doc.docs().get(key)
try:
logic = whole.logic(key)
except m01.cm.mf.FormulaError as e:
raise m01.StoreError(404, str(e)) from e
given, ax = _given(whole, logic, change)
filled = m01.cm.mf.fill_empty(logic, given)
got = msl.annotate(files, key, filled, m01.mtx.lines(files, key, filled)) # 줄 덧칸(714-1)
done = settle.settle(whole, key, filled)
if "결과" not in done: # 돈 로직 — 줄마다 버림(B09 산근 규칙)
settle.apply(got.get("groups") or [], m01.cm.mf.run(whole, key, filled), done)
got["계"] = done["계"]
groups = [
{
"비목": g["비목"],
"소계": g.get("소계"),
"끝수": g.get("끝수") or "",
"줄": [{k: line.get(k) for k in ("이름", "글", "금액", *msl.KEYS)} for line in g["줄"]],
}
for g in got.get("groups") or []
]
if doc is None:
raise m01.StoreError(404, f"수식 문서 없음 「{key}」")
given, ax = _given(whole, doc, change)
links = _links(whole)
got = _calc(doc, links, given) or {}
money = str(doc.get("결과단위") or "").startswith("원") and "결과" not in doc
return labor_inputs._num(
{
"키": key,
@@ -357,8 +399,8 @@ def sheet(key: str, change: dict) -> dict:
"출처": labor_inputs.sources(logic) or "",
"판": edition(files),
"입력": given,
"묶음": groups,
"계": got.get("계"),
"기준단위": got.get("기준단위"),
"묶음": mdt.sheet_groups(doc, got, links) if got and money else [],
"계": got.get("계") if money else got.get("결과"),
"기준단위": _unit(logic) or None,
}
)
+32 -51
View File
@@ -8,7 +8,7 @@
기계표 = M01 + 지금 층 내 기계(821-1 · `M02_MyMachine` — 식은 채운 칸으로 고른 같은 GC 식 · 직접 = 그 값) ·
층을 모르는 길(`/api/m02/logic-lib/machine-hourly`)은 M01 만.
셈 한 길(842-3) = 식 문서 계산기(`master_doc_calc` · 기계 줄 인력 · 잡품 목록을 바탕 덮음으로 얹음 —
`master_doc_cover.row_entry`) · 식 문서 없는 식만 옛 로직 엔진 · 조종원 유무 = 인력 줄(`master_machine_crew.view`).
`master_doc_cover.row_entry`) · 식 문서 없는 식 = 못 셈 + 까닭(855 2-B2 · 옛 엔진 폴백 걷음) · 조종원 유무 = 인력 줄(`master_machine_crew.view`).
식 고름 한 곳(822-2 · `pick`) = ㉠ 원문번호가 식 「기계」 목록에 있으면 그 식(짝 차례) ㉡ 그 기계만의 식
(`_own`) ㉢ 없으면 꼴(채운 칸 · `M02_MyMachine.logic_key`) — M01 [새 기계] · 불러오기 · 데이터 흐름 ·
줄 쌓기 · 단가산출 기초가 다 이것을 씀 · 못 고름 · 값 모자람 = 까닭 글(`why`).
@@ -183,39 +183,22 @@ def hourly(key: str) -> dict[str, Any]:
logic = pick(row)
if lack := why(row, logic):
return {"ok": False, "reason": lack, **({"로직": logic["키"]} if logic else {})}
args = "".join( # 빈칸 든 입력 이름(「전력 계약종별」 · 820-1 파워트로웰)은 따옴표로
f", {n if (n := i['이름']).isidentifier() else repr(n)}='{(i.get('고르기') or [''])[0]}'"
for i in logic.get("입력") or []
if i.get("이름") != "기계"
)
if (got := doc_sums(row, logic, whole)) is not None:
return got if not got["ok"] else {"ok": True, "이름": row.get("이름"), "규격": row.get("규격"),
"로직": logic["키"], "원문번호": code, **got["합"]} # fmt: skip
mine = f", 기계='{code}'" if takes_machine(logic) else ""
call = f"로직({logic['키']}{mine}{args})"
line = {"종류": "로직", "요소": call, "이름": "기계", "단위": "시간", "수량": "1"}
holder = {
"키": "", "원문번호": "", "이름": "기계 시간", "결과단위": "원/식", "출처": "자체",
"입력": [], "중간": [], "호표": [line], "덧줄": [], "끝수": None,
} # fmt: skip
got = store.calc("", {}, holder, None)
if not got.get("ok") or "sums" not in got:
return {"ok": False, "reason": got.get("reason") or "셈 못 함"}
sums = {k: float(got["sums"][k]) for k in (*cm.mf.COST_ITEMS, "계")}
# 804-3 줄 쌓기 기계 줄 = 이 로직 + 기계='원문번호'
return {
"ok": True,
"이름": row.get("이름"),
"규격": row.get("규격"),
"로직": logic["키"],
"원문번호": code,
**sums,
}
got = hour(row, logic, whole) # 804-3 줄 쌓기 기계 줄 = 이 로직 + 기계='원문번호'
if not got["ok"]:
return got
return {"ok": True, "이름": row.get("이름"), "규격": row.get("규격"), "원문번호": code, **got}
def hour(row: dict, logic: dict, index: Any) -> dict[str, Any]:
"""시간당 한 몸(`hourly` · `brief` · `M02_MyMachine.hourly`) — {ok, 로직, 노무비 · 재료비 · 경비 · 계} |
{ok False, reason, 로직}."""
got = doc_sums(row, logic, index)
return {"ok": True, "로직": logic["키"], **got["합"]} if got["ok"] else got
def doc_sums(row: dict, logic: dict, index: Any) -> dict | None:
"""셈 한 길(842-3) — 식 문서 계산기 + 기계 줄 목록(바탕 덮음) · 입력 = 식 기본값 ·
{ok, 합 {노무비 · 재료비 · 경비 · 계}} | {ok False, reason} · 식 문서 없음 = None(옛 로직 엔진)."""
{ok, 합 {노무비 · 재료비 · 경비 · 계}} | {ok False, reason, 로직} · 식 문서 없음 = 못 셈(855 2-B2)."""
import master_doc_calc as mc
import master_doc_cover as mcv
import master_doc_link as ml
@@ -224,8 +207,12 @@ def doc_sums(row: dict, logic: dict, index: Any) -> dict | None:
docs = m01doc.docs()
doc = docs.get(str(logic.get("키")))
if doc is None:
return None
if doc is None: # 854-2 이후 수식 문서 없는 로직 0 — 옛 엔진 폴백 없음
return {
"ok": False,
"reason": f"식 문서 없음 — 「{logic.get('키')}」",
"로직": logic.get("키"),
}
given = {"기계": str(row.get("원문번호"))} if takes_machine(logic) else {}
shaped = mcv.cover_doc(doc, given, None, mcv.row_entry(doc, row.get("값")))
got = mc.calc(shaped, ml.Links(index, docs), given)
@@ -235,22 +222,26 @@ 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]]:
"""기계 창 목록 · 양식(827-1) — M01 기계 줄 값 + 시간당(`hourly` 와 같은 식 · 입력 기본값 ·
마스터를 다시 읽지 않고 색인 위에서 셈 · 색인마다 메모) · 키 · 원문번호로 찾음 · 없는 키 = 뺌."""
import master_cut as mcut
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:
@@ -259,20 +250,10 @@ def brief(keys: list[str]) -> list[dict[str, Any]]:
continue
logic = pick(row)
head = {k: row.get(k) for k in ("키", "원문번호", "이름", "규격")}
if lack := why(row, logic):
hour = {"ok": False, "reason": lack}
elif (by_doc := doc_sums(row, logic, index)) is not None:
hour = {"ok": True, "로직": logic["키"], **by_doc["합"]} if by_doc["ok"] else by_doc
else:
given = {i["이름"]: (i.get("고르기") or [""])[0] for i in logic.get("입력") or []}
if takes_machine(logic):
given["기계"] = str(row.get("원문번호"))
sums = mcut.engine(
index, logic["키"], mf.run(index, logic["키"], mf.fill_empty(logic, given))
)
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}
lack = why(row, logic)
hours = {"ok": False, "reason": lack} if lack else hour(row, logic, index)
got = {**head, "값": to_json(row.get("값")), "시간당": hours}
_BRIEF[key] = (index, got)
out.append(got)
return out
@@ -24,57 +24,6 @@
white-space: pre-wrap;
}
.m02-hopyo__search {
max-width: 320px;
}
/* 실무자료 표 — 한글은 낱말 단위로만 줄바꿈(두세 글자마다 안 갈라짐) · 너무 긴 낱말만 쪼갬 */
.m02-hopyo__table :is(th, td) {
word-break: keep-all;
overflow-wrap: break-word;
}
/* 우리 로직 칸 — 대상 여럿 = 칸 안 여러 줄(이름 · 키 · 몫 · 배 칸 · [옵션]) */
.m02-hopyo__parts {
min-width: 11em;
}
.m02-hopyo__part {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: var(--spacing-4);
}
.m02-hopyo__part + .m02-hopyo__part {
margin-top: var(--spacing-4);
}
.m02-hopyo__times {
width: 6em;
}
.m02-hopyo__unit {
display: inline-flex;
align-items: center;
gap: var(--spacing-4);
}
/* 단위 환산 칸 앞뒤 글 — 「엑셀 1 ㎡ = 우리 [ ] 본」 */
.m02-hopyo__unit-text {
color: var(--color-text-secondary);
font-size: var(--text-sm);
white-space: nowrap;
}
.m02-hopyo__acts {
white-space: nowrap;
}
.m02-hopyo__acts > button + button {
margin-left: var(--spacing-4);
}
/* 엑셀 보기(329) — 왼쪽 읽기 전용 시트 · 오른쪽 호표 목록 */
.m02-hopyo-sheet {
display: grid;
@@ -65,7 +65,6 @@ export function gridOf(id: string, scope: HopyoScope, key: string): Promise<Hopy
got.catch(() => kept?.got === got && (kept = null));
return got;
}
export const dropGrid = (): void => void (kept = null);
/** 역할 시트 탭 글 통일 — 역할 → 시트 id */
export function nameTabs(book: Workbook, grid: HopyoGrid): Partial<Record<Role, string>> {
@@ -48,7 +48,6 @@ export function buildHopyoSection(opt: HopyoSectionOptions): HopyoSection {
start.classList.add("m02-layers__btn");
start.title =
"파일 하나 — 경쟁사 엑셀(.xls · .xlsx) 또는 경쟁사 파일(.estx · .STC) → 우리 정보로 다시 만듦(한시 · 끝내거나 떠나면 올린 파일 지움)";
start.dataset.hopyoWizardOpen = "";
const jobs = el("div", { className: "m02-hopyo-side", attrs: { "data-hopyo-jobs": "" } });
const body = el("div", {
className: "m02-hopyo-side",
@@ -10,7 +10,7 @@ import { currentLanguageIndex } from "@ui/ui_template_locale";
import { wheelZoomsIn } from "../A00_Common/touch_bridge";
import { guardMenuAfterDrag, isAuxPanButton } from "../A00_Common/input_prefs";
import { createButton, el } from "@ui/ui_template_elements";
import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money";
import { formatMoney } from "../common_util/common_util_money";
import "./M02_MasterTemplete_Labor_Diagram.css";
import { createEmpty } from "@ui/ui_template_empty";
@@ -9,7 +9,7 @@
* ========================================================================== */
import { createButton, el } from "@ui/ui_template_elements";
import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money";
import { formatMoney } from "../common_util/common_util_money";
import { openPickTable } from "../M01_MasterData/M01_MasterData_UI_Logic_PickTable";
import { headWord } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Modal";
import type { LaborCalc, LaborRow, MatMarkKey } from "./M02_MasterTemplete_Labor_Api";
@@ -6,7 +6,7 @@
* ========================================================================== */
import { createButton, el } from "@ui/ui_template_elements";
import { formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money";
import { formatMoney } from "../common_util/common_util_money";
import type {
LaborCalc,
LaborCalcLine,
@@ -15,7 +15,7 @@
import { createButton, createSelectField, el } from "@ui/ui_template_elements";
import { HOPYO_TAG } from "@ui/ui_template_hopyo_grid";
import { pctView } from "../M01_MasterData/M01_MasterData_UI_Logic_Api";
import { formatLineMoney, formatMoney } from "../M01_MasterData/M01_MasterData_UI_Logic_Money";
import { formatLineMoney, formatMoney } from "../common_util/common_util_money";
import type { ItemLogic } from "./M02_MasterTemplete_Api_Fetch";
import type {
LaborCalc,
+11 -9
View File
@@ -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
+58 -37
View File
@@ -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)
@@ -227,28 +254,14 @@ def hourly(row: dict, index: Any) -> dict[str, Any]:
**sums,
"계": sum(sums.values()),
}
import master_cut as mcut
mf = m01.cm.mf
key = logic_key(row)
if key is None:
return {"ok": False, **head, "reason": "식 없음 — 조종원직종 없음"}
logic = index.logic(key)
from M02_MasterTemplete import M02_Machine_Hourly as mh # 셈 한 길(842-3)
from M02_MasterTemplete import M02_Machine_Hourly as mh # 셈 한 길(842-3 · 855 2-B2)
if (by_doc := mh.doc_sums(row, logic, index)) is not None:
got = by_doc.get("합") or {"reason": by_doc.get("reason")}
return {"ok": by_doc["ok"], **head, "로직": logic["키"], **got}
given = {i["이름"]: (i.get("고르기") or [""])[0] for i in logic.get("입력") or []}
given["기계"] = str(row.get("원문번호"))
try:
got = mcut.engine(
index, logic["키"], mf.run(index, logic["키"], mf.fill_empty(logic, given))
)
except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e:
return {"ok": False, "reason": str(e) or type(e).__name__}
sums = {k: float(got[k]) for k in (*COSTS, "계")}
return {"ok": True, **head, "로직": logic["키"], **sums}
got = mh.hour(row, logic, index)
return {"ok": got["ok"], **head, **got}
# ── 검사 ──────────────────────────────────────────────────────────────
@@ -420,9 +433,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 +443,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 +529,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["키"]),
}
+4 -1
View File
@@ -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 {
+10 -6
View File
@@ -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:
+6 -4
View File
@@ -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;
}
+5 -16
View File
@@ -2,8 +2,9 @@
GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) ·
POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) ·
PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}.
PUT `/{키}` 몸 {줄, 판?}(판 = 연 판 · 다르면 409 {stale, 판} · 854-1) ·
POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
옛 POST `/draft`(기계 창 [확인] · 화면 0)은 853-3 에서 지움 — 확인 셈 `M02_MyMachine_Draft.check` 는 시험 827-1 기준값으로 남김.
권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404).
⚠ 등록은 `main.py`(로그인만).
"""
@@ -17,7 +18,6 @@ from pydantic import BaseModel
from common_util.common_util_auth import verify_session
from M02_MasterTemplete import M02_MyMachine as mym
from M02_MasterTemplete import M02_MyMachine_Draft as draft
from M02_MasterTemplete import M02_MyMachine_Impact as impact
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Session, _call, _root
@@ -28,8 +28,7 @@ PATH = "/layers/{layer}/my-machines"
class MachineBody(BaseModel):
줄: dict[str, Any] | None = None
본뜬: 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):
@@ -43,16 +42,6 @@ def my_machines(layer: str, owner: str | None = None, session: Session = Depends
return _call(_folder(session, layer, owner), mym.listing)
@router.post(PATH + "/draft")
def my_machine_draft(
layer: str,
body: MachineBody,
owner: str | None = None,
session: Session = Depends(verify_session),
):
return _call(_folder(session, layer, owner, True), draft.check, body.model_dump())
@router.get(PATH + "/{key}")
def my_machine(
layer: str, key: str, owner: str | None = None, session: Session = Depends(verify_session)
@@ -78,7 +67,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")
+1
View File
@@ -28,6 +28,7 @@ const TEXT = {
Back: "목록",
Close: "닫기",
Failed: "못 함",
Stale: "그 사이 다른 곳에서 바뀜 — 목록에서 다시 열어 고침",
Name_Needed: "이름 · 비어 있음",
Same: "같은 이름 · 규격 있음 — {value}",
Copied: "「{value}」 값을 복사 — 고친 뒤 [저장]",
-56
View File
@@ -152,14 +152,6 @@ def flat(s: Any) -> str:
return re.sub(r"\s+", "", str(s or ""))
def _hcol(rows: list[list[Any]], word: str, start: int = 2) -> int | None:
for r in rows[start : start + 2]:
for j, v in enumerate(r):
if flat(v) == word:
return j
return None
def _n(v: Any) -> float | None:
if isinstance(v, (int, float)):
return float(v)
@@ -192,51 +184,3 @@ def applied_how(r: list[Any]) -> tuple[dict[str, float], str | None]:
return got, None # 쓸 값이 없음 — 표지할 것 없음
why = "적용 칸 합이 안 맞음" if a["T"] else "적용 칸 비어 있음"
return got, f"당초 칸 사용 — {why}" + (f" ({gap})" if gap else "")
def applied(r: list[Any]) -> dict[str, float]:
return applied_how(r)[0]
def est_prices(book: dict[str, list]) -> tuple[list[dict[str, Any]], dict[int, dict[str, Any]]]:
"""→ (단가 목록 [{종류, 이름, 규격, 비목, 값}], 산근 총괄 {번: {T, L, M, S, 이름, 규격}})."""
out: list[dict[str, Any]] = []
lab = book.get("노임단가", [])
c = _hcol(lab, "적용단가")
for r in lab[3:]:
if c is not None and len(r) > c and r[2] and isinstance(r[c], (int, float)):
out.append(
{"종류": "노임", "이름": flat(r[2]), "규격": "", "비목": "L", "값": float(r[c])}
)
mat = book.get("자재단가", [])
c = _hcol(mat, "적용단가")
for r in mat[4:]:
if c is not None and len(r) > c and r[2] and isinstance(r[c], (int, float)):
out.append(
{
"종류": "자재",
"이름": flat(r[2]),
"규격": flat(r[3]),
"비목": "M",
"값": float(r[c]),
}
)
for sheet, kind in (("기계경비총괄표", "기계"), ("견적단가", "견적")):
for r in book.get(sheet, [])[3:]:
if len(r) > 28 and r[2]:
for k, v in applied(r).items():
if isinstance(v, (int, float)) and (v or k != "T"):
one = {"종류": kind, "이름": flat(r[2]), "규격": flat(r[3])}
out.append({**one, "비목": k, "값": float(v or 0)})
san: dict[int, dict[str, Any]] = {}
for r in book.get("단가산출총괄표", [])[3:]:
if len(r) > 28 and str(r[1]).strip().isdigit():
n = int(str(r[1]).strip())
got, note = applied_how(r)
san[n] = {k: float(v or 0) for k, v in got.items()}
san[n] |= {"이름": flat(r[2]), "규격": flat(r[3]), "칸": note}
for k in "TLMS":
if san[n][k] or k != "T":
one = {"종류": "산근", "이름": f"단산{n}", "규격": ""}
out.append({**one, "비목": k, "값": san[n][k]})
return out, san
-6
View File
@@ -139,12 +139,6 @@ def chosen(item: dict) -> dict | None:
return got if got and not _apart(res) else None
def item_key(res: dict) -> str | None:
"""줄 품목 키 — 고름 › 엔진 이음."""
found = res.get("재료찾기") or {}
return (found.get("고름") or {}).get("키") or found.get("키")
def apart_note(found: dict) -> str:
"""별도계상 줄 설명 — 품목이 있으면 「별도계상 · 품목: 이름 규격」."""
from M02_MasterTemplete import M02_San_Link as link
-7
View File
@@ -182,10 +182,3 @@ def parse_line(g: str | None) -> dict[str, Any]:
if refs:
return {**head, **_ref_line(st, refs[0])}
return {**head, **_assign_line(st)}
def parse_block(lines: list[dict[str, Any]]) -> list[dict[str, Any]]:
"""[{행, G}] → 줄 나무 목록(행 · 원문 붙임)."""
return [
{"행": ln.get("행"), "글": ln.get("G") or "", **parse_line(ln.get("G"))} for ln in lines
]
+1 -1
View File
@@ -122,7 +122,7 @@ def _table(rows: list[list[Any]], price: tuple[str, ...]) -> list[dict[str, Any]
def resources(sheets: dict[str, list]) -> dict[str, list[dict[str, Any]]]:
"""같은 책 단가표 → {종류: [{번 · 이름 · 규격 · 단위 · 표 · 값 {T L M S}}]}(노임 · 자재 = 적용단가 ·
기계 · 견적 · 산근 = 적용 칸(합이 안 맞으면 당초 · `M02_San_Book.applied`))."""
기계 · 견적 · 산근 = 적용 칸(합이 안 맞으면 당초 · `M02_San_Book.applied_how`))."""
out: dict[str, list[dict[str, Any]]] = {}
for kind, sheet, comp in (("노임", "노임단가", "L"), ("자재", "자재단가", "M")):
rows = sheets.get(sheet) or []
+2 -1
View File
@@ -561,7 +561,8 @@ def create(
new: bool = False, use: str | None = None,
) -> dict[str, Any]: # fmt: skip
"""엔진 로직 줄 + 원본 → 지금 층 새 가져온 식 SK — 서버가 다시 셈해 엑셀과 맞댐(검산 ·
다르면 `같음` False 로 표지 · 막지 않음) · 같은 층 같은 내용 = 409(`ask` · 733-2)."""
다르면 `같음` False 로 표지 · 막지 않음) · 같은 층 같은 내용 = 409(`ask` · 733-2) ·
서버 길(POST sangeun/imported)은 853-3 에서 걷음 — 시험이 가져온 식 SK 바탕으로 씀."""
return keep(new_doc(logic, source, name, unit, head), new, use)
+1 -26
View File
@@ -1,6 +1,6 @@
"""M02 단가산출(SK) 셈 길(PLAN 715-1b) — `POST /api/m02/layers/{층}/sangeun/calc` ·
일위대가 [+ 줄] M01 기초 = 그 층 SK 사본(811-1 · `M02_Labor_SkRow`) `…/sangeun/from-logic`(층 쓰기) ·
가져온 식(793-2 · `M02_Sangeun_Imported`) `…/sangeun/imported`(만들기 · 층 쓰기) · `/price` ·
가져온 식(793-2 · `M02_Sangeun_Imported`) `…/sangeun/imported/price` ·
`/link`(화면 캐시 문서 고침 · 저장 없음 · 층 읽기 · 기초로 바꾸기 없음 · 809-1) ·
불러오기 단산 블록 → 가져온 식(793-3b · `M02_Sangeun_FromHopyo`) `…/sangeun/from-hopyo`
(늘 개인 층 쓰기 · 몸 `문서` = 미리 보기에서 고친 문서) · 미리 보기 `…/from-hopyo/preview`(층 읽기 · 안 씀 · 835-1).
@@ -81,31 +81,6 @@ def calc_sangeun(
return _call(_root(session, layer, owner), _calc, body)
class ImportedBody(BaseModel):
로직: dict[str, Any]
원본: dict[str, Any] | None = None
이름: str = ""
단위: str = ""
구분: str = ""
상세구분: str = ""
새로: bool = False
씀: str | None = None
@router.post("/layers/{layer}/sangeun/imported")
def sangeun_imported(
layer: Layer,
body: ImportedBody,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""가져온 식 단가산출 만들기(793-2) — 답 = {이름, 검산, 단가기준} · 같은 내용 409."""
folder = _root(session, layer, owner, write=True)
head = {"구분": body.구분, "상세구분": body.상세구분}
args = (body.로직, body.원본, body.이름, body.단위, head, body.새로, body.씀)
return _call(folder, _sd(imp.create), *args)
class FromHopyoBody(BaseModel):
층: Layer
주인: str | None = None
@@ -1,61 +0,0 @@
/* =============================================================================
* M02_MasterTemplete_Hopyo_Unit.ts — 확인 창 대상 이름 옆 「단위 환산」 칸의 보이기 판정(PLAN 784-2 · 요구 635-2).
* 순수 계산(화면 · fetch 없음) — 숨김 조건 · 두 단위 글 재료 · 추정 두께.
* · same = 배 1 · 단위 같음(서버 갈래 같음 · 두 단위 · 단위표 1) → 칸 숨김 · 「단위 같음 ×1」
* · quota = 배가 몫(0.1)과 같음 → 칸 숨김 · 「몫 0.1」 만
* · input = 빈칸 · 추정 · 그 밖 → 입력 칸 「엑셀 1 ㎡ = 우리 [ ] 본」
* 값 자체(배)는 안 바꿈 — 서버 `Match.factor` 가 낸 배 · 갈래를 보이기만 다르게.
* ========================================================================== */
export interface UnitPart {
배: number | null;
몫?: number | null;
환산?: { 배: number | null; 갈래: string } | null;
단위?: string | null;
}
export type UnitMode = "same" | "quota" | "input";
export interface UnitView {
mode: UnitMode;
/** 엑셀 단위 · 우리 단위(빈 글 = 모름) */
from: string;
to: string;
/** 추정 갈래 — 두께 m(㎡ → ㎥ 일 때만 · 아니면 null) */
thick: number | null;
estimated: boolean;
}
const plain = (u: string | null | undefined): string =>
String(u ?? "")
.replace(/\s+/g, "")
.replace("㎡", "m2")
.replace("㎥", "m3")
.toLowerCase();
const close = (a: number, b: number): boolean => Math.abs(a - b) < 1e-9;
export function unitView(
p: UnitPart,
from: string | null | undefined,
to?: string | null,
): UnitView {
const f = String(from ?? "").trim();
const t = String(to ?? p.단위 ?? "").trim();
const quota = p.몫 != null && p.몫 !== 1; // 몫 1 = 몫 없음과 같음
const kind = p.환산?.갈래;
const unitSame = kind
? kind === "같음" || kind === "두 단위" || (kind === "단위표" && p.환산?.배 === 1)
: plain(f) !== "" && plain(f) === plain(t);
const at = quota ? (p.몫 as number) : 1;
const hidden = p.배 !== null && close(p.배, at) && unitSame;
const estimated = kind === "추정";
const thick =
estimated && plain(f) === "m2" && plain(t) === "m3" && p.환산?.배 != null ? p.환산.배 : null;
return {
mode: hidden ? (quota ? "quota" : "same") : "input",
from: f,
to: t,
thick,
estimated,
};
}