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

This commit is contained in:
2026-11-17 19:05:16 +09:00
8 changed files with 4512 additions and 0 deletions
+2
View File
@@ -43,6 +43,8 @@ COSTS = ("노무비", "재료비", "경비")
RATIOS = ("내용시간", "연간표준가동시간", "상각비율", "정비비율", "연간관리비율")
COEFS = ("상각비계수", "정비비계수", "관리비계수")
NUMS = ("가격", *RATIOS, *COEFS, "손료계수", "주연료", "전력")
# 기계 칸 단위 — 짝(표 셋): `common_util_line_stack_unit.ts` MACHINE_UNIT · `build_기계_건설품셈.py` UNIT ·
# 거울 시험 `resources/tester/test_854_3_machine_unit_mirror.py`(칸을 더하거나 글을 바꾸면 셋 모두)
UNITS = {
"가격": "천원", "내용시간": "시간", "연간표준가동시간": "시간", "상각비율": "", "정비비율": "",
"연간관리비율": "", **{k: "10^-7/시간" for k in (*COEFS, "손료계수")}, "주연료": "ℓ/hr",
@@ -8,6 +8,7 @@
`TOUCH` = 사본 단가 줄을 새 값으로(`renew`) · 실패 = 만든 파일 지움 · 고친 줄 되돌림(번호표는 그대로).
사본 줄 보기(`copy_row`) = 그 SK 사본에 박힌 기계 줄 · 지금 줄 · 새 값 여부.
개인 층만(`mym._user` — 그 밖 404).
화면 짝 = `common_util/common_util_line_stack_draft.ts`(칸 이름 · 표지 꼴 「EQP초안-N」).
"""
from __future__ import annotations
@@ -0,0 +1,277 @@
# 설계 857 — 걸음 4 「불러오기 한 번 읽기」 (요구 896 · PLAN 857)
sub8 · 2026-11-17 · 읽기 · 세기만(코드 · 자료 · 시험 고침 0). 바탕 = `_분석_894-C_불러오기.md`(「분석 C」) · `설계_855_정본하나_계산기하나.md`(「본 설계」) · `설계_855_보충_B09_로직JSON_호환.md`(「보충」) · `_방향_불러오기.md` 0 절.
세는 도구 · 결과 = `tmp/s894/m857/`(끝 표). 견본 = 저장소의 실무 엑셀 11(`test_797_1a_import_flags.FILES`) · 경쟁사 자료 내용 · 푸는 법은 안 옮김(모듈 구실만).
## 0. 한눈 요약
- **두 계보가 읽은 블록은 이미 같음** — 엑셀 11 에서 단가산출 블록 번 · 단위 · 블록 금액이 두 계보 모두 같음(다름 1 = 빈 블록 「{}」 대 「0」). 이름만 꼴이 다름(EST 호표 쪽 = 「이름(규격)」 한 칸 · 둘 꼴 = 이름 · 규격 두 칸 / STmate 둘 꼴 = 「이름 규격 / 단위」 머리 글). → **호표 계보를 둘 꼴 위에 얹는 것은 가능**. 다만 호표 쪽이 더 읽는 것(항목 · 절 · 출처 · 직종 · 줄합 · 덮음 · **EST 일위대가 시트 전체**)을 둘 꼴에 더 실어야 함(1-3).
- **엑셀 11 중 2 개(516 블록)는 지금 화면에서 못 올림** — 일위대가 시트가 없으면 호표 읽기가 400 을 내고 산근 읽기까지 안 감(`M02_Hopyo_Router.py:83`). 산근 계보는 이 둘을 읽음(374 · 142 블록 · 「3,241 블록 재현」 에 들어 있음). 한 번 읽기(산근 계보 먼저)가 이것도 풂.
- **올림 한 번 = 책 열기 2 회 + 격자 XML 1 회**(`_open` 1 · `San_Book.sheets` 1 · 격자는 `opened` 재사용) — 큰 xlsx(거창)는 두 번째 열기만 9.3 초. 한 번 열기로 그만큼 줄어듦.
- **재료 이음 규칙을 호표 길에 그대로 쓰면 118 줄이 바뀜**(9 파일 · 자재 · 별도계상 393 줄 중) — 생김 106 · 다른 품목으로 바뀜 12 · 풀림 0 · 그중 **109 줄 금액이 엑셀과 달라짐**. 차이의 거의 전부는 「규칙」 이 아니라 **호표 길의 「단가가 엑셀과 같을 때만 이음」 관문**(`M02_Hopyo_Fixed.py:153`)에서 옴(생김 중 정확 일치 66 · 표기 32 · 규칙 F2 8). 고정 줄은 이으면 우리 단가로 셈 → 「엑셀 숫자 그대로」 와 정면으로 부딪힘(2 절 · 판단 거리 1).
- **「고를 재료」 판 첫 셈이 느린 까닭은 변환이 아니라 M01 「바뀌었나」 확인** — 블록마다 줄마다 `m01.loaded()` 가 M01 파일 날짜를 다시 잼(65 블록에 2,069 번 · 시간의 약 80 %) + 기계 파일 목록 glob 2,069 번. 실측 4 ~ 41 초/파일(북부청임도 95 블록 40.9 초). 셈 한 번 동안 M01 한 벌을 쥐면 결과 그대로 몇 초로 줄 것(5 절) — 「재료 줄만 도는 길」 보다 작고 안전.
- **가져온 식은 「옛 로직 줄 꼴 → 옛 엔진 → 빌더 변환기」 를 거쳐 문서가 됨**(`M02_Doc_Import.py:409-422` · `master_doc_convert.convert`). 2-C2 가 옛 엔진만 걷음 · **변환기(`master_doc_convert`)는 그대로 남음** → 본 설계 2-E3(빌더 · 변환기 은퇴) 앞에 857 의 「읽기기가 문서를 바로 냄」 이 끝나야 함(차례 조건 · 3 절).
- **L2 ⓒ(불러오기가 M01 로직 줄을 읽는 곳)는 실제로 9 곳 7 파일**(보충 2-2 의 「관문」 줄 대부분은 M01 요소 색인 `m01.loaded()` 로 로직 줄이 아님 · 4 절) — 857 걸음 안에 합침 권함.
- 걸음 = **여섯**(857-0 지킴 · 857-1 책 한 번 · 857-2 호표를 둘 꼴 위로 · 857-3 문서 바로 · 857-4 재료 한 벌 · 857-5 옛 길 지움) · 병행 묶음 셋 · 앞 조건 = 본 설계 2-C2 · 2-C3 · 2-C5(`Hopyo_Build._inside`) 끝(6 절).
---
## 1. 읽기 한 번
### 1-1 지금 올림 한 번(엑셀)
| 차례 | 자리 | 하는 일 | 책 열기 |
| --- | --- | --- | --- |
| ① | `M02_Hopyo_Router.py:83` → `M02_Hopyo_Excel.read_book:300` → `_open:112` | 일위대가 · 총괄표 · 단가산출 · 목록 시트(STmate = `Hopyo_Stmate.SHEETS`) 줄 · **일위대가 시트 없으면 400** | xlsx `openpyxl` 1 · xls `xlrd`(서식) 1 |
| ② | `Router.py:87` → `Hopyo_Grid.read:325` → `Hopyo_Excel.opened:102` | 격자(보기) — ① 책 재사용(`_OPENED:58` 프로세스 전역 하나) · xlsx 는 ZIP XML 을 따로 읽음(`Grid.py:212`) | 0(+ XML) |
| ③ | `Router.py:91` → `Sangeun_FromHopyo.keep:50` → `San_Book.sheets:40` | 산근 시트(STmate 8 · EST 7) 줄 — **책을 처음부터 다시 엶** | 1 |
| ④ | `FromHopyo._excel:73` → `San_Xlsx.read_sheets` → `Doc_FromNative.pack` | 둘 꼴 → `실무자료/산근/<HP>.json` `{파일 시트 엑셀}` | 0 |
종류 가름 두 곳 · 시트 목록 둘:
| | 호표 쪽 | 산근 쪽 | 갈림 |
| --- | --- | --- | --- |
| 종류 가름 | `Hopyo_Stmate.is_stmate:67` = 「일위대가표」 **와** 「단가산출근거」 | `San_Book.kind_of:67` = 「단가산출근거」 있으면 STmate · 「단가산출」 있으면 EST | 단가산출근거만 있는 STmate = 호표 쪽 EST 로 보고 「일위대가 시트 없음」 400 · 견본 11 에서는 셋 다 같은 판정 |
| 시트 목록 | `Hopyo_Excel` SHEET · SUMMARY · `ReadEst.SHEET` + LISTS · `Hopyo_Stmate.SHEETS`(7) · `Grid.EXTRA` | `San_Book.STM_SHEETS`(8 · 중기사용료 · 일위대가표 더 있음) · `EST_SHEETS`(7 · 기계경비 · 자재 · 노임 · 견적단가 더 있음) | 두 목록 합집합이 한 번에 읽을 시트 |
### 1-2 세기 — 두 계보가 읽은 단가산출 블록(`m857_read.py` → `out_read.json`)
| 파일 | 꼴 | 호표 쪽 단산 | 둘 꼴 산근 | 같은 번 | 단위 다름 | 금액 다름 | 이름 꼴 다름 | 호표 읽기 초 | 산근 책 다시 열기 초 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 북부청임도 | EST xls | 95 | 95 | 95 | 0 | 1(빈 블록) | 87 | 3.7 | 0.08 |
| 북부청사방 | EST xls | 67 | 67 | 67 | 0 | 0 | 47 | 1.9 | 0.10 |
| 거창 | EST xlsx | 61 | 61 | 61 | 0 | 0 | 47 | 10.4 | **9.28** |
| 봉화 · 영월 · 울진대흥 · 영덕 · 울진소광 · 대흥공통 | STmate xlsx | 282 | 282 | 282 | 0 | 0 | 282 | 12.4 | 3.29 |
| 2016사방 · 2026수목 | EST xls | **0(400)** | 516 | — | — | — | — | — | 0.13 |
| 합 | | 505 | 1,021 | 505 | 0 | 1 | 463 | 28.5 | 12.9 |
- 「이름 꼴 다름」 = 같은 블록 · 쓰는 법만 다름(1 절 요약) — 둘 꼴에 「보일 이름」 하나를 더 실으면 됨.
- 「산근 책 다시 열기」 = 한 번 읽기로 없어지는 시간(거창 꼴 큰 xlsx 에서 큼).
### 1-3 호표 계보가 둘 꼴 위에서 돌려면 더 실어야 할 것(호표 쪽 단산 칸 전수 · 505 블록)
| 호표 쪽 칸(`Hopyo_Excel.read_book:369` keep) | 만드는 곳 | 읽는 곳(호표 계보 · 그 밖) | 둘 꼴에 지금 | 더 실을 것 |
| --- | --- | --- | --- | --- |
| 번 · 이름 · 단위 · 행 | ReadEst · Stmate | 목록 · 칠 · 격자 | 번 · 이름(+ 규격) · 단위 · 엑셀행 | 「보일 이름」(호표 쪽 꼴) |
| 금액 {계 노무비 재료비 경비} | 같음 | 검산 · 목록 | 저장 {T L M S} | 없음(이름만 바꿔 읽음) |
| 글 · 글행 | ReadEst(EST) | 근거 보기 · 칠 · `Hopyo_Formula` | EST 줄 `행` · `보임`(같은 시트 줄) / STmate 줄 `글`(숨은 G 열) | STmate = 보이는 글(B 열) 줄 · 아니면 그대로 |
| 출처 [[책, 절]] | `Hopyo_Clause.settle` | 근거 표 · `San_Basis_Index` | 없음 | 글에서 셈(지금 부품 그대로 · 둘 꼴 위로 옮김) |
| 직종 | `ReadEst.trade` | 근거 · `San_Basis_Index:122` | 없음 | 같음 |
| 항목 [{묶음 이름 규격 품 밑품 율 인자 어떻게 단가 금액 절 윗절 절율 행 재현 기준* 계수 손료율 …}] | `ReadEst.items:298` · `Hopyo_Formula` · `Hopyo_Stmate._blocks` | `Hopyo_Marks`(칠 · 줄 표지) · `Hopyo_Units` · `Hopyo_UnitLine`(재현 · 덮음) | EST 구조 줄(자원 · 결과 · 변수 · 연결단가 · 비목 · 품명) · STmate 원문 풀이 | **품 · 율 · 인자 · 절 나무(`Formula`)** — 구조 줄로는 못 냄 · 그 계산은 남기고 입력만 둘 꼴 줄로 |
| 절 [{번 층 제목 갈래 행 글 상수 식}](EST) | `Hopyo_Formula` | 칠 · 근거 | 없음 | 위와 같음 |
| 줄합 · 덮음 | `Hopyo_UnitLine.settle` | 호표 줄 투영 · 칠 | EST 없음 · STmate `줄합`(산근 쪽은 `pack` 이 버림 · 분석 C 2-1) | `줄합` 버리지 않음 |
| 코드 · 규격 · 자원(STmate) | `Hopyo_Stmate` | 목록 · 이음 | 코드 · 규격 · 줄 글 | 자원 줄 메타(M · H · X 열) |
| **EST 일위대가 시트(호표 · 줄 · 참조 · 갈래 · 검산)** | `Hopyo_Excel.read_book:300-360` | 호표 목록 · SC 만들기 · **B09 내역서 불러오기**(`B09_Estimation_Bill_Hopyo.py:41`) | **없음**(`San_Xlsx_Est` 일위 = 빈 목록 · STmate 는 `San_Xlsx_Ilwi` 로 있음) | EST 일위 읽기(지금 함수 그대로)를 둘 꼴 `일위` 로 |
| 일위대가총괄표 · 목록 시트 줄 | `_summary` · 격자 | 검산 · 격자 | 없음 | 시트 줄(한 번 읽은 책에서) |
못 얹는 것(그대로 둠):
- **격자**(`Hopyo_Grid`) — 서식 · 병합 · 열 폭 = 책 자체(xls 서식 · xlsx XML)가 필요 · 둘 꼴과 무관. 한 번 연 책을 넘겨받는 꼴만.
- **붙여넣기**(`Hopyo_Paste.read_text`) · **B09 내역서**(`Bill_Excel` · `Import_Prices` · `Import_Rates` 가 `hx._text` · `_flat` · `_out` · `DRM` 씀) — 엑셀 책이 아닌 입구 · 작은 도우미만 공유 → 도우미를 공용 자리에 두고 그대로.
- 호표 쪽 **항목 계산 몸**(`ReadEst.items` 116 줄 · `Formula` 352 줄) — 읽는 것은 같은 시트 글이므로 「입력 = 둘 꼴 줄」 로만 바꾸고 몸은 둠(지우면 칠 · 줄 표지 · 고정 줄 회귀가 큼).
### 1-4 끝 모습
- 책 열기 = **한 곳**(새 「책 한 벌」 · 시트 목록 합집합 · 종류 가름 한 말 · xls 서식 책 함께) → ① 둘 꼴(`pack` · 일위 포함) ② 격자 ③ 호표 목록이 그 위.
- 올림 순서 = **산근(둘 꼴) 먼저** → 일위대가 시트 없으면 호표 목록만 빔(400 아님) · 둘 꼴 못 읽으면 지금처럼 「읽기불가」 사유.
- `_OPENED` 전역 걷음(책 한 벌을 인자로 넘김).
---
## 2. 재료 이음 규칙 한 벌
### 2-1 두 길 차이 전수
| 항목 | 단가산출 길 `San_Link.m01:15` → `San_MatFind.find:125` | 호표 길 `Hopyo_Fixed.Linker.link:107` · `_mats:159` |
| --- | --- | --- |
| 밑 부품 | `Hopyo_Match` · `Hopyo_Material` · `Hopyo_MatSame` · `Elem_Alias` | 같음(`hm._exact` · `hmat.sure`) |
| 코드 길 | EST 원파일 자원 코드 → 우리 자재 출처 코드(`ea.est_code` · 815-1 K1) | 없음 |
| 별칭 | 있음(`ea.keys`) | `hm._exact` 안의 별칭만 |
| 표기 다름(817-1) | 있음(`_how` 「표기」) | 없음 |
| 자동 규칙 A ~ F2 | 있음(`RULES:346`) | 없음 |
| 단서(산근 줄 글 · 머리 · 내역서 · 일위대가표) | 있음(`clues_on:91`) | 없음 |
| 단위 맞춤 | 쌍둥이 › 같은 성격 › 고르기(`_by_unit:176`) | 단위 배 = 1 일 때만 |
| **단가 값** | **안 봄**(판정 = 글만 · 두 판 [엑셀 단가로] · [우리 단가로]) | **엑셀 재료비 단가와 1 원 안으로 같은 품목 하나일 때만**(`_same:152`) |
| 유가 · 환율 | 재료 줄이 MO · 화폐 이름이면 유가 · 환율로 | 없음(자재만) |
| 별도계상 | 품목 찾되 이음 비움(단가 0 그대로) | 재료비 있으면 같은 관문 |
| 못 이은 줄 | 판정 다섯 갈래 + 후보 → 사람 고름(`San_MatPick`) | 후보 수만(`near`) → [수정] 모달 고름 |
| 이은 뒤 셈 | 가져온 식 = 두 판(엑셀 값 기억 · `Doc_Import` `엑셀` 칸) | **고정 줄 = 이은 비목은 우리 단가 책 값**(`M02_Labor_Fixed.py:6-9`) · 엑셀 값 기억 없음 |
### 2-2 세기 — 호표 길이 단가산출 규칙을 쓰면(`m857_mat.py` → `out_mat.json` · `out_mat.tsv`)
대상 = 일위대가 시트 호표 줄 중 자재 · 별도계상 갈래(9 파일 · 393 줄 · 단서 = 같은 파일 둘 꼴 단서).
| 파일 | 같음(이음) | 같음(못 이음) | 생김 | 다른 품목 | 풀림 | 금액 달라짐 | 엑셀 값 그대로 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 북부청임도 | 1 | 97 | 32 | 12 | 0 | 44 | 0 |
| 북부청사방 | 0 | 48 | 8 | 0 | 0 | 5 | 3 |
| 거창 | 1 | 10 | 5 | 0 | 0 | 5 | 0 |
| 봉화 | 8 | 13 | 19 | 0 | 0 | 17 | 2 |
| 동부청영월 | 0 | 36 | 5 | 0 | 0 | 3 | 2 |
| 울진대흥 · 대흥공통 | 0 | 36 | 26 | 0 | 0 | 24 | 2 |
| 영덕계류 | 4 | 0 | 0 | 0 | 0 | 0 | 0 |
| 울진소광 | 0 | 13 | 11 | 0 | 0 | 11 | 0 |
| **합** | **14** | **253** | **106** | **12** | **0** | **109** | **9** |
- 생김 106 의 방법 = 정확 일치 66 · 표기 32 · 규칙 F2 8 → **새 규칙보다 「단가 같을 때만」 관문이 차이의 대부분**.
- 다른 품목 12(북부청임도 돌망태 둘 × 6) = 호표 길은 단가가 엑셀과 같은 품목(지역 · 판이 맞는 줄)을 고름 · 단가산출 길은 단가를 안 보고 표기로 다른 품목을 고름 → **규칙 한 벌로 가면 이 12 줄은 품목이 틀어짐**(호표 길 쪽이 맞음).
- 「금액 달라짐」 = 이은 품목의 우리 단가 ≠ 엑셀 재료비 단가(고정 줄은 이으면 우리 단가로 셈).
### 2-3 「엑셀 숫자 그대로」 와 부딪히는 자리
| 자리 | 부딪힘 | 피하는 법(안) |
| --- | --- | --- |
| 고정 줄 이음 = 우리 단가로 셈(`Labor_Fixed.py:6-9`) | 이음이 늘면 SC 금액이 엑셀과 달라짐(109 줄) | ㉠ **규칙 한 벌 = 「찾기」 만**(키 · 후보 · 판정) · 호표 길은 「단가 같음」 관문을 그대로 두고 단가 다른 짝은 「후보 · 판정」 으로만 보임(권함) ㉡ 고정 줄에도 엑셀 값 기억(두 판)을 둠(SC 꼴 바뀜 · 큼) ㉢ 이음 늘림을 받아들이고 금액이 우리 단가로 바뀌는 것을 인정 |
| 다른 품목 12 | 단가산출 길은 단가를 안 봐 지역 · 판이 다른 품목을 고름 | ㉠ 에서는 호표 길이 「단가 같은 후보」 를 먼저 고름 = 지금 결과 그대로 · 단가산출 길에도 같은 「값 같은 쌍둥이 먼저」 를 더할지는 판단 거리 2 |
| 705-3 「빠짐 0」 | 이음 판정이 바뀌어도 줄이 빠지지 않음(고정 줄 그대로) | 지킴 시험 그대로 |
→ 권함 = **「찾기 한 벌 · 관문은 길마다」**: 호표 길 `_mats` 를 `San_MatFind.find`(단서 포함) 후보로 바꾸되 「엑셀 단가와 같은 후보 하나」 일 때만 이음 · 나머지는 판정 · 후보로 [수정] 모달에 보임. 이러면 금액 달라짐 0 · 생김 = 지금 관문을 통과하는 것만 · 다른 품목 0 · 화면의 「후보 · 판정」 말이 두 길에서 같아짐.
---
## 3. 가져온 식을 문서로 바로
### 3-1 지금 길(블록 하나 → 저장 SK)
| 단 | 꼴 | 자리 | 옛 식 파서 · 엔진 · 변환기 |
| --- | --- | --- | --- |
| ㉠ 둘 꼴 | 블록 구조 줄 | `Doc_FromNative.pack:49` | — |
| ㉡ 옛 로직 줄 `{로직 {이름 결과단위 입력 중간 호표 덧줄 단계 끝전 조정 끝수}, 원본}` | `Doc_NativeEst.block:610`(EST) · `San_Emit.stmate`(STmate) · 이음 · 재료 · 기계 판정 얹음 | `San_Expr` · `San_Stmate.parse_line`(경쟁사 글 풀이 · 남음) |
| ㉢ 가져온 식 SK `가져온 {로직 원본 검산 단가기준}` | `Sangeun_Imported.new_doc:569` · `check:368` → `_run:346`(옛 엔진) | 옛 엔진(2-C3 이 걷음) · `whole.logic`(:179) |
| ㉣ 수식 문서 | `Doc_Import.derive:409` = `_ctx:74`(옛 엔진 · **2-C2 가 걷음**) → `master.logic(key)` → **`master_doc_convert.convert`**(:422) → `_attach` · `_numbers` · `_native` · `Shape` · `Q` · `NativeLayout` | 변환기 · `mf.parse` · `mf._OPS` · `_plain`(`_swap_nth` · `_picks` · `_logic_link`) |
옛 로직 줄 꼴(㉡ · ㉢)을 읽고 쓰는 자리(불러오기 안 · `out_l2.tsv` 의 「로직」 칸 줄): `Sangeun_Imported`(:7 · 109 · 127 · 281-319 · 334 · 374 · 513-518 · 578) · `Doc_Import`(:142 · 249 · 419) · `Doc_Import_Shape:259` · `Doc_NativeLayout:42 · 68-70` · `San_MatPick:206 · 342` · `San_MyMachine:368-391` · `Sangeun_FromHopyo:133-244` · `Sangeun_QtyLinks:241 · 290 · 330` · `Doc_FromNative:145` · `San_Emit` · `Doc_NativeEst` — **15 파일**.
### 3-2 바꾸는 길 — 읽기기가 문서를 바로 냄
| 박자 | 무엇 | 걷히는 것 |
| --- | --- | --- |
| 첫 박자(857-3a) | ㉡ 꼴은 그대로 두고 **㉡ → 문서 변환을 불러오기 자기 모듈로**(새 `M02_San_ToDoc`) — 지금 `derive` 가 하는 일(변환기 몫 + 붙임 · 다듬기)을 옛 로직 줄 대신 ㉡ 를 직접 읽어 문서 변수 · 식 · 금액 줄로 · 식 글 파서 = 문서 파서(`master_doc.parse`) 또는 `San_Expr` | `Doc_Import` 의 `master_doc_convert` 부름 · `master.logic` · `_Row`(가짜 마스터) · `mf.parse` · `_OPS` · `_plain` |
| 둘째 박자(857-3b) | **SK 정본 = 문서**(`수식`) · `가져온` = `{원본 · 단가기준 · 검산}` 만(호환 안 만듦 · 요구 899) · 이음 고침 · 두 판 · 소요량 고름 · 재료 고름 · 내 기계가 문서 연결을 고침 · 다시 열기 = 저장 문서 그대로(`derive` 없음) | `가져온.로직` · `Sangeun_Imported` 의 옛 줄 꼴 정리(`clean_row` · `row_of` · `_with`) · `San_Basis_Index` · `Sangeun_QtyLinks` 의 옛 식 파서 부름(`mf.parse` · `_OPS` 5 + 3 곳) · `Doc_Import_Reset` 의 옛 줄 되돌림(초기화 = 원본에서 다시 지음) |
| 끝 | 2-E4 「바탕 기반」 새 모듈에서 **옛 식 파서도 뺌**(보충 3-3 의 「857 이 문서를 바로 내면 그때 파서도 걷음」) | `mf.parse` 류(불러오기 몫 0) |
- 읽기기(㉠ · `San_Xlsx*` · `San_Estx` · `San_Stc`)와 `San_Expr` · `San_Stmate.parse_line`(경쟁사 글 풀이)은 그대로 — 바뀌는 것은 ㉡ 뒤.
- **차례 조건**: 본 설계 2-E3 이 `master_doc_convert` 를 은퇴시키므로 **857-3a 가 2-E3 앞**에 끝나야 함(아니면 2-E3 이 불러오기용으로 변환기를 남겨야 함).
### 3-3 3,241 블록 금액 재현 지키는 법
| 지킴 | 지금 | 857 에서 |
| --- | --- | --- |
| 블록 금액(계 · 비목) | 저장소 시험 = `test_812_1` ③(엑셀 11 = 1,021 블록 · 문서 셈 = 엑셀 금액) · `test_810_2`(원파일) · 전수 3,241 = sub7 `tmp/s894/m855b/m855_import.py`(저장소 밖 · 옛 = 새 대조) | **857-0 에서 저장소 지킴 시험으로 올림** — 3,241 블록 × 두 판(엑셀 · 우리) 계 · 비목 지문(`golden_857_import.json`) + 검산 판정 지문 · 원파일 견본 없으면 건너뜀 |
| 줄 꼴 | 없음 | 블록마다 문서 금액 줄 수 · 이름 · 비목 지문(857-3 전후 같음 · 줄 쌓기 화면이 같은 줄을 봄) |
| 이음률 | `_방향_불러오기.md` 0 절 수(인력 100 · 기계 90.8 · 재료 72.0 %) | 지킴 시험 안에 갈래별 이음 수 · 판정 수 지문(857-4 는 「뜻한 바뀜」 표로 다시 뜸) |
---
## 4. L2 ⓒ — 불러오기가 M01 로직 줄을 읽는 자리(`m857_l2.py` → `out_l2.tsv`)
보충 2-2 의 「불러오기 이음」 줄(Hopyo_Elem 5 · Match 3 · Clause · Relink · Row · Units · Build · Doc_Import · San_*)을 코드 줄로 펼친 결과 — **대부분은 M01 요소 색인(`m01.loaded()[1]` · LB · MT · EQ · MO · FX)이라 로직 JSON 이 아님**. 로직 줄(로직 JSON)을 실제로 읽는 곳만:
| 자리 | 읽는 것 | 갈 곳(수식 문서 읽기) | 걸음 |
| --- | --- | --- | --- |
| `M02_San_Basis_Index.py:160` | `로직_*.json` 파일을 **이름으로** glob | 수식 문서 파일(`수식_*.json` · `master_doc_link.load_all`) | 857-3b(옛 식 파서와 같이) |
| `M02_Hopyo_Clause.py:68-71` | M01 파일 중 그룹 「로직」 의 구분 · 원문번호(출처 → 기초 짝) | 문서 머리 원문번호(보충 L1 이 싣는 이름표) | 857-2 |
| `M02_Hopyo_Match.py:211-221` | 로직 줄 키 · 이름 + 알약 단위(`combo_pills`) — 맞춤 대상 | 문서 머리 이름 · 결과단위 | 857-2 |
| `M02_Hopyo_Units.py:72` · `:209` | `whole.logic(code).입력` · 기계 로직 | 문서 변수(입력 갈래) | 857-2 |
| `M02_Doc_Import.py:415` · `:488` | 옛 엔진 색인의 로직 줄 · 하위 로직 | 없앰(857-3a) | 2-C2 가 반 · 857-3a 끝 |
| `M02_Sangeun_Imported.py:179` | 「로직(GC…)」 부름 키 있나 | 문서 있나(`Links.doc`) | 2-C3 |
| `M02_Sangeun_Imported.py:419` | `over.logic(key)` 자동값(`mau`) | 문서 변수 기본값 | 2-C5(`_inner`) |
| `M02_Hopyo_Build.py:332-333` | `run_line` 로 하위 로직 금액 | 문서 셈 | 2-C5(`_inside`) |
| `M02_Hopyo_Relink.py:119` · `Hopyo_Compare.py:55` | `Labor_Ref.Expand`(일위대가 참조 펼침 — 안에서 로직 줄을 읽을 수 있음 · **유력**) | `Labor_Ref` 쪽 걸음을 따라감 | 2-C5 · 855-E |
- 걷힐 것: `Hopyo_Ledger`(로직 장부 읽기 · 분석 C 「안 씀」) — 857-5 에서 지움.
- **차례**: 보충 L1(이름표 싣기)이 먼저 있어야 Clause · Match · Units 가 문서 머리에서 같은 칸을 읽음 → 857-2 는 L1 뒤 · 857-3b 는 2-C2 · 2-C3 뒤. 보충 4-2 묶음 ⑦(L2 ⓒ)은 **857 에 합침**(따로 걸음 안 둠).
---
## 5. 「고를 재료」 판 첫 셈 · 저장본 무효
### 5-1 세기(`m857_census.py` · `m857_census_split.py` · `m857_prof.py` → `out_census*.json`)
| 파일 | 블록 | 판 첫 셈 초 | 그 안 재료 찾기 초 | 인력 초 | 재료 줄 |
| --- | --- | --- | --- | --- | --- |
| 북부청임도 | 95 | 40.9 | 14.8 | 2.7 | 59 |
| 봉화 | 65 | 28.3 | 8.7 | 1.1 | 36 |
| 2026수목 | 142 | 21.2 | 9.1 | 6.1 | 72 |
| 그 밖 8 | 15 ~ 374 | 4.2 ~ 25.4 | — | — | 0 ~ 64 |
프로파일(봉화 65 블록): **`m01.loaded()` 2,069 번 → `Store_Cache._stamps`(M01 파일 날짜 다시 잼 · `M01_MasterData_Store_Cache.py:57`) 누적 42.5 초 / 54.5 초**(약 80 %) · 기계 파일 목록 `master_machine_files.names:28` · `stamp:42` 2,069 번 · 별칭 책 `Elem_Alias.book:60` 591 번.
### 5-2 1 ~ 3 과 같이 풀리나
| 문제 | 1 ~ 3 으로 풀림? | 따로 할 것 |
| --- | --- | --- |
| 느림 | **아님** — 한 번 읽기 · 규칙 한 벌 · 문서 바로는 이 확인 횟수를 안 줄임 | **판 셈 · 블록 열기 · 저장 한 번 동안 M01 한 벌을 쥠**(요청 안 「M01 고정」 · 지금 `San_MatFind._CTX` 같은 ContextVar 꼴 · 결과 그대로) — 어림 30 줄 · 기대 = 수 초. 「재료 줄만 도는 길」(분석 C (나) 5)은 그 뒤에도 느릴 때만 |
| 저장본 무효(`산근/<HP>.json` `재료판` · 무효 = HP 지움뿐 · `San_MatPick.py:194`) | **일부** — 3-2 둘째 박자 뒤에도 판은 그대로 남음 | 판에 **M01 지문 + 별칭 판 + 그 파일 고름 판**을 같이 적고 다르면 다시 셈(분석 C (나) 4 · 어림 10 줄) · 한 번 읽기(857-1)에서 `산근/<HP>.json` 꼴을 바꿀 때 같이 |
| 셈 엔진 셋(읽기 투표 · 검산 · 최종) | 857-3b 로 검산 = 문서 셈 하나 | 읽기 끝전 투표(`San_Eval`)는 경쟁사 끝수 읽기라 남음 |
---
## 6. 걸음
원칙: 두 박자(새 길로 바꿈 → 전수 다름 0 → 옛 길 지움) · 한 걸음 = 한 커밋 묶음 · 화면은 걸음마다 그대로 돎.
| 걸음 | 무엇 | 파일(어림 줄) | 지킴 | 위험 · 막는 법 | 화면 확인 |
| --- | --- | --- | --- | --- | --- |
| **857-0 지킴 올림** | 3,241 블록 × 두 판 계 · 비목 · 검산 판정 · 이음 판정 지문 · 호표 쪽 HP 읽기 지문(엑셀 9 · 호표 · 단산 · 칠 표지 · 고정 줄) · 재료 이음 전후 표(`m857_mat` 꼴) | 새 `resources/tester/test_857_import_golden.py`(+ 250) · `helper_857.py` | 지금 수치 그대로 통과 | 원파일 견본 없는 PC = 건너뜀 · 전수는 환경 변수 | — |
| **857-1 책 한 번 · 종류 한 말** | 새 「책 한 벌」(시트 목록 합집합 · 종류 가름 하나 · xls 서식 책) → `read_book` · `Grid` · `San_Book.sheets` 가 받음 · `_OPENED` 걷음 · 올림 = 산근 먼저(일위대가 없음 = 호표 빈 목록 · 400 아님) · `재료판` 무효 지문 | 새 `M02_San_Workbook.py`(+ 90) · `Hopyo_Excel`(− 60) · `Hopyo_Grid`(± 15) · `San_Book`(− 40) · `Hopyo_Router._upload`(± 20) · `Sangeun_FromHopyo.keep`(± 20) · `Hopyo_Stmate.is_stmate`(− 5) · `San_MatPick`(± 15) | 857-0 전부 같음 · 2016사방 · 2026수목 올림이 됨(HP 생김 · 단가산출 목록 516) · 올림 시간 전후 표 | 시트 선택이 계보마다 달랐던 것(STmate 단가산출근거만 있는 파일) — 견본 11 에서는 같은 판정 | 엑셀 · 원파일 올림 · 엑셀 보기 · 오른쪽 두 목록 |
| **857-2 호표를 둘 꼴 위로 + L2 ⓒ 이름표** | 둘 꼴에 1-3 표 칸(보일 이름 · STmate 보이는 글 · 줄합 · EST 일위)을 더 싣고 `ReadEst` · `Stmate._blocks` · `UnitLine` · `Clause` 의 **입력을 둘 꼴 줄로**(몸은 둠) · `Clause` · `Match` · `Units` 의 로직 줄 읽기 → 문서 머리 | `Doc_FromNative.pack`(± 30) · `San_Xlsx_Est`(+ 60 · EST 일위) · `Hopyo_Excel.read_book`(± 80) · `Hopyo_ReadEst`(± 40) · `Hopyo_Stmate`(± 60) · `Hopyo_Clause` · `Hopyo_Match` · `Hopyo_Units`(± 40) | 호표 쪽 HP 읽기 지문 같음(505 블록 칸 전부) · 칠 · 고정 줄 · `test_621` · `test_m02_hopyo_*` · `test_812_1` · B09 내역서 시험 | B09 `Bill_Hopyo` 가 `read_book` 꼴을 먹음 — 꼴 유지 · `San_Basis_Index` 의 `trade` 를 가벼운 자리로(분석 C (나) 3) | 호표 목록 · 엑셀 칠 · [수정] 모달 · B09 내역서 불러오기 |
| **857-3a 문서 바로(첫 박자)** | ㉡ → 문서를 불러오기 자기 모듈로(변환기 · `master.logic` · `mf.parse` 안 부름) | 새 `M02_San_ToDoc.py`(+ 350) · `Doc_Import.derive`(− 120) | 3,241 × 두 판 지문 같음 · 줄 꼴 지문 같음 · `test_802_4b1` · `test_810_2` · `test_848_*` 불러오기 줄 | 붙임 · 다듬기 다섯 단계(`_attach` · `_numbers` · `Shape` · `Q` · `NativeLayout`)가 변환기 결과 꼴에 기댐 — 한 단계씩 옮기며 지문 확인 | [가져온 식으로 열기] · 줄 쌓기 |
| **857-3b SK 정본 = 문서(둘째 박자)** | `가져온.로직` 없앰 · 이음 고침 · 두 판 · 소요량 · 재료 고름 · 내 기계 · 초기화가 문서 연결을 고침 · 다시 열기 = 저장 문서 · `San_Basis_Index:160` 수식 문서로 · 옛 식 파서 부름 0 | `Sangeun_Imported`(− 250) · `Doc_Import`(− 200) · `Doc_Import_Reset` · `_Shape` · `Doc_NativeLayout` · `San_MatPick` · `San_MyMachine` · `Sangeun_QtyLinks`(± 150) · `San_Basis_Index`(± 40) · `Sangeun_FromHopyo`(± 40) · 화면 `Hopyo_Imported_Model.ts`(± 40) | 위 지문 · 저장 → 다시 열기 왕복 같음 · 이음 고침 · 초기화 시험(`test_793_2` · `797_2` · `827_3` · `848_3`) | 옛 SK 저장본 = 지금 시험 자료(요구 899 · 호환 안 만듦) — 저장본 비움(보충 3-2) 뒤 | 모달 [우리 단가로] · [엑셀 단가로] · [이음 고르기] · 소요량 · 초기화 |
| **857-4 재료 찾기 한 벌** | 호표 길 `_mats` → `San_MatFind.find`(단서 포함) 후보 · 이음 관문 = 판단 거리 1 의 답(권함 = 「엑셀 단가 같은 후보 하나」 만 이음) · [수정] 모달 판정 말 같게 | `Hopyo_Fixed`(± 50) · `Hopyo_View`(± 20) · TS `Hopyo_View` 판정 글(± 20) | 857-0 고정 줄 지문 — 권한 안이면 금액 다름 0 · 이음 · 판정 바뀜 = `out_mat.tsv` 꼴 표로 뜻한 바뀜만 | 다른 품목 12 꼴(단가로 고르던 지역 · 판) — 「값 같은 쌍둥이 먼저」 를 호표 길에 남김 | [수정] 모달 후보 · 안 이은 줄 띠 |
| **857-5 옛 길 지움** | 호표 쪽 시트 직접 읽기 · `_OPENED` · `Hopyo_Ledger` · 분석 C 「안 씀」 약 0.9 천 줄 · 소스 글자 시험 약 10 개 정리 · 옛 로직 줄 꼴 함수 | 위 파일들 · 시험 | 857-0 지문 · 관련 시험 전부 · `/openapi.json` 전후(뜻한 길만 빠짐) | — | 올림 · 두 목록 · 모달 한 바퀴 |
같이 돌릴 수 있는 묶음(파일 안 겹침):
| 묶음 | 걸음(창) | 겹침 확인 |
| --- | --- | --- |
| Ⓐ | 857-0(한 창) | 새 시험 파일만 |
| Ⓑ | 857-1 · 857-3a · 857-4(세 창) | 책 · Router · San_Book · Hopyo_Excel 열기 ↔ 새 `San_ToDoc` · `Doc_Import.derive` ↔ `Hopyo_Fixed` · `Hopyo_View` — 다름 |
| Ⓒ | 857-2 · 857-3b(두 창) | Hopyo 읽기 · Clause · Match · Units · pack ↔ Sangeun_Imported · Doc_Import · San_MatPick · QtyLinks · Basis_Index — `pack` 은 857-2 몫 · `San_Basis_Index` 는 857-3b 몫(`trade` 옮김도 그 창) |
| 끝 | 857-5(한 창) | — |
꼭 차례인 까닭:
- 857-0 먼저 — 「다름 0」 의 자.
- 857-2 는 857-1 뒤(둘 꼴이 한 번 읽은 책에서 와야 호표가 그 위에 얹힘) · **보충 L1 뒤**(이름표가 문서 머리에 있어야 Clause · Match · Units 가 옮겨 감).
- 857-3a 는 **본 설계 2-C2 · 2-C3 뒤**(옛 엔진 없이 열리고 검산되는 길 위에서 변환만 바꿈) · **2-E3 앞**(변환기 은퇴 전에 불러오기가 변환기를 안 부르게).
- 857-3b 는 857-3a 뒤 · **저장본 비움 뒤**(보충 3-2 · 옛 `가져온.로직` 꼴 저장본 0).
- 857-4 는 판단 거리 1 의 답 뒤 · 857-0 의 재료 이음 표가 기준.
- 857-5 는 맨 끝 · 2-E4(엔진 · 옛 파서 지움)는 857-3b 뒤에야 불러오기 몫이 0.
걸음 2 와 맞물림 — 시작할 수 있는 때:
| 857 걸음 | 시작 가능 |
| --- | --- |
| 857-0 · 857-1 · 857-4 | **지금 바로**(걸음 2 와 파일 안 겹침 · 857-1 은 `Sangeun_FromHopyo.keep` 만 만짐) — 단 857-4 는 판단 거리 1 답 뒤 |
| 857-3a | 2-C2 · 2-C3 끝 뒤(보충 묶음 ③ 뒤) |
| 857-2 | 857-1 · 보충 L1(묶음 ④) 뒤 |
| 857-3b | 857-3a · 저장본 비움(보충 묶음 ②) · 2-C5(`Hopyo_Build._inside` · `Sangeun_Imported._inner`) 뒤 |
| 857-5 | 857 전부 · 856(화면 하나) 뒤(`Hopyo_*.ts` 화면 겹침) |
---
## 7. 사용자 판단 거리 · 못 본 것
### 7-1 판단 거리(쉬운 말)
1. **일위대가(호표) 불러오기의 재료 이음을 단가산출 불러오기와 맞출 때 「엑셀 숫자 그대로」 를 지킬지** — ㉠ 찾는 법만 맞추고 「엑셀 단가와 같은 품목」 일 때만 이음(금액 그대로 · 나머지는 후보로 보여 사람이 고름 · 권함) ㉡ 다 이음(9 파일에서 118 줄 이음이 바뀌고 109 줄 금액이 우리 단가로 바뀜) ㉢ 일위대가 고정 줄에도 「엑셀 값 · 우리 값」 두 판을 둠(일이 큼).
2. **단가산출 불러오기도 단가를 볼지** — 지금은 이름 · 규격 · 단위로만 골라 지역 · 판이 다른 품목(북부청임도 돌망태 12 줄)을 고를 때가 있음. 「같은 이름 · 규격 쌍둥이 중 엑셀 단가와 같은 품목 먼저」 를 더할지.
3. **일위대가 시트가 없는 엑셀(2016 사방 · 2026 수목 꼴)** — 지금은 화면 올림이 「일위대가 시트 없음」 으로 막힘. 한 번 읽기로 단가산출만 있는 파일도 올라가게 할지(권함 · 단가산출 목록만 보임).
4. 「고를 재료」 판 — M01 · 별칭을 고친 뒤 판이 자동으로 다시 셈되게 할지(권함 · 몇 초 걸림).
### 7-2 못 본 것
- 원파일(EST 6 · STC 7 · 2,220 블록)은 견본 자리만 확인 · 세기는 엑셀 11 만(원파일은 호표 계보가 없어 1 · 2 절 대상 아님 · 3 절 지킴은 857-0 에서 같이 돎).
- 재료 이음 세기는 일위대가 시트 호표 줄만 — 호표가 부르는 단산(SK 참조) 안 줄은 이미 단가산출 길이라 뺌 · 붙여넣기 · B09 내역서(`Linker(by_name=False)`) 길은 안 셈(관문이 더 좁음 · 같은 결론으로 봄).
- 「금액 달라짐」 은 품목 단가 대 엑셀 재료비 단가만 맞댐 · SC 합계 · 내역서 금액 영향은 안 셈(건수만).
- 판 첫 셈 「M01 한 벌 쥐기」 의 기대 시간은 프로파일에서 확인 부분을 뺀 어림(실측 아님) · 서버 · 화면은 안 돌림(파이썬 직접 · 저장 없음).
- 호표 쪽 항목 계산(`ReadEst.items` · `Formula`)을 둘 꼴 줄 입력으로 바꿀 때 같은 결과가 나오는지는 857-2 에서 HP 지문으로 확인할 일(여기서는 칸 전수 · 만드는 곳 · 읽는 곳까지).
- `Labor_Ref.Expand` 안의 로직 줄 읽기는 이름만 확인(유력).
### 세기 결과(`tmp/s894/m857/`)
| 도구 | 결과 | 무엇 |
| --- | --- | --- |
| `m857_read.py` | `out_read.json` | 책 열기 횟수 · 시간 · 두 계보 블록 대조 · 호표 쪽 단산 칸 |
| `m857_mat.py` | `out_mat.json` · `out_mat.tsv`(바뀌는 118 줄) | 재료 이음 두 규칙 대조 |
| `m857_l2.py` | `out_l2.tsv`(85 곳 · 19 파일) | 「로직」 낱말 · 로직 줄 읽기 자리 |
| `m857_census.py` · `_split.py` · `m857_prof.py` | `out_census.json` · `out_census_split.json` | 판 첫 셈 시간 · 이음 몫 · 프로파일 |
@@ -0,0 +1,54 @@
{
"갈래": {
"precombo.고치기": "600ec92b1b7fabe4",
"precombo.나무": "d08cff9db9575c99",
"precombo.되돌림": "ce11ade1bd96129c",
"precombo.만들기": "e53ad45acbf386bc",
"precombo.목록": "20bd9f3f0803cb91",
"precombo.복사": "ea957146cf361b70",
"precombo.붙여넣기": "236bf55301ef9045",
"precombo.쓰는곳": "8f68c3d2501f7a53",
"precombo.읽기": "c822ceb7cedfc59d",
"precombo.중복": "6f783eab99eb8095",
"precombo.지우기": "a356d2496ae34f51",
"precombo.합치기": "2010fbd1ab774d86",
"sangeun.고치기": "e47e5593c71f5a56",
"sangeun.나무": "991823a8c1fe1913",
"sangeun.되돌림": "6ca25af01d1d38ab",
"sangeun.만들기": "2155d280fd6d97ae",
"sangeun.목록": "a75cf0387e16ed84",
"sangeun.복사": "40edbd4d0644186f",
"sangeun.붙여넣기": "57cfb7bb522a80d3",
"sangeun.쓰는곳": "2c9ec1824709481f",
"sangeun.읽기": "6f5b02af37f2b55b",
"sangeun.중복": "e4d3ff3235a8d0b9",
"sangeun.지우기": "db8b1e8ad9bef9eb",
"sangeun.합치기": "5a6d9e24d05ae1af",
"공유.거절": "9a38b16329ed7c68",
"공유.목록": "eccff54e8114d69c",
"공유.봄": "a3bdb64cc1be2935",
"공유.승인": "ec5183ff8c81f5c8",
"공유.요청": "762ba10d5af57643",
"권한.같은회사남": "2d3d50a90583497d",
"권한.남의회사관리": "a1213c908c70528f",
"권한.시스템": "ee1c88a183b2740f",
"권한.일반": "9a05899de41301f2",
"권한.회사관리": "d6da88af7fe80323",
"내기계.고치기": "3f00365dbfb77cee",
"내기계.만들기": "20f5562f02c276f8",
"내기계.목록": "064102da4c9740d6",
"내기계.쓰는곳": "7bd823f7780c6f86",
"내기계.읽기": "0e5467fc806d83ff",
"내기계.지우기": "6db3b2b387f87ce7",
"내기계.찾기": "feca2de012a206ee",
"내재료.고치기": "60c0d3337d7dde06",
"내재료.만들기": "9fec4ce2a9bbfb82",
"내재료.목록": "9c5929426719e9ae",
"내재료.지우기": "9c194d1b5367920e",
"항목.나무": "abb5815352e81102",
"항목.목록": "f7ff1a6372bf308f",
"항목.복사": "b37ed4bfc45e5032",
"항목.붙여넣기": "2324914f36f4b24e",
"항목.지우기": "1fd673b8f7e3bab1"
}
}
File diff suppressed because it is too large Load Diff
+301
View File
@@ -0,0 +1,301 @@
"""857-0 지킴 도우미 — 불러오기 지문(블록 × 두 판 · 검산 · 이음 / 엑셀 올림 · 호표 목록 · 칠 ·
고정 줄 / 재료 이음 표).
- 블록 = 견본(원파일 EST · STC · 실무 엑셀)마다 `Doc_FromNative.emit` → 가져온 식 SK(저장 없음) →
엑셀 판 · 우리 판 문서 셈(`Doc_Import.derive` + `run`) 노 · 재 · 경 · 계 +
검산(`Sangeun_Imported.check` 같음 · 줄 같음 수) + 줄마다 이음(종류 · 이음 · 기계 찾기 ·
재료 찾기 판정 · 키).
- 올림 = 엑셀을 임시 개인 층에 올림(`Hopyo_Router._upload`) → 거절 글 | 목록(`Hopyo_View.listing`) ·
칠(`Hopyo_Marks.blocks`) · 고정 줄(`Hopyo_Fixed.line_of` 이름 · 규격 · 단위 · 단가 · 이음 · 비율).
- 재료 이음 표 = 일위대가 호표 자재 · 별도계상 줄 — 호표 길 키(`line_of`) ·
단가산출 길 키(`San_Link.m01`).
- 지문 = 갈래 열쇠(「블록 EST:거창#3」 등)마다 sha256 앞 16 자 · 견본 내용은 안 남김.
- M01 한 벌 쥠(셈 동안 M01 파일이 안 바뀜 — 빠르게만 · 답 같음).
"""
from __future__ import annotations
import contextlib
import hashlib
import json
import sys
import tempfile
import warnings
from pathlib import Path
from typing import Any
HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[1]
for p in (str(ROOT), str(HERE)):
if p not in sys.path:
sys.path.insert(0, p)
warnings.filterwarnings("ignore", category=UserWarning, module="openpyxl")
KEYS = ("노무비", "재료비", "경비", "계")
#: 기본(빠른) 표본 — 견본마다 블록 몇 개 · 올림 파일 몇 개(전수 = `S857_ALL=1`)
QUICK_BLOCKS = {
"EST:거창": 8,
"STC:봉화": 8,
"엑셀:북부청임도": 8,
"엑셀:봉화": 8,
"엑셀:2026수목": 8,
}
QUICK_UPLOAD = ("북부청임도", "봉화", "2026수목")
def sources() -> dict[str, Path]:
"""「갈래:이름」 → 견본 경로(없는 PC = 경로가 없음)."""
import test_797_1a_import_flags as practice
from test_810_1_estx import FILES as EST
from test_810_1_stc import FILES as STC
out = {f"EST:{k}": v for k, v in EST.items()}
out |= {f"STC:{k}": v for k, v in STC.items()}
return out | {f"엑셀:{k}": v for k, v in practice.FILES.items()}
def digest(value: Any) -> str:
raw = json.dumps(value, ensure_ascii=False, sort_keys=True, default=str)
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
@contextlib.contextmanager
def hold_m01():
"""M01 한 벌을 셈 동안 쥠(줄마다 파일 날짜 다시 재기 뺌)."""
from M01_MasterData import M01_MasterData_Store as m01
real, memo = m01.loaded, []
def once():
if not memo:
memo.append(real())
return memo[0]
m01.loaded = once
try:
yield
finally:
m01.loaded = real
@contextlib.contextmanager
def personal():
"""임시 storage 개인 층(원본 storage · 마스터 안 씀)."""
from config import config_system
old = config_system.STORAGE_BASE_DIR
tmp = Path(tempfile.mkdtemp(prefix="t857_"))
config_system.STORAGE_BASE_DIR = str(tmp / "storage")
(tmp / "storage").mkdir()
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
folder = layers.personal_dir(7, 42)
folder.mkdir(parents=True, exist_ok=True)
try:
with store.at(folder):
yield folder
finally:
config_system.STORAGE_BASE_DIR = old
# ── 블록 ──────────────────────────────────────────────────────────────
def saved_of(tag: str, path: Path) -> dict:
from M02_MasterTemplete import M02_Doc_FromNative as fn
from M02_MasterTemplete import M02_San_Xlsx as sx
raw = path.read_bytes()
if tag.startswith("엑셀:"):
return fn.pack(sx.read(path.name, raw), path.name)
return fn.read(path.name, raw)
def _money(got: dict) -> Any:
return {k: str(got.get(k)) for k in KEYS} if got.get("셈됨") else "못 셈"
def _links(row: dict) -> list:
out = []
for it in row.get("호표") or []:
res = it.get("자원") or {}
find, mat = res.get("찾기") or {}, res.get("재료찾기") or {}
out.append(
[
it.get("종류"),
it.get("이음"),
find.get("판정"),
find.get("키"),
mat.get("판정"),
mat.get("키"),
]
)
return out
def block(saved: dict, no: int) -> dict:
"""블록 하나 → 지문 몸 {엑셀, 우리, 검산, 이음}."""
from M02_MasterTemplete import M02_Doc_FromNative as fn
from M02_MasterTemplete import M02_Doc_Import as dim
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sangeun_Imported as imp
whole = imp._whole()
out = fn.emit(saved, no)
row = out["로직"]
sk = {
"키": "SK-999999",
"이름": row["이름"],
"단위": str(row.get("결과단위", "/")).split("/", 1)[-1],
}
sk |= {"바탕": None, "입력값": {}, "덮개": {}, "뺀줄": [], "더한줄": []}
sk[imp.KEY] = {"로직": row, "원본": out["원본"], "단가기준": "엑셀"}
sk = sd.clean(sk, None, whole)
got: dict[str, Any] = {"이음": _links(row)}
for basis in ("엑셀", "우리"):
one = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": basis}}
try:
got[basis] = _money(dim.run(dim.derive(one, None, whole), one, whole))
except Exception as e: # noqa: BLE001 — 예외도 지문
got[basis] = f"예외 {type(e).__name__}"
try:
c = imp.check(sk, whole)
got["검산"] = [c["같음"], sum(1 for x in c["줄"] if x.get("같음")), len(c["줄"])]
except Exception as e: # noqa: BLE001
got["검산"] = f"예외 {type(e).__name__}"
return got
def blocks(full: bool) -> tuple[dict[str, str], int]:
"""{「블록 갈래:이름#번」: 지문} · 건너뛴 견본 수."""
from M02_MasterTemplete import M02_Doc_FromNative as fn
out, skipped = {}, 0
with hold_m01(), personal():
for tag, path in sources().items():
if not full and tag not in QUICK_BLOCKS:
continue
if not path or not path.exists():
skipped += 1
continue
saved = saved_of(tag, path)
nos = sorted(fn.numbers(saved))
if not full:
step = max(1, len(nos) // QUICK_BLOCKS[tag])
nos = nos[::step][: QUICK_BLOCKS[tag]]
for no in nos:
out[f"블록 {tag}#{no}"] = digest(block(saved, no))
return out, skipped
# ── 엑셀 올림 · 호표 쪽 ─────────────────────────────────────────────────
def _fixed(book: dict) -> list:
from M02_MasterTemplete import M02_Hopyo_Fixed as hf
linker, out = hf.Linker(True), []
for h in book.get("호표") or []:
for ln in h.get("줄") or []:
fx = hf.line_of(ln, h["줄"], {}, set(), linker)["고정"]
out.append(
[
h["번"],
ln.get("차례"),
{k: fx.get(k) for k in ("이름", "규격", "단위", "단가", "이음", "비율")},
]
)
return out
def mats(book: dict, clues: list) -> list:
"""재료 이음 표 [호표, 차례, 갈래, 호표 길 키, 단가산출 길 키, 산근 판정 · 방법]."""
from M02_MasterTemplete import M02_Hopyo_Fixed as hf
from M02_MasterTemplete import M02_Hopyo_Match as hm
from M02_MasterTemplete import M02_San_Link as sl
from M02_MasterTemplete import M02_San_MatFind as smf
linker, out = hf.Linker(True), []
for h in book.get("호표") or []:
for ln in h.get("줄") or []:
if hf.kind_of(ln) not in hm.MATERIAL_KINDS:
continue
a = (hf.line_of(ln, h["줄"], {}, set(), linker)["고정"]["이음"] or {}).get("자재")
src = {k: ln.get(k) or "" for k in ("이름", "규격", "단위")}
src |= {"종류": "자재", "코드": ln.get("코드") or ""}
with smf.clues_on(clues):
b, _ = sl.m01("재료", src, "")
found = src.get("재료찾기") or {}
out.append(
[
h["번"],
ln.get("차례"),
ln.get("갈래"),
a,
b,
found.get("판정"),
found.get("방법"),
]
)
return out
def upload(tag: str, path: Path) -> dict[str, Any]:
"""엑셀 하나 올림(임시 층) → {올림, 목록, 칠, 고정, 재료} 지문 몸."""
from M02_MasterTemplete import M02_Doc_FromNative as fn
from M02_MasterTemplete import M02_Hopyo_Marks as marks
from M02_MasterTemplete import M02_Hopyo_Router as router
from M02_MasterTemplete import M02_Hopyo_Store as hstore
from M02_MasterTemplete import M02_Hopyo_View as view
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_San_Book as sb
from M02_MasterTemplete import M02_San_Xlsx as sx
data = path.read_bytes()
try:
row = router._upload(path.name, data, {"id": 42, "이름": "시험"})
except store.StoreError as e:
return {"올림": f"거절 {e.status} {e}"}
folder, key = store.root(), row["키"]
book = hstore.read(folder, key)
listing = view.listing(folder, key, folder)
sheets = sb.sheets(path.name, data)
clues = (fn.pack(sx.read_sheets(sheets), path.name) if sb.kind_of(sheets) else {}).get("단서")
return {
"올림": {k: row.get(k) for k in ("시트", "호표수", "읽기불가")},
"목록": {k: listing.get(k) for k in ("호표", "단산", "검산")},
"칠": marks.blocks(folder, key),
"고정": _fixed(book),
"재료": mats(book, clues or []),
}
def uploads(full: bool) -> tuple[dict[str, str], dict[str, list], int]:
"""({「올림 이름 갈래」: 지문}, {이름: 재료 이음 표}, 건너뛴 수)."""
out, table, skipped = {}, {}, 0
with hold_m01(), personal():
for tag, path in sources().items():
name = tag.split(":", 1)[1]
if not tag.startswith("엑셀:") or (not full and name not in QUICK_UPLOAD):
continue
if not path or not path.exists():
skipped += 1
continue
got = upload(tag, path)
for part, body in got.items():
out[f"올림 {name} {part}"] = digest(body)
table[name] = got.get("재료") or []
return out, table, skipped
def mat_counts(table: dict[str, list]) -> dict[str, dict[str, int]]:
"""재료 이음 전후 표(`m857_mat` 꼴) — 같음(이음) · 같음(못 이음) · 생김 · 풂 · 다른 품목."""
out = {}
for name, rows in table.items():
c: dict[str, int] = {}
for r in rows:
a, b = r[3], r[4]
if a == b:
k = "같음(이음)" if a else "같음(못 이음)"
else:
k = "풀림" if a and not b else "생김" if b and not a else "다른 품목"
c[k] = c.get(k, 0) + 1
out[name] = c
return out
@@ -0,0 +1,70 @@
"""857-0 지킴 — 불러오기 지문(걸음 4 동안 「다름 0」 자 · 도우미 `helper_857_import`).
- 블록 = 원파일 EST · STC · 실무 엑셀 블록마다 엑셀 판 · 우리 판 문서 셈(노 · 재 · 경 · 계) ·
검산 판정 · 줄 이음 판정.
- 올림 = 실무 엑셀을 임시 개인 층에 올림 → 거절 | 호표 목록 · 칠 · 고정 줄 · 재료 이음 표.
- 재료 이음 전후 표 = 호표 길 키 대 단가산출 길 키 갈래 수(857-4 의 기준).
- 기본 = 빠른 표본(`QUICK_*`) · 전수 = 환경 `S857_ALL=1` · 견본 없는 PC = 그 갈래 건너뜀(수를 글로).
- 다르면 실패 + 갈래 이름 — 뜻대로 바꾼 걸음만 다시 뜸(바뀐 갈래를 커밋 글에):
`S857_ALL=1 ./venv/Scripts/python.exe resources/tester/test_857_import_golden.py --write`
"""
from __future__ import annotations
import json
import os
import sys
import warnings
from pathlib import Path
import pytest
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
import helper_857_import as h # noqa: E402
FILE = HERE / "golden_857_import.json"
REDO = "S857_ALL=1 ./venv/Scripts/python.exe resources/tester/test_857_import_golden.py --write"
ALL = os.environ.get("S857_ALL") == "1"
def _want() -> dict:
return json.loads(FILE.read_text("utf-8"))
def _compare(got: dict[str, str], want: dict[str, str], skipped: int) -> None:
if not got:
pytest.skip(f"견본 없음 — 건너뜀 {skipped}")
missing = sorted(k for k in got if k not in want)
changed = sorted(k for k in got if k in want and want[k] != got[k])
gone = sorted(k for k in want if k not in got) if ALL and not skipped else []
assert not (missing or changed or gone), (
f"지문 다름 — 바뀜 {len(changed)} {changed[:15]} · 새 {missing[:10]} · 빠짐 {gone[:10]}"
f" · 건너뜀 {skipped}\n뜻대로 바꾼 걸음이면 다시 뜸: {REDO}"
)
if skipped:
warnings.warn(f"견본 없어 건너뜀 {skipped}", stacklevel=2)
def test_블록_두_판_검산_이음_지문_같음():
got, skipped = h.blocks(ALL)
_compare(got, _want()["블록"], skipped)
def test_엑셀_올림_호표_목록_칠_고정_재료_지문_같음():
got, table, skipped = h.uploads(ALL)
_compare(got, _want()["올림"], skipped)
want = _want()["재료표"]
assert {k: v for k, v in h.mat_counts(table).items()} == {k: want[k] for k in table}
if __name__ == "__main__":
if "--write" not in sys.argv or not ALL:
sys.exit(f"다시 뜨기 = {REDO}")
blocks, skip_b = h.blocks(True)
ups, table, skip_u = h.uploads(True)
body = {"판": 1, "블록": blocks, "올림": ups, "재료표": h.mat_counts(table)}
FILE.write_text(
json.dumps(body, ensure_ascii=False, indent=1, sort_keys=True) + "\n", "utf-8", newline="\n"
)
print(f"블록 {len(blocks)} · 올림 {len(ups)} · 건너뜀 {skip_b + skip_u} → {FILE.name}")
+469
View File
@@ -0,0 +1,469 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""858 5-0 층 서고 지킴 — 서버 길 답 지문 · 동시 쓰기(임시 storage · 제품 코드 안 고침).
① 지문 — 견본 층(단가산출 · 일위대가 · 구조물 조합 항목 · 내 기계 · 내 재료 · 공유 요청)에서
목록 · 나무 · 만들기 · 고치기 · 지우기 · 복사 · 붙여넣기 · 합치기 · 되돌림 · 쓰는 곳 · 권한 길을
차례로 불러 답(상태 + 몸)을 갈래마다 지문으로 → `fixtures/m02_858_shelf_golden.json` 과 같음.
다르면 갈래 이름 + 지금 답 + 다시 뜨는 법으로 실패(건너뛰지 않음). 다시 뜸 =
`SHELF_858_WRITE=1 ./venv/Scripts/python.exe -m pytest resources/tester/test_858_shelf_golden.py`
(뜻한 바뀜일 때만 · 커밋 글에 까닭). 답 통째 전후 대조 = `SHELF_858_DUMP=tmp/<파일>.json`.
② 동시 쓰기 — 잠금 없는 나무 고침 · 나무 지우기 · 합치기를 같은 판으로 겹쳐 부름. 지금 사실을
그대로 단언(나무 = 둘 다 됨 · 뒤 것이 이김 · 지우기 + 합치기 = 앞 것이 이기고 뒤 것은 터짐) —
「5-4 에서 뒤집을 단언」 표시 줄은 5-4 가 바꿈.
"""
from __future__ import annotations
import hashlib
import json
import os
import threading
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from typing import Any
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from common_util.common_util_auth import verify_session
from M02_MasterTemplete import M02_Labor_Router as labor_router
from M02_MasterTemplete import M02_Library_Same_Router as same_router
from M02_MasterTemplete import M02_MasterTemplete_Router_Items as items_router
from M02_MasterTemplete import M02_MasterTemplete_Router_Layers as layers_router
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MyMachine_Look as look_router
from M02_MasterTemplete import M02_MyMachine_Router as machine_router
from M02_MasterTemplete import M02_Precombo_Folders as pre_folders
from M02_MasterTemplete import M02_Share_Request as share
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
GOLD = Path(__file__).resolve().parent / "fixtures" / "m02_858_shelf_golden.json"
WRITE = "SHELF_858_WRITE"
USER = {"user_id": 42, "company_id": 7, "role": "USER", "is_master": False, "name": "갑"}
NEIGHBOR = {**USER, "user_id": 43, "name": "을"} # 같은 회사 남
ADMIN = {**USER, "user_id": 50, "role": "ADMIN", "name": "관리"} # 회사 7 관리자
SYSADMIN = {**USER, "user_id": 1, "role": "SYSTEM_ADMIN", "name": "시스템"}
STRANGER = {"user_id": 90, "company_id": 9, "role": "ADMIN", "is_master": False, "name": "남"}
MEMBERS = {42: 7, 43: 7, 44: 7, 50: 7, 1: 7, 90: 9}
P = "/api/m02/layers/personal"
MASK = {"날짜", "때", "처리날짜", "수정일", "넣은날", "고친날"} # 실행마다 다른 시각
PREFIX = {"sangeun": "SK", "precombo": "SC"}
@pytest.fixture()
def shelf(world, monkeypatch, tmp_path):
async def member(owner: str) -> bool:
company, _, user = owner.partition("/")
return MEMBERS.get(int(user)) == int(company) if user else int(company) in (7, 9)
async def note(session: dict[str, Any], got: Any) -> None:
return None
monkeypatch.setattr(items_router, "_member", member)
monkeypatch.setattr(items_router, "_note", note)
app = FastAPI()
for one in (
layers_router,
items_router,
labor_router,
same_router,
machine_router,
look_router,
share,
):
app.include_router(one.router)
session = dict(USER)
app.dependency_overrides[verify_session] = lambda: session
return Shelf(TestClient(app), session, str(tmp_path))
class Shelf:
"""길을 부르고 답을 갈래마다 모음 — 갈래 = 「종류.일」."""
def __init__(self, client: TestClient, session: dict[str, Any], tmp: str):
self.client, self.session, self.tmp = client, session, tmp
self.got: dict[str, list[Any]] = {}
self.seq: dict[str, dict[str, str]] = {} # 갈래마다 값 → 차례 표
self.home: dict[str, str] = {} # 값 → 처음 본 갈래 표(길 글자용)
def who(self, person: dict[str, Any]) -> None:
self.session.clear()
self.session.update(person)
def go(self, branch: str, method: str, url: str, body: Any = None) -> Any:
res = self.client.request(method, url, json=body)
try:
out = res.json()
except ValueError:
out = res.text
who = self.session.get("user_id")
local = self.seq.setdefault(branch, {})
for raw, mark in self.home.items(): # 길 글자 속 uuid · 판도 같은 표로
url = url.replace(raw, local.get(raw) or mark)
row = [who, method, url, res.status_code, self.clean(out, branch)]
self.got.setdefault(branch, []).append(row)
return out
def clean(self, value: Any, branch: str) -> Any:
"""실행마다 다른 것만 가림 — 임시 폴더 · 시각 · uuid 와 판(갈래 안 처음 본 차례 번호 — 같은
값은 같은 번호라 「409 판 = 앞서 받은 판」 같은 이음은 그대로 잼 · 한 갈래가 바뀌어도 다른
갈래 번호는 안 밀림)."""
local = self.seq.setdefault(branch, {})
if isinstance(value, dict):
out = {}
for k, v in value.items():
if (k == "id" or k.endswith("판")) and isinstance(v, str) and v:
out[k] = local.setdefault(v, f"<{k}{len(local) + 1}>")
self.home.setdefault(v, f"<{branch}{out[k][1:]}")
elif k in MASK and v is not None:
out[k] = "<가림>"
else:
out[k] = self.clean(v, branch)
return out
if isinstance(value, list):
return [self.clean(v, branch) for v in value]
if isinstance(value, str):
return value.replace(self.tmp, "<tmp>").replace(self.tmp.replace("\\", "/"), "<tmp>")
return value
def _finger(answers: list[Any]) -> str:
text = json.dumps(answers, ensure_ascii=False, sort_keys=True, default=str)
return hashlib.sha256(text.encode()).hexdigest()[:16]
# ── 견본 ──────────────────────────────────────────────────────────────
def _fixed(price: int, kind: str) -> dict[str, Any]:
line = {"고정": {"이름": "운반", "단위": "식", "단가": {"경비": price}}}
return {**line, "수량": 1 if kind == "sangeun" else {"손": 1}}
def _doc(kind: str, name: str, price: int) -> dict[str, Any]:
field = "더한줄" if kind == "sangeun" else "담은로직"
return {"이름": f"sub4임시{name}", "단위": "m", field: [_fixed(price, kind)]}
def _library(s: Shelf, world: dict[str, Any], kind: str) -> None:
b = f"{kind}."
lib, tree = f"{P}/library/{kind}", f"{P}/{kind}-tree"
one = s.go(b + "만들기", "POST", lib, {"문서": _doc(kind, "가", 1000)})["이름"]
two = s.go(b + "만들기", "POST", lib, {"문서": _doc(kind, "나", 2000)})["이름"]
s.go(b + "만들기", "POST", lib, {"문서": _doc(kind, "가", 1000)}) # 같은 내용
twin = s.go(b + "만들기", "POST", lib, {"문서": _doc(kind, "가", 1000), "새로": True})["이름"]
s.go(b + "복사", "POST", lib, {"본뜬": {"층": "personal", "주인": "7/42", "키": two}})
s.go(
b + "복사",
"POST",
lib,
{"본뜬": {"층": "personal", "주인": "7/42", "키": f"{PREFIX[kind]}-999999"}},
)
spare = s.go(b + "만들기", "POST", lib, {"문서": _doc(kind, "다", 3000), "새로": True})["이름"]
s.go(b + "목록", "GET", f"{P}/templates")
read = s.go(b + "읽기", "GET", f"{P}/templates/{kind}/{one}")
s.go(b + "읽기", "GET", f"{P}/templates/{kind}/{PREFIX[kind]}-999999")
edited = {**read["문서"], "이름": "sub4임시가고침"}
s.go(b + "고치기", "PUT", f"{P}/templates/{kind}/{one}", {"문서": edited, "판": read["판"]})
s.go(b + "고치기", "PUT", f"{P}/templates/{kind}/{one}", {"문서": edited, "판": read["판"]})
판 = s.go(b + "나무", "GET", tree)["판"]
for body in (
{"op": "add-folder", "경로": [], "이름": "옹벽"},
{"op": "add-folder", "경로": [], "이름": "옹벽"}, # 이미 있음
{"op": "move", "키": one, "새경로": ["옹벽"]},
{"op": "rename", "경로": ["옹벽"], "이름": "석축"},
):
got = s.go(b + "나무", "POST", tree, {**body, "판": 판})
판 = got.get("판", 판)
s.go(b + "나무", "POST", tree, {"op": "add-folder", "경로": [], "이름": "x", "판": "옛판"})
paste = {"from_layer": "personal", "대상": [{"경로": ["석축"]}], "경로": []}
s.go(b + "붙여넣기", "POST", f"{tree}/paste", paste)
s.go(b + "붙여넣기", "POST", f"{tree}/paste", {**paste, "대상": [{"경로": ["없음"]}]})
with store.at(world["personal"]): # 쓰는 곳 = 구조물 조합 열(740-1)
ref = {"참조": {"층": "personal", "주인": "7/42", "키": two}, "수량": {"손": 2}}
store.write("labor", f"u{kind}", "", {"열": f"u{kind}", "담은로직": [ref], "자재": []})
s.go(b + "쓰는곳", "POST", f"{tree}/delete-check", {"대상": [{"키": two}]})
s.go(b + "쓰는곳", "POST", f"{tree}/delete-check", {"대상": [{"경로": ["석축"]}]})
판 = s.go(b + "나무", "GET", tree)["판"]
s.go(b + "지우기", "POST", tree, {"op": "delete", "대상": [{"키": two}], "판": 판})
gone = s.go(
b + "지우기", "POST", tree, {"op": "delete", "대상": [{"키": two}], "판": 판, "확인": True}
)
s.go(b + "지우기", "GET", f"{P}/templates/{kind}/{two}")
s.go(b + "지우기", "GET", f"{P}/templates/labor/u{kind}")
spare_판 = s.go(b + "읽기", "GET", f"{P}/templates/{kind}/{spare}")["판"]
s.go(b + "지우기", "DELETE", f"{P}/templates/{kind}/{spare}") # 판 없음
s.go(b + "지우기", "DELETE", f"{P}/templates/{kind}/{spare}?판={spare_판}")
s.go(b + "지우기", "DELETE", f"{P}/templates/{kind}/{spare}?판={spare_판}")
record = (gone.get("알림") or {}).get("기록")
s.go(b + "되돌림", "POST", f"{P}/{kind}-same/undo", {"키": record or "없음"})
s.go(b + "되돌림", "GET", f"{P}/templates/labor/u{kind}")
s.go(b + "되돌림", "POST", f"{P}/{kind}-same/undo", {"키": "없음"})
found = s.go(b + "중복", "GET", f"{P}/{kind}-same")
keep = {"층": "personal", "주인": "7/42", "키": twin}
merge = {"남김": keep, "지움": [one], "판": found["판"]}
s.go(b + "합치기", "POST", f"{P}/{kind}-same/merge", {**merge, "판": "옛판"})
s.go(b + "합치기", "POST", f"{P}/{kind}-same/merge", merge)
s.go(b + "되돌림", "POST", f"{P}/{kind}-same/undo", {"키": one})
s.go(b + "목록", "GET", f"{P}/templates")
s.go(b + "나무", "GET", tree)
def _items(s: Shelf) -> None:
tree = f"{P}/tree"
판 = s.go("항목.나무", "GET", tree)["판"]
for body in (
{"op": "add-folder", "경로": [], "이름": "배수"},
{"op": "add-item", "경로": ["배수"], "이름": "sub4임시측구", "단위": "m"},
{"op": "add-item", "경로": [], "이름": "sub4임시옹벽", "단위": "m"},
{"op": "rename", "경로": ["배수"], "이름": "수로"},
{"op": "move", "경로": ["sub4임시옹벽"], "새경로": ["수로"]},
{"op": "add-folder", "경로": [], "이름": "수로"}, # 이미 있음
):
got = s.go("항목.나무", "POST", tree, {**body, "판": 판})
판 = got.get("판", 판)
s.go("항목.나무", "POST", tree, {"op": "add-folder", "경로": [], "이름": "x", "판": "옛판"})
s.go("항목.목록", "GET", "/api/m02/items?layer=personal")
s.go("항목.목록", "GET", "/api/m02/items")
paste = {"from_layer": "personal", "대상": [{"경로": ["수로"]}], "경로": []}
s.go("항목.붙여넣기", "POST", f"{P}/items/paste", paste)
system = s.go("항목.목록", "GET", "/api/m02/items")
key = system[0]["key"] if system else "없음"
s.go("항목.복사", "POST", f"{P}/items/copy", {"from_layer": "system", "key": key})
s.go("항목.복사", "POST", f"{P}/items/copy", {"from_layer": "system", "key": "SS-999999"})
판 = s.go("항목.나무", "GET", tree)["판"]
s.go("항목.지우기", "POST", tree, {"op": "delete", "경로": ["수로(1)"], "판": 판})
s.go("항목.나무", "GET", tree)
def _machines(s: Shelf) -> None:
m = f"{P}/my-machines"
easy = {"이름": "sub4임시기계", "규격": "1㎾", "방식": "바로"}
easy["값"] = {"가격": 1000, "손료계수": 2000, "주연료": 0, "주연료종류": "경유"}
made = s.go("내기계.만들기", "POST", m, {"줄": easy})
key = made.get("줄", {}).get("키", "없음")
s.go("내기계.목록", "GET", m)
one = s.go("내기계.읽기", "GET", f"{m}/{key}")
fixed = {**easy, "값": {**easy["값"], "가격": 3000}}
s.go("내기계.고치기", "PUT", f"{m}/{key}", {"줄": fixed, "판": one.get("판")})
s.go("내기계.고치기", "PUT", f"{m}/{key}", {"줄": fixed, "판": one.get("판")}) # 옛 판
s.go("내기계.쓰는곳", "POST", f"{m}/{key}/impact", {"줄": fixed})
s.go("내기계.찾기", "GET", f"{P}/my-machine-find?q=sub4")
s.go("내기계.목록", "GET", "/api/m02/layers/company/my-machines")
s.go("내기계.지우기", "DELETE", f"{m}/{key}")
s.go("내기계.지우기", "GET", f"{m}/{key}")
def _materials(s: Shelf) -> None:
m = f"{P}/materials"
bolt = {"이름": "sub4임시볼트", "규격": "M16", "단위": "EA", "값": 1200}
key = s.go("내재료.만들기", "POST", m, bolt).get("키", "없음")
s.go("내재료.만들기", "POST", m, {**bolt, "규격": "M20"})
s.go("내재료.만들기", "POST", "/api/m02/layers/company/materials", bolt)
s.go("내재료.목록", "GET", m)
s.go("내재료.목록", "GET", "/api/m02/layers/company/materials")
s.go("내재료.고치기", "PUT", f"{m}/{key}", {**bolt, "값": 1500})
s.go("내재료.지우기", "DELETE", f"{m}/{key}")
s.go("내재료.지우기", "DELETE", f"{m}/{key}")
s.go("내재료.목록", "GET", m)
def _share(s: Shelf) -> None:
url = "/api/m02/share-requests"
item = s.go("공유.요청", "GET", "/api/m02/items?layer=personal")[0]["key"]
pre = s.go("공유.요청", "POST", f"{P}/library/precombo", {"문서": _doc("precombo", "공유", 7)})
one = s.go("공유.요청", "POST", url, {"종류": "item", "키": item, "글": " 회사 공용 "})
s.go("공유.요청", "POST", url, {"종류": "item", "키": item}) # 요청 중
two = s.go("공유.요청", "POST", url, {"종류": "precombo", "키": pre["이름"]})
s.go("공유.요청", "POST", url, {"종류": "precombo", "키": "SC-999999"})
s.go("공유.목록", "GET", url)
s.go("공유.승인", "POST", f"{url}/{one['id']}/approve", {"경로": []}) # 일반 = 403
s.who(STRANGER)
s.go("공유.목록", "GET", url)
s.go("공유.승인", "POST", f"{url}/{one['id']}/approve", {"경로": []})
s.who(ADMIN)
s.go("공유.목록", "GET", url)
s.go("공유.승인", "POST", f"{url}/{one['id']}/approve", {"경로": []})
s.go("공유.승인", "POST", f"{url}/{one['id']}/approve", {"경로": []}) # 이미 끝남
s.go("공유.거절", "POST", f"{url}/{two['id']}/reject", {"사유": " 겹침 "})
s.go("공유.목록", "GET", "/api/m02/items?layer=company")
s.who(USER)
s.go("공유.목록", "GET", url)
s.go("공유.봄", "POST", f"{url}/seen")
s.go("공유.봄", "POST", f"{url}/seen")
READS = { # 남의 층 읽기 길(주인 붙임)
"목록": "/api/m02/layers/personal/templates",
"단가산출나무": "/api/m02/layers/personal/sangeun-tree",
"일위대가나무": "/api/m02/layers/personal/precombo-tree",
"항목나무": "/api/m02/layers/personal/tree",
"내기계": "/api/m02/layers/personal/my-machines",
"내재료": "/api/m02/layers/personal/materials",
}
def _access(s: Shelf) -> None:
people = {"일반": USER, "같은회사남": NEIGHBOR, "회사관리": ADMIN, "시스템": SYSADMIN}
people["남의회사관리"] = STRANGER
for n, (name, person) in enumerate(people.items()):
s.who(person)
for owner in ("7/42", "7/44"): # 44 = 아직 층 없음
for what, url in READS.items():
s.go(f"권한.{name}", "GET", f"{url}?owner={owner}")
s.go(f"권한.{name}", "GET", "/api/m02/layers/company/sangeun-tree")
s.go(f"권한.{name}", "GET", "/api/m02/layers/system/sangeun-tree")
new = {"문서": _doc("sangeun", f"권한{name}", 90 + n)} # 사람마다 다른 내용
s.go(f"권한.{name}", "POST", "/api/m02/layers/company/library/sangeun", new)
s.go(f"권한.{name}", "POST", "/api/m02/layers/system/library/sangeun", new)
s.go(f"권한.{name}", "POST", f"{P}/library/sangeun?owner=7/42", new)
s.go(f"권한.{name}", "GET", f"{P}/sangeun-same?owner=7/42")
s.who(USER)
def test_서고_길_답_지문(shelf, world):
for kind in ("sangeun", "precombo"):
_library(shelf, world, kind)
_items(shelf)
_machines(shelf)
_materials(shelf)
_share(shelf)
_access(shelf)
now = {k: _finger(v) for k, v in sorted(shelf.got.items())}
if dump := os.environ.get("SHELF_858_DUMP"): # 전후 답 통째 대조용(자기 tmp/ 에)
Path(dump).write_text(
json.dumps(shelf.got, ensure_ascii=False, indent=1, default=str), "utf-8"
)
if os.environ.get(WRITE):
text = json.dumps({"갈래": now}, ensure_ascii=False, indent=1) + "\n"
GOLD.write_bytes(text.encode()) # 줄 끝 LF
was = json.loads(GOLD.read_bytes())["갈래"]
bad = sorted(k for k in now.keys() | was.keys() if now.get(k) != was.get(k))
if bad:
shown = {k: shelf.got.get(k) for k in bad}
text = json.dumps(shown, ensure_ascii=False, default=str)[:4000]
pytest.fail(
f"서고 길 답 지문이 다름 — 갈래 {bad}\n지금 답: {text}\n"
f"뜻한 바뀜이면 다시 뜸: {WRITE}=1 ./venv/Scripts/python.exe -m pytest {__file__}"
)
# ── ② 동시 쓰기 — 잠금 없는 여러 파일 쓰기(설계 858 1-4 「잠금 없는 쓰기」 · 5-4 몫) ─────────
def _two(first, second, meet: list[tuple[Any, str]], late: tuple[Any, str]):
"""둘을 같이 돌림 — 둘 다 판 대조를 지난 뒤 `meet` 함수 앞에서 만나고, 그 뒤 `second` 쪽
`late` 함수를 늦춤 → (먼저 답 · 나중 답 — 예외면 예외)."""
gate = threading.Barrier(2, timeout=10)
slow = threading.local()
saved = [(late[0], late[1], getattr(*late))] + [(o, n, None) for o, n in meet]
def later(*a, _real=saved[0][2], **k):
if getattr(slow, "on", False):
threading.Event().wait(0.3)
return _real(*a, **k)
setattr(*late, later) # 안쪽 = 늦춤 · 바깥 = 만남(같은 함수면 만난 뒤 늦춤)
for i, (owner, name, _) in enumerate(saved[1:], 1):
inner = getattr(owner, name)
saved[i] = (owner, name, inner)
def wait(*a, _inner=inner, **k):
gate.wait()
return _inner(*a, **k)
setattr(owner, name, wait)
def run(fn, is_late):
slow.on = is_late
try:
return fn()
except Exception as error: # 지금 사실(터짐)도 답으로
return error
try:
with ThreadPoolExecutor(2) as pool:
a = pool.submit(run, first, False)
b = pool.submit(run, second, True)
return a.result(), b.result()
finally:
for owner, name, real in reversed(saved):
setattr(owner, name, real)
def _sk(me: Path, name: str, price: int, again: bool = False) -> str:
from M02_MasterTemplete import M02_Library_Ask as ask
with store.at(me):
return ask.create("sangeun", _doc("sangeun", name, price), again, None)["이름"]
def _edit(me: Path, body: dict[str, Any]):
def go():
with store.at(me):
return pre_folders.edit(body, "sangeun", dict(USER))
return go
def _folders(me: Path) -> list[list[str]]:
with store.at(me):
return pre_folders.view("sangeun")["폴더"]
def test_동시_나무_고침_둘_다_됨_뒤_것이_이김(world):
me = world["personal"]
with store.at(me):
판 = pre_folders.view("sangeun")["판"]
first, second = _two(
_edit(me, {"op": "add-folder", "경로": [], "이름": "가", "판": 판}),
_edit(me, {"op": "add-folder", "경로": [], "이름": "나", "판": 판}),
[(pre_folders, "apply_many")],
(pre_folders, "atomic_write_json"),
)
assert first["알림"]["경로"] == ["가"] and second["알림"]["경로"] == ["나"] # 둘 다 됨
assert _folders(me) == [["나"]] # 5-4 에서 뒤집을 단언 — 지금은 뒤 것이 이김(앞 「가」 사라짐)
def test_동시_나무_지우기와_고침_둘_다_됨_뒤_것이_이김(world):
me = world["personal"]
gone = _sk(me, "지울것", 1000)
with store.at(me):
판 = pre_folders.view("sangeun")["판"]
first, second = _two(
_edit(me, {"op": "add-folder", "경로": [], "이름": "가", "판": 판}),
_edit(me, {"op": "delete", "대상": [{"키": gone}], "판": 판}),
[(pre_folders, "apply_many")],
(pre_folders, "atomic_write_json"),
)
assert first["알림"]["경로"] == ["가"] and second["알림"]["기록"] # 둘 다 됨
assert not (me / "sangeun" / f"{gone}.json").exists()
assert _folders(me) == [] # 5-4 에서 뒤집을 단언 — 지금은 뒤 것(지우기)이 이김(「가」 사라짐)
def test_동시_지우기와_합치기_앞_것이_이기고_뒤_것은_터짐(world):
me = world["personal"]
gone = _sk(me, "겹침", 1000)
keep = _sk(me, "겹침", 1000, again=True)
with store.at(me):
판 = pre_folders.view("sangeun")["판"]
body = same_router.MergeBody(
남김={"층": "personal", "주인": "7/42", "키": keep}, 지움=[gone], 판=판
)
first, second = _two(
_edit(me, {"op": "delete", "대상": [{"키": gone}], "판": 판}),
lambda: same_router.merge(dict(USER), me, "sangeun", body),
[(pre_folders, "apply_many"), (same_router, "_user_index")],
(same_router, "_user_index"),
)
assert first["알림"]["기록"] == gone # 지우기 = 됨(기록 키 = 그 문서)
# 5-4 에서 뒤집을 단언 — 지금은 뒤 합치기가 판 · 지문 대조를 지난 뒤 사라진 파일에서 터짐
# (화면 = 500) · 5-4 뒤 = 409 · 파일 앞판 그대로
assert isinstance(second, FileNotFoundError)
assert not (me / "sangeun" / f"{gone}.json").exists()
assert (me / "sangeun" / f"{keep}.json").is_file()
assert [p.stem for p in (me / same_router.GONE).glob("*.json")] == [gone] # 지우기 기록만