Merge remote-tracking branch 'origin/dev' into sub_laptop_7
This commit is contained in:
@@ -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
@@ -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}")
|
||||
@@ -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] # 지우기 기록만
|
||||
Reference in New Issue
Block a user