diff --git a/M02_MasterTemplete/M02_Hopyo_Elem.py b/M02_MasterTemplete/M02_Hopyo_Elem.py index df8d48226..2dddaa79d 100644 --- a/M02_MasterTemplete/M02_Hopyo_Elem.py +++ b/M02_MasterTemplete/M02_Hopyo_Elem.py @@ -20,7 +20,6 @@ from typing import Any from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Hopyo_Match as hm from M02_MasterTemplete import M02_Hopyo_Material as hmat -from M02_MasterTemplete import M02_Hopyo_UnitLine as unit_line from M02_MasterTemplete import M02_Machine_Find as mfind from M02_MasterTemplete.M02_Hopyo_Words import nfkc @@ -28,16 +27,6 @@ TOP = 3 POOL = 5 -def prices(block: dict[str, Any] | None) -> dict[str, float]: - """블록 단위 줄(노무 · 자재 · 값) → `{이름: 엑셀 단가}`(첫 것 · 776-3 — 글 다시 안 풂).""" - out: dict[str, float] = {} - for one in (block or {}).get("항목") or []: - price = unit_line.money(one.get("단가")) if one.get("묶음") in ("L", "M", "E") else None - if price: - out.setdefault(re.sub(r"^[0-9가-힣]\.", "", str(one.get("이름") or "")).strip(), price) - return out - - def _gap(price: Any, want: float | None) -> float: try: p = float(price) diff --git a/M02_MasterTemplete/M02_Hopyo_Item.py b/M02_MasterTemplete/M02_Hopyo_Item.py deleted file mode 100644 index c21b58b48..000000000 --- a/M02_MasterTemplete/M02_Hopyo_Item.py +++ /dev/null @@ -1,155 +0,0 @@ -"""실무 호표 → 구조물 조합 항목 한 단계(PLAN 704-4 뒷부분 · `_제안_704-4_규격표.md` 6장 끝) — 사전조합 안 거침. - -[구조물 조합으로] = 확인 창 몸(체크한 줄 · 통째 · `M02_Hopyo_Build.check` 그대로)으로 줄을 만들어(`build(save=False)` · - 사전조합 SC 문서 안 씀 · 옛 [사전조합 생성] 길은 그대로) 이 층 구조물집계표에 새 항목(SU · `M02_Item_Personal.create_item` - · 경로 「실무자료」) + 그 일위대가 문서에 줄을 담음(수량 = 1 단위 몫 `{손}`). -확인 안 된 하위 호표 = 고정 줄(하위 먼저 만들기는 옮기기 `M02_Hopyo_Make` 몫 · 785-7). -규격 묶음 = 같은 파일에서 이름 · 단위 같고 줄 구성(줄 이름 · 단위 차례) 같은 · 규격만 다른 호표(5-A 「구성 같은 묶음」) → - 한 항목의 규격 열(704-4) — 열 이름 = 규격 글에서 달라지는 칸(「H=1.5」 → 이름 H · 열 1.5) · 아니면 이름 「규격」 · - 열마다 같은 몸으로 만든 줄 수량(줄 차례 같음 · 다르면 400) · 기본 열 = 연 호표. -""" - -from __future__ import annotations - -import re -from pathlib import Path -from typing import Any - -from M02_MasterTemplete import M02_Hopyo_Build as hb -from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store -from M02_MasterTemplete import M02_Item_Personal as personal -from M02_MasterTemplete import M02_Labor_Spec as spec -from M02_MasterTemplete import M02_Library_Ask as ask -from M02_MasterTemplete import M02_MasterTemplete_Store as store - -PATH = ["실무자료"] -_TOKEN = re.compile(r"[\s,]+") -_PAIR = re.compile(r"^([A-Za-z가-힣Φφ]+)\s*[=:]?\s*([\d.]+)\D{0,3}$") - - -def _flat(text: Any) -> str: - return re.sub(r"\s+", "", str(text or "")) - - -def _shape(h: dict[str, Any]) -> tuple: - return tuple((_flat(x.get("이름")), _flat(x.get("단위"))) for x in h.get("줄") or []) - - -def columns(specs: list[str]) -> tuple[str, list[str]]: - """규격 글들 → (규격 이름, 열 이름) — 처음 달라지는 칸이 모두 「H=1.5」 꼴이면 (H, [1.5 …]) · - 아니면 (「규격」, 그 칸 글) · 20 자 자름 · 겹치면 뒤에 차례.""" - parts = [[t for t in _TOKEN.split(s.strip()) if t] for s in specs] - width = max((len(p) for p in parts), default=0) - at = next((i for i in range(width) if len({p[i] if i < len(p) else "" for p in parts}) > 1), 0) - cells = [p[at] if at < len(p) else "" for p in parts] - hits = [_PAIR.match(c) for c in cells] - if all(hits) and len({h.group(1) for h in hits}) == 1: - name, cols = hits[0].group(1), [h.group(2) for h in hits] - else: - name, cols = "규격", [c or s for c, s in zip(cells, specs, strict=True)] - out: list[str] = [] - for c in cols: - c = (c.strip() or "열")[: spec.NAME_MAX] - while c in out: - c = f"{c[: spec.NAME_MAX - 2]}·{len(out) + 1}" - out.append(c) - return name[: spec.NAME_MAX], out - - -def siblings(source: Path, key: str, no: int) -> dict[str, Any]: - """규격 묶음 제안 — 같은 이름 · 단위 · 줄 구성 · 규격 다른 호표(연 호표 먼저) → - `{묶음 [{번, 규격, 열}], 이름}` · 없으면 묶음 빈 것.""" - units = hopyo_store.read(source, key).get("호표") or [] - me = next((h for h in units if int(h["번"]) == int(no)), None) - if me is None: - raise store.StoreError(404, f"없는 호표 「제{no}호표」") - same = [ - h - for h in units - if _flat(h.get("이름")) == _flat(me.get("이름")) - and _flat(h.get("단위")) == _flat(me.get("단위")) - and _shape(h) == _shape(me) - ] - same.sort(key=lambda h: (int(h["번"]) != int(no), int(h["번"]))) - specs = list(dict.fromkeys(_flat(h.get("규격")) for h in same)) - if len(same) < 2 or len(specs) != len(same): - return {"묶음": [], "이름": None} - name, cols = columns([str(h.get("규격") or "") for h in same]) - rows = [ - {"번": int(h["번"]), "규격": h.get("규격") or "", "열": c} - for h, c in zip(same, cols, strict=True) - ] - return {"묶음": rows, "이름": name} - - -def _doc(folder: Path, source: Path, key: str, no: int, lines: list, whole: Any, who: Any) -> dict: - maker = hb.Builder(folder, source, key, no, who) - checked, pairs = maker.check(list(lines or []), whole) - return {**maker.build(checked, pairs, save=False), "호표": maker.hopyo} - - -def make_item( - folder: Path, - source: Path, - key: str, - no: int, - lines: list[dict[str, Any]] | None = None, - whole: dict[str, Any] | None = None, - bundle: list[int] | None = None, - name: str | None = None, - who: Any = None, - new: bool = False, - use: str | None = None, -) -> dict[str, Any]: - """[구조물 조합으로] → `{key, 열, 이름, 줄수, 열수, 빠진줄}` — - `bundle` = 규격 열로 묶을 호표 번(연 호표 빼고) · - 이 층 같은 내용 항목 = 409(733-2) → `new` 그래도 새로 · `use` 그 항목(`씀` · 새로 안 만듦).""" - main = _doc(folder, source, key, no, lines, whole, who) - doc, hopyo = main["문서"], main["호표"] - title = (name or "").strip() or doc["이름"] - cols_doc = None - if bundle: - found = {r["번"]: r for r in siblings(source, key, no)["묶음"]} - want = [int(no), *(int(b) for b in bundle if int(b) != int(no))] - if any(b not in found for b in want): - raise store.StoreError(400, "규격 묶음은 이름 · 단위 · 줄 구성이 같은 호표만") - title = (name or "").strip() or str(hopyo.get("이름") or doc["이름"]) - qty: dict[str, dict[str, Any]] = {} - for b in want: - got = ( - main["문서"] - if b == int(no) - else _doc(folder, source, key, b, lines, whole, who)["문서"] - ) - col = found[b]["열"] - for part in ("담은로직", "자재"): - mine, theirs = doc[part], got[part] - if len(mine) != len(theirs): - raise store.StoreError(400, f"제{b}호표 줄 구성이 다름 — 묶지 않고 따로 만듦") - for one, other in zip(mine, theirs, strict=True): - hand = (other.get("수량") or {}).get("손") - if hand is not None: - qty.setdefault(str(spec.line_key(one)), {})[col] = hand - cols_doc = { - "이름": siblings(source, key, no)["이름"], - "열": [found[b]["열"] for b in want], - "기본": found[int(no)]["열"], - "수량": qty, - } - count = { - "줄수": len(doc["담은로직"]) + len(doc["자재"]), - "열수": len(cols_doc["열"]) if cols_doc else 1, - } - want = {"담은로직": doc["담은로직"], "자재": doc["자재"], "단위": doc.get("단위")} - reuse = ask.ask_item(folder, {**want, "규격": cols_doc}, new, use) - if reuse: - return {**reuse, **count, "빠진줄": main["빠진줄"]} - with store.at(folder): - made = personal.create_item(folder, PATH, title, doc.get("단위")) - have = store.read("labor", made["열"]) - body = {**have["문서"], "담은로직": doc["담은로직"], "자재": doc["자재"]} - body["단위"] = doc.get("단위") or body.get("단위") - if cols_doc: - body["규격"] = cols_doc - store.write("labor", made["열"], have["판"], body) - return {**made, **count, "빠진줄": main["빠진줄"]} diff --git a/M02_MasterTemplete/M02_Hopyo_Kids.py b/M02_MasterTemplete/M02_Hopyo_Kids.py index 717252afc..b07d15217 100644 --- a/M02_MasterTemplete/M02_Hopyo_Kids.py +++ b/M02_MasterTemplete/M02_Hopyo_Kids.py @@ -4,7 +4,7 @@ 부모 줄 = 하위 사본(740-1 그대로) · 옛 서버 체크 제안 하위 함께(`first` · `proposal`)는 785-7 에서 지움. 같은 내용 일위대가 재사용 `save` — 같은 본뜬(키 · 원본)이면 그 SC(혼자 쓰면 덮음 · 나눠 쓰면 내용 같을 때만) · 아니면 이 층 같은 이름 · 같은 내용 SC(`M02_Library_Same.find_same` + 수량까지) 의 `본뜬.또` 에 출처를 더해 씀 - (SK 꼴 `M02_Hopyo_Sangeun.Maker.write`) · 없으면 새로 → 다시 불러와도 SC 가 안 늚. + · 없으면 새로 → 다시 불러와도 SC 가 안 늚. """ from __future__ import annotations diff --git a/M02_MasterTemplete/M02_Hopyo_Ledger.py b/M02_MasterTemplete/M02_Hopyo_Ledger.py index 423756021..95caedba2 100644 --- a/M02_MasterTemplete/M02_Hopyo_Ledger.py +++ b/M02_MasterTemplete/M02_Hopyo_Ledger.py @@ -1,19 +1,9 @@ -"""M02 일위대가 실무자료 별칭 장부(PLAN 338-3 · 설계 3-5) — 층 `실무자료/맞춤.json` 을 키움. +"""M02 일위대가 짝 검사 · 불러오기 열쇠(PLAN 338-3 · 739-1 · 815-2) — `M02_Hopyo_Build` 가 부름. -줄 = {열쇠(품명|규격|단위 정규화): {원래 {품명, 규격, 단위}, - 갈래 「짝」 · 「우리에 없음」 · 「안 씀」, 짝 [{로직|자재, 입력값, 배, 몫} - | 고른 것 꼴 {갈래, 키?, 입력값, 배, 몫, 이름?, 단위?, 비목?, 기준?, 별도계상?}(785-3)], - 누가, 때, 처음파일, 엑셀조항, 판}} · -직접 줄 호표 통째 = 열쇠 「호표|품명|규격|단위」. -옛 줄 {로직|자재|빼기, 입력값, 환산, 확정} = 읽을 때 새 꼴로 바꿔 읽음(빼기 = 「안 씀」 · -파일은 다음 쓰기 때 새 꼴). -중앙 관리(739-1) — 자동 짝 = 마스터 층(M01 별칭 장부 승인) · 이 불러오기에서 이은 짝 -(줄 `불러오기` = `doc_id`)만 · 회사 · 개인 층 짝 = 「내 제안」(`제안` True · 자동 아님 · -후보 맨 위 · M01 승인 대기). -읽는 차례 = 자동 정확 열쇠(같은 층 → 위 층) → 제안 정확 열쇠 → 품명|단위 느슨 열쇠(`규격다름`). -⚠ 815-2 — 장부 화면 · M01 승인 · 불러오기 확인 때 쓰기는 걷음(별칭 = M01 요소 「별칭」 칸) · -남은 것 = 짝 검사 · 열쇠 도우미 · 요소 잇기의 옛 장부 읽기(sub3 815-1 이 뗌) · 쓰기 = 그 층만 · -짝은 서버가 다시 검사(돈 로직 · 그 로직 입력 이름 · M01 자재품목 · 배 0 넘음 · 몫 (0, 1]). +남은 것 = 짝 재검사(`check_pair` · 고른 것 꼴 · 돈 로직 · 그 로직 입력 이름 · M01 자재품목 · 배 0 넘음 · +몫 (0, 1]) · `times_of` · `KINDS` · 불러오기 하나 열쇠 `doc_id`. +옛 별칭 장부(층 `실무자료/맞춤.json` 읽기 · 쓰기 · 찾기)는 815-2 에 화면 · 길을 걷고 853-3 에서 지움 +(별칭 = M01 요소 「별칭」 칸). """ from __future__ import annotations @@ -22,87 +12,12 @@ from decimal import Decimal from pathlib import Path from typing import Any -from common_util.common_util_time import utc_now_text from M01_MasterData import M01_MasterData_Store as m01 -from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store -mm = m01.cm.mf.mp.mm KINDS = ("짝", "우리에 없음", "안 씀") -HOPYO = "호표|" - - -# ── 열쇠 ───────────────────────────────────────────────────────────── -def key(line: dict[str, Any]) -> str: - """줄 열쇠 = 품명 | 규격 | 단위(정규화 · `M02_Hopyo_Match.line_key` 와 같음).""" - return "|".join( - ( - mm.plain(line.get("이름")), - mm.plain_spec(line.get("규격")), - mm.plain_unit(line.get("단위")), - ) - ) - - -def hopyo_key(hopyo: dict[str, Any]) -> str: - """직접 줄 호표 통째 열쇠 — 「호표|품명|규격|단위」.""" - return HOPYO + key(hopyo) - - -def _loose(full: str) -> str: - """느슨 열쇠 = 품명 | 단위(규격 뺌).""" - head, _, rest = full.rpartition("|") - return f"{head.rsplit('|', 1)[0]}|{rest}" - - -# ── 옛 꼴 → 새 꼴 ───────────────────────────────────────────────────── -def _plain_of(full: str) -> dict[str, str]: - name, spec, unit = full.removeprefix(HOPYO).split("|") - return {"품명": name, "규격": spec, "단위": unit} - - -def upgrade(full: str, raw: Any) -> dict[str, Any] | None: - """장부 한 줄을 새 꼴로 — 옛 기억 줄 · 새 꼴 · 모르는 꼴(None).""" - if not isinstance(raw, dict): - return None - if raw.get("갈래") in KINDS: - return {"원래": _plain_of(full), "짝": [], **raw} - head = {"원래": _plain_of(full), "때": raw.get("확정"), "누가": None, "처음파일": None} - if raw.get("빼기"): - return {**head, "갈래": "안 씀", "짝": []} - pair = {"로직": raw["로직"]} if raw.get("로직") else {"자재": raw.get("자재")} - if not any(pair.values()): - return None - pair.update(입력값=raw.get("입력값") or {}, 배=raw.get("환산"), 몫=None) - return {**head, "갈래": "짝", "짝": [pair]} - - -def read(folder: str | Path) -> dict[str, dict[str, Any]]: - """한 층 장부 `{열쇠: 새 꼴 줄}`(옛 꼴은 바꿔 읽음 · 모르는 줄 뺌).""" - out = {} - for full, raw in hopyo_store.memory(folder).items(): - if str(full).removeprefix(HOPYO).count("|") == 2 and (got := upgrade(str(full), raw)): - out[str(full)] = got - return out - - -# ── 층 ─────────────────────────────────────────────────────────────── -def chain(folder: str | Path) -> list[Path]: - """장부를 볼 층 폴더 — 같은 층 → 위 층(개인 → 회사 → 마스터).""" - layer, owner = refs.where(folder) - out = [Path(folder)] - if layer == "personal": - out.append(refs.folder_of("company", str(owner).split("/")[0])) - if layer in ("personal", "company"): - out.append(Path(store.FOLDER)) - return out - - -def books(folder: str | Path) -> list[tuple[str, str | None, dict[str, dict[str, Any]]]]: - """층마다 `(층, 주인, 장부)` — 같은 층부터(줄 여럿을 찾을 때 한 번 읽어 넘김).""" - return [(*refs.where(one), read(one)) for one in chain(folder)] def doc_id(folder: str | Path, doc: str) -> str: @@ -111,33 +26,6 @@ def doc_id(folder: str | Path, doc: str) -> str: return f"{layer}/{owner or ''}/{doc}" -def recall( - line: dict[str, Any], - folder: str | Path, - got: list | None = None, - whole: bool = False, - doc: str | None = None, -) -> dict[str, Any] | None: - """줄(`whole` = 호표 통째)의 장부 짝 — `{…줄, 층, 주인, 규격다름, 제안}` · 없으면 None. - 자동 정확 열쇠(마스터 · `doc` 불러오기에서 이은 짝) → 제안 정확 열쇠(회사 · 개인 층 · - `제안` True · 자동 아님) → 품명|단위 느슨(규격다름 True · 체크 안 함).""" - full = hopyo_key(line) if whole else key(line) - got = books(folder) if got is None else got - hits = [(layer, owner, book[full]) for layer, owner, book in got if full in book] - for layer, owner, row in hits: - if layer == "system" or (doc and row.get("불러오기") == doc): - return {**row, "층": layer, "주인": owner, "규격다름": False, "제안": False} - if hits: - layer, owner, row = hits[0] - return {**row, "층": layer, "주인": owner, "규격다름": False, "제안": True} - loose = _loose(full) - for layer, owner, book in got: - for one, row in book.items(): - if one.startswith(HOPYO) == whole and _loose(one) == loose: - return {**row, "층": layer, "주인": owner, "규격다름": True, "제안": False} - return None - - # ── 검사 · 쓰기 ─────────────────────────────────────────────────────── def _bad(text: str) -> store.StoreError: return store.StoreError(400, text) @@ -267,60 +155,3 @@ def times_of(raw: dict[str, Any], where: str) -> tuple[int | float, int | float if share is not None and (part is None or not 0 < part <= 1): raise _bad(f"몫은 0 넘고 1 이하 「{where}」") return _json(times), None if part is None else _json(part) - - -def check(full: str, raw: Any, known: tuple[set[str], set[str]] | None = None) -> dict[str, Any]: - """장부 한 줄 재검사(장부 화면 [저장]) → 쓸 꼴(누가 · 때 빼고).""" - if str(full).removeprefix(HOPYO).count("|") != 2 or not isinstance(raw, dict): - raise _bad(f"장부 꼴이 틀림 「{full}」") - kind = raw.get("갈래") - if kind not in KINDS: - raise _bad(f"갈래는 {' · '.join(KINDS)} 「{full}」") - pairs = raw.get("짝") or [] - if kind != "짝" and pairs: - raise _bad(f"「{kind}」 줄은 짝 없음 「{full}」") - if kind == "짝" and (not isinstance(pairs, list) or not pairs or len(pairs) > 20): - raise _bad(f"짝은 하나 넘고 스물 이하 「{full}」") - known = known or _known() - origin = raw.get("원래") if isinstance(raw.get("원래"), dict) else _plain_of(full) - return { - "원래": {k: str(origin.get(k) or "") for k in ("품명", "규격", "단위")}, - "갈래": kind, - "짝": [check_pair(p, full, known) for p in pairs], - "엑셀조항": raw.get("엑셀조항") if isinstance(raw.get("엑셀조항"), list) else [], - } - - -def write( - folder: str | Path, - entries: dict[str, dict[str, Any] | None], - who: Any, - file: str | None = None, - doc: str | None = None, -) -> int: - """검사 끝난 줄을 층 장부에 씀(None = 지움) — 같은 열쇠는 덮음 · 처음파일은 있던 값 둠 · - `doc` = 이은 불러오기(`doc_id` · 없으면 있던 값) · 옛 꼴 줄은 이때 새 꼴로 → 쓴 줄 수.""" - if not entries: - return 0 - have = read(folder) - stamp = utc_now_text() - out: dict[str, dict[str, Any] | None] = dict(have) # 옛 꼴도 새 꼴로 다시 씀 - for full, row in entries.items(): - if row is None: - out[full] = None - continue - first = (have.get(full) or {}).get("처음파일") or file - out[full] = {**row, "누가": who, "때": stamp, "처음파일": first} - if came := doc or (have.get(full) or {}).get("불러오기"): - out[full]["불러오기"] = came - hopyo_store.remember(folder, out) - return len(entries) - - -def put(folder: str | Path, entries: Any, who: Any) -> dict[str, Any]: - """`{열쇠: 줄 | None}` 재검사 뒤 이 층에 씀 → `{씀}`(장부 화면 · M01 승인은 걷음 · 815-2).""" - if not isinstance(entries, dict) or not entries or len(entries) > 2000: - raise _bad("저장할 줄이 없음") - known = _known() - clean = {str(k): None if v is None else check(str(k), v, known) for k, v in entries.items()} - return {"씀": write(folder, clean, who)} diff --git a/M02_MasterTemplete/M02_Hopyo_Router.py b/M02_MasterTemplete/M02_Hopyo_Router.py index 9ff588aea..0ac096fc2 100644 --- a/M02_MasterTemplete/M02_Hopyo_Router.py +++ b/M02_MasterTemplete/M02_Hopyo_Router.py @@ -5,15 +5,16 @@ 옛 판정 · 검산 · 옮기기 · 근거 제안 길(785-5 `hopyo-judge` · `check` · `move` · `price` · 793-3a `hopyo-basis`)은 809-1 에서 지움(요구 703 — 기초로 바꾸기 없음). 그대로 쓰는 길(목록 · 올림 · 엑셀 보기 머리 · 격자 · 지우기 · 모두 고정 · 붙여넣기 · 다시 잇기 · -구조물 조합 · 칠 = B09 · M01 이 씀) · 옛 맞춤 길(호표 하나 맞춤 · 미리 셈 · 실무 호표 · 확인 만들기 · 안 이은 줄 · -단가산출 만들기)은 785-7 에서 지움. +칠 = B09 · M01 이 씀) · 옛 맞춤 길(호표 하나 맞춤 · 미리 셈 · 실무 호표 · 확인 만들기 · 안 이은 줄 · +단가산출 만들기)은 785-7 · +옛 [구조물 조합으로] 길(`hopyo-item` · `siblings` — 화면은 구조물 조합 길을 바로 부름)은 853-3 에서 지움. 층 = 늘 개인(요구 855 · 위 `_root` 가 고정) · ⚠ 등록은 `main.py`(로그인만). """ from __future__ import annotations from pathlib import Path -from typing import Any, Literal +from typing import Any from fastapi import APIRouter, Depends, File, HTTPException, UploadFile from pydantic import BaseModel, ConfigDict, Field @@ -24,7 +25,6 @@ from M02_MasterTemplete import M02_Hopyo_Build as hopyo_build from M02_MasterTemplete import M02_Hopyo_Excel as hopyo_excel from M02_MasterTemplete import M02_Hopyo_Forget as hopyo_forget from M02_MasterTemplete import M02_Hopyo_Grid as hopyo_grid -from M02_MasterTemplete import M02_Hopyo_Item as hopyo_item from M02_MasterTemplete import M02_Hopyo_Marks as hopyo_marks from M02_MasterTemplete import M02_Hopyo_Paste as hopyo_paste from M02_MasterTemplete import M02_Hopyo_Relink as hopyo_relink @@ -141,45 +141,6 @@ class _Strict(BaseModel): model_config = ConfigDict(extra="forbid") # 금액 · 품 칸 = 400(서버가 셈) -class BuildTarget(_Strict): - """대상 하나 — 로직 · 자재 · 호표 중 하나 · 배 = 우리 수량 ÷ 엑셀 수량 · 몫 = 섞인 줄 몫.""" - - 로직: str | None = None - 자재: str | None = None - 호표: int | None = None - 전국: bool | None = None # 「전국」 자재(361-1 · 키 없음 · 서버가 줄에서 다시 셈) - 노임: str | None = None # 729-2 사용자 이음 — LB 키(엑셀 숫자 + 이음) - 기계: str | None = None # EQ 키 - 비율: Literal["노무비", "재료비", "경비"] | None = None # % 줄 밑수 - 입력값: dict[str, Any] = Field(default_factory=dict) - 배: float = 1 - 몫: float | None = None - - -class BuildLine(_Strict): - """확인한 줄 — `차례` = 호표 안 줄(0부터) · `대상` 목록 또는 `뺌` 까닭.""" - - 차례: int - 대상: list[BuildTarget] = Field(default_factory=list) - 뺌: Literal["우리에 없음", "안 씀"] | None = None - - -class BuildWhole(_Strict): - 대상: list[BuildTarget] - - -class BuildBody(_Strict): - """실무 호표 → 이 층 사전조합 — 파일 층 `층` · `주인` · `키` + 호표 `번` + 확인한 `줄` · - 직접 줄 호표 = `통째` · 같은 본뜬은 늘 덮음.""" - - 층: Layer - 주인: str | None = None - 키: str - 번: int - 줄: list[BuildLine] = Field(default_factory=list, max_length=500) - 통째: BuildWhole | None = None - - class BuildAllBody(_Strict): """시트 통째(705-3) — 파일 층 `층` · `주인` · `키` 만(숫자 · 줄 칸 없음 · 서버가 파일에서 읽음) · `번` = 그 호표 하나 + 하위(807-1 [내 일위대가로]).""" @@ -284,46 +245,6 @@ def hopyo_relink_apply( return _call(folder, hopyo_relink.apply, body.바꿈) -@router.get("/layers/{layer}/hopyo/{key}/{no}/siblings") -def hopyo_siblings( - layer: Layer, - key: str, - no: int, - owner: str | None = None, - session: Session = Depends(verify_session), -) -> dict: - """규격 묶음 제안(704-4) — 이름 · 단위 · 줄 구성 같고 규격만 다른 호표 `{묶음 [{번, 규격, 열}], 이름}`.""" - folder = _root(session, layer, owner) - return _call(folder, hopyo_item.siblings, folder, key, no) - - -class ItemBody(BuildBody): - """[구조물 조합으로](704-4) — 확인 창 몸 그대로 + `묶음` = 규격 열로 묶을 호표 번 · `이름` = 항목 이름.""" - - 묶음: list[int] = Field(default_factory=list, max_length=20) - 이름: str | None = Field(None, max_length=120) - 새로: bool = False # 같은 내용 항목 409 뒤 — 그래도 새로(733-2) - 씀: str | None = Field(None, max_length=80) # 같은 내용 409 뒤 — 그 항목 씀 - - -@router.post("/layers/{layer}/hopyo-item") -def hopyo_to_item( - layer: Layer, - body: ItemBody, - owner: str | None = None, - session: Session = Depends(verify_session), -) -> dict: - """실무 호표 → 이 층 구조물 조합 항목(사전조합 안 만듦 · 이 층 쓰기 · 파일 층 읽기) → - `{key, 열, 이름, 줄수, 열수, 빠진줄}`.""" - folder = _root(session, layer, owner, write=True) - source = _root(session, body.층, body.주인) - lines = [one.model_dump(exclude_none=True) for one in body.줄] - whole = body.통째.model_dump(exclude_none=True) if body.통째 else None - args = (folder, source, body.키, body.번, lines, whole, body.묶음, body.이름, _who(session)) - args += (body.새로, body.씀) - return _call(folder, hopyo_item.make_item, *args) - - @router.get("/layers/{layer}/hopyo-marks/{key}") def hopyo_marks_read( layer: Layer, diff --git a/M02_MasterTemplete/M02_Hopyo_Sangeun.py b/M02_MasterTemplete/M02_Hopyo_Sangeun.py index 481ba6f28..87518e106 100644 --- a/M02_MasterTemplete/M02_Hopyo_Sangeun.py +++ b/M02_MasterTemplete/M02_Hopyo_Sangeun.py @@ -1,12 +1,7 @@ """M02 일위대가 불러오기 → 단가산출(PLAN 718-1 · 729-1 · 778-5 · 785-5 · 785-7 · 요구 621 · 623 · 642) — SK 쓰기 · 이음. -SK 쓰기 = `Maker.write`(옮기기 `M02_Hopyo_Make` 가 부름 · 확인한 블록만) — 이름 블록 이름(없으면 줄 품명) · -단위 = 줄 단위(없으면 블록 · 「식」) · 구분 「실무자료」 · 상세구분 = 파일 · 본뜬 = {층 「실무자료」, -키 「HP-###### 단산N」, 파일, 원본, 확인, 갈래, 근거, 못옮김 []} · 같은 본뜬(키 · 원본)이 이 층에 있으면 그 키에 덮음 · -만드는 층 = 부르는 층. -같은 내용(733-1 · `M02_Library_Same` 지문) SK 가 이 층에 있으면 새로 안 만들고 그것을 씀 — 이름 = 먼저 만든 것 · -뒤 출처 = 그 SK `본뜬.또 [그 블록 본뜬 + 이름]`(`made` · `origin_of` 가 읽음) · 다른 출처가 쓰는 SK 는 내용을 -안 바꿈(바뀌면 떼고 다시 찾음) · 위 층 같은 것 = `Maker.above`(알림만). +SK 쓰기 · 같은 내용 재사용(`Maker`)은 853-3 에서 지움(만드는 곳 0 — 단산 블록 SK = `M02_Sangeun_FromHopyo`) · +남은 것 = 본뜬 읽기(`made` · `origin_of`) · 부름 표(`calls` · `callers`) · 이음. SK 이음(729-2 · 일위대가 모두 고정 길 · `M02_Hopyo_Build.Builder` · `M02_Hopyo_Make.Lines` 가 부름 — 옛 `SkLink`) = 확인 안 한 단가산출 줄 → 이 층 · 같은 원본 그 블록 SK 참조(`sk_line` · 없으면 「확인 전」 고름 대기 · 단위 다름 · 못옮김 남음 = 못 이음) · 확인한 로직 줄이 차이 SK 의 바탕 = 그 SK 참조(`kept`) · 남은 줄 = `left`. @@ -19,16 +14,11 @@ from decimal import Decimal from pathlib import Path from typing import Any -from common_util.common_util_time import utc_now_text from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Hopyo_Elem as elem from M02_MasterTemplete import M02_Hopyo_Fixed as hfix -from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store -from M02_MasterTemplete import M02_Hopyo_Units as units from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs -from M02_MasterTemplete import M02_Library_Same as same -from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete.M02_Hopyo_Kids import _same_mark ORIGIN = "실무자료" @@ -107,108 +97,6 @@ def callers(hp: dict[str, Any]) -> dict[int, list]: return out -def _doc(line: dict, block: dict, no: int, hp: dict, plan: dict, sure: dict) -> dict[str, Any]: - name = str(block.get("이름") or line.get("이름") or "").strip() or f"단산{no}" - unit = str(line.get("단위") or block.get("단위") or "").strip() or "식" - keep = {k: plan[k] for k in ("갈래", "엑셀품", "못옮김", "근거") if k in plan} - keep |= {"놓음": plan["놓음"]} if plan.get("놓음") else {} - return { - "종류": "단가산출", - "이름": name, - "단위": unit, - "구분": ORIGIN, - "상세구분": str(hp.get("파일") or ""), - "본뜬": {"층": ORIGIN, "키": mark(hp["키"], no), "파일": hp.get("파일"), **sure, **keep}, - "바탕": plan["바탕"], - "입력값": plan["입력값"], - **({"환산": plan["환산"]} if plan.get("환산") else {}), - "열린입력": [], - "고름": {}, - **{k: plan[k] for k in ("자재표시", "덮개", "더한줄", "뺀줄")}, - } - - -class Maker: - """한 번 만들기 — 파일 · 이 층 SK 를 한 번 읽음(`source` = 파일 층 · 쓰기 = `store.root()`).""" - - def __init__(self, source: Path, key: str, who: Any = None) -> None: - self.source, self.key, self.who = Path(source), key, who - self.hp = hopyo_store.read(source, key) - self.blocks, self.first = calls(self.hp) - self.here = refs.where(source) - self.whole = m01.loaded()[1] - self.sure = {"원본": list(self.here), "확인": {"누가": who, "때": utc_now_text()}} - self.same, self.reused, self.above = same.Same(), [], [] - self.keys = made(source, key, self.here) # {본뜬 키: SK} — 만든 것 더해 감 - self._units: units.Units | None = None - - def units(self) -> units.Units: - if self._units is None: # 815-1 — 옛 별칭 장부 안 읽음(M01 별칭 칸은 Units 가 읽음) - self._units = units.Units() - return self._units - - def ref_of(self, sub: dict[str, Any]) -> dict[str, Any] | None: - """하위 줄 → 참조 칸 — 단산 = 이 HP 그 블록 SK · 일위 = 확인된 그 호표 SC · 없으면 None.""" - from M02_MasterTemplete import M02_Hopyo_Build as hopyo_build # Build → 여기 — 늦게 읽음 - - if sub.get("종류") == "단산": - got = self.keys.get(mark(self.key, int(sub["번"]))) - else: - done = hopyo_build.confirmed(store.root(), self.here) - got = done.get(hopyo_build.mark(self.key, int(sub["번"]))) - layer, owner = refs.here() - return {"층": layer, "주인": owner, "키": got} if got else None - - def write(self, no: int, plan: dict, have: str | None) -> str: - """그 블록 SK 를 씀 → 키 — 다른 출처(또)가 쓰는 SK 의 내용은 안 바꿈(바뀌면 떼고 다시 찾음).""" - doc = _doc(self.first.get(no) or {}, self.blocks[no], no, self.hp, plan, self.sure) - root, mine = store.root(), doc["본뜬"] - self.above += [{"번": no, **r} for r in self.same.find_above(root, KIND, doc)] - if have: - raw, old, own, rest = self._read(have, mine) - owner = _same_mark(own, mine) - if self.same.finger(KIND, old) == self.same.finger(KIND, doc): # 내용 같음 = 출처만 - self._put( - have, raw, old, *((mine, rest) if owner else (own, [*rest, self._entry(doc)])) - ) - return have - if owner and not rest: # 혼자 쓰던 SK — 제자리 덮음 - store.write(KIND, have, store.version_of(raw), {**doc, "키": have}) - self.same.add(root, KIND, have, doc) - return have - head = {k: v for k, v in rest[0].items() if k != "이름"} if owner else own - self._put(have, raw, old, head, rest[1:] if owner else rest) # 떼어 냄 - found = self.same.find_same(root, KIND, doc) - if found: - raw, old, own, rest = self._read(found[0], mine) - self._put(found[0], raw, old, own, [*rest, self._entry(doc)]) - self.reused.append({"번": no, "키": found[0]}) - return found[0] - key = refs.create(KIND, doc)["이름"] - self.same.add(root, KIND, key, doc) - return key - - @staticmethod - def _entry(doc: dict) -> dict[str, Any]: - return {**doc["본뜬"], "이름": doc["이름"]} - - @staticmethod - def _read(key: str, mine: dict) -> tuple[bytes, dict, dict, list]: - """(바이트, 문서, 제 본뜬(또 뺌), 또 가운데 `mine` 뺀 것).""" - raw = (store.root() / KIND / f"{key}.json").read_bytes() - doc = json.loads(raw) - got = doc.get("본뜬") or {} - own = {k: v for k, v in got.items() if k != "또"} - rest = [x for x in got.get("또") or [] if isinstance(x, dict) and not _same_mark(x, mine)] - return raw, doc, own, rest - - @staticmethod - def _put(key: str, raw: bytes, doc: dict, own: dict, also: list) -> None: - body = {**doc, "본뜬": {**own, "또": also} if also else own} - if body != doc: - store.write(KIND, key, store.version_of(raw), body) - - # ── SK 이음(일위대가 모두 고정 길 · 옛 `M02_Hopyo_SkLink`) ─────────────────────────── def _num(value: Decimal) -> int | float: value = value.normalize() diff --git a/M02_MasterTemplete/M02_Hopyo_SkUnit.py b/M02_MasterTemplete/M02_Hopyo_SkUnit.py deleted file mode 100644 index e9332dffd..000000000 --- a/M02_MasterTemplete/M02_Hopyo_SkUnit.py +++ /dev/null @@ -1,224 +0,0 @@ -"""M02 실무 단가산출 블록 = 줄 판정 모음 · 단위 SK(PLAN 778-5 · D-3 · 요구 623 · 624). - -모두 줄로만 — 바탕 기초 안 씀(기초 = 근거 꼬리표만) · 자동 없음(사용자가 확인한 블록만 만듦). -줄 판정 = `M02_Hopyo_Units` 잇기(상태 · 방법 · 단위) + 매개값(품 · 시간 · 수량 · 율) · 사용자 고름 -`{차례: 단위 | {뺌: 까닭}}`(그 줄만 · 꼬리표 「내가 고름」) · 단가 = M01 지금 값으로 다시 셈(`우리금액`) · -엑셀 금액과의 `차` = 참고(엑셀 = 과거 값 · 판정에 안 씀) · 셈 밖 줄 = 상태 「밖」(SK 에 안 들임). -블록 판정 = 줄 모음 — 모두 이어짐 = 「옮길 수 있음」 · 아니면 「고를 줄 n」 · 줄 0 = 「줄 없음」(고를줄 1 · 빈 SK 막음). -단위 SK 더한줄(바탕 없음 · 778-4 꼴) = 인력 `{요소 LB, 수량 품}` · 기계경비 로직 `{로직 GC, 입력값 {기계}, -수량 시간 × 할증}` · 재료 `{요소 MT, 수량(손료율 든), 별도계상?}`(못 찾은 별도계상 = 0 원 고정 줄) · -율 `{고정 {비율 {기준, 비목}}, 수량 = 율 %}`(줄 목록 = 그 행 줄 `add:#k`) · 하위 `{참조 SK · SC}` · 값 고정 줄. -근거 꼬리표 = 조항 색인(`Sangeun.Maker.basis` · 참고) · 고른 것(785-5 `M02_Hopyo_Make`)도 `adds` 를 부름 · -기계경비 기초 차례(`_mach_logics`) = 옛 SkPatch 에서 옮김. 서버 단독 · 쓰기 = `M02_Hopyo_Sangeun`. -""" - -from __future__ import annotations - -from typing import Any - -from M02_MasterTemplete import M02_Hopyo_Fixed as hfix -from M02_MasterTemplete import M02_Hopyo_UnitLine as unit_line -from M02_MasterTemplete import M02_Hopyo_Units as units -from M02_MasterTemplete import M02_Sangeun_Calc as calc -from M02_MasterTemplete import M02_Sangeun_Doc as sd -from M02_MasterTemplete.M02_Hopyo_Words import mtypes - -GOOD = "옮길 수 있음" -EMPTY = "줄 없음" -OUT, DROP = "밖", "뺌" -UNIT = "단위" # 본뜬 갈래 -MINE = "내가 고름" -WORD = {"L": "품", "X": "시간", "M": "수량", "R": "율", "S": "수량"} -PICKS = {"L": ("노임", "LB"), "X": ("기계", "EQ"), "M": ("자재", ("MT", "MO"))} -MACH_IN = "기계" # 기계경비 기초 기계 입력 칸 -MACHINE = {"굴착기": "GC000267"} # 굴착기(무한궤도) 시간당 기계경비 · 그 밖 장비 = GC000268 -MACHINE_ANY = "GC000268" -MACHINE_SET = {"GC000267", "GC000268", "GC000269", "GC000275"} -# (주연료, 조종원) 없는 기종 → 그 기계경비 기초(M01 로직이 부르는 것과 같음 · 778-2) -SOLO = {(False, False): "GC000273", (True, False): "GC000272", (False, True): "GC000276"} - - -class PickError(ValueError): - """고름 틀림 — 부르는 쪽이 400.""" - - -def _mach_logics(whole: Any, kinds: set, eq: dict | None = None) -> list[str]: - """기계경비 기초 차례 — 갈래 첫 기초(굴착기 = 무한궤도) › 그 밖 · `eq` 가 있으면 - 연료 · 조종원 없는 기종 = 그 기초 하나 · 아니면 그 기계(또는 같은 이름 기계)를 고르기에 둔 기초가 앞.""" - first = next((c for k, c in MACHINE.items() if k in kinds), MACHINE_ANY) - order = [first, *sorted(MACHINE_SET - {first})] - if not eq: - return order - import master_machine_crew as mcrew # 인력 줄 → 조종원 수(842-3) - - has = mcrew.view(eq.get("값")) if isinstance(eq.get("값"), dict) else {} - if solo := SOLO.get((bool(has.get("주연료")), bool(has.get("조종원")))): - return [solo] - eqs = whole.numbers.get("EQ", {}) - - def takes(code: str) -> bool: - ins = whole.logic(code).get("입력") or [] - opts = next((s.get("고르기") or [] for s in ins if s.get("이름") == MACH_IN), []) - same = any((eqs.get(o) or {}).get("이름") == eq.get("이름") for o in opts) - return eq.get("원문번호") in opts or same - - hit = [c for c in order if takes(c)] - return hit + [c for c in order if c not in hit] - - -def _picked(one: dict[str, Any], pick: Any, us: units.Units) -> dict[str, Any]: - """사용자 고름 → 이어짐 단위 — 노임 LB · 기계 EQ(→ 기계경비 로직) · 자재 MT · 율 기준 · 뺌.""" - if not isinstance(pick, dict): - raise PickError("고름은 {노임|기계|자재: 키} · {기준, 비목?} · {뺌}") - if pick.get("뺌"): - return {"상태": DROP, "단위": None, "글": str(pick["뺌"]), "꼬리표": [MINE]} - kind = one["묶음"] - if kind == "R" and pick.get("기준") is not None: - unit = {"기준": pick["기준"], "비목": pick.get("비목") or units.rate_part(one.get("이름"))} - hfix.fixed.clean({"이름": "율", "비율": unit}, "고름", us.whole) - return {"상태": units.LINKED, "단위": unit, "꼬리표": [MINE]} - field, head = PICKS.get(kind, ("", "?")) - code = str(pick.get(field) or "") - if not field or not code.startswith(head): - shown = head if isinstance(head, str) else head[0] - raise PickError(f"{units.HOW.get(kind, kind)} 줄 · {field or '뺌'} 키({shown}…)로 고름") - try: - row = us.whole.get(code) - except Exception as e: # noqa: BLE001 — 없는 키 - raise PickError(f"없는 키 「{code}」") from e - unit: dict[str, Any] = {field: code} - if kind == "X": - kinds = mtypes(f"{row.get('상세구분')} {row.get('이름')}") - unit["로직"] = _mach_logics(us.whole, kinds, row)[0] - unit |= {"할증": one["할증"]} if one.get("할증") else {} - if kind == "M" and (one.get("어떻게") == "별도" or pick.get("별도계상")): - unit["별도계상"] = True - return {"상태": units.LINKED, "단위": unit, "꼬리표": [MINE]} - - -def lines(block: dict[str, Any], us: units.Units, picks: dict | None = None) -> list[dict]: - """블록 단위 줄 → 줄 판정 `[{차례, 행, 묶음, 이름, 규격, 매개값, 엑셀금액, 재현, 상태, 방법, 단위, 후보, - 꼬리표, 글}]`(재현 = 엑셀 단가 × 매개값 ≈ 엑셀 금액 · D-6 띠) · `picks` = `{차례: 고름}`.""" - out = [] - for at, one in enumerate(block.get("항목") or []): - q = one.get("품") - row = {"차례": at, "행": one.get("행"), "묶음": one["묶음"], "이름": one.get("이름")} - row |= {"규격": one.get("규격") or "", "엑셀금액": one.get("금액"), "재현": one.get("재현")} - row["매개값"] = {WORD[one["묶음"]]: q} if one["묶음"] in WORD and q is not None else {} - if one.get("밖"): - out.append({**row, "상태": OUT, "방법": "", "단위": None, "후보": [], "꼬리표": []}) - continue - got = us.line(one) - pick = (picks or {}).get(at) - if pick is not None: - got = {**got, "후보": [], "글": "", **_picked(one, pick, us)} - out.append({**row, **got}) - return out - - -def verdict(rows: list[dict]) -> tuple[str, int]: - """블록 판정 — (「옮길 수 있음」 | 「고를 줄 n」 | 「줄 없음」, n) · 줄 0 = 1(확인해도 못 만듦).""" - if not rows: - return EMPTY, 1 - n = sum(1 for r in rows if r["상태"] not in (units.LINKED, OUT, DROP)) - return (GOOD if not n else f"고를 줄 {n}"), n - - -def adds(block: dict, rows: list[dict], us: units.Units, ref_of: Any) -> tuple[list, dict]: - """이어진 줄 → 단위 SK 더한줄 · `{차례: add 번}` — `ref_of(하위)` = 참조 칸 | None(빠짐).""" - out: list[dict] = [] - at_of: dict[int, int] = {} - by_row = {r.get("행"): r["차례"] for r in rows} - items = block.get("항목") or [] - for r in rows: - if r["상태"] != units.LINKED: - continue - one, unit = items[r["차례"]], r["단위"] or {} - name = " ".join(str(one.get("이름") or "").split()) or "이름 없음" - q = float(one.get("품") or 0) - kind = one["묶음"] - if kind == "L": - add = {"종류": "인력", "요소": unit["노임"], "이름": name, "단위": "인", "수량": q} - elif kind == "X": - eq = us.whole.get(unit["기계"]) or {} - given = {MACH_IN: eq.get("원문번호")} - q *= float(unit.get("할증") or 1) - add = { - "종류": "로직", - "로직": unit["로직"], - "입력값": given, - "이름": name, - "단위": "시간", - } - add["수량"] = q - elif kind == "M" and unit.get("자재"): - add = {"종류": "재료", "요소": unit["자재"], "이름": name, "수량": q} - add |= {"별도계상": True} if unit.get("별도계상") else {} - elif kind == "R": - basis = unit["기준"] - if isinstance(basis, dict): # 줄 목록 = 그 행 줄 - basis = [f"add:#{at_of[k]}" for h in basis.get("행") or [] - if (k := by_row.get(h)) in at_of] # fmt: skip - fx = { - "이름": name, - "단가": {}, - "이음": {}, - "비율": {"기준": basis, "비목": unit["비목"]}, - } - add = {"고정": fx, "이름": name, "단위": "%", "수량": round(q * 100, 9)} - elif kind == "S": - ref = ref_of(unit["하위"]) - if ref is None: - continue - add = {"참조": ref, "이름": name, "수량": q or 1} - else: # 값 · 못 찾은 별도계상 = 고정 금액 줄 - money = unit.get("값", 0) - fx = { - "이름": name, - "단가": {k: float(v) for k, v in hfix._parts({"계": money}).items()}, - } - add = {"고정": {**fx, "이음": {}}, "이름": name, "수량": q if kind == "M" else 1} - at_of[r["차례"]] = len(out) - out.append(add) - return out, at_of - - -def priced(rows: list[dict], made: list[dict], at_of: dict, unit: str, whole: Any) -> Any: - """M01 지금 값으로 다시 셈 → (저장 꼴 더한줄, 블록 1 단위 계 | None) · 줄 `우리금액` · `차`(참고) · - 셈 못 함 = 금액 칸 비움(판정은 그대로).""" - doc = {"키": "SK-000000", "이름": "판정", "단위": unit or "식", "바탕": None, "더한줄": made} - try: - doc = sd.clean(doc, None, whole) # 저장 꼴(같은 내용 SK 지문이 저장본과 같게) - got = calc.run(doc, whole) - except Exception: # noqa: BLE001 - return made, None - money = {x.get("cid"): x.get("금액") for x in got.get("줄") or []} - for r in rows: - k = at_of.get(r["차례"]) - mine = money.get(f"add:#{k}") if k is not None else None - r["우리금액"] = float(mine) if mine is not None else None - theirs = r.get("엑셀금액") - r["차"] = round(r["우리금액"] - float(theirs), 4) if mine is not None and theirs else None - total = (got.get("1단위") or {}).get("계") - return doc["더한줄"], float(total) if total is not None else None - - -def judge( - block: dict, us: units.Units, ref_of: Any, picks: dict | None = None, unit: str = "" -) -> dict[str, Any]: - """블록 하나 → `{판정, 고를줄, 우리금액, 엑셀금액, 줄 [...], 더한줄, 담음}`(더한줄 = 단위 SK 몸 · - 담음 = 더한줄에 든 줄 차례 · 이어졌는데 빠진 줄 = 하위 SK · SC 아직 없음).""" - rows = lines(block, us, picks) - word, n = verdict(rows) - made, at_of = adds(block, rows, us, ref_of) - made, total = priced(rows, made, at_of, unit, us.whole) - head = {"판정": word, "고를줄": n, "우리금액": total} - head["엑셀금액"] = unit_line.money(block.get("금액")) - return {**head, "줄": rows, "더한줄": made, "담음": sorted(at_of)} - - -def plan(got: dict[str, Any], basis: dict | None) -> dict[str, Any]: - """판정 → `Sangeun.Maker.write` 꼴 — 바탕 없음 · 덮개 · 뺀줄 없음 · 근거 꼬리표.""" - keep = {"갈래": UNIT, "바탕": None, "입력값": {}, "덮개": {}, "자재표시": {}, "뺀줄": []} - out = {**keep, "더한줄": got["더한줄"], "못옮김": [], "놓음": []} - return out | ({"근거": basis} if basis else {}) diff --git a/M02_MasterTemplete/M02_Hopyo_Store.py b/M02_MasterTemplete/M02_Hopyo_Store.py index 4d7a9856d..f8e28d3e1 100644 --- a/M02_MasterTemplete/M02_Hopyo_Store.py +++ b/M02_MasterTemplete/M02_Hopyo_Store.py @@ -1,8 +1,8 @@ """M02 일위대가 실무자료 저장(PLAN 324-1) — 층 폴더 `실무자료/<키>.json` · -맞춤 기억 `실무자료/맞춤.json` · 엑셀꼴 격자 `실무자료/격자/<키>.json`(329-1 · 파일과 같이 지움). +엑셀꼴 격자 `실무자료/격자/<키>.json`(329-1 · 파일과 같이 지움). 파일 = 읽은 결과만(원본 엑셀 안 둠) `{키, 파일, 올린때, 올린이, 시트, 호표, 검산}` · 키 `HP-######` -(층마다 다음 번호) · 맞춤 기억 = `{줄: {줄 열쇠: {로직?|자재?|빼기?, 입력값, 환산, 확정}}}`. +(층마다 다음 번호) · 옛 맞춤 기억(`맞춤.json` · 별칭 장부)은 853-3 에서 지움. 층 종류(`layers.KINDS`) 밖 폴더 — 양식 목록 · 복사 · 프로젝트 씨앗에 안 섞임 · 권한은 길 몫. 한시 불러오기(718-1 · 743-1) — 파일에 `지문`(올린 엑셀 sha256) · 목록 = 지문 있고 하루 안 지난 것 (작업 중)만 · 옛 HP · 하루 지난 HP 는 목록에서 숨김(지움 = `M02_Hopyo_Forget`) · @@ -26,7 +26,6 @@ from common_util.common_util_time import utc_now_text from M02_MasterTemplete import M02_MasterTemplete_Store as store DIRNAME = "실무자료" -MEMORY = "맞춤" GRID = "격자" DONE = "불러옴" NO_GRID = "격자 없음 — 다시 올리면 보임" @@ -174,27 +173,3 @@ def delete(folder: str | Path, key: str) -> None: path.unlink() _grid_path(folder, key).unlink(missing_ok=True) (_dir(folder) / "산근" / f"{key}.json").unlink(missing_ok=True) # 793-3b 산근 시트 - - -# ── 맞춤 기억 ───────────────────────────────────────────────────────── -def memory(folder: str | Path, name: str = MEMORY) -> dict[str, dict[str, Any]]: - """층 맞춤 기억 `{줄 열쇠: 확정}` — 없으면 빈 것 · - `name` = 기억 파일(내역 잇기 707-4 = 「내역맞춤」).""" - doc = _load(_dir(folder) / f"{name}.json") - got = doc.get("줄") if isinstance(doc, dict) else None - return got if isinstance(got, dict) else {} - - -def remember( - folder: str | Path, entries: dict[str, dict[str, Any] | None], name: str = MEMORY -) -> dict[str, Any]: - """기억 더함 · 바꿈(값 None = 지움) → 새 기억 전부.""" - with _LOCK: - got = memory(folder, name) - for key, value in entries.items(): - if value is None: - got.pop(key, None) - else: - got[key] = value - atomic_write_json(_dir(folder) / f"{name}.json", {"줄": got}) - return got diff --git a/M02_MasterTemplete/M02_Hopyo_Units.py b/M02_MasterTemplete/M02_Hopyo_Units.py index 9da3a6d31..9afeee449 100644 --- a/M02_MasterTemplete/M02_Hopyo_Units.py +++ b/M02_MasterTemplete/M02_Hopyo_Units.py @@ -276,28 +276,3 @@ class Units: if got is None: return {"상태": NONE, "단위": None, "글": "금액 없음"} return {"상태": LINKED, "방법": HOW["E"], "단위": {"값": float(got)}} - - -def hopyo_unit(line: dict[str, Any]) -> dict[str, Any]: - """일위대가 줄(`UnitLine.check_hopyo` 투영 뒤) → 단위 줄 꼴 — 이름 · 규격 · 단위 · 품 = 수량 · 별도.""" - one = {k: line.get(k) for k in ("묶음", "이름", "규격", "단위", "할증")} - one.update(품=line.get("수량"), 금액=unit_line.money(line.get("금액")), 직종=None) - if line.get("갈래") == "별도계상": - one["어떻게"] = "별도" - if one["묶음"] == "R": - base = str(line.get("기준") or "노무비") - one.update(기준=base, 기준꼴={"주재료비": "자재"}.get(base, base)) - one["품"] = float(line["수량"]) / 100 if line.get("수량") is not None else None - ref = line.get("참조") or {} - if one["묶음"] == "S" and ref.get("번"): - one["하위"] = {"종류": ref.get("종류"), "번": ref.get("번")} - return one - - -def summary(rows: list[dict[str, Any]]) -> dict[str, dict[str, int]]: - """묶음별 `{묶음: {이어짐, 고를 것, 못 이음}}` — 줄 연결 표.""" - out: dict[str, dict[str, int]] = {} - for kind, state in rows: - one = out.setdefault(kind, dict.fromkeys((LINKED, PICK, NONE), 0)) - one[state] += 1 - return out diff --git a/M02_MasterTemplete/M02_Labor_Ref.py b/M02_MasterTemplete/M02_Labor_Ref.py index 1afa5198c..2306ad99f 100644 --- a/M02_MasterTemplete/M02_Labor_Ref.py +++ b/M02_MasterTemplete/M02_Labor_Ref.py @@ -352,11 +352,34 @@ def _no_loop(ref: Ref, trail: list[Ref]) -> None: _no_loop(child, [*trail, child]) +#: 층 뿌리 번호 장부 {종류: 발급한 가장 큰 번호} — 지운 끝 번호를 다시 안 씀(854-1 · M01 키대장 규칙과 같은 뜻) +ISSUED = "_번호.json" + + +def _issued() -> dict[str, Any]: + try: + got = json.loads((store.root() / ISSUED).read_bytes()) + except (OSError, ValueError): + return {} + return got if isinstance(got, dict) else {} + + def next_key(kind: str) -> str: - """지금 층 그 종류의 다음 키(가장 큰 번호 + 1).""" + """지금 층 그 종류의 다음 키(파일 · 장부 가운데 가장 큰 번호 + 1).""" folder = store.root() / kind have = [int(m.group(2)) for p in folder.glob("*.json") if (m := _KEY.match(p.stem))] - return f"{PREFIX[kind]}-{max(have, default=0) + 1:06d}" + return f"{PREFIX[kind]}-{max(*have, int(_issued().get(kind) or 0), 0) + 1:06d}" + + +def _keep_issued(kind: str, key: str) -> None: + """장부에 발급한 번호(더 클 때만).""" + from common_util.common_util_json import atomic_write_json + + n = int(_KEY.match(key).group(2)) + with store._LOCK: + got = _issued() + if int(got.get(kind) or 0) < n: + atomic_write_json(store.root() / ISSUED, {**got, kind: n}) def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]: @@ -364,10 +387,13 @@ def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]: for _ in range(5): key = next_key(kind) try: - return store.write(kind, key, "", {**doc, "키": key}) + got = store.write(kind, key, "", {**doc, "키": key}) except store.StoreError as e: if e.status != 409 or not isinstance(e.detail, dict): raise + else: + _keep_issued(kind, key) + return got raise _bad("새 키를 못 잡음 — 다시 누름", 409) diff --git a/M02_MasterTemplete/M02_Library_Ask.py b/M02_MasterTemplete/M02_Library_Ask.py index ff3796196..480ce3a3a 100644 --- a/M02_MasterTemplete/M02_Library_Ask.py +++ b/M02_MasterTemplete/M02_Library_Ask.py @@ -2,22 +2,18 @@ 409 detail = `{같은것: [{키, 이름, 층, 주인}], 까닭}` → 다시 보냄 몸 `새로: true` = 그래도 새로 · `씀: <키>` = 그것을 씀(새로 안 만듦 · 그 키를 돌려줌 · 같은 내용이 아니면 다시 409). -지문 = `M02_Library_Same`(일위대가 SC · 단가산출 SK) · 구조물 조합(labor) = 같은 꼴 + 줄 수량 넣음. +지문 = `M02_Library_Same`(일위대가 SC · 단가산출 SK). 빈 문서(지문 없음) = 안 물음 · 같은 층 [복사] · 붙여넣기 = 안 물음(복사가 뜻). 부르는 쪽 = 지금 층(`store.at` 안). """ from __future__ import annotations -import json -from pathlib import Path from typing import Any -from common_util.common_util_derived_store import derived_key from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Library_Same as same from M02_MasterTemplete import M02_MasterTemplete_Store as store -from M02_MasterTemplete import M02_MasterTemplete_Tree as tree WHY = "같은 층에 같은 내용 문서가 있음 — 그것을 씀 · 그래도 새로" @@ -66,57 +62,6 @@ def ask( return _pick(found, [{**r, "층": at[0], "주인": at[1]} for r in rows], new, use) -def labor_finger(doc: Any) -> str | None: - """구조물 조합 일위대가 지문 — 담은로직 · 자재 · 단위 · 규격(줄 수량 넣음 · 차례 무시).""" - if not isinstance(doc, dict): - return None - s = same.Same() - mats = [same.norm(m) for m in doc.get("자재") or []] - body = { - "단위": same.unit(doc.get("단위")), - "담은로직": same._sorted([s._line(x, (), True) for x in doc.get("담은로직") or []]), - "자재": same._sorted(mats), - "규격": same.norm(doc.get("규격")), - } - body = {k: v for k, v in body.items() if v not in same.EMPTY} - if not body.get("담은로직") and not body.get("자재"): - return None - return f"SU:{derived_key(body)}" - - -def ask_item( - folder: Path, doc: dict[str, Any], new: bool = False, use: str | None = None -) -> dict[str, Any] | None: - """구조물 조합 항목(실무 호표 [구조물 조합으로]) — 씀 = `{key, 열, 이름}` | None(새로) · 409.""" - from M02_MasterTemplete import M02_Labor_Doc as labor - - try: - doc = {**labor.clean(doc), "규격": doc.get("규격")} # 저장될 꼴로 견줌 - except store.StoreError: - pass - want = labor_finger(doc) - if not want: - return None - at = refs.where(folder) - with store.at(folder): - table = store.read("table", store.STRUCTURE_TABLE)["문서"] - cols = {c["id"]: c for c in table.get("열") or [] if tree.is_item(c)} - found, rows = [], [] - for key, col in cols.items(): - try: - have = json.loads((Path(folder) / "labor" / f"{key}.json").read_bytes()) - except (OSError, ValueError): - continue - if labor_finger(have) == want: - name = " / ".join(tree.path_of(col)) - found.append(key) - rows.append({"키": key, "이름": name, "층": at[0], "주인": at[1]}) - got = _pick(found, rows, new, use) - if got is None: - return None - return {"key": got, "열": got, "이름": rows[found.index(got)]["이름"], "씀": True} - - def create(kind: str, doc: dict[str, Any], new: bool = False, use: str | None = None) -> dict: """[새로 만들기](733-2) — 같은 것 물음 뒤 `refs.create` · 씀 = `{이름: 그 키, 씀: true}`.""" got = ask(kind, doc, new, use) diff --git a/M02_MasterTemplete/M02_Machine_Hourly.py b/M02_MasterTemplete/M02_Machine_Hourly.py index c263059c6..1911f808c 100644 --- a/M02_MasterTemplete/M02_Machine_Hourly.py +++ b/M02_MasterTemplete/M02_Machine_Hourly.py @@ -235,7 +235,9 @@ def doc_sums(row: dict, logic: dict, index: Any) -> dict | None: return {"ok": True, "합": {k: float(got[k]) for k in (*cm.mf.COST_ITEMS, "계")}} -_BRIEF: dict[tuple, dict] = {} +#: {키: (색인, 줄)} — 색인이 바뀌면 비움 · 꺼낼 때 `is` 확인(옛 색인 주소 재사용 · 옛 값 막음 · 854-1) +_BRIEF: dict[str, tuple[Any, dict]] = {} +_BRIEF_OF: list[Any] = [None] def brief(keys: list[str]) -> list[dict[str, Any]]: @@ -246,11 +248,15 @@ def brief(keys: list[str]) -> list[dict[str, Any]]: from M02_MasterTemplete.M02_Item_Prices import to_json index, mf = store.loaded()[1], cm.mf - if len(_BRIEF) > 2000: # ponytail: 통째 비움 · 기계 수(655)의 세 배 + # ponytail: 통째 비움 · 기계 수(655)의 세 배 + if _BRIEF_OF[0] is not index or len(_BRIEF) > 2000: _BRIEF.clear() + _BRIEF_OF[0] = index out = [] for key in keys[:60]: - if (got := _BRIEF.get((id(index), key))) is None: + hit = _BRIEF.get(key) + got = hit[1] if hit and hit[0] is index else None + if got is None: try: row = (index.numbers.get("EQ") or {}).get(key) or index.get(key) except mf.FormulaError: @@ -272,7 +278,8 @@ def brief(keys: list[str]) -> list[dict[str, Any]]: ) hour = {"ok": True, "로직": logic["키"]} hour |= {k: float(sums[k]) for k in (*cm.mf.COST_ITEMS, "계")} - got = _BRIEF[(id(index), key)] = {**head, "값": to_json(row.get("값")), "시간당": hour} + got = {**head, "값": to_json(row.get("값")), "시간당": hour} + _BRIEF[key] = (index, got) out.append(got) return out diff --git a/M02_MasterTemplete/M02_Material_Own.py b/M02_MasterTemplete/M02_Material_Own.py index b5885a4cb..789962c58 100644 --- a/M02_MasterTemplete/M02_Material_Own.py +++ b/M02_MasterTemplete/M02_Material_Own.py @@ -49,14 +49,14 @@ def rows(folder: str | Path) -> list[dict[str, Any]]: def _last() -> int: - """모든 개인 층 파일의 가장 큰 PM 번호 — 사람 사이 번호 안 겹침.""" - found = [ - int(m.group(1)) - for path in layers.storage_root().glob(f"*/*/{layers.TEMPLATES_DIRNAME}/{FILE}") - for row in read(path.parent)["줄"] - if (m := KEY.match(str(row.get("키") or ""))) - ] - return max(found, default=0) + """모든 개인 층 파일의 가장 큰 PM 번호 — 사람 사이 번호 안 겹침 · 파일마다 `마지막`(발급한 가장 큰 번호)도 + 셈(지운 끝 번호를 다시 안 씀 · 854-1).""" + found = [0] + for path in layers.storage_root().glob(f"*/*/{layers.TEMPLATES_DIRNAME}/{FILE}"): + doc = read(path.parent) + found.append(int(doc.get("마지막") or 0)) + found += [int(m.group(1)) for r in doc["줄"] if (m := KEY.match(str(r.get("키") or "")))] + return max(found) def _text(v: Any) -> str: @@ -114,8 +114,10 @@ def add(folder: str | Path, body: dict[str, Any]) -> dict[str, Any]: with store._LOCK: doc = read(folder) row = _checked(body, doc["줄"]) - got = {"키": f"{PREFIX}{_last() + 1:06d}", **row} + n = _last() + 1 + got = {"키": f"{PREFIX}{n:06d}", **row} doc["줄"].append(got) + doc["마지막"] = n atomic_write_json(Path(folder) / FILE, doc) return got diff --git a/M02_MasterTemplete/M02_MyMachine.py b/M02_MasterTemplete/M02_MyMachine.py index bb5e0ef15..7778fc825 100644 --- a/M02_MasterTemplete/M02_MyMachine.py +++ b/M02_MasterTemplete/M02_MyMachine.py @@ -23,6 +23,8 @@ from __future__ import annotations import json import os import re +import threading +from collections.abc import Callable from contextvars import ContextVar from datetime import datetime from decimal import Decimal @@ -53,6 +55,11 @@ POWER, POWER_CREW, DIRECT_KEY = "GC001196", "GC001197", "GC001199" FUEL_POWER, FUEL_POWER_CREW = "GC001200", "GC001201" # 연료 + 전력(+ 조종원) — 경쟁사 구성(822-2b) +#: 번호 발급 · 고치기 · 지우기 한 번에 하나(854-1) — 자기 잠금(`store._LOCK` 안에서 불려도 교착 없게) +# ponytail: 프로세스 안 잠금 · 서버를 여럿 띄우면 파일 잠금으로 +_LOCK = threading.RLock() + + #: 단가산출 기계 창 초안(827-1 · `M02_MyMachine_Draft`) — 셈 꼴 줄 · 미리 셈 · 저장 한 요청 안만 `whole()` 위에 얹음 DRAFT: ContextVar[tuple] = ContextVar("내기계초안", default=()) @@ -106,6 +113,26 @@ def _put(row: dict) -> None: atomic_write_json(_dir() / f"{row['키']}.json", row) +def version(key: str) -> str: + """내 기계 한 대 판(파일 바이트 지문 · 없으면 빈 글).""" + path = _dir() / f"{key}.json" + return store.version_of(path.read_bytes()) if path.is_file() else "" + + +def add(build: Callable[[str], dict]) -> dict: + """새 번호 발급 + 쓰기를 한 잠금 안에서(854-1) — `_다음` 번호 · 이미 있는 파일 번호는 건너뜀(덮어쓰기 없음) · + `build(키)` = 저장 줄.""" + with _LOCK: + _move() + user, n = _user(), int(_load(_dir() / NEXT).get("다음") or 1) + while (_dir() / f"{PREFIX}{user}-{n:04d}.json").exists(): + n += 1 + row = build(f"{PREFIX}{user}-{n:04d}") + atomic_write_json(_dir() / NEXT, {"다음": n + 1}) # 번호 먼저 — 겹쳐 쓰지 않게 + _put(row) + return row + + def _read(folder: Path | None = None) -> dict[str, Any]: _move(folder) base = _dir(folder) @@ -420,9 +447,9 @@ def create_own(raw: Any = None, base: str | None = None) -> dict[str, Any]: return create(raw, base) -def update_own(key: str, raw: Any) -> dict[str, Any]: +def update_own(key: str, raw: Any, ver: str | None = None) -> dict[str, Any]: not_m01(raw, key) - return update(key, raw) + return update(key, raw, ver) def create(raw: Any = None, base: str | None = None) -> dict[str, Any]: @@ -430,37 +457,44 @@ def create(raw: Any = None, base: str | None = None) -> dict[str, Any]: seed = _seed(base) if base else {} raw = raw if isinstance(raw, dict) else {} body = clean({**seed, **raw, "값": {**seed.get("값", {}), **(raw.get("값") or {})}}) - data = _read() - key = f"{PREFIX}{_user()}-{data['다음']:04d}" when = _now() - row = {"키": key, "원문번호": f"{NO}{key}", "원문": "개인", "구분": "개인", "상세구분": body["이름"], - **body, "넣은날": when, "고친날": when, **({"본뜬": base} if base else {})} # fmt: skip - atomic_write_json(_dir() / NEXT, {"다음": data["다음"] + 1}) # 번호 먼저 — 겹쳐 쓰지 않게 - _put(row) + row = add(lambda key: {"키": key, "원문번호": f"{NO}{key}", "원문": "개인", "구분": "개인", + "상세구분": body["이름"], **body, "넣은날": when, "고친날": when, + **({"본뜬": base} if base else {})}) # fmt: skip return answer(row) -def update(key: str, raw: Any) -> dict[str, Any]: - _user() - data = _read() - old = next((r for r in data["줄"] if r["키"] == key), None) +def _old(key: str) -> dict: + old = next((r for r in rows() if r["키"] == key), None) if old is None: raise _bad(f"없는 내 기계 「{key}」", 404) + return old + + +def update(key: str, raw: Any, ver: str | None = None) -> dict[str, Any]: + """고침 — `ver`(화면이 연 판)가 지금 판과 다르면 409 {stale, 판} · None = 대조 없음(초안 저장 등 서버 길).""" + _user() + _old(key) body = clean(raw) - keep = {k: old[k] for k in ("키", "원문번호", "원문", "구분", "넣은날", "본뜬") if k in old} - row = {**keep, "상세구분": body["이름"], **body, "고친날": _now()} - _put(row) - return answer(row) + with _LOCK: + old = _old(key) + if ver is not None and (have := version(key)) != ver: + raise store.StoreError(409, {"stale": [key], "판": have}) + keep = {k: old[k] for k in ("키", "원문번호", "원문", "구분", "넣은날", "본뜬") if k in old} + row = {**keep, "상세구분": body["이름"], **body, "고친날": _now()} + _put(row) + now = version(key) # 잠금 안 판 — 뒤 고침이 끼어도 화면이 그 고침을 덮지 않게 + return {**answer(row), "판": now} def delete(key: str) -> dict[str, Any]: """지움 — 이미 만든 단가산출은 사본의 마지막 값 그대로(「지운키」).""" _user() - data = _read() - if not any(r["키"] == key for r in data["줄"]): - raise _bad(f"없는 내 기계 「{key}」", 404) + _old(key) used = uses().get(key, []) - (_dir() / f"{key}.json").unlink(missing_ok=True) + with _LOCK: + _old(key) + (_dir() / f"{key}.json").unlink(missing_ok=True) return {"지움": key, "쓰는곳": used} @@ -509,6 +543,7 @@ def same(name: Any, spec: Any, skip: str = "") -> list[dict]: def answer(row: dict, used: list | None = None) -> dict[str, Any]: out = { "줄": row, + "판": version(row["키"]), "시간당": hourly(engine(row), whole()), "같은이름": same(row["이름"], row["규격"], row["키"]), } diff --git a/M02_MasterTemplete/M02_MyMachine_Api.ts b/M02_MasterTemplete/M02_MyMachine_Api.ts index bd686defe..a7f10a983 100644 --- a/M02_MasterTemplete/M02_MyMachine_Api.ts +++ b/M02_MasterTemplete/M02_MyMachine_Api.ts @@ -48,6 +48,8 @@ export interface Use { export interface MyMachineOne { 줄: MyMachine; + /** 연 판(854-1) — 고치기 때 보냄 · 다르면 409(`StaleError`) */ + 판?: string; 시간당: MyHourly; 같은이름: { 키: string; 이름: string; 규격: string; 출처: string }[]; 쓰는곳?: Use[]; @@ -116,8 +118,9 @@ export const updateMyMachine = ( owner: string | null, k: string, body: MyMachineBody, + ver?: string, ): Promise => - call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body }) }); + call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body, 판: ver ?? null }) }); /** 저장 전 영향(848-5) — 바뀐 칸 · 이 층 쓰는 단가산출(그 칸을 따로 고쳐 둠?) · 쓰기 없음 */ export interface MyMachineImpact { diff --git a/M02_MasterTemplete/M02_MyMachine_Draft.py b/M02_MasterTemplete/M02_MyMachine_Draft.py index cfb51347b..f289820e1 100644 --- a/M02_MasterTemplete/M02_MyMachine_Draft.py +++ b/M02_MasterTemplete/M02_MyMachine_Draft.py @@ -140,15 +140,19 @@ def renew(copy: Any) -> Any: def _new(row: dict) -> str: """새 내 기계 파일(`mym.create` 와 같은 꼴 · 값은 초안 그대로 — 본뜬 값을 다시 섞지 않음).""" - data = mym._read() - key = f"{mym.PREFIX}{mym._user()}-{data['다음']:04d}" when = mym._now() - head = {"키": key, "원문번호": f"{mym.NO}{key}", "원문": "개인", "구분": "개인"} body = {k: row[k] for k in ("상세구분", *BODY, "단위", "출처") if k in row} tail = {"넣은날": when, "고친날": when, **({"본뜬": row["본뜬"]} if row.get("본뜬") else {})} - mym.atomic_write_json(mym._dir() / mym.NEXT, {"다음": data["다음"] + 1}) # 번호 먼저 - mym._put({**head, **body, **tail}) - return key + return mym.add( # 번호 발급 + 쓰기 한 잠금(854-1) + lambda key: { + "키": key, + "원문번호": f"{mym.NO}{key}", + "원문": "개인", + "구분": "개인", + **body, + **tail, + } # fmt: skip + )["키"] def saving(body: dict, inner: Callable[[dict], Any]) -> Any: diff --git a/M02_MasterTemplete/M02_MyMachine_Form.ts b/M02_MasterTemplete/M02_MyMachine_Form.ts index ac7b6d766..bdb9f5941 100644 --- a/M02_MasterTemplete/M02_MyMachine_Form.ts +++ b/M02_MasterTemplete/M02_MyMachine_Form.ts @@ -33,6 +33,7 @@ import { type MyMachineOne, type SimilarRow, } from "./M02_MyMachine_Api"; +import { StaleError } from "./M02_MasterTemplete_Api_Fetch"; import { confirmMyMachineImpact } from "./M02_MyMachine_Impact"; import { mt } from "./M02_MyMachine_Text"; import "./M02_MyMachine.css"; @@ -97,6 +98,7 @@ export async function mountMyMachineForm( opt.key ? readMyMachine(opt.owner, opt.key) : Promise.resolve(null), ]); const row = one?.줄; + let ver = one?.판; // 연 판(854-1) — 고치기 때 보냄 · 저장마다 새 판 let base: string | undefined; // 서버 `본뜬` const notice = el("div", { className: "m02-mymach__notice" }); const server = el("div", { className: "m02-mymach__server" }); @@ -173,16 +175,16 @@ export async function mountMyMachineForm( // 정본 고침 = 영향 보고 저장(848-5) if (opt.key && !(await confirmMyMachineImpact(opt.owner, opt.key, body))) return; const got = opt.key - ? await updateMyMachine(opt.owner, opt.key, body) + ? await updateMyMachine(opt.owner, opt.key, body, ver) : await createMyMachine(opt.owner, body, base); + ver = got.판; saved = true; opt.onDirty?.(false); showToast(mt("Saved"), "success"); opt.onSaved(got); } catch (error) { - notice.replaceChildren( - createText(error instanceof Error ? error.message : mt("Failed"), "error"), - ); + const why = error instanceof StaleError ? mt("Stale") : error instanceof Error ? error.message : mt("Failed"); // prettier-ignore + notice.replaceChildren(createText(why, "error")); } finally { saveBtn.disabled = m01Same; } diff --git a/M02_MasterTemplete/M02_MyMachine_Router.py b/M02_MasterTemplete/M02_MyMachine_Router.py index 31ee23219..75bc55a6a 100644 --- a/M02_MasterTemplete/M02_MyMachine_Router.py +++ b/M02_MasterTemplete/M02_MyMachine_Router.py @@ -2,7 +2,8 @@ GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) · POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) · -PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · +PUT `/{키}` 몸 {줄, 판?}(판 = 연 판 · 다르면 409 {stale, 판} · 854-1) · +POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}. 권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404). ⚠ 등록은 `main.py`(로그인만). @@ -30,6 +31,7 @@ class MachineBody(BaseModel): 본뜬: str | None = None 키: str | None = None # 초안 확인(827-1) — 고칠 내 기계 표지: str | None = None # 초안 확인(827-1) — 화면이 정한 표지(셈 기록 열쇠) + 판: str | None = None # 고치기 — 화면이 연 판(854-1 · 다르면 409) def _folder(session: Session, layer: str, owner: str | None, write: bool = False): @@ -78,7 +80,7 @@ def my_machine_update( owner: str | None = None, session: Session = Depends(verify_session), ): - return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄) + return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄, body.판) @router.post(PATH + "/{key}/impact") diff --git a/M02_MasterTemplete/M02_MyMachine_Text.ts b/M02_MasterTemplete/M02_MyMachine_Text.ts index df7e114e1..d79a93497 100644 --- a/M02_MasterTemplete/M02_MyMachine_Text.ts +++ b/M02_MasterTemplete/M02_MyMachine_Text.ts @@ -28,6 +28,7 @@ const TEXT = { Back: "목록", Close: "닫기", Failed: "못 함", + Stale: "그 사이 다른 곳에서 바뀜 — 목록에서 다시 열어 고침", Name_Needed: "이름 · 비어 있음", Same: "같은 이름 · 규격 있음 — {value}", Copied: "「{value}」 값을 복사 — 고친 뒤 [저장]", diff --git a/resources/master_data/로직_건설품셈_01장_적용기준.json b/resources/master_data/로직_건설품셈_01장_적용기준.json index d0973d0d7..11faa41db 100644 --- a/resources/master_data/로직_건설품셈_01장_적용기준.json +++ b/resources/master_data/로직_건설품셈_01장_적용기준.json @@ -282,8 +282,8 @@ "이름": "건설폐기물 발생량 — 건설 공통 1-5-4", "결과단위": "ton", "출처": "건설품셈 공통 1-5-4 2", - "부품": { "갈래": "계수식" }, "개정": [2011, 2014, 2017, 2020], + "부품": { "갈래": "계수식" }, "소유": "공용", "비고": "발생량 = 면적 × 단위면적당 발생량(TON/㎡) × (1 + 증가율 ÷ 100) · 증가율 = 폐콘크리트류만(주③ 파일 시공 15% · 20% 이내 · 주④ 세륜 시설 개소당 3% 이내 — 설계자가 넣음 · 0 = 증가 없음) · 원문 칸 「-」 = 줄 없음(멈춤) · 건축물 해체는 설계도서 산출 우선(원문 2) · 주⑤ 현장 여건 조정", "시험입력": { "공사": "신축", "구조": "철근콘크리트조", "폐기물": "폐콘크리트류", "면적": 1000, "증가율": 0 }, diff --git a/resources/master_data/로직_건설품셈_08장_건설기계.json b/resources/master_data/로직_건설품셈_08장_건설기계.json index 4c290bd3d..7ec5817a1 100644 --- a/resources/master_data/로직_건설품셈_08장_건설기계.json +++ b/resources/master_data/로직_건설품셈_08장_건설기계.json @@ -1543,8 +1543,8 @@ "이름": "불도저 시간당 작업량 — 건설 공통 8-2-1", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-1", - "부품": { "갈래": "작업량 틀", "기종": ["불도저"] }, "개정": [2025], + "부품": { "갈래": "작업량 틀", "기종": ["불도저"] }, "소유": "공용", "비고": "q = q° × e · cm = L/V1 + L/V2 + t · 타이어형 속도 표는 규격이 수(15 · 28 · 33) · 직접 칸 q0입력 · e입력 · V1입력 · V2입력 0 = 표(851-1)", "시험입력": { @@ -1642,8 +1642,8 @@ "이름": "리퍼(유압식) 시간당 파쇄량 — 건설 공통 8-2-2", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-2", - "부품": { "갈래": "작업량 틀", "기종": ["유압식 리퍼"] }, "개정": [2025], + "부품": { "갈래": "작업량 틀", "기종": ["유압식 리퍼"] }, "소유": "공용", "비고": "cm = 0.05ℓ + 0.25(원문 산정식) · 탄성파속도는 작업효율 표에 있는 값(규격별) · 직접 칸 An입력 0 = 표(851-1)", "시험입력": { "규격": 20, "발톱수": "3본", "작업거리": 30, "암질": "연질", "탄성파속도": 500, "f": 1, "E입력": 0, "An입력": 0 }, @@ -1686,8 +1686,8 @@ "이름": "굴착기 시간당 작업량 — 건설 공통 8-2-3", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-3", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "버킷용량" }, "개정": [2004, 2007, 2009, 2025], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "버킷용량" }, "소유": "공용", "비고": "Q = 3,600·q·K·f·E/cm · 협소현장 = 주⑦ 상하수도관로부설 등 별도 E 표 · 싸이클입력 0 = 표(규격 · 선회각도) · K입력 0 = 표(버킷조건)", "시험입력": { @@ -1817,8 +1817,8 @@ "이름": "로더 운전시간당 작업량 — 건설 공통 8-2-5", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-5", - "부품": { "갈래": "작업량 틀", "기종": ["로더"], "규격": "버킷용량" }, "개정": [2007, 2020], + "부품": { "갈래": "작업량 틀", "기종": ["로더"], "규격": "버킷용량" }, "소유": "공용", "비고": "cm = m·ℓ + t1 + t2 · K 표 둘(산적상태 적재 · 자연상태·기타 적재) · 주행거리 0 = 표준 8m · 직접 칸 m입력 · t1입력 · K입력 0 = 표(851-1)", "시험입력": { @@ -2006,8 +2006,8 @@ "이름": "모터 그레이더 1시간당 작업면적 — 건설 공통 8-2-7", "결과단위": "㎡/hr", "출처": "건설품셈 공통 8-2-7", - "부품": { "갈래": "작업량 틀", "기종": ["모터그레이더"] }, "개정": [2025], + "부품": { "갈래": "작업량 틀", "기종": ["모터그레이더"] }, "소유": "공용", "비고": "cm 가 = 0.06×D/V1 + t · 나 = 0.06×(D/V1 + D/V2) + 2t · 속도가 여럿이면(P1·Cm1 + P2·Cm2 …) 설계자가 나눠 셈 · 직접 칸 V1입력 · V2입력 · t입력 0 = 표(851-1)", "시험입력": { @@ -2081,8 +2081,8 @@ "이름": "모터 그레이더 1시간당 작업토량 — 건설 공통 8-2-7", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-7", - "부품": { "갈래": "작업량 틀", "기종": ["모터그레이더"] }, "개정": [2025], + "부품": { "갈래": "작업량 틀", "기종": ["모터그레이더"] }, "소유": "공용", "비고": "cm 가 = 0.06×D/V1 + t · 나 = 0.06×(D/V1 + D/V2) + 2t · 속도가 여럿이면(P1·Cm1 + P2·Cm2 …) 설계자가 나눠 셈 · 직접 칸 V1입력 · V2입력 · t입력 · l입력 0 = 표(851-1)", "시험입력": { @@ -2167,8 +2167,8 @@ "이름": "덤프트럭 1시간당 작업량 — 건설 공통 8-2-8", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-8", - "부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"], "규격": "적재용량" }, "개정": [2017], + "부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"], "규격": "적재용량" }, "소유": "공용", "비고": "q = T/γt × L · cm = t1 + … + t6 · 적재기계 t1 = cms·n/(60·Es) · n = q/(qs·k)(2자리) · 인력 t1 = 적재시간(분/㎥) × q · t2 = 거리/속도 × 60(분) · t2 = 구간 셋(구간 2 · 3 거리 0 = 안 씀) · 속도 · t2 ~ t5 직접 칸 0 = 표", "시험입력": { @@ -2390,8 +2390,8 @@ "이름": "롤러 시간당 다짐토량 — 건설 공통 8-2-9", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-9", - "부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] }, "개정": [2004, 2017, 2025], + "부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] }, "소유": "공용", "비고": "Q = 1,000·V·W·D·E·f/N · 소요다짐횟수 · 두께는 2 표(CC000063) 참고 입력 · 직접 칸 W입력 · V입력 0 = 표(851-1)", "시험입력": { @@ -2467,8 +2467,8 @@ "이름": "롤러 시간당 다짐면적 — 건설 공통 8-2-9", "결과단위": "㎡/hr", "출처": "건설품셈 공통 8-2-9", - "부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] }, "개정": [2004, 2017, 2025], + "부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] }, "소유": "공용", "비고": "A = 1,000·V·W·E·1/N · 직접 칸 W입력 · V입력 0 = 표(851-1)", "시험입력": { "다짐기계": "타이어롤러", "규격": "8∼15", "다짐층": "노체, 축제, 노상", "다짐횟수": 4, "E공종": "노체, 축제, 노상", "E기계": "불도저", "현장조건": "보통", "E입력": 0, "W입력": 0, "V입력": 0 }, @@ -2745,8 +2745,8 @@ "이름": "압쇄기(콘크리트 소할용) 시간당 작업량 — 건설 공통 8-2-14", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-14", - "부품": { "갈래": "작업량 틀", "기종": ["압쇄기"] }, "개정": [2004], + "부품": { "갈래": "작업량 틀", "기종": ["압쇄기"] }, "소유": "공용", "비고": "Q = q × E", "시험입력": { "E입력": 0 }, @@ -2785,8 +2785,8 @@ "이름": "골재세척설비 시간당 작업량 — 건설 공통 8-2-16", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-16", - "부품": { "갈래": "작업량 틀", "기종": ["골재세척설비"] }, "개정": [2001], + "부품": { "갈래": "작업량 틀", "기종": ["골재세척설비"] }, "소유": "공용", "비고": "Q = q × E", "시험입력": { "E입력": 0 }, @@ -2825,8 +2825,8 @@ "이름": "콘크리트 배치플랜트(강제 혼합식) 시간당 작업량 — 건설 공통 8-2-18", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-18", - "부품": { "갈래": "작업량 틀", "기종": ["콘크리트 배치플랜트"] }, "개정": [2000, 2002, 2011], + "부품": { "갈래": "작업량 틀", "기종": ["콘크리트 배치플랜트"] }, "소유": "공용", "비고": "Q = 60·q·E/cm · 터널 숏크리트 매우 불량은 E입력 0.40(주②) · 직접 칸 q입력 · cm입력 0 = 표(851-1)", "시험입력": { "규격": "60㎥/h (96㎾)", "슬럼프": "5㎝이상", "공종": "사방", "현장조건": "보통", "싸이클": "표준", "E입력": 0, "q입력": 0, "cm입력": 0 }, @@ -3359,8 +3359,8 @@ "이름": "진동파일 해머 파일 1본당 시공시간 — H파일 — 건설 공통 8-2-24", "결과단위": "분/본", "출처": "건설품셈 공통 8-2-24", - "부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머"] }, "개정": [1996, 2026], + "부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머"] }, "소유": "공용", "비고": "Tc = (Ts+Tb)/F · Tb = r×ℓ×k · r = (r1ℓ1 + r2ℓ2)/(ℓ1+ℓ2) · F = F0 + (f1+f2+f3+f4) · 직접 칸 Ts입력 · F0입력 · k입력 · r1입력 · r2입력 0 = 표(851-1)", "시험입력": { @@ -3451,8 +3451,8 @@ "이름": "진동파일 해머 파일 1본당 시공시간 — 강널말뚝 — 건설 공통 8-2-24", "결과단위": "분/본", "출처": "건설품셈 공통 8-2-24", - "부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머"] }, "개정": [1996, 2026], + "부품": { "갈래": "작업량 틀", "기종": ["진동파일 해머"] }, "소유": "공용", "비고": "Tc = {(0.75+γ·Nmax)·ℓ+α}·K/F · K = 원문 항타 · 인발 두 줄에 걸친 한 칸(항타 줄 값) · 인발 F0 = 원문 「항발」 칸 · 직접 칸 α입력 · K입력 · γ입력 · F0입력 0 = 표(851-1)", "시험입력": { "종류": "III-Type (400×150×13)", "작업": "항타", "해머": 45, "근입길이": 10, "Nmax": 20, "f1": 0, "f2": 0, "f3": 0, "α입력": 0, "K입력": 0, "γ입력": 0, "F0입력": 0 }, @@ -3652,8 +3652,8 @@ "이름": "펌프식 준설선 1시간당 준설능력 — 건설 공통 8-2-29", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-29", - "부품": { "갈래": "작업량 틀", "기종": ["펌프 준설선"] }, "개정": [2010, 2011], + "부품": { "갈래": "작업량 틀", "기종": ["펌프 준설선"] }, "소유": "공용", "비고": "Q = q·bo·E/746 · E = E1×E2×E3×E4 · bo = 디젤 공칭 × 0.8 · 터빈 × 0.9 · 직접 칸 E1입력 · E2입력 · E3입력 · E4입력 0 = 표(851-1)", "시험입력": { @@ -3757,8 +3757,8 @@ "이름": "그래브 준설선 1시간당 준설량 — 건설 공통 8-2-30", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-30", - "부품": { "갈래": "작업량 틀", "기종": ["그래브 준설선"] }, "개정": [2010, 2011], + "부품": { "갈래": "작업량 틀", "기종": ["그래브 준설선"] }, "소유": "공용", "비고": "Q = 3,600·q·k·f·E/cm · E = E1×E2 · 수심 10m 기준 1m 증감마다 2초 증감 · 표의 괄호 값 = 쇄암 · 발파후 준설 · 직접 칸 싸이클입력 · E1입력 · E2입력 0 = 표(851-1)", "시험입력": { @@ -3847,8 +3847,8 @@ "이름": "쇄암선(중추식) 시간당 작업능력 — 건설 공통 8-2-31", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-31", - "부품": { "갈래": "작업량 틀", "기종": [] }, "개정": [2011], + "부품": { "갈래": "작업량 틀", "기종": [] }, "소유": "공용", "비고": "Q = 60·d·S·E/(t + n/p) · 직접 칸 S입력 · n입력 0 = 표(851-1)", "시험입력": { "분류": "암반", "상태": "연질", "중추중량": 30, "E": 0.7, "S입력": 0, "n입력": 0 }, @@ -3888,8 +3888,8 @@ "이름": "이동식 임목파쇄기 시간당 파쇄능력 — 건설 공통 8-2-32", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-32", - "부품": { "갈래": "작업량 틀", "기종": ["이동식 임목파쇄기"] }, "개정": [2007, 2011], + "부품": { "갈래": "작업량 틀", "기종": ["이동식 임목파쇄기"] }, "소유": "공용", "비고": "93.25㎾ Q = 6.0 · 354.35∼402.84㎾ Q = q·K·S·E · 직접 칸 K입력 · S입력 · E입력 0 = 표(851-1)", "시험입력": { "규격": "354.35㎾", "스크린": "75㎜", "작업조건": "보통", "K입력": 0, "S입력": 0, "E입력": 0 }, @@ -3924,8 +3924,8 @@ "이름": "하천골재채취선 시간당 준설량 — 건설 공통 8-2-33", "결과단위": "㎥/hr", "출처": "건설품셈 공통 8-2-33", - "부품": { "갈래": "작업량 틀", "기종": ["하천골재채취선"] }, "개정": [2005], + "부품": { "갈래": "작업량 틀", "기종": ["하천골재채취선"] }, "소유": "공용", "비고": "Q = q·b·E/746 · 직접 칸 q입력 · E입력 0 = 표(851-1)", "시험입력": { "분류": "모래질토사", "상태": "연질", "배송거리": 300, "출력": 746, "조건": "보통", "유속": "보통", "q입력": 0, "E입력": 0 }, diff --git a/resources/master_data/로직_산림품셈_02장_소요재료_및_기계손료.json b/resources/master_data/로직_산림품셈_02장_소요재료_및_기계손료.json index aad693f84..098576e02 100644 --- a/resources/master_data/로직_산림품셈_02장_소요재료_및_기계손료.json +++ b/resources/master_data/로직_산림품셈_02장_소요재료_및_기계손료.json @@ -12,12 +12,10 @@ "이름": "체인톱 시간당 기계경비", "결과단위": "원/시간", "출처": "산림품셈 2-1-1 · 2-2-1", + "개정": [2026], "부품": { "갈래": "기계경비식" }, - "개정": [ - 2026 - ], "소유": "공용", "비고": "1일 1대당(2-1-1 주연료 · 체인오일 · 잡품 · 2-2-1 손료계수) × 시간환산(1일 8시간) · 체인톱 가격 = 재료 「동력체인톱」 · 체인오일 = 재료 「작동유」(GF000076 체인톱 줄과 같음) · 가져온 시간당 「엔진톱」 줄을 잇는 식", "입력": [ diff --git a/resources/master_data/로직_산림품셈_03장_작업장_관리.json b/resources/master_data/로직_산림품셈_03장_작업장_관리.json index cd236bc63..3ae53faa9 100644 --- a/resources/master_data/로직_산림품셈_03장_작업장_관리.json +++ b/resources/master_data/로직_산림품셈_03장_작업장_관리.json @@ -83,8 +83,8 @@ "이름": "임산물 운반로 신설 굴착기 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 3-4-2 1", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "비고": "해석: 원문 단가산출 예시의 값(q 0.2 · K 0.7 · f 0.71 · E 0.45 · Cm 18)을 표준 값으로 씀", "입력": [], diff --git a/resources/master_data/로직_산림품셈_05장_식재_및_녹화.json b/resources/master_data/로직_산림품셈_05장_식재_및_녹화.json index 5e459a422..6a9558445 100644 --- a/resources/master_data/로직_산림품셈_05장_식재_및_녹화.json +++ b/resources/master_data/로직_산림품셈_05장_식재_및_녹화.json @@ -1199,8 +1199,8 @@ "이름": "복사이식 굴착기 시간당 작업량(Q1)", "결과단위": "㎥/hr", "출처": "산림품셈 5-29 주④", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "비고": "해석: q = 주③ 굴착기 용량 1.0㎥ · 주⑤ Q=Q1×T 는 단위가 안 맞아(㎥/시간 × m) 넣지 않음", "입력": [], diff --git a/resources/master_data/로직_산림품셈_09장_토공.json b/resources/master_data/로직_산림품셈_09장_토공.json index f857d963f..e65a8d6f8 100644 --- a/resources/master_data/로직_산림품셈_09장_토공.json +++ b/resources/master_data/로직_산림품셈_09장_토공.json @@ -46,8 +46,8 @@ "이름": "토사깍기(기계 · 굴착기 0.7㎥) 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-3-2", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "비고": "E 원문 「0.55∼0.45」 — 설계자 입력 · f 는 주④ 0.77", "입력": [{ "이름": "E입력", "범위": [0.45, 0.55], "출처": "산림품셈 9-3-2" }], @@ -170,8 +170,8 @@ "이름": "암절취 집토(굴착기 0.7㎥) 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-4-2", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "비고": "f 원문 「1/1.40」 그대로 계산", "입력": [], @@ -323,8 +323,8 @@ "이름": "발파암 집토(굴착기 0.7㎥) 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-5-3", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "비고": "f 원문 「1/1.625」 그대로 계산", "입력": [], @@ -424,8 +424,8 @@ "이름": "콘크리트 깨기 집토(굴착기 0.7㎥) 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-7-1 주⑥", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "입력": [], "중간": [ @@ -928,8 +928,8 @@ "이름": "측구터파기 토사 굴착기 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-12-1", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "입력": [], "중간": [ @@ -2286,8 +2286,8 @@ "이름": "되메우기 굴착기 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-14-1", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "입력": [], "중간": [ @@ -2339,8 +2339,8 @@ "이름": "다짐(플레이트콤펙터) 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-14-2", - "부품": { "갈래": "작업량 틀", "기종": ["플레이트 콤팩터"] }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["플레이트 콤팩터"] }, "소유": "공용", "비고": "돈 로직 GF000249", "입력": [], @@ -2381,8 +2381,8 @@ "이름": "표토제거 답(畓)구간(굴착기 0.7㎥) 시간당 작업량", "결과단위": "㎡/hr", "출처": "산림품셈 9-15-1", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "비고": "T(표토두께) 설계자 입력 · Q=Q1/T · f 원문 「1/1.30」 그대로 계산", "입력": [{ "이름": "T", "단위": "m", "출처": "산림품셈 9-15-1 주②" }], @@ -2426,8 +2426,8 @@ "이름": "표토제거 답(畓)외구간(불도저 19ton) 시간당 작업량", "결과단위": "㎡/hr", "출처": "산림품셈 9-15-2", - "부품": { "갈래": "작업량 틀", "기종": ["불도저"] }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["불도저"] }, "소유": "공용", "비고": "돈 로직 GF000250 · f 원문 「1/1.3」 그대로 계산", "입력": [], @@ -2486,8 +2486,8 @@ "이름": "노체포설 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-16-1 주②", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"] }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"] }, "소유": "공용", "입력": [], "중간": [ @@ -2533,8 +2533,8 @@ "이름": "노체다짐 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-16-2 주②", - "부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"] }, "소유": "공용", "입력": [], "중간": [ @@ -2605,8 +2605,8 @@ "이름": "비다짐(정지 · 불도저 19ton) 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-17-2", - "부품": { "갈래": "작업량 틀", "기종": ["불도저"] }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["불도저"] }, "소유": "공용", "비고": "돈 로직 GF000251 · E 원문 「(0.55-0.1)」 · f 원문 「1/1.3」 그대로 계산", "입력": [], @@ -2660,8 +2660,8 @@ "이름": "층따기(굴착기 0.7㎥) 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-18", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "비고": "f 원문 「1/1.3」 그대로 계산", "입력": [], @@ -2907,8 +2907,8 @@ "이름": "섞기(굴착기 0.7㎥) 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 9-22", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "비고": "f 원문 「1/1.25」 그대로 계산 · 주③ Q=Q1*T 는 단위가 맞지 않아 Q1 까지만", "입력": [], diff --git a/resources/master_data/로직_산림품셈_10장_자재․장비_운반.json b/resources/master_data/로직_산림품셈_10장_자재․장비_운반.json index 12fb4d679..0a2505b42 100644 --- a/resources/master_data/로직_산림품셈_10장_자재․장비_운반.json +++ b/resources/master_data/로직_산림품셈_10장_자재․장비_운반.json @@ -12,8 +12,8 @@ "이름": "골재운반 덤프트럭 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 10-3-1 주", - "부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"] }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["덤프트럭"] }, "소유": "공용", "비고": "원문은 식만(Q=60×qt×f×E/㎝) — qt · f · E · ㎝ 값 없음 · 설계자 입력", "입력": [{ "이름": "qt", "단위": "㎥" }, { "이름": "f", "단위": "" }, { "이름": "E", "단위": "" }, { "이름": "Cm", "단위": "분" }], @@ -519,8 +519,8 @@ "이름": "4륜구동 1톤 덤프트럭 시간당 기계경비", "결과단위": "원/시간", "출처": "산림품셈 10-9", - "부품": { "갈래": "기계경비식" }, "개정": [2026], + "부품": { "갈래": "기계경비식" }, "소유": "공용", "비고": "손료·운전경비는 2.5톤(0602-0025) · 주연료 2.5톤의 80% · 중기가격 조달청 등재가격 = 기계표 EQ000655 덤프트럭(4륜구동) 1ton 가격 · 작업량(건설품셈 덤프트럭 식)·10-9-1 운반량 쓰는 식 요소 없음 · 주② 제잡비 비율 원문에 없음", "입력": [ @@ -679,8 +679,8 @@ "이름": "불도저 운반 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 10-11 주②", - "부품": { "갈래": "작업량 틀", "기종": ["불도저"] }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["불도저"] }, "소유": "공용", "비고": "해석: 파쇄암·발파암의 E 는 「암석」 줄", "입력": [ diff --git a/resources/master_data/로직_산림품셈_11장_가설.json b/resources/master_data/로직_산림품셈_11장_가설.json index 02482673b..750ffc1db 100644 --- a/resources/master_data/로직_산림품셈_11장_가설.json +++ b/resources/master_data/로직_산림품셈_11장_가설.json @@ -93,8 +93,8 @@ "이름": "쇄석·혼합석 부설 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 11-4 주①", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "비고": "해석: 원문 식 「3600×90×k×f×E/㎝」의 90 을 q(버킷용량)로 봄", "입력": [], diff --git a/resources/master_data/로직_산림품셈_13장_구조물.json b/resources/master_data/로직_산림품셈_13장_구조물.json index be198f642..3b3542d8e 100644 --- a/resources/master_data/로직_산림품셈_13장_구조물.json +++ b/resources/master_data/로직_산림품셈_13장_구조물.json @@ -1367,8 +1367,8 @@ "이름": "토양개량제 부설 굴착기 시간당 작업량", "결과단위": "㎥/hr", "출처": "산림품셈 13-13-2", - "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "개정": [2026], + "부품": { "갈래": "작업량 틀", "기종": ["굴착기"], "규격": "q" }, "소유": "공용", "비고": "식은 9장 같은 꼴 표(9-12-1 등)와 같이 Q=3600×q×k×f×E/㎝", "입력": [], diff --git a/resources/tester/fixtures/m01_791_1_logic_fingerprint.json b/resources/tester/fixtures/m01_791_1_logic_fingerprint.json index cb1ff516e..d49958944 100644 --- a/resources/tester/fixtures/m01_791_1_logic_fingerprint.json +++ b/resources/tester/fixtures/m01_791_1_logic_fingerprint.json @@ -1,44 +1,44 @@ { "결과": { - "GC000001": "7d4315a2e57faccf", - "GC000002": "80490ffd46bdae1b", + "GC000001": "9573d5036c46ff0b", + "GC000002": "3ad162f7c68b7d9a", "GC000003": "fc0976937690096a", - "GC000004": "5cd8f6b509cb63ba", - "GC000005": "8f1f86153b65923d", - "GC000006": "ddf5033d1bd2509a", - "GC000007": "553403dda3ab31a0", + "GC000004": "981aa7aa2dfbb8ed", + "GC000005": "b6060c5ccd3be406", + "GC000006": "f8c207ef4dd72229", + "GC000007": "0b3786ee99c8ca3d", "GC000008": "0ac6b48f9d954b72", "GC000009": "8d6c81186a43cde2", - "GC000010": "a088272376704a38", + "GC000010": "a46a2892d7048ff0", "GC000011": "5e5a0a95b476657f", "GC000012": "9cf6be2ec277e6a2", "GC000013": "c89b367028599f4c", - "GC000014": "87958bd41c33d96c", + "GC000014": "ca249c82a72bba64", "GC000015": "08f6644a6182218a", "GC000016": "bfb81b345bd8a6a0", "GC000017": "6cad0db0ed40263c", "GC000018": "bfb81b345bd8a6a0", - "GC000019": "0a7e43c3d979c6b1", + "GC000019": "5c668047e489d924", "GC000020": "d42ef536820ee847", "GC000021": "de367438e0c57c50", "GC000022": "f63fc47171b4d9d7", "GC000023": "da46b5ea55791653", - "GC000024": "507fbe4f1a6aeb5c", + "GC000024": "79fe7976c8d962d3", "GC000025": "8fb514ac60852f63", "GC000026": "885231b92e1ec4f6", - "GC000027": "c2fab8d107e4f459", + "GC000027": "4fccbee71d410d86", "GC000028": "6c237aa8d841c9f4", - "GC000029": "1a4b933ba0915dcd", + "GC000029": "c0ea335d63354f1f", "GC000030": "b1f93779c53c10b5", - "GC000031": "19fb2b3f060a403f", - "GC000032": "8d12915b31886478", + "GC000031": "3701ec26ae5afb35", + "GC000032": "3bfdcc2b5f943f06", "GC000033": "40db920dd4a5196b", - "GC000034": "a3741cec025edb17", - "GC000035": "b71369fe75a4b524", + "GC000034": "9632c57e8629500d", + "GC000035": "e4e3b13007c1f746", "GC000036": "daadaa89de50d0fb", - "GC000037": "fc1a463c1eb95bdf", - "GC000038": "ee6573b583d06de6", - "GC000039": "be616cde585b00d3", + "GC000037": "becda7dcffe11be1", + "GC000038": "1fe92bf692d777e0", + "GC000039": "b9543ab4dddbcf09", "GC000040": "e7301c8f26bd3e89", "GC000041": "f43bf1c4efa68ff8", "GC000042": "ab81c28667d6ca6d", @@ -52,315 +52,315 @@ "GC000050": "20be2e907b6199c5", "GC000051": "8975480ffbc241a9", "GC000052": "b62987293805c837", - "GC000053": "44b7e04a7ca59616", - "GC000054": "8c9a8ec4605bb950", - "GC000055": "817f5ce8e0657df1", + "GC000053": "362ae78e277cd358", + "GC000054": "7a47881059127e15", + "GC000055": "21bd8a8d08ce080f", "GC000056": "3f785c308f782466", "GC000057": "00ed3f6ccc42d576", "GC000058": "e46c97809efb7ae7", "GC000059": "e46c97809efb7ae7", "GC000060": "5bb952313838ecd7", "GC000061": "cd28fc332349f88d", - "GC000062": "62cc79d4cf67aef3", - "GC000063": "afbc888625061ac0", - "GC000064": "76fdd68435511ac1", - "GC000065": "e4e8d81dd320304d", + "GC000062": "a20545485e0acf57", + "GC000063": "1e4c95b47d8d669e", + "GC000064": "d918d2561ba648ec", + "GC000065": "78b27f468bdb8365", "GC000066": "c8af6791ccf6b573", - "GC000067": "94915f55811ac00d", - "GC000068": "84aa511954797da9", + "GC000067": "97d7be47096bb3a6", + "GC000068": "780e337f13f349d4", "GC000069": "3651f131d15e7285", "GC000070": "f351693f4068a226", "GC000071": "ebd014c62661585e", - "GC000072": "435bcae8429e2c02", - "GC000073": "e23a64b95f41ecec", - "GC000074": "84b75ca4a1b8795e", + "GC000072": "012bcae41ef7f5f6", + "GC000073": "d18f50f3582950f1", + "GC000074": "62e879c9ce3b5f95", "GC000075": "4efd1e289f112c69", "GC000076": "3f942af62ac7ab1f", - "GC000077": "45a97187a616dcc5", + "GC000077": "7af9f6c6d1ce19d0", "GC000078": "dc46b5900d098ecd", "GC000079": "9b1b96115595f4f8", - "GC000080": "04d79a59a861c2a8", - "GC000081": "ffee855c85eb2eb5", - "GC000082": "207ba2aad6d7e897", + "GC000080": "0d4860fe223d0aff", + "GC000081": "1a92870ed61d3295", + "GC000082": "7b34fcf959c74c14", "GC000083": "69e7634523137c9e", - "GC000084": "457f1f82a889f107", - "GC000085": "788737f4c20ca2af", - "GC000086": "8462d2f751e6b96f", - "GC000087": "e9a85bc4ee941c66", - "GC000088": "21a08ba083032c59", - "GC000089": "07164e3ad3a1b366", - "GC000090": "3e57391df5b0c39f", - "GC000091": "525b1d44d0f29909", - "GC000092": "dbcd8db9e280d8d2", - "GC000093": "8558a524c82b70b6", - "GC000094": "41b50de14cc61fb0", - "GC000095": "2733ce5f163adea7", - "GC000096": "03fda01e29f3c071", - "GC000097": "2f9c3b00f1a5ee47", - "GC000098": "9cfe01fec9cb8c42", - "GC000099": "eb10e55dc952f897", - "GC000100": "b8f43a31bff36b76", - "GC000101": "3421450503e00246", - "GC000102": "8d5767cc0256f0eb", - "GC000103": "c75814c9b633394e", - "GC000104": "9569c65648ea532b", + "GC000084": "3c7bce3283af0200", + "GC000085": "5414a3044e63fb74", + "GC000086": "6909ece723a1751f", + "GC000087": "f7af1d2d154ecc7f", + "GC000088": "5ae1d447689b04df", + "GC000089": "a1b023b136256cea", + "GC000090": "08bfa141c65d5a40", + "GC000091": "048622465155db45", + "GC000092": "17c18c4fe904de58", + "GC000093": "d80e66d2983ee51a", + "GC000094": "9bf4fc0b125826ea", + "GC000095": "e638ccb6bc874af7", + "GC000096": "a5798af069eda6bc", + "GC000097": "7ddbd47dab4594e8", + "GC000098": "4031c34366688fb3", + "GC000099": "a10b3556c65536c4", + "GC000100": "da281a27184e0e93", + "GC000101": "0f2cd415fde77334", + "GC000102": "9c91108ad8853d19", + "GC000103": "32ac5732862cae19", + "GC000104": "d735bd150120b3d6", "GC000105": "9a4adb7e2192f33f", - "GC000106": "b902ac2249efbf8c", - "GC000107": "b741aec2a3b01ae1", - "GC000108": "ebe7317e11b671e4", - "GC000109": "f5d34edfb423809f", - "GC000110": "58e3550db4ef72da", - "GC000111": "6a618afca1cf9380", - "GC000112": "b2734007ec3b6a2d", - "GC000113": "76dcf488dadb26af", + "GC000106": "5416c771462ff775", + "GC000107": "4818c7b5923dbb7a", + "GC000108": "56f8ca6e6e990554", + "GC000109": "af4a692a09a52a3d", + "GC000110": "1deae9b62f350ce2", + "GC000111": "d7687652f1ccb814", + "GC000112": "b77a7ac6552c273b", + "GC000113": "03a740c3b9d250a8", "GC000114": "9e31c47b4dcbb6cc", - "GC000115": "03d9429e03ad9c6e", - "GC000116": "3353091a5eb7cfaa", + "GC000115": "d2abb94e68c42b45", + "GC000116": "d54eefd08bc8909c", "GC000117": "a3d6cc9fb0dfef85", - "GC000118": "9ea0717f80e9306b", - "GC000119": "919627582b73efff", - "GC000120": "d77f4deb4d339132", - "GC000121": "dbc6833625d331e4", - "GC000122": "eee3a6a9dc3d77b8", + "GC000118": "f36a7ffd4a7e818a", + "GC000119": "ddae7aca0c4d563f", + "GC000120": "339beab5678b3f4c", + "GC000121": "e51e4baf6e9dbf25", + "GC000122": "895af7b3e96f2493", "GC000123": "27931deb9e861cbb", "GC000124": "1f2793f478b52093", - "GC000125": "ad8bb518824c9166", - "GC000126": "efe6e42c00c8a277", + "GC000125": "0d05b58510ca67c0", + "GC000126": "38a3aa225ba8c0a1", "GC000127": "22bfa31ad4846a1a", - "GC000128": "3d4a3b6c7c69a3d5", - "GC000129": "3d1e7fae7d93468c", - "GC000130": "f7eac9082c989025", - "GC000131": "054e716eb9e8f6fd", + "GC000128": "a8e8a50d178e238a", + "GC000129": "f4e85bd06d58d23c", + "GC000130": "dff0837d41e1b056", + "GC000131": "665d01ba9495c59e", "GC000132": "f63f83a9b3775fda", "GC000133": "891824d21d03cc64", "GC000134": "f63f83a9b3775fda", "GC000135": "891824d21d03cc64", "GC000136": "42b086acd9faf73c", - "GC000137": "10188216c2bdcd54", - "GC000138": "56e7a7446cab2155", - "GC000139": "3d0aa6a2ad7552bd", - "GC000140": "0b50a7e5f0bcd592", - "GC000141": "e9da8f094d8e8d90", - "GC000142": "7850caecb40cdc94", + "GC000137": "6080ea835873dbca", + "GC000138": "764d7808b9780f7e", + "GC000139": "03a104e46175de2e", + "GC000140": "ac683a030884dfd8", + "GC000141": "f345bce0a2bdbd88", + "GC000142": "0c89cd35b6f75665", "GC000143": "5d53c30e20b325f5", - "GC000144": "9c94b3edeec51f4d", - "GC000145": "450d8a92f438e197", + "GC000144": "54e553f6c5597254", + "GC000145": "4941b9d25d1807f9", "GC000146": "9da178d350502807", "GC000147": "dece099c43814b73", "GC000148": "7d460fb358a1b230", "GC000149": "63a1228dea21e66e", "GC000150": "0b2401e37bf584d9", "GC000151": "7c76662f24c9fc09", - "GC000152": "975beb2e1bfbe36d", - "GC000153": "1b8aed605cf79438", - "GC000154": "26731a6c0b2e18b5", - "GC000155": "dabfd6e2cfd6f2c1", - "GC000156": "03f8b8b63aceb103", - "GC000157": "b6348d67357ecc3a", - "GC000158": "3b8aa5a3b4f77ec9", + "GC000152": "c94f8c58a1f9caaf", + "GC000153": "60c499e28b542ecc", + "GC000154": "783fbae897f36674", + "GC000155": "964e098a5d49ab46", + "GC000156": "dc60b838d105c89f", + "GC000157": "58888f193b017dfc", + "GC000158": "fe489d911afedbfb", "GC000159": "baf8cf68043d30e4", "GC000160": "fb859a7d6686343d", "GC000161": "b2d8ed6a1da732e2", - "GC000162": "87cab124a3eecac3", - "GC000163": "caba1a165786097e", - "GC000164": "f10b1d5f1c100fc0", - "GC000165": "81bbf22a88e858c7", - "GC000166": "f59e061172144650", - "GC000167": "f79b56b66e2e1ed9", - "GC000168": "17706e4e780e9aed", - "GC000169": "1b7bef5161eaa578", + "GC000162": "c1d36136f0951fcb", + "GC000163": "fd0506e0dd17ee1d", + "GC000164": "52ce93f4f3c71524", + "GC000165": "bb2e958ea3ecd853", + "GC000166": "58b45adf7938b086", + "GC000167": "8c080387d5ef8666", + "GC000168": "72c7060876631cbd", + "GC000169": "6835b89d48c554f4", "GC000170": "2c827c8f8239f566", "GC000171": "57461898c49242e8", "GC000172": "73755963d5a9a355", "GC000173": "de42eb0f8107f234", - "GC000174": "67715fda44e114f8", - "GC000175": "615383a5a8b4c2ce", - "GC000176": "ad627b606f64d0ab", - "GC000177": "c48c7849eae1fb1c", + "GC000174": "875dd4d07eef21a0", + "GC000175": "a015ab98bd9be3a4", + "GC000176": "33bfca939474c173", + "GC000177": "26dc8b0146a2e7d3", "GC000178": "a2d4bca71a7244af", - "GC000179": "aa0273537429d949", - "GC000180": "c42fae8bc78ff89f", - "GC000181": "dedf6c30302ac3ac", - "GC000182": "f8dd24c0ebbe771a", - "GC000183": "c3322fc50ae93fdc", - "GC000184": "cebe9c91474ac374", - "GC000185": "2623e56d0c7fe9c2", - "GC000186": "ea70b7c4fd7e980a", - "GC000187": "e16ba1d2451c06dd", - "GC000188": "1af7de5322af4ac4", - "GC000189": "20acc8af9d883979", - "GC000190": "0557f98fa18bf5bc", - "GC000191": "ce3afd445e92a458", - "GC000192": "2925bfc60a52b5c3", - "GC000193": "e0b9082d6f39c479", - "GC000194": "ea70b7c4fd7e980a", - "GC000195": "b01f7d344a35f8a9", - "GC000196": "6407822d4207652f", - "GC000197": "98edb70b616372f4", - "GC000198": "341ac37370b92438", + "GC000179": "7283b0f0103655ce", + "GC000180": "2367cc815c05438c", + "GC000181": "f0d00bce287ddb99", + "GC000182": "46841bc3e7e68b3f", + "GC000183": "d15aecf1c2543586", + "GC000184": "15344df6238dbbcd", + "GC000185": "434c7b496087a34a", + "GC000186": "f103c2e6e1d913b9", + "GC000187": "747575b3e340d0e9", + "GC000188": "31eecad512e38827", + "GC000189": "b996360b74307fac", + "GC000190": "4f418840facdc9b6", + "GC000191": "0a78937b54e43893", + "GC000192": "82b5778d6bf8d859", + "GC000193": "d173d4b41ecd796b", + "GC000194": "f103c2e6e1d913b9", + "GC000195": "0ffb06b29e4a01e3", + "GC000196": "75d3a422ea865350", + "GC000197": "03f15c0c6757818c", + "GC000198": "d277eaf25389dcb7", "GC000199": "13c737b4f4a26735", "GC000200": "3f981f6df1d36185", - "GC000201": "35950594d9c84c5e", + "GC000201": "b12326e3a4437933", "GC000202": "cccd52da5310ead1", - "GC000203": "a87ed8ad678ae521", + "GC000203": "b4a1c504d685dd4b", "GC000204": "5fa98634166a788b", "GC000205": "5fbd636612132145", "GC000206": "720bf63c8ab22044", - "GC000207": "4a259801b941a05a", + "GC000207": "2d164568396b690d", "GC000208": "e7f9cc5e0a734a4f", - "GC000209": "e199487f8d011e60", + "GC000209": "9e91e3b721a50a5f", "GC000210": "55d80d2222df5649", - "GC000211": "ff37a68cd5d56c82", + "GC000211": "12243790a7c7ac25", "GC000212": "ee602e699f5b7b51", - "GC000213": "e82dc2b5b576eff4", + "GC000213": "96dda02be788a987", "GC000214": "406666ef873ece33", - "GC000215": "f066baac792f1dee", + "GC000215": "f6dfd2f18e852ea7", "GC000216": "f2413394a7755175", - "GC000217": "09a1df7ea42252d1", - "GC000218": "6dd1f8e8f9d2cbe3", + "GC000217": "99df6918d1aed5d1", + "GC000218": "39fa38b85b83d045", "GC000219": "776c529d1584955f", "GC000220": "514b2746ef1abc91", "GC000221": "67f0c8d90182ac51", "GC000222": "5a0e91ff710663cf", - "GC000223": "b2d52429bc550767", - "GC000224": "2f9ac2a2130d294f", + "GC000223": "f205f711a8309df2", + "GC000224": "14623865d06351e2", "GC000225": "137b699f0b4da17a", "GC000226": "b926069644f1a2d8", "GC000227": "7cc66a21bc56756f", "GC000228": "d1cd922abccecf30", - "GC000229": "40e3b3d655e974b2", + "GC000229": "ce3df94930a91bfc", "GC000230": "3cbf3a1a3dc1243f", "GC000231": "8a8d8f48684eea6b", "GC000232": "00959c359c472c35", - "GC000233": "c88e2b47e90b6022", + "GC000233": "8fec6c4ec84e2a6b", "GC000234": "e120c71ff285238f", - "GC000235": "afd2823828bd2eac", + "GC000235": "f13f1bb12e7c8ca7", "GC000236": "87fbb46fa763a532", "GC000237": "0b6f08eb7d7c4ab3", "GC000238": "2a8985fccd78ef60", "GC000239": "87a1bc2be76c9753", "GC000240": "2535307dfaabf2a1", - "GC000241": "a47ae052f428616e", - "GC000242": "771e04764d87aaea", - "GC000243": "4f6a1c69d5b02d95", - "GC000244": "9490d5de415640e5", - "GC000245": "b10bd1061122917d", + "GC000241": "948af87f98fd91b4", + "GC000242": "50070755bc3a65b3", + "GC000243": "4348456feccfdc28", + "GC000244": "a201c921cd233856", + "GC000245": "7a88bc3bc44b36df", "GC000246": "62692a8527c5d47d", - "GC000247": "0ddd22193e16d629", - "GC000248": "36b35a081681749f", - "GC000249": "187ec67d3a365397", - "GC000250": "939340b132920eb7", - "GC000251": "51a9c36ab1ea7538", - "GC000252": "efb4b94d4f23442b", - "GC000253": "99d137e5144ed348", - "GC000254": "73e103b7a51b161d", - "GC000255": "4fd7d55e792a2332", - "GC000256": "f662402af22cc884", - "GC000257": "3b9fd26679cdf702", + "GC000247": "e48aef2b68e94bb2", + "GC000248": "7ad16382d284e626", + "GC000249": "4ba9b8aab8d745c4", + "GC000250": "8a96e75365bf1226", + "GC000251": "5e88831f32c6b5f6", + "GC000252": "a9777dca1da89c2f", + "GC000253": "7fe2bed9670b4b30", + "GC000254": "d788430163fd2085", + "GC000255": "8956f00f08b9c341", + "GC000256": "120562e3db63cf5e", + "GC000257": "a3805dc780adf2eb", "GC000258": "69b4f229a9a686c1", - "GC000259": "a0e45ba570f5a1db", - "GC000260": "e91cd0a97ed72649", - "GC000261": "dad84d307a423562", - "GC000262": "539dddb2c4adb75a", - "GC000263": "4e1d2a34b4456c69", - "GC000264": "edd7d1b501dc016a", - "GC000265": "93a676d703990def", + "GC000259": "0ce756297974370f", + "GC000260": "cf5b405bb433c28d", + "GC000261": "108c921ba570a267", + "GC000262": "d20c84445d95f45b", + "GC000263": "7003f5f8266bfa86", + "GC000264": "60651e44949f4324", + "GC000265": "dd96c01715b65a4a", "GC000266": "f73c91fdf63b7b2c", - "GC000267": "47be327e7d9b0859", - "GC000268": "47a774da333f01bb", - "GC000269": "21fcc5f6cc6a5189", - "GC000270": "d316c138ac531c5b", - "GC000271": "7ef79cb4d13247e4", + "GC000267": "f0cf8b7965dadd21", + "GC000268": "847dc7ca0728a2da", + "GC000269": "4e627e77f45e9bb3", + "GC000270": "6e949e1bd9dee402", + "GC000271": "516fae9a4846cbaf", "GC000272": "85d8c11839035bad", "GC000273": "9d452fb25423a1fc", "GC000274": "88a19fbd041d094d", - "GC000275": "a355da735a5bd80d", - "GC000276": "f756a060dfde9022", + "GC000275": "e4a6d12309465e86", + "GC000276": "77331e5ce36c6685", "GC000277": "6f33339fcb3d9efd", - "GC000278": "5b3132c093bbfa5e", - "GC000279": "c4bac2b47a52b7e4", - "GC000280": "d9d571c7e80d10aa", - "GC000281": "799574151cd2de72", - "GC000282": "b6ab5d54a6148f4f", - "GC000283": "bc2ddd008d1aaf12", - "GC000284": "4eff859d8640732c", - "GC000285": "bd87c96d47e35a5b", - "GC000286": "8c2152ca9c5233ec", + "GC000278": "82c87a889585bb54", + "GC000279": "1e6c22f4ac53e9f0", + "GC000280": "d4be40f9bda68852", + "GC000281": "b8321a9622112d2b", + "GC000282": "ab3b7d7626d993fe", + "GC000283": "62b71902737a942b", + "GC000284": "602317187edd00ce", + "GC000285": "53a2a61ff86c32f0", + "GC000286": "fd09859056ca5655", "GC000287": "f66887911776131a", - "GC000288": "9247fbc3ee26a174", - "GC000289": "40c3837dccd21820", - "GC000290": "04948cbd574e2b25", - "GC000291": "9e447f72494aee1b", - "GC000292": "1e768fb4b88f1c77", - "GC000293": "9ed4f59e59aaae9d", - "GC000294": "d2deaaac3ee9da22", - "GC000295": "2c7c68432ab641b4", - "GC000296": "86a0a7fa4021356a", + "GC000288": "660d4112a385a296", + "GC000289": "0ab7c1ac986b5e7c", + "GC000290": "00fe7b9c7f151fbf", + "GC000291": "3aa076e16f02c75a", + "GC000292": "c37b64f4f37cd87b", + "GC000293": "8437e5373b81824d", + "GC000294": "4133f1c121cc753f", + "GC000295": "90a3124b5e07d9a5", + "GC000296": "1b63112736e52c23", "GC000297": "d7b58bc42f8593a9", - "GC000298": "c3c9a98069c5bfc9", - "GC000299": "ca4d6d768fd6fce5", - "GC000300": "336ca09285614dc9", + "GC000298": "b6c4a3ed13a02e9c", + "GC000299": "d6e7c6eb40ef1313", + "GC000300": "bb673f4e884a57dc", "GC000301": "fafce48c96b8b04e", "GC000302": "b6f1683c81bce129", - "GC000303": "fb89190822ff2102", - "GC000304": "824d01f6179f216f", - "GC000305": "98a266dee8372229", - "GC000306": "6f387f6390e125ea", - "GC000307": "73406e9a4ce7e279", - "GC000308": "495cdb5291b84dad", - "GC000309": "c34ecad3b1f8c3c5", + "GC000303": "67aa164df7ea89b8", + "GC000304": "814036d1630c3b47", + "GC000305": "ef7d835c3ce47354", + "GC000306": "eda635b00837221e", + "GC000307": "8f94d8692fed0001", + "GC000308": "06cac1bb1bcae55d", + "GC000309": "10a4d0bb6eacf88c", "GC000310": "2117bc583e2656d4", "GC000311": "0d3c9e12647ea427", "GC000312": "c63de29972a053a5", "GC000313": "a7998138cdad5b80", "GC000314": "21170a8334edb82b", "GC000315": "57a5421f1e1e57c9", - "GC000316": "1a91a87dfcb20911", - "GC000317": "50633e6604d59291", - "GC000318": "a91369072c45e272", - "GC000319": "6430dcfa8416d547", - "GC000320": "5b7a4afc49c66b45", - "GC000321": "a6006dffe54f848f", - "GC000322": "6b594f44971b14f9", - "GC000323": "298514ef118c812d", - "GC000324": "7a318b9916465377", - "GC000325": "2a1e30dbc05fc94a", - "GC000326": "0351c694db3718e0", - "GC000327": "5f98de3ba837824d", - "GC000328": "f7506c2e6f25358e", + "GC000316": "44a9ab4b29d68cf4", + "GC000317": "0e7e8aeafe53a787", + "GC000318": "3044cec62b173823", + "GC000319": "2ab56c3dd7eabe78", + "GC000320": "d7b98b73041b4795", + "GC000321": "b61b43041b2b8deb", + "GC000322": "73b476c64fb5710e", + "GC000323": "859a11dbc50e62e8", + "GC000324": "85db7bbd66d03b91", + "GC000325": "d93240d143520b90", + "GC000326": "829db6be70d841a3", + "GC000327": "8006b6dda8abbd0f", + "GC000328": "c677ab9dc3a5a17a", "GC000329": "56c90d8705a72fac", - "GC000330": "ff3e3873fb3457f1", - "GC000331": "9e37a24848816b9f", - "GC000332": "7961e0927b34b819", - "GC000333": "a0fdb96ec8156889", + "GC000330": "9aa68a1382230191", + "GC000331": "a15330b02c96c9ae", + "GC000332": "c44c44f29e70f448", + "GC000333": "3e68966ea6e7ac5f", "GC000334": "3107fa69146f3da3", "GC000335": "319d6de01353d757", - "GC000336": "6e443bfe87ba8ac9", - "GC000337": "b7e5896a41b00bea", - "GC000338": "28f8eee137f98700", - "GC000339": "337307b2ae1f789a", - "GC000340": "f1b795b868397bc1", - "GC000341": "d9ab39537a34a974", - "GC000342": "c7f20ccf4d71a1c1", - "GC000343": "5ebf8b2c6d13ce01", + "GC000336": "eb18bdeb4f33a460", + "GC000337": "3011aca34fb9b9cf", + "GC000338": "731b93b26185eb46", + "GC000339": "14c86692fab5f0a5", + "GC000340": "0e56a66d03d1328b", + "GC000341": "996487eba82d007a", + "GC000342": "b7ff852b2178aace", + "GC000343": "9d874b03c60c28ba", "GC000344": "8fe4b98db736e9dc", - "GC000345": "abd241840ebf9a26", + "GC000345": "e894b25e1dffdbcf", "GC000346": "b7172c64f854a9de", - "GC000347": "9a9ea8fee2da6d1d", + "GC000347": "93b30cacd9550704", "GC000348": "2b465f9b3d89a61e", "GC000349": "22e1354d8ac05109", - "GC000350": "d7d9c87aca729e38", - "GC000351": "098d7657740db30a", + "GC000350": "009a78177c81ec24", + "GC000351": "dd6eed29332f0df9", "GC000352": "feea563364e0f392", "GC000353": "be3d3a8a77e8e626", - "GC000354": "bd0ea2fc069a451c", - "GC000355": "41fbf3c04dad9b63", - "GC000356": "335597af08c18bc2", + "GC000354": "d7ee6483e13d6008", + "GC000355": "cb0ec37a9127ead6", + "GC000356": "5f8a508c38140875", "GC000357": "0b85bf1d665b8e03", - "GC000358": "90fbc25ac6c477ca", - "GC000359": "267cfc953ddb41fa", - "GC000360": "8443e47377de0f0b", - "GC000361": "7014dee182a1baed", + "GC000358": "7c513a7ecacd4c61", + "GC000359": "6422589ad6c85b24", + "GC000360": "9b03aca872ccf549", + "GC000361": "8febcad5bbeec2d7", "GC000362": "989d3804642fd56f", "GC000363": "d200b4eaa58e9679", "GC000364": "b224a93c307ab5b0", @@ -368,25 +368,25 @@ "GC000366": "04cb78fbfe85be9a", "GC000367": "4ddf6ed74deec53a", "GC000368": "230b9fe5910cbb8f", - "GC000369": "dc2cfd4131611fe0", + "GC000369": "80303bd2510f6786", "GC000370": "5448c808d97d5f2b", "GC000371": "6de8664db4a2236d", "GC000372": "80151d97116612dc", "GC000373": "6fac06fe457c121f", - "GC000374": "01fc967be9e3a68f", - "GC000375": "ae8e8a4912a78d00", + "GC000374": "f0618397483d4e2c", + "GC000375": "b72134b65f317ac7", "GC000376": "01264a6bb28b620a", "GC000377": "c5435aeda2be8ffc", "GC000378": "d8e635b2b9a551e0", - "GC000379": "cee6034c827932ee", - "GC000380": "3c2d047a59dc7784", - "GC000381": "7a295c780d74dc35", - "GC000382": "127d37b6139aff57", + "GC000379": "e0a68bcba832d140", + "GC000380": "3650fdf7636eb614", + "GC000381": "7d716342f827c46f", + "GC000382": "83768e5e3952c563", "GC000383": "4d93e13d6da83a46", - "GC000384": "18e29c55cb864b98", + "GC000384": "6cb8f7198a32ee62", "GC000385": "2ffe431115673986", "GC000386": "ba669eeae64dfcba", - "GC000387": "f22ae0be142f2f19", + "GC000387": "9ca0dde9eea66a7e", "GC000388": "5cf3c3ad8ee2818f", "GC000389": "90998b7f0e6611db", "GC000390": "a31228850286eca3", @@ -396,44 +396,44 @@ "GC000394": "118f0e72b5d291cb", "GC000395": "e28762f8b2fbddf1", "GC000396": "b9e9dac144853b7e", - "GC000397": "a7e8fd68ef585dd3", + "GC000397": "8cb31e5293b15207", "GC000398": "4c68b2677eeecc96", - "GC000399": "110f49c7e393a5cc", - "GC000400": "7993645a30dc0098", + "GC000399": "41f33d3faad678bd", + "GC000400": "586e2f8694e5feb4", "GC000401": "34cb1623751c932d", "GC000402": "5fa3793801797b51", - "GC000403": "aaf14fc52fb059ad", - "GC000404": "b28e965576dca519", - "GC000405": "f8d2aa99a40d28d5", + "GC000403": "e10108a09f0f9303", + "GC000404": "8a53fc56189e2e96", + "GC000405": "7ce5ccc075d9422e", "GC000406": "702921e69417e8a8", - "GC000407": "95395e343a036fb2", - "GC000408": "d999302c8fc5faf5", - "GC000409": "266483ded4357b94", - "GC000410": "00ed3325b5381cb7", + "GC000407": "616d16ba276ad90a", + "GC000408": "cb0853f2133cf0cb", + "GC000409": "c3576ccb7b7d4e61", + "GC000410": "56ef4c96e30f8284", "GC000411": "3dceccd1da0ed7f6", - "GC000412": "cae7b6d438256f4d", - "GC000413": "4529ca47c5a24540", - "GC000414": "bf6bc2f190980995", - "GC000415": "6f29f03e5b520ac4", + "GC000412": "a93243f743ce0035", + "GC000413": "e3c7be401b60eef0", + "GC000414": "954cb6ee808ab9c4", + "GC000415": "ae5682faec8305e9", "GC000416": "be3d0741dc3dd97f", "GC000417": "25c962d659335495", "GC000418": "364e0c78fed800c7", "GC000419": "258553d537f9e5b2", "GC000420": "59d808e04cb3ab0e", - "GC000421": "e0f695205ba2183e", + "GC000421": "42426b66b736e983", "GC000422": "ef487e4050204cc5", "GC000423": "4179607e274f6411", "GC000424": "4179607e274f6411", "GC000425": "15bed50901c1019c", "GC000426": "4bc609ef025f197d", - "GC000427": "5b63ac3d8db2586e", - "GC000428": "4b3f07c0fc31d19d", - "GC000429": "93377cf125c035ec", + "GC000427": "c443eb5accdb323a", + "GC000428": "01e2ea319ca708b8", + "GC000429": "aa20675598c3cbe8", "GC000430": "bbdef53fce7994ba", - "GC000431": "a350e17865b6b2b3", - "GC000432": "a6d4d0c489afcc54", + "GC000431": "30abfa45445ef6e1", + "GC000432": "6e133cac962bb0f4", "GC000433": "74b583b5b7479b3e", - "GC000434": "7f0817261c451b9d", + "GC000434": "ee23713c1e56746e", "GC000435": "78bf4fb8024385d3", "GC000436": "6f73a1a31b678d08", "GC000437": "6cbb755b5a022229", @@ -441,14 +441,14 @@ "GC000439": "9339b9b7ea138d9e", "GC000440": "625a48be3718d6c0", "GC000441": "f5135178b946544e", - "GC000442": "668eb8f20b67846f", - "GC000443": "631fb22b91a01cfc", - "GC000444": "eb00fca3240bc15f", - "GC000445": "f33ca1ffbfbdf4d5", - "GC000446": "b9421e104677733b", - "GC000447": "c03c96e86e4d1047", - "GC000448": "c1be5c13b879bb16", - "GC000449": "9ac17e95ceb6ec13", + "GC000442": "2fe0b0c049b74d3a", + "GC000443": "5013439f539bc438", + "GC000444": "77729c86f94e6f02", + "GC000445": "e4aa9b868c173b54", + "GC000446": "4f31ea1421527381", + "GC000447": "d715e559570bd8c9", + "GC000448": "7cb1ee3e4d8c3925", + "GC000449": "be5f22e6bf5b6d11", "GC000450": "438cb694e3223dbc", "GC000451": "f3502c5d8982a8ab", "GC000452": "32b9a39992d166e5", @@ -558,35 +558,35 @@ "GC000556": "196033b96083bca5", "GC000557": "ce0c0a8758e8624c", "GC000558": "bb53ec117abbfc34", - "GC000559": "d3f1952d0e45683a", - "GC000560": "a75c377290ab5688", - "GC000561": "5392b86533f4cfc7", + "GC000559": "9a49d2a9ae57fc8f", + "GC000560": "4b994fedf9cb3f30", + "GC000561": "722ae690eb6f6954", "GC000562": "0e24bb979692f61f", "GC000563": "f4910cc8080bd692", "GC000564": "ea83ebd5c7107bcc", - "GC000565": "7dffc4bf6a3c7ba0", + "GC000565": "7f11abf101db170a", "GC000566": "cc6a969af98b4845", "GC000567": "35352260168021ce", - "GC000568": "29e326c17821f705", + "GC000568": "7c9e1b08f8c3d23e", "GC000569": "ef042784eea44e37", "GC000570": "39e0e8f417a930b4", - "GC000571": "041e8e3df3ba5ba3", + "GC000571": "d700f49e60f16a5c", "GC000572": "c039eab0555281e2", "GC000573": "8653e0949bb42b97", "GC000574": "37b40ba2d7463d6f", - "GC000575": "5d3854cd54310827", - "GC000576": "642a954c647addb5", - "GC000577": "4c8005e1d5d3d905", - "GC000578": "fd50edf1bf4e57e4", + "GC000575": "0588e20f11237fbb", + "GC000576": "d3334f3038e64dce", + "GC000577": "05bbba90def5c91e", + "GC000578": "b8e3dd4b00e5f284", "GC000579": "3e0d3862f0cb7394", - "GC000580": "b6a064c4c077efa9", - "GC000581": "7783ee039ad4f206", - "GC000582": "5a6d83c0a8277104", + "GC000580": "2fbb1f7883b8bb4e", + "GC000581": "1eace5e637497f7a", + "GC000582": "d0e600552f5bce9e", "GC000583": "de23757b451580b6", "GC000584": "11c9e93e5c5ccc3b", - "GC000585": "055b5cb03f031a3b", - "GC000586": "32a452dfd347a9a4", - "GC000587": "b4e3e76ebea9cd7d", + "GC000585": "d64940de781c251e", + "GC000586": "c04cc395b7e47b9c", + "GC000587": "9bb1655f75a437e7", "GC000588": "2a81166e6ac05e79", "GC000589": "3559f4cf5a8c27a9", "GC000590": "ae1d56b089222e28", @@ -596,14 +596,14 @@ "GC000594": "8ca3771b774f5527", "GC000595": "5805d9712fc1b88b", "GC000596": "d801ec3c4c4558d8", - "GC000597": "ea5ffdd62442cafc", + "GC000597": "a2b680bdf2131f34", "GC000598": "21dbeb540efa3aca", "GC000599": "65a886732073c963", "GC000600": "8e30e4c6daa74174", "GC000601": "9d274397d7added3", "GC000602": "e838cde23071877a", - "GC000603": "d2ec5ccd539e681b", - "GC000604": "3f4f94bbf4d6bfa3", + "GC000603": "d9f8939b2d6627e2", + "GC000604": "f95b4893cd029924", "GC000605": "455a68d92e8c0cea", "GC000606": "744dda0cf8b27a92", "GC000607": "4211a4cff262f4b3", @@ -611,24 +611,24 @@ "GC000609": "5de979fbc41c8ad3", "GC000610": "0de017446ba99b5f", "GC000611": "6dcfe61b32546835", - "GC000612": "9d1ef73d1b2dc3a5", - "GC000613": "ddd76ef5b957052a", + "GC000612": "cbb054b874f2b735", + "GC000613": "f16cda3e110c3514", "GC000614": "7d54163a76e70199", - "GC000615": "ac83b0652db0ea1c", - "GC000616": "19e2ff79d46ea40d", + "GC000615": "cd72b5287bb25495", + "GC000616": "6fb0fb3c7f1a5388", "GC000617": "08002aaf584c5066", - "GC000618": "cd13166e23575ab8", + "GC000618": "d995785f4b5069c0", "GC000619": "03c5ad96b55964c7", - "GC000620": "aa379d523ced0677", - "GC000621": "0cdbf1c79de28a18", - "GC000622": "a493adad5c0bb11f", - "GC000623": "2c840d248fa72294", + "GC000620": "15add5a1cc758d96", + "GC000621": "a92aa7870fa37a2c", + "GC000622": "0b22541f0a93cf57", + "GC000623": "aaa60d260014311b", "GC000624": "3269d67dc11b8b66", - "GC000625": "935e740ec4257979", - "GC000626": "43161d07d2a1f3a1", - "GC000627": "f2e7f01d715e56d1", - "GC000628": "a1ddec0580f01aeb", - "GC000629": "925f6d7520a6f1e9", + "GC000625": "e3bae183a0927fd3", + "GC000626": "7483258d04d5e914", + "GC000627": "e5f92607f490ca4c", + "GC000628": "d4dfeb7f460d3478", + "GC000629": "12508d1ddc63ad60", "GC000630": "c521bd33447ebc36", "GC000631": "420c25ace98a26fb", "GC000632": "1940510ca50d3021", @@ -636,26 +636,26 @@ "GC000634": "9941e6ed207d158f", "GC000635": "61d1b415f4fb3da9", "GC000636": "4f2d9777d81db2ea", - "GC000637": "9b41cffafe8454c5", - "GC000638": "fac4ee1c170e5e27", - "GC000639": "23568dba95325e52", + "GC000637": "44581c82e86d60f5", + "GC000638": "63d509da0193de79", + "GC000639": "c636f61db1762bfc", "GC000640": "9f6ef3108725d0a1", "GC000641": "2555fffc0fef8280", "GC000642": "b44f3ad4b3eb9de7", "GC000643": "dc195f1f9f071c41", "GC000644": "7789ab3505915d32", "GC000645": "0bd97d55926cc7f2", - "GC000646": "666b4fbbcbe824d9", - "GC000647": "741e03d1aced25f5", - "GC000648": "2979142019a724dc", + "GC000646": "af2264719131a3a6", + "GC000647": "6f5ee25c2b630e02", + "GC000648": "31a0da22b84dbf20", "GC000649": "53651582b9a5d821", "GC000650": "91f3d2955bc7abf2", "GC000651": "fa0b44a00d0c46fe", "GC000652": "96089b3ac28f22bd", "GC000653": "5f54e3268457bb3a", "GC000654": "0c598ee6a25210a2", - "GC000655": "0f1c88126863925a", - "GC000656": "527b8e1e4a604e5a", + "GC000655": "b8ecba5cb49656dc", + "GC000656": "d84927d94606e596", "GC000657": "c686a29299f10c17", "GC000658": "34eda6c57f33d324", "GC000659": "885301c41dceb88b", @@ -664,29 +664,29 @@ "GC000662": "4c6d832cc29cb16a", "GC000663": "87b81aa7bb73ce71", "GC000664": "cfd8049292bd8144", - "GC000665": "df1f5269b2dbb1ab", - "GC000666": "3bdc025f3213baca", - "GC000667": "80f2a471f3491dd9", + "GC000665": "bd0ced8cde88c271", + "GC000666": "822aa24c7f88830c", + "GC000667": "4bd2ecdedab6d401", "GC000668": "5f3e8d8a280c10ae", "GC000669": "00c52adaf4fc2212", - "GC000670": "fa693328cc5b2a5c", - "GC000671": "e57766f1c2f9fb13", + "GC000670": "c238617f0399867c", + "GC000671": "bfc8b3b006db7147", "GC000672": "ae04be8d8173b997", "GC000673": "2e284ee5363741c6", "GC000674": "948713f482396bbf", "GC000675": "0ddd18f561f0d7ca", "GC000676": "532e261b29d25757", - "GC000677": "17c86455c4813e62", + "GC000677": "483705fb2abb98b0", "GC000678": "fc4b05f4d5f1d1c0", "GC000679": "bbefcb9d31664efc", "GC000680": "49ac6e0a8f8c6984", "GC000681": "8835a121da94796f", "GC000682": "53cf95205f5fae46", "GC000683": "d18c3124134dfa73", - "GC000684": "dedb790d4e1d0e72", - "GC000685": "def3b08dc883d3f1", + "GC000684": "84c967b10583c10f", + "GC000685": "6401509f413e38ed", "GC000686": "565a08b083b4483a", - "GC000687": "112c990eaabaac64", + "GC000687": "fdf32af46fce0e1a", "GC000688": "ff679e877394399b", "GC000689": "dd0d32d7ae8e05d5", "GC000690": "0809478f5b38e662", @@ -720,9 +720,9 @@ "GC000718": "7fbf536a731b0652", "GC000719": "99f8e88a6e04cc18", "GC000720": "2aaa7b6ca31e2a8b", - "GC000721": "776ed06b4c669392", + "GC000721": "c9e990ae6cde2192", "GC000722": "cd08f27610741e3f", - "GC000723": "30de68b46d9670a0", + "GC000723": "1fff1f0a4d3f5041", "GC000724": "3537d39e3ca02293", "GC000725": "bc45cee23fb0c36f", "GC000726": "e84a4a1846b92165", @@ -751,7 +751,7 @@ "GC000749": "1c335b0d8b638119", "GC000750": "9a490d207a52ef11", "GC000751": "e93238a820365be0", - "GC000752": "e4c82dd5125e8052", + "GC000752": "7c83a9b30d83a11c", "GC000753": "759f1518a0a5550d", "GC000754": "b6120f24a1c7ff13", "GC000755": "e69201ee13e2d17d", @@ -810,7 +810,7 @@ "GC000808": "234bc33ae078efac", "GC000809": "091f29b4519bab9e", "GC000810": "e111263e61e9f08a", - "GC000811": "0014cfeca71fc7f1", + "GC000811": "e9f9b06136383dc0", "GC000812": "8d7e25f4f5956412", "GC000813": "039c20813b4963de", "GC000814": "960aaf37506fe2ae", @@ -821,7 +821,7 @@ "GC000819": "fd1db564b3634e9a", "GC000820": "59778499d3aedde1", "GC000821": "4ad29411f1e07961", - "GC000822": "61a775ac96448087", + "GC000822": "c0c4236cec696cd6", "GC000823": "4a84ea2059e6d1cd", "GC000824": "b22ed260dfb7c91f", "GC000825": "bf539279ebd0ed9d", @@ -853,7 +853,7 @@ "GC000851": "b39881ea25a692f7", "GC000852": "21cda18200ca6153", "GC000853": "bcfc1475534ed380", - "GC000854": "faf5f80411f815c2", + "GC000854": "398e5340efc7c6f0", "GC000855": "00276e84b6afc49e", "GC000856": "dfa2dbfc64c00ab0", "GC000857": "7062f238bf119e3c", @@ -881,71 +881,71 @@ "GC000883": "04a5c5921e82601d", "GC000884": "b43354b03d8b8c3a", "GC000885": "d111179a1d12cee8", - "GC000886": "e3c6eaaca33cfb5f", - "GC000887": "4b7aba05e78691c9", - "GC000888": "05f24ee28b535f07", - "GC000889": "c519e74ffe52b7a8", - "GC000890": "cccd70af3605b067", - "GC000891": "43c365a04d302c91", + "GC000886": "f69d2444f9369727", + "GC000887": "6cf823ab2968433f", + "GC000888": "03900195fb11af51", + "GC000889": "e5ee13179d3663c7", + "GC000890": "0f12ef198df07ab5", + "GC000891": "b66271b61c330db3", "GC000892": "bb65cba2d9553b79", - "GC000893": "6fce1e70bd923096", - "GC000894": "b3a8a6381fc57d60", - "GC000895": "2144517a19378ca5", - "GC000896": "c3d79af44e4359f4", - "GC000897": "a7d551bf23b637f2", + "GC000893": "eea6ac496e87c3dc", + "GC000894": "78a221c6f2f6b034", + "GC000895": "dac98a3dfb897f5e", + "GC000896": "f71e7b3079b31a4b", + "GC000897": "dd78bffdaa1df948", "GC000898": "6944b6b4e1ae3af2", "GC000899": "fbfbfb7a878ffdde", "GC000900": "8e31b8f888b93016", - "GC000901": "a5ea3f73e8e20d6d", + "GC000901": "75c938bc61a82573", "GC000902": "5d5cd4bde9d0068a", "GC000903": "d32706ab68b37561", - "GC000904": "ccb55cde594dca49", + "GC000904": "0af1c20235ec6e94", "GC000905": "3ce597226dc4532d", "GC000906": "987dd5df984b32e3", "GC000907": "962e9f9b8f401949", "GC000908": "21acda1f3b2a2c08", - "GC000909": "e90add81ff13f031", + "GC000909": "a95ca922e1d7664d", "GC000910": "32434b15208e4dd9", "GC000911": "273a3e1b2b80196b", - "GC000912": "135fb09f45726fbb", + "GC000912": "a8b01c1fd7d1c475", "GC000913": "a177a4fc5f2ff9cc", - "GC000914": "1c2b089b2d3703bb", + "GC000914": "de742c9f3ec5fb23", "GC000915": "3d8d6ba87e0cf8fb", - "GC000916": "500ef8730d2d4543", - "GC000917": "eeff71bdf1a29f81", + "GC000916": "9a04e0948bd1108d", + "GC000917": "30c41bdc7bb849dd", "GC000918": "88afd9f049cced17", "GC000919": "c64432778bc72ef7", - "GC000920": "65587719ceead5ac", - "GC000921": "a8720619f80561f6", - "GC000922": "9c4556fbe6cca33b", + "GC000920": "de0d1a4b15e2d719", + "GC000921": "558c0d863e04ad31", + "GC000922": "06595c159e645346", "GC000923": "16b4d4a59b5ddb19", "GC000924": "a3a7c17b28f0eda1", "GC000925": "55e8a1d67e50d2fb", "GC000926": "2284e9abb8d6e215", - "GC000927": "a295358244ebfc74", - "GC000928": "abfada19ff003e89", + "GC000927": "f4158af3bb99f3e7", + "GC000928": "71cf55f26aab5053", "GC000929": "98194b7d6f9624e1", "GC000930": "befe278af5a705ca", - "GC000931": "4694429d4d9645e8", - "GC000932": "f8a8cf62c535ed6c", - "GC000933": "cb3c3d82fe0e88b2", - "GC000934": "5a5ffc0e84e858e4", - "GC000935": "2a924859a3f2d8ef", - "GC000936": "f1f3fb17254f6240", - "GC000937": "2cd2f70e5130012e", - "GC000938": "bd23fcd42360d46a", - "GC000939": "3c9e994e2ab5c164", - "GC000940": "01959b03d398e482", - "GC000941": "67625ba7df4f4dd4", - "GC000942": "6a3515aa6d3a0d30", - "GC000943": "77ba5b8ee8299442", - "GC000944": "19c5d698dd87bc10", - "GC000945": "8b27a845fb8e8387", - "GC000946": "217015662be10524", - "GC000947": "aec5813b0fa15137", - "GC000948": "fa3e2e3e6d965fad", - "GC000949": "26470a9ec29acbd4", - "GC000950": "4f8f45052fe9cf6e", + "GC000931": "0b6c67c8c80ea1a0", + "GC000932": "614124a2e02b6c37", + "GC000933": "9c826a423ff38e8d", + "GC000934": "e1bbed73ee93c9e6", + "GC000935": "346fabf18a852721", + "GC000936": "4d37e3f5a3597974", + "GC000937": "881de0c73f4f7d55", + "GC000938": "8d2c5aada16cdf51", + "GC000939": "025ae9bc0849df17", + "GC000940": "a188d26a0781ac85", + "GC000941": "601f02a108945e34", + "GC000942": "f5e49fd5e42768e5", + "GC000943": "b8395aa18e3e89e9", + "GC000944": "c40697141c319f30", + "GC000945": "ff663ab341c3294d", + "GC000946": "77b95a936421a1f7", + "GC000947": "cf9786bc6feb5139", + "GC000948": "f37f244a2c7b7761", + "GC000949": "d1e67da1b7939811", + "GC000950": "36b6a8dc2c93b9f7", "GC000951": "01dbc2d05f7112ed", "GC000952": "cd096d607d055a97", "GC000953": "6b23eea11ff95216", @@ -968,141 +968,141 @@ "GC000970": "33bf521702a2add5", "GC000971": "33bf521702a2add5", "GC000972": "3b46dd05bbfae1d8", - "GC000973": "8e4ba1c41cc24d04", - "GC000974": "968ccd0a121965f9", - "GC000975": "b9736e9ce4da4265", - "GC000976": "215b0373c463bcd5", - "GC000977": "d5073bb102eb4550", - "GC000978": "d44a7e7c41b68346", - "GC000979": "66b8cdbac3a18a24", - "GC000980": "d8c188c2017d8be9", - "GC000981": "cf25ecb60e6e7ba6", - "GC000982": "dcd4d266f6d4a4cc", + "GC000973": "4ee564ccc7455315", + "GC000974": "21e7d56db36c182d", + "GC000975": "2fdc14164821c611", + "GC000976": "4de4d55a4e86cc49", + "GC000977": "bfbacf73290064a1", + "GC000978": "5998ccc2596c8368", + "GC000979": "33dd9469e5f879cc", + "GC000980": "dd998d4882cb7201", + "GC000981": "c40c482fdb5fe78e", + "GC000982": "792a8790c1a17437", "GC000983": "7f66351ed5bc6b48", "GC000984": "9a5deace93d997d4", "GC000985": "0c1679033a780b22", - "GC000986": "83bc7d3df4b34029", - "GC000987": "967c0d5aba8a5677", + "GC000986": "358eea7ebbddaff8", + "GC000987": "be3fc10bf528e6a6", "GC000988": "52c0e18edbca9717", "GC000989": "a4b9839706716820", "GC000990": "98dd7432bdf51bf9", "GC000991": "c7d5c882eeeb7c4c", - "GC000992": "3ab53b186d32b387", - "GC000993": "b764994ea7e63623", - "GC000994": "c0fd19a449b4aa12", + "GC000992": "70467ead27b004b2", + "GC000993": "ccb9b09ec9cb09b3", + "GC000994": "3f49a21f99a4903e", "GC000995": "346ee8f43484a87b", - "GC000996": "5113840c59b410ab", - "GC000997": "2947bcbb72eda4fb", + "GC000996": "013a23d4443d5a18", + "GC000997": "9a2cbcf3d71d0aee", "GC000998": "e599d578b9916145", - "GC000999": "2e5eda6da8036edc", - "GC001000": "4af3ac8ecd1443f4", - "GC001001": "640065aa8944ee57", + "GC000999": "434b5b2cf085f1ef", + "GC001000": "2db0554d7e146247", + "GC001001": "f7e336e5dc66df12", "GC001002": "cc0d593b69540945", "GC001003": "2dac95327c392c49", "GC001004": "7bb31e271f90595a", "GC001005": "31a3ec44adbc5e2f", - "GC001006": "8773c1e4b7bd39c6", + "GC001006": "e4acd2025df861dd", "GC001007": "e9148209c731d414", "GC001008": "4f6b26ff60a6e2bb", "GC001009": "666155e171a9291c", "GC001010": "ac406dce03689656", "GC001011": "b932292b01a4f392", - "GC001012": "bae7b595ccf0aa28", - "GC001013": "00a53e7291d18aab", + "GC001012": "169f571847d7fd93", + "GC001013": "3481749f1b410171", "GC001014": "0aeeb439dfe90cc8", "GC001015": "214f95011fbe63b3", - "GC001016": "f2eac67750dbd364", - "GC001017": "58fcddc06f11d9cd", + "GC001016": "bbbc7d8d23cbabae", + "GC001017": "2121aa84619db0e8", "GC001018": "150e60b62aeca1c2", "GC001019": "594ef955c7188b45", "GC001020": "d3fe6ca3a31b9bd9", "GC001021": "5083e28f2b6fb432", "GC001022": "4bc2cbc0138bd260", "GC001023": "7531e7005bc374b8", - "GC001024": "d6c59aa933c7da08", - "GC001025": "fabc4044409f4248", - "GC001026": "f3f0e384da9e5f68", - "GC001027": "f230ef0182960ece", - "GC001028": "b025e0d7cf6bb1d2", - "GC001029": "cad0a5a4630bc6e5", - "GC001030": "6b1d9e371f18247e", - "GC001031": "625f09c97c8914ed", - "GC001032": "4e29044db8a32463", - "GC001033": "1c236222b001ee16", - "GC001034": "f4629cc8bc295643", - "GC001035": "a8ef0abc89a34e95", - "GC001036": "08adea0fc8c53a13", - "GC001037": "a7113a795984a5f3", - "GC001038": "0000b62a8ef9caaa", - "GC001039": "778e3e9e6be01ca9", - "GC001040": "2601dd50ffb4bd69", - "GC001041": "a6838df30a1081db", - "GC001042": "adc0baf00a2ff439", - "GC001043": "59773e9ccf18672b", - "GC001044": "1d375fb510ca1f53", - "GC001045": "c2b37c4414a91f4d", - "GC001046": "a6b89761bba43099", - "GC001047": "25110541c24176ea", - "GC001048": "b04b02b0d52bcc9f", - "GC001049": "f3f6828e91d7abbe", - "GC001050": "35c6dae4af71653e", - "GC001051": "e23e7d382b82d6a4", - "GC001052": "382fc1cd55899963", - "GC001053": "4638a7514238a7d1", - "GC001054": "213c958b4c0610b4", - "GC001055": "fe7d7bbb71ce33ff", - "GC001056": "0df5f51e9f1a8b6c", - "GC001057": "eb66412ba029d46a", - "GC001058": "83be7233448e4a83", - "GC001059": "51ff2942e90e45ff", - "GC001060": "451fe26d14b3a4df", - "GC001061": "11c4517010881b0b", - "GC001062": "321b26784a33578e", - "GC001063": "3784d44c9a55d7ba", - "GC001064": "4f16160479dc7edc", - "GC001065": "62ec81680c4b83a0", - "GC001066": "6f1482dee9012330", - "GC001067": "d3ea286295aafaf4", - "GC001068": "0435e299b40773c3", - "GC001069": "44908b617230b346", - "GC001070": "e7b02016afb1d5c9", - "GC001071": "8c6f3adf5141871c", + "GC001024": "fe562a27ce239a1c", + "GC001025": "ad93c807f9afb462", + "GC001026": "2dd1d907acbf52b2", + "GC001027": "e84f03f676eb724d", + "GC001028": "1e95dd8eb03fa515", + "GC001029": "3d218f544b75b62e", + "GC001030": "d7735a534a1d6cd8", + "GC001031": "d71adf81f75304b3", + "GC001032": "b64c28df91460621", + "GC001033": "80759046dafc0a04", + "GC001034": "793a8f833bec3e98", + "GC001035": "be7b5a4298520c60", + "GC001036": "0f9cada5667961a9", + "GC001037": "095c64154b957298", + "GC001038": "24a40d11162d76fe", + "GC001039": "c05528e91c95f396", + "GC001040": "2936b3419b7e9c39", + "GC001041": "84e03e01e7107735", + "GC001042": "98e7404570785e24", + "GC001043": "002940c7cb088f27", + "GC001044": "d19e59d4c70a1b7c", + "GC001045": "a2d6939b4984a34a", + "GC001046": "40a93a0ced68739f", + "GC001047": "e97ea42dc63f785f", + "GC001048": "88b30f89b8b6a7e1", + "GC001049": "95143e0476879079", + "GC001050": "0db8330e28b5f411", + "GC001051": "c5b703b1f74ffa6e", + "GC001052": "b89952a7749a814b", + "GC001053": "518214e35a68922a", + "GC001054": "a4fbdfb5b420bd4a", + "GC001055": "9eb207ef3641cd12", + "GC001056": "11d45bd3b198a951", + "GC001057": "21ab2371f4a4807b", + "GC001058": "1962693d75ec4cff", + "GC001059": "38ee8f7df5717887", + "GC001060": "b67058d063c08d75", + "GC001061": "ee7bee934dc7bf6d", + "GC001062": "0b845be82ad3a6e5", + "GC001063": "e69eea2162615ec3", + "GC001064": "e32f4b2ae2b37c37", + "GC001065": "98aba0bbaf8324dd", + "GC001066": "57386af3ccda5e6a", + "GC001067": "9d1863ad2e090528", + "GC001068": "d8f7b952b1f753f3", + "GC001069": "39fbfdc3749b09ee", + "GC001070": "7a0e93caa7a5330a", + "GC001071": "ba9be8c4c9f1391c", "GC001072": "d13e3d28a3ac9760", - "GC001073": "99ddf5db02e89eb7", + "GC001073": "e0ed050d68efcfc0", "GC001074": "d1bb34c70923c513", - "GC001075": "023184e3ad6e0ee7", + "GC001075": "1745d1e26ccc8b5b", "GC001076": "be2eb9644885ff84", - "GC001077": "0058c22b4bae45c8", - "GC001078": "92df44ab97d399ea", + "GC001077": "039e0b12382469c3", + "GC001078": "79329675c7d2251d", "GC001079": "cd17f889793f7291", - "GC001080": "3b3ab1d074b992cb", + "GC001080": "8f11f8bf0b88b626", "GC001081": "62fa249d89e1bcba", "GC001082": "8d11ea260802ec8c", "GC001083": "2c4c28a8158e2cc3", "GC001084": "b61e9f6c365b1e0c", - "GC001085": "1fffe2c8fd00ff8d", - "GC001086": "dbf85e913e4ec1e8", + "GC001085": "fe0d66ab7fe757cd", + "GC001086": "f527c1e9907e6eef", "GC001087": "b14c9b0f2ac6db16", - "GC001088": "a7edf01a02f60cf3", - "GC001089": "d472cbecb2608431", + "GC001088": "8a45aa2b36e2329a", + "GC001089": "493cff9fe7b9b5f8", "GC001090": "87f293dc65c9a99d", - "GC001091": "4f55f881feab810b", - "GC001092": "2e43caea98075638", - "GC001093": "81183e21f308e1c1", - "GC001094": "9dba8e2ddeea2473", - "GC001095": "4414eac42667f97f", - "GC001096": "c0bfef9c900113da", - "GC001097": "4b6db055132d8a19", - "GC001098": "64d0425d7e213c02", - "GC001099": "19a0ae17152cd4fa", - "GC001100": "6703e1a3a74e8c82", + "GC001091": "ec3c5ab0f4af2b3e", + "GC001092": "ce855cd319ae8fda", + "GC001093": "40ddb3ad26224329", + "GC001094": "1d98a9cf53c7dea4", + "GC001095": "b2981c6bda6125db", + "GC001096": "b8e1bb2787348ef3", + "GC001097": "6f4ee6ac176a3779", + "GC001098": "604882c2d64162c2", + "GC001099": "14cc34715c71fb62", + "GC001100": "167a9dabe0ed25d9", "GC001101": "9791731acaa1c1e8", - "GC001102": "b9a5b3e4bc8417ac", - "GC001103": "14aa2fa4c1ca2d7b", + "GC001102": "483066a9c648e1ba", + "GC001103": "791dc341425069c1", "GC001104": "a0ef0d1557fe43aa", - "GC001105": "d7077e78af2a270a", - "GC001106": "80b4d644a378c9df", - "GC001107": "52851f7eacd234a6", + "GC001105": "fdcafb6588446025", + "GC001106": "6e59d50558f0743b", + "GC001107": "8287b69a92c5676b", "GC001108": "b451a6460d26f30e", "GC001109": "0eb23607caba10e8", "GC001110": "bf9b73f391f25287", @@ -1113,7 +1113,7 @@ "GC001115": "caa862ecb662f4e9", "GC001116": "f8c0d8d29e23f25e", "GC001117": "7cb35dd128452016", - "GC001118": "137a6c1c9651b0cd", + "GC001118": "e7eaca742ba54ba9", "GC001119": "7cf5bed7d5104df4", "GC001120": "493ba494273555a4", "GC001121": "d3c4f53ade95f4bb", @@ -1131,7 +1131,7 @@ "GC001133": "8bd27203b8c1d9da", "GC001134": "4996d563b9a9d6f5", "GC001135": "b6e0b935b99ea9a8", - "GC001136": "44b78b3e3adf2c2b", + "GC001136": "c04d5b835cffe3fe", "GC001137": "d1d64ede12fd57bc", "GC001138": "97baf6cbfe8ef653", "GC001139": "bfbb103f6c8d581e", @@ -1139,63 +1139,70 @@ "GC001141": "b7a9afb31c7367fe", "GC001142": "a71c65aaf3eaa7fb", "GC001143": "67408ddb506d5fff", - "GC001144": "7b207014a8648623", - "GC001146": "d0cb3999201a30ac", - "GC001147": "a0b23be6a9736a77", - "GC001149": "aeed5c7c9e52efef", - "GC001150": "1375791d7dd5ce45", - "GC001152": "6ae99c99ea7e4c9f", - "GC001153": "813d46800b48b946", - "GC001154": "cbbd35887f079546", - "GC001155": "0b6c9c3dc014fc51", - "GC001157": "19c727d732d3c6c2", - "GC001158": "108ec420791670b2", - "GC001160": "3ca4cdd646f5e7b1", + "GC001144": "dd934f27ea184f2a", + "GC001146": "7424f89d9c7c751f", + "GC001147": "bc67834a81f85013", + "GC001149": "81ff6f19d1c9d36f", + "GC001150": "e93ac36e623af90e", + "GC001152": "5d8ea8d7428e70ed", + "GC001153": "2404ff0bd5d2ae68", + "GC001154": "67d4cb7e855ddd9e", + "GC001155": "8b0370799534c121", + "GC001157": "b84deacf50aba53f", + "GC001158": "971568f036be479d", + "GC001160": "10c3caf0fb2386e9", "GC001161": "0cb1fa1eeda920fb", - "GC001162": "c3d278e87f2fded4", - "GC001163": "c1216e4fdd0db9e4", - "GC001164": "ac5b787938ec3ca2", - "GC001165": "798aee41ed132310", + "GC001162": "f831908116afd1f7", + "GC001163": "1478aac910b65c17", + "GC001164": "002d445afe631b2f", + "GC001165": "dd78deec436d91ed", "GC001167": "ab6999dcf7f7dfe6", - "GC001168": "29e3a9b048eaf277", + "GC001168": "875607dc1f2d9e56", "GC001169": "6cda5f96e9b1895b", "GC001170": "ffa182f36c870ff5", - "GC001171": "9f75127a01bd86bb", + "GC001171": "f9e1a02b863fe6f7", "GC001172": "5c6541add2107560", - "GC001173": "cf591c7b9110fc61", - "GC001174": "f4460eb1a5bbf5a8", - "GC001175": "e977653544776b8d", - "GC001176": "b2ee9367c2e76297", - "GC001177": "cd96d482611e3fac", - "GC001178": "6f0ce9eb75c93485", - "GC001179": "31ca6315d407d18e", - "GC001180": "5d64ee0703bd9fd8", - "GC001181": "d710dc2e5d6209cd", + "GC001173": "54b7fc2ee44317e4", + "GC001174": "5204ef8b9d242602", + "GC001175": "84b41d97f7e8116a", + "GC001176": "e50773d0ddf564de", + "GC001177": "1243e0d011b5b036", + "GC001178": "635517bffa4c600f", + "GC001179": "e30c2e44bdf561a6", + "GC001180": "9e9987b852337e00", + "GC001181": "5acf93c4c3708841", "GC001182": "39728686a32b586b", "GC001183": "ba58b75e8ae7d4ad", "GC001184": "270066ef9e54a1ff", "GC001185": "7b25fdf0a39b285b", - "GC001186": "f3e1dcf656c28da6", - "GC001187": "fa3afeea5bd94cea", - "GC001188": "b9d0c9c443d613be", - "GC001189": "e024ae7a407a41bc", - "GC001190": "8a48901776c6c318", + "GC001186": "62e81843154a6f17", + "GC001187": "08f3a1be0db5548b", + "GC001188": "49a2eb5d8eadfb3a", + "GC001189": "be6a572c346b915d", + "GC001190": "ae0e3f67fcaa25ce", "GC001191": "46df05f842017dd6", "GC001192": "c5fb416fcdc88610", "GC001193": "28c7498794e07f1b", "GC001194": "6d4852b3bed4d630", + "GC001196": "7676db3e62e5fa60", + "GC001197": "12ff7dff39ea3524", + "GC001198": "ad84843b2f990d6a", + "GC001199": "b05bab09cd48af83", + "GC001200": "b05bab09cd48af83", + "GC001201": "b05bab09cd48af83", + "GC001202": "3e048f8b962a4a9f", "GF000001": "6d4852b3bed4d630", - "GF000002": "7fb3cc42d7f9c1e4", + "GF000002": "b7b433f295acaf87", "GF000003": "4103e0624c021e21", - "GF000004": "077753726c853fb4", + "GF000004": "c6ed3c8d16ce0d70", "GF000005": "15e14570263e541b", "GF000006": "f5fbc5599593fcdd", "GF000007": "2678b09e837335c1", "GF000008": "5ed4709df6f16245", "GF000009": "b44147fc04463d85", "GF000010": "12c25f3eca199e16", - "GF000011": "1081dfe5c1331344", - "GF000012": "8921be8954b4fcdc", + "GF000011": "ce3806a299cb5e30", + "GF000012": "0d76bb58b3d1361b", "GF000013": "0c12bfb2dd486fda", "GF000014": "118833bb184bc013", "GF000015": "fba610f24d522df0", @@ -1213,20 +1220,20 @@ "GF000027": "ecae5aed219de4af", "GF000028": "8ca5b5802c337b50", "GF000029": "2479e0215c0b84b2", - "GF000030": "9e904a1678d15291", + "GF000030": "a6f0518010e4f244", "GF000031": "ccd1bfe7a062ecdb", "GF000032": "0ab83b189e8f29cc", "GF000033": "d1a7b8d3198701bd", "GF000034": "56c3e7c30ccb927c", "GF000035": "c7aa32b1a1869cf7", - "GF000036": "e1445cde895ec900", - "GF000037": "9d6a0b7a5f8353bf", - "GF000038": "9d6a0b7a5f8353bf", + "GF000036": "15ba24bfd19cb946", + "GF000037": "4c4ad4d8b5716c2c", + "GF000038": "4c4ad4d8b5716c2c", "GF000039": "c62f002c5f43b0e3", "GF000040": "e51dccdea617671b", "GF000041": "cd47ee154f3244b5", "GF000042": "0e4bfc8fcd8874a2", - "GF000043": "1fe78a8a6f7f2801", + "GF000043": "1e606dcf257132d2", "GF000044": "779f3ed515c49772", "GF000045": "fc41f3f6207badb8", "GF000046": "3bdd18d6ed956517", @@ -1238,12 +1245,12 @@ "GF000052": "0735e0e635e43dc8", "GF000053": "cee8d87f37d4a83c", "GF000054": "6510bf1a5443fc69", - "GF000055": "106a26812f74428f", - "GF000056": "201e2ecc830249ab", + "GF000055": "de435980cc9a427c", + "GF000056": "0ba9e51f8cf0fb5d", "GF000057": "3e4d697f5d8e2ac3", "GF000058": "4ce1a48d78b20135", "GF000059": "2468dc593e62b609", - "GF000060": "32795025f32c2ea1", + "GF000060": "8cd2dcbd222affe1", "GF000061": "3e2dbd0238c650ae", "GF000062": "82ac20b13db525a6", "GF000063": "2399a8a6f2370ebb", @@ -1259,7 +1266,7 @@ "GF000073": "04351d792ec7cb57", "GF000074": "1784012fed5c2a60", "GF000075": "2fefa5dfd69f6c54", - "GF000076": "d8d214a95bf066b2", + "GF000076": "49a7df203573a800", "GF000077": "29da9b241ebba44c", "GF000078": "dadd4d6b1ebdde10", "GF000079": "025467d91fd4d3e9", @@ -1267,212 +1274,212 @@ "GF000081": "570e10034d48d167", "GF000082": "0ac9a5dbf19782f1", "GF000083": "138801569f4c0b4c", - "GF000084": "c47b5525c6999de8", + "GF000084": "492d4c5d9c02ca63", "GF000085": "3d77f5a2ee6c6686", "GF000086": "f51782051f807b28", "GF000087": "04d75ab523e838c5", "GF000088": "428bae72d8a01f50", - "GF000089": "7e58c196a1055a36", + "GF000089": "29656ed13fbb2b2e", "GF000090": "9454c89101d85c73", - "GF000091": "a12b65a3d655b55b", + "GF000091": "bdbd845907123aed", "GF000092": "e0f4984208153657", - "GF000093": "69c2d44e10283591", + "GF000093": "c571d13adb8e9b7d", "GF000094": "239a41f878dea121", - "GF000095": "1e165bec50520755", - "GF000096": "d2b46146a28d1b43", + "GF000095": "48dd0d059dd1598b", + "GF000096": "11e2074a2cf4f9eb", "GF000097": "539d92d88ee79dc1", "GF000098": "07a3e69abc721577", - "GF000099": "cb7d2f17a290243b", - "GF000101": "db317f695afed2b2", - "GF000103": "deac82bbd8832a03", - "GF000105": "d159c5453de90795", - "GF000107": "db2019a9acb968b1", - "GF000109": "8e4f58911b220102", - "GF000111": "b0d55497b049d9ca", + "GF000099": "9b5c8cbb331194dd", + "GF000101": "ce4aaef3a66c6837", + "GF000103": "2a92a8730a5890f7", + "GF000105": "71b77fef46730253", + "GF000107": "260de7e5a0331266", + "GF000109": "dbf5a7de68f7fb9e", + "GF000111": "69dd65e664c421ad", "GF000112": "08e31ea2787ab8a3", - "GF000113": "96b811faf59c723a", + "GF000113": "62bec593bbabdc97", "GF000114": "da1f6dbb0e97b062", "GF000115": "1c9e47c2facb0a0f", - "GF000116": "34393ed51f08780d", + "GF000116": "72a122bd28d5d84e", "GF000117": "9ab2c67374fb2ade", "GF000118": "8fdb03e7ac44ad66", - "GF000119": "4723c568a4dd0770", + "GF000119": "8146e9180249b725", "GF000120": "95901768fd7e0b75", "GF000121": "ae3ff4722ab44895", "GF000122": "aab1cd310b948ada", - "GF000123": "d29f5e6eafdc5e19", - "GF000124": "33cdd0187bfc8cee", + "GF000123": "13416b48abf31ba2", + "GF000124": "7bc5722a67eac4aa", "GF000125": "ba310d5129e09bf9", - "GF000126": "7787895938016575", - "GF000127": "a8e707e848abff01", - "GF000128": "4d5e616c017a72fc", - "GF000129": "755fd0bc92640528", - "GF000130": "9d100c36239e8fc6", + "GF000126": "822b8d53a910094c", + "GF000127": "4284b5f78963d5d8", + "GF000128": "a87f5229cbd2036f", + "GF000129": "8f6e36437a0c8b6f", + "GF000130": "dbadd9967b704aa6", "GF000131": "a9559ccc964a7182", - "GF000132": "e88ed19943884de0", + "GF000132": "ea4ddff237b04817", "GF000133": "45218c4076224b49", - "GF000134": "ac9bd137ba90ed31", - "GF000135": "ac9bd137ba90ed31", - "GF000136": "ac9bd137ba90ed31", - "GF000137": "fecab379718d0537", + "GF000134": "8ef84f6b31074355", + "GF000135": "8ef84f6b31074355", + "GF000136": "8ef84f6b31074355", + "GF000137": "b8bb2794b600af1a", "GF000138": "af68f29c14d86a80", "GF000139": "b75d001c209ca4d5", "GF000140": "5bd79368c766024b", "GF000141": "1e0ca0edefd1e7ab", "GF000142": "845d686f40d694ba", - "GF000143": "6f402786f10fc588", + "GF000143": "5a826e1d2d0e9fee", "GF000144": "236be8ca6d0e968a", - "GF000145": "5cae634d5f28ba66", + "GF000145": "c5f3f140ea4bdf90", "GF000146": "d24fd59d8ce81498", "GF000147": "a2be3e52ade7132f", - "GF000148": "d622d3f62faa6e91", - "GF000149": "c827b77a6a931472", + "GF000148": "5c8bc3a399a2792f", + "GF000149": "5a5b8ac4ec1cba22", "GF000150": "070b408ca4265d5d", - "GF000151": "02ba4b5ba5fcdb70", - "GF000152": "ca7e15de45166964", + "GF000151": "fbc61595be66db24", + "GF000152": "587e1b48ce04f9bb", "GF000153": "ecfa88d93e333e7a", - "GF000154": "4723c568a4dd0770", + "GF000154": "8146e9180249b725", "GF000155": "e906e78633adf07c", - "GF000156": "6c94a1416e351867", - "GF000157": "0257cea6572ee314", + "GF000156": "994a63cf5ccf531b", + "GF000157": "ce1057d3896f1141", "GF000158": "16d341cdfc67195b", - "GF000159": "8817e4b04dadf2ce", - "GF000160": "00d98cee92de7d27", - "GF000161": "11bb248ad80468cd", + "GF000159": "fb0729bf8fd69de2", + "GF000160": "4307a7f51a13b70e", + "GF000161": "d7c27c74a5435a86", "GF000162": "b7687c7e06f196d3", - "GF000163": "0c0ad21be9f89a8e", + "GF000163": "bfe9e11765e9e96b", "GF000164": "aa2b36be6b628505", "GF000165": "70fdffa5f34564de", "GF000166": "82f956e679b07bd6", "GF000167": "7ca81aa29f6d9f0c", - "GF000168": "563811f75d6d3342", - "GF000169": "aa000e0c740ecb8c", - "GF000170": "f82e819bc314f81e", - "GF000171": "99a718b6e7355d20", - "GF000172": "68dcf3c5d0c57383", - "GF000173": "679da6395273d77d", - "GF000174": "ff03d4337a5f2281", + "GF000168": "4b17dd79deac3b49", + "GF000169": "38e659e4ef96254d", + "GF000170": "ca7122228d2f37d2", + "GF000171": "16cecd9cb5547ab5", + "GF000172": "20b461c5558230f6", + "GF000173": "119e593f383f2959", + "GF000174": "041f98d3d5f6eced", "GF000175": "2d16f478d0cafd8c", - "GF000176": "13f47cf6de6d0f0e", - "GF000177": "1c9db6b4ce1e99f9", - "GF000178": "3b25e607a8aed569", - "GF000179": "32cc377894b839cd", - "GF000180": "3a40d6c2684741ca", - "GF000181": "0ce74e3b9f2dbdf7", - "GF000182": "a0308f901047ff7c", - "GF000183": "d00dfada55ec7bd9", + "GF000176": "00df7b64096b7cde", + "GF000177": "af3905754e2a5f29", + "GF000178": "b0fa7d003253ff71", + "GF000179": "2b72a47bbc57a6dd", + "GF000180": "d78cb572dcc1c1a7", + "GF000181": "b4a452caae528db3", + "GF000182": "13764805b4cc5594", + "GF000183": "85200029bf474bec", "GF000184": "a8576736c4fae350", - "GF000185": "cdebcbcc593d8d4a", - "GF000186": "d6dc63e6e42748c3", - "GF000187": "178afffb640781b9", - "GF000188": "1c26d242f7586962", - "GF000189": "2a84b8cb96b392bc", - "GF000190": "adaa715de4fb64ce", - "GF000191": "01503f3286ef00ac", + "GF000185": "2e7703ef6774ba59", + "GF000186": "50dc19fe009fb8f6", + "GF000187": "af7f760eade3c2ba", + "GF000188": "f282e514f56338b4", + "GF000189": "c73e96eaf0ad08e0", + "GF000190": "2066355077bcc60c", + "GF000191": "6ad602359fdaa275", "GF000192": "5aaf34d8ddb4127c", - "GF000193": "e5d2faa2b7c1a355", - "GF000194": "423dc18d67c4665c", + "GF000193": "bca4f905f45de508", + "GF000194": "16023cf135943731", "GF000195": "a7ff93639d2a6969", - "GF000196": "cd1e1e2b4cfe3069", - "GF000197": "fbbf865f1f6e8a14", - "GF000198": "d97fd61a1d84f17b", - "GF000199": "461c811c8ffd1517", + "GF000196": "26a3ea34e76a1624", + "GF000197": "6de363ab15f5859e", + "GF000198": "0cbc3de17b473fe2", + "GF000199": "942df6ae6b3a94ff", "GF000200": "f403fedba481ee7e", - "GF000201": "536dc3187b013c5b", - "GF000202": "1cd4cc49bc7f5194", + "GF000201": "6163e58dff4a0db2", + "GF000202": "65f7e8e8c7ef7589", "GF000203": "99d36c97bb09860e", - "GF000204": "80e60a85357eabd1", - "GF000205": "eae96eb030e20485", + "GF000204": "850575e89fa45221", + "GF000205": "86696326dc6f5107", "GF000206": "ed3fd1e3a713e64b", - "GF000207": "cfa07d686c60012a", + "GF000207": "ad25e9c725ffdd1e", "GF000208": "8d087cb2ca6e8c87", "GF000209": "4a5f3f10efc42cd0", - "GF000210": "8d557e55abdfd170", + "GF000210": "d0db20ea133bd26e", "GF000211": "8b437a7bce97fbbb", "GF000212": "dd3d0739262e95b5", - "GF000213": "7dfdf0edfc9b6c82", + "GF000213": "efa21cd653369cd6", "GF000214": "15f0256c9db37da3", "GF000215": "dca1425caff1e684", - "GF000218": "7571c4ac6166793b", + "GF000218": "242a9aab994de898", "GF000219": "1314eaa6c0b9b1d6", - "GF000220": "3b4654013468fcc8", - "GF000221": "b0293813b344e36e", - "GF000222": "e2d934fae1deb595", - "GF000223": "706dfd279976c254", - "GF000224": "ba3c5cef3e5de148", - "GF000225": "428629cd64e4f788", - "GF000226": "1994024b7f4bdd19", - "GF000227": "c7e9353623931b23", - "GF000228": "aebe49cee8070517", - "GF000229": "0bceb0832a67ec41", - "GF000230": "bba2fd51094ff47d", + "GF000220": "b9212c0fa8300381", + "GF000221": "c8f356836b04f55c", + "GF000222": "789acc2d0db0946c", + "GF000223": "f923e72a7e52a4e5", + "GF000224": "d1ea419376a2853e", + "GF000225": "c11494ee33407582", + "GF000226": "4ebee0fe2a610f6a", + "GF000227": "90a8dd1cca57c13c", + "GF000228": "b83b08e3865fec7b", + "GF000229": "8c7328c10f728266", + "GF000230": "3f2d2beb5e45136c", "GF000231": "e9f30b4b57c24fc3", - "GF000232": "5cfb6ad5ed394f59", + "GF000232": "0ea6c8a66ce0a0f9", "GF000233": "afc940f2974b4eb1", - "GF000234": "9b1cc563b400659a", - "GF000235": "3d440a702953c58f", + "GF000234": "7763fa12ed753a60", + "GF000235": "93596072dbc26209", "GF000236": "4262cb6bab517270", "GF000237": "411bd04576041ac1", "GF000238": "165045a50a36af5f", "GF000239": "82ad8bc99f26511b", - "GF000240": "4a6c40e405dbe3b2", - "GF000241": "b7013a513cca5d0e", + "GF000240": "681c22ba0a08d72a", + "GF000241": "7e9dde53487b3f1e", "GF000242": "c13eb53d9a442cb7", "GF000243": "3a2d983f69ad6139", "GF000244": "4fed4c9600592005", - "GF000245": "bc96ad734f651e7e", + "GF000245": "7dd3fa393841991a", "GF000246": "7be48038f25080fa", - "GF000247": "c984fc1fc5a63f49", - "GF000248": "ab92ee738d86dadc", + "GF000247": "21a74989ace68d63", + "GF000248": "f60c345d31caf8c3", "GF000249": "56dd25ae6b4db7e9", - "GF000250": "8de00901d02be001", - "GF000251": "a440d676787d52ae", - "GF000252": "2ac24ef5c72c5d96", - "GF000253": "2ac24ef5c72c5d96", - "GF000254": "f1272c2df5e41eb7", - "GF000255": "55558a307ba31119", - "GF000256": "a8d81316e7ec1231", - "GF000257": "fe78865aa0a44b5f", - "GF000258": "a8611574f25c026c", - "GF000259": "3cda324f976d401a", - "GF000260": "a8d81316e7ec1231", - "GF000261": "e35b8ea9a34f2e4d", - "GF000262": "32f20e99e73ea19b", - "GF000263": "2a6ecea5c98ec26c", - "GF000264": "5bc0db7a59a5b681", - "GF000265": "d2e16acba1fd8133", - "GF000266": "f9c882ddf20a98fa", - "GF000267": "ba329b38b823a1cb", - "GF000268": "528eb599e471b675", - "GF000269": "a8e18e9a275bd3f2", - "GF000270": "6b50a02dcc443911", - "GF000271": "909756409f10d449", - "GF000272": "0d1f915802311cc0", - "GF000273": "2777f16bfdb4bded", - "GF000274": "28af883d6a5a9f5d", - "GF000275": "98624eee7ede5f6e", - "GF000276": "88f1911eba353a99", - "GF000277": "54860a2a318e2993", - "GF000278": "6015fc19f3c9f605", + "GF000250": "4d943e0ea69f49e2", + "GF000251": "9c7a2aabf475dd75", + "GF000252": "386e9471aeeb713b", + "GF000253": "386e9471aeeb713b", + "GF000254": "c9fc7b5d1eef9d30", + "GF000255": "704e4ccb3e3b924a", + "GF000256": "488a76ba55d914a7", + "GF000257": "cc972602ccaa2dad", + "GF000258": "e73aa3f9f964cb27", + "GF000259": "37c019e47a0119be", + "GF000260": "488a76ba55d914a7", + "GF000261": "183a34bd4a3d03b1", + "GF000262": "9162834f25202857", + "GF000263": "b9217a661b52a464", + "GF000264": "29d7183b892fd271", + "GF000265": "f09d2ee9c4df2252", + "GF000266": "fe4d566712d0dc20", + "GF000267": "cc7622c4ff70fcaf", + "GF000268": "d5ee5a797ed59514", + "GF000269": "fbaaf260833006a4", + "GF000270": "7565d59a3c23b114", + "GF000271": "f9e1b8985af68835", + "GF000272": "180c0278177f1f10", + "GF000273": "37d1ea1e943efc81", + "GF000274": "aabe8b599fa736d2", + "GF000275": "264d551ad14cfdac", + "GF000276": "3df9f414fb921579", + "GF000277": "8e1417c17c163a01", + "GF000278": "e46c706966cda16f", "GF000279": "428ba10ebe5140fd", "GF000280": "0c3cb103e27efb38", "GF000281": "0e04b83c9ad7fec9", "GF000282": "0078b51a88b7eb8e", - "GF000283": "cef74d92887ff33d", - "GF000284": "e035f3f7ecd83ece", + "GF000283": "0837dcb71f73155c", + "GF000284": "e05850fa20552b08", "GF000285": "f26e296cff8a8cc0", "GF000286": "11a75298fc653945", "GF000287": "9ee12abca8b5bfcc", - "GF000288": "f9d2c71240e043d7", - "GF000289": "2e9e9dffdb46a00d", + "GF000288": "75b6d1490f9b0dd6", + "GF000289": "fd5b5506ef737a0b", "GF000290": "ed94f2d9f60b491e", "GF000291": "b780ce32357fa512", "GF000292": "4a20fb8a1a94e467", "GF000293": "acddae8d16934885", - "GF000294": "0280cba84e6f1050", + "GF000294": "192c0bc6e2ae9d5a", "GF000295": "b5f021410b0ed71e", - "GF000296": "8569615eaadd9ab8", - "GF000297": "0f21feb9cfdff97a", + "GF000296": "b8a03b466cdb1933", + "GF000297": "723cc0e9755fca4b", "GF000298": "9f9dede4548bb44b", "GF000299": "cd6f50a4a75e1ca3", "GF000300": "715c7eb299facb34", @@ -1495,7 +1502,7 @@ "GF000317": "087ab95a315be873", "GF000318": "39eff01c2c26c798", "GF000319": "9aa5293a954f06c6", - "GF000320": "d68a6a7e6a1ac5d4", + "GF000320": "50ccd707d09bf1af", "GF000321": "4d282a27209fe4d6", "GF000322": "473ad156ac2fe2da", "GF000323": "4821e510e47ff308", @@ -1503,16 +1510,17 @@ "GF000325": "51d18c3cac6d2573", "GF000326": "db2a93fbee97bc6c", "GF000327": "38729fe0ac79a42b", - "GF000328": "6c85d6dcb2f86f5e", - "GF000329": "91ae6615b093f63d", + "GF000328": "4c6842570c017b8f", + "GF000329": "a711979a27bf2f49", "GF000330": "c2c9ecfb55f5a1a1", "GF000331": "a180544f2ae28361", "GF000332": "9a8ef8dfe5b2edc5", "GF000333": "86799e690947928f", "GF000334": "05e8796025a4fe06", - "GF000335": "9c400ca3e7b49338", - "GF000336": "a9b9e0bb0f7da1f0", - "GX000004": "a3f4c454a5764d6e" + "GF000335": "c1f8d16a3056132f", + "GF000336": "07db2e6ccd1b4aa6", + "GF000337": "c04267a0937de232", + "GX000004": "6734ed375ca50dbf" }, - "마스터": "e6010f1c04492168" + "마스터": "fbe517fed71918bf" } diff --git a/resources/tester/test_572_hopyo_same.py b/resources/tester/test_572_hopyo_same.py deleted file mode 100644 index 886d875bb..000000000 --- a/resources/tester/test_572_hopyo_same.py +++ /dev/null @@ -1,59 +0,0 @@ -"""불러오기 [단가산출 만들기] 같은 내용 SK 씀(PLAN 733-1b · 요구서_572 3장 2). - -북부청 임도(실물)를 임시 층에 → 같은 파일 안 같은 내용 SK 한 벌 · 바이트만 다른 사본 다시 = 새 SK 0 · -뒤 출처 = `본뜬.또` · 다시 = 그대로 · 위 층(회사) 같은 것 = `위층같음` 알림 · -출처마다 못옮김 · 다른 출처가 쓰는 SK 내용은 안 바꿈(떼어 냄 · 넘겨줌). -""" - -import io -import json -import zipfile - -from M02_MasterTemplete import M02_Hopyo_Sangeun as sangeun -from M02_MasterTemplete import M02_Library_Same as same -from M02_MasterTemplete import M02_MasterTemplete_Store as store -from M02_MasterTemplete import M02_Template_Layers as layers -from resources.tester.test_m02_hopyo_excel import NORTH, URL, _post, client # noqa: F401 - - -def _sks(folder) -> dict[str, dict]: - paths = sorted((folder / "sangeun").glob("SK-*.json")) - return {p.stem: json.loads(p.read_bytes()) for p in paths} - - -def _maker(hp: str) -> sangeun.Maker: - """블록 하나짜리 만들기(파일 · 맞춤셈 없이) — 쓰기 규칙만 봄.""" - m = object.__new__(sangeun.Maker) - m.first, m.blocks = {1: {"이름": "줄", "단위": "㎥"}}, {1: {"이름": "블록"}} - m.hp, m.sure = {"키": hp, "파일": f"{hp}.xls"}, {"원본": ["personal", "7/42"]} - m.same, m.reused, m.above = same.Same(), [], [] - return m - - -def _plan(code: str, lost: list) -> dict: - keep = {"갈래": "기초", "엑셀품": {}, "못옮김": lost, "바탕": {"로직": code}, "입력값": {}} - return {**keep, "자재표시": {}, "덮개": {}, "더한줄": [], "뺀줄": []} - - -def test_같은내용_SK_출처마다_못옮김_떼어냄_넘겨줌(client): - folder, at = layers.personal_dir(7, 42), ("personal", "7/42") - one, two = _maker("HP-000001"), _maker("HP-000002") - with store.at(folder): - key = one.write(1, _plan("GF000113", []), None) - assert two.write(1, _plan("GF000113", [{"id": "x"}]), None) == key # 같은 것 씀 - assert two.reused == [{"번": 1, "키": key}] - doc = _sks(folder)[key] - assert sangeun.origin_of(doc, "HP-000002 단산1", at)["못옮김"] == [{"id": "x"}] - assert sangeun.origin_of(doc, "HP-000001 단산1", at)["못옮김"] == [] - assert sangeun.made(folder, "HP-000002", at) == {"HP-000002 단산1": key} - # 뒤 출처가 바탕을 바꿈 = 떼어 냄 · 남의 SK 내용 그대로 - moved = _maker("HP-000002").write(1, _plan("GF000114", []), key) - assert moved != key and "또" not in _sks(folder)[key]["본뜬"] - assert _sks(folder)[key]["바탕"]["로직"] == "GF000113" - # 앞 출처가 바탕을 바꿈 = 뒤 출처에게 넘겨줌 - assert _maker("HP-000003").write(1, _plan("GF000113", []), None) == key - back = _maker("HP-000001").write(1, _plan("GF000114", []), key) - assert back == moved # 바꾼 내용 = 이미 있는 같은 것 - left = _sks(folder)[key] - assert left["바탕"]["로직"] == "GF000113" and left["본뜬"]["키"] == "HP-000003 단산1" - assert "또" not in left["본뜬"] and len(_sks(folder)) == 2 diff --git a/resources/tester/test_705_2_hopyo_paste.py b/resources/tester/test_705_2_hopyo_paste.py index 257ad1276..4ebc682de 100644 --- a/resources/tester/test_705_2_hopyo_paste.py +++ b/resources/tester/test_705_2_hopyo_paste.py @@ -280,109 +280,6 @@ def test_B09_붙인_줄_거울_정리_수요(): assert pct["amounts"]["expense"] > 0 and py["daega_orphans"] == [] -# ── 704-4 뒷부분 — [구조물 조합으로] · 규격 묶음 ───────────────────────────────── -def _upload(client, tag): - from resources.tester.test_m02_hopyo_excel import _post - - path = DOCS / FILES[tag][0] - res = _post(client, data=path.read_bytes(), name=path.name) - assert res.status_code == 200, res.text - return res.json()["키"] - - -def _item_doc(column): - from M02_MasterTemplete import M02_MasterTemplete_Store as store - from M02_MasterTemplete import M02_Template_Layers as layers - - with store.at(layers.personal_dir(7, 42)): - table = store.read("table", store.STRUCTURE_TABLE)["문서"] - col = next(c for c in table["열"] if c.get("id") == column) - return store.read("labor", column)["문서"], col - - -def _total(doc, col=None): - from M02_MasterTemplete import M02_Labor_Doc as labor - from M02_MasterTemplete import M02_Labor_Spec as spec - - doc = {**doc, "규격": {**doc["규격"], "기본": col}} if col else doc # 셈 = 기본 열 - return labor.calc(labor.clean(spec.at(doc, col)), {})["반영합"]["계"] - - -def layers_dir(): - from M02_MasterTemplete import M02_Template_Layers as layers - - return layers.personal_dir(7, 42) - - -def test_구조물_조합으로_규격_묶음_울진_돌기슭막이(client): - before = master_hash() - key = _upload(client, "대흥") - sib = client.get(f"/api/m02/layers/personal/hopyo/{key}/17/siblings").json() - assert sib["이름"] == "H" and [(r["번"], r["열"]) for r in sib["묶음"]] == [ - (17, "1.5"), (24, "2.0"), (25, "2.5") - ] # fmt: skip - body = {"층": "personal", "키": key, "번": 17, "묶음": [24, 25]} - res = client.post("/api/m02/layers/personal/hopyo-item", json=body) - assert res.status_code == 200, res.text - got = res.json() - assert got["열수"] == 3 and got["이름"].endswith("돌기슭막이(찰쌓기,기초무,구입)") - doc, col = _item_doc(got["열"]) - assert col["경로"] == ["실무자료", "돌기슭막이(찰쌓기,기초무,구입)"] and doc["규격"]["열"] == [ - "1.5", - "2.0", - "2.5", - ] - assert doc["규격"]["기본"] == "1.5" and all("고정" in x for x in doc["담은로직"]) - excel = { - h["번"]: h["금액"]["계"] - for h in client.get(f"/api/m02/layers/personal/hopyo/{key}").json()["호표"] - if h["번"] in (17, 24, 25) - } - for no, c in ((17, "1.5"), (24, "2.0"), (25, "2.5")): - assert ( - abs(_total(doc, c) - excel[no]) <= excel[no] * 1e-4 - ) # 열마다 = 그 호표 엑셀 합계(끝수 차) - one = client.post("/api/m02/layers/personal/hopyo-item", json={**body, "묶음": []}).json() - single, _ = _item_doc(one["열"]) - assert not single.get("규격") and one["이름"].endswith("H=1.5 L3=45cm") - bad = client.post("/api/m02/layers/personal/hopyo-item", json={**body, "묶음": [3]}) - assert bad.status_code == 400 # 줄 구성 다른 호표 - precombo = layers_dir() / "precombo" - assert not list(precombo.glob("SC-*.json")) # 사전조합 문서 안 만듦 - assert master_hash() == before - - -def test_구조물_조합으로_경로_층_무시_늘_개인(client): # 837-1 · 요구 855 — 옛 「남의 층 403」 갈음 - key = _upload(client, "대흥") - body = {"층": "personal", "키": key, "번": 17} - assert client.post("/api/m02/layers/company/hopyo-item", json=body).status_code == 200 - assert list((layers_dir() / "labor").glob("*.json")) # 쓴 곳 = 개인 층(`layers_dir`) - - -def test_구조물_조합으로_같은_내용_409_씀_새로(client): - """733-2 — 이 층 같은 내용 항목 = 409 `{같은것}` → `씀` = 새 항목 0 · `새로` = 새 항목 1.""" - key = _upload(client, "대흥") - url, body = "/api/m02/layers/personal/hopyo-item", {"층": "personal", "키": key, "번": 17} - first = client.post(url, json=body).json() - count = len(list((layers_dir() / "labor").glob("*.json"))) - res = client.post(url, json=body) - assert res.status_code == 409 and res.json()["detail"]["같은것"][0]["키"] == first["열"] - used = client.post(url, json={**body, "씀": first["열"]}).json() - assert used["열"] == first["열"] and used["씀"] is True - assert len(list((layers_dir() / "labor").glob("*.json"))) == count - made = client.post(url, json={**body, "새로": True}).json() - assert made["열"] != first["열"] - assert len(list((layers_dir() / "labor").glob("*.json"))) == count + 1 - - -def test_규격_열_이름(): - from M02_MasterTemplete import M02_Hopyo_Item as item - - assert item.columns(["H=1.5 L3=45cm", "H=2.0 L3=45cm"]) == ("H", ["1.5", "2.0"]) - assert item.columns(["일반형", "ㄷ형"]) == ("규격", ["일반형", "ㄷ형"]) - assert item.columns(["D800", "D1000"]) == ("D", ["800", "1000"]) - - def test_줄만_첫_줄_수량_없음_별도계산은_줄(): rows = _block(_rows("거창"), 2)[ 1: diff --git a/resources/tester/test_707_4_bill_link.py b/resources/tester/test_707_4_bill_link.py index 1d54aeb56..b995e821d 100644 --- a/resources/tester/test_707_4_bill_link.py +++ b/resources/tester/test_707_4_bill_link.py @@ -28,7 +28,6 @@ from B09_Estimation import B09_Estimation_Store as store # noqa: E402 from B09_Estimation.B09_Estimation_Bill_Excel import read_bill # noqa: E402 from B09_Estimation.B09_Estimation_Bill_Items import EARTH, earth_items # noqa: E402 from B09_Estimation.B09_Estimation_Calc_Bill import compute_estimation # noqa: E402 -from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store # noqa: E402 K = ROOT / "resources" / "knowledge" / "original" / "실무문서" GEO = ( @@ -122,9 +121,8 @@ def test_맞춤_기억_두_번째_공사_저절로(geo, tmp_path): user, rows = _load(geo) made, report, bill = _link(user, rows, _pick(lk.suggest(rows, {}))) assert report["이음"] == 12 and report["못함"] == [] - hopyo_store.remember(tmp_path, report["기억"], lk.MEMORY) - assert hopyo_store.memory(tmp_path) == {} # 실무자료 맞춤과 다른 파일 - memory = hopyo_store.memory(tmp_path, lk.MEMORY) + # 기억 = 다음 공사 찾기 입력(옛 M02 맞춤 저장은 853-3 에서 걷음) + memory = {k: v for k, v in report["기억"].items() if v is not None} assert memory["암석절취|보통암|m3"]["확정"] == "earth:6" for name, path in ESTX.items(): parsed = ex.read_bill(path.name, path.read_bytes()) diff --git a/resources/tester/test_718_1_hopyo_import.py b/resources/tester/test_718_1_hopyo_import.py index b05c061c6..3a722ed56 100644 --- a/resources/tester/test_718_1_hopyo_import.py +++ b/resources/tester/test_718_1_hopyo_import.py @@ -32,14 +32,12 @@ def test_이어서_끝내기_지움_겹침_막음(client): and n + len(made["실패"]) == 68 and all(x.get("남은줄") or x.get("하위") for x in made["실패"]) ) - hs.remember(folder, {"장부 줄": {"갈래": "안 씀"}}) # 별칭 장부 = 끝내기 뒤 남음 sc_before = sorted((folder / "precombo").glob("SC-*.json")) res = client.delete(URL.format("personal") + "/HP-000001") assert res.status_code == 200 and res.json() == {"지움": "HP-000001", "만든": n} assert not list((folder / hs.DIRNAME).glob("HP-*.json")) # 이번 HP 0 assert not list((folder / hs.DIRNAME / hs.GRID).glob("HP-*.json")) - assert hs.memory(folder) == {"장부 줄": {"갈래": "안 씀"}} assert sorted((folder / "precombo").glob("SC-*.json")) == sc_before # 만든 일위대가 그대로 again = _post(client) # 743-1 — 끝낸 같은 엑셀 = 다시 올림 됨(새 키) diff --git a/resources/tester/test_733_2_library_ask.py b/resources/tester/test_733_2_library_ask.py index 99b9d7663..93d8c9a1a 100644 --- a/resources/tester/test_733_2_library_ask.py +++ b/resources/tester/test_733_2_library_ask.py @@ -3,8 +3,7 @@ 같은 층 같은 내용 = 409 `{같은것: [{키, 이름, 층, 주인}], 까닭}` → `씀` = 새 문서 0 · `새로` = 새 문서 1. 길 = 새로 만들기 · [단가산출로 저장] from-line · 공유 요청 승인 · 복사 딸림 재사용(carry) · -빈 문서 · 같은 층 복사 = 안 물음. B09 내 자료집 = `test_703_b09_daega_copy` · 구조물 조합으로 = -`test_705_2_hopyo_paste`. +빈 문서 · 같은 층 복사 = 안 물음. B09 내 자료집 = `test_703_b09_daega_copy`. """ from __future__ import annotations diff --git a/resources/tester/test_778_5_hopyo_units.py b/resources/tester/test_778_5_hopyo_units.py index 99831f348..880b286be 100644 --- a/resources/tester/test_778_5_hopyo_units.py +++ b/resources/tester/test_778_5_hopyo_units.py @@ -1,27 +1,18 @@ -"""778-5 줄 잇기 한 벌 · 블록 = 줄 판정 모음 · 단위 SK(D-2 · D-3 · 요구 622 · 623 · 624). +"""778-5 줄 잇기 한 벌 · 블록 = 줄 판정 모음(D-2 · D-3 · 요구 622 · 623 · 624). - 줄 잇기(`M02_Hopyo_Units`) — 작업반장 = 건설업 · 숫자 규격 치수 차례 · 구분자 무관 · 글자 규격 = 고를 것 · 손료율 = 자재 줄 방법 · 우리에 없는 율 항목(설치비 · 제경비) = 율 줄 · 여덟 파일 묶음별 수 굳힘 -- 단위 SK(`M02_Hopyo_SkUnit` · `M02_Hopyo_Sangeun`) — 확인 안 한 블록 안 만듦 · 확인 블록 = 바탕 없는 SK + - 근거 꼬리표 · 고를 줄 남으면 못만듦 · 고르면 만듦 · 다시 올려도 같은 SK 재사용 · 일위대가 = 확인 전 못 이음 층 = 임시 폴더 · M01 · 마스터 읽기만. """ from __future__ import annotations -import json - import pytest from M02_MasterTemplete import M02_Hopyo_Material as hmat from M02_MasterTemplete import M02_Hopyo_Sangeun as sangeun -from M02_MasterTemplete import M02_Hopyo_SkUnit as skunit from M02_MasterTemplete import M02_Hopyo_Units as units -from M02_MasterTemplete import M02_Labor_Doc as labor -from M02_MasterTemplete import M02_Sangeun_Calc as calc -from M02_MasterTemplete import M02_Sangeun_Doc as sd from resources.tester import helper_m02_hopyo_golden as golden -from resources.tester.test_m02_hopyo_excel import URL, _post, client, master_hash # noqa: F401 # 여덟 파일 불리는 블록 줄 연결 표(778-5 D-2 · 바닥값 — 이어짐은 이 수 이상 · 고를 것 · 못 이음은 이 수 이하 · # 마스터 · 기계 자료가 좋아지면 바닥이 오름 · 줄 수는 엑셀 몫이라 그대로) @@ -74,21 +65,6 @@ def test_손료율_자재_줄_율_항목_율_줄(us): assert us.line(rest)["단위"] == {"기준": "노무비", "비목": "경비"} lost = us.line({"묶음": "R", "이름": "기구손료(노무비의 9%)", "기준": "노무비", "품": 0.09}) assert lost["상태"] == units.PICK and lost["후보"] == [{"기준": "노무비", "비목": "경비"}] - # 단위 SK 셈 — 설치비 = 재료 줄 × 5 % · 제경비 = 노무비 × 60 % - block = {"항목": [ - {"묶음": "L", "이름": "보통인부", "직종": "보통인부", "품": 0.5, "행": 1}, - {"묶음": "M", "이름": "유로폼패널", "규격": "600×1200", "단위": "매", "품": 2, "행": 2}, - {**setup, "행": 3}, {**rest, "행": 4}, - ]} # fmt: skip - got = skunit.judge(block, us, lambda sub: None, None, "㎡") - assert got["판정"] == skunit.GOOD and [r["상태"] for r in got["줄"]] == [units.LINKED] * 4 - labor_, mat = (got["줄"][0]["우리금액"], got["줄"][1]["우리금액"]) - assert got["줄"][2]["우리금액"] == pytest.approx(mat * 0.05, abs=0.1) - assert got["줄"][3]["우리금액"] == pytest.approx(labor_ * 0.6, abs=0.1) - doc = {"키": "SK-000001", "이름": "t", "단위": "㎡", "바탕": None, "더한줄": got["더한줄"]} - whole = us.whole - ran = labor._json(calc.run(sd.clean(doc, None, whole), whole)) - assert ran["1단위"]["계"] == pytest.approx(got["우리금액"]) def test_글_붙은_규격_수_배율_같이_씀_같은_수는_한_번(us): @@ -118,7 +94,11 @@ def table(us): rows += got blocks += 1 full += all(s == units.LINKED for _, s in got) - return units.summary(rows), full, blocks + out: dict[str, dict[str, int]] = {} + for kind, state in rows: + one = out.setdefault(kind, dict.fromkeys((units.LINKED, units.PICK, units.NONE), 0)) + one[state] += 1 + return out, full, blocks def _floor(got: dict, kind: str) -> None: @@ -140,7 +120,3 @@ def test_여덟_파일_자재_줄_연결_표(table): got, full, _ = table _floor(got, "M") assert full >= ALL_LINKED - - -def _sks(folder) -> dict[str, dict]: - return {p.stem: json.loads(p.read_bytes()) for p in (folder / "sangeun").glob("SK-*.json")} diff --git a/resources/tester/test_780_1_sangeun_outside.py b/resources/tester/test_780_1_sangeun_outside.py index bd2678557..32039ab69 100644 --- a/resources/tester/test_780_1_sangeun_outside.py +++ b/resources/tester/test_780_1_sangeun_outside.py @@ -1,44 +1,23 @@ -"""780-1 일위대가 밖 단가산출도 잇기(요구 627) — 판정 · 확인 = 모든 블록 · `부름 [호표 번]`([] = 일위대가 밖) · -밖 블록 확인 = 단위 SK(이름 · 단위 = 블록 것 · 근거 없음) · 빈 블록(줄 0) = 「줄 없음」 확인해도 못만듦 · -하위 밖 블록(울진소광 492 → 83) = 확인 목록에 함께 넣으면 하위 먼저 만듦 · 칠 재료 `줄` · `어긋남` 모든 블록 · -여덟 파일 블록 459 판정 오류 0(빈 블록은 모두 밖 = 일위대가 안 판정 그대로). 층 = 임시 폴더 · 마스터 읽기만. +"""780-1 일위대가 밖 단가산출(요구 627) — 블록 · 부름 표 = 모든 블록 · `부름 [호표 번]`([] = 일위대가 밖) · +여덟 파일 블록 수 · 부름 첫 줄 블록 수 굳힘(옛 단위 SK 판정 `M02_Hopyo_SkUnit` 은 853-3 에서 지움). """ from __future__ import annotations -import json - from M02_MasterTemplete import M02_Hopyo_Sangeun as sangeun -from M02_MasterTemplete import M02_Hopyo_SkUnit as skunit -from M02_MasterTemplete import M02_Hopyo_Units as units -from M02_MasterTemplete import M02_Template_Layers as layers from resources.tester import helper_m02_hopyo_golden as golden -from resources.tester.test_m02_hopyo_excel import URL, _post, client, master_hash # noqa: F401 BLOCKS = {"북부청임도": (95, 49), "북부청사방": (67, 45), "거창": (61, 13), "봉화": (65, 31)} BLOCKS |= {"동부청영월": (69, 35), "울진대흥": (47, 14), "영덕계류": (15, 2), "울진소광": (40, 17)} -def _sks(folder) -> dict[str, dict]: - return {p.stem: json.loads(p.read_bytes()) for p in (folder / "sangeun").glob("SK-*.json")} - - -def _ready(client, tag="북부청임도"): - path = golden.FILES[tag] - key = _post(client, data=path.read_bytes(), name=path.name).json()["키"] - folder = layers.personal_dir(7, 42) - return folder, key, f"{URL.format('personal')}/{key}/sangeun" - - -def test_여덟_파일_모든_블록_판정(): - us = units.Units() +def test_여덟_파일_모든_블록_부름(): for tag, (n, called) in BLOCKS.items(): hp = golden.read(tag) blocks, first = sangeun.calls(hp) call = sangeun.callers(hp) assert (len(blocks), len(first)) == (n, called), tag assert {b for b in blocks if call.get(b)} == set(first), tag # 부름 = 첫 줄과 같은 블록 - for no, block in blocks.items(): - got = skunit.judge(block, us, lambda sub: None, None, str(block.get("단위") or "")) - if not block.get("항목"): # 빈 블록 = 모두 밖 - assert no not in first and got["판정"] == skunit.EMPTY, (tag, no) + assert not {no for no, b in blocks.items() if not b.get("항목")} & set(first), ( + tag + ) # 빈 블록 = 밖 diff --git a/resources/tester/test_801_3_groups.py b/resources/tester/test_801_3_groups.py index c21bde280..6d9c3f8ac 100644 --- a/resources/tester/test_801_3_groups.py +++ b/resources/tester/test_801_3_groups.py @@ -72,7 +72,7 @@ def test_거푸집_한_묶음_굴착기_한_묶음(): eq = _export("GF000089") rows = eq["소계"]["줄"] assert [(r["갈래"], r["이름"]) for r in rows] == [("블록", "굴착기(무한궤도) 0.7㎥")] - assert eq["합계"]["계"] == D("2190.0") and eq["소계"]["끝수"]["계"] == D("-1.0") + assert eq["합계"]["계"] == rows[0]["계"] + eq["소계"]["끝수"]["계"] > 0 # 금액은 M01 값 따라감 def test_M01_전수_묶음_합_끝수_합계_안쪽_말_0(): diff --git a/resources/tester/test_815_2_alias_column.py b/resources/tester/test_815_2_alias_column.py index b8603e6ba..e3347c948 100644 --- a/resources/tester/test_815_2_alias_column.py +++ b/resources/tester/test_815_2_alias_column.py @@ -235,7 +235,5 @@ def test_걷은_파일_쓰는_곳_0() -> None: continue text = path.read_text(encoding="utf-8", errors="ignore") assert not [n for n in names if f"import {n}" in text or f'/{n}"' in text], path - build = (ROOT / "M02_MasterTemplete" / "M02_Hopyo_Build.py").read_text(encoding="utf-8") - assert "ledger.write(" not in build # 일위대가 불러오기 확인 = 장부에 안 적음 doc = (ROOT / "M02_MasterTemplete" / "M02_Doc_Router.py").read_text(encoding="utf-8") assert "mfind.learn" not in doc # 가져온 식 저장 = 장부에 안 적음 diff --git a/resources/tester/test_826_1_layer_index.py b/resources/tester/test_826_1_layer_index.py index d0836623a..c285e2302 100644 --- a/resources/tester/test_826_1_layer_index.py +++ b/resources/tester/test_826_1_layer_index.py @@ -133,12 +133,12 @@ def test_edit_delete_add_and_dep_change(fresh, reads): assert set(reads) == {f"sangeun/{a}", f"sangeun/{c}"} # 바뀐 항목만 다시 읽음 assert rows == _old(mine) titles = {r["이름"]: r.get("제목") for r in rows if r["종류"] in index.layers.LIBRARY_KINDS} - assert gone == c and titles == { + assert gone != c and titles == { a: "가", b: "나", c: "다", sc: "일위대가", - } # 지운 키를 새 것이 받음 + } # 지운 키는 빠지고 새 것은 새 번호(854-1 · 지운 번호 안 다시 씀) reads.clear() was = {r["이름"]: r.get("기준금액") for r in _new(mine)} assert reads == [] diff --git a/resources/tester/test_854_1_my_machine_lock.py b/resources/tester/test_854_1_my_machine_lock.py new file mode 100644 index 000000000..0e3c84833 --- /dev/null +++ b/resources/tester/test_854_1_my_machine_lock.py @@ -0,0 +1,119 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""854-1 안전 고침 — 내 기계 저장 잠금 · 판 대조 · 번호 겹침 없음(임시 storage · M01 정본 안 고침). + +① 스레드 여럿이 동시에 만들기 → 번호 겹침 0 · 파일 수 = 요청 수 ② 옛 판으로 고치기 = 409 · 새 판 = 됨 +③ `_다음` 이 뒤처져도 있는 파일 번호를 덮지 않음. +""" + +from __future__ import annotations + +import json +import time +from concurrent.futures import ThreadPoolExecutor + +import pytest + +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_MyMachine as mym +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + +N = 8 + + +def _at(folder, fn, *args): + with store.at(folder): + return fn(*args) + + +def _easy(name="sub4임시기계", **vals): + base = {"가격": 1000, "손료계수": 2000, "주연료": 2, "주연료종류": "경유"} + return {"이름": name, "규격": "1㎾", "방식": "바로", "값": base | vals} + + +def test_parallel_create_no_clash(world, monkeypatch): + """① 동시 만들기 N 번 — 키 N 개 모두 다름 · 파일 N 개 · 줄마다 자기 이름(쓰기마다 늦춰 틈을 벌림).""" + me = world["personal"] + write = mym.atomic_write_json + + def slow(path, value): + time.sleep(0.02) + write(path, value) + + monkeypatch.setattr(mym, "atomic_write_json", slow) + with ThreadPoolExecutor(N) as pool: + got = list(pool.map(lambda i: _at(me, mym.create, _easy(f"sub4임시{i}"))["줄"], range(N))) + keys = [r["키"] for r in got] + assert len(set(keys)) == N + files = sorted((me / mym.DIR).glob(f"{mym.PREFIX}*.json")) + assert len(files) == N + names = {json.loads(p.read_bytes())["이름"] for p in files} + assert names == {f"sub4임시{i}" for i in range(N)} + assert json.loads((me / mym.DIR / mym.NEXT).read_bytes())["다음"] == N + 1 + + +def test_stale_version_409(world): + """② 연 판으로 고침 = 됨(새 판 받음) · 옛 판으로 한 번 더 = 409 {stale, 판} · 판 없음 = 대조 없음.""" + me = world["personal"] + made = _at(me, mym.create, _easy()) + key, old = made["줄"]["키"], made["판"] + assert old + fresh = _at(me, mym.update, key, _easy(가격=3000), old) + assert fresh["판"] and fresh["판"] != old + with pytest.raises(store.StoreError) as e: + _at(me, mym.update, key, _easy(가격=4000), old) + assert e.value.status == 409 and e.value.detail == {"stale": [key], "판": fresh["판"]} + assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 3000 # 막힌 고침은 안 적힘 + _at(me, mym.update, key, _easy(가격=5000)) # 서버 길(초안 저장) = 대조 없음 + assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 5000 + + +def test_counter_behind_skips_file(world): + """③ `_다음` 이 옛 번호를 가리켜도 있는 파일은 안 덮음 — 다음 빈 번호.""" + me = world["personal"] + first = _at(me, mym.create, _easy("sub4임시처음"))["줄"]["키"] + (me / mym.DIR / mym.NEXT).write_text('{"다음": 1}', encoding="utf-8") + second = _at(me, mym.create, _easy("sub4임시둘째"))["줄"]["키"] + assert second != first + assert _at(me, mym.one, first)["줄"]["이름"] == "sub4임시처음" + + +def test_brief_cache_follows_index(monkeypatch): + """④ 기계 창 목록 메모(`Machine_Hourly.brief`) — 색인이 바뀌면 새 값 · 옛 색인 메모를 안 꺼냄 · 되돌리면 처음 값.""" + from M01_MasterData import M01_MasterData_Store as m01 + from M02_MasterTemplete import M02_Machine_Hourly as mh + from M02_MasterTemplete import M02_Sangeun_Copy as skc + + key = "EQ000022" # 굴착기 — 가격 · 시간당 있음 + base = m01.loaded() + first = mh.brief([key])[0] + row = base[1].get(key) + twice = {**row, "값": {**row["값"], "가격": row["값"]["가격"] * 2}} + other = skc.Copy(base[1], [twice], ("시험854",)) + monkeypatch.setattr(m01, "loaded", lambda: (base[0], other)) + got = mh.brief([key])[0] + assert got["값"]["가격"] == first["값"]["가격"] * 2 + assert got["시간당"]["계"] > first["시간당"]["계"] + assert all(v[0] is other for v in mh._BRIEF.values()) + monkeypatch.setattr(m01, "loaded", lambda: base) + assert mh.brief([key])[0] == first + + +def test_deleted_last_key_not_reused(world): + """⑤ 단가산출(SK) · 내 재료(PM) — 끝 번호를 지운 뒤 새로 만들면 새 번호(지운 번호 안 다시 씀).""" + from M02_MasterTemplete import M02_Labor_Ref as refs + from M02_MasterTemplete import M02_Material_Own as own + + me = world["personal"] + body = {"단위": "시간", "더한줄": []} + made = [ + _at(me, refs.create, "sangeun", {**body, "이름": f"sub4임시{i}"})["이름"] for i in range(2) + ] + assert made == ["SK-000001", "SK-000002"] + _at(me, store.delete, "sangeun", made[-1]) + assert _at(me, refs.create, "sangeun", {**body, "이름": "sub4임시3"})["이름"] == "SK-000003" + + bolt = {"이름": "sub4임시볼트", "규격": "M16", "단위": "EA", "값": 1200} + keys = [own.add(me, {**bolt, "규격": f"M{i}"})["키"] for i in (16, 20)] + assert keys == ["PM000001", "PM000002"] + own.remove(me, keys[-1]) + assert own.add(me, {**bolt, "규격": "M24"})["키"] == "PM000003" diff --git a/resources/tester/test_m02_hopyo_ledger.py b/resources/tester/test_m02_hopyo_ledger.py index 710f44a89..444c5571f 100644 --- a/resources/tester/test_m02_hopyo_ledger.py +++ b/resources/tester/test_m02_hopyo_ledger.py @@ -1,146 +1,33 @@ -"""일위대가 실무자료 별칭 장부(PLAN 338-3 · `M02_Hopyo_Ledger`) — 옛 꼴 바꿔 읽음 · 새 꼴 · -층 차례(739-1 자동 = 마스터 · 이 불러오기 짝 · 아래 층 = 제안) · 느슨 찾기(규격다름) · 우리에 없음 · 안 씀 · 호표 통째 열쇠 · -위 층 읽기만 · 재검사 · 쓰기(처음파일 둠 · 옛 꼴 새로 씀) · master_data 원본 그대로. 층은 임시 폴더. +"""일위대가 짝 재검사(PLAN 338-3 · 739-1 · `M02_Hopyo_Ledger.check_pair`) — 불러오기 [내 일위대가로]가 +받은 짝을 서버가 다시 봄: 돈 로직 · 그 로직 입력 이름 · M01 자재품목 · 배 0 넘음 · 몫 (0, 1] · 금액 칸 안 받음. +옛 별칭 장부 읽기 · 쓰기 시험은 853-3 에서 지움(장부 함수 걷음). """ -import json - import pytest from M02_MasterTemplete import M02_Hopyo_Ledger as ledger -from M02_MasterTemplete import M02_Hopyo_Match as hm -from M02_MasterTemplete import M02_Hopyo_Store as hs from M02_MasterTemplete import M02_MasterTemplete_Store as store -from M02_MasterTemplete import M02_Template_Layers as layers -# 올리기 길 시험의 `client` 마당을 같이 씀 -# ruff: noqa: F811 -from resources.tester.test_m02_hopyo_excel import client, master_hash # noqa: F401 - -DIG = {"이름": "구조물터파기(인력100%)", "규격": "토사", "단위": "㎥"} -DIG_KEY = "구조물터파기(인력100%)|토사|m3" -WHO = {"id": 42, "이름": "갑"} +WHERE = "구조물터파기(인력100%)|토사|m3" -def _put_raw(folder, rows): - path = folder / hs.DIRNAME / f"{hs.MEMORY}.json" - path.parent.mkdir(parents=True, exist_ok=True) - path.write_text(json.dumps({"줄": rows}, ensure_ascii=False), encoding="utf-8") - - -def _raw(folder): - return json.loads((folder / hs.DIRNAME / f"{hs.MEMORY}.json").read_bytes())["줄"] - - -def test_열쇠는_맞춤과_같음(): - assert ledger.key(DIG) == hm.line_key(DIG) == DIG_KEY - assert ledger.hopyo_key(DIG) == "호표|" + DIG_KEY - assert ledger._loose(DIG_KEY) == "구조물터파기(인력100%)|m3" - assert ledger._loose("호표|" + DIG_KEY) == "호표|구조물터파기(인력100%)|m3" - - -def test_옛_꼴_바꿔_읽음(client): - mine = layers.personal_dir(7, 42) - _put_raw( - mine, - { - DIG_KEY: {"로직": "GF000101", "입력값": {"지역": "서울"}, "환산": 2, "확정": "t1"}, - "합판거푸집|4회|m2": {"빼기": True, "확정": "2026-10-02T10:00:00"}, - "표지석||개": {"자재": "MT004258", "입력값": {}, "환산": 1, "확정": "t"}, - "깨진|줄": {"로직": "X"}, - "빈|짝|m": {"입력값": {}}, - }, - ) # fmt: skip - got = ledger.read(mine) - assert set(got) == {DIG_KEY, "합판거푸집|4회|m2", "표지석||개"} # 모르는 꼴 뺌 - assert got[DIG_KEY] == { - "원래": {"품명": "구조물터파기(인력100%)", "규격": "토사", "단위": "m3"}, - "때": "t1", - "누가": None, - "처음파일": None, - "갈래": "짝", - "짝": [{"로직": "GF000101", "입력값": {"지역": "서울"}, "배": 2, "몫": None}], - } - assert got["합판거푸집|4회|m2"]["갈래"] == "안 씀" and got["합판거푸집|4회|m2"]["짝"] == [] - assert got["표지석||개"]["짝"] == [{"자재": "MT004258", "입력값": {}, "배": 1, "몫": None}] - - -def test_층_차례_마스터만_자동_아래_층은_제안_느슨_찾기(client): - mine, company, system = ledger.chain(layers.personal_dir(7, 42)) - assert (company, system) == (layers.company_dir(7), store.FOLDER) - new = {"갈래": "짝", "짝": [{"로직": "GF000103", "입력값": {}, "배": 1, "몫": None}]} - _put_raw(system, {DIG_KEY: new, "잔토처리(인력100%)||m3": {"갈래": "우리에 없음"}}) - _put_raw(company, {DIG_KEY: {**new, "짝": [{"로직": "GF000102", "배": 1}]}}) - got = ledger.recall(DIG, mine) # 739-1 — 회사 층 짝이 있어도 자동 = 마스터(승인) - assert (got["층"], got["주인"], got["짝"][0]["로직"], got["규격다름"], got["제안"]) == ( - "system", - None, - "GF000103", - False, - False, - ) - _put_raw(system, {"잔토처리(인력100%)||m3": {"갈래": "우리에 없음"}}) - got = ledger.recall(DIG, mine) - assert (got["층"], got["짝"][0]["로직"], got["제안"]) == ("company", "GF000102", True) - _put_raw(mine, {DIG_KEY: {"로직": "GF000101", "환산": 1}}) - got = ledger.recall(DIG, mine) - assert (got["짝"][0]["로직"], got["제안"]) == ("GF000101", True) # 제안 = 같은 층 먼저 - rock = {**DIG, "규격": "경암"} - loose = ledger.recall(rock, mine) - assert loose["규격다름"] is True and loose["층"] == "personal" # 품명|단위 느슨 - soil = {"이름": "잔토처리(인력100%)", "규격": "", "단위": "M3"} - assert ledger.recall(soil, mine)["갈래"] == "우리에 없음" - assert ledger.recall({"이름": "없는 줄", "단위": "m"}, mine) is None - assert ledger.recall(DIG, mine, whole=True) is None # 호표 통째 열쇠는 따로 - books = ledger.books(mine) - assert ledger.recall(DIG, mine, books)["짝"][0]["로직"] == "GF000101" # 한 번 읽어 넘김 - - -def test_재검사(client): +def test_짝_재검사(): known = ledger._known() - ok = { - "갈래": "짝", - "짝": [{"로직": "GF000101", "입력값": {"지역": "서울"}, "배": "2", "몫": 0.5}], - } - got = ledger.check(DIG_KEY, ok, known) - assert got["짝"] == [{"로직": "GF000101", "입력값": {"지역": "서울"}, "배": 2, "몫": 0.5}] - assert got["원래"] == {"품명": "구조물터파기(인력100%)", "규격": "토사", "단위": "m3"} - assert ledger.check(DIG_KEY, {"갈래": "안 씀"}, known)["짝"] == [] - pair = ok["짝"][0] + pair = {"로직": "GF000101", "입력값": {"지역": "서울"}, "배": "2", "몫": 0.5} + got = ledger.check_pair(pair, WHERE, known) + assert got == {"로직": "GF000101", "입력값": {"지역": "서울"}, "배": 2, "몫": 0.5} + assert ledger.times_of({}, WHERE) == (1, None) bad = [ - ("a|b", ok), - (DIG_KEY, {"갈래": "같음", "짝": ok["짝"]}), - (DIG_KEY, {"갈래": "짝", "짝": []}), - (DIG_KEY, {"갈래": "안 씀", "짝": ok["짝"]}), - (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "로직": "GC000422"}]}), # 돈 아닌 로직 - (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "입력값": {"없는칸": 1}}]}), - (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "배": 0}]}), - (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "배": "nan"}]}), - (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "몫": 1.5}]}), - (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "자재": "MT004258"}]}), - (DIG_KEY, {"갈래": "짝", "짝": [{**pair, "금액": 100}]}), # 금액 칸 받지 않음 - (DIG_KEY, {"갈래": "짝", "짝": [{"자재": "MT000000", "배": 1}]}), + {**pair, "로직": "GC000422"}, # 돈 아닌 로직 + {**pair, "입력값": {"없는칸": 1}}, + {**pair, "배": 0}, + {**pair, "배": "nan"}, + {**pair, "몫": 1.5}, + {**pair, "자재": "MT004258"}, + {**pair, "금액": 100}, # 금액 칸 받지 않음 + {"자재": "MT000000", "배": 1}, ] - for full, raw in bad: + for raw in bad: with pytest.raises(store.StoreError) as error: - ledger.check(full, raw, known) + ledger.check_pair(raw, WHERE, known) assert error.value.status == 400, raw - - -def test_쓰기_처음파일_옛_꼴_새로(client): - before = master_hash() - mine = layers.personal_dir(7, 42) - _put_raw(mine, {"합판거푸집|4회|m2": {"빼기": True, "확정": "t"}}) - row = ledger.check(DIG_KEY, {"갈래": "짝", "짝": [{"로직": "GF000101", "배": 1}]}) - assert ledger.write(mine, {DIG_KEY: row}, WHO, "가.xls") == 1 - raw = _raw(mine) - assert raw["합판거푸집|4회|m2"]["갈래"] == "안 씀" # 옛 꼴 = 쓸 때 새 꼴 - assert raw[DIG_KEY]["누가"] == WHO and raw[DIG_KEY]["처음파일"] == "가.xls" - assert raw[DIG_KEY]["때"] - ledger.write(mine, {DIG_KEY: row}, WHO, "나.xls") - assert _raw(mine)[DIG_KEY]["처음파일"] == "가.xls" # 처음파일은 있던 값 - got = ledger.put(mine, {DIG_KEY: None}, WHO) - assert got["씀"] == 1 and DIG_KEY not in _raw(mine) - with pytest.raises(store.StoreError): - ledger.put(mine, {}, WHO) - assert master_hash() == before