Merge remote-tracking branch 'origin/main_laptop_1' into sub_laptop_1

This commit is contained in:
2026-11-17 01:11:07 +09:00
8 changed files with 424 additions and 27 deletions
+1 -1
View File
@@ -1,7 +1,7 @@
/* =============================================================================
* formula_doc_options.ts
* 수식 문서 옵션 가로(PLAN 802-3 · 802-4b-2 · 요구 655 「옵션 선택은 상단에 수평」) — 선택 · 입력 기호마다 칸 하나
* 값 = 화면 값(`given`) › 문서 값 · 고침은 부른 쪽 `set`(M01 = 화면 값만 · M02 사본 = 문서 값) · `lock` = 읽기만
* 값 = 화면 값(`given`) › 문서 값 · 고침은 부른 쪽 `set`(M01 = 고칠 권한 = 문서 기본값 · 읽기 = 화면 값만 · M02 사본 = 문서 값 · 848-10) · `lock` = 읽기만
* 목록이 모두 기계 원문번호(`0101-0007`)면 글 = 「이름 규격 (원문번호)」(요구 692-2 · 값은 그대로 · 이름은 한 번 받아 둠)
* `view` 있음 + 기계 목록 = 곁에 [조회](827-1 · 기계 창 읽기 전용 · 고른 기계)
* `hide` = 안 그릴 기호(847-1 시간당 식 줄이 안 읽게 된 옵션 · 값은 그대로)
+2 -1
View File
@@ -329,7 +329,8 @@ export function createStackScreen(opt: StackScreenOptions) {
}
const setOption = (k: string, v: DocVar, x: unknown): void => {
const at = doc?.변수?.indexOf(v) ?? -1;
if (cp) return change((d) => at >= 0 && (d.변수![at].연결 = { ...v.연결!, 값: x }));
// 848-10 M01 기초 = 고칠 권한이면 옵션 기본값(M02 새 단가산출이 이 값으로 시작) · 읽기 = 화면 값만
if (cp || edit()) return change((d) => at >= 0 && (d.변수![at].연결 = { ...v.연결!, 값: x }));
given[k] = x;
recalc();
draw();
+53 -8
View File
@@ -14,6 +14,9 @@ SK 금액(기준 · 1 단위 = 기준 ÷ 배) = 문서 셈 — 일위대가 ·
위 층 덮음(848-1) = `수식.위덮음`(① · 기초 문서 `기계덮음` 사본 · 문서 `기계덮음` = ② 내 고침만) —
프로젝트 층 밖 = 셈마다 지금 기초 것(`upper`) · [저장] 때 굳음 · 프로젝트 층 · 가져온 식 = 저장본 ·
파생 문서(`derive`)는 기초 문서의 `기계덮음` 을 떼고 복사(② 와 안 섞임).
기초 문서(848-10) = 프로젝트 층 밖 = 지금 M01 문서 그대로(옵션 기본 포함 · 옛 로직 줄
자동값 안 씀 · 내가 고른 값만 얹음) · 굳힌 사본 · 프로젝트 층 = `수식.바탕문서`(굳힐 때 ·
손고침 기초를 저장할 때 사본) › 옛 길(옛 사본 금액 그대로).
"""
from __future__ import annotations
@@ -37,6 +40,9 @@ import master_doc_cover as mcv # noqa: E402 — scripts 길 = dc
KEY = dc.KEY
UPPER = mcv.UPPER
BASE_DOC = (
"바탕문서" # `수식` 칸(848-10) — 기초 문서 사본(손고침 기초 · 굳힌 사본) · 프로젝트 셈의 기초
)
OLD_FIELDS = (
"바탕", "입력값", "열린입력", "덮개", "뺀줄", "더한줄", "뺀더한줄", "상수덮개", "표값덮개",
"수식고침", "고름", "자재표시", "켜쌓기율",
@@ -79,27 +85,61 @@ def _set_values(doc: dict, given: dict) -> None:
link["값"] = given[var["열쇠"]]
def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]:
"""기초 문서(848-10) → (문서, 옵션 기본을 문서에서 읽음) — 프로젝트 층 밖 = 지금 M01 문서 ·
그 밖(굳힌 사본 · 프로젝트 층) = 굳힐 때 사본 `바탕문서` › 손고침 기초 = 빌더 문서
(굳은 뒤 고침 안 받음) › 지금 문서 · 문서에서 안 읽음 = 옛 로직 줄 자동값
(옛 사본 금액 그대로)."""
live = dc.folder().get(key)
if renew.on() and live is not None:
return dc.doc_of(whole, key), True
kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None
if kept:
return cp.deepcopy(kept), True
if live is not None and live.get(mcv.HAND):
from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게
return m01.built(key), False
return dc.doc_of(whole, key), False
_PATCH = ("덮개", "뺀줄", "더한줄", "뺀더한줄", "상수덮개", "표값덮개", "수식고침")
def patched(sk: dict) -> bool:
"""옛 칸이 기초 줄을 고친 SK — 파생 문서 = 고친 줄 변환(기초 문서 사본 `바탕문서` 안 씀)."""
return any(sk.get(k) not in (None, {}, []) for k in _PATCH)
def _bare_doc(doc: dict) -> dict:
return {k: v for k, v in doc.items() if k not in (mcv.COVER, mcv.HAND)}
def derive(sk: dict, ctx: tuple) -> dict:
"""옛 칸이 낸 고친 줄(`ctx` = run 이 엔진에 넣은 (색인, 키, 입력, 바탕 답)) → 이 SK 문서.
덮개 없는 바탕(고친 줄 = 바탕 줄) = 그 M01 문서 사본 · 아니면 고친 줄 변환."""
덮개 없는 바탕(고친 줄 = 바탕 줄) = 기초 문서(`base_doc`) 사본 · 아니면 고친 줄 변환 ·
옵션 = 기초 문서 기본 위에 내가 고른 값(848-10 · 옛 로직 줄 자동값이 기초 고침을 안 이김)."""
whole, key, values, got, mats = ctx
row = whole.logic(key)
given = dc.given_of(whole, key, values)
mine = {k: v for k, v in given.items() if k in (values or {})} # 내가 고른 값
base_key = str((sk.get("바탕") or {}).get("로직") or "")
plain = None
plain, real = None, False
if base_key:
try:
frozen = whole.logic(base_key)
same = {**row, "키": base_key} == frozen
except dc._ERR:
same = False
plain = dc.doc_of(whole, base_key) if same else None
plain, real = base_doc(sk, whole, base_key) if same else (None, False)
if plain is not None:
doc = cp.deepcopy({k: v for k, v in plain.items() if k != mcv.COVER}) # ① = `위덮음`(848-1)
_set_values(doc, given)
doc = cp.deepcopy(_bare_doc(plain)) # ① = `위덮음`(848-1)
_set_values(doc, mine if real else given)
elif not (row.get("호표") or row.get("덧줄") or row.get("결과")):
doc = dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))
else:
live = dc.folder().get(base_key) if base_key and renew.on() else None
given = {**given, **renew._opts(live), **mine} if live else given
doc = dc.cv.convert(whole, row, given)[0]
apart = dc.apart_of(got.get("자재표시"), mats)
doc = dc.line_doc(doc, got.get("켜쌓기율"), got.get("고름") or None, apart)
@@ -119,13 +159,18 @@ def seed(sk: dict) -> dict | None:
return {**empty, "문서": dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))}
def with_upper(sk: dict, got: dict) -> dict:
"""① 위 층 덮음을 지금 기초(`바탕.로직`) 문서 `기계덮음` 으로(848-1) — 없으면 칸 뺌 · 기초 문서 없음 = 그대로 ·
① 이 부르는 시간당 작업량 식 = 부름 닫힌 묶음에 더함."""
def with_upper(sk: dict, got: dict, keep: bool = False) -> dict:
"""① 위 층 덮음을 지금 기초(`바탕.로직`) 문서 `기계덮음` 으로(848-1) — 없으면 칸 뺌 ·
기초 문서 없음 = 그대로 · ① 이 부르는 시간당 작업량 식 = 부름 닫힌 묶음에 더함 ·
기초 문서 사본 `바탕문서`(848-10) = 손고침 기초 · `keep`(굳히기) = 늘 · 옛 칸이 줄을 고친 SK 빼고 —
프로젝트 사본이 굳힐 때 기초 문서로 셈(`base_doc`)."""
key = str((sk.get("바탕") or {}).get("로직") or "")
live = dc.folder().get(key) if key else None
if live is None:
return got
got = {k: v for k, v in got.items() if k != BASE_DOC}
if (keep or live.get(mcv.HAND)) and not patched(sk):
got[BASE_DOC] = norm(_bare_doc(live)) # JSON 꼴(굳힌 사본 · 저장 파일)
cover = mcv.cover_of(live)
if not cover:
return {k: v for k, v in got.items() if k != UPPER} if UPPER in got else got
+14 -9
View File
@@ -104,8 +104,9 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]:
def layers(copy: dict, sk: dict) -> dict[str, Any]:
"""848-8 바뀐 자리 바탕 — {위: 위 층 문서, 빌더?: 기초가 손고침이면 빌더 문서} · 모름 = 빈 묶음.
위 층 = 그 기초 문서(지금 · 덮음 · 손고침 표지 뺌 · 옵션 값 = 파생과 같게 옛 로직 줄 기본) ·
가져온 식 = 불러올 때 문서(따로 = `처음` · 아니면 지금 파생) · 읽기만(파일 안 씀)."""
위 층 = 파생과 같은 기초 문서(`dsk.base_doc` · 덮음 · 손고침 표지 뺌 · 옵션 값 = 그 문서 기본 ·
옛 길 = 옛 로직 줄 기본) · 가져온 식 = 불러올 때 문서(따로 = `처음` · 아니면 지금 파생) ·
읽기만(파일 안 씀)."""
if dim.is_imported(sk):
up = copy.get(renew.FIRST) if copy.get("따로") else copy.get("문서")
out = {"위": up} if up else {}
@@ -114,16 +115,20 @@ def layers(copy: dict, sk: dict) -> dict[str, Any]:
live = dc.folder().get(key) if key else None
if live is None:
return {}
out = {"위": {k: v for k, v in live.items() if k not in (mcv.COVER, mcv.HAND)}}
if live.get(mcv.HAND):
top, real = dsk.base_doc({**sk, dsk.KEY: copy}, dc.over(copy), key)
if top is None:
return {}
out = {"위": dsk._bare_doc(top)}
if live.get(mcv.HAND) and renew.on():
from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게
if (top := m01.built(key)) is not None:
out["빌더"] = top
if (built := m01.built(key)) is not None:
out["빌더"] = built
out = json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str)) # 사본
auto = dc.given_of(skc.whole_(), key, {}) # `derive` 와 같은 옵션 값
for doc in out.values():
dsk._set_values(doc, auto)
if not real: # 옛 길 — `derive` 와 같은 옵션 값
auto = dc.given_of(skc.whole_(), key, {})
for doc in out.values():
dsk._set_values(doc, auto)
return json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str))
+1 -1
View File
@@ -102,7 +102,7 @@ def _upper(doc: dict) -> dict:
from M02_MasterTemplete import M02_Doc_Import as dim
from M02_MasterTemplete import M02_Doc_Sk as dsk
return doc["수식"] if dim.is_imported(doc) else dsk.with_upper(doc, doc["수식"])
return doc["수식"] if dim.is_imported(doc) else dsk.with_upper(doc, doc["수식"], keep=True)
def _patched(doc: Any) -> list[int]:
+87 -4
View File
@@ -171,6 +171,67 @@ def _replay(mine: dict, first: Any, live: Any) -> tuple[dict, list[str], list[st
return put, [f"{k} {v}" for k, v in put.items()], lost
LABEL = dc.LABEL # 변수 · 식 · 금액 줄 글 칸 — 위가 바꾸면 안 고친 줄은 따라옴(848-10)
_ROWS = (("변수", dc.md.var_id), ("식", lambda x: str(x.get("기호") or "")))
def _relabel(mine: dict, first: dict, live: dict) -> None:
"""글만 바뀐 줄 = 안 고친 줄(원본 줄 그대로)만 새 글로 — `mine` · `first` 제자리.
금액 = 차례(셈 같음 = 같은 차례) · 변수 = 기호 · 식 = 기호."""
pairs: list[tuple[dict, dict]] = []
a, b = first.get("금액") or [], live.get("금액") or []
pairs += list(zip(a, b)) if len(a) == len(b) else []
for part, key in _ROWS:
now = {key(x): x for x in live.get(part) or []}
pairs += [(x, now[key(x)]) for x in first.get(part) or [] if key(x) in now]
for old, new in pairs:
if all(old.get(k) == new.get(k) for k in LABEL):
continue
fresh = {
**{k: v for k, v in old.items() if k not in LABEL},
**{k: new[k] for k in LABEL if k in new},
}
for part in ("금액", "변수", "식"):
rows = mine.get(part) or []
for n, x in enumerate(rows):
if x == old:
rows[n] = cp.deepcopy(fresh)
old.clear()
old.update(fresh)
def _soft(mine: dict, first: dict, live: dict, held: set, opts: bool, confirm: bool):
"""따로 문서 — 위 기초가 옵션 기본 · 글만 바꿈(848-10) → (새 문서, 새 원본,
지킨 옵션 [(열쇠, 전, 후, 내값)]) · 계산 구조가 바뀜 = None(다시 복사).
옵션: 안 고른 열쇠 = 새 기본 따라옴(원본도) · 고른 열쇠 = 내 값 지킴 + 알림(원본 그대로 =
[확인] 까지 · 옛 칸 `입력값` 고름 = 알림 없이 지킴) · 글: 안 고친 줄만 새 글 ·
`opts` 거짓 = 계산 내용 그대로(글만 봄)."""
was, have, now = _opts(first), _opts(mine), _opts(live)
if opts and dc.doc_fp(put_opts(live, was)) != dc.doc_fp(first):
return None
mine, first = cp.deepcopy(mine), cp.deepcopy(first)
_relabel(mine, first, live)
follow, kept, ack = {}, [], {}
for k, v in now.items() if opts else ():
if k not in was or mcv._canon(v) == mcv._canon(was[k]):
continue
if k in held or (k in have and mcv._canon(have[k]) != mcv._canon(was[k])):
kept += [] if k in held else [(k, was[k], v, have.get(k))]
ack[k] = v
else:
follow[k] = v
mine, first = put_opts(mine, follow), put_opts(first, {**follow, **(ack if confirm else {})})
return mine, first, [] if confirm else kept
def _opt_note(key: str, doc: dict, kept: list) -> dict:
return {
"키": key, "이름": str(doc.get("이름") or key), "갈래": "문서", "처리": "지킴",
"M01": [f"{k} {_txt(a)} → {_txt(b)}" for k, a, b, _ in kept],
"내고침": [f"{k} {_txt(m)}" for k, _, _, m in kept], "다시얹음": [],
} # fmt: skip
def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) -> Any:
"""수식 사본 → 지금 M01 으로 본 것(값 줄 · 부름) · 기계 고침 = 칸 단위 지킴(`_covers`) ·
계산 내용이 바뀐 고친 문서(끊음 · 따로) = 다시 복사(옵션 값 · ② 다시 얹음) ·
@@ -190,10 +251,20 @@ def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) ->
calls[k] = cp.deepcopy(live[k])
redo = {k for k in moved if dc.doc_fp((got.get("부름") or {}).get(k)) != dc.doc_fp(live[k])}
cut = dict(out.get("끊음") or {})
for k in sorted(redo & set(cut)):
mine, was = cut.pop(k), (got.get("부름") or {}).get(k)
if dc.doc_fp(mine) == dc.doc_fp(was):
for k in sorted(moved & set(cut)):
was = (got.get("부름") or {}).get(k)
if k in redo and dc.doc_fp(cut[k]) == dc.doc_fp(was):
cut.pop(k)
continue # 안 고친 끊음 = 조용히 따라옴
soft = _soft(cut[k], was, live[k], set(), k in redo, False) if was else None
if soft is not None: # 옵션 기본 · 글만 바뀜 = 끊음 지킴 · 고른 옵션 알림(848-10)
cut[k] = soft[0]
if soft[2] and notes is not None:
notes.append(_opt_note(k, live[k], soft[2]))
continue
if k not in redo:
continue
mine = cut.pop(k)
put, again, lost = _replay(mine, was, live[k])
if put:
cut[k] = put_opts(cp.deepcopy(live[k]), put)
@@ -202,7 +273,19 @@ def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) ->
out |= {"부름": calls, "끊음": cut}
base = out.get("원본") or {}
key = str(base.get("키") or "")
if out.get("따로") and key in live and not dc.same_origin(base, live[key]):
moved_doc = out.get("따로") and key in live and not dc.same_origin(base, live[key])
if out.get("따로") and key in live and out.get(FIRST) is not None:
held = set((sk.get("입력값") or {}) if isinstance(sk.get("입력값"), dict) else ())
soft = _soft(out["문서"], out[FIRST], live[key], held, bool(moved_doc), confirm)
if soft is not None: # 옵션 기본 · 글만 바뀜 = 다시 복사 없이 얹음(848-10)
mine, first, kept = soft
out |= {"문서": mine, FIRST: first}
if moved_doc and (confirm or not kept):
out["원본"] = {**base, "판": dc.doc_fp(live[key])}
if kept and notes is not None:
notes.append(_opt_note(key, mine, kept))
moved_doc = False
if moved_doc:
first = out.get(FIRST)
mine = out.get("문서") or {}
put: dict = {}
+22 -3
View File
@@ -259,7 +259,8 @@ function setValue(d: StackDoc, id: string, was: ReturnType<typeof valueAt>): voi
if (was?.식 !== undefined) d.식.push({ 기호: id, 식: was.식 });
}
/** 빠진 줄 되살림 — `src` 금액 줄 `at` 을 항목 `k` 에(앞 짝 줄 뒤) · 그 줄이 부르는 기호 중 없는 것도 */
/** 빠진 줄 되살림 — `src` 금액 줄 `at` 을 제 그룹(`home` · 그룹째 빠졌으면 제목째 새로 · 제목 없음 = 항목 `k`)에
* (앞 짝 줄 뒤) · 그 줄이 부르는 기호 중 없는 것도 */
export function restoreLines(
d: StackDoc,
items: StackItem[],
@@ -280,6 +281,8 @@ export function restoreLines(
(uses.get(id) ?? []).forEach(pull);
};
const match = matchLines(d.금액 ?? [], src.금액 ?? []);
const srcItems = stackOf(src);
const srcOf = itemOfLine(srcItems);
for (const b of [...at].sort((x, y) => x - y)) {
const line = clone((src.금액 ?? [])[b]);
if (!line) continue;
@@ -289,10 +292,26 @@ export function restoreLines(
}
const n = (d.금액 ??= []).push(line) - 1;
match[n] = b;
const into = home(items, srcItems, srcOf.get(b) ?? -1) ?? it;
let p = 0; // 앞 짝 줄 뒤
it.줄.forEach((l, j) => {
into.줄.forEach((l, j) => {
if (l.꼴 === "금액" && match[l.i] >= 0 && match[l.i] < b) p = j + 1;
});
it.줄.splice(p, 0, { 꼴: "금액", i: n });
into.줄.splice(p, 0, { 꼴: "금액", i: n });
}
}
/** 되살릴 줄의 제 그룹(848-10) — `src` 그룹 제목이 있으면 그 제목 항목 › 없으면 새 항목
* (`src` 차례에서 앞 그룹들 뒤) · 제목 없음 = undefined(누른 항목) */
function home(items: StackItem[], src: StackItem[], si: number): StackItem | undefined {
const title = src[si]?.제목 ?? "";
if (!title) return undefined;
const have = items.find((x) => x.제목 === title);
if (have) return have;
const before = new Set(src.slice(0, si).map((x) => x.제목));
let at = 0;
items.forEach((x, j) => before.has(x.제목) && (at = j + 1));
const it: StackItem = { 제목: title, 줄: [] };
items.splice(at, 0, it);
return it;
}
+244
View File
@@ -0,0 +1,244 @@
# ruff: noqa: F811 — 임시 층 · 임시 수식 문서 폴더 fixture 를 다른 시험에서 받아 씀
"""848-10 M01 기초 고침이 M02 단가산출로 내려감(요구 887 · 889 · 요구서_889 1 · 3 절).
㉡ 새 단가산출 = 고친 기초 그 상태(옵션 기본 · 입력 기본 · 줄 수량 · 줄 뺌 · 기계 고침 · 작업량 방식) —
문서 = 기초 문서 · 위덮음 = 기초 기계덮음 · 금액 = 기초 금액.
㉢ 있던 단가산출 — 안 고친 것 = 따라옴 · 다른 옵션을 고른 것 = 내 값 지킴 + 나머지 따라옴 ·
같은 옵션을 고른 것 = 내 값 지킴 + 알림 → [확인] 뒤 알림 없음 · 줄을 고친 것 + 옵션 기본 바뀜 = 줄 고침 지킴
(다시 복사 아님) · 기초 줄 이름만 바뀜 = 안 고친 줄 이름 따라옴.
㉣ 프로젝트 사본 — 고치기 전 굳힌 것 = 그대로 · 고친 뒤 굳힌 것 = 그때 단가산출 금액(손고침 기초 사본).
㉤ 손고침 기초 = 빌더가 안 덮음(그 로직 파일 글 = 저장본) · SK 층바탕 = {위: 기초, 빌더} → 기초에서 바꾼 옵션 = 위(주황).
㉥ 기초가 그룹째 뺀 줄 되살림 = 제 그룹(제목)으로 · 처음 문서 차례.
정본 파일 안 고침 — 수식 문서 폴더 = 임시 사본 · 층 = 임시 storage.
"""
from __future__ import annotations
import copy as cp
import importlib
import json
import shutil
import pytest
from M01_MasterData import M01_MasterData_Doc as m01doc
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Item_Prices as item_prices
from M02_MasterTemplete import M02_Item_Source as source
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
from resources.tester.test_848_1_cover_layers import docs_tmp # noqa: F401
from resources.tester.test_848_8_diff import _node
from resources.tester.test_m02_labor_ref import world # noqa: F401
ml = importlib.import_module("master_doc_link")
mcv = importlib.import_module("master_doc_cover")
cv = importlib.import_module("master_doc_convert")
build = importlib.import_module("build_수식문서_802_2")
CON = "GC000198" # 레디믹스트콘크리트 타설 — 선택 · 입력 옵션 · 인력 둘 · 굴착기 · 공구손료
CUT = "GC000088" # 터파기(기계) — 옵션 Type 이 굴착기를 고름
NO, SYM = "0201-0100", "P_굴착기무한궤"
def _j(v):
return json.loads(json.dumps(ml._norm(v), ensure_ascii=False, default=str))
def _at(folder, fn, *a):
with store.at(folder):
return fn(*a)
def _sk(me, base: str) -> str:
body = {"이름": "sub2임시 848-10", "단위": "㎥", "더한줄": [], "바탕": {"로직": base}}
return _at(me, lambda: refs.create("sangeun", body)["이름"])
def _read(folder, key):
return _at(folder, path.read, key)
def _edit_sk(me, key, fn) -> None:
got = _read(me, key)
doc = cp.deepcopy(got["문서"])
fn(doc)
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
def _m01(key, fn) -> dict:
doc = _j(m01doc.read(key)["문서"])
fn(doc)
return m01doc.save(doc)
def _opt(key, val):
def fn(d):
next(v for v in d["변수"] if v.get("열쇠") == key)["연결"]["값"] = val
return fn
def _val(doc, key):
return renew._opts(doc).get(key)
def _bare(doc) -> str:
drop = ("키", "이름", mcv.COVER, mcv.HAND, "쌓기", "판", "꼴")
return dc.fp(_j({k: v for k, v in (doc or {}).items() if k not in drop}))
def _is_base(got, key) -> bool:
"""단가산출 = 그 기초 그대로(문서 · 위덮음 · 금액)."""
live = dc.folder()[key]
return (
_bare(got["문서"]) == _bare(live)
and _j(got.get("위덮음") or {}) == _j(mcv.cover_of(live))
and got["셈"]["계"] == m01doc.read(key)["셈"]["계"]
)
def _drop_line(d):
del d["금액"][1]
def _cover(entry):
return lambda d: d.update({mcv.COVER: entry})
EDITS = {
"옵션 선택": (CON, _opt("구조물", "철근구조물")),
"옵션 입력": (CON, _opt("소량감률", "20")),
"옵션 기계": (CUT, _opt("Type", "TypeⅢ")),
"줄 수량": (CON, lambda d: d["금액"][0].update(수량="Q_콘크리트공 × 1.1")),
"줄 뺌": (CON, _drop_line),
"기계 값": (CUT, _cover({NO: {"값": {"가격": 200000}}})),
"작업량 방식": (CUT, _cover({SYM: {"작업량": {"방식": "시간당", "식": "GC001147"}}})),
}
@pytest.mark.parametrize("name", list(EDITS))
def test_새_단가산출_있던_단가산출_따라옴(world, docs_tmp, name):
key, fn = EDITS[name]
me = world["personal"]
old = _sk(me, key)
was = m01doc.read(key)["셈"]["계"]
assert _is_base(_read(me, old), key)
_m01(key, fn)
assert m01doc.read(key)["셈"]["계"] != was # ㉠ 기초 셈이 바뀜
assert _is_base(_read(me, _sk(me, key)), key) # ㉡ 새 단가산출
assert _is_base(_read(me, old), key) # ㉢ 안 고친 단가산출
def test_옵션_고름_지킴_알림_확인(world, docs_tmp):
me = world["personal"]
other, same, line = _sk(me, CON), _sk(me, CON), _sk(me, CON)
_edit_sk(me, other, _opt("타설방법", "장비사용타설"))
_edit_sk(me, same, _opt("지역", "서울"))
_edit_sk(me, line, lambda d: d["금액"][0].update(수량="(Q_콘크리트공) × 2"))
_m01(CON, _opt("지역", "경기"))
got = _read(me, other) # 다른 옵션을 고름 = 내 값 지킴 · 기초 옵션 따라옴 · 알림 없음
assert (_val(got["문서"], "타설방법"), _val(got["문서"], "지역")) == ("장비사용타설", "경기")
assert got["사본"]["따로"] and got["사본"]["갱신"] == []
got = _read(me, same) # 같은 옵션을 고름 = 내 값 지킴 + 알림
assert _val(got["문서"], "지역") == "서울"
[note] = got["사본"]["갱신"]
assert (note["갈래"], note["처리"]) == ("문서", "지킴")
assert note["M01"] == ["지역 전국평균 → 경기"] and note["내고침"] == ["지역 서울"]
_at(me, path.save, same, {"할일": renew.CONFIRM, "판": got["판"]})
after = _read(me, same)
assert after["사본"]["갱신"] == [] and _val(after["문서"], "지역") == "서울"
assert after["셈"]["계"] == got["셈"]["계"]
got = _read(me, line) # 줄 고침 + 옵션 기본 바뀜 = 줄 고침 지킴(다시 복사 아님) · 옵션 따라옴
assert got["문서"]["금액"][0]["수량"] == "(Q_콘크리트공) × 2"
assert _val(got["문서"], "지역") == "경기" and got["사본"]["갱신"] == []
def test_기초_줄_이름_따라옴(world, docs_tmp):
me = world["personal"]
key = _sk(me, CON)
_edit_sk(me, key, lambda d: d["금액"][1].update(수량="(Q_보통인부) × 2"))
_m01(CON, lambda d: [d["금액"][i].update(이름=f"848-10 이름 {i}") for i in (0, 1)])
lines = _read(me, key)["문서"]["금액"]
assert lines[0]["이름"] == "848-10 이름 0" # 안 고친 줄 = 따라옴
assert (
lines[1]["이름"] == "보통인부" and lines[1]["수량"] == "(Q_보통인부) × 2"
) # 고친 줄 = 내 것
def _freeze(me, key):
with store.at(me):
here = refs.here()
ref = {"층": here[0], "주인": here[1], "키": key}
rows = source.labor_doc_rows(
{"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]}
)
bundle = source.price_bundle(rows, me)
return lambda: float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"])
def test_프로젝트_사본(world, docs_tmp):
me = world["personal"]
key = _sk(me, CON)
before = _freeze(me, key)
was = before()
proj = me.parent / "p84810" / "templates"
(proj / "sangeun").mkdir(parents=True)
shutil.copy(me / "sangeun" / f"{key}.json", proj / "sangeun" / f"{key}.json")
in_proj = _read(proj, key)
_m01(CON, lambda d: d["금액"][0].update(수량="Q_콘크리트공 × 1.1"))
now = float(_read(me, key)["셈"]["계"])
assert now != was
assert before() == was # 고치기 전 굳힌 것 = 그대로
p = _read(proj, key) # 프로젝트 층 = 그대로
assert p["셈"]["계"] == in_proj["셈"]["계"] and _bare(p["문서"]) == _bare(in_proj["문서"])
assert _freeze(me, key)() == now # 고친 뒤 굳힘 = 그때 단가산출 금액
def test_손고침_빌더_층바탕(world, docs_tmp):
_m01(CUT, _opt("Type", "TypeⅢ"))
saved = ml.load_all()[CUT]
assert saved.get(mcv.HAND)
files, whole = m01.loaded()
name = next(
n
for n, d in files.items()
if d.get("그룹") == "로직" and any(str(r.get("키")) == CUT for r in d.get("줄") or [])
)
rows = files[name]["줄"]
keys = [str(r["키"]) for r in rows]
result = {
"문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows},
"파일": {name: keys},
"저장": set(keys) & build.saved_keys(),
"저장본": build.carried(),
}
file = ml.FOLDER / ml.file_of(name)
assert build.files_of(result)[ml.file_of(name)] == file.read_text(encoding="utf-8")
assert CUT in build.hand_kept(result)
me = world["personal"]
got = _read(me, _sk(me, CUT))
assert _val(got["문서"], "Type") == "TypeⅢ" and set(got["층바탕"]) == {"위", "빌더"}
shown = _node(
{"문서": got["문서"], "위": got["층바탕"]["위"], "빌더": got["층바탕"]["빌더"], "고침": []}
)[0]
[(where, (kind, was, back))] = shown["표시"].items() # 기초에서 바꾼 옵션 = 위(주황)
assert (where, kind, was["연결"]["값"], back) == ("v:Type", "upper", "TypeⅠ", False)
assert shown["빠짐"] == {} and shown["줄틀"] == {}
def test_그룹째_뺀_줄_되살림_제_그룹():
top = _j(ml.load_all()["GC000994"]) # 인력 · 크롤러드릴 · 공기압축기 · 크레인 그룹
up = cp.deepcopy(top)
del up["금액"][4] # 공기압축기 그룹째
got = _node({"문서": up, "위": up, "빌더": top, "고침": [{"꼴": "되살림", "항목": 2}]})
doc = got[0]["문서"]
assert [x["이름"] for x in doc["금액"]] == [x["이름"] for x in top["금액"]]
heads = [(x.get("제목"), [y.get("이름") for y in x["줄"] if "금액" in y]) for x in doc["쌓기"]]
assert heads[2] == ("공기압축기 21㎥/min", ["공기압축기 21㎥/min"]) # 제 그룹 · 제 자리
titles = ["인력", "크롤러드릴(공기식) 17㎥/min", "공기압축기 21㎥/min", "크레인"]
assert [h[0] for h in heads] == titles
assert got[0]["빠짐"] == {}