chore(ledger): 설계 855 보충 — B08 · B09 옛 엔진 걷기 · 로직 JSON 없애기 · 호환 뺌 · 바뀐 걸음 표
Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,286 @@
|
||||
# 설계 855 보충 — 사용자 확정 넷 반영 (PLAN 855-F)
|
||||
|
||||
요구 898 · 899 · sub7 · 2026-11-17 · 읽기 · 세기만(코드 · 자료 · 시험 고침 0). 바탕 = `docs/raw/요구_1104/설계_855_정본하나_계산기하나.md`(아래 「본 설계」).
|
||||
세는 도구 · 결과 = `tmp/s894/m855b/`(sub6 도구 셋 복사 + 새 도구 넷 · 결과 파일은 4 절 끝 표).
|
||||
|
||||
## 0. 한눈 요약
|
||||
|
||||
- **B08 · B09 는 지금 「M02 셈 답을 받는」 게 아니라 「M02 를 복사한 옛 로직 줄을 옛 엔진으로 다시 푸는」 꼴** — 프로젝트 사본 `단가.json` 에 M01 로직 줄 · 굳힌 SK 로직 줄(`로직_단가산출.json` `GX9…`)을 싣고, B09 가 그 줄을 `run_line` · `mf.evaluate` 로 다시 풀어 수량 · 자원 키 · 하위 산근 · 풀이 글을 얻음. 셈 몸은 이미 M02 엔진 값(841-1) — B09 고유 셈은 비목 합 · 끝수 · 관급 0 원 · % 밑수뿐.
|
||||
- 사본에 이미 `수식.json`(수식 문서 닫힌 묶음 · 802-4a)이 같이 실림 — **쓰는 곳 0**(만들기만).
|
||||
- 권함 = **안 B「프로젝트는 M02 계산기(문서 셈) 한 벌을 불러 사본을 셈 · B09 는 답을 갈라 합산만」** + 입력 지문이 같으면 다시 안 셈(파생 저장본). 안 A(복사 때 셈 답만 굳힘)는 프로젝트 입력값(구조물마다 · 운반 거리) · [단가 갱신] 이 다시 셈을 요구해 못 씀.
|
||||
- **B09 손 줄이 M01 기초를 직접 고름**(설계내역서 [단가 연결] · 운반 단가 모달 · `ref.tab = logic`) — 저장된 프로젝트 1 곳에 **6 줄 살아 있음**. M02 를 거치지 않는 유일한 길 → 판단 거리 1.
|
||||
- 로직 JSON 칸 19 가운데 문서에 같은 값으로 이미 있는 것 4(`이름 결과단위 출처 부품`) · 문서로 옮길 이름표 6(`원문번호 구분 상세구분 소유 비고 개정`) + `별칭`(지금 값 0) + 파일 머리 3(`원문 부문 차례`) · 셈 칸 8 은 문서 셈 칸이 대신(버림) · **문서에 없는 정보 = 이름표뿐**.
|
||||
- 로직 줄을 직접 읽는 파이썬 자리 = `.logic(` 류 **102 곳 · 49 파일**(M01 7 파일 19 · M02 23 파일 48 · B09 7 파일 16 · scripts 12 파일 19) + 층 서고 SK `수식.로직` · `사본.로직`(로직 줄 값 사본 28 줄) — 모두 문서 읽기로 옮긴 뒤 로직 JSON 을 뺌.
|
||||
- **지금 진행 중인 기초 고침(851-1 등)이 로직 JSON → 빌더 길을 씀** — 로직 JSON 을 빼기 전에 「기초 내용 고침 = 수식 문서를 바로 고치는 스크립트 · M01 [저장]」 으로 길을 바꿔야 함(차례 조건).
|
||||
- 호환을 안 만들면 빠지는 것: 2-D 올림 규칙 · 사본 없는 SK 옛 길 · 옛 SK 상세 시험 8 군 고쳐 쓰기 · 프로젝트 옛 사본 꼴 읽기(`items/` · `complete_old`) · SK `사본` · `수식.로직` 이행 — **어림 −1,200 줄 · 걸음 하나(2-D) 크기 절반**.
|
||||
- 저장본을 비울 때 = **2-C1(SK 셈 한 길) 바로 앞**(옛 칸을 읽는 셈이 꺼지기 전에 자료가 0 이면 2-C1 · 2-D 가 옛 꼴을 볼 필요 없음).
|
||||
- 「가져온 식」(`가져온.로직` = 옛 로직 줄 꼴)은 저장본을 비워도 불러올 때마다 새로 생김 → 옛 식 **파서만** 불러오기 몫으로 남김(엔진 몸은 지움) · 857 이 문서를 바로 내면 그때 걷음.
|
||||
|
||||
---
|
||||
|
||||
## 1. ㉮ B08 · B09 — 옛 엔진 부름 걷기
|
||||
|
||||
### 1-1 옛 엔진을 부르는 자리 하나하나
|
||||
|
||||
길 = 화면 → 서버 길 → 함수. 「살아 있음」 = 화면 단추 · 페이지 열기가 실제로 탐 · 「자료 0」 = 길은 살았으나 지금 저장소에 그 자료가 없어 실제로는 안 돎(프로젝트 사본 0 · 구조물 조합 줄 0).
|
||||
|
||||
| 자리 | 부름 | 무엇을 얻으려고 | 타는 길 | 판정 |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| `B08_Quantity_Router_Material.py:79` `_ref_mats.run` | `labor.run_line` | 참조 일위대가 안 **옛 로직 줄**의 재료 줄(이름 · 단위 · 품목 키 · 수량) → 단위수량 | B08 자재 집계표 열기 `GET …/quantity/materials`(:275) → `snapshot_units` → `_folder_units`(:117) | 살아 있음 · 자료 0(SC 옛 로직 줄 0) |
|
||||
| 같은 파일 `_folder_units` | `copies.calc`(`M02_Item_Copy.py:338` → `Item_Prices.calc` → `Labor_Doc.calc` → `run_line`) | 사본 일위대가 줄 재료 · 자재 수량 | 같음 | 살아 있음 · 자료 0(사본 0) |
|
||||
| `B09_Estimation_Sangeun.py:346` `Solver._solve:333` | `labor_doc.run_line(raw=True)` | 산근 줄마다 **엔진 금액 ÷ 수량 = 단가**(841-1) | B09 열기 · [저장] · 셈 `GET/PUT …/estimation` · `POST …/estimation/calc`(:430) → `calc_user` → `Sangeun.build`(:667) → `collect`(:626) | 살아 있음 · 손 줄 6 이 탐 |
|
||||
| 같은 파일 `_env:200` | `mau.values` · `mf._inputs` · `mf.evaluate(중간)` | **입력 기본값** · 중간 값(작업량 Q 표시 자리) | 위 `_solve` 안 | 살아 있음 |
|
||||
| `_line:445` · `_logic_line:488` | `mf.evaluate(수량)` · `mf.fill(요소)` · `mf.mp.priced` | 줄 **수량 · 자원 키**(노임 · 자재 · 기계) · 고른 품목 | 같음 | 살아 있음 |
|
||||
| `call_of:223` · `line_calls:242` · `_captured:261` | `mf.parse` · `mf.evaluate` · `whole.get` 가로채기 | **하위 산근**(부른 로직 키 + 넘긴 입력) · 기계경비 줄의 **기계 키** | 같음 + `rows_of`(일위대가화 줄 펼침) + `Labor_Source` | 살아 있음 |
|
||||
| `_extras:513` | `mf.evaluate(덧줄 식)` · `labor_doc.pct_extras` | **율 줄**(% · 밑수 = B09 비목 합) | 같음 | 살아 있음 |
|
||||
| `hand_resource_keys:602` | `run_line`(+ `whole.get` 가로채기) | 손 줄이 부르는 **자원 키**(자재 단가 책 수요) | B09 열기 `payload` → `Router.py:238` | 살아 있음 |
|
||||
| `B09_Estimation_Sangeun_Text.py` 13 함수 31 곳(`render_sangeun_text:347`) | `mf.*` · `master_text`(`mtx.fmt` · `render` · `_names`) | **산출근거 글**(머리 · 줄 · 계) | `_solve` → `_text` · `POST …/estimation/logic-preview`(:444 · 운반 단가 모달 ③) | 살아 있음 |
|
||||
| `B09_Estimation_Sangeun_Sum.py:36 · 87` | `mcut._line` · `mcut.settle` | **끝수**(줄 자리 · 끝전 · 조정 · 792-3) | `_solve` 안 | 살아 있음 |
|
||||
| `B09_Estimation_Labor_Rule.py:90 · 115` | `mf.parse`(덧줄 식 꼴 읽기) | 대가 블록 **율 줄 밑수 · 합밖 · 번지 표지**(792-4) | `Labor_Source._poomsem` | 살아 있음 · 자료 0 |
|
||||
| `B09_Estimation_Labor_Source.py:140` `_poomsem` | `run_line(raw=True)` + `sg.line_calls` | 대가(품셈) 블록 **줄 꼴 · 수량 · 비목 · 하위 산근** | B09 열기 `payload` → `daega_inputs`(:656) | 살아 있음 · 자료 0 |
|
||||
| 같은 파일 `sangeun:181` → `Supply.sk_money:79` | `Sangeun_Calc.unit`(옛 엔진 + 문서 합계 덮음) | 굳힌 SK 블록 **합(노 · 재 · 경)** | 같음 | 살아 있음 · 자료 0 |
|
||||
| `B09_Estimation_Linked.py:64` `used_keys` | `run_line`(+ `get` 가로채기) | 사본이 부르는 **자원 키**(단가 책 수요) | `payload` → `linked_resource_keys`(`Router.py:237`) | 살아 있음 · 자료 0 |
|
||||
| `M02_Item_Sangeun.py:45` `freeze` | `Sangeun_Calc.resolve` | 사본 만들 때 SK 를 **옛 로직 줄 하나(GX9)로 굳힘** | 구조물 [저장] → `Item_Snapshot.build_snapshot:126` · B09 서고 [가져오기] `POST …/estimation/library` → `Bill_Library.import_copy:272` · [재생성] `Refresh` | 살아 있음 · 자료 0 |
|
||||
| `M02_Item_Prices.py:234` `collect` · `:346` `calc` | `_texts`(옛 식 글 훑기) · `mf._expand` 류 · `Labor_Doc.calc` | 사본 **닫힌 묶음**(로직 줄 · 요소 · 표) 모으기 · 사본 셈 | 사본 만들기 · B08 · B09 전부 | 살아 있음 |
|
||||
|
||||
죽은 길 = 없음(모두 화면에서 닿음). 지금 실제로 도는 것은 **손 줄 로직 6 줄**(B09 프로젝트 1 곳)뿐 — 나머지는 자료 0.
|
||||
|
||||
### 1-2 사본에 지금 실어 오는 것 대 실어 와야 할 것
|
||||
|
||||
| 파일(구조물 사본 `templates/structures/{id}/` · B09 서고 `library/`) | 지금 내용 | 쓰는 곳 | 끝 모습(안 B) |
|
||||
| --- | --- | --- | --- |
|
||||
| `일위대가.json` | 일위대가 문서 + **M01 로직 줄 사본**(`로직`) · 알약 · `참조사본`(SC · 굳힌 SK 문서 = `굳힌줄` · `원본` · `정체`) (`Item_Source.py:93 · 105`) | B08 · B09 전부 | 일위대가 문서 + 참조사본(SC 그대로 · **SK = 수식 문서 사본**) · 로직 줄 사본 없음 |
|
||||
| `단가.json` | 닫힌 묶음 = **M01 로직 줄** + 요소 · 표 줄 + 자원 단가 줄 + `로직_단가산출.json`(GX9 굳힌 SK 줄) (`Item_Source.py:162`) | 옛 엔진 색인(`load_prices`) | **자원 단가 줄 · 표 줄만**(로직 줄 · GX9 없음) — [단가 갱신] 이 바꾸는 자리 |
|
||||
| `수식.json` | 수식 문서 닫힌 묶음(`Doc_B09.build:33` · 802-4a) | **없음**(만들기만) | **셈 정본** — 프로젝트 셈이 읽는 유일한 식 |
|
||||
| `입력값.json` · `고른자재.json` · `면적.json` | 구조물마다 입력 · 고른 재료 · 알약 칸 값 | 사본 셈 | 그대로(키 = 문서 키 · 입력 이름 → 변수 열쇠 맞춤 필요) |
|
||||
| B09 견적 `user_values.json` 손 줄 `ref{tab: logic, code, given, rate, picks}` | M01 로직 키 + 입력 | `hand_whole`(지금 M01 묶음 즉석 모음) | 안 바뀜 — 키가 같은 수식 문서로 셈(판단 거리 1) |
|
||||
|
||||
### 1-3 「프로젝트는 직접 계산하지 않음」 을 지키는 두 안
|
||||
|
||||
B09 가 셈 답에서 먹는 것 = 줄마다 **이름 · 종류(인력 · 자재 · 기계 · 하위 산근 · 율) · 자원 키 · 수량(1 단위) · 비목 금액 · 하위 부름(키 + 입력) · 율 밑 · 끝수 표지** + **풀이 글**. 새 계산기 답(`master_doc_calc.calc:545` → 줄 `{이름 비목 수량 단가 금액 까닭 합밖 묶음 작업량}`)에 **자원 키 · 하위 부름이 없음** → 어느 안이든 「줄마다 무엇을 불렀나」 기록이 새로 필요(셈은 안 바꿈 · 연결 풀이 `master_doc_link.Links` 를 감싸 부른 것을 적음 · 서버 단독 · TS 짝 안 건드림).
|
||||
|
||||
| 경우 | 안 A — 복사 때 셈 답을 굳혀 실어 옴 | 안 B — 프로젝트가 M02 문서 계산 함수를 불러 사본을 셈(권함) |
|
||||
| --- | --- | --- |
|
||||
| 실어 오는 것 | 셈 답(줄 · 비목 · 자원 키 · 하위 부름 · 풀이 글) | 수식 사본 + 자원 단가 줄(지금 `수식.json` + 줄인 `단가.json`) |
|
||||
| 프로젝트 안 [단가 갱신] | 자원 단가가 바뀌면 줄 금액이 달라짐 → 굳힌 답 못 씀 → M02 에서 다시 복사([재생성]) 해야 함 = 지금 뜻(사본 로직 그대로 · 단가만 새로)과 다름 | 자원 줄만 바꾸고 다시 셈 — 지금 뜻 그대로 |
|
||||
| 수량 · 입력 바뀜(구조물마다 입력값 · 운반 거리 이정표 `haul_dist` · 면적 알약) | 입력이 바뀌면 굳힌 답 무효 → 못 함 | 같은 계산기로 다시 셈 |
|
||||
| 산출근거 보기 | 굳힌 글(단가 갱신 · 입력 바뀜 뒤엔 틀림) | 셈 답 → 서버 풀이 글(본 설계 ② `master_doc_text` · 2-C4) + B09 단가 |
|
||||
| 내역서 합산 | 같음(비목 합) | 같음(비목 합) — B09 고유 셈 = 비목 합 · 끝수 · 관급 0 원 · % 밑수만 |
|
||||
| 손 줄 M01 로직(6 줄) | 고를 때 M02 에서 셈해 굳힘 — 입력 바꾸면 다시 | 그대로 문서 셈 |
|
||||
| 속도 | 빠름 | 입력 지문이 같으면 저장본(CLAUDE.md 5 장 「파생 저장본」) → 안 A 와 같은 속도 |
|
||||
| 고칠 크기 | 사본 꼴 + B09 5 파일 + [단가 갱신] · 입력 바꿈 길 새로 | 사본 꼴 + B09 5 파일(읽는 답만 바뀜) |
|
||||
|
||||
→ **안 B 권함.** 「계산을 직접 할 일 없음」 = B09 에 식 엔진이 없음(계산기는 M01 · M02 와 같은 한 벌) · B09 는 답을 갈라 합산만 — 로 읽음(판단 거리 2 에서 확인).
|
||||
|
||||
### 1-4 걸음(두 박자 · 한 걸음 = 한 커밋 묶음)
|
||||
|
||||
| 걸음 | 무엇 | 파일(어림 줄) | 지킴 | 앞 조건 |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| **B9-0 견본 · 골든** | 지금 사본 0 · 조합 줄 0 → **임시 storage 견본 프로젝트**를 시험이 지음: 층 견본(SK 가져온 식 · 따로 · 율 더한줄 · 형제 SK · 기계 · 관급 재료 / SC 참조 · 고정 · 자재 / 구조물 조합 일위대가 열) → 구조물 지정 → 사본 만들기(지금 길) → B09 `calc_user` · `daega_inputs` · `payload` 수요 키 · B08 `snapshot_units` · `logic_preview` 답을 지문으로 `855_b09_golden.json` · 손 줄 견본(운반공 · 율 · 고른 재료) 포함 · 실제 B09 프로젝트 1 곳(손 줄 6)은 자기 포트에서 `GET …/estimation` 답 읽기만 전후 대조(tmp) | 새 `resources/tester/test_855_b09_golden.py`(+ 250) · 견본 짓기는 기존 `test_143_*` · `145_*` · `792_3` · `802_4a` 견본을 모아 씀 | 지금 수치 그대로 통과 | 2-A(855-A) |
|
||||
| B9-1 셈 기록 | 문서 셈 줄마다 부른 자원 키 · 하위 문서(키 + 입력) · 고른 품목을 적는 연결 감쌈 | 새 `scripts/master_doc_trace.py`(+ 120) · 시험 | 1,521 기초 기본 옵션 — 기록한 자원 키 = 옛 `whole.get` 가로채기 키(같음) | B9-0 |
|
||||
| B9-2 사본 셈 한 길 | `Item_Copy.calc` · `Item_Prices.calc` = `수식.json` 문서 셈 · B08 `_folder_units` · `_ref_mats` = 문서 셈 답 재료 줄 | `M02_Item_Prices.py`(± 120) · `M02_Item_Copy.py`(± 20) · `B08_Quantity_Router_Material.py`(± 60) | 골든(B08 단위수량 · 사본 셈 금액) 같음 · `test_143_*` · `145_3_b08` | B9-1 · 2-C1(SK 문서 셈) |
|
||||
| B9-3 B09 산근 · 대가 | `Sangeun._solve · _env · _line · call_of · line_calls · _captured · rows_of · _extras · hand_resource_keys` · `Labor_Source._poomsem` · `Linked.used_keys` · `Supply.sk_money` · `Sangeun_Sum` · `Labor_Rule` → 문서 셈 답 + 기록(끝수 = 답 `끝수` · 율 = 금액 줄 `합밖 · 자리 · 단계` 칸) | `B09_Estimation_Sangeun.py`(± 250) · `_Labor_Source.py`(± 120) · `_Linked.py`(± 40) · `_Supply.py`(± 20) · `_Sangeun_Sum.py`(− 40) · `_Labor_Rule.py`(± 60) | 골든 B09 산근 합 · 줄 비목 · 대가 줄 · 내역서 합계 같음 · `test_145_*` · `792_3`(다섯 길) | B9-1 · 2-C1 |
|
||||
| B9-4 산출근거 글 | `Sangeun_Text` 31 곳 → 서버 풀이 글(본 설계 ②) + B09 단가 끼움 | `B09_Estimation_Sangeun_Text.py`(± 250 · 줄어듦) | 글 = 골든 글(줄 수 · 금액 숫자) · 화면 산근 탭 · 운반 모달 ③ 확인 | 2-C4(`master_doc_text`) · B9-3 |
|
||||
| B9-5 사본 꼴 | 새 사본 = `수식.json`(셈 정본) + 자원 줄만 `단가.json` · SK 굳힘(`Item_Sangeun.freeze` → GX9 줄) 대신 SK 수식 문서 사본(따로 · 덮음 반영) · [재생성] · [단가 갱신] 같은 꼴로 | `M02_Item_Source.py`(± 80) · `M02_Item_Sangeun.py`(− 150) · `M02_Doc_B09.py`(± 20) · `B09_Estimation_Bill_Library.py`(± 30) · `_Refresh.py` · `_Copy_Prices.py`(± 40) | 골든 같음 · 사본 파일 칸 전수(`census_copies`) · 옛 꼴 사본 읽기 없음(지금 0 · 1-2) | B9-3 |
|
||||
| B9-6 옛 길 지움 | B08 · B09 의 `run_line` · `mf` · `mau` · `mtx` · `mcut` 부름 · `Item_Prices` 옛 묶음 모음(`_texts` · `collect` 로직 줄) · `Labor_Doc.run_line` 의 B 쪽 | 위 파일들 · 옛 사본 시험 줄(`test_143_4` · `145_1` · `145_2` 등 옛 꼴 견본 부분) | 골든 · 관련 시험 전부 · `/openapi.json` 같음 | B9-5 |
|
||||
|
||||
### 1-5 2-E4(엔진 모듈 지움) 앞 조건 — 새 차례
|
||||
|
||||
1. 본 설계 2-C1(SK 셈 한 길) · 2-C4(서버 풀이 글) 끝.
|
||||
2. B9-0 → B9-6 끝 = B08 · B09 가 옛 엔진 · `master_text` · `master_cut.engine` · `master_auto` 를 부르는 곳 0(`census_calls.py` 에서 B08 · B09 줄 0).
|
||||
3. 불러오기 옛 식 **파서**(`mf.parse` 류 · `Doc_Import` · `San_Basis_Index` · `Sangeun_QtyLinks`)는 엔진 몸과 떼어 「바탕 기반」 새 모듈로(3-3).
|
||||
4. 그 뒤 2-E4 = 엔진 몸 · 셈 · 글 · `master_auto` · `master_combo.run` 지움 · `test_791_1` 은퇴.
|
||||
|
||||
---
|
||||
|
||||
## 2. ㉯ 로직 JSON 없애기 — 수식 문서에 합침
|
||||
|
||||
### 2-1 칸 전수와 갈 곳(`census_logic_fields.py` · 1,521 줄 · 59 파일)
|
||||
|
||||
| 칸 | 줄 수(값 있음) | 문서에 지금 | 갈 곳 |
|
||||
| --- | --- | --- | --- |
|
||||
| 파일 머리 `그룹` · `판` | 59 | 문서 파일 머리 `그룹` · 줄 `판` | 그대로(문서 파일 `그룹 = 수식문서`) |
|
||||
| 파일 머리 `원문` · `부문` · `차례` | 59 · 45 · 58 | 없음(문서 파일 머리 = `로직파일` 이름만) | **문서 파일 머리로** — M01 분류(원문 · 장 차례 · 부문) 정본 |
|
||||
| `키` | 1,521 | 같음 | 그대로 |
|
||||
| `이름` · `결과단위` · `출처` · `부품` | 1,521 · 1,521 · 1,521 · 81 | **같은 값**(다름 0) | 이미 문서 — 로직 쪽 버림 |
|
||||
| `원문번호` · `구분` · `상세구분` · `소유` | 1,521 | 없음 | **문서 줄 머리로**(이름표) |
|
||||
| `비고` · `개정` | 1,452 · 1,257 | 없음 | **문서 줄 머리로** |
|
||||
| `별칭` | 0(지금 값 없음 · 칸은 화면 · 저장 길에 있음) | 없음 | **문서 줄 머리로** |
|
||||
| `입력` · `중간` · `호표` · `덧줄` · `끝수` · `결과` | 1,245 · 1,227 · 1,452 · 570 · 70 · 65 | 문서 `변수` · `식` · `금액` · `끝수` · `결과`(꼴 다름 · 빌더가 변환) | 버림(문서가 셈 정본 · 금액 다름 0 = 본 설계 3 절) |
|
||||
| `입력[].고르기`(기계 목록 2,757) | — | 문서 변수 `선택 목록` | 버림(기계 등록이 문서만 고침) |
|
||||
| `변수표` | 1,423 | 문서 `변수`(이름 · 기호 · 단위 · 빌더 `master_equation` 길) | 버림 |
|
||||
| `시험입력` | 234 | 없음 | **버림** — 읽는 곳 = 옛 틀 검사(`check_master`) · 옛 수식 탭(`master_equation*`) · 한 번용 스크립트뿐(작은 결정) |
|
||||
|
||||
→ 문서에 없는 정보 = 이름표 칸 여섯 + 별칭 + 파일 머리 셋. 셈 칸은 전부 문서가 대신함.
|
||||
|
||||
### 2-2 로직 줄을 읽는 자리 전수(`census_logic_readers.py` · `.logic(` 류 102 곳 49 파일 · 결과 `out_logic_readers.tsv`)
|
||||
|
||||
| 갈래 | 자리(대표 `파일:줄`) | 무엇을 읽나 | 문서 읽기로 바꾸는 법 |
|
||||
| --- | --- | --- | --- |
|
||||
| **M01 관문** | `M01_MasterData_Store.py:337 _logic_files` · `:21-26`(scripts 길 · `check_master.load` → `mf.Master` 로직 그룹) | 로직 파일 전부 | 문서 색인(`master_doc_link.load_all` · 이미 있음)을 관문 하나로 · `mf.GROUPS` 에서 「로직」 뺌 |
|
||||
| 목록 · 찾기 · 분류 | `Store.logics:343` · `files_of('로직'):113` · `subs` · `Store_List.attach` · `Store_Find`(↔ `ui_template_logic_find.ts` 짝) · 화면 `UI_Side.ts:48` · `Logic_List` | `키 원문번호 구분 상세구분 이름 결과단위 출처 소유 별칭` · 파일 머리 차례 | 같은 칸을 문서 머리에서 · 답 꼴 그대로(화면 안 바뀜) |
|
||||
| 상세 · 기본정보 | `Store.logic:384`(+ `blocked` · `prices`) · `LogicLab_Detail` · `_Basic` | 줄 통째 · 막힘 · 단가 미리보기 | 이름표 = 문서 머리 · 막힘 = 2-B3 문서 막힘 · 단가 미리보기 = 문서 셈 |
|
||||
| 별칭 | `M01_MasterData_Alias.py`(`/alias/save` → `Make.save` 별칭 칸) · 로직 목록 `onAlias` | `별칭` 칸 | 문서 머리 `별칭` 쓰기(문서 저장 길 · 잠금 = 걸음 1 의 문서 저장 잠금) |
|
||||
| 개정 · 개정 확인 | `Store_Revise`(정본 줄 지문 · 409) · `UI_Logic_Text.ts` · `build_로직_개정.py` | `개정` · 줄 지문 | 문서 지문(`dc.doc_fp` 꼴) · 개정 칸 = 문서 머리 |
|
||||
| 키 대장 | `master_keys`(`_키대장.json`) · `Store_Save._errors`(키 겹침 · 대장 대조) | 로직 키 발급 · 대조 | 대장 그대로 · 대조 대상 = 문서 키 |
|
||||
| 기계 등록 | `Machine.register`(`M01_MasterData_Machine.py:131-201`) | 로직 `입력[기계].고르기` + 문서 `선택 목록` 두 벌 | 문서만 |
|
||||
| [신규 로직] · [복사/생성] · [삭제] | `Store_Make`(3 곳) · `/logic/copy` · `/logic/formula*` · `/logic/remove` · `/logic/users` | 로직 줄 만들기 · 지우기 · 쓰는 곳 | 문서만 만들고 지움(854-2 가 문서 같이 만들기 하는 중 → 그 뒤 로직 쪽 걷음) |
|
||||
| 저장 검사 | `check_master`(로직 틀 · `시험입력`) · `Store_Save._errors` · `Store_Cache._check · check_saved` | 로직 줄 틀 | 문서 검사(`master_doc.check` + 2-B3 막힘) |
|
||||
| 손고침 판정 | `M01_MasterData_Doc.py`(`built()` = `master_doc_convert.convert(로직 줄)`) | 로직 줄 → 빌더 문서 | 빌더 은퇴와 함께 `손고침` 칸 뜻 없어짐 → 걷음 |
|
||||
| 계산서 덧칸 | `Store_Sheet` · `master_sheet_line`(B09 `_annotate` 도) | 로직 줄 식 | 문서 셈 기록(B9-1) |
|
||||
| 일위대가 조합 알약 · 입력 | `M01_MasterData_Store_Combo.combo_pills` · `M02_Labor_Inputs.py:36-94`(`/logic-lib/inputs` ← M02 일위대가 · B09 손 줄 · 운반 모달 `fetchLogicInputs`) · `Combo_Store` · `Router_Combos` | `입력`(이름 · 설명 · 단위 · 고르기 · 범위) · `결과단위` | 문서 `변수`(입력 갈래 · `선택 목록` · `연결.값` 기본값 = 본 설계 ③) |
|
||||
| M02 기초 고르기 · 찾아 넣기 | `/logic-lib/logics · subs · logic · source`(`M02_MasterTemplete_Router_Combos.py:42-93` → M01 함수) · `Logic_Standard`(2-C4) | 목록 · 이름표 · 출처 | M01 목록 갈래를 따라 바뀜 |
|
||||
| M02 SK · SC 사본 | `Sangeun_Copy`(`사본.로직` · `수식.로직` = **로직 줄 값 사본**) · `Copy_Slim` · `Doc_Gap` · `Item_Prices.collect`(로직 식 글 훑어 닫힌 묶음) | 로직 줄 · 표 · 요소 줄 | 로직 줄 값 사본 없앰 → `수식.부름`(문서 사본)이 대신 · 닫힌 묶음 = `Doc_Copy.closure`(문서로 · 이미 있음) · 표 · 요소 줄은 남음 |
|
||||
| M02 그 밖 이름 · 단위 읽기 | `Layer_Index` · `Library_Flat`(5) · `Doc_Copy` · `Doc_Sk` · `Doc_Take` · `Labor_SkRow` · `Sangeun_Doc` · `Sangeun_Block` · `Machine_Find` · `MyMachine*` · `Material_Own` · `Elem_Alias` | `이름` · `결과단위` · `입력` | 문서 머리 · 변수 |
|
||||
| 불러오기 이음 | `Hopyo_Elem`(5) · `Hopyo_Match`(3) · `Hopyo_Clause` · `Hopyo_Relink` · `Hopyo_Row` · `Hopyo_Units` · `Hopyo_Build` · `Doc_Import` · `San_*` | 엑셀 호표 ↔ M01 기초 맞춤(이름 · 원문번호 · 단위 · 입력) | 문서 머리(원문번호 · 이름 · 단위) · 변수 — **857 과 겹침**(아래 2-3 묶음 ⓒ) |
|
||||
| B08 · B09 | `Item_Source.logic_rows:105`(사본에 로직 줄 실음) · B09 `Sangeun` 6 · `Sangeun_Text` 4 · `Labor_Source` 2 · `Supply` · `Bill_Hopyo` · `Bill_Library` · `Daega_Personal` | 사본 · 지금 M01 로직 줄 | ㉮ 끝(B9-6)이면 0 |
|
||||
| 옛 엔진 · 옛 수식 탭 | `master_formula` · `_check` · `_sum` · `master_cut` · `master_text` · `master_combo` · `master_equation*` · `M01_MasterData_Equation` · `M02_Sangeun_Equation` · `M02_Sangeun_Formula` | 로직 줄 셈 칸 | 2-E2 · 2-E4 로 지움 |
|
||||
| 갱신 스크립트 | `build_로직_직접칸_851_1.py` · `build_로직_개정.py` · `build_용도.py` · `build_재료_검색어.py`(쓰기) · `build_변수표_796_3` · `build_변수기호_800_1` · `build_단위표기_801_5` · `build_기계_작업량_846_1` · `compare_estx` · `master_bundle` · `master_doc_unit` | 로직 JSON 읽고 씀 | 2-4 |
|
||||
| 시험 | 로직 파일 이름 45 · `.logic(` 42 · `run_line` 27 · `master_formula` 23 · `master_doc_convert` 7 · 빌더 4(1,401 시험 파일 중) | 로직 줄 견본 · 대조 | 걸음마다 그 자리 시험만 문서 견본으로 · 대조 시험은 은퇴 |
|
||||
|
||||
### 2-3 차례 · 병행 · 지킴
|
||||
|
||||
| 걸음 | 무엇 | 지킴 | 앞 조건 |
|
||||
| --- | --- | --- | --- |
|
||||
| L1 이름표 싣기(첫 박자) | 빌더가 이름표 칸 일곱 · 파일 머리 셋을 문서에 실음(`--check` 새 기준) · M01 [저장](비고 · 별칭 · 자체 이름 · 개정)이 두 곳에 씀 | 1,521 문서 이름표 = 로직 줄 이름표(다름 0) · 금액 골든 같음 | 2-B3 · 854-2 끝 · **로직 JSON 을 고치는 일감 0**(851 류 끝) |
|
||||
| L2 읽는 쪽 바꿈(묶음 셋 병행) | ⓐ M01 목록 · 찾기 · 분류 · 상세 · 별칭 · 개정 · 키 대장 · 저장 검사 · 기계 등록 · 신규 · 복사 · 삭제 ⓑ M02 입력 목록 · 알약 · 이름 읽기 · SK 사본 `로직` 값 사본 없앰(`수식.부름` 으로) · 닫힌 묶음 = 문서 ⓒ 불러오기 이음(Hopyo · San — 857 과 같이 하거나 857 앞에 이름표 읽기만 바꿈) | 화면 답 전후 같음(`/logics` 전 갈래 · `/subs` · `/groups/로직/files` · `/logic` · `/alias` · `/logic-lib/inputs` 답 JSON 대조) · 금액 골든 · 불러오기 골든(`test_812_1`) | L1 · ⓑ 는 2-C1 · 2-D 뒤 · ⓒ 는 2-C2 뒤 |
|
||||
| L3 로직 JSON 뺌(둘째 박자) | 읽는 곳 0 확인(`census_logic_readers` 관문 · 이름표 0) → `로직_*.json` 59 `git rm`(브레인이 tmp 보관) · `mf.GROUPS` 「로직」 뺌 · 키 대장은 그대로 | 금액 골든 · 화면 답 대조 · 핵심 시험 · 서버 뜸 | L2 · ㉮ B9-6 · 2-E1 · 2-E2 |
|
||||
| L4 은퇴 | 2-4 표 | `test_855_golden` + `test_802_1`(거울)이 관문 | L3 |
|
||||
|
||||
### 2-4 은퇴 목록
|
||||
|
||||
| 대상 | 은퇴 때 | 대신 |
|
||||
| --- | --- | --- |
|
||||
| 빌더 `build_수식문서_802_2.py` · `master_doc_convert` · `_목록_802-2_변환대조.xlsx` | L3 | 문서가 정본 · 고침 = M01 [저장] · 문서 고침 스크립트 |
|
||||
| `test_802_2_convert`(싱크 관문) | L3 | `test_855_golden`(지문) + `test_802_1`(파이썬 ↔ TS 거울) 관문 |
|
||||
| `master_equation*` 6 · `M01_MasterData_Equation` · `M02_Sangeun_Equation` · `master_symbol` | 2-E2(SK 옛 식 덮개 걷음) 뒤 · L3 | 문서 변수(이름 · 기호 · 단위) |
|
||||
| `M01_MasterData_Doc` 의 `built()` · `손고침` 판정 | L3 | 없음(빌더가 없으니 갈림도 없음) |
|
||||
| 「로직 줄을 더한 뒤 채우기」 넷(`build_변수표_796_3` · `build_변수기호_800_1` · `build_단위표기_801_5` · `build_재료_검색어`) | L3 | 문서에서 같은 채우기가 필요하면 문서 대상 스크립트로 다시 씀(지금은 새 로직이 늘 때만 돎) |
|
||||
| `build_로직_개정.py` | L1 에서 문서 머리 `개정` 을 쓰도록 바꿈 | 같은 스크립트 · 대상만 문서 |
|
||||
| 한 번용 `build_로직_*`(851-1 등) | 다 돈 것 → 걸음 0 보관 갈래 | 앞으로 기초 고침 = 문서 고침 스크립트 |
|
||||
| `_갱신절차.md` 로직 절 · 수식 문서 절 | L3 | 수식 문서 절 하나(빌더 없음 · 고치는 길 = 화면 · 문서 스크립트) — 갱신절차 고침은 이 일감 범위 밖 · 그때 같이 |
|
||||
|
||||
### 2-5 수식 문서 파일 나눔
|
||||
|
||||
지금 = 옛 로직 파일마다 한 벌(59 파일 · 원문 · 장 단위 · 파일 머리 `로직파일`). **그대로 둠(권함)** — 분류 화면(원문 · 장 차례)과 파일이 1:1 · 저장 한 번에 작은 파일 하나만 씀 · git 다름이 장 단위로 읽힘. 바꾸는 것 = 파일 머리 `로직파일` → `원문 · 부문 · 차례`(L1) · 파일 이름은 그대로(`수식_<원문>_<NN>장_….json`).
|
||||
|
||||
---
|
||||
|
||||
## 3. ㉰ 호환을 안 만드는 쪽으로 줄이기
|
||||
|
||||
### 3-1 빼거나 줄이는 걸음(저장본을 비우는 전제)
|
||||
|
||||
| 본 설계 자리 | 원래 할 일 | 비우면 | 어림 줄 | 차례 |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| 2-C1 「사본 없는 SK 는 옛 `run_line`」 | 옛 길을 남겨 둠 | **뺌** — SK 는 늘 `수식` 사본으로 만들어짐 · 없는 SK = 「못 셈 · 까닭」 | −150(2-C1 안 옛 갈래 · 2-E2 가 나중에 지울 몫이 미리 없음) | 2-C1 과 2-E2 일부가 한 걸음 |
|
||||
| 2-C1 「옛 칸 값 있는 SK 는 옛 길 그대로(2-D 에서 올림)」 | 옛 7 칸 셈 유지 | **뺌** | −100 | 같음 |
|
||||
| 2-D 「읽을 때 올림」(옛 7 칸 → `따로` 굳힘 · `사본` → `수식` · `바탕판` 버림) | 올림 규칙 새로 + 시험 | **뺌** — 칸만 걷고 읽지 않음 | −250(+ 시험 −150) | 2-D 가 2-C1 바로 뒤에 붙음 · 옛 엔진 살아 있을 때 할 일 없음 |
|
||||
| 5-1 SC 「옛 로직 줄 → SK 참조」(`Labor_SkRow.migrate` 꼴) | 규칙 유지 | **뺌**(이미 걷음 · 자료 0) | 0 | — |
|
||||
| SK `사본` 칸(= `수식` 여섯 칸) · `수식.로직`(로직 줄 값 사본) | 2-D 에서 이행 | 그냥 안 씀 · 안 읽음 · `Copy_Slim` · `Doc_Gap` 의 `사본` 갈래 걷음 | −120 | 2-D |
|
||||
| 옛 SK 상세 길 시험 8 군(`715_*` 4 · `717_4` · `725_1` · `742_1` · `744_1` · `806_1`) | 견본을 문서 꼴로 고쳐 씀 | **지움**(옛 칸 견본만 붙듦) · 살아 있는 결과는 `test_855_sk_layers` 가 봄 | −(시험) | 2-C1 과 같은 커밋 묶음 |
|
||||
| 옛 식 문법 도구 — SK 옛 식 덮개(`Sangeun_Formula` `변수줄 · 식덮개 · 더한줄 수량식`) | 옛 칸 있는 동안 유지 | 저장본에 이 칸 값 0 → **2-C1 과 같이 걷음**(2-E2 몫이 앞당겨짐) | −530 | 2-C1 뒤 |
|
||||
| 프로젝트 옛 사본 꼴 — `Item_Snapshot.migrate_items:198`(25-2b `items/`) · `complete_old:384` · `Item_Copy._migrated:71` | 남김 | 프로젝트 사본 0 · `items/` 0 → **뺌**(판단 거리 3 — 프로젝트는 사용자 확정 범위 밖) | −120 | B9-5 |
|
||||
| `M02_Sk_AutoRenew` 의 옛 사본 갈래 · `MasterTemplete_Tree.old_fields:58` · `MyMachine._old:467` | 남김 | 각 갈래가 옛 저장 꼴을 읽는지 그 걸음에서 확인 뒤 뺌(지금 확인 안 함) | −(미확인) | 2-D · 858 |
|
||||
| B09 사본 안 굳힌 로직(`로직_단가산출.json` · `굳힌줄` · `GX9`) | 판단 5 · B09 와 같이 꼴 바꿈 | 사본 0 → 이행 없이 새 꼴(B9-5) | 0(이행) | B9-5 |
|
||||
|
||||
합 어림 = 코드 **−1,200 줄 안팎** + 이행 시험 0 · 2-D 크기 절반 · 2-E2 일부가 2-C1 로 당겨짐.
|
||||
|
||||
### 3-2 저장본을 비울 때 · 범위(비우는 일은 하지 않음 · 브레인이 사용자 확인 뒤)
|
||||
|
||||
**때 = 2-C1 바로 앞**(855-B 끝 · 855-C 첫 걸음 전). 까닭: 2-C1 이 옛 칸 · 사본 없는 SK 를 보지 않으려면 그때 자료가 새 꼴뿐이어야 함 · 2-A 골든은 저장본이 아니라 임시 storage 견본이라 영향 없음 · 비운 뒤 사용자가 새로 만든 SK 는 이미 새 꼴(`수식` 있음).
|
||||
|
||||
| 후보 | 자리 | 지금 수(`census_storage` · `census_copy_fields`) | 권함 |
|
||||
| --- | --- | --- | --- |
|
||||
| 단가산출 SK | 개인 `templates/sangeun/SK-*.json` · `sangeun_폴더.json` | 14 ~ 15(세는 동안 늘어남 = 사용자가 지금 만드는 중) · 가져온 식 12 ~ 13 | 비움 — 단 **사용자가 지금 개인 층에서 단가산출을 만들어 쓰는 중**(공통 지시) → 판단 거리 4 |
|
||||
| 일위대가 SC | 개인 `precombo/SC-*.json` · `precombo_폴더.json` | 6 | 비움(같은 판단) |
|
||||
| 지운 문서 보관 | 개인 `_합친것/` | SK 12 · SC 3 | 비움 |
|
||||
| 구조물 조합 | 회사 · 개인 `구조물집계표조합.json` · `table/구조물집계표.json` | 줄 0(파일 6 · 표 6) | 그대로(빈 틀 · 새 꼴 상관없음) |
|
||||
| 불러온 자료 | 개인 `실무자료/`(불러옴 4 · HP 3) | 7 | 비움 — 다시 불러오면 새로 생김 |
|
||||
| 내 기계 · 내 재료 | 개인 `내기계/_다음.json` · `개인자재.json` | 1 · 1 | 858(서고 한 벌) 앞에 같이 · 855 엔 상관없음 |
|
||||
| 번호 · 겉 | `_번호.json` · `manifest.json` | 1 · 1 | 비우면 번호도 처음부터(번호 겹침 위험 없음 — 문서 0) |
|
||||
| **따로 둠** | 마스터 층 `resources/master_template/`(구조물 표 · 도면 틀 · 구조물정의) · 회사 `drawing/` · 프로젝트 `_initial/` · `drawing/` · `table/`(14 프로젝트) | — | 비우지 않음 — 다른 페이지(B05 · B08 · 도면)가 씀 |
|
||||
| **따로 둠** | B09 견적 저장 `B09_Estimation/v1/`(1 프로젝트 · 손 줄 로직 6) | — | 프로젝트 자료 — 확정 범위 밖 · 키가 같아 새 계산기로 그대로 셈 |
|
||||
|
||||
### 3-3 가져온 식(`가져온.로직` = 옛 로직 줄 꼴)은 따로
|
||||
|
||||
- 지금 SK 12 의 `가져온.로직` 칸 = `호표 · 중간 · 덧줄 · 단계 · 끝전 · 이름 · 결과단위`(옛 로직 줄 꼴) — 불러오기 읽기기(`Hopyo_*` · `San_*`)가 **불러올 때마다 이 꼴을 새로 냄** → 저장본을 비워도 다시 생김.
|
||||
- 이것을 문서로 바꾸는 `Doc_Import`(`mf.parse` · `_OPS` · `_plain`) · 가져온 식 기호 `San_Basis_Index` · `Sangeun_QtyLinks` 는 **옛 식 파서**만 씀(엔진 셈 · 글 · 끝수는 안 씀 · 2-C2 · 2-C3 뒤).
|
||||
- 가름: 2-E4 때 파서(`parse` · 연산 표)는 「바탕 기반」 새 모듈(`mf.Master` · `FormulaError` · `COST_ITEMS` 등과 같이)로 떼어 남김 → 857(불러오기 한 번 읽기)이 읽기기에서 문서를 바로 내면 그때 파서도 걷음.
|
||||
- 저장본 비우기와 무관 · 호환 아님(살아 있는 입력 꼴).
|
||||
|
||||
---
|
||||
|
||||
## 4. ㉱ 바뀐 전체 걸음 표 · 병행 묶음
|
||||
|
||||
### 4-1 걸음 표(본 설계 4-1 을 고친 것 · ★ = 새 · ✂ = 줄임)
|
||||
|
||||
| 걸음 | 무엇 | 바뀐 점 |
|
||||
| --- | --- | --- |
|
||||
| 2-A 지킴 올림 | 855 시험 넷 · 골든 | 끝(855-A) |
|
||||
| ★ B9-0 B09 견본 · 골든 | 1-4 | 새 |
|
||||
| 2-B1 | 854-2 확인만 | 그대로 |
|
||||
| 2-B2 · 2-B3 · 2-B4 | 기계 폴백 · 문서 막힘(기준 지금 그대로 · 확정 3) · M01 시험 계산 | 그대로 |
|
||||
| ★ B9-1 셈 기록 | 1-4 | 새 · 2-B 와 병행 |
|
||||
| ★ 저장본 비움(사용자 확인 · 브레인) | 3-2 | 새 · 2-C1 바로 앞 |
|
||||
| 2-C1 ✂ SK 셈 한 길 | 수식 사본 셈만 · 옛 길 갈래 없음 · `Sangeun_Formula` 옛 식 칸 · 옛 상세 시험 8 군 같이 걷음 | 옛 칸 · 사본 없는 SK 갈래 뺌 |
|
||||
| 2-C2 · 2-C3 | 가져온 식 열기 · 검산 | 그대로 |
|
||||
| 2-C4 | 기준 목록 · 서버 풀이 글 ② | 그대로 · B9-4 의 앞 조건 |
|
||||
| 2-C5 | 나머지 셈 자리 | 그대로 |
|
||||
| ★ B9-2 · B9-3 | 사본 셈 · B08 / B09 산근 · 대가 | 2-C1 뒤 |
|
||||
| ★ B9-4 · B9-5 | 산출근거 글 · 사본 꼴 | 2-C4 · B9-3 뒤 |
|
||||
| 2-D ✂ 파일 칸 정리 | 칸 걷음만(올림 규칙 · 이행 없음) · `사본` · `수식.로직` 안 씀 | 크기 절반 |
|
||||
| ★ L1 이름표 싣기 | 2-3 | 새 · 2-D 와 병행 가능(파일 다름) |
|
||||
| 2-E1 · 2-E2 | M01 · M02 옛 길 지움 | 2-E2 일부(옛 식 칸)는 2-C1 로 당겨짐 |
|
||||
| ★ B9-6 B08 · B09 옛 길 지움 | 1-4 | 새 |
|
||||
| ★ L2 읽는 쪽 바꿈 ⓐ ⓑ ⓒ | 2-3 | 새(본 설계 2-E3 의 앞 절반) |
|
||||
| 2-E3 → L3 · L4 | 로직 JSON 뺌 · 빌더 은퇴 | 「이름표만 남김」 → 「없앰」 |
|
||||
| 2-E4 엔진 모듈 지움 | 1-5 차례 · 파서는 바탕 기반으로 | 보류 풂 |
|
||||
|
||||
### 4-2 병행 묶음(창 여덟까지 · 파일 안 겹침)
|
||||
|
||||
| 묶음 | 같이 도는 걸음(창) | 겹침 확인 | 앞 조건 |
|
||||
| --- | --- | --- | --- |
|
||||
| ① | 2-B2 · 2-B3 · 2-B4 · 2-C2 · 2-C4 · **B9-0** · **B9-1**(일곱) | 본 설계 ② + 새 시험 파일 · 새 `master_doc_trace.py` — 서로 다름 | 2-A · 2-B2 는 854-1 뒤 |
|
||||
| ② | 저장본 비움(브레인 · 사용자 확인) | — | ① 의 2-B3 |
|
||||
| ③ | 2-C1(중심) · 2-C3 · **B9-2**(B08 · `Item_Prices` · `Item_Copy`)(셋) | Sangeun_Calc · Doc_Sk ↔ Sangeun_Imported ↔ Item_* · B08 — 다름 | ② · 2-C2 · B9-1 |
|
||||
| ④ | 2-C5 · **B9-3**(B09 Sangeun · Labor_Source · Linked · Supply · Sum · Rule) · 856 화면 하나 · **L1**(빌더 · M01 저장 두 곳)(넷) | Labor_Expand · Hopyo_Build ↔ B09 5 파일 ↔ 화면 TS ↔ 빌더 · M01 Store_Save — 다름 | 2-C1 · B9-2 |
|
||||
| ⑤ | 2-D · **B9-4** · **B9-5** · **L2 ⓐ**(M01 쪽)(넷) | Sangeun_Doc · Copy_Slim 무리 ↔ B09 Sangeun_Text ↔ Item_Source · Item_Sangeun · Bill_Library ↔ M01 Store 무리 — 다름(B9-4 · B9-5 는 B09 안 파일이 다름) | ④ · 2-C4 |
|
||||
| ⑥ | 2-E1 · 2-E2 · **B9-6** · **L2 ⓑ**(M02 이름 읽기 · SK 값 사본)(넷) | M01 ↔ M02 Sangeun 무리 ↔ B08 · B09 ↔ M02 Labor_Inputs · Layer_Index 무리 — 2-E2 와 L2 ⓑ 가 `Sangeun_Copy` 를 같이 만질 수 있음 → 그 파일은 2-E2 한 창 몫 | ⑤ · 856 |
|
||||
| ⑦ | **L2 ⓒ**(불러오기 이음 — 857 과 합침 권함) | Hopyo · San | ⑥ · 857 |
|
||||
| ⑧ | L3 → L4 → 2-E4(차례 · 한 창) | scripts · 자료 | ⑥ · ⑦ |
|
||||
|
||||
꼭 차례인 까닭(본 설계에 더함):
|
||||
- 저장본 비움은 2-C1 앞 — 2-C1 이 옛 꼴 갈래를 안 가지려면.
|
||||
- B9-2 · B9-3 은 2-C1 뒤 — 사본 안 SK 셈이 문서 한 길이어야 B09 가 같은 답을 받음.
|
||||
- B9-4 는 2-C4 뒤 — 서버 풀이 글이 먼저 있어야 함.
|
||||
- L1 은 로직 JSON 을 고치는 일감이 0 일 때 — 빌더 기준이 두 번 바뀌지 않게.
|
||||
- L3 은 B9-6 · 2-E1 · 2-E2 · L2 뒤 — 로직 줄을 읽는 곳 0.
|
||||
- 2-E4 는 L3 뒤 — `mf.Master` 의 로직 그룹이 빠져야 엔진 몸이 지울 수 있는 꼴.
|
||||
|
||||
### 4-3 세기 결과 파일(`tmp/s894/m855b/`)
|
||||
|
||||
| 도구 | 결과 | 핵심 수 |
|
||||
| --- | --- | --- |
|
||||
| `census_calls.py`(sub6 · 내 폴더에서 다시) | `out_calls.tsv` | 185 자리 · 39 파일 · B08 1 · B09 5 파일 51 자리 |
|
||||
| `census_copies.py` · `census_storage.py`(sub6) | `out_copies.json` · `out_storage.json` | 프로젝트 사본 0 · SK 15 · SC 6 · `_합친것` 15 |
|
||||
| `census_logic_fields.py`(새) | `out_logic_fields.json` | 로직 칸 19 · 문서와 같은 값 4 · 문서 없는 이름표 6 + 별칭 + 파일 머리 3 |
|
||||
| `census_logic_readers.py`(새) | `out_logic_readers.tsv` | 파일 · 갈래(관문 · 파일 이름 · 셈 칸 · 이름표 칸)별 자리 |
|
||||
| `census_copy_fields.py`(새) | `out_copy_fields.json` | SK `수식.로직` 16 줄 · `사본.로직` 12 줄 · `가져온.로직` 12 · B09 손 줄 `ref.tab = logic` 6 |
|
||||
|
||||
---
|
||||
|
||||
## 5. 사용자 판단 거리
|
||||
|
||||
1. **B09 손 줄이 M01 기초를 바로 고르는 기능** — B09 설계내역서 [단가 연결] · 운반 단가 모달에서 M01 단가산출 기초를 직접 골라 셈(지금 프로젝트 1 곳에 6 줄). 확정 1(「M02 것을 복사해 가져감」)과 어긋남. ㉠ 그대로 둠 — 같은 새 계산기로 셈 · 지금 6 줄 그대로 이어짐(권함) ㉡ M02 단가산출만 고르게 바꿈 — 6 줄을 다시 이어야 함.
|
||||
2. **「계산을 직접 할 일 없음」 의 뜻** — 프로젝트에서 구조물 입력값 · 운반 거리를 바꾸거나 [단가 갱신] 을 누르면 금액이 다시 나와야 함. 이때 M02 와 **같은 계산기 한 벌**을 불러 다시 셈(B09 엔 식 엔진 없음 · 갈라 합산만)으로 이해(권함 · 1-3 안 B). 「복사 때 굳힌 금액만 쓰고 프로젝트에선 절대 다시 셈 안 함」 이 뜻이면 입력 바꿈 · [단가 갱신] 을 M02 [재생성]으로만 하게 바뀜.
|
||||
3. **프로젝트 쪽 옛 꼴** — 확정 5 는 M02 층 자료. 프로젝트 사본은 지금 0 개라 옛 사본 꼴 읽기(25-2b `items/` 옮겨 받기 등)도 같이 걷어도 되는지(권함 = 걷음 · 지금 옮길 것 0).
|
||||
4. **저장본 비우는 때** — 지금 개인 층 단가산출이 계속 늘어나는 중(세는 동안 14 → 15). 2-C1 앞에 비우면 그 사이 만든 것도 지워짐 → 비우기 전날 알림 · 남길 것만 다시 만들 길(가져온 식은 다시 불러오면 됨)을 같이 알림.
|
||||
|
||||
## 6. 못 본 것
|
||||
|
||||
- 서버 · 화면을 돌리지 않음(코드 따라가기 + 자료 세기). 「살아 있음」 = 화면 TS 에서 서버 길까지 이름으로 이은 것 · 단추를 눌러 보지 않음.
|
||||
- B09 프로젝트 1 곳의 손 줄 6 은 칸 이름만 셈(로직 키 · 값 안 봄).
|
||||
- `M02_Sk_AutoRenew` · `MasterTemplete_Tree.old_fields` · `MyMachine._old` 가 옛 저장 꼴만 읽는지는 확인 안 함(3-1 「미확인」).
|
||||
- `.logic(` 류 자리 수(102)는 글자 찾기 — `whole.logic` 처럼 이름을 바꿔 부르는 곳 · 문자열로 조립한 부름은 빠졌을 수 있음(L3 앞 전수는 다시 셈).
|
||||
- 855-A 시험(sub6 커밋 327fdc5d9)은 이 폴더 받은 판에 아직 없음 — 이름만 PLAN 에서 봄.
|
||||
- 줄 수 어림은 함수 크기로 짐작한 값.
|
||||
Reference in New Issue
Block a user