Merge remote-tracking branches 'origin/main_laptop_1' and 'origin/sub_laptop_7' into sub_laptop_4
This commit is contained in:
@@ -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,
|
||||
}
|
||||
)
|
||||
|
||||
@@ -0,0 +1,221 @@
|
||||
# 설계 858 — 걸음 5 「서고 한 벌」
|
||||
|
||||
요구 896 · 898 · 899 · 2026-11-17 · sub4 · 읽기만(코드 · 자료 · 시험 안 고침). 근거 = `파일:줄`(sub_laptop_4 · 커밋 962476e69). 세기 도구 · 결과 = `tmp/s894/m858/`(끝 절).
|
||||
|
||||
## 0. 한눈 요약
|
||||
|
||||
- 층 서고 종류 아홉 가운데 **단가산출 · 일위대가 둘만 한 틀**(`Store.write` + `Library_*` + `Precombo_Folders`). 구조물 조합 · 표 · 도면은 같은 `Store.write` 를 쓰나 목록 · 나무 · 번호가 따로. 내 기계 · 내 재료 · 실무자료 · 재료 고름 · 공유 요청은 저장 · 번호 · 목록 · 쓰는 곳 찾기를 **각자** 가짐.
|
||||
- 같은 일 여러 벌(지금 자리 확인): 층 폴더 찾기 **5**(진짜 몸 2) · 폴더 → 층 판정 **4** · 쓰는 곳 찾기 **10**(서고 참조 4 + 자원 키 6) · 쓰기 권한 판단 **3**(+ TS 짝 1) · 파일 판 `version_of` **M02 3**(+ M01 2) · 쓰기 잠금 **4 벌** + **잠금 없는 여러 파일 쓰기 5 곳** · 번호 체계 **7 갈래** · 목록 **8**.
|
||||
- 제안 = **새 틀을 만들지 않고 가장 잘 된 것을 넓힘**: 종류 표 하나(`Template_Layers` 안 · 옵션 칸) + 부품 일곱(층 폴더 · 권한 · 판 · 여러 파일 쓰기 · 번호 장부 · 쓰는 곳 색인 · 저장). 새 파일 = 지킴 시험 1 · 쓰는 곳 색인 1(`Labor_Ref` 700 줄 경계 때문에 떼어 냄) 뿐.
|
||||
- 걸음 = 5-0 지킴 → 5-1 · 5-2 · 5-3(셋 병행) → 5-4 → 5-5 → 5-6 → 5-7(공유 · 판단 뒤) → 5-8 옛 코드 지움. 어림 **서버 +250 / −450 줄**.
|
||||
- **지금 바로 시작해도 되는 조각** = 5-0 · 5-1 · 5-3(855 남은 걸음 · 856 · 857 과 파일 안 겹침). 실무자료 · 재료 고름은 **857 과 같이**.
|
||||
|
||||
## 1. 지금 모습
|
||||
|
||||
### 1-1 종류 · 자리 · 서버 길
|
||||
|
||||
| 종류 | 저장 자리(층 폴더 안) | 층 | 서버 길(묶음) |
|
||||
| --- | --- | --- | --- |
|
||||
| 단가산출 SK | `sangeun/SK-######.json` + 뿌리 `sangeun_폴더.json` · `_번호.json` | 마스터 · 회사 · 개인 · 프로젝트(굳힘) | `/layers/{층}/library/{kind}` · `{kind}-tree(/paste)` · `{kind}-same(/merge /undo)` · `-tree/delete-check` · `-flat` · `-reset` · `templates/sangeun/{키}` · `sangeun/{키}/doc/*` |
|
||||
| 일위대가 SC | `precombo/SC-######.json` + `precombo_폴더.json` | 같음 | 같음(종류 인자) |
|
||||
| 구조물 조합(항목 · 열) | `table/구조물집계표.json`(열 · 경로 = 나무) + 뿌리 `구조물집계표조합.json`(장부) + `structure/ area/ labor/<열id>.json` | 같음 | `/items` · `/layers/{층}/tree` · `items/paste` · `personal/items/copy` · `structures/*` · `area/*` · `{kind}/{column}/clear·copy` |
|
||||
| 구조물 표 · 도면 틀(양식) | `table/*.json` · `drawing/*.json` | 같음 + 프로젝트 `_initial/` | `/layers/{층}/templates(/{kind}/{name})` GET · PUT · DELETE |
|
||||
| 내 기계 | `내기계/EQP{사용자}-####.json` + `내기계/_다음.json` | 개인만 | `/layers/personal/my-machines(/{키})` · `/{키}/impact` · `my-machine-lists · -find` · `machine-sheet` |
|
||||
| 내 재료 | 뿌리 `개인자재.json`(한 파일 묶음 `{그룹, 원문, 줄, 마지막}`) | 개인만 | `/layers/{층}/materials(/{키})`(**`Labor_Router` 안** · 이름 안 맞음) |
|
||||
| 실무자료(불러온 것) | `실무자료/HP-######.json` · `격자/` · `산근/` · `불러옴.json{번}` | 개인만 · 하루 지나면 숨김 | `/layers/{층}/hopyo*`(층 글 무시 · 늘 개인) |
|
||||
| 재료 고름 | `실무자료/재료고름/<파일 지문>.json` | 개인만 | `/layers/{층}/material-picks/{fp}` |
|
||||
| 공유 요청 | 회사 층 뿌리 `올리기요청.json{줄}` | 회사 | `/share-requests(/{id}/approve·reject · /seen)` |
|
||||
|
||||
서버 길 수(자기 포트 `openapi.json` 읽기 · `routes.tsv`): M02 108 가운데 단가산출 · 일위대가 28 · 구조물 조합 · 표 · 도면 12 · 내 기계 9 · 내 재료 5 · 불러오기 15 · 공유 5.
|
||||
|
||||
### 1-2 일마다 하는 자리 — 저장 쪽
|
||||
|
||||
| 종류 | 층 폴더 찾기 | 목록 | 폴더(나무) | 만들기 · 번호 | 저장(잠금 · 판 · 원자) |
|
||||
| --- | --- | --- | --- | --- | --- |
|
||||
| SK · SC | `Router_Items._root:145`(서고 길) · `Router_Layers._layer_dir:140`(templates 길) | `Router_Layers.list_layer:229` → `Layer_Index.list_rows:90` · `summaries:152` | `Precombo_Folders.view:67` · `edit:180`(**판 대조 · 잠금 없음**) | `Labor_Ref.create:385` · `next_key:367` + `_번호.json`(854-1) | `Store.write:142`(잠금 `_LOCK:80` · 판 409 · 원자) · 프로젝트 = `layers.write_template:251`(판 · **잠금 없음**) |
|
||||
| 구조물 조합 | `Router_Items._root:145` | `Items.items:62` · `get_tree:219` | 표 안 경로 `Tree.apply:233` → `Store.write`(표) | `Item_Personal.create_item:44` · `Items.copy_item:140` · 장부 키 `Book.key_head:36`(`SC{회사}-` · `SP{사용자}-` · `다음`) · 도번 `Store._serial:326`(지운 번호 `_retired:339` 셈) | `Store.write`(표 · 세 파일 · `sync_combos:629`) |
|
||||
| 표 · 도면 틀 | `Router_Layers._layer_dir:140` | `Layer_Index.list_rows` · `Template_Layers.list_templates:150` | 없음 | 이름 = 파일 이름(번호 없음) | `Store.write` · 프로젝트 `write_template` |
|
||||
| 내 기계 | `MyMachine_Router._folder:34`(개인 고정 감쌈) + `MyMachine._user:410`(경로로 층 판정) | `MyMachine.listing` | 없음 | `MyMachine.add`(자기 `_LOCK:60` · `_다음.json`) | `update`(자기 잠금 · 판 · 원자 — 854-1) |
|
||||
| 내 재료 | `Router_Items._root` + `Material_Own._personal:236` | `Material_Own.rows` | 없음 | `add`(`store._LOCK` · **모든 개인 층 최대 + 1** `_last` + 파일 `마지막`) | `update`(`store._LOCK` · **판 없음** · 원자) |
|
||||
| 실무자료 | `Hopyo_Router._root:42`(개인 고정 감쌈) | `Hopyo_Store.rows:87`(하루 지난 것 숨김) | 없음 | `Hopyo_Store.save:119`(자기 `_LOCK:37` · `불러옴.json.번`) | `save`(새 키만 · 고침 없음) |
|
||||
| 재료 고름 | `Hopyo_Router._root` | 없음 | 없음 | 파일 지문이 키 | `San_MatPick.write:97`(**잠금 · 판 없음** · 원자) |
|
||||
| 공유 요청 | `Share_Request._company:66` + `Router_Items._root` | `listing:145` | 없음 | `uuid` | 자기 `_LOCK:47` · 원자 · 상태 409 |
|
||||
|
||||
### 1-3 일마다 하는 자리 — 고침 · 둘러싼 쪽
|
||||
|
||||
| 종류 | 지우기 | 복사 · 붙여넣기 | 쓰는 곳 찾기 | 권한 | 지문 · 캐시 | 공유 |
|
||||
| --- | --- | --- | --- | --- | --- | --- |
|
||||
| SK · SC | 나무 `edit` → `Library_Delete.remove:166`(쓰는 줄 지움 · `_합친것` 기록 · **잠금 없음 · 앞판 되돌림** `:189`) · `Store.delete:207` | `Precombo_Folders.paste:203` → `Labor_Ref.carry:533`(못 읽는 참조 같이) · 합치기 `Library_Same_Router.merge:206`(**잠금 없음** `:261`) | `Labor_Ref.users:459`(+ `use_files:452` · 기억 `_ids_of:473`) · `Library_Delete.users:76` · `Library_Same_Router._user_index:93` · `Layer_Index._uses:185` | `Layer_Access.require:83` + `Library_Delete.can_write:40` + `Library_Same_Router._can_write:108` · 참조 위 층 규칙 `Labor_Ref.readable:146` | 판 `Store.version_of:89` · 내용 `Library_Same.finger:208` · 캐시 `Layer_Index._MEM:34` · `Labor_Ref._IDS:470` | SC 만 요청 길 · SK 는 승인 `carry` 로 딸려 감 |
|
||||
| 구조물 조합 | 나무 지움 → `Store.prune_removed_structures:489` | `Item_Paste.paste:44`(층 사이) · `Items.copy_item:140` · 열끼리 `Store.copy_from:442` · `copy_pair:471` | SK 쪽에서 열 이름 `Library_Delete._columns:64` | `Router_Items._root` | `Store.version_of` | 요청 길 있음(`item`) |
|
||||
| 표 · 도면 틀 | `Router_Layers.delete_layer_template:366` → `Store.delete` · `layers.delete_template:272` | 프로젝트로 `copy_templates:345` · `seed_project:390` · `reset_project:425` | 고정 표 `Store.IN_USE:58`(네 양식) | `_layer_dir` | `Template_Layers.version_of:139` | 없음 |
|
||||
| 내 기계 | `MyMachine.delete`(잠금) | 없음(층 사이 안 옮김) | `MyMachine.uses:487`(SK 글 훑기) · 영향 `MyMachine_Impact` · M01 `Machine_Uses.uses:265` | `_folder` | 판 `MyMachine.version:116` · 캐시 `_MEMO:169` | 없음 |
|
||||
| 내 재료 | `Material_Own.remove`(쓰는 곳 409) | 층 사이 같은 키 `carry` · `adopt` | `Material_Own.usage:143`(층 폴더 통째 글 훑기) | `_root` + `_personal` | 캐시 `_MEMO:184` | 없음 |
|
||||
| 실무자료 | `Hopyo_Store.delete:167` · `Hopyo_Forget.finish:128` · 하루 지남 `sweep:148` | 없음 | 본뜬 키로 사본 걷음 `Hopyo_Forget.forget:102` | `Hopyo_Router._root` | 올린 엑셀 `Hopyo_Store.fingerprint:71` | 없음 |
|
||||
| 재료 고름 | HP 지울 때 판만 | 없음 | `San_MatPick.made:248` · `uses:333` · `tally:348` | `Hopyo_Router._root` | — | 없음 |
|
||||
| 공유 요청 | 없음(상태만) | 승인 = 위 두 길 | — | `_company` | — | — |
|
||||
|
||||
### 1-4 같은 일 몇 벌(분석 수 → 지금 자리)
|
||||
|
||||
| 일 | 분석 | 지금 | 자리 |
|
||||
| --- | --- | --- | --- |
|
||||
| 층 폴더 찾기(세션 → 폴더) | 4 | **5**(몸 2 + 감쌈 2 + 프로젝트 1) | `Router_Items._root:145` · `Router_Layers._layer_dir:140` · 감쌈 `Hopyo_Router._root:42` · `MyMachine_Router._folder:34` · 프로젝트 `Project_Items_Router._root:87` |
|
||||
| 폴더 → 층 판정 | — | **4** | `Labor_Ref.where:77`(몸) · `MyMachine._user:410`(경로 부모 이름) · `Material_Own._personal:236`(→ `where`) · 키 → 층 `Combo_Store.where:86` |
|
||||
| 쓰는 곳 찾기 | 6 | **10** | 서고 참조 4: `Labor_Ref.users:459` · `Library_Delete.users:76` · `Library_Same_Router._user_index:93` · `Layer_Index._uses:185` / 자원 키 6: `MyMachine.uses:487` · `Material_Own.usage:143` · `Labor_Spec.users:143`(규격 열) · `San_MatPick.made:248 · uses:333` · M01 `Machine_Uses.uses:265` · M01 `Doc.users:268` |
|
||||
| 쓰기 권한 판단 | 여러 곳 | **3 + TS 1** | `Layer_Access.grant:61 · require:83`(몸) · `Library_Delete.can_write:40` · `Library_Same_Router._can_write:108` · TS `M02_MasterTemplete_Layer.ts:107 accessFor`(거울 시험 없음) |
|
||||
| 파일 판 `version_of` | 3 | **M02 3 + M01 2** | `Store.version_of:89`(바이트) · `Template_Layers.version_of:139`(경로 · 같은 sha256[:16]) · `Item_Source.version_of:79`(JSON 정렬 — 실은 내용 지문) · M01 `Store.version_of:56` · `Doc.version_of:46` |
|
||||
| 내용 지문 | 7 | 7(855 몫) + 서고 2 | 서고 쪽 `Library_Same.finger:208` · `Hopyo_Store.fingerprint:71` |
|
||||
| 쓰기 잠금 | — | **4 벌** | `Store._LOCK:80`(서고 · 표 · 재료 공용 · `Lock` = 안에서 다시 잡으면 교착) · `MyMachine._LOCK:60`(RLock) · `Hopyo_Store._LOCK:37` · `Share_Request._LOCK:47` |
|
||||
| 잠금 없는 쓰기 | B 5-4 · 5-5 | **5 곳** | `Precombo_Folders.edit:180`(판 대조와 쓰기 사이 열림) · `Library_Delete.remove:166` · `Library_Same_Router.merge:206 · undo:285` · `Template_Layers.write_template:251` · `San_MatPick.write:97` |
|
||||
| 번호 체계 | 9 갈래(E 4-1) | 서고 **7** | SK · SC `next_key` + `_번호.json` · 장부 `Book`(`다음`) · 도번 `Store._serial`(지운 번호) · HP `불러옴.json.번` · PM 전 층 최대 + `마지막` · EQP `_다음.json` · 요청 `uuid` |
|
||||
| 목록 | — | **8** | `Layer_Index.list_rows` · `Precombo_Folders.view` · `Items.items` · `MyMachine.listing` · `Material_Own.rows` · `Hopyo_Store.rows` · `Share_Request.listing` · `Combo_Store.listing:159` |
|
||||
|
||||
### 1-5 storage 실측(꼴 · 개수만 · `census_storage.tsv`)
|
||||
|
||||
| 층 | 수 | 폴더별 json(층 합) | 뿌리 파일 |
|
||||
| --- | --- | --- | --- |
|
||||
| 마스터 | 1 | drawing 5 · table 1 · report 1 · stability 2 · 구조물정의_이력 22 | `구조물정의.json` · `구조물집계표조합.json` · `calc_sites.json` |
|
||||
| 회사 | 2 | table 2 · drawing 1 · 나머지 0 | `구조물집계표조합.json` 2 · `00_template_A1.json` 1(종류 폴더 밖에 놓인 양식 — 확인 거리) |
|
||||
| 개인 | 6 | sangeun 15 · precombo 6 · `_합친것` 16 · table 4 · 내기계 1(`_다음` 만) · 실무자료 7 · 빈 폴더 `area drawing inputs labor material promote structure` | `구조물집계표조합.json` 4 · `sangeun_폴더` 2 · `precombo_폴더` 2 · `개인자재.json` 1 · `manifest.json` 1 · `_번호.json` 1 |
|
||||
|
||||
## 2. 한 벌 틀 제안
|
||||
|
||||
### 2-1 바탕 — 이미 잘 된 것
|
||||
|
||||
- **저장** `Store.write:142` — 잠금 · 판 409 · 원자 쓰기 · 서버 정본 다시 셈(`_server:566`) · 서고 키 = 파일 이름. 한 파일 한 문서 꼴의 정본 길.
|
||||
- **나무** `Precombo_Folders` — `{종류}_폴더.json{폴더, 자리}` · 종류 인자 한 벌.
|
||||
- **지우기 · 합치기 · 되돌림** `Library_Delete` · `Library_Same(_Router)` — 쓰는 줄 정리 · `_합친것` 기록 · 되돌림.
|
||||
- **권한** `Layer_Access` 한 벌 · **층 폴더** `Router_Items._root` 한 벌(대부분 가져다 씀).
|
||||
|
||||
### 2-2 종류 표 하나(새 파일 없음 · `Template_Layers` 안 · 어림 +40)
|
||||
|
||||
지금 `KINDS · LIBRARY_KINDS`(`Template_Layers:34-35`) · `Labor_Ref.PREFIX · TITLE` · `Share_Request` `Literal`(종류 글) · TS `Api_Fetch.Kind` 로 흩어진 종류 정의를 한 표로.
|
||||
|
||||
| 칸(옵션) | 뜻 | SK | SC | 내 기계 | 내 재료 | 실무자료(857) |
|
||||
| --- | --- | --- | --- | --- | --- | --- |
|
||||
| `폴더` | 층 안 자리 | `sangeun` | `precombo` | `내기계` | 판단 1 | `실무자료` |
|
||||
| `키꼴` · `머리` | 번호 꼴 | `SK-######` | `SC-######` | `EQP{사용자}-####` | `PM######`(전 층) | `HP-######` |
|
||||
| `층` | 놓일 층 | 넷 | 넷 | 개인만 | 개인만 | 개인만 |
|
||||
| `번호` | 장부 자리 | 층 `_번호.json` | 같음 | 같음(`_다음.json` 걷음) | 전 층 최대 + `마지막` 그대로 | `불러옴.json.번` 그대로(857) |
|
||||
| `나무` | 폴더 장부 | 있음 | 있음 | 없음 | 없음 | 없음 |
|
||||
| `숨김` | 하루 지나면 | — | — | — | — | 1 일 |
|
||||
| `쓰는곳` | 쓰는 곳의 뜻 | 참조 `{층 주인 키}` | 같음 | 자원 키 글(`개인 EQP…`) | 자원 키 글(`PM…`) | 본뜬 키 |
|
||||
| `공유` | 회사에 올리기 | 판단 2 | 있음 | 판단 2 | 판단 2 | 없음 |
|
||||
| `셈` | 저장 때 서버 정본 | `Store._server` | 같음 | 시간당(`Machine_Hourly.hour`) | 없음 | 없음 |
|
||||
|
||||
구조물 조합 · 표 · 도면 틀은 이미 `Store.write` 를 쓰고 번호가 표 장부와 같이 움직임 → 표에 「양식 종류」 로만 올리고 번호 · 나무는 지금 것 그대로.
|
||||
|
||||
### 2-3 부품 일곱(지금 것을 넓힘)
|
||||
|
||||
| 부품 | 한 벌로 삼을 것 | 걷을 것 | 어림 |
|
||||
| --- | --- | --- | --- |
|
||||
| ① 층 폴더 | `Router_Items._root` + 옵션 `개인만` | `Hopyo_Router._root:42` · `MyMachine_Router._folder:34` 감쌈 · `Router_Layers._layer_dir` 는 프로젝트 · 비동기 때문에 남기되 안쪽이 `access.folder` 를 같이 씀 | −10 |
|
||||
| ② 층 판정 | `Labor_Ref.where:77` | `MyMachine._user:410` 의 경로 부모 이름 판정 → `where` | −10 |
|
||||
| ③ 권한 | `Layer_Access` 에 `can_write(session, here)` 하나 | `Library_Delete.can_write:40` · `Library_Same_Router._can_write:108` · TS `accessFor` 는 거울 시험 붙임 | +15 / −15 |
|
||||
| ④ 판 | `Store.version_of` | `Template_Layers.version_of:139` → 그것을 부름 · `Item_Source.version_of` 는 이름만 「내용 지문」 으로(855 B9-5 때) | −5 |
|
||||
| ⑤ 여러 파일 쓰기 | `Store` 에 `batch()`(잠금 하나 + 앞판 되돌림 · `Library_Delete.remove:189` 의 되돌림 꼴을 옮김) · `_LOCK` → `RLock` | `Library_Delete` 되돌림 몸 · `Library_Same_Router.merge` · `undo` · `Precombo_Folders.edit` 가 `batch` 안에서 | +40 / −40 |
|
||||
| ⑥ 번호 장부 | 층 `_번호.json`(854-1 · `Labor_Ref.next_key` 꼴) 을 종류 표 `번호` 칸으로 | `MyMachine._다음.json` · `MyMachine.add` 의 번호 몸 | +10 / −20 |
|
||||
| ⑦ 쓰는 곳 색인 | `Labor_Ref.use_files · users · _ids_of`(파일 판 기억) 를 새 `M02_Library_Uses.py` 로 떼어 넓힘(참조 + 자원 키 두 찾기) | `Library_Delete.users` 훑기 몸 · `_user_index` · `Layer_Index._uses` · `MyMachine.uses` · `Material_Own.usage` | +120 / −150 |
|
||||
|
||||
### 2-4 새로 만드는 것(가장 적게)
|
||||
|
||||
- 새 파일 2 = `M02_Library_Uses.py`(⑦ · `Labor_Ref` 675 줄이라 더 못 넣음) · 지킴 시험 `test_858_shelf_golden.py`.
|
||||
- 새 저장 파일 0(층 `_번호.json` 은 이미 있음).
|
||||
- 새 서버 길 0 — 내 재료 길을 `Labor_Router` 에서 내 기계와 같은 라우터 묶음으로 옮김(길 글자는 그대로).
|
||||
|
||||
## 3. 걸음(두 박자 — 새 틀로 옮김 → 답 전후 같음 → 다음 묶음에서 옛 코드 지움)
|
||||
|
||||
| 걸음 | 무엇 | 파일(어림 줄) | 지킴 | 위험 · 막는 법 | 화면 확인 |
|
||||
| --- | --- | --- | --- | --- | --- |
|
||||
| **5-0 지킴 올림** | 임시 storage 견본 층(SK · SC · 항목 · 내 기계 · 내 재료 · 공유 요청)에서 길 답 지문 — 목록 · 나무 · 만들기 · 고치기 · 지우기 · 복사 · 붙여넣기 · 합치기 · 되돌림 · 쓰는 곳 · 권한 403/404 → `858_shelf_golden.json` · 동시 쓰기 시험(854-1 꼴)을 나무 · 지우기 · 합치기로 넓힘 | 새 `resources/tester/test_858_shelf_golden.py`(+ 300) | 지금 수치 그대로 통과 | 견본 짓기가 남의 시험 견본과 겹침 → 기존 `world` 픽스처(`test_m02_labor_ref`) 재사용 | — |
|
||||
| **5-1 권한 한 벌** | ③ | `M02_Layer_Access.py`(+ 15) · `M02_Library_Delete.py`(− 8) · `M02_Library_Same_Router.py`(− 5) · 거울 시험(TS `accessFor` ↔ 서버) 새 1(+ 60) | 5-0 · `test_m02_layer_access` · `test_735_1` · `test_733_3_*` | 회사 관리자 · 남의 층 경우 — 5-0 의 403 지문 | 개인 · 회사 층 나무 지우기 · 중복 합치기 단추 보임 |
|
||||
| **5-2 층 폴더 · 층 판정 한 벌** | ① ② | `M02_MasterTemplete_Router_Items.py`(+ 5) · `M02_MyMachine_Router.py`(− 5) · `M02_MyMachine.py`(± 10) · `M02_Material_Own.py`(± 5) | 5-0 · `test_821_*` · `test_840_4` · `test_m02_material_own` | `Hopyo_Router._root` 는 **857 몫 파일** → 여기선 안 고침 · 857 이 같은 옵션을 씀 | 개인관리 › 기계 · 자재 열기 |
|
||||
| **5-3 판 한 벌 · 프로젝트 저장 잠금** | ④ + `write_template` 을 `Store._LOCK` 안에서 | `M02_Template_Layers.py`(± 10) · `M02_MasterTemplete_Store.py`(± 3) | 5-0 · `test_826_1` · `test_204_2` · `test_572` | 프로젝트 층 저장(B05 · B07 양식) — 판 값은 같은 sha256[:16] 이라 안 바뀜 | 프로젝트 양식 저장 한 번 |
|
||||
| **5-4 여러 파일 쓰기 한 꼴** | ⑤ | `M02_MasterTemplete_Store.py`(+ 40) · `M02_Library_Delete.py`(− 30) · `M02_Library_Same_Router.py`(± 20) · `M02_Precombo_Folders.py`(± 5) | 5-0 동시 시험(같은 층 지우기 · 합치기 겹침 → 하나만 이김 · 파일 앞판 그대로) · `test_735_1` · `test_733_3_*` · `test_m02_precombo_folders` | `RLock` 으로 바꿈 — `Store.write` 를 잠금 안에서 부르는 길(합치기 `_rewrite:125`)이 생김 · 늦은 쓰기(`_refresh_labor`)는 잠금 밖 그대로 | 나무 지우기 · 되돌림 · 합치기 |
|
||||
| **5-5 쓰는 곳 색인 한 벌** | ⑦ | 새 `M02_Library_Uses.py`(+ 120) · `M02_Labor_Ref.py`(− 60) · `M02_Library_Delete.py`(− 30) · `M02_Library_Same_Router.py`(− 20) · `M02_Layer_Index.py`(− 15) · `M02_MyMachine.py`(− 25) · `M02_Material_Own.py`(− 20) | 5-0 쓰는 곳 지문 · `test_826_1`(목록 쓰는 곳 수) · `test_840_4` · `test_848_5` | **855 L2 ⓑ 가 `Layer_Index` 를 만짐** → L2 ⓑ 뒤 또는 `Layer_Index` 몫만 L2 ⓑ 창에 | 지우기 미리 보기 쓰는 곳 · 목록 쓰는곳수 · 내 기계 쓰는 단가산출 |
|
||||
| **5-6 내 기계 · 내 재료를 서고 틀로** | 종류 표(2-2) · 내 기계 번호 = 층 `_번호.json` · 옛 `내기계.json` 옮김(`MyMachine._move:97`) 걷음 · 내 재료 판 대조(+ 판단 1) · 내 재료 길을 내 기계 라우터 묶음으로 | `M02_Template_Layers.py`(+ 40) · `M02_MyMachine.py`(− 60) · `M02_MyMachine_Router.py`(+ 40) · `M02_Material_Own.py`(± 40) · `M02_Labor_Router.py`(− 50) · TS `M02_MyMachine_Api.ts` · 내 재료 화면 Api(판 칸 · ± 20) | 5-0 · `test_854_1` · `test_821_*` · `test_840_4` · `test_m02_material_own` · `test_826_2` | **`San_MyMachine.attach` 가 `MyMachine.create` 를 부름(857 몫)** → `create` 인자 · 답 꼴 그대로 | 내 기계 만들기 · 고침 · 옛 판 막힘 · 내 재료 같은 것 |
|
||||
| 5-7 공유 범위(판단 2 뒤) | `Share_Request` `Literal` → 종류 표 `공유` 칸 | `M02_Share_Request.py`(± 20) · TS `ShareRequest`(± 20) | `test_706_1` | — | [회사에 올리기] |
|
||||
| **5-8 옛 코드 지움** | 감쌈 · 중복 몸 · 옛 꼴 옮김 · 잠금 없는 되돌림 몸 · 화면 0 이 된 것 · 그것만 붙드는 시험 | 위 파일들(− 150 안팎) | `/openapi.json` 길 전후(뜻한 길만) · 관련 시험 전부 | — | 한 바퀴 |
|
||||
|
||||
### 3-1 같이 돌릴 수 있는 묶음(파일 안 겹침)
|
||||
|
||||
| 묶음 | 걸음(창) | 겹침 확인 | 앞 조건 |
|
||||
| --- | --- | --- | --- |
|
||||
| ㉠ | 5-0(하나) | 새 시험 파일만 | 없음 — **지금** |
|
||||
| ㉡ | 5-1 · 5-2 · 5-3(셋) | Layer_Access · Library_Delete · Library_Same_Router ↔ Router_Items · MyMachine* · Material_Own ↔ Template_Layers · Store — 다름 | ㉠ |
|
||||
| ㉢ | 5-4(하나) | Store · Library_* · Precombo_Folders | ㉡(5-1 의 Library_* · 5-3 의 Store) |
|
||||
| ㉣ | 5-5(하나) | Labor_Ref · Library_* · Layer_Index · MyMachine · Material_Own | ㉢ · 855 L2 ⓑ |
|
||||
| ㉤ | 5-6 · 5-7(둘) | MyMachine* · Material_Own · Labor_Router · Template_Layers ↔ Share_Request — 다름 | ㉣ · 판단 1 · 2 |
|
||||
| ㉥ | 5-8(하나) | 전부 | ㉤ |
|
||||
|
||||
꼭 차례인 까닭:
|
||||
- `Library_Delete` · `Library_Same_Router` 를 5-1 · 5-4 · 5-5 셋이 만짐 → 한 걸음씩.
|
||||
- `MyMachine` · `Material_Own` 을 5-2 · 5-5 · 5-6 이 만짐 → 5-2 는 판정 몸만 · 5-6 은 마지막.
|
||||
- 5-4(잠금 하나)가 5-5 앞 — 쓰는 곳 색인을 지우기 · 합치기 잠금 안에서 쓰게 되므로.
|
||||
|
||||
## 4. 「다시 셈 · 새로 고침」 길 열두 가지
|
||||
|
||||
| 번호 | 길(B 4-1) | 걸음 2 뒤 | 하나로 모을 수 있나 · 정리안 |
|
||||
| --- | --- | --- | --- |
|
||||
| ① | 자동 따라옴 `Sk_AutoRenew`(프로젝트 층 밖) | 남음(2-D 가 옛 사본 갈래만 걷음) | ②와 「값을 새로 받기」 한 뜻 — 층 따라 자동 / 손 |
|
||||
| ② | [단가 갱신] `Sangeun_Copy.PRICE:40` | 남음(프로젝트 층) | 판단 3 — 이름 가름 |
|
||||
| ③ | [재생성] `REGEN` | 남음 | 그대로(고친 것 버림 · 뜻 다름) |
|
||||
| ④ | 알림 [확인] `Sk_AutoRenew.CONFIRM:47` | 남음 | ① 의 짝 — ① 과 같이 |
|
||||
| ⑤ | 저장 때 재계산 `Store._server:566` → … `Doc_Sk.settle` | 남음(서버 정본 원칙) · 2-D 뒤 `사본` 줄임 갈래 빠짐 | 그대로 — 모든 저장이 이미 이 한 길 |
|
||||
| ⑥ | 펼침 `Library_Flat.flat_doc`(읽기 · 저장 · 복사) · 초기화 `reset_doc` | 남음 · 읽기 길 펼침(`Router_Layers:275-276` `unpromote` · `flat_doc`) = 「열 때 본 문서 ≠ 파일」 | 옛 로직 줄 꼴 올림 몫이 크면 저장본 비운 뒤 읽기 길 펼침 걷음(855 2-D 와 같이 확인) |
|
||||
| ⑦ | 일위대가 계산값 다시 적기 `Labor_Doc.server` · `Store._refresh_labor:596` | 남음 | ⑦ ⑧ = 「저장 뒤 딸림 갱신」 한 목록으로(`Store.write` 끝 · 5-4 의 `batch` 안) |
|
||||
| ⑧ | 도면 연결표 글 `Store._refresh_drawing:588` | 남음 | 위와 같음 |
|
||||
| ⑨ | 저장 전 영향 `MyMachine_Impact` | 남음 | 내 재료에도 같은 꼴(5-6 · 판단 1 과 같이) |
|
||||
| ⑩ | 파생 색인 `Layer_Index` · `Logic_Standard` · 프로젝트 [재적용] · `Item_Prices.refresh` · B09 | 색인 둘 남음 · 프로젝트 쪽은 B9 걸음 몫 | 색인 무효 규칙 = 「파일 자국」 한 꼴(`Layer_Index._stamps:49` · `Logic_Standard._stamp:227` 이 각자) — 858 범위 밖 · 메모만 |
|
||||
| ⑪ | `Hopyo_Relink` | 857 몫 | — |
|
||||
| ⑫ | 한 번용 `*_Migrate*` | **이미 없음**(853-2 · 지금 파일 0) | — |
|
||||
|
||||
같은 단추 이름이 층 따라 다른 뜻인 자리 — **[단가 갱신]**: 프로젝트 층 = 굳힌 사본을 지금 M01 값으로 다시 씀(손) · 층 서고 = 자동 따라옴이라 단추 대신 알림 [확인]. 서버가 `Sk_AutoRenew.on:55` 로 가름 · 화면 글 `formula_doc_text.ts:54` 한 벌. 정리안 = 판단 3.
|
||||
|
||||
## 5. 화면 쪽
|
||||
|
||||
| 거리 | 지금 | 제안 |
|
||||
| --- | --- | --- |
|
||||
| 고치는 중 값 보관 | 단가산출만 sessionStorage(`line_stack_screen.ts:185 · 197` · 열쇠 `m02_sk_doc_drafts` `Sangeun_Tabs.ts:56`) · 나머지는 메모리 + 떠날 때 `confirmLeave`(11 파일) | **858 범위 밖** 권함 — 856 이 일위대가 줄 창을 줄 쌓기로 바꾸면 SC 도 같은 보관을 얻음 · 내 기계 · 내 재료는 짧은 양식이라 메모리 그대로 · 판단 5 |
|
||||
| 층 전역 `setActiveLayer` | `Api_Fetch.ts:74-92` 모든 M02 부름이 `/layers/${activeLayer}` · `UI_Page.ts:162 · 345` 가 바꿈 · 되돌림 · 섞임은 `turn` 이 막음 | **858 범위 밖** 권함(화면 부름 전부가 걸림 · 효과 작음) · 5-6 에서 내 기계 · 내 재료 Api 만 「종류 + 층」 을 인자로 받는 한 함수로 |
|
||||
| 권한 짝 | TS `accessFor` ↔ 서버 `Layer_Access` 거울 시험 없음 | 5-1 에서 붙임 |
|
||||
|
||||
## 6. 걸음 2 · 3 · 4 와 겹침 · 차례 조건
|
||||
|
||||
| 상대 | 겹치는 파일 | 조건 |
|
||||
| --- | --- | --- |
|
||||
| 855 2-C1 · 2-C5 · 2-D | `Doc_Sk` · `Sangeun_Calc` · `Labor_Copy` · `Labor_Expand` · `Copy_Slim` · `Library_Flat` · `Sangeun_Copy` · `Sk_AutoRenew` | 858 은 이 파일들을 **안 고침**(⑥ 펼침 정리는 2-D 뒤 메모만) |
|
||||
| 855 L2 ⓑ | `Layer_Index` · `Labor_Inputs` | 5-5 의 `Layer_Index` 몫은 L2 ⓑ 뒤 |
|
||||
| 855 B9-5 | `Item_Source.version_of` | 이름 바꿈은 B9-5 몫 · 858 은 안 고침 |
|
||||
| 856 화면 하나 | `Sangeun_Detail` · `LogicLab_Ho` · `line_stack_*` · 일위대가 줄 창 TS | 겹침 없음 · 고치는 중 값 보관은 856 에 맡김 |
|
||||
| 857 불러오기 | `Hopyo_Router` · `Hopyo_Store` · `Hopyo_Forget` · `San_MatPick` · `San_MyMachine`(→ `MyMachine.create`) | 실무자료 · 재료 고름의 틀 옮김은 **857 안에서**(종류 표 `숨김` 칸을 씀) · 5-6 은 `create` 꼴 그대로 |
|
||||
| 854 · 855 이미 끝난 것 | `MyMachine`(854-1 잠금 · 판 · 2-B2) · `Labor_Ref.next_key`(854-1) · `Machine_Hourly` | 바탕으로 씀 |
|
||||
|
||||
지금 바로 시작해도 되는 조각 = **㉠ 5-0 · ㉡ 5-1 · 5-3**(855 남은 걸음 · 856 · 857 과 파일 안 겹침). 5-2 는 `MyMachine` 을 만지는 다른 일감이 없으면 같이.
|
||||
|
||||
## 7. 사용자 판단 거리 · 못 본 것
|
||||
|
||||
### 7-1 판단 거리(쉬운 말)
|
||||
|
||||
1. **내 재료 저장 꼴** — 지금 한 파일에 모든 줄 · 고칠 때 판 대조 없음. ㉮ 내 기계처럼 한 줄 한 파일 + 판(서고 틀과 같음 · 지금 저장본 1 개라 옛 꼴 호환 없이 바꿈) ㉯ 한 파일 그대로 + 판만 붙임(권함 — 줄이 적고 번호가 전 층에 걸쳐 있어 파일을 나눌 득이 작음).
|
||||
2. **공유 범위** — 지금 [회사에 올리기] 요청은 구조물 조합 항목 · 일위대가만. 단가산출 · 내 기계 · 내 재료도 요청 길을 둘지(지금 단가산출은 일위대가 승인 때 딸려 갈 때만 올라감).
|
||||
3. **[단가 갱신] 이름** — 프로젝트 층에선 손으로 새 값 받기, 층 서고에선 저절로 따라오고 알림 [확인]만 있음. ㉮ 이름을 가름(프로젝트 = 「단가 갱신」 · 층 서고 = 「새 값 확인」 · 권함) ㉯ 그대로.
|
||||
4. **내 기계 · 내 재료 저장본** — 지금 내 기계 0 대(번호 파일만) · 내 재료 1 파일. 비우고 시작해도 되는지(옛 `내기계.json` 옮김 코드도 같이 걷음).
|
||||
5. **고치는 중 값 보관** — 새로고침 뒤에도 고친 값이 남아야 하는 화면(지금 단가산출만) — 858 에선 안 다루고 856 에 맡겨도 되는지.
|
||||
6. **실무자료 · 재료 고름** — 857(불러오기 합침) 안에서 같은 틀로 옮김(권함).
|
||||
|
||||
### 7-2 못 본 것
|
||||
|
||||
- 화면 · 서버를 조작하지 않음(코드 따라가기 · 길 목록만 읽음) — 「공유 요청 승인」 · 「합치기 되돌림」 실제 동작.
|
||||
- 프로젝트 층 서고(굳힌 사본)의 목록 · 쓰는 곳 — B9 걸음 몫이라 깊게 안 봄.
|
||||
- M01 `Machine_Uses` · `Doc.users` 속(M01 범위).
|
||||
- 회사 층 뿌리 `00_template_A1.json`(종류 폴더 밖) 이 어느 코드가 놓은 것인지.
|
||||
- `Router_Layers._layer_dir` 의 프로젝트 · 직접 SQL(B 1-4) 정리 — 858 에 넣지 않음(마스터 층 ↔ 프로젝트 경계 · B 6(다) 다른 후보).
|
||||
|
||||
## 세기 도구 · 결과(`tmp/s894/m858/`)
|
||||
|
||||
| 파일 | 내용 |
|
||||
| --- | --- |
|
||||
| `defs.py` → `defs.tsv` | 서고 관련 36 파일 함수 555 개(이름 · 줄 · 길이 · 서버 길 · 독스트링 첫 줄) |
|
||||
| `count.py` → `count.tsv` · `count_summary.tsv` | 일 16 갈래 정규식 자리(`파일:줄`) — 표 1-4 는 이것을 손으로 걸러 셈(이름이 같은 다른 일 뺌 — 예 `Hopyo_Excel._columns`) |
|
||||
| `census_storage.py` → `census_storage.tsv` | 층 폴더 꼴 · 폴더별 json 수 · 뿌리 파일(키 이름은 `<키>` 로 가림 · 값 안 봄) |
|
||||
| `openapi.json` → `routes.tsv` | 자기 포트 8006 길 목록(읽기만) · M02 108 길 묶음 |
|
||||
@@ -0,0 +1,327 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""단가산출 수식 문서 셈 답 → 산출근거 글(PLAN 855-C 2-C4 · 서버 풀이 글) — 셈 안 함(답만 읽음).
|
||||
|
||||
쓰는 곳 = M02 기준 목록 계산서(`M02_Logic_Standard.sheet`) · (뒤에) B09 산출근거(855 보충 B9-4).
|
||||
⚠ 짝(글 규칙) — 한쪽을 고치면 다른 쪽도 · 거울 시험 `resources/tester/test_855_c4_doc_text.py`:
|
||||
`A00_Common/line_stack_out.ts`(금액 줄 · 계 줄 꼴 · 수 꼴 `one` · `won` · 비목 이름) ·
|
||||
`ui_template/ui_template_equation.ts`(`eqText`) ·
|
||||
`common_util/common_util_line_stack_unit.ts`(`unitText` · `isAtom` · `moneyUnits`) ·
|
||||
`common_util/common_util_formula_doc_view.ts`(`offLine` — 선택으로 꺼진 줄).
|
||||
금액 줄 = 「이름 : 단가 원/단위 × 수량 단위 = 금액 원」 · 묶음 줄 = 비목마다 「노무비 : …」 ·
|
||||
계 = 「노무비 : 줄 + 줄 = 금액 원」 · 「합계 : 금액 원」.
|
||||
수 꼴 = 화면과 같음 — 단가 · 수량 = `eqText`(소수 여섯 자리까지 · 셈 값 그대로) ·
|
||||
줄 금액 = 소수 한 자리 · 비목 · 합계 = 원(셈 답의 끝수 그대로 · 여기서 자르지 않음).
|
||||
옮기지 않은 것(화면만) — 식 조판(KaTeX · 수량 식은 값 하나로) · 공식 줄 · 펼침 ·
|
||||
작업량 줄(846-2) · 굳은 기계 이름(847-1) · 비목곱 인수 글(848-7 · 금액은 답 그대로) ·
|
||||
계 덧셈 항 = 줄 금액(화면은 묶음 줄 있는 항목 · 항이 넷 넘으면 항목 소계 — 여기는 금액만).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from decimal import ROUND_FLOOR, ROUND_HALF_UP, Decimal, InvalidOperation
|
||||
|
||||
import master_doc as md
|
||||
import master_doc_calc as mc
|
||||
|
||||
COSTS = md.COSTS # 노무비 · 재료비 · 경비
|
||||
COST_SHOW = {"노무비": "노무비", "재료비": "재료비", "경비": "경 비"}
|
||||
AMOUNT_UNIT = "원"
|
||||
LONG_SUM = 4
|
||||
_HIDE = ("반올림", "올림", "버림")
|
||||
_SAME = (("일", "인"), ("㎏", "kg"), ("ℓ", "L"))
|
||||
|
||||
|
||||
# ── 수 꼴 ─────────────────────────────────────────────────────────────
|
||||
def _dec(v) -> Decimal | None:
|
||||
if isinstance(v, bool) or v is None:
|
||||
return None
|
||||
try:
|
||||
d = Decimal(str(v)) if not isinstance(v, Decimal) else v
|
||||
except InvalidOperation:
|
||||
return None
|
||||
return d if d.is_finite() else None
|
||||
|
||||
|
||||
def _group(d: Decimal, places: int, keep: bool) -> str:
|
||||
q = d.quantize(Decimal(1).scaleb(-places), ROUND_HALF_UP)
|
||||
sign = "-" if q.is_signed() else "" # Intl 과 같음 — 0 으로 반올림된 음수 = 「-0」
|
||||
whole, _, frac = f"{abs(q):f}".partition(".")
|
||||
frac = frac if keep else frac.rstrip("0")
|
||||
head = f"{int(whole):,}"
|
||||
return f"{sign}{head}.{frac}" if frac else f"{sign}{head}"
|
||||
|
||||
|
||||
def eq_text(v) -> str:
|
||||
"""`eqText` — 수 = 천 단위 쉼표 · 소수 여섯 자리까지(반올림 · 끝 0 뗌) · 그 밖 = 글 그대로."""
|
||||
if v is None or v == "":
|
||||
return ""
|
||||
if isinstance(v, bool):
|
||||
return "true" if v else "false"
|
||||
d = _dec(v)
|
||||
if d is None or (isinstance(v, str) and not v.strip()):
|
||||
return str(v)
|
||||
return _group(d, 6, False)
|
||||
|
||||
|
||||
def one(v) -> str:
|
||||
"""줄 금액 — 소수 한 자리 꼭(「26,890.8」 · 「0.0」)."""
|
||||
return _group(_dec(v) or Decimal(0), 1, True)
|
||||
|
||||
|
||||
def won(v) -> str:
|
||||
"""비목 · 합계 — 원(JS `Math.round` = 0.5 올림)."""
|
||||
d = _dec(v) or Decimal(0)
|
||||
r = (d + Decimal("0.5")).to_integral_value(ROUND_FLOOR)
|
||||
return eq_text(Decimal("-0") if r == 0 and d.is_signed() else r) # JS Math.round(-0.4) = -0
|
||||
|
||||
|
||||
# ── 단위 ─────────────────────────────────────────────────────────────
|
||||
def unit_text(u) -> str:
|
||||
"""자료 단위 글 → 화면 단위(메타 단위 = 빈 글)."""
|
||||
s = str(u if u is not None else "").strip()
|
||||
if not s or re.search(r"따름|원문 단위 없음", s) or re.match(r"^수(\(| 또는|$)", s):
|
||||
return ""
|
||||
s = re.sub(r"^%\(.*\)$", "%", s)
|
||||
return s.replace("10^-7", "10⁻⁷").replace("kWh", "㎾h")
|
||||
|
||||
|
||||
def _same(a: str, b: str) -> bool:
|
||||
return a == b or any((a == x and b == y) or (a == y and b == x) for x, y in _SAME)
|
||||
|
||||
|
||||
def is_atom(n) -> bool:
|
||||
"""한 덩이(기호 · 수 · 칸 · 글 — 반올림 · 올림 · 버림 감싸개 안 한 덩이 포함)."""
|
||||
if not n:
|
||||
return False
|
||||
if n[0] == "call" and n[1] in _HIDE and 1 <= len(n[2]) <= 2:
|
||||
return is_atom(n[2][0])
|
||||
return n[0] in ("var", "num", "field", "str")
|
||||
|
||||
|
||||
def node_of(text):
|
||||
if text is None or str(text).strip() == "":
|
||||
return None
|
||||
try:
|
||||
return md.parse(text)
|
||||
except md.DocError:
|
||||
return None
|
||||
|
||||
|
||||
def money_units(
|
||||
line: dict, price, qty, price_var: dict | None = None, sub: dict | None = None
|
||||
) -> dict:
|
||||
"""금액 줄 단위 자리 `{price, qty, wrap}` — 수량이 식이면 괄호 ·
|
||||
단가 분모가 수량 단위와 같은 뜻이면 수량 단위 글."""
|
||||
has = line.get("수량") not in (None, "")
|
||||
q = unit_text(line.get("단위")) if has else ""
|
||||
wrap = bool(q) and bool(qty) and not is_atom(qty)
|
||||
own = next(
|
||||
(
|
||||
u
|
||||
for u in (
|
||||
unit_text((sub or {}).get("결과단위")),
|
||||
unit_text((price_var or {}).get("단위")),
|
||||
)
|
||||
if u.startswith("원")
|
||||
), # fmt: skip
|
||||
None,
|
||||
)
|
||||
mine = f"{AMOUNT_UNIT}/{q}" if own and q and _same(own[2:], q) else own
|
||||
fallback = f"{AMOUNT_UNIT}/{q}" if q else ""
|
||||
price_unit = (mine if mine is not None else fallback) if has and is_atom(price) else ""
|
||||
return {"price": price_unit, "qty": q, "wrap": wrap}
|
||||
|
||||
|
||||
def price_sym(line: dict) -> str | None:
|
||||
n = node_of(line.get("단가"))
|
||||
if not n:
|
||||
return None
|
||||
if n[0] == "var":
|
||||
return n[1]
|
||||
if n[0] == "field" and n[1][0] == "var":
|
||||
return n[1][1]
|
||||
return None
|
||||
|
||||
|
||||
def line_name(line: dict) -> str:
|
||||
"""이름에 규격이 들면 한 번만(814-1)."""
|
||||
name, spec = str(line.get("이름") or ""), line.get("규격")
|
||||
return f"{name} {spec}".strip() if spec and spec not in name else name
|
||||
|
||||
|
||||
# ── 선택으로 꺼진 줄(`offLine`) ───────────────────────────────────────
|
||||
class _Look:
|
||||
"""셈 답 값으로 조건만 읽음 — 계산기 한 벌(`master_doc_calc._Run.ev`) · 값은 답에서 채움."""
|
||||
|
||||
def __init__(self, doc: dict, answer: dict, links):
|
||||
self.run = mc._Run(doc, links, None, (), {})
|
||||
got = answer.get("값") or {}
|
||||
names = {md.var_id(v) for v in doc.get("변수") or []}
|
||||
names |= {str(x.get("기호") or "") for x in doc.get("식") or []}
|
||||
for name in names: # 답에 없는 값 = 모름(다시 셈하지 않음 · 화면 `evalNode` 와 같음)
|
||||
have = got.get(name)
|
||||
self.run.values[name] = mc.Blank("모름") if have is None else have
|
||||
self.lines = {str(x.get("기호") or ""): x.get("식") for x in doc.get("식") or []}
|
||||
|
||||
def value(self, n):
|
||||
try:
|
||||
v = self.run.ev(n, None, "")
|
||||
except Exception: # noqa: BLE001 — 그림용 값 · 모르면 없음
|
||||
return None
|
||||
return None if isinstance(v, (mc.Blank, mc.Stop)) else v
|
||||
|
||||
def taken(self, n) -> int:
|
||||
if not (n and n[0] == "call" and n[1] == "만약" and len(n[2]) == 3):
|
||||
return 0
|
||||
t = self.value(n[2][0])
|
||||
return 0 if t is None else (1 if t else 2)
|
||||
|
||||
def off_zero(self, n, path: frozenset = frozenset()) -> bool:
|
||||
if not n:
|
||||
return False
|
||||
at, hop = n, 0
|
||||
while pick := self.taken(at):
|
||||
at, hop = at[2][pick], hop + 1
|
||||
if hop and at[0] == "num":
|
||||
return at[1] == 0
|
||||
kind = at[0]
|
||||
if kind == "var":
|
||||
name = at[1]
|
||||
if name not in self.lines or name in path:
|
||||
return False
|
||||
return self.off_zero(node_of(self.lines[name]), path | {name})
|
||||
if kind in ("neg", "pct"):
|
||||
return self.off_zero(at[1], path)
|
||||
if kind == "bin":
|
||||
if at[1] == "*":
|
||||
return self.off_zero(at[2], path) or self.off_zero(at[3], path)
|
||||
if at[1] == "/":
|
||||
return self.off_zero(at[2], path)
|
||||
if at[1] in ("+", "-"):
|
||||
return self.off_zero(at[2], path) and self.off_zero(at[3], path)
|
||||
return False
|
||||
|
||||
def off_line(self, line: dict) -> bool:
|
||||
return any(self.off_zero(node_of(line.get(k))) for k in ("수량", "단가"))
|
||||
|
||||
|
||||
# ── 줄 글 ────────────────────────────────────────────────────────────
|
||||
def _num(v) -> Decimal | None:
|
||||
return _dec(v)
|
||||
|
||||
|
||||
def _u(text: str, unit: str) -> str:
|
||||
return f"{text} {unit}" if unit else text
|
||||
|
||||
|
||||
def money_lines(doc: dict, answer: dict, links) -> list[dict]:
|
||||
"""금액 줄마다 산출근거 조각 `{i, 이름, 비목, 단가, 수량, 금액, 단위, 글, 꺼짐, 합밖, 까닭?}` ·
|
||||
묶음 줄 = 비목마다 한 조각(`비목` = 노무비 · 재료비 · 경비 · `묶음줄` 참)."""
|
||||
look = _Look(doc, answer, links)
|
||||
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
rows = answer.get("줄") or []
|
||||
out: list[dict] = []
|
||||
for i, line in enumerate(doc.get("금액") or []):
|
||||
got = rows[i] if i < len(rows) else {}
|
||||
name = line_name(line)
|
||||
ps = price_sym(line)
|
||||
pv = vars_.get(ps) if ps else None
|
||||
link = (pv or {}).get("연결") or {}
|
||||
sub = None
|
||||
if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]):
|
||||
try:
|
||||
sub = links.doc(str(link["키"]))
|
||||
except Exception: # noqa: BLE001 — 못 읽는 부름 = 단위 없이
|
||||
sub = None
|
||||
mu = money_units(line, node_of(line.get("단가")), node_of(line.get("수량")), pv, sub)
|
||||
qty = got.get("수량")
|
||||
base = {
|
||||
"i": i,
|
||||
"이름": name,
|
||||
"수량": _num(qty),
|
||||
"단위": mu,
|
||||
"꺼짐": look.off_line(line),
|
||||
"합밖": bool(got.get("합밖")),
|
||||
"묶음": line.get("묶음") or "",
|
||||
}
|
||||
tail = "" if qty is None else " × " + _u(eq_text(qty), mu["qty"])
|
||||
if got.get("까닭") and got.get("금액") is None:
|
||||
why = got["까닭"]
|
||||
out.append({**base, "비목": line.get("비목"), "단가": None, "금액": None, "까닭": why,
|
||||
"글": f"{name} : — {why}"}) # fmt: skip
|
||||
continue
|
||||
if line.get("비목") == "묶음":
|
||||
bundle = got.get("단가") if isinstance(got.get("단가"), dict) else {}
|
||||
for c in COSTS:
|
||||
part = (got.get("비목") or {}).get(c)
|
||||
if _dec(part) is None or (not part and not bundle.get(c)):
|
||||
continue
|
||||
price = _u(eq_text(bundle.get(c)), mu["price"])
|
||||
text = f"{COST_SHOW[c]} : {price}{tail} = {one(part)} {AMOUNT_UNIT}"
|
||||
out.append({**base, "비목": c, "묶음줄": True, "단가": _num(bundle.get(c)),
|
||||
"금액": _num(part), "글": text}) # fmt: skip
|
||||
continue
|
||||
amt, price = got.get("금액"), got.get("단가")
|
||||
text = f"{name} : {_u(eq_text(price), mu['price'])}{tail} = {one(amt or 0)} {AMOUNT_UNIT}"
|
||||
out.append({**base, "비목": line.get("비목"), "단가": _num(price), "금액": _num(amt),
|
||||
"글": text}) # fmt: skip
|
||||
return out
|
||||
|
||||
|
||||
def total_lines(answer: dict, lines: list[dict]) -> list[str]:
|
||||
"""계 줄 — 비목마다 「노무비 : 줄 + 줄 = 금액 원」(항이 넷 넘으면 금액만) ·
|
||||
「합계 : 금액 원」."""
|
||||
out = []
|
||||
for c in COSTS:
|
||||
terms = [
|
||||
x["금액"]
|
||||
for x in lines
|
||||
if x.get("비목") == c and not x["합밖"] and not x["꺼짐"] and x.get("금액")
|
||||
]
|
||||
v = answer.get(c)
|
||||
if _dec(v) is None:
|
||||
body = "—"
|
||||
elif 1 < len(terms) <= LONG_SUM:
|
||||
body = f"{' + '.join(one(t) for t in terms)} = {won(v)}"
|
||||
else:
|
||||
body = won(v) if terms or v else ""
|
||||
unit = f" {AMOUNT_UNIT}" if _dec(v) is not None and body else ""
|
||||
out.append(f"{COST_SHOW[c]} : {body}{unit}")
|
||||
total = answer.get("계")
|
||||
out.append(f"합계 : {_u(won(total), AMOUNT_UNIT) if _dec(total) is not None else '—'}")
|
||||
return out
|
||||
|
||||
|
||||
def sheet_groups(doc: dict, answer: dict, links) -> list[dict]:
|
||||
"""공용 계산서(`A00_Common/calc_sheet.ts`) 묶음 — 비목마다 줄
|
||||
`{이름, 글 「단가 * 수량 = 금액」, 금액, 묶음, 장비, 옵션꺼짐}` ·
|
||||
소계 = 셈 답 비목 값(끝수 뒤) ·
|
||||
합 밖 줄 · 비목 없는 줄 = 뺌."""
|
||||
groups: dict[str, list] = {c: [] for c in COSTS}
|
||||
for x in money_lines(doc, answer, links):
|
||||
c = x.get("비목")
|
||||
if c not in groups or x["합밖"]:
|
||||
continue
|
||||
mu = x["단위"]
|
||||
if x.get("까닭"):
|
||||
text = f"— {x['까닭']}"
|
||||
else:
|
||||
price = "—" if x["단가"] is None else _u(eq_text(x["단가"]), mu["price"])
|
||||
qty = "" if x["수량"] is None else " * " + _u(eq_text(x["수량"]), mu["qty"])
|
||||
text = f"{price}{qty} = {one(x['금액'] or 0)}"
|
||||
groups[c].append(
|
||||
{
|
||||
"이름": x["이름"],
|
||||
"글": text,
|
||||
"금액": x["금액"],
|
||||
"묶음": x["묶음"] or None,
|
||||
"장비": bool(x.get("묶음줄")) or None,
|
||||
"옵션꺼짐": x["꺼짐"] or None,
|
||||
}
|
||||
)
|
||||
return [
|
||||
{"비목": c, "소계": _num(answer.get(c)), "끝수": "", "줄": groups[c]}
|
||||
for c in COSTS
|
||||
if groups[c] or _dec(answer.get(c))
|
||||
]
|
||||
@@ -0,0 +1,71 @@
|
||||
/* 855-C 2-C4 거울 헬퍼 — 산출근거 글 규칙(TS)을 Node 로 돌림(`master_doc_text.py` 짝).
|
||||
* stdin = {수: [값], 단위: [글], 금액줄: [{줄, 단가변수, 부름}], 꺼짐: [{문서, 값}], 원: [수]}
|
||||
* stdout = {eq: [eqText], one: [one], won: [won], 단위: [unitText], 금액줄: [moneyUnits],
|
||||
* 꺼짐: [[offLine …] …], 비목: COST_SHOW, 항: LONG_SUM}
|
||||
* `one` · `won` · `COST_SHOW` · `LONG_SUM` = `line_stack_out.ts` 안 정의를 그대로 읽어 돌림(내보내지 않는 값). */
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
|
||||
|
||||
const cache = new Map();
|
||||
function load(at) {
|
||||
if (cache.has(at)) return cache.get(at);
|
||||
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const box = { exports: {} };
|
||||
cache.set(at, box.exports);
|
||||
const need = (p) => {
|
||||
if (p.endsWith(".css")) return {};
|
||||
return p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p);
|
||||
};
|
||||
new Function("exports", "module", "require", js)(box.exports, box, need);
|
||||
return box.exports;
|
||||
}
|
||||
const ROOT = path.join(__dirname, "..", "..");
|
||||
const eq = load(path.join(ROOT, "ui_template", "ui_template_equation.ts"));
|
||||
const unit = load(path.join(ROOT, "common_util", "common_util_line_stack_unit.ts"));
|
||||
const view = load(path.join(ROOT, "common_util", "common_util_formula_doc_view.ts"));
|
||||
const stack = load(path.join(ROOT, "common_util", "common_util_line_stack.ts"));
|
||||
|
||||
// line_stack_out.ts 안 정의(내보내지 않음) — 그 줄 글을 그대로 떼어 돌림
|
||||
const out = fs.readFileSync(path.join(ROOT, "A00_Common", "line_stack_out.ts"), "utf8");
|
||||
const grab = (re) => {
|
||||
const m = out.match(re);
|
||||
if (!m) throw new Error(`line_stack_out.ts 에서 못 찾음: ${re}`);
|
||||
return m[0];
|
||||
};
|
||||
const defs = [
|
||||
grab(/const COST_SHOW: Record<string, string> = \{[^}]*\};/),
|
||||
grab(/const won = \(n: number\): string => [^;]*;/),
|
||||
grab(/const one = \(n: number\): string =>\s*n\.toLocaleString\([^;]*;/),
|
||||
grab(/const LONG_SUM = \d+;/),
|
||||
].join("\n");
|
||||
const js = ts.transpileModule(`${defs}\nreturn { COST_SHOW, won, one, LONG_SUM };`, {
|
||||
compilerOptions: { target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const local = new Function("eqText", js)(eq.eqText);
|
||||
|
||||
const input = JSON.parse(fs.readFileSync(0, "utf8"));
|
||||
const res = {
|
||||
eq: (input.수 || []).map((v) => eq.eqText(v)),
|
||||
one: (input.원 || []).map((v) => local.one(v)),
|
||||
won: (input.원 || []).map((v) => local.won(v)),
|
||||
단위: (input.단위 || []).map((u) => unit.unitText(u)),
|
||||
금액줄: (input.금액줄 || []).map((x) =>
|
||||
unit.moneyUnits(
|
||||
x.줄,
|
||||
view.tryParse(x.줄.단가),
|
||||
view.tryParse(x.줄.수량),
|
||||
x.단가변수 || undefined,
|
||||
x.부름 || null,
|
||||
),
|
||||
),
|
||||
기호: (input.금액줄 || []).map((x) => stack.priceSym(x.줄)),
|
||||
꺼짐: (input.꺼짐 || []).map((x) =>
|
||||
(x.문서.금액 || []).map((line) => view.offLine(line, x.값, view.lineMap(x.문서))),
|
||||
),
|
||||
비목: local.COST_SHOW,
|
||||
항: local.LONG_SUM,
|
||||
};
|
||||
process.stdout.write(JSON.stringify(res));
|
||||
@@ -11,10 +11,12 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as m01_doc
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M01_MasterData.M01_MasterData_Store_Find import hit
|
||||
from M02_MasterTemplete import M02_Logic_Standard as st
|
||||
@@ -30,18 +32,20 @@ def _rows(key: str) -> list[dict]:
|
||||
|
||||
def _given(key: str, change: dict) -> dict:
|
||||
whole = m01.loaded()[1]
|
||||
return st._given(whole, whole.logic(key), change)[0]
|
||||
return st._given(whole, m01_doc.docs()[key], change)[0]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("key", THREE)
|
||||
def test_줄_금액은_M01_시험_계산에_끝수만_버림(key: str) -> None:
|
||||
def test_줄_금액은_M01_수식_탭_셈과_같음(key: str) -> None:
|
||||
"""855-C — 기준 목록 금액 = 수식 문서 셈(M01 수식 탭 미리 셈 · M02 단가산출과 같은 계산기)."""
|
||||
rows = _rows(key)
|
||||
assert rows
|
||||
doc = json.loads(json.dumps(m01_doc.docs()[key], default=float)) # 화면 JSON 꼴 문서
|
||||
for row in rows:
|
||||
got = m01.calc(key, _given(key, row["바꿈"]))
|
||||
assert got["ok"], got
|
||||
gap = float(got["sums"]["계"]) - row["금액"] # 줄 · 비목 버림(B09 산근 규칙) — 최대 3 원
|
||||
assert -0.01 <= gap < 3.2, row["규격"]
|
||||
given = st.labor_inputs._num(_given(key, row["바꿈"]))
|
||||
got = m01_doc.preview(doc, given)["셈"]
|
||||
assert got["셈됨"], row["규격"]
|
||||
assert float(got["계"]) == row["금액"], row["규격"]
|
||||
|
||||
|
||||
def test_대표_규격_펼침() -> None:
|
||||
|
||||
@@ -13,6 +13,7 @@ if str(ROOT) not in sys.path:
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Doc as m01_doc # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # noqa: E402
|
||||
from M02_MasterTemplete import M02_Logic_Settle as st # noqa: E402
|
||||
from M02_MasterTemplete import M02_Logic_Standard as ls # noqa: E402
|
||||
@@ -39,7 +40,7 @@ def test_줄마다_버림_비목마다_버림_B09와_같음():
|
||||
for row in data.get("줄") or []:
|
||||
if not _plain(row) or checked >= 60:
|
||||
continue
|
||||
base, _ = ls.axes(whole, row)
|
||||
base, _ = ls.axes(whole, m01_doc.docs()[row["키"]])
|
||||
given = mf.fill_empty(row, base)
|
||||
got = mf.run(whole, row["키"], given)
|
||||
lines = []
|
||||
@@ -70,6 +71,5 @@ def test_계산서_줄_소계_계가_맞물림():
|
||||
assert group["소계"] == int(group["소계"])
|
||||
assert group["소계"] <= sum(lines) < group["소계"] + 1 + Decimal("0.05"), group["비목"]
|
||||
assert got["계"] == sum(g["소계"] for g in got["묶음"])
|
||||
assert got["계"] == ls._money(
|
||||
whole, whole.logic(key), ls._given(whole, whole.logic(key), {})[0]
|
||||
)
|
||||
doc = m01_doc.docs()[key] # 855-C 계산서 = 문서 셈(목록 금액과 같은 값)
|
||||
assert got["계"] == ls._money(doc, ls._links(whole), ls._given(whole, doc, {})[0])
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) · M01 `/text` 와
|
||||
M02 `/logic-lib/sheet` 가 같은 줄 꼴(`master_sheet_line`)."""
|
||||
"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) — M01 `/text`.
|
||||
(M02 `/logic-lib/sheet` 는 855-C 부터 문서 셈 · `master_doc_text` 글 — `test_855_c4_doc_text`.)"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
@@ -11,10 +11,8 @@ sys.path.insert(0, str(ROOT))
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store_Sheet as sheet # noqa: E402
|
||||
from M02_MasterTemplete import M02_Logic_Standard as standard # noqa: E402
|
||||
|
||||
msl = sheet.msl
|
||||
num = standard.labor_inputs._num # Decimal → JSON 수(두 길 같은 규칙)
|
||||
|
||||
|
||||
def _text(key: str) -> dict:
|
||||
@@ -61,15 +59,3 @@ def test_basis_note_tenfold():
|
||||
assert one[0]["기준단위"] == "10㎡" and one[0]["환산근거"] == "10㎡당 → 1㎡당 ÷10"
|
||||
ten = _text("GF000124")
|
||||
assert ten["기준단위"] == "10㎡" and all(not x["환산근거"] for x in _lines(ten))
|
||||
|
||||
|
||||
def test_two_routes_same_shape():
|
||||
"""M01 `/text` 와 M02 계산서 — 줄 차례 · 덧칸 값이 같음(금액 끝수만 다를 수 있음)."""
|
||||
for key in ("GF000169", "GF000103", "GF000219"):
|
||||
m01 = _lines(_text(key))
|
||||
m02 = _lines(standard.sheet(key, {}), "묶음")
|
||||
assert len(m01) == len(m02)
|
||||
for a, b in zip(m01, m02):
|
||||
assert set(b) == {"이름", "글", "금액", *msl.KEYS}
|
||||
assert a["이름"] == b["이름"]
|
||||
assert num([a.get(k) for k in msl.KEYS]) == [b.get(k) for k in msl.KEYS]
|
||||
|
||||
@@ -0,0 +1,155 @@
|
||||
"""855-C 2-C4 지킴 — 서버 산출근거 글(`master_doc_text`) · 기준 목록 · 계산서가 문서 셈.
|
||||
|
||||
① 거울 — 글 규칙이 화면 TS 와 같음(헬퍼 `helper_855_c4_doc_text.cjs`):
|
||||
수 꼴(`eqText` · 줄 금액 · 원) · 단위 글(`unitText`) · 금액 줄 단위 자리 · 단가 기호
|
||||
(`moneyUnits` · `priceSym`) · 선택으로 꺼진 줄(`offLine`) · 비목 이름 — 실제 M01 수식 문서 전부
|
||||
(기본 입력 셈 답)로.
|
||||
② 계산서 — 줄 금액 · 소계 · 계 = 문서 셈 답 그대로 · 소계 합 = 계 ·
|
||||
줄 글 「단가 원/단위 * 수량 단위 = 금액」.
|
||||
③ 기준 목록 줄 금액 = 같은 입력의 문서 셈 계.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
from decimal import Decimal
|
||||
from functools import lru_cache
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as m01_doc
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Logic_Standard as st
|
||||
|
||||
mc = importlib.import_module("master_doc_calc")
|
||||
md = importlib.import_module("master_doc")
|
||||
mdt = importlib.import_module("master_doc_text")
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
NUMS = [0, 1, -1, 0.5, 1.5, 2.5, -2.5, 0.05, 0.15, 0.25, 0.35, 1.05, 1.15, 1.25, 2.675, 99.95,
|
||||
-0.05, 0.1 + 0.2, 1e-7, 1234567.891234567, 59018.0857142857, 284.42142857142,
|
||||
123456789012.345, 26890.75, 1502.04999] # fmt: skip
|
||||
|
||||
|
||||
def _js(v):
|
||||
if isinstance(v, Decimal):
|
||||
return float(v)
|
||||
if isinstance(v, dict):
|
||||
return {k: _js(x) for k, x in v.items()}
|
||||
if isinstance(v, (list, tuple)):
|
||||
return [_js(x) for x in v]
|
||||
if isinstance(v, (mc.Blank, mc.Stop)):
|
||||
return None
|
||||
return v
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def world():
|
||||
"""(문서들, 연결, {키: 기본 셈 답})."""
|
||||
whole = m01.loaded()[1]
|
||||
docs = m01_doc.docs()
|
||||
links = st._links(whole)
|
||||
answers = {k: mc.calc(d, links, None) for k, d in docs.items() if d.get("금액")}
|
||||
return docs, links, answers
|
||||
|
||||
|
||||
def _helper(payload: dict) -> dict:
|
||||
run = subprocess.run(
|
||||
["node", os.path.join(HERE, "helper_855_c4_doc_text.cjs")],
|
||||
input=json.dumps(payload, ensure_ascii=False),
|
||||
capture_output=True,
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
check=True,
|
||||
)
|
||||
return json.loads(run.stdout)
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def mirror():
|
||||
docs, links, answers = world()
|
||||
nums, units, lines, offs, py = list(NUMS), set(), [], [], {"단위": [], "줄": [], "꺼짐": []}
|
||||
for key, a in answers.items():
|
||||
doc = docs[key]
|
||||
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
units |= {str(v.get("단위") or "") for v in doc.get("변수") or []}
|
||||
units.add(str(doc.get("결과단위") or ""))
|
||||
for row in a.get("줄") or []:
|
||||
nums += [_js(row.get(k)) for k in ("단가", "수량", "금액")]
|
||||
for line in doc["금액"]:
|
||||
units.add(str(line.get("단위") or ""))
|
||||
sym = mdt.price_sym(line)
|
||||
pv = vars_.get(sym) if sym else None
|
||||
link = (pv or {}).get("연결") or {}
|
||||
sub = None
|
||||
if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]):
|
||||
got = links.doc(str(link["키"]))
|
||||
sub = {"결과단위": got.get("결과단위")} if got else None
|
||||
lines.append({"줄": _js(line), "단가변수": _js(pv), "부름": sub})
|
||||
nodes = (mdt.node_of(line.get("단가")), mdt.node_of(line.get("수량")))
|
||||
py["줄"].append((mdt.money_units(line, *nodes, pv, sub), sym))
|
||||
look = mdt._Look(doc, a, links)
|
||||
vals = {k: v for k, v in (a.get("값") or {}).items() if v is not None}
|
||||
part = {"식": _js(doc.get("식") or []), "금액": _js(doc["금액"])}
|
||||
offs.append({"문서": part, "값": _js(vals)})
|
||||
py["꺼짐"].append([look.off_line(line) for line in doc["금액"]])
|
||||
nums = [x for x in nums if isinstance(x, (int, float))]
|
||||
units |= {"%(인력품 대비)", "10^-7/시간", "kWh/hr", "줄 따름", "수(개)", "원문 단위 없음"}
|
||||
units = sorted(units)
|
||||
ts = _helper({"수": nums, "원": nums, "단위": units, "금액줄": lines, "꺼짐": offs})
|
||||
return nums, units, py, ts
|
||||
|
||||
|
||||
def test_수_꼴_eqText_한자리_원():
|
||||
nums, _, _, ts = mirror()
|
||||
assert len(nums) > 5000
|
||||
assert [mdt.eq_text(v) for v in nums] == ts["eq"]
|
||||
assert [mdt.one(v) for v in nums] == ts["one"]
|
||||
assert [mdt.won(v) for v in nums] == ts["won"]
|
||||
texts = ("5401-0017", "", " ", "1048")
|
||||
assert [mdt.eq_text(v) for v in texts] == ["5401-0017", "", " ", "1,048"]
|
||||
|
||||
|
||||
def test_단위_글_금액줄_단위_자리_단가_기호():
|
||||
_, units, py, ts = mirror()
|
||||
assert [mdt.unit_text(u) for u in units] == ts["단위"]
|
||||
assert len(py["줄"]) > 5000
|
||||
assert [u for u, _ in py["줄"]] == ts["금액줄"]
|
||||
assert [s for _, s in py["줄"]] == ts["기호"]
|
||||
assert any(u["wrap"] for u, _ in py["줄"]) and any(u["price"] for u, _ in py["줄"])
|
||||
|
||||
|
||||
def test_선택으로_꺼진_줄_비목_이름():
|
||||
_, _, py, ts = mirror()
|
||||
assert py["꺼짐"] == ts["꺼짐"]
|
||||
assert sum(map(sum, py["꺼짐"])) > 0 # 꺼진 줄이 실제로 있음(판정이 일을 함)
|
||||
assert mdt.COST_SHOW == ts["비목"] and mdt.LONG_SUM == ts["항"]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("key", ("GF000220", "GF000089", "GC000404", "GF000101"))
|
||||
def test_계산서_문서_셈_답_그대로(key):
|
||||
got = st.sheet(key, {})
|
||||
docs, links, _ = world()
|
||||
answer = mc.calc(docs[key], links, st._given(m01.loaded()[1], docs[key], {})[0])
|
||||
assert got["계"] == float(answer["계"]) and got["계"] == sum(g["소계"] for g in got["묶음"])
|
||||
for g in got["묶음"]:
|
||||
assert g["소계"] == float(answer[g["비목"]])
|
||||
for line in g["줄"]:
|
||||
assert line["글"].endswith(f"= {mdt.one(line['금액'] or 0)}")
|
||||
assert " * " in line["글"] or line["글"].startswith("—")
|
||||
first = got["묶음"][0]["줄"][0]
|
||||
if key == "GF000220": # 석공 노임 — 「268,908 원/인 * 0.1 인 = 26,890.8」
|
||||
assert first["이름"] == "석공" and first["글"].startswith("268,908 원/인 * 0.1 인 = ")
|
||||
|
||||
|
||||
def test_기준_목록_금액_문서_셈():
|
||||
whole = m01.loaded()[1]
|
||||
docs, links, _ = world()
|
||||
for key in ("GF000220", "GC000404", "GX000004"):
|
||||
for row in st._rows_of(whole, whole.logic(key), False, links):
|
||||
given = st._given(whole, docs[key], row["바꿈"])[0]
|
||||
want = mc.calc(docs[key], links, given)
|
||||
assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"])
|
||||
Reference in New Issue
Block a user