Merge remote-tracking branches 'origin/main_laptop_1' and 'origin/sub_laptop_8' into sub_laptop_3

This commit is contained in:
2026-11-17 18:43:35 +09:00
5 changed files with 4232 additions and 0 deletions
@@ -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] # 지우기 기록만