{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# 🎯 [DAT06] 월간 정산·보고·취합 One-click 자동화\n",
        "### Google Colab 실습 환경 (데이터·자동화·업무플랫폼 / Level 3)\n",
        "\n",
        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/edunlab/milicontent2/blob/main/uploads/DAT06/DAT06_solution.ipynb)\n",
        "\n",
        "---\n",
        "\n",
        "## 📌 1. 프로젝트 개요 및 배경\n",
        "\n",
        "| 항목 | 내용 |\n",
        "| :--- | :--- |\n",
        "| **과정 분류** | 데이터·자동화·업무플랫폼 (Level 3) |\n",
        "| **학습 소요 시간** | 10개 미션 (5일 / 총 27.0시간) |\n",
        "| **환경 사양** | Python 3.10+, numpy, pandas, matplotlib, scipy, scikit-learn |\n",
        "\n",
        "### 📖 프로젝트 목표\n",
        "미국 국방재무회계국(DFAS)은 반복적인 재무·정산 업무에 업무 자동화(RPA)를 도입해 사람이 하던 취합과 점검을 줄이는 사업을 추진해 왔다. 이 공개 사례의 학습 초점은 반복 업무 분해, 입력과 트리거, 자동 처리 순서, 오류 복구, 실행 로그, 시간 절감이다. 본 프로젝트는 이를 바탕으로 교육용 가상 부대 24개의 월간 결산 자료(물자 불출, 수리부속 소모, 탄약 정산, 장비 가동률)를 코드로 만들고, 파일 대신 메모리 안의 가상 문서와 표로 모의한다. 학습자는 업무 분해, 다형식 파싱, 검증 룰 엔진, 이상 원인 추천, 일관성 검증, 승인·반려 대시보드, 3단계 사람 결재선, 대량 배치 시험, AAR 보정, 최종 통합을 차례로 수행한다. 최종 목표는 월간 정산·보고·취합을 한 번에 실행하되 발간은 반드시 사람이 결재하도록 하는 원클릭 자동화 도구를 완성하는 것이다.\n",
        "\n",
        "> **⚠️ [교육용 가상 데이터셋 원칙]**\n",
        "> - 본 노트북의 모든 데이터(제원, 로그, 시나리오 등)는 보안 규정을 준수하여 **코드 내 난수 기반 가상 데이터로 생성**됩니다.\n",
        "> - 실제 부대 위치, 작전 인가, 실제 전장 정보, 군사 기밀 데이터는 일체 포함되지 않습니다.\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# ============================================================================\n",
        "# [Google Colab 환경 설정] 필수 라이브러리 설치 및 임포트\n",
        "# ============================================================================\n",
        "!pip install -q numpy pandas matplotlib scipy scikit-learn\n",
        "\n",
        "import os\n",
        "import sys\n",
        "import time\n",
        "import math\n",
        "import json\n",
        "import re\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# 그래프 영문 폰트 기본 설정 (환경 독립성 보장)\n",
        "plt.rcParams['font.sans-serif'] = 'DejaVu Sans'\n",
        "plt.rcParams['axes.unicode_minus'] = False\n",
        "\n",
        "print(f\"실행 환경 준비 완료 (Python {sys.version.split()[0]})\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "## 🎯 미션 01. 군수 월간 결산 항목(물자 불출, 수리부속 소모, 탄약 정산, 장비 가동률) 데이터 구조 분석\n",
        "**소요시간**: 약 1.5시간\n",
        "\n",
        "### 📋 미션 배경 및 수행 지침\n",
        "#### 미션 배경 및 당위성\n",
        "\n",
        "군수 월간 결산 항목(물자 불출, 수리부속 소모, 탄약 정산) 데이터 구조를 분석한다. 실제 전술 현장에서는 단순 탐지에 그치지 않고 신속한 위협 판단과 신뢰도 높은 의사결정이 필수적이므로, **월간 결산 4개 항목(물자 불출, 수리부속 소모, 탄약 정산, 장비 가동률)의 데이터 구조를 분석해 필드와 산식을 정의하고, 현행 결산 업무를 AS-IS/TO-BE로 비교한다.** 과업을 완수하여 오판을 방지하고 작전 대응력을 극대화해야 합니다.\n",
        "\n",
        "이 문제를 해결하기 위해 본 미션에서는 **가상 부대 24개의 월간 원장(기초·수령·불출·반납·기말)과 장비 가동 현황을 만들어 항목별 필드와 재고 산식(기말 = 기초 + 수령 + 반납 - 불출) 정리하고 규격화하는** 실습을 체계적으로 수행합니다.\n",
        "\n",
        "학습자는 실습가이드에 제시된 총 4개 세부 활동(기본 기능 구현 ➔ 결과 지표 검증 ➔ 파라미터 튜닝 및 도전과제)을 순차적으로 진행하며 핵심 판정 기준을 달성합니다.\n",
        "\n",
        "**이번 결과물:** `docs/dat06_as_is_to_be_spec.md` 형태의 결과물을 완성한다.\n",
        "\n",
        "### 🔍 평가 및 검증 기준 (PASS 조건)\n",
        "#### 미션 판정\n",
        "\n",
        "**평가 구분:** 필수\n",
        "\n",
        "**핵심 평가영역:** 현행 업무(AS-IS)와 개선 업무(TO-BE) 비교의 명확성\n",
        "\n",
        "#### 미션 PASS 조건\n",
        "\n",
        "- 정량 기준: 업무 단계 분해 10단계 이상, 병목 구간 3개소 이상 도출\n",
        "\n",
        "\n",
        "- 진행 기준: 업무 정의서 및 입출력 데이터 명세 작성 완료\n",
        "\n",
        "\n",
        "- 검증 방법: 실무 프로세스와의 일치성 검증\n",
        "\n",
        "\n",
        "#### 채점자 판정 메모\n",
        "\n",
        "> 단순 코드 실행 여부뿐만 아니라 출력된 수치와 근거 자료가 군 실무 요구사항에 부합하는지 면밀히 확인한다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"군수 월간 결산 4개 항목(물자 불출, 수리부속 소모, 탄약 정산, 장비 가동률)의 데이터 구조를 분석해 스키마를 정의하고, 월간 결산 업무를 AS-IS/TO-BE 단계로 분해해 병목 구간을 도출한다.\"\"\"\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# ---------------------------------------------------------------------------\n",
        "# [교육용가상자료] 가상 월간 결산 원장 생성기 (실제 부대명·품목·수량·재무 정보 없음)\n",
        "# 가상 대대 24개 x (물자 불출 / 수리부속 소모 / 탄약 정산) 품목 원장과 장비 가동 현황을 만든다.\n",
        "# 재고 산식: 기말 = 기초 + 수령 + 반납 - 불출,  다음 달 기초 = 이번 달 기말.\n",
        "# ---------------------------------------------------------------------------\n",
        "UNITS = [f\"가상{i:02d}대대\" for i in range(1, 25)]\n",
        "ITEMS = {\"물자불출\": [\"급식류\", \"피복류\", \"유류\", \"정비소모품\"],\n",
        "         \"수리부속\": [\"필터류\", \"베어링류\", \"전장품\", \"타이어류\"],\n",
        "         \"탄약정산\": [\"훈련탄A\", \"훈련탄B\", \"모의탄\"]}\n",
        "UNIT_CODE = {\"급식류\": \"BX\", \"피복류\": \"EA\", \"유류\": \"L\", \"정비소모품\": \"EA\", \"필터류\": \"EA\", \"베어링류\": \"EA\",\n",
        "             \"전장품\": \"EA\", \"타이어류\": \"EA\", \"훈련탄A\": \"RD\", \"훈련탄B\": \"RD\", \"모의탄\": \"RD\"}\n",
        "LEDGER_COLS = [\"month\", \"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "\n",
        "\n",
        "def make_ledger(n_months=2, seed=60):\n",
        "    \"\"\"n_months개월 원장(list of dict). 둘째 달 기초는 첫째 달 기말과 같다.\"\"\"\n",
        "    rng = np.random.default_rng(seed)\n",
        "    rows, prev = [], {}\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            for cat, items in ITEMS.items():\n",
        "                for it in items:\n",
        "                    base = int(rng.integers(80, 400))\n",
        "                    op = prev.get((u, it), base * 3)\n",
        "                    recv = int(rng.integers(0, base))\n",
        "                    issue = int(rng.integers(base // 4, base // 2 + 1))\n",
        "                    ret = int(issue * rng.uniform(0, 0.15))\n",
        "                    cl = op + recv + ret - issue\n",
        "                    rows.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"cat\": cat, \"item\": it,\n",
        "                                 \"open\": op, \"recv\": recv, \"issue\": issue, \"ret\": ret, \"close\": cl})\n",
        "                    prev[(u, it)] = cl\n",
        "    return rows\n",
        "\n",
        "\n",
        "def make_equip(n_months=2, seed=61):\n",
        "    rng = np.random.default_rng(seed)\n",
        "    out = []\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            hold = int(rng.integers(20, 60))\n",
        "            out.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"hold\": hold, \"operable\": int(hold * rng.uniform(0.78, 0.97))})\n",
        "    return out\n",
        "\n",
        "# 1) 데이터 구조 분석: 원장 4개 항목의 필드·허용값·산식\n",
        "led = pd.DataFrame(make_ledger(2), columns=LEDGER_COLS)\n",
        "eq = pd.DataFrame(make_equip(2))\n",
        "SCHEMA = {\n",
        "    \"물자불출\": {\"fields\": \"month, unit, item, open, recv, issue, ret, close\", \"rule\": \"close = open + recv + ret - issue\"},\n",
        "    \"수리부속\": {\"fields\": \"month, unit, item, open, recv, issue(소모), ret, close\", \"rule\": \"close = open + recv + ret - issue\"},\n",
        "    \"탄약정산\": {\"fields\": \"month, unit, item, open, recv, issue(사용), ret(잔탄 반납), close\", \"rule\": \"close = open + recv + ret - issue\"},\n",
        "    \"장비가동률\": {\"fields\": \"month, unit, hold(보유), operable(가동)\", \"rule\": \"가동률 = operable / hold, 0 <= 가동률 <= 1\"},\n",
        "}\n",
        "print(\"[결산 항목별 데이터 구조] [교육용가상자료]\")\n",
        "for k, v in SCHEMA.items():\n",
        "    print(f\" - {k}: 필드[{v['fields']}] 규칙[{v['rule']}]\")\n",
        "print(f\"\\n원장 {len(led)}행(부대 {led['unit'].nunique()}개 x 품목 {led['item'].nunique()}종 x 2개월), 장비 현황 {len(eq)}행\")\n",
        "chk = ((led[\"open\"] + led[\"recv\"] + led[\"ret\"] - led[\"issue\"]) == led[\"close\"]).mean()\n",
        "cont = led.pivot_table(index=[\"unit\", \"item\"], columns=\"month\", values=[\"open\", \"close\"])\n",
        "cont_ok = (cont[(\"close\", \"2026-07\")] == cont[(\"open\", \"2026-08\")]).mean()\n",
        "print(f\"재고 산식 일치율 {chk:.0%}, 월 간 연속성(전월 기말=당월 기초) {cont_ok:.0%}\")\n",
        "print(\"분류별 월 불출·소모량 합계:\")\n",
        "print(led[led[\"month\"] == \"2026-08\"].groupby(\"cat\")[\"issue\"].sum().to_string())\n",
        "print(f\"장비 평균 가동률 {(eq['operable'] / eq['hold']).mean():.1%} (가동률 낮은 부대 3개: \"\n",
        "      f\"{', '.join(eq.assign(r=eq['operable'] / eq['hold']).nsmallest(3, 'r')['unit'])})\")\n",
        "\n",
        "# 2) 월간 결산 업무 AS-IS 분해(단계, 소요 분 - 가상 측정값)와 TO-BE\n",
        "steps = [(\"예하 부대별 결산 자료 수신(메일·메신저)\", 40, \"제출 양식 표준화·자동 수집 함수\", 3),\n",
        "         (\"제출 양식 확인(서식 다른 파일 구분)\", 35, \"형식 자동 판별·별칭 사전\", 2),\n",
        "         (\"엑셀 값 복사·붙여넣기 취합\", 90, \"자동 파싱·병합\", 2),\n",
        "         (\"품목 코드·단위 수기 통일\", 60, \"코드·단위 표준 변환표\", 3),\n",
        "         (\"기초·기말 재고 산식 대조\", 55, \"검증 룰 15종 자동 적용\", 2),\n",
        "         (\"전월 대비 증감 계산\", 30, \"전월 비교표 자동 생성\", 1),\n",
        "         (\"이상 수치 확인(전화 문의)\", 75, \"이상치 후보·원인 요약 추천\", 15),\n",
        "         (\"장비 가동률 집계\", 30, \"가동률 자동 계산\", 1),\n",
        "         (\"결산 보고서 서식 작성\", 80, \"템플릿에 자동 채움\", 3),\n",
        "         (\"보급관·군수과장 결재 요청·회수\", 45, \"3단계 전자 결재 흐름\", 15),\n",
        "         (\"반려 사항 수정 후 재제출\", 50, \"반려 사유별 수정 위치 안내\", 10),\n",
        "         (\"최종본 배포·보관\", 20, \"발간본 자동 보관·배포\", 1)]\n",
        "proc = pd.DataFrame(steps, columns=[\"업무 단계\", \"AS-IS(분)\", \"TO-BE 개선\", \"TO-BE(분)\"])\n",
        "proc.index = range(1, len(proc) + 1)\n",
        "thr = proc[\"AS-IS(분)\"].mean() + 0.5 * proc[\"AS-IS(분)\"].std()\n",
        "proc[\"병목\"] = np.where(proc[\"AS-IS(분)\"] >= thr, \"병목\", \"\")\n",
        "print(f\"\\n[AS-IS / TO-BE 업무 단계 {len(proc)}단계] (병목 기준: 평균+0.5표준편차 = {thr:.0f}분 이상)\")\n",
        "print(proc[[\"업무 단계\", \"AS-IS(분)\", \"TO-BE(분)\", \"병목\"]].to_string())\n",
        "nb = int((proc[\"병목\"] == \"병목\").sum())\n",
        "a, t = proc[\"AS-IS(분)\"].sum(), proc[\"TO-BE(분)\"].sum()\n",
        "print(f\"\\n업무 단계 {len(proc)}단계(목표 10단계 이상: {'달성' if len(proc) >= 10 else '미달'}), 병목 {nb}개소(목표 3개소 이상: {'달성' if nb >= 3 else '미달'})\")\n",
        "print(f\"1회 결산 AS-IS {a}분 -> TO-BE {t}분 ({1 - t / a:.0%} 단축 예상, 가정값)\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<details>\n",
        "<summary><b>💡 [참고] 미션 01 예상 실행 결과 (Output)</b></summary>\n",
        "\n",
        "```text\n",
        "[결산 항목별 데이터 구조] [교육용가상자료]\n",
        " - 물자불출: 필드[month, unit, item, open, recv, issue, ret, close] 규칙[close = open + recv + ret - issue]\n",
        " - 수리부속: 필드[month, unit, item, open, recv, issue(소모), ret, close] 규칙[close = open + recv + ret - issue]\n",
        " - 탄약정산: 필드[month, unit, item, open, recv, issue(사용), ret(잔탄 반납), close] 규칙[close = open + recv + ret - issue]\n",
        " - 장비가동률: 필드[month, unit, hold(보유), operable(가동)] 규칙[가동률 = operable / hold, 0 <= 가동률 <= 1]\n",
        "\n",
        "원장 528행(부대 24개 x 품목 11종 x 2개월), 장비 현황 48행\n",
        "재고 산식 일치율 100%, 월 간 연속성(전월 기말=당월 기초) 100%\n",
        "분류별 월 불출·소모량 합계:\n",
        "cat\n",
        "물자불출    8270\n",
        "수리부속    8184\n",
        "탄약정산    6743\n",
        "장비 평균 가동률 87.0% (가동률 낮은 부대 3개: 가상23대대, 가상19대대, 가상22대대)\n",
        "\n",
        "[AS-IS / TO-BE 업무 단계 12단계] (병목 기준: 평균+0.5표준편차 = 62분 이상)\n",
        "                      업무 단계  AS-IS(분)  TO-BE(분)  병목\n",
        "1   예하 부대별 결산 자료 수신(메일·메신저)        40         3    \n",
        "2     제출 양식 확인(서식 다른 파일 구분)        35         2    \n",
        "3           엑셀 값 복사·붙여넣기 취합        90         2  병목\n",
        "4            품목 코드·단위 수기 통일        60         3    \n",
        "5            기초·기말 재고 산식 대조        55         2    \n",
        "6               전월 대비 증감 계산        30         1    \n",
        "7           이상 수치 확인(전화 문의)        75        15  병목\n",
        "8                 장비 가동률 집계        30         1    \n",
        "9              결산 보고서 서식 작성        80         3  병목\n",
        "10        보급관·군수과장 결재 요청·회수        45        15    \n",
        "11           반려 사항 수정 후 재제출        50        10    \n",
        "12                최종본 배포·보관        20         1    \n",
        "\n",
        "업무 단계 12단계(목표 10단계 이상: 달성), 병목 3개소(목표 3개소 이상: 달성)\n",
        "1회 결산 AS-IS 610분 -> TO-BE 58분 (90% 단축 예상, 가정값)\n",
        "```\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "## 🎯 미션 02. 다양한 양식의 엑셀/CSV 데이터 자동 파싱, 정합성 검증 및 전처리 파이프라인 구축\n",
        "**소요시간**: 약 2.0시간\n",
        "\n",
        "### 📋 미션 배경 및 수행 지침\n",
        "#### 미션 배경 및 당위성\n",
        "\n",
        "엑셀/CSV 데이터 자동 파싱, 정합성 검증 및 전처리 파이프라인을 구축한다. 실제 전술 현장에서는 단순 탐지에 그치지 않고 신속한 위협 판단과 신뢰도 높은 의사결정이 필수적이므로, **CSV, 엑셀 내보내기(탭 구분), JSON, 공문 텍스트 형식의 결산 자료를 자동 파싱하고 정합성을 검증하는 전처리 파이프라인을 구축한다.** 과업을 완수하여 오판을 방지하고 작전 대응력을 극대화해야 합니다.\n",
        "\n",
        "이 문제를 해결하기 위해 본 미션에서는 **서로 다른 서식의 가상 결산 자료 4종을 메모리 안의 문자열로 만들고 형식별 파서로 표준 레코드로 바꾼다 과정을 진행하는** 실습을 체계적으로 수행합니다.\n",
        "\n",
        "학습자는 실습가이드에 제시된 총 4개 세부 활동(기본 기능 구현 ➔ 결과 지표 검증 ➔ 파라미터 튜닝 및 도전과제)을 순차적으로 진행하며 핵심 판정 기준을 달성합니다.\n",
        "\n",
        "**이번 결과물:** `src/connectors/dat06_data_loader.py 및 스키마 정의서` 형태의 결과물을 완성한다.\n",
        "\n",
        "### 🔍 평가 및 검증 기준 (PASS 조건)\n",
        "#### 미션 판정\n",
        "\n",
        "**평가 구분:** 필수\n",
        "\n",
        "**핵심 평가영역:** 국방 서식/양식 변경에 대한 유연한 확장성\n",
        "\n",
        "#### 미션 PASS 조건\n",
        "\n",
        "- 정량 기준: 지원 파일 포맷(CSV, Excel, JSON 등) 파싱 성공률 100%\n",
        "\n",
        "\n",
        "- 진행 기준: 데이터 로더 및 스키마 유효성 검사 모듈 완성\n",
        "\n",
        "\n",
        "- 검증 방법: 다양한 형태의 샘플 군수 문서 대상 파싱 테스트\n",
        "\n",
        "\n",
        "#### 채점자 판정 메모\n",
        "\n",
        "> 단순 코드 실행 여부뿐만 아니라 출력된 수치와 근거 자료가 군 실무 요구사항에 부합하는지 면밀히 확인한다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"CSV, 엑셀 내보내기(탭 구분), JSON, 공문 텍스트 4가지 형식의 가상 결산 자료를 메모리 안에서 자동 파싱하고 머리글 별칭 대응·정합성 검증·전처리를 거쳐 표준 원장으로 합치는 파이프라인을 구축한다.\"\"\"\n",
        "import csv\n",
        "import io\n",
        "import json\n",
        "import re\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# ---------------------------------------------------------------------------\n",
        "# [교육용가상자료] 가상 월간 결산 원장 생성기 (실제 부대명·품목·수량·재무 정보 없음)\n",
        "# 가상 대대 24개 x (물자 불출 / 수리부속 소모 / 탄약 정산) 품목 원장과 장비 가동 현황을 만든다.\n",
        "# 재고 산식: 기말 = 기초 + 수령 + 반납 - 불출,  다음 달 기초 = 이번 달 기말.\n",
        "# ---------------------------------------------------------------------------\n",
        "UNITS = [f\"가상{i:02d}대대\" for i in range(1, 25)]\n",
        "ITEMS = {\"물자불출\": [\"급식류\", \"피복류\", \"유류\", \"정비소모품\"],\n",
        "         \"수리부속\": [\"필터류\", \"베어링류\", \"전장품\", \"타이어류\"],\n",
        "         \"탄약정산\": [\"훈련탄A\", \"훈련탄B\", \"모의탄\"]}\n",
        "UNIT_CODE = {\"급식류\": \"BX\", \"피복류\": \"EA\", \"유류\": \"L\", \"정비소모품\": \"EA\", \"필터류\": \"EA\", \"베어링류\": \"EA\",\n",
        "             \"전장품\": \"EA\", \"타이어류\": \"EA\", \"훈련탄A\": \"RD\", \"훈련탄B\": \"RD\", \"모의탄\": \"RD\"}\n",
        "LEDGER_COLS = [\"month\", \"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "\n",
        "\n",
        "def make_ledger(n_months=2, seed=60):\n",
        "    \"\"\"n_months개월 원장(list of dict). 둘째 달 기초는 첫째 달 기말과 같다.\"\"\"\n",
        "    rng = np.random.default_rng(seed)\n",
        "    rows, prev = [], {}\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            for cat, items in ITEMS.items():\n",
        "                for it in items:\n",
        "                    base = int(rng.integers(80, 400))\n",
        "                    op = prev.get((u, it), base * 3)\n",
        "                    recv = int(rng.integers(0, base))\n",
        "                    issue = int(rng.integers(base // 4, base // 2 + 1))\n",
        "                    ret = int(issue * rng.uniform(0, 0.15))\n",
        "                    cl = op + recv + ret - issue\n",
        "                    rows.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"cat\": cat, \"item\": it,\n",
        "                                 \"open\": op, \"recv\": recv, \"issue\": issue, \"ret\": ret, \"close\": cl})\n",
        "                    prev[(u, it)] = cl\n",
        "    return rows\n",
        "\n",
        "\n",
        "def make_equip(n_months=2, seed=61):\n",
        "    rng = np.random.default_rng(seed)\n",
        "    out = []\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            hold = int(rng.integers(20, 60))\n",
        "            out.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"hold\": hold, \"operable\": int(hold * rng.uniform(0.78, 0.97))})\n",
        "    return out\n",
        "\n",
        "TRUTH = [r for r in make_ledger(2) if r[\"month\"] == \"2026-08\"]\n",
        "FIELDS = [\"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "ALIAS = {\"unit\": [\"unit\", \"부대\", \"부대명\", \"제출부대\"], \"cat\": [\"cat\", \"구분\", \"분류\"], \"item\": [\"item\", \"품목\", \"품목명\"],\n",
        "         \"open\": [\"open\", \"기초\", \"기초재고\"], \"recv\": [\"recv\", \"수령\", \"입고\"], \"issue\": [\"issue\", \"불출\", \"소모\", \"사용\"],\n",
        "         \"ret\": [\"ret\", \"반납\"], \"close\": [\"close\", \"기말\", \"기말재고\"]}\n",
        "H2F = {h: f for f, hs in ALIAS.items() for h in hs}\n",
        "by_unit = lambda a, b: [r for r in TRUTH if UNITS[a] <= r[\"unit\"] <= UNITS[b]]\n",
        "\n",
        "# --- 가상 원본 4종(문자열) 생성: 형식마다 서식이 다르다 ---\n",
        "def mk_csv(rows):\n",
        "    return \"\\n\".join([\"부대,구분,품목,기초,수령,불출,반납,기말\"] + [\",\".join(str(r[f]) for f in FIELDS) for r in rows])\n",
        "def mk_tab(rows):        # 엑셀에서 '탭 구분 텍스트'로 내보낸 형태, 머리글이 양식 개정으로 바뀜\n",
        "    return \"\\n\".join([\"제출부대\\t분류\\t품목명\\t기초재고\\t입고\\t소모\\t반납\\t기말재고\"] + [\"\\t\".join(str(r[f]) for f in FIELDS) for r in rows])\n",
        "def mk_json(rows):\n",
        "    return json.dumps({\"form\": \"결산서\", \"rows\": [{f: r[f] for f in FIELDS} for r in rows]}, ensure_ascii=False)\n",
        "def mk_memo(rows):       # 공문 본문 형태 비정형 텍스트\n",
        "    return \"\\n\".join(f\"{i + 1}. {r['unit']} {r['cat']} {r['item']}: 기초 {r['open']}, 수령 {r['recv']}, 불출 {r['issue']}, 반납 {r['ret']}, 기말 {r['close']}\"\n",
        "                     for i, r in enumerate(rows))\n",
        "RAW = {\"csv\": mk_csv(by_unit(0, 2)), \"excel_tab\": mk_tab(by_unit(3, 5)), \"json\": mk_json(by_unit(6, 8)), \"memo\": mk_memo(by_unit(9, 11))}\n",
        "RAW[\"csv\"] += \"\\n가상99대대,물자불출,급식류,10,0,3,0,7\"   # 존재하지 않는 부대 코드(보류 대상)\n",
        "RAW[\"memo\"] += \"\\n99. 가상10대대 탄약정산 훈련탄A: 기초 50, 수령 10, 불출 abc, 반납 0, 기말 60\"   # 숫자 아님(보류 대상)\n",
        "\n",
        "# --- 파서: 모두 표준 레코드(dict) 리스트로 변환 ---\n",
        "def norm(row):\n",
        "    out = {}\n",
        "    for k, v in row.items():\n",
        "        f = H2F.get(str(k).strip())\n",
        "        if f:\n",
        "            out[f] = v.strip() if isinstance(v, str) else v\n",
        "    return out\n",
        "def parse_csv(s, delim=\",\"):\n",
        "    return [norm(r) for r in csv.DictReader(io.StringIO(s), delimiter=delim)]\n",
        "def parse_json(s):\n",
        "    return [norm(r) for r in json.loads(s)[\"rows\"]]\n",
        "def parse_memo(s):\n",
        "    pat = re.compile(r\"\\d+\\.\\s*(\\S+)\\s+(\\S+)\\s+(\\S+):\\s*기초\\s*(\\S+),\\s*수령\\s*(\\S+),\\s*불출\\s*(\\S+),\\s*반납\\s*(\\S+),\\s*기말\\s*(\\S+)\")\n",
        "    return [dict(zip(FIELDS, m.groups())) for m in map(pat.match, s.splitlines()) if m]\n",
        "PARSERS = {\"csv\": parse_csv, \"excel_tab\": lambda s: parse_csv(s, \"\\t\"), \"json\": parse_json, \"memo\": parse_memo}\n",
        "\n",
        "# --- 전처리·정합성 검증: 형 변환, 코드 확인, 산식 대조. 오류 레코드는 반영 보류 ---\n",
        "known_items = {it for v in ITEMS.values() for it in v}\n",
        "def clean(r, fmt):\n",
        "    try:\n",
        "        for f in (\"open\", \"recv\", \"issue\", \"ret\", \"close\"):\n",
        "            r[f] = int(r[f])\n",
        "    except (ValueError, KeyError):\n",
        "        return None, f\"[{fmt}] 숫자 변환 실패: {r.get('unit')} {r.get('item')}\"\n",
        "    if r[\"unit\"] not in UNITS:\n",
        "        return None, f\"[{fmt}] 존재하지 않는 부대 코드 {r['unit']}\"\n",
        "    if r[\"item\"] not in known_items:\n",
        "        return None, f\"[{fmt}] 알 수 없는 품목 {r['item']}\"\n",
        "    if r[\"open\"] + r[\"recv\"] + r[\"ret\"] - r[\"issue\"] != r[\"close\"]:\n",
        "        return None, f\"[{fmt}] 재고 산식 불일치 {r['unit']} {r['item']}\"\n",
        "    return r, None\n",
        "\n",
        "good, hold, stat = [], [], {}\n",
        "for fmt, text in RAW.items():\n",
        "    try:\n",
        "        recs = PARSERS[fmt](text)\n",
        "        stat[fmt] = {\"parse_ok\": True, \"n\": len(recs)}\n",
        "    except Exception as ex:\n",
        "        recs, stat[fmt] = [], {\"parse_ok\": False, \"n\": 0, \"err\": repr(ex)[:50]}\n",
        "    for r in recs:\n",
        "        c, why = clean(r, fmt)\n",
        "        (good if c else hold).append(c or why)\n",
        "df = pd.DataFrame(good, columns=FIELDS).sort_values([\"unit\", \"item\"]).reset_index(drop=True)\n",
        "\n",
        "print(\"[형식별 파싱 결과] [교육용가상자료]\")\n",
        "for fmt, s in stat.items():\n",
        "    print(f\" - {fmt:<9} 파싱 {'성공' if s['parse_ok'] else '실패'}, 읽은 레코드 {s['n']}건\")\n",
        "rate = sum(s[\"parse_ok\"] for s in stat.values()) / len(stat)\n",
        "print(f\"파싱 성공률 {rate:.0%}({len(stat)}개 형식), 정상 반영 {len(df)}건, 반영 보류 {len(hold)}건\")\n",
        "for w in hold:\n",
        "    print(\"   보류:\", w)\n",
        "truth = pd.DataFrame(by_unit(0, 11), columns=FIELDS).sort_values([\"unit\", \"item\"]).reset_index(drop=True)\n",
        "same = df.equals(truth.astype(df.dtypes.to_dict()))\n",
        "print(f\"원본 대비 값 일치: {'전부 일치' if same else '불일치'} ({len(df)}행 = 12개 부대 x 11품목 = {12 * 11}행)\")\n",
        "print(\"표준 원장 미리보기(앞 4행):\")\n",
        "print(df.head(4).to_string(index=False))\n",
        "print(f\"\\n목표(4개 형식 파싱 성공률 100%, 양식 변경 대응, 오류 레코드 보류): {'달성' if rate == 1 and same and len(hold) == 2 else '미달'}\")\n",
        "print(\"새 서식 대응은 ALIAS 사전에 머리글 별칭만 추가하면 된다(코드 수정 불필요).\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<details>\n",
        "<summary><b>💡 [참고] 미션 02 예상 실행 결과 (Output)</b></summary>\n",
        "\n",
        "```text\n",
        "[형식별 파싱 결과] [교육용가상자료]\n",
        " - csv       파싱 성공, 읽은 레코드 34건\n",
        " - excel_tab 파싱 성공, 읽은 레코드 33건\n",
        " - json      파싱 성공, 읽은 레코드 33건\n",
        " - memo      파싱 성공, 읽은 레코드 34건\n",
        "파싱 성공률 100%(4개 형식), 정상 반영 132건, 반영 보류 2건\n",
        "   보류: [csv] 존재하지 않는 부대 코드 가상99대대\n",
        "   보류: [memo] 숫자 변환 실패: 가상10대대 훈련탄A\n",
        "원본 대비 값 일치: 전부 일치 (132행 = 12개 부대 x 11품목 = 132행)\n",
        "표준 원장 미리보기(앞 4행):\n",
        "  unit  cat item  open  recv  issue  ret  close\n",
        "가상01대대 물자불출  급식류   402    51     39    3    417\n",
        "가상01대대 탄약정산  모의탄   943   147    117   11    984\n",
        "가상01대대 수리부속 베어링류   261    34    142    1    154\n",
        "가상01대대 물자불출   유류  1279   257    108    5   1433\n",
        "\n",
        "목표(4개 형식 파싱 성공률 100%, 양식 변경 대응, 오류 레코드 보류): 달성\n",
        "새 서식 대응은 ALIAS 사전에 머리글 별칭만 추가하면 된다(코드 수정 불필요).\n",
        "```\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "## 🎯 미션 03. 표준 정산 규칙 기반 1차 월간 결산 집계 및 통계 산출 Baseline 엔진 구현\n",
        "**소요시간**: 약 2.5시간\n",
        "\n",
        "### 📋 미션 배경 및 수행 지침\n",
        "#### 미션 배경 및 당위성\n",
        "\n",
        "표준 정산 규칙 기반 1차 월간 결산 집계 Baseline 엔진을 구현한다. 실제 전술 현장에서는 단순 탐지에 그치지 않고 신속한 위협 판단과 신뢰도 높은 의사결정이 필수적이므로, **표준 정산 규칙을 설정 문자열 룰 15종으로 분리하고, 이를 적용한 1차 월간 결산 집계 Baseline 엔진을 구현한다.** 과업을 완수하여 오판을 방지하고 작전 대응력을 극대화해야 합니다.\n",
        "\n",
        "이 문제를 해결하기 위해 본 미션에서는 **룰마다 가상 조항 번호, 조건식, 오류 메시지를 설정으로 두어 코드 수정 없이 바꿀 수 있게 수행하고 검증하는** 실습을 체계적으로 수행합니다.\n",
        "\n",
        "학습자는 실습가이드에 제시된 총 4개 세부 활동(기본 기능 구현 ➔ 결과 지표 검증 ➔ 파라미터 튜닝 및 도전과제)을 순차적으로 진행하며 핵심 판정 기준을 달성합니다.\n",
        "\n",
        "**이번 결과물:** `src/engine/dat06_rule_engine.py` 형태의 결과물을 완성한다.\n",
        "\n",
        "### 🔍 평가 및 검증 기준 (PASS 조건)\n",
        "#### 미션 판정\n",
        "\n",
        "**평가 구분:** 필수\n",
        "\n",
        "**핵심 평가영역:** 군 규정 및 지침 조항과의 정확한 일치성\n",
        "\n",
        "#### 미션 PASS 조건\n",
        "\n",
        "- 정량 기준: 업무 검증 룰 15종 이상 코딩, 룰 처리 지연시간 50ms 이하\n",
        "\n",
        "\n",
        "- 진행 기준: 룰 엔진 단위 테스트 100% 통과\n",
        "\n",
        "\n",
        "- 검증 방법: 경계 조건(Boundary condition)에 대한 룰 판정 검증\n",
        "\n",
        "\n",
        "#### 채점자 판정 메모\n",
        "\n",
        "> 단순 코드 실행 여부뿐만 아니라 출력된 수치와 근거 자료가 군 실무 요구사항에 부합하는지 면밀히 확인한다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"설정 문자열로 분리한 검증 룰 15종(가상 정산 규정 조항 대응)으로 월간 원장을 검사하고, 표준 정산 규칙에 따른 1차 결산 집계 Baseline을 계산하며 처리 지연시간과 경계 조건 단위 테스트를 확인한다.\"\"\"\n",
        "import time\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# ---------------------------------------------------------------------------\n",
        "# [교육용가상자료] 가상 월간 결산 원장 생성기 (실제 부대명·품목·수량·재무 정보 없음)\n",
        "# 가상 대대 24개 x (물자 불출 / 수리부속 소모 / 탄약 정산) 품목 원장과 장비 가동 현황을 만든다.\n",
        "# 재고 산식: 기말 = 기초 + 수령 + 반납 - 불출,  다음 달 기초 = 이번 달 기말.\n",
        "# ---------------------------------------------------------------------------\n",
        "UNITS = [f\"가상{i:02d}대대\" for i in range(1, 25)]\n",
        "ITEMS = {\"물자불출\": [\"급식류\", \"피복류\", \"유류\", \"정비소모품\"],\n",
        "         \"수리부속\": [\"필터류\", \"베어링류\", \"전장품\", \"타이어류\"],\n",
        "         \"탄약정산\": [\"훈련탄A\", \"훈련탄B\", \"모의탄\"]}\n",
        "UNIT_CODE = {\"급식류\": \"BX\", \"피복류\": \"EA\", \"유류\": \"L\", \"정비소모품\": \"EA\", \"필터류\": \"EA\", \"베어링류\": \"EA\",\n",
        "             \"전장품\": \"EA\", \"타이어류\": \"EA\", \"훈련탄A\": \"RD\", \"훈련탄B\": \"RD\", \"모의탄\": \"RD\"}\n",
        "LEDGER_COLS = [\"month\", \"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "\n",
        "\n",
        "def make_ledger(n_months=2, seed=60):\n",
        "    \"\"\"n_months개월 원장(list of dict). 둘째 달 기초는 첫째 달 기말과 같다.\"\"\"\n",
        "    rng = np.random.default_rng(seed)\n",
        "    rows, prev = [], {}\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            for cat, items in ITEMS.items():\n",
        "                for it in items:\n",
        "                    base = int(rng.integers(80, 400))\n",
        "                    op = prev.get((u, it), base * 3)\n",
        "                    recv = int(rng.integers(0, base))\n",
        "                    issue = int(rng.integers(base // 4, base // 2 + 1))\n",
        "                    ret = int(issue * rng.uniform(0, 0.15))\n",
        "                    cl = op + recv + ret - issue\n",
        "                    rows.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"cat\": cat, \"item\": it,\n",
        "                                 \"open\": op, \"recv\": recv, \"issue\": issue, \"ret\": ret, \"close\": cl})\n",
        "                    prev[(u, it)] = cl\n",
        "    return rows\n",
        "\n",
        "\n",
        "def make_equip(n_months=2, seed=61):\n",
        "    rng = np.random.default_rng(seed)\n",
        "    out = []\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            hold = int(rng.integers(20, 60))\n",
        "            out.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"hold\": hold, \"operable\": int(hold * rng.uniform(0.78, 0.97))})\n",
        "    return out\n",
        "\n",
        "# 1) 검증 룰 설정: (룰ID, 가상 조항, 조건식(참이어야 정상), 오류 메시지) - 코드 수정 없이 문자열만 바꿔 룰 변경\n",
        "RULES = [\n",
        "    (\"V01\", \"가상규정 제1조\", \"unit in UNITS\", \"존재하지 않는 부대\"),\n",
        "    (\"V02\", \"가상규정 제2조\", \"item in UNIT_CODE\", \"알 수 없는 품목\"),\n",
        "    (\"V03\", \"가상규정 제3조\", \"cat in ITEMS and item in ITEMS[cat]\", \"구분과 품목 불일치\"),\n",
        "    (\"V04\", \"가상규정 제4조\", \"open >= 0\", \"기초 재고 음수\"),\n",
        "    (\"V05\", \"가상규정 제4조\", \"recv >= 0\", \"수령량 음수\"),\n",
        "    (\"V06\", \"가상규정 제4조\", \"issue >= 0\", \"불출량 음수\"),\n",
        "    (\"V07\", \"가상규정 제4조\", \"ret >= 0\", \"반납량 음수\"),\n",
        "    (\"V08\", \"가상규정 제5조\", \"close == open + recv + ret - issue\", \"기말 산식 불일치\"),\n",
        "    (\"V09\", \"가상규정 제6조\", \"issue <= open + recv\", \"가용량 초과 불출\"),\n",
        "    (\"V10\", \"가상규정 제6조\", \"ret <= issue\", \"불출보다 큰 반납\"),\n",
        "    (\"V11\", \"가상규정 제7조\", \"close >= 0\", \"기말 재고 음수\"),\n",
        "    (\"V12\", \"가상규정 제8조\", \"len(month) == 7 and month[4] == '-'\", \"결산월 형식 오류\"),\n",
        "    (\"V13\", \"가상규정 제9조\", \"cat != '탄약정산' or issue <= 5000\", \"탄약 월 사용량 한도 초과\"),\n",
        "    (\"V14\", \"가상규정 제10조\", \"isinstance(open, int) and isinstance(close, int)\", \"수량 자료형 오류\"),\n",
        "    (\"V15\", \"가상규정 제11조\", \"issue <= max(open + recv, 1) * 0.9 or issue == 0\", \"불출 비율 과다(90% 초과)\"),\n",
        "]\n",
        "COMPILED = [(rid, art, compile(expr, rid, \"eval\"), msg) for rid, art, expr, msg in RULES]\n",
        "CTX = {\"UNITS\": UNITS, \"UNIT_CODE\": UNIT_CODE, \"ITEMS\": ITEMS}\n",
        "\n",
        "\n",
        "def check_row(row):\n",
        "    env = {**CTX, **row}\n",
        "    out = []\n",
        "    for rid, art, code, msg in COMPILED:\n",
        "        try:\n",
        "            ok = eval(code, {\"__builtins__\": {\"len\": len, \"isinstance\": isinstance, \"int\": int, \"max\": max}}, env)\n",
        "        except Exception:\n",
        "            ok = False\n",
        "        if not ok:\n",
        "            out.append((rid, art, msg))\n",
        "    return out\n",
        "\n",
        "\n",
        "# 2) 검증 실행 + 지연시간(행당) 측정\n",
        "rows = make_ledger(2)\n",
        "rng = np.random.default_rng(3)\n",
        "for i in rng.choice(len(rows), 6, replace=False):          # 오류 6건 주입(룰이 잡는지 확인)\n",
        "    k = int(rng.integers(0, 3))\n",
        "    rows[i] = {**rows[i], **[{\"close\": rows[i][\"close\"] + 7}, {\"issue\": rows[i][\"open\"] + rows[i][\"recv\"] + 50}, {\"ret\": -3}][k]}\n",
        "lat, found = [], []\n",
        "for r in rows:\n",
        "    t0 = time.perf_counter()\n",
        "    res = check_row(r)\n",
        "    lat.append((time.perf_counter() - t0) * 1000)\n",
        "    found += [(r[\"month\"], r[\"unit\"], r[\"item\"], *x) for x in res]\n",
        "lat = np.array(lat)\n",
        "print(f\"[검증 룰 {len(RULES)}종 적용] 대상 {len(rows)}행, 위반 {len(found)}건 [교육용가상자료]\")\n",
        "cnt = pd.Series([f[3] for f in found]).value_counts()\n",
        "print(\"룰별 위반 건수:\", {k: int(v) for k, v in cnt.items()})\n",
        "print(\"위반 예시(3건):\")\n",
        "for f in found[:3]:\n",
        "    print(\"  \", f)\n",
        "print(f\"룰 처리 지연: 평균 {lat.mean():.3f}ms, 최대 {lat.max():.3f}ms (목표 50ms 이하: {'달성' if lat.max() <= 50 else '미달'}, 환경에 따라 다름)\")\n",
        "\n",
        "# 3) 1차 결산 집계 Baseline: 부대 x 구분 합계, 구분별 통계\n",
        "clean = pd.DataFrame([r for r in make_ledger(2) if r[\"month\"] == \"2026-08\"])\n",
        "pv = clean.pivot_table(index=\"unit\", columns=\"cat\", values=\"issue\", aggfunc=\"sum\")\n",
        "print(\"\\n[1차 결산 집계 - 8월 불출·소모량 부대별(상위 4개)]\")\n",
        "print(pv.head(4).to_string())\n",
        "st = pv.agg([\"sum\", \"mean\", \"std\"]).round(1)\n",
        "print(\"[구분별 합계·평균·표준편차]\")\n",
        "print(st.to_string())\n",
        "print(f\"전체 기말 재고 합계 {int(clean['close'].sum())}, 보고 대상 부대 {clean['unit'].nunique()}개\")\n",
        "\n",
        "# 4) 경계 조건 단위 테스트\n",
        "base = {\"month\": \"2026-08\", \"unit\": UNITS[0], \"cat\": \"물자불출\", \"item\": \"유류\", \"open\": 100, \"recv\": 0, \"issue\": 0, \"ret\": 0, \"close\": 100}\n",
        "tests = [(\"정상 행\", base, []),\n",
        "         (\"불출 = 가용량 정확히 일치(V15만 위반)\", {**base, \"issue\": 100, \"close\": 0}, [\"V15\"]),\n",
        "         (\"불출 = 가용량+1 (V09, V11, V15)\", {**base, \"issue\": 101, \"close\": -1}, [\"V09\", \"V11\", \"V15\"]),\n",
        "         (\"기말 0 허용\", {**base, \"issue\": 90, \"close\": 10, \"ret\": 0}, []),\n",
        "         (\"반납 = 불출 경계 허용\", {**base, \"issue\": 50, \"ret\": 50, \"close\": 100}, []),\n",
        "         (\"탄약 한도 5000 경계\", {**base, \"cat\": \"탄약정산\", \"item\": \"훈련탄A\", \"open\": 9000, \"issue\": 5000, \"close\": 4000}, []),\n",
        "         (\"탄약 한도 5001 초과\", {**base, \"cat\": \"탄약정산\", \"item\": \"훈련탄A\", \"open\": 9000, \"issue\": 5001, \"close\": 3999}, [\"V13\"]),\n",
        "         (\"결산월 형식 오류\", {**base, \"month\": \"202608\"}, [\"V12\"]),\n",
        "         (\"자료형 오류(문자열 수량)\", {**base, \"open\": \"100\"}, [\"V14\"])]   # 이 경우 V14 포함 여부만 확인\n",
        "ok = 0\n",
        "print(\"\\n[경계 조건 단위 테스트]\")\n",
        "for name, r, exp in tests:\n",
        "    got = sorted(x[0] for x in check_row(r))\n",
        "    p = set(exp) <= set(got) if name.startswith(\"자료형\") else got == exp\n",
        "    ok += p\n",
        "    print(f\" - {name}: 기대 {exp} / 결과 {got} -> {'PASS' if p else 'FAIL'}\")\n",
        "print(f\"단위 테스트 {ok}/{len(tests)} 통과({ok / len(tests):.0%})\")\n",
        "print(f\"목표(룰 15종 이상, 지연 50ms 이하, 단위 테스트 100%): {'달성' if len(RULES) >= 15 and lat.max() <= 50 and ok == len(tests) else '미달'}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<details>\n",
        "<summary><b>💡 [참고] 미션 03 예상 실행 결과 (Output)</b></summary>\n",
        "\n",
        "```text\n",
        "[검증 룰 15종 적용] 대상 528행, 위반 13건 [교육용가상자료]\n",
        "룰별 위반 건수: {'V08': 6, 'V09': 3, 'V15': 3, 'V07': 1}\n",
        "위반 예시(3건):\n",
        "   ('2026-07', '가상05대대', '급식류', 'V08', '가상규정 제5조', '기말 산식 불일치')\n",
        "   ('2026-07', '가상05대대', '급식류', 'V09', '가상규정 제6조', '가용량 초과 불출')\n",
        "   ('2026-07', '가상05대대', '급식류', 'V15', '가상규정 제11조', '불출 비율 과다(90% 초과)')\n",
        "룰 처리 지연: 평균 0.008ms, 최대 0.072ms (목표 50ms 이하: 달성, 환경에 따라 다름)\n",
        "\n",
        "[1차 결산 집계 - 8월 불출·소모량 부대별(상위 4개)]\n",
        "cat     물자불출  수리부속  탄약정산\n",
        "unit                    \n",
        "가상01대대   378   385   384\n",
        "가상02대대   255   427   234\n",
        "가상03대대   239   371   168\n",
        "가상04대대   305   258   319\n",
        "[구분별 합계·평균·표준편차]\n",
        "cat     물자불출    수리부속    탄약정산\n",
        "sum   8270.0  8184.0  6743.0\n",
        "mean   344.6   341.0   281.0\n",
        "std     79.3    72.2    75.9\n",
        "전체 기말 재고 합계 199291, 보고 대상 부대 24개\n",
        "\n",
        "[경계 조건 단위 테스트]\n",
        " - 정상 행: 기대 [] / 결과 [] -> PASS\n",
        " - 불출 = 가용량 정확히 일치(V15만 위반): 기대 ['V15'] / 결과 ['V15'] -> PASS\n",
        " - 불출 = 가용량+1 (V09, V11, V15): 기대 ['V09', 'V11', 'V15'] / 결과 ['V09', 'V11', 'V15'] -> PASS\n",
        " - 기말 0 허용: 기대 [] / 결과 [] -> PASS\n",
        " - 반납 = 불출 경계 허용: 기대 [] / 결과 [] -> PASS\n",
        " - 탄약 한도 5000 경계: 기대 [] / 결과 [] -> PASS\n",
        " - 탄약 한도 5001 초과: 기대 ['V13'] / 결과 ['V13'] -> PASS\n",
        " - 결산월 형식 오류: 기대 ['V12'] / 결과 ['V12'] -> PASS\n",
        " - 자료형 오류(문자열 수량): 기대 ['V14'] / 결과 ['V04', 'V08', 'V09', 'V14', 'V15'] -> PASS\n",
        "단위 테스트 9/9 통과(100%)\n",
        "목표(룰 15종 이상, 지연 50ms 이하, 단위 테스트 100%): 달성\n",
        "```\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "## 🎯 미션 04. 데이터 이상치(전월 대비 급증 항목) 자동 감지 및 이상 원인 요약 추천 모듈 고도화\n",
        "**소요시간**: 약 3.0시간\n",
        "\n",
        "### 📋 미션 배경 및 수행 지침\n",
        "#### 미션 배경 및 당위성\n",
        "\n",
        "전월 대비 급증 항목 이상치 감지 및 이상 원인 요약 추천 모듈을 고도화한다. 실제 전술 현장에서는 단순 탐지에 그치지 않고 신속한 위협 판단과 신뢰도 높은 의사결정이 필수적이므로, **전월 대비 급증한 품목을 자동 감지하고 이상 원인을 요약해 추천하는 모듈을 고도화한다.** 과업을 완수하여 오판을 방지하고 작전 대응력을 극대화해야 합니다.\n",
        "\n",
        "이 문제를 해결하기 위해 본 미션에서는 **품목별 증가율의 로그 값에 중앙값과 MAD 기반 점수를 적용해 급증 품목을 찾는다 과정을 진행하는** 실습을 체계적으로 수행합니다.\n",
        "\n",
        "학습자는 실습가이드에 제시된 총 4개 세부 활동(기본 기능 구현 ➔ 결과 지표 검증 ➔ 파라미터 튜닝 및 도전과제)을 순차적으로 진행하며 핵심 판정 기준을 달성합니다.\n",
        "\n",
        "**이번 결과물:** `src/ai/dat06_intelligence_module.py` 형태의 결과물을 완성한다.\n",
        "\n",
        "### 🔍 평가 및 검증 기준 (PASS 조건)\n",
        "#### 미션 판정\n",
        "\n",
        "**평가 구분:** 필수\n",
        "\n",
        "**핵심 평가영역:** 추천 사유의 합리성 및 실무 수용성\n",
        "\n",
        "#### 미션 PASS 조건\n",
        "\n",
        "- 정량 기준: 추천/분류 정확도 85% 이상 달성\n",
        "\n",
        "\n",
        "- 진행 기준: AI 추론 모듈 구현 및 벤치마크 테스트 완료\n",
        "\n",
        "\n",
        "- 검증 방법: 과거 승인/처리 완료 데이터와의 추천 일치도 검증\n",
        "\n",
        "\n",
        "#### 채점자 판정 메모\n",
        "\n",
        "> 단순 코드 실행 여부뿐만 아니라 출력된 수치와 근거 자료가 군 실무 요구사항에 부합하는지 면밀히 확인한다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"전월 대비 급증한 품목을 로버스트 통계로 자동 감지하고, 훈련·정비 일정 등 맥락 정보와 대조해 이상 원인을 요약·추천하는 모듈을 구현해 감지 정확도와 원인 분류 정확도를 측정한다.\"\"\"\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# ---------------------------------------------------------------------------\n",
        "# [교육용가상자료] 가상 월간 결산 원장 생성기 (실제 부대명·품목·수량·재무 정보 없음)\n",
        "# 가상 대대 24개 x (물자 불출 / 수리부속 소모 / 탄약 정산) 품목 원장과 장비 가동 현황을 만든다.\n",
        "# 재고 산식: 기말 = 기초 + 수령 + 반납 - 불출,  다음 달 기초 = 이번 달 기말.\n",
        "# ---------------------------------------------------------------------------\n",
        "UNITS = [f\"가상{i:02d}대대\" for i in range(1, 25)]\n",
        "ITEMS = {\"물자불출\": [\"급식류\", \"피복류\", \"유류\", \"정비소모품\"],\n",
        "         \"수리부속\": [\"필터류\", \"베어링류\", \"전장품\", \"타이어류\"],\n",
        "         \"탄약정산\": [\"훈련탄A\", \"훈련탄B\", \"모의탄\"]}\n",
        "UNIT_CODE = {\"급식류\": \"BX\", \"피복류\": \"EA\", \"유류\": \"L\", \"정비소모품\": \"EA\", \"필터류\": \"EA\", \"베어링류\": \"EA\",\n",
        "             \"전장품\": \"EA\", \"타이어류\": \"EA\", \"훈련탄A\": \"RD\", \"훈련탄B\": \"RD\", \"모의탄\": \"RD\"}\n",
        "LEDGER_COLS = [\"month\", \"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "\n",
        "\n",
        "def make_ledger(n_months=2, seed=60):\n",
        "    \"\"\"n_months개월 원장(list of dict). 둘째 달 기초는 첫째 달 기말과 같다.\"\"\"\n",
        "    rng = np.random.default_rng(seed)\n",
        "    rows, prev = [], {}\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            for cat, items in ITEMS.items():\n",
        "                for it in items:\n",
        "                    base = int(rng.integers(80, 400))\n",
        "                    op = prev.get((u, it), base * 3)\n",
        "                    recv = int(rng.integers(0, base))\n",
        "                    issue = int(rng.integers(base // 4, base // 2 + 1))\n",
        "                    ret = int(issue * rng.uniform(0, 0.15))\n",
        "                    cl = op + recv + ret - issue\n",
        "                    rows.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"cat\": cat, \"item\": it,\n",
        "                                 \"open\": op, \"recv\": recv, \"issue\": issue, \"ret\": ret, \"close\": cl})\n",
        "                    prev[(u, it)] = cl\n",
        "    return rows\n",
        "\n",
        "\n",
        "def make_equip(n_months=2, seed=61):\n",
        "    rng = np.random.default_rng(seed)\n",
        "    out = []\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            hold = int(rng.integers(20, 60))\n",
        "            out.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"hold\": hold, \"operable\": int(hold * rng.uniform(0.78, 0.97))})\n",
        "    return out\n",
        "\n",
        "# 1) 가상 2개월 데이터 + 정답(숨은 원인) 생성\n",
        "led = pd.DataFrame(make_ledger(2))\n",
        "p7 = led[led[\"month\"] == \"2026-07\"].set_index([\"unit\", \"item\"])\n",
        "p8 = led[led[\"month\"] == \"2026-08\"].set_index([\"unit\", \"item\"])\n",
        "d = pd.DataFrame({\"cat\": p8[\"cat\"], \"prev\": p7[\"issue\"].clip(lower=1), \"cur\": p8[\"issue\"]})\n",
        "rng = np.random.default_rng(4)\n",
        "n = len(d)\n",
        "d[\"train_days\"] = rng.integers(0, 5, n)          # 해당 부대 월 훈련 일수(맥락)\n",
        "d[\"repair_orders\"] = rng.integers(0, 4, n)       # 정비 지시서 건수(맥락)\n",
        "d[\"special\"] = 0                                 # 일회성 특별 지급 승인 여부\n",
        "d[\"truth\"] = \"정상\"\n",
        "d[\"cur\"] = (d[\"prev\"] * rng.uniform(0.7, 1.4, n)).round().astype(int)    # 정상 변동(-30%~+40%)\n",
        "CAUSES = [\"훈련 증가\", \"정비 집중\", \"입력 자릿수 오류\", \"일회성 특별 지급\", \"원인 불명\"]\n",
        "idx = rng.choice(n, 36, replace=False)\n",
        "for k, i in enumerate(idx):\n",
        "    c = CAUSES[k % 5]\n",
        "    d.iloc[i, d.columns.get_loc(\"truth\")] = c\n",
        "    f = {\"훈련 증가\": rng.uniform(1.8, 3.0), \"정비 집중\": rng.uniform(1.8, 3.2), \"입력 자릿수 오류\": 10.0,\n",
        "         \"일회성 특별 지급\": rng.uniform(2.0, 4.0), \"원인 불명\": rng.uniform(1.9, 3.0)}[c]\n",
        "    d.iloc[i, d.columns.get_loc(\"cur\")] = int(d.iloc[i][\"prev\"] * f)\n",
        "    if c == \"훈련 증가\":\n",
        "        d.iloc[i, d.columns.get_loc(\"train_days\")] = rng.integers(8, 14)\n",
        "    if c == \"정비 집중\":\n",
        "        d.iloc[i, d.columns.get_loc(\"repair_orders\")] = rng.integers(7, 12)\n",
        "    if c == \"일회성 특별 지급\":\n",
        "        d.iloc[i, d.columns.get_loc(\"special\")] = 1\n",
        "for i in rng.choice(n, 8, replace=False):        # 정상이지만 활동이 많았던 곳(오탐 유도)\n",
        "    d.iloc[i, d.columns.get_loc(\"train_days\")] = rng.integers(8, 14)\n",
        "\n",
        "# 2) 감지: 품목별 로그 증가율의 중앙값·MAD 기반 z 점수\n",
        "d[\"ratio\"] = d[\"cur\"] / d[\"prev\"]\n",
        "lr = np.log(d[\"ratio\"])\n",
        "med = lr.groupby(level=\"item\").transform(\"median\")\n",
        "mad = (lr - med).abs().groupby(level=\"item\").transform(\"median\").clip(lower=0.05) * 1.4826\n",
        "d[\"z\"] = (lr - med) / mad\n",
        "d[\"flag\"] = (d[\"z\"] > 2.0) & (d[\"ratio\"] >= 1.6)\n",
        "\n",
        "# 3) 원인 요약 추천(규칙 기반, 사람이 확인할 후보를 제시)\n",
        "def recommend(r):\n",
        "    if abs(r[\"ratio\"] - 10) < 1.2:\n",
        "        return \"입력 자릿수 오류\"\n",
        "    if r[\"special\"]:\n",
        "        return \"일회성 특별 지급\"\n",
        "    if r[\"repair_orders\"] >= 6:\n",
        "        return \"정비 집중\"\n",
        "    if r[\"train_days\"] >= 8:\n",
        "        return \"훈련 증가\"\n",
        "    return \"원인 불명\"\n",
        "ACTION = {\"훈련 증가\": \"훈련 계획 대조 후 정상 처리\", \"정비 집중\": \"정비 지시서와 소모 수량 대조\", \"입력 자릿수 오류\": \"제출 부대에 수치 재확인 요청\",\n",
        "          \"일회성 특별 지급\": \"승인 문서 번호 확인\", \"원인 불명\": \"담당자가 부대에 직접 문의\"}\n",
        "d[\"cause\"] = np.where(d[\"flag\"], d.apply(recommend, axis=1), \"정상\")\n",
        "\n",
        "# 4) 평가\n",
        "truth_anom = d[\"truth\"] != \"정상\"\n",
        "tp = int((d[\"flag\"] & truth_anom).sum()); fp = int((d[\"flag\"] & ~truth_anom).sum()); fn = int((~d[\"flag\"] & truth_anom).sum())\n",
        "prec, rec = tp / max(tp + fp, 1), tp / max(tp + fn, 1)\n",
        "acc = float((d[\"flag\"] == truth_anom).mean())\n",
        "both = d[d[\"flag\"] & truth_anom]\n",
        "cause_acc = float((both[\"cause\"] == both[\"truth\"]).mean())\n",
        "total_acc = float(((d[\"cause\"] == d[\"truth\"])).mean())\n",
        "print(f\"[이상 감지] 대상 {n}건(부대 24 x 품목 11), 실제 급증 {int(truth_anom.sum())}건 [교육용가상자료]\")\n",
        "print(f\"감지 {int(d['flag'].sum())}건: 정확도 {acc:.1%}, 정밀도 {prec:.1%}, 재현율 {rec:.1%} (TP {tp}, FP {fp}, FN {fn})\")\n",
        "print(f\"원인 분류 정확도(감지된 실제 급증 중) {cause_acc:.1%}, 전체 분류(정상 포함) 정확도 {total_acc:.1%}\")\n",
        "print(\"\\n[원인별 감지·추천 현황]\")\n",
        "print(pd.crosstab(both[\"truth\"], both[\"cause\"]).to_string())\n",
        "print(\"\\n[이상 원인 요약 추천 예시 - 증가율 상위 5건]\")\n",
        "for (u, it), r in d[d[\"flag\"]].sort_values(\"ratio\", ascending=False).head(5).iterrows():\n",
        "    print(f\" - {u} {it}: 전월 {int(r['prev'])} -> 당월 {int(r['cur'])}({r['ratio']:.1f}배), 추정 원인 '{r['cause']}' -> 조치: {ACTION[r['cause']]}\")\n",
        "print(\"추천은 후보 제시이며 최종 원인 판단과 수치 정정은 담당자가 확인한다.\")\n",
        "print(f\"\\n목표(추천·분류 정확도 85% 이상): 감지 {'달성' if acc >= 0.85 else '미달'}, 원인 분류 {'달성' if cause_acc >= 0.85 else '미달'}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<details>\n",
        "<summary><b>💡 [참고] 미션 04 예상 실행 결과 (Output)</b></summary>\n",
        "\n",
        "```text\n",
        "[이상 감지] 대상 264건(부대 24 x 품목 11), 실제 급증 36건 [교육용가상자료]\n",
        "감지 35건: 정확도 99.6%, 정밀도 100.0%, 재현율 97.2% (TP 35, FP 0, FN 1)\n",
        "원인 분류 정확도(감지된 실제 급증 중) 100.0%, 전체 분류(정상 포함) 정확도 99.6%\n",
        "\n",
        "[원인별 감지·추천 현황]\n",
        "cause      원인 불명  일회성 특별 지급  입력 자릿수 오류  정비 집중  훈련 증가\n",
        "truth                                               \n",
        "원인 불명          6          0          0      0      0\n",
        "일회성 특별 지급      0          7          0      0      0\n",
        "입력 자릿수 오류      0          0          7      0      0\n",
        "정비 집중          0          0          0      7      0\n",
        "훈련 증가          0          0          0      0      8\n",
        "\n",
        "[이상 원인 요약 추천 예시 - 증가율 상위 5건]\n",
        " - 가상01대대 훈련탄B: 전월 93 -> 당월 930(10.0배), 추정 원인 '입력 자릿수 오류' -> 조치: 제출 부대에 수치 재확인 요청\n",
        " - 가상15대대 피복류: 전월 119 -> 당월 1190(10.0배), 추정 원인 '입력 자릿수 오류' -> 조치: 제출 부대에 수치 재확인 요청\n",
        " - 가상15대대 정비소모품: 전월 124 -> 당월 1240(10.0배), 추정 원인 '입력 자릿수 오류' -> 조치: 제출 부대에 수치 재확인 요청\n",
        " - 가상19대대 모의탄: 전월 174 -> 당월 1740(10.0배), 추정 원인 '입력 자릿수 오류' -> 조치: 제출 부대에 수치 재확인 요청\n",
        " - 가상21대대 정비소모품: 전월 146 -> 당월 1460(10.0배), 추정 원인 '입력 자릿수 오류' -> 조치: 제출 부대에 수치 재확인 요청\n",
        "추천은 후보 제시이며 최종 원인 판단과 수치 정정은 담당자가 확인한다.\n",
        "\n",
        "목표(추천·분류 정확도 85% 이상): 감지 달성, 원인 분류 달성\n",
        "```\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "## 🎯 미션 05. 정산 결과의 회계적 일관성 검증 및 신뢰도 검증 엔진 개발\n",
        "**소요시간**: 약 3.0시간\n",
        "\n",
        "### 📋 미션 배경 및 수행 지침\n",
        "#### 미션 배경 및 당위성\n",
        "\n",
        "정산 결과의 회계적 일관성 검증 및 신뢰도 검증 엔진을 개발한다. 실제 전술 현장에서는 단순 탐지에 그치지 않고 신속한 위협 판단과 신뢰도 높은 의사결정이 필수적이므로, **정산 결과의 회계적 일관성을 검증하고 부대별 신뢰도 점수를 산출하는 엔진을 입력-분석-검토-결과 4개 화면으로 구현한다.** 과업을 완수하여 오판을 방지하고 작전 대응력을 극대화해야 합니다.\n",
        "\n",
        "이 문제를 해결하기 위해 본 미션에서는 **재고 산식, 전월 기말과 당월 기초의 연속성, 부대 합계와 분류 합계의 교차 대조, 장비 가동률 범위를 검사하고 오류 8건을 주입해 검출 여부 확인하고 유효성을 점검하는** 실습을 체계적으로 수행합니다.\n",
        "\n",
        "학습자는 실습가이드에 제시된 총 4개 세부 활동(기본 기능 구현 ➔ 결과 지표 검증 ➔ 파라미터 튜닝 및 도전과제)을 순차적으로 진행하며 핵심 판정 기준을 달성합니다.\n",
        "\n",
        "**이번 결과물:** `src/ui/dat06_app.py` 형태의 결과물을 완성한다.\n",
        "\n",
        "### 🔍 평가 및 검증 기준 (PASS 조건)\n",
        "#### 미션 판정\n",
        "\n",
        "**평가 구분:** 필수\n",
        "\n",
        "**핵심 평가영역:** 군 실무자 친화적 디자인 및 조작 편의성\n",
        "\n",
        "#### 미션 PASS 조건\n",
        "\n",
        "- 정량 기준: 핵심 화면 4종(입력-분석-검토-결과) 구현 완료\n",
        "\n",
        "\n",
        "- 진행 기준: UI 프로토타입 로컬 서버 구동 및 전체 페이지 네비게이션 확인\n",
        "\n",
        "\n",
        "- 검증 방법: 사용성 평가(UX Walkthrough) 및 인터랙션 테스트\n",
        "\n",
        "\n",
        "#### 채점자 판정 메모\n",
        "\n",
        "> 단순 코드 실행 여부뿐만 아니라 출력된 수치와 근거 자료가 군 실무 요구사항에 부합하는지 면밀히 확인한다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"결산 결과의 회계적 일관성(재고 산식·월 연속성·합계 교차 대조·가동률 범위)을 검증해 부대별 신뢰도 점수를 산출하고, 입력-분석-검토-결과 4개 화면을 텍스트 화면으로 구현한다.\"\"\"\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# ---------------------------------------------------------------------------\n",
        "# [교육용가상자료] 가상 월간 결산 원장 생성기 (실제 부대명·품목·수량·재무 정보 없음)\n",
        "# 가상 대대 24개 x (물자 불출 / 수리부속 소모 / 탄약 정산) 품목 원장과 장비 가동 현황을 만든다.\n",
        "# 재고 산식: 기말 = 기초 + 수령 + 반납 - 불출,  다음 달 기초 = 이번 달 기말.\n",
        "# ---------------------------------------------------------------------------\n",
        "UNITS = [f\"가상{i:02d}대대\" for i in range(1, 25)]\n",
        "ITEMS = {\"물자불출\": [\"급식류\", \"피복류\", \"유류\", \"정비소모품\"],\n",
        "         \"수리부속\": [\"필터류\", \"베어링류\", \"전장품\", \"타이어류\"],\n",
        "         \"탄약정산\": [\"훈련탄A\", \"훈련탄B\", \"모의탄\"]}\n",
        "UNIT_CODE = {\"급식류\": \"BX\", \"피복류\": \"EA\", \"유류\": \"L\", \"정비소모품\": \"EA\", \"필터류\": \"EA\", \"베어링류\": \"EA\",\n",
        "             \"전장품\": \"EA\", \"타이어류\": \"EA\", \"훈련탄A\": \"RD\", \"훈련탄B\": \"RD\", \"모의탄\": \"RD\"}\n",
        "LEDGER_COLS = [\"month\", \"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "\n",
        "\n",
        "def make_ledger(n_months=2, seed=60):\n",
        "    \"\"\"n_months개월 원장(list of dict). 둘째 달 기초는 첫째 달 기말과 같다.\"\"\"\n",
        "    rng = np.random.default_rng(seed)\n",
        "    rows, prev = [], {}\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            for cat, items in ITEMS.items():\n",
        "                for it in items:\n",
        "                    base = int(rng.integers(80, 400))\n",
        "                    op = prev.get((u, it), base * 3)\n",
        "                    recv = int(rng.integers(0, base))\n",
        "                    issue = int(rng.integers(base // 4, base // 2 + 1))\n",
        "                    ret = int(issue * rng.uniform(0, 0.15))\n",
        "                    cl = op + recv + ret - issue\n",
        "                    rows.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"cat\": cat, \"item\": it,\n",
        "                                 \"open\": op, \"recv\": recv, \"issue\": issue, \"ret\": ret, \"close\": cl})\n",
        "                    prev[(u, it)] = cl\n",
        "    return rows\n",
        "\n",
        "\n",
        "def make_equip(n_months=2, seed=61):\n",
        "    rng = np.random.default_rng(seed)\n",
        "    out = []\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            hold = int(rng.integers(20, 60))\n",
        "            out.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"hold\": hold, \"operable\": int(hold * rng.uniform(0.78, 0.97))})\n",
        "    return out\n",
        "\n",
        "# ---------- 화면 1: 입력 ----------\n",
        "led = pd.DataFrame(make_ledger(2))\n",
        "eq = pd.DataFrame(make_equip(2))\n",
        "cur = led[led[\"month\"] == \"2026-08\"].copy()\n",
        "prev = led[led[\"month\"] == \"2026-07\"].set_index([\"unit\", \"item\"])\n",
        "rng = np.random.default_rng(5)\n",
        "faults = []                                        # 가상 오류 주입 8건\n",
        "for i in rng.choice(cur.index, 8, replace=False):\n",
        "    kind = [\"산식\", \"연속성\", \"산식\", \"연속성\"][len(faults) % 4]\n",
        "    if kind == \"산식\":\n",
        "        cur.loc[i, \"close\"] += int(rng.integers(5, 40))\n",
        "    else:\n",
        "        cur.loc[i, \"open\"] += int(rng.integers(5, 40)); cur.loc[i, \"close\"] = cur.loc[i, \"open\"] + cur.loc[i, \"recv\"] + cur.loc[i, \"ret\"] - cur.loc[i, \"issue\"]\n",
        "    faults.append((cur.loc[i, \"unit\"], cur.loc[i, \"item\"], kind))\n",
        "eq2 = eq[eq[\"month\"] == \"2026-08\"].copy()\n",
        "eq2.iloc[3, eq2.columns.get_loc(\"operable\")] = eq2.iloc[3][\"hold\"] + 4   # 가동 대수가 보유 대수 초과\n",
        "SCREEN1 = f\"원장 {len(cur)}행(월 2026-08), 장비 현황 {len(eq2)}행, 전월 원장 {len(prev)}행 적재 / 양식 검사 통과\"\n",
        "print(\"[화면 1. 입력]\", SCREEN1)\n",
        "\n",
        "# ---------- 화면 2: 분석(일관성 검사 4종) ----------\n",
        "issues = []\n",
        "for r in cur.itertuples():\n",
        "    if r.open + r.recv + r.ret - r.issue != r.close:\n",
        "        issues.append((r.unit, r.item, \"C1 재고 산식 불일치\", abs(r.open + r.recv + r.ret - r.issue - r.close)))\n",
        "    if prev.loc[(r.unit, r.item), \"close\"] != r.open:\n",
        "        issues.append((r.unit, r.item, \"C2 전월 기말 != 당월 기초\", abs(prev.loc[(r.unit, r.item), \"close\"] - r.open)))\n",
        "unit_sum = cur.groupby(\"unit\")[[\"open\", \"recv\", \"ret\", \"issue\", \"close\"]].sum()\n",
        "cat_sum = cur.groupby([\"unit\", \"cat\"])[[\"open\", \"recv\", \"ret\", \"issue\", \"close\"]].sum().groupby(\"unit\").sum()\n",
        "for u in unit_sum.index:                           # C3 교차 대조: 부대 합계 = 분류 합계의 합\n",
        "    if not (unit_sum.loc[u] == cat_sum.loc[u]).all():\n",
        "        issues.append((u, \"-\", \"C3 합계 교차 대조 불일치\", 0))\n",
        "for r in eq2.itertuples():\n",
        "    if not (0 <= r.operable <= r.hold):\n",
        "        issues.append((r.unit, \"장비\", \"C4 가동 대수가 보유 대수 초과\", r.operable - r.hold))\n",
        "iss = pd.DataFrame(issues, columns=[\"부대\", \"품목\", \"검사\", \"차이\"])\n",
        "print(f\"[화면 2. 분석] 검사 4종 수행, 불일치 {len(iss)}건\")\n",
        "print(iss[\"검사\"].value_counts().to_string())\n",
        "\n",
        "# ---------- 신뢰도 점수 ----------\n",
        "score = pd.Series(100.0, index=UNITS)\n",
        "W = {\"C1\": 12, \"C2\": 10, \"C3\": 15, \"C4\": 8}\n",
        "for r in iss.itertuples():\n",
        "    score[r.부대] -= W[r.검사[:2]]\n",
        "score = score.clip(lower=0)\n",
        "grade = pd.cut(score, [-1, 69, 89, 100], labels=[\"C(재제출)\", \"B(검토)\", \"A(양호)\"])\n",
        "\n",
        "# ---------- 화면 3: 검토 ----------\n",
        "print(f\"\\n[화면 3. 검토] 신뢰도 100점 미만 부대와 검토 대기 사항 [교육용가상자료]\")\n",
        "low = iss.groupby(\"부대\").agg(건수=(\"검사\", \"count\"), 유형=(\"검사\", lambda s: \", \".join(sorted(set(x[:2] for x in s))))).join(score.rename(\"점수\"))\n",
        "print(low.sort_values(\"점수\").to_string())\n",
        "print(\"검토자는 불일치 건별로 '수정 요청 / 정상 확인' 중 선택하며, 수정은 제출 부대가 한다(시스템이 값을 임의로 바꾸지 않는다).\")\n",
        "\n",
        "# ---------- 화면 4: 결과 ----------\n",
        "detected = {(u, i) for u, i, k in faults}\n",
        "caught = {(r.부대, r.품목) for r in iss.itertuples() if r.검사[:2] in (\"C1\", \"C2\")}\n",
        "print(f\"\\n[화면 4. 결과] 부대 {len(score)}개 중 A {int((grade == 'A(양호)').sum())} / B {int((grade == 'B(검토)').sum())} / C {int((grade == 'C(재제출)').sum())}\")\n",
        "print(f\"평균 신뢰도 {score.mean():.1f}점, 주입 오류 {len(faults)}건 중 검출 {len(detected & caught)}건({len(detected & caught) / len(faults):.0%}), 가동률 범위 오류 {int((iss['검사'].str[:2] == 'C4').sum())}건\")\n",
        "ok = len(detected & caught) == len(faults)\n",
        "print(f\"\\n목표(핵심 화면 4종 구현, 일관성 검증 엔진 동작): {'달성' if ok else '미달'} (화면 4종: 입력/분석/검토/결과)\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<details>\n",
        "<summary><b>💡 [참고] 미션 05 예상 실행 결과 (Output)</b></summary>\n",
        "\n",
        "```text\n",
        "[화면 1. 입력] 원장 264행(월 2026-08), 장비 현황 24행, 전월 원장 264행 적재 / 양식 검사 통과\n",
        "[화면 2. 분석] 검사 4종 수행, 불일치 9건\n",
        "검사\n",
        "C2 전월 기말 != 당월 기초     4\n",
        "C1 재고 산식 불일치          4\n",
        "C4 가동 대수가 보유 대수 초과    1\n",
        "\n",
        "[화면 3. 검토] 신뢰도 100점 미만 부대와 검토 대기 사항 [교육용가상자료]\n",
        "        건수      유형    점수\n",
        "부대                      \n",
        "가상16대대   2  C1, C2  78.0\n",
        "가상12대대   1      C1  88.0\n",
        "가상13대대   1      C1  88.0\n",
        "가상20대대   1      C1  88.0\n",
        "가상01대대   1      C2  90.0\n",
        "가상07대대   1      C2  90.0\n",
        "가상19대대   1      C2  90.0\n",
        "가상04대대   1      C4  92.0\n",
        "검토자는 불일치 건별로 '수정 요청 / 정상 확인' 중 선택하며, 수정은 제출 부대가 한다(시스템이 값을 임의로 바꾸지 않는다).\n",
        "\n",
        "[화면 4. 결과] 부대 24개 중 A 20 / B 4 / C 0\n",
        "평균 신뢰도 96.0점, 주입 오류 8건 중 검출 8건(100%), 가동률 범위 오류 1건\n",
        "\n",
        "목표(핵심 화면 4종 구현, 일관성 검증 엔진 동작): 달성 (화면 4종: 입력/분석/검토/결과)\n",
        "```\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "## 🎯 미션 06. 군수 결산 보고서 생성 및 승인/반려 관리 대화형 웹 대시보드 구현\n",
        "**소요시간**: 약 2.5시간\n",
        "\n",
        "### 📋 미션 배경 및 수행 지침\n",
        "#### 미션 배경 및 당위성\n",
        "\n",
        "군수 결산 보고서 생성 및 승인/반려 대화형 웹 대시보드를 구현한다. 실제 전술 현장에서는 단순 탐지에 그치지 않고 신속한 위협 판단과 신뢰도 높은 의사결정이 필수적이므로, **결산 보고서 생성과 승인·반려 상태를 관리하는 대시보드를 구현하고, 예외 상황에서도 중단되지 않는 입력 검증기와 에러 핸들러를 갖춘다.** 과업을 완수하여 오판을 방지하고 작전 대응력을 극대화해야 합니다.\n",
        "\n",
        "이 문제를 해결하기 위해 본 미션에서는 **부대별 보고서를 생성해 작성-제출-승인-반려 상태 전이를 관리하고 현황판과 그래프로 보여 준다 과정을 진행하는** 실습을 체계적으로 수행합니다.\n",
        "\n",
        "학습자는 실습가이드에 제시된 총 4개 세부 활동(기본 기능 구현 ➔ 결과 지표 검증 ➔ 파라미터 튜닝 및 도전과제)을 순차적으로 진행하며 핵심 판정 기준을 달성합니다.\n",
        "\n",
        "**이번 결과물:** `src/utils/dat06_validator.py 및 에러 핸들러` 형태의 결과물을 완성한다.\n",
        "\n",
        "### 🔍 평가 및 검증 기준 (PASS 조건)\n",
        "#### 미션 판정\n",
        "\n",
        "**평가 구분:** 필수\n",
        "\n",
        "**핵심 평가영역:** 사용자에게 알기 쉬운 에러 메시지 및 조치 가이드 제공\n",
        "\n",
        "#### 미션 PASS 조건\n",
        "\n",
        "- 정량 기준: 예외 상황 발생 시 크래시(Crash) 0건, 에러 로그 기록률 100%\n",
        "\n",
        "\n",
        "- 진행 기준: 예외 주입 테스트 10종 통과 및 감사 로그 파일 생성\n",
        "\n",
        "\n",
        "- 검증 방법: 비정상 데이터(결측, 특수문자, 대용량) 스트레스 테스트\n",
        "\n",
        "\n",
        "#### 채점자 판정 메모\n",
        "\n",
        "> 단순 코드 실행 여부뿐만 아니라 출력된 수치와 근거 자료가 군 실무 요구사항에 부합하는지 면밀히 확인한다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"부대별 결산 보고서를 생성하고 제출·승인·반려 상태를 관리하는 대시보드(상태 현황판·그래프)를 구현하며, 입력 검증기와 에러 핸들러로 예외 10종을 크래시 없이 로그에 기록하고 사용자 조치 안내를 출력한다.\"\"\"\n",
        "import json\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# ---------------------------------------------------------------------------\n",
        "# [교육용가상자료] 가상 월간 결산 원장 생성기 (실제 부대명·품목·수량·재무 정보 없음)\n",
        "# 가상 대대 24개 x (물자 불출 / 수리부속 소모 / 탄약 정산) 품목 원장과 장비 가동 현황을 만든다.\n",
        "# 재고 산식: 기말 = 기초 + 수령 + 반납 - 불출,  다음 달 기초 = 이번 달 기말.\n",
        "# ---------------------------------------------------------------------------\n",
        "UNITS = [f\"가상{i:02d}대대\" for i in range(1, 25)]\n",
        "ITEMS = {\"물자불출\": [\"급식류\", \"피복류\", \"유류\", \"정비소모품\"],\n",
        "         \"수리부속\": [\"필터류\", \"베어링류\", \"전장품\", \"타이어류\"],\n",
        "         \"탄약정산\": [\"훈련탄A\", \"훈련탄B\", \"모의탄\"]}\n",
        "UNIT_CODE = {\"급식류\": \"BX\", \"피복류\": \"EA\", \"유류\": \"L\", \"정비소모품\": \"EA\", \"필터류\": \"EA\", \"베어링류\": \"EA\",\n",
        "             \"전장품\": \"EA\", \"타이어류\": \"EA\", \"훈련탄A\": \"RD\", \"훈련탄B\": \"RD\", \"모의탄\": \"RD\"}\n",
        "LEDGER_COLS = [\"month\", \"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "\n",
        "\n",
        "def make_ledger(n_months=2, seed=60):\n",
        "    \"\"\"n_months개월 원장(list of dict). 둘째 달 기초는 첫째 달 기말과 같다.\"\"\"\n",
        "    rng = np.random.default_rng(seed)\n",
        "    rows, prev = [], {}\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            for cat, items in ITEMS.items():\n",
        "                for it in items:\n",
        "                    base = int(rng.integers(80, 400))\n",
        "                    op = prev.get((u, it), base * 3)\n",
        "                    recv = int(rng.integers(0, base))\n",
        "                    issue = int(rng.integers(base // 4, base // 2 + 1))\n",
        "                    ret = int(issue * rng.uniform(0, 0.15))\n",
        "                    cl = op + recv + ret - issue\n",
        "                    rows.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"cat\": cat, \"item\": it,\n",
        "                                 \"open\": op, \"recv\": recv, \"issue\": issue, \"ret\": ret, \"close\": cl})\n",
        "                    prev[(u, it)] = cl\n",
        "    return rows\n",
        "\n",
        "\n",
        "def make_equip(n_months=2, seed=61):\n",
        "    rng = np.random.default_rng(seed)\n",
        "    out = []\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            hold = int(rng.integers(20, 60))\n",
        "            out.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"hold\": hold, \"operable\": int(hold * rng.uniform(0.78, 0.97))})\n",
        "    return out\n",
        "\n",
        "LEDGER = pd.DataFrame(make_ledger(2))\n",
        "LOG, REPORTS = [], {}\n",
        "\n",
        "\n",
        "class AppError(Exception):\n",
        "    def __init__(self, code, msg, guide):\n",
        "        super().__init__(msg); self.code, self.msg, self.guide = code, msg, guide\n",
        "\n",
        "\n",
        "def validate(unit, month, rows):\n",
        "    if unit not in UNITS:\n",
        "        raise AppError(\"E01\", f\"존재하지 않는 부대 '{unit}'\", \"부대 목록(가상01~24대대)에서 선택\")\n",
        "    if month not in set(LEDGER[\"month\"]):\n",
        "        raise AppError(\"E02\", f\"결산월 '{month}' 자료 없음\", \"2026-07 또는 2026-08 중 선택\")\n",
        "    if len(rows) == 0:\n",
        "        raise AppError(\"E03\", \"해당 부대 자료가 비어 있음\", \"제출 부대에 원장 재제출 요청\")\n",
        "    for c in (\"open\", \"recv\", \"issue\", \"ret\", \"close\"):\n",
        "        if c not in rows.columns:\n",
        "            raise AppError(\"E04\", f\"필수 열 '{c}' 누락\", \"표준 양식을 다시 내려받아 작성\")\n",
        "        if not pd.api.types.is_numeric_dtype(rows[c]):\n",
        "            raise AppError(\"E05\", f\"'{c}' 열에 숫자가 아닌 값\", \"숫자만 입력(단위 문자 제거)\")\n",
        "        if (rows[c] < 0).any():\n",
        "            raise AppError(\"E06\", f\"'{c}' 열에 음수\", \"수량 0 이상으로 수정\")\n",
        "\n",
        "\n",
        "def generate(unit, month, data=None):\n",
        "    rows = data if data is not None else LEDGER[(LEDGER[\"unit\"] == unit) & (LEDGER[\"month\"] == month)]\n",
        "    validate(unit, month, rows)\n",
        "    rid = f\"RPT-{unit[2:4]}-{month[-2:]}\"\n",
        "    if rid in REPORTS:\n",
        "        raise AppError(\"E07\", f\"이미 생성된 보고서 {rid}\", \"기존 보고서를 열어 수정·재제출\")\n",
        "    REPORTS[rid] = {\"unit\": unit, \"month\": month, \"status\": \"작성\", \"issue\": int(rows[\"issue\"].sum()), \"close\": int(rows[\"close\"].sum()),\n",
        "                    \"hist\": [(\"작성\", \"system\")]}\n",
        "    return rid\n",
        "\n",
        "\n",
        "FLOW = {\"제출\": (\"작성\", \"제출\"), \"승인\": (\"제출\", \"승인\"), \"반려\": (\"제출\", \"반려\"), \"재작성\": (\"반려\", \"작성\")}\n",
        "\n",
        "\n",
        "def act(rid, action, who, reason=\"\"):\n",
        "    if rid not in REPORTS:\n",
        "        raise AppError(\"E08\", f\"보고서 {rid} 없음\", \"보고서 번호를 목록에서 확인\")\n",
        "    if action not in FLOW:\n",
        "        raise AppError(\"E09\", f\"알 수 없는 처리 '{action}'\", \"제출/승인/반려/재작성 중 선택\")\n",
        "    need, new = FLOW[action]\n",
        "    if REPORTS[rid][\"status\"] != need:\n",
        "        raise AppError(\"E10\", f\"현재 상태 '{REPORTS[rid]['status']}'에서 '{action}' 불가\", f\"'{need}' 상태에서만 가능\")\n",
        "    if action == \"반려\" and not reason.strip():\n",
        "        raise AppError(\"E11\", \"반려 사유 없음\", \"반려 사유를 한 줄 이상 입력\")\n",
        "    REPORTS[rid][\"status\"] = new\n",
        "    REPORTS[rid][\"hist\"].append((new, who + (f\": {reason}\" if reason else \"\")))\n",
        "\n",
        "\n",
        "def safe(fn, *a, **k):\n",
        "    \"\"\"에러 핸들러: 모든 예외를 잡아 로그에 남기고 사용자에게 알기 쉬운 메시지와 조치를 돌려준다(크래시 없음).\"\"\"\n",
        "    try:\n",
        "        r = fn(*a, **k)\n",
        "        LOG.append({\"level\": \"INFO\", \"code\": \"OK\", \"msg\": fn.__name__}); return r\n",
        "    except AppError as e:\n",
        "        LOG.append({\"level\": \"ERROR\", \"code\": e.code, \"msg\": e.msg, \"guide\": e.guide}); return None\n",
        "    except Exception as e:                    # 예상 밖 오류도 기록\n",
        "        LOG.append({\"level\": \"ERROR\", \"code\": \"E99\", \"msg\": repr(e)[:50], \"guide\": \"운영 담당자에게 로그 전달\"}); return None\n",
        "\n",
        "\n",
        "# 1) 정상 흐름: 12개 부대 보고서 생성 -> 제출 -> 승인 8 / 반려 2 / 대기 2\n",
        "rids = [safe(generate, u, \"2026-08\") for u in UNITS[:12]]\n",
        "for i, rid in enumerate(rids):\n",
        "    safe(act, rid, \"제출\", f\"담당자{i % 3 + 1}\")\n",
        "    if i < 8:\n",
        "        safe(act, rid, \"승인\", \"보급관\")\n",
        "    elif i < 10:\n",
        "        safe(act, rid, \"반려\", \"보급관\", \"기말 재고 산식 재확인 요망\")\n",
        "board = pd.DataFrame([{\"보고서\": k, **{x: v[x] for x in (\"unit\", \"status\", \"issue\", \"close\")}} for k, v in REPORTS.items()])\n",
        "print(\"[결산 보고서 현황판] [교육용가상자료]\")\n",
        "print(board.rename(columns={\"unit\": \"부대\", \"status\": \"상태\", \"issue\": \"불출합\", \"close\": \"기말합\"}).to_string(index=False))\n",
        "print(\"상태별:\", board[\"status\"].value_counts().to_dict())\n",
        "safe(act, rids[8], \"재작성\", \"담당자\")\n",
        "print(\"반려 건 재작성 후 상태:\", REPORTS[rids[8]][\"status\"], \"/ 이력:\", REPORTS[rids[8]][\"hist\"][-3:])\n",
        "\n",
        "# 2) 예외 주입 10종\n",
        "LOG.clear()\n",
        "bad = LEDGER[(LEDGER[\"unit\"] == UNITS[20]) & (LEDGER[\"month\"] == \"2026-08\")].copy()\n",
        "neg = bad.copy(); neg.iloc[0, neg.columns.get_loc(\"issue\")] = -5\n",
        "txt = bad.copy(); txt[\"issue\"] = txt[\"issue\"].astype(str) + \"개\"\n",
        "nocol = bad.drop(columns=[\"ret\"])\n",
        "cases = [(\"부대명 오류\", generate, (\"가상99대대\", \"2026-08\")), (\"월 오류\", generate, (UNITS[20], \"2027-01\")),\n",
        "         (\"빈 자료\", generate, (UNITS[20], \"2026-08\", bad.iloc[0:0])), (\"열 누락\", generate, (UNITS[20], \"2026-08\", nocol)),\n",
        "         (\"숫자 아님\", generate, (UNITS[20], \"2026-08\", txt)), (\"음수\", generate, (UNITS[20], \"2026-08\", neg)),\n",
        "         (\"중복 생성\", generate, (UNITS[0], \"2026-08\")), (\"없는 보고서\", act, (\"RPT-00-00\", \"승인\", \"보급관\")),\n",
        "         (\"상태 위반(미제출 승인)\", act, (rids[8], \"승인\", \"보급관\")), (\"반려 사유 누락\", act, (rids[11], \"반려\", \"보급관\", \" \"))]\n",
        "crash = 0\n",
        "LOG.clear()\n",
        "for name, fn, args in cases:\n",
        "    try:\n",
        "        safe(fn, *args)\n",
        "    except BaseException:\n",
        "        crash += 1\n",
        "errs = [l for l in LOG if l[\"level\"] == \"ERROR\"]\n",
        "print(\"\\n[예외 주입 결과 - 사용자 안내 메시지]\")\n",
        "for (name, _, _), l in zip(cases, errs):\n",
        "    print(f\" {l['code']} {name:<14} {l['msg']:<28} -> 조치: {l['guide']}\")\n",
        "rate = len(errs) / len(cases)\n",
        "print(f\"예외 {len(cases)}종 중 로그 기록 {len(errs)}건(기록률 {rate:.0%}), 크래시 {crash}건\")\n",
        "print(\"로그 예시:\", json.dumps(errs[0], ensure_ascii=False))\n",
        "print(f\"목표(크래시 0건, 에러 로그 기록률 100%): {'달성' if crash == 0 and rate == 1 else '미달'}\")\n",
        "\n",
        "fig, ax = plt.subplots(1, 2, figsize=(11, 4))\n",
        "cnt = board[\"status\"].map({\"승인\": \"approved\", \"반려\": \"rejected\", \"제출\": \"pending\"}).fillna(\"draft\").value_counts()\n",
        "ax[0].bar(cnt.index, cnt.values, color=\"tab:blue\"); ax[0].set_title(\"Report status\")\n",
        "ax[1].barh(board[\"unit\"].str[2:4], board[\"issue\"], color=\"tab:gray\"); ax[1].set_title(\"Issued quantity by unit (synthetic)\")\n",
        "plt.tight_layout(); plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<details>\n",
        "<summary><b>💡 [참고] 미션 06 예상 실행 결과 (Output)</b></summary>\n",
        "\n",
        "```text\n",
        "[결산 보고서 현황판] [교육용가상자료]\n",
        "      보고서     부대 상태  불출합   기말합\n",
        "RPT-01-08 가상01대대 승인 1147  8915\n",
        "RPT-02-08 가상02대대 승인  916  9139\n",
        "RPT-03-08 가상03대대 승인  778  7428\n",
        "RPT-04-08 가상04대대 승인  882  8357\n",
        "RPT-05-08 가상05대대 승인  920  7718\n",
        "RPT-06-08 가상06대대 승인  887 10211\n",
        "RPT-07-08 가상07대대 승인  967  8567\n",
        "RPT-08-08 가상08대대 승인  877  7738\n",
        "RPT-09-08 가상09대대 반려 1056  8987\n",
        "RPT-10-08 가상10대대 반려 1015  9029\n",
        "RPT-11-08 가상11대대 제출 1130  6845\n",
        "RPT-12-08 가상12대대 제출 1266  9330\n",
        "상태별: {'승인': 8, '반려': 2, '제출': 2}\n",
        "반려 건 재작성 후 상태: 작성 / 이력: [('제출', '담당자3'), ('반려', '보급관: 기말 재고 산식 재확인 요망'), ('작성', '담당자')]\n",
        "\n",
        "[예외 주입 결과 - 사용자 안내 메시지]\n",
        " E01 부대명 오류         존재하지 않는 부대 '가상99대대'          -> 조치: 부대 목록(가상01~24대대)에서 선택\n",
        " E02 월 오류           결산월 '2027-01' 자료 없음          -> 조치: 2026-07 또는 2026-08 중 선택\n",
        " E03 빈 자료           해당 부대 자료가 비어 있음              -> 조치: 제출 부대에 원장 재제출 요청\n",
        " E04 열 누락           필수 열 'ret' 누락                -> 조치: 표준 양식을 다시 내려받아 작성\n",
        " E05 숫자 아님          'issue' 열에 숫자가 아닌 값          -> 조치: 숫자만 입력(단위 문자 제거)\n",
        " E06 음수             'issue' 열에 음수                -> 조치: 수량 0 이상으로 수정\n",
        " E07 중복 생성          이미 생성된 보고서 RPT-01-08         -> 조치: 기존 보고서를 열어 수정·재제출\n",
        " E08 없는 보고서         보고서 RPT-00-00 없음             -> 조치: 보고서 번호를 목록에서 확인\n",
        " E10 상태 위반(미제출 승인)  현재 상태 '작성'에서 '승인' 불가         -> 조치: '제출' 상태에서만 가능\n",
        " E11 반려 사유 누락       반려 사유 없음                     -> 조치: 반려 사유를 한 줄 이상 입력\n",
        "예외 10종 중 로그 기록 10건(기록률 100%), 크래시 0건\n",
        "로그 예시: {\"level\": \"ERROR\", \"code\": \"E01\", \"msg\": \"존재하지 않는 부대 '가상99대대'\", \"guide\": \"부대 목록(가상01~24대대)에서 선택\"}\n",
        "목표(크래시 0건, 에러 로그 기록률 100%): 달성\n",
        "```\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "## 🎯 미션 07. 결산 보고서 최종 발간 전 군수과장/보급관 3단계 HITL 전자 결재선 연계 설계\n",
        "**소요시간**: 약 3.0시간\n",
        "\n",
        "### 📋 미션 배경 및 수행 지침\n",
        "#### 미션 배경 및 당위성\n",
        "\n",
        "결산 보고서 최종 발간 전 군수과장/보급관 3단계 HITL 결재선을 설계한다. 실제 전술 현장에서는 단순 탐지에 그치지 않고 신속한 위협 판단과 신뢰도 높은 의사결정이 필수적이므로, **결산 보고서 발간 전 담당자 기안, 보급관 검토, 군수과장 승인의 3단계 사람 결재선을 설계하고 이력의 무결성과 권한 통제를 검증한다.** 과업을 완수하여 오판을 방지하고 작전 대응력을 극대화해야 합니다.\n",
        "\n",
        "이 문제를 해결하기 위해 본 미션에서는 **결재 단계별 역할과 순서를 설정으로 고정하고, 순서 위반, 본인 결재, 근거 미기재, 미등록 사용자를 차단 수행하고 검증하는** 실습을 체계적으로 수행합니다.\n",
        "\n",
        "학습자는 실습가이드에 제시된 총 4개 세부 활동(기본 기능 구현 ➔ 결과 지표 검증 ➔ 파라미터 튜닝 및 도전과제)을 순차적으로 진행하며 핵심 판정 기준을 달성합니다.\n",
        "\n",
        "**이번 결과물:** `src/workflow/dat06_approval_system.py` 형태의 결과물을 완성한다.\n",
        "\n",
        "### 🔍 평가 및 검증 기준 (PASS 조건)\n",
        "#### 미션 판정\n",
        "\n",
        "**평가 구분:** 필수\n",
        "\n",
        "**핵심 평가영역:** 군 보안 규정 및 행정 절차 부합성\n",
        "\n",
        "#### 미션 PASS 조건\n",
        "\n",
        "- 정량 기준: 이력 기록 무결성 100%, 승인 권한 우회 시도 차단율 100%\n",
        "\n",
        "\n",
        "- 진행 기준: 결재선 승인/반려 시뮬레이션 및 이력 조회 화면 구현\n",
        "\n",
        "\n",
        "- 검증 방법: 권한별 접근 제어(RBAC) 테스트\n",
        "\n",
        "\n",
        "#### 채점자 판정 메모\n",
        "\n",
        "> 단순 코드 실행 여부뿐만 아니라 출력된 수치와 근거 자료가 군 실무 요구사항에 부합하는지 면밀히 확인한다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"결산 보고서 발간 전 담당자 기안, 보급관 검토, 군수과장 최종 승인의 3단계 사람 결재선을 설계하고, 해시 체인 감사 이력의 무결성과 권한 우회 시도 10종의 차단을 검증한다. 자동 발간은 허용하지 않는다.\"\"\"\n",
        "import hashlib\n",
        "import json\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# [교육용가상자료] 가상 직책·인물(가명). 실제 전자 결재 체계와 무관한 학습용 모의\n",
        "USERS = {\"kim\": \"담당자\", \"lee\": \"담당자\", \"park\": \"보급관\", \"choi\": \"군수과장\", \"han\": \"열람자\"}\n",
        "LINE = [(\"기안\", \"담당자\"), (\"검토\", \"보급관\"), (\"승인\", \"군수과장\")]       # 순서 고정 3단계\n",
        "AUDIT = []\n",
        "\n",
        "\n",
        "def _h(prev, rec):\n",
        "    return hashlib.sha256((prev + json.dumps(rec, ensure_ascii=False, sort_keys=True)).encode()).hexdigest()[:16]\n",
        "\n",
        "\n",
        "def log(doc, user, action, result, note=\"\"):\n",
        "    rec = {\"seq\": len(AUDIT) + 1, \"doc\": doc, \"user\": user, \"role\": USERS.get(user, \"미등록\"), \"action\": action, \"result\": result, \"note\": note}\n",
        "    rec[\"hash\"] = _h(AUDIT[-1][\"hash\"] if AUDIT else \"GENESIS\", {k: v for k, v in rec.items() if k != \"hash\"})\n",
        "    AUDIT.append(rec)\n",
        "\n",
        "\n",
        "def verify_chain():\n",
        "    prev, ok = \"GENESIS\", 0\n",
        "    for r in AUDIT:\n",
        "        body = {k: v for k, v in r.items() if k != \"hash\"}\n",
        "        ok += (r[\"hash\"] == _h(prev, body)); prev = r[\"hash\"]\n",
        "    return ok, len(AUDIT)\n",
        "\n",
        "\n",
        "DOCS = {}\n",
        "\n",
        "\n",
        "def step(doc, user, action, comment=\"\"):\n",
        "    \"\"\"결재 처리. 권한·순서·본인 결재 금지·근거 기재를 모두 통과해야 기록되고, 실패는 차단 기록을 남긴다.\"\"\"\n",
        "    d = DOCS.setdefault(doc, {\"stage\": 0, \"signers\": [], \"published\": False})\n",
        "    role = USERS.get(user)\n",
        "    if role is None:\n",
        "        return log(doc, user, action, \"차단\", \"미등록 사용자\"), False\n",
        "    if d[\"stage\"] >= len(LINE):\n",
        "        return log(doc, user, action, \"차단\", \"이미 결재 완료\"), False\n",
        "    need_act, need_role = LINE[d[\"stage\"]]\n",
        "    if action != need_act:\n",
        "        return log(doc, user, action, \"차단\", f\"순서 위반: 현재 단계 '{need_act}'\"), False\n",
        "    if role != need_role:\n",
        "        return log(doc, user, action, \"차단\", f\"권한 없음: 역할 '{role}'은(는) '{action}' 불가({need_role} 필요)\"), False\n",
        "    if user in d[\"signers\"]:\n",
        "        return log(doc, user, action, \"차단\", \"본인이 앞 단계에 서명한 문서는 다음 단계를 결재할 수 없음\"), False\n",
        "    if action != \"기안\" and len(comment.strip()) < 5:\n",
        "        return log(doc, user, action, \"차단\", \"검토 근거(5자 이상) 미기재\"), False\n",
        "    d[\"stage\"] += 1; d[\"signers\"].append(user)\n",
        "    log(doc, user, action, \"승인\", comment or \"기안 상신\")\n",
        "    return None, True\n",
        "\n",
        "\n",
        "def publish(doc, user):\n",
        "    d = DOCS.get(doc)\n",
        "    if not d or d[\"stage\"] < len(LINE):\n",
        "        log(doc, user, \"발간\", \"차단\", \"3단계 결재 미완료(자동 발간 금지)\"); return False\n",
        "    if USERS.get(user) != \"담당자\":\n",
        "        log(doc, user, \"발간\", \"차단\", \"발간은 담당자가 결재 완료 후 수동 실행\"); return False\n",
        "    d[\"published\"] = True; log(doc, user, \"발간\", \"승인\", \"결재 3단계 완료 후 수동 발간\"); return True\n",
        "\n",
        "\n",
        "# 1) 정상 결재 흐름 2건\n",
        "for doc, drafter in ((\"RPT-2026-08-A\", \"kim\"), (\"RPT-2026-08-B\", \"lee\")):\n",
        "    step(doc, drafter, \"기안\")\n",
        "    step(doc, \"park\", \"검토\", \"재고 산식 및 전월 연속성 확인 완료\")\n",
        "    step(doc, \"choi\", \"승인\", \"보급관 검토 의견 확인, 발간 승인\")\n",
        "    publish(doc, drafter)\n",
        "\n",
        "# 2) 권한 우회 시도 10종 - 결재가 진행되는 순서에 맞춰 시도하고, 모두 차단되어야 한다\n",
        "blocked, total = 0, 0\n",
        "print(\"[권한 우회 시도 결과] [교육용가상자료]\")\n",
        "\n",
        "\n",
        "def attempt(name, fn):\n",
        "    global blocked, total\n",
        "    n = len(AUDIT); fn(); r = AUDIT[-1]\n",
        "    ok = len(AUDIT) == n + 1 and r[\"result\"] == \"차단\"\n",
        "    blocked += ok; total += 1\n",
        "    print(f\" - {name}: {r['result']} ({r['note']})\")\n",
        "\n",
        "\n",
        "attempt(\"미등록 사용자 기안\", lambda: step(\"RPT-ATT\", \"hacker\", \"기안\"))\n",
        "attempt(\"열람자가 기안\", lambda: step(\"RPT-ATT\", \"han\", \"기안\"))\n",
        "attempt(\"기안 전에 군수과장이 승인(단계 건너뛰기)\", lambda: step(\"RPT-ATT\", \"choi\", \"승인\", \"바로 승인합니다 확인\"))\n",
        "step(\"RPT-ATT\", \"kim\", \"기안\")\n",
        "attempt(\"기안자 본인이 검토까지 처리\", lambda: step(\"RPT-ATT\", \"kim\", \"검토\", \"본인이 검토합니다 확인\"))\n",
        "attempt(\"다른 담당자가 검토 단계 처리\", lambda: step(\"RPT-ATT\", \"lee\", \"검토\", \"다른 담당자 검토 시도 확인\"))\n",
        "attempt(\"검토 근거 없이 보급관 검토\", lambda: step(\"RPT-ATT\", \"park\", \"검토\", \"\"))\n",
        "attempt(\"보급관 검토 전에 군수과장이 승인\", lambda: step(\"RPT-ATT\", \"choi\", \"승인\", \"보급관 단계를 생략한 승인 확인\"))\n",
        "attempt(\"결재 미완료 상태에서 발간\", lambda: publish(\"RPT-ATT\", \"kim\"))\n",
        "step(\"RPT-ATT\", \"park\", \"검토\", \"산식 검증 결과 이상 없음 확인\")\n",
        "step(\"RPT-ATT\", \"choi\", \"승인\", \"최종 승인합니다 확인\")\n",
        "attempt(\"완결된 문서 재승인 시도\", lambda: step(\"RPT-ATT\", \"choi\", \"승인\", \"한 번 더 승인 시도 확인\"))\n",
        "attempt(\"보급관이 발간 시도\", lambda: publish(\"RPT-ATT\", \"park\"))\n",
        "print(f\"우회 시도 {total}건 중 차단 {blocked}건({blocked / total:.0%})\")\n",
        "\n",
        "# 3) 이력 무결성: 정상 체인 검증 후 위·변조 시험\n",
        "ok, tot = verify_chain()\n",
        "print(f\"\\n이력 {tot}건 해시 체인 검증: {ok}/{tot} 일치({ok / tot:.0%})\")\n",
        "k = next(i for i, r in enumerate(AUDIT) if r[\"result\"] == \"차단\")\n",
        "saved = AUDIT[k][\"result\"]\n",
        "AUDIT[k][\"result\"] = \"승인\"          # 차단 기록을 승인으로 위조\n",
        "ok2, _ = verify_chain()\n",
        "AUDIT[k][\"result\"] = saved\n",
        "print(f\"위조 시험: {k + 1}번 기록 변조 시 검증 {ok2}/{tot} -> 변조 탐지 {'성공' if ok2 < tot else '실패'}, 원복 후 {verify_chain()[0]}/{tot}\")\n",
        "st = pd.DataFrame(AUDIT).groupby(\"doc\")[\"result\"].value_counts().unstack(fill_value=0)\n",
        "print(\"\\n[문서별 결재 이력 요약]\")\n",
        "print(st.to_string())\n",
        "pubs = [k for k, v in DOCS.items() if v[\"published\"]]\n",
        "print(\"발간 완료 문서:\", pubs, \"/ 우회 시험 문서 RPT-ATT는 발간되지 않음 / 자동 발간 0건(발간은 담당자 수동 실행)\")\n",
        "print(f\"목표(이력 무결성 100%, 우회 차단율 100%): {'달성' if ok == tot and blocked == total and ok2 < tot else '미달'}\")\n",
        "print(\"실제 결재와 보안 규정은 부대 지침과 지휘계통에 따른다. 본 코드는 학습용 모의이다.\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<details>\n",
        "<summary><b>💡 [참고] 미션 07 예상 실행 결과 (Output)</b></summary>\n",
        "\n",
        "```text\n",
        "[권한 우회 시도 결과] [교육용가상자료]\n",
        " - 미등록 사용자 기안: 차단 (미등록 사용자)\n",
        " - 열람자가 기안: 차단 (권한 없음: 역할 '열람자'은(는) '기안' 불가(담당자 필요))\n",
        " - 기안 전에 군수과장이 승인(단계 건너뛰기): 차단 (순서 위반: 현재 단계 '기안')\n",
        " - 기안자 본인이 검토까지 처리: 차단 (권한 없음: 역할 '담당자'은(는) '검토' 불가(보급관 필요))\n",
        " - 다른 담당자가 검토 단계 처리: 차단 (권한 없음: 역할 '담당자'은(는) '검토' 불가(보급관 필요))\n",
        " - 검토 근거 없이 보급관 검토: 차단 (검토 근거(5자 이상) 미기재)\n",
        " - 보급관 검토 전에 군수과장이 승인: 차단 (순서 위반: 현재 단계 '검토')\n",
        " - 결재 미완료 상태에서 발간: 차단 (3단계 결재 미완료(자동 발간 금지))\n",
        " - 완결된 문서 재승인 시도: 차단 (이미 결재 완료)\n",
        " - 보급관이 발간 시도: 차단 (발간은 담당자가 결재 완료 후 수동 실행)\n",
        "우회 시도 10건 중 차단 10건(100%)\n",
        "\n",
        "이력 21건 해시 체인 검증: 21/21 일치(100%)\n",
        "위조 시험: 9번 기록 변조 시 검증 20/21 -> 변조 탐지 성공, 원복 후 21/21\n",
        "\n",
        "[문서별 결재 이력 요약]\n",
        "result         승인  차단\n",
        "doc                  \n",
        "RPT-2026-08-A   4   0\n",
        "RPT-2026-08-B   4   0\n",
        "RPT-ATT         3  10\n",
        "발간 완료 문서: ['RPT-2026-08-A', 'RPT-2026-08-B'] / 우회 시험 문서 RPT-ATT는 발간되지 않음 / 자동 발간 0건(발간은 담당자 수동 실행)\n",
        "목표(이력 무결성 100%, 우회 차단율 100%): 달성\n",
        "실제 결재와 보안 규정은 부대 지침과 지휘계통에 따른다. 본 코드는 학습용 모의이다.\n",
        "```\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "## 🎯 미션 08. 수십 개 예하 부대 월간 결산 보고서 원클릭 일괄 생성 배치(Batch) 스트레스 테스트\n",
        "**소요시간**: 약 3.5시간\n",
        "\n",
        "### 📋 미션 배경 및 수행 지침\n",
        "#### 미션 배경 및 당위성\n",
        "\n",
        "수십 개 예하 부대 월간 결산 보고서 일괄 생성 배치 스트레스 테스트를 수행한다. 실제 전술 현장에서는 단순 탐지에 그치지 않고 신속한 위협 판단과 신뢰도 높은 의사결정이 필수적이므로, **수십 개 예하 부대의 월간 결산 보고서를 원클릭으로 일괄 생성하는 배치를 만들고 장애·손상 자료를 주입해 스트레스 시험을 수행한다.** 과업을 완수하여 오판을 방지하고 작전 대응력을 극대화해야 합니다.\n",
        "\n",
        "이 문제를 해결하기 위해 본 미션에서는 **가상 부대 40개 x 12개월, 480건 보고서를 한 번에 생성 수행하고 검증하는** 실습을 체계적으로 수행합니다.\n",
        "\n",
        "학습자는 실습가이드에 제시된 총 4개 세부 활동(기본 기능 구현 ➔ 결과 지표 검증 ➔ 파라미터 튜닝 및 도전과제)을 순차적으로 진행하며 핵심 판정 기준을 달성합니다.\n",
        "\n",
        "**이번 결과물:** `src/pipeline/dat06_batch_runner.py` 형태의 결과물을 완성한다.\n",
        "\n",
        "### 🔍 평가 및 검증 기준 (PASS 조건)\n",
        "#### 미션 판정\n",
        "\n",
        "**평가 구분:** 필수\n",
        "\n",
        "**핵심 평가영역:** 수작업 대비 업무 소요 시간 80% 이상 절감 효과\n",
        "\n",
        "#### 미션 PASS 조건\n",
        "\n",
        "- 정량 기준: 전체 배치 파이프라인 실행 시간 5분 이내, 자동화 성공률 99% 이상\n",
        "\n",
        "\n",
        "- 진행 기준: 스케줄러 연동 테스트 및 자동 실행 확인\n",
        "\n",
        "\n",
        "- 검증 방법: 실제 월간 업무 데이터 1년치 일괄 배치 시뮬레이션\n",
        "\n",
        "\n",
        "#### 채점자 판정 메모\n",
        "\n",
        "> 단순 코드 실행 여부뿐만 아니라 출력된 수치와 근거 자료가 군 실무 요구사항에 부합하는지 면밀히 확인한다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"40개 가상 예하 부대 x 12개월(480건) 월간 결산 보고서를 한 번에 생성하는 배치를 실행하며, 일시 장애와 손상 자료를 주입해 재시도·격리 처리를 확인하고 전체 실행 시간, 자동화 성공률, 수작업 대비 절감률을 측정한다.\"\"\"\n",
        "import time\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# ---------------------------------------------------------------------------\n",
        "# [교육용가상자료] 가상 월간 결산 원장 생성기 (실제 부대명·품목·수량·재무 정보 없음)\n",
        "# 가상 대대 24개 x (물자 불출 / 수리부속 소모 / 탄약 정산) 품목 원장과 장비 가동 현황을 만든다.\n",
        "# 재고 산식: 기말 = 기초 + 수령 + 반납 - 불출,  다음 달 기초 = 이번 달 기말.\n",
        "# ---------------------------------------------------------------------------\n",
        "UNITS = [f\"가상{i:02d}대대\" for i in range(1, 25)]\n",
        "ITEMS = {\"물자불출\": [\"급식류\", \"피복류\", \"유류\", \"정비소모품\"],\n",
        "         \"수리부속\": [\"필터류\", \"베어링류\", \"전장품\", \"타이어류\"],\n",
        "         \"탄약정산\": [\"훈련탄A\", \"훈련탄B\", \"모의탄\"]}\n",
        "UNIT_CODE = {\"급식류\": \"BX\", \"피복류\": \"EA\", \"유류\": \"L\", \"정비소모품\": \"EA\", \"필터류\": \"EA\", \"베어링류\": \"EA\",\n",
        "             \"전장품\": \"EA\", \"타이어류\": \"EA\", \"훈련탄A\": \"RD\", \"훈련탄B\": \"RD\", \"모의탄\": \"RD\"}\n",
        "LEDGER_COLS = [\"month\", \"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "\n",
        "\n",
        "def make_ledger(n_months=2, seed=60):\n",
        "    \"\"\"n_months개월 원장(list of dict). 둘째 달 기초는 첫째 달 기말과 같다.\"\"\"\n",
        "    rng = np.random.default_rng(seed)\n",
        "    rows, prev = [], {}\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            for cat, items in ITEMS.items():\n",
        "                for it in items:\n",
        "                    base = int(rng.integers(80, 400))\n",
        "                    op = prev.get((u, it), base * 3)\n",
        "                    recv = int(rng.integers(0, base))\n",
        "                    issue = int(rng.integers(base // 4, base // 2 + 1))\n",
        "                    ret = int(issue * rng.uniform(0, 0.15))\n",
        "                    cl = op + recv + ret - issue\n",
        "                    rows.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"cat\": cat, \"item\": it,\n",
        "                                 \"open\": op, \"recv\": recv, \"issue\": issue, \"ret\": ret, \"close\": cl})\n",
        "                    prev[(u, it)] = cl\n",
        "    return rows\n",
        "\n",
        "\n",
        "def make_equip(n_months=2, seed=61):\n",
        "    rng = np.random.default_rng(seed)\n",
        "    out = []\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            hold = int(rng.integers(20, 60))\n",
        "            out.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"hold\": hold, \"operable\": int(hold * rng.uniform(0.78, 0.97))})\n",
        "    return out\n",
        "\n",
        "UNITS = [f\"가상{i:02d}대대\" for i in range(1, 41)]                 # 배치용으로 40개 부대로 확장\n",
        "t_all = time.perf_counter()\n",
        "rows = make_ledger(12, seed=8)\n",
        "led = pd.DataFrame(rows)\n",
        "lab = {f\"2026-{i + 7:02d}\": f\"{2026 + (i + 6) // 12}-{(i + 6) % 12 + 1:02d}\" for i in range(12)}   # 2026-07 ~ 2027-06\n",
        "led[\"month\"] = led[\"month\"].map(lab)\n",
        "months = sorted(led[\"month\"].unique())\n",
        "print(f\"[배치 입력] 부대 {len(UNITS)}개 x {len(months)}개월 = {len(UNITS) * len(months)}건, 원장 {len(led)}행 [교육용가상자료]\")\n",
        "\n",
        "# 장애 주입: 일시 장애(재시도로 복구) 9건, 손상 자료(격리) 3건\n",
        "rng = np.random.default_rng(80)\n",
        "keys = [(u, m) for u in UNITS for m in months]\n",
        "pick = rng.choice(len(keys), 12, replace=False)\n",
        "transient = {keys[i] for i in pick[:9]}\n",
        "corrupt = {keys[i] for i in pick[9:]}\n",
        "for (u, m) in corrupt:                             # 기말 수치를 훼손(산식 불일치)\n",
        "    i = led[(led[\"unit\"] == u) & (led[\"month\"] == m)].index[0]\n",
        "    led.loc[i, \"close\"] = led.loc[i, \"close\"] + 999\n",
        "attempts_log = {}\n",
        "\n",
        "\n",
        "def build_report(u, m, g):\n",
        "    k = (u, m)\n",
        "    attempts_log[k] = attempts_log.get(k, 0) + 1\n",
        "    if k in transient and attempts_log[k] == 1:\n",
        "        raise TimeoutError(\"저장소 응답 지연(일시 장애)\")\n",
        "    bad = (g[\"open\"] + g[\"recv\"] + g[\"ret\"] - g[\"issue\"] != g[\"close\"]).sum()\n",
        "    if bad:\n",
        "        raise ValueError(f\"재고 산식 불일치 {int(bad)}건\")\n",
        "    s = g.groupby(\"cat\")[[\"issue\", \"close\"]].sum()\n",
        "    return f\"{u} {m} 불출 {int(s['issue'].sum())} 기말 {int(s['close'].sum())} (항목 {len(g)})\"\n",
        "\n",
        "\n",
        "done, quarantine, retries = {}, [], 0\n",
        "t0 = time.perf_counter()\n",
        "for (u, m), g in led.groupby([\"unit\", \"month\"]):\n",
        "    for attempt in range(1, 4):                    # 최대 3회 재시도\n",
        "        try:\n",
        "            done[(u, m)] = build_report(u, m, g)\n",
        "            break\n",
        "        except TimeoutError:\n",
        "            retries += 1\n",
        "        except ValueError as ex:                   # 자료 오류는 재시도해도 소용없으므로 즉시 격리하고 다음 건으로 진행\n",
        "            quarantine.append((u, m, str(ex)))\n",
        "            break\n",
        "run_s = time.perf_counter() - t0\n",
        "total = len(keys)\n",
        "succ = len(done) / total\n",
        "print(f\"\\n[배치 실행] 생성 {len(done)}건, 격리 {len(quarantine)}건, 재시도 {retries}회\")\n",
        "for q in quarantine:\n",
        "    print(\"  격리(담당자 확인 필요):\", q)\n",
        "print(f\"보고서 생성 순수 실행 시간 {run_s:.2f}초, 전체(자료 생성 포함) {time.perf_counter() - t_all:.2f}초 (목표 5분 이내: {'달성' if time.perf_counter() - t_all < 300 else '미달'})\")\n",
        "print(f\"자동화 성공률 {succ:.1%} (일시 장애 {len(transient)}건은 재시도로 자동 복구, 손상 자료는 격리 후 보고)\")\n",
        "\n",
        "# 수작업 대비 절감(가정값): 부대 보고서 1건 수작업 25분(미션 1 AS-IS 610분/24개 부대 기준), 자동화 후 사람 검토 2분/건, 격리 건 수동 처리 15분\n",
        "manual = total * 25\n",
        "auto = total * 2 + len(quarantine) * 15 + run_s / 60\n",
        "print(f\"\\n[업무 소요 비교(가정값)] 수작업 {manual}분({manual / 60:.0f}시간) vs 자동화 {auto:.0f}분({auto / 60:.1f}시간) -> 절감 {1 - auto / manual:.1%}\")\n",
        "\n",
        "# 스트레스: 부하 3배(1,440건) 반복 실행의 처리량\n",
        "big = list(led.groupby([\"unit\", \"month\"]))\n",
        "t0 = time.perf_counter(); n = 0\n",
        "for _ in range(3):\n",
        "    for (u, m), g in big:\n",
        "        if (u, m) in corrupt:\n",
        "            continue\n",
        "        attempts_log[(u, m)] = 9                     # 일시 장애 주입 해제(처리량 측정 목적)\n",
        "        build_report(u, m, g); n += 1\n",
        "dt = time.perf_counter() - t0\n",
        "print(f\"부하 시험 {n}건 처리 {dt:.2f}초 (초당 {n / dt:.0f}건), 오류 0건\")\n",
        "print(f\"\\n목표(전체 5분 이내, 자동화 성공률 99% 이상, 수작업 대비 80% 이상 절감): \"\n",
        "      f\"{'달성' if run_s < 300 and succ >= 0.99 and 1 - auto / manual >= 0.8 else '미달'}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<details>\n",
        "<summary><b>💡 [참고] 미션 08 예상 실행 결과 (Output)</b></summary>\n",
        "\n",
        "```text\n",
        "[배치 입력] 부대 40개 x 12개월 = 480건, 원장 5280행 [교육용가상자료]\n",
        "\n",
        "[배치 실행] 생성 477건, 격리 3건, 재시도 9회\n",
        "  격리(담당자 확인 필요): ('가상10대대', '2027-05', '재고 산식 불일치 1건')\n",
        "  격리(담당자 확인 필요): ('가상24대대', '2027-02', '재고 산식 불일치 1건')\n",
        "  격리(담당자 확인 필요): ('가상36대대', '2026-12', '재고 산식 불일치 1건')\n",
        "보고서 생성 순수 실행 시간 1.06초, 전체(자료 생성 포함) 1.13초 (목표 5분 이내: 달성)\n",
        "자동화 성공률 99.4% (일시 장애 9건은 재시도로 자동 복구, 손상 자료는 격리 후 보고)\n",
        "\n",
        "[업무 소요 비교(가정값)] 수작업 12000분(200시간) vs 자동화 1005분(16.8시간) -> 절감 91.6%\n",
        "부하 시험 1431건 처리 3.63초 (초당 394건), 오류 0건\n",
        "\n",
        "목표(전체 5분 이내, 자동화 성공률 99% 이상, 수작업 대비 80% 이상 절감): 달성\n",
        "```\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "## 🎯 미션 09. AAR 기반 결산 수치 오집계 사례 분석 및 집계 룰셋/템플릿 보정\n",
        "**소요시간**: 약 3.0시간\n",
        "\n",
        "### 📋 미션 배경 및 수행 지침\n",
        "#### 미션 배경 및 당위성\n",
        "\n",
        "AAR 기반 결산 수치 오집계 사례를 분석하고 룰셋을 보정한다. 실제 전술 현장에서는 단순 탐지에 그치지 않고 신속한 위협 판단과 신뢰도 높은 의사결정이 필수적이므로, **AAR 사례의 결산 수치 오집계 5유형을 재현·분석하고 집계 룰셋과 템플릿을 보정한다.** 과업을 완수하여 오판을 방지하고 작전 대응력을 극대화해야 합니다.\n",
        "\n",
        "이 문제를 해결하기 위해 본 미션에서는 **중복 제출, 단위 혼용(kL), 정정 문서 누락, 박스·발 혼용, 품목 별칭 누락의 5유형을 가상 제출 자료에 심어 룰셋 v1의 오집계를 재현 수행하고 검증하는** 실습을 체계적으로 수행합니다.\n",
        "\n",
        "학습자는 실습가이드에 제시된 총 4개 세부 활동(기본 기능 구현 ➔ 결과 지표 검증 ➔ 파라미터 튜닝 및 도전과제)을 순차적으로 진행하며 핵심 판정 기준을 달성합니다.\n",
        "\n",
        "**이번 결과물:** `docs/dat06_uat_feedback_report.md 및 패치 내역` 형태의 결과물을 완성한다.\n",
        "\n",
        "### 🔍 평가 및 검증 기준 (PASS 조건)\n",
        "#### 미션 판정\n",
        "\n",
        "**평가 구분:** 필수\n",
        "\n",
        "**핵심 평가영역:** 실무 업무 생산성 기여도 및 현장 적응성\n",
        "\n",
        "#### 미션 PASS 조건\n",
        "\n",
        "- 정량 기준: UAT 체크리스트 만족도 90점 이상, 개선 요구 5건 반영 완료\n",
        "\n",
        "\n",
        "- 진행 기준: UAT 결과 보고서 작성 및 최종 버그 픽스 완료\n",
        "\n",
        "\n",
        "- 검증 방법: 실제 업무 시나리오 기반 최종 검수 테스트\n",
        "\n",
        "\n",
        "#### 채점자 판정 메모\n",
        "\n",
        "> 단순 코드 실행 여부뿐만 아니라 출력된 수치와 근거 자료가 군 실무 요구사항에 부합하는지 면밀히 확인한다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"사후검토(AAR) 사례에서 결산 수치 오집계 5유형(중복 행, 단위 혼용, 정정 누락, 박스·발 혼용, 품목 별칭 누락)을 재현해 원인을 분석하고 집계 룰셋 v1을 v2로 보정한 뒤, 재집계 결과와 UAT 체크리스트 점수, 개선 요구 반영 현황, 패치 내역을 출력한다.\"\"\"\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# ---------------------------------------------------------------------------\n",
        "# [교육용가상자료] 가상 월간 결산 원장 생성기 (실제 부대명·품목·수량·재무 정보 없음)\n",
        "# 가상 대대 24개 x (물자 불출 / 수리부속 소모 / 탄약 정산) 품목 원장과 장비 가동 현황을 만든다.\n",
        "# 재고 산식: 기말 = 기초 + 수령 + 반납 - 불출,  다음 달 기초 = 이번 달 기말.\n",
        "# ---------------------------------------------------------------------------\n",
        "UNITS = [f\"가상{i:02d}대대\" for i in range(1, 25)]\n",
        "ITEMS = {\"물자불출\": [\"급식류\", \"피복류\", \"유류\", \"정비소모품\"],\n",
        "         \"수리부속\": [\"필터류\", \"베어링류\", \"전장품\", \"타이어류\"],\n",
        "         \"탄약정산\": [\"훈련탄A\", \"훈련탄B\", \"모의탄\"]}\n",
        "UNIT_CODE = {\"급식류\": \"BX\", \"피복류\": \"EA\", \"유류\": \"L\", \"정비소모품\": \"EA\", \"필터류\": \"EA\", \"베어링류\": \"EA\",\n",
        "             \"전장품\": \"EA\", \"타이어류\": \"EA\", \"훈련탄A\": \"RD\", \"훈련탄B\": \"RD\", \"모의탄\": \"RD\"}\n",
        "LEDGER_COLS = [\"month\", \"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "\n",
        "\n",
        "def make_ledger(n_months=2, seed=60):\n",
        "    \"\"\"n_months개월 원장(list of dict). 둘째 달 기초는 첫째 달 기말과 같다.\"\"\"\n",
        "    rng = np.random.default_rng(seed)\n",
        "    rows, prev = [], {}\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            for cat, items in ITEMS.items():\n",
        "                for it in items:\n",
        "                    base = int(rng.integers(80, 400))\n",
        "                    op = prev.get((u, it), base * 3)\n",
        "                    recv = int(rng.integers(0, base))\n",
        "                    issue = int(rng.integers(base // 4, base // 2 + 1))\n",
        "                    ret = int(issue * rng.uniform(0, 0.15))\n",
        "                    cl = op + recv + ret - issue\n",
        "                    rows.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"cat\": cat, \"item\": it,\n",
        "                                 \"open\": op, \"recv\": recv, \"issue\": issue, \"ret\": ret, \"close\": cl})\n",
        "                    prev[(u, it)] = cl\n",
        "    return rows\n",
        "\n",
        "\n",
        "def make_equip(n_months=2, seed=61):\n",
        "    rng = np.random.default_rng(seed)\n",
        "    out = []\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            hold = int(rng.integers(20, 60))\n",
        "            out.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"hold\": hold, \"operable\": int(hold * rng.uniform(0.78, 0.97))})\n",
        "    return out\n",
        "\n",
        "# 1) 가상 제출 레코드 생성: 정답(순불출 = 불출 - 반납)과 부대가 실제로 낸 제출 형태(오집계 유발 요인 포함)\n",
        "led = pd.DataFrame(make_ledger(1))\n",
        "rng = np.random.default_rng(9)\n",
        "truth = {(r.unit, r.item): r.issue - r.ret for r in led.itertuples()}\n",
        "subs, doc = [], 0\n",
        "def add(u, it, kind, qty, uom, name=None):\n",
        "    global doc\n",
        "    doc += 1\n",
        "    subs.append({\"doc\": f\"D{doc:05d}\", \"unit\": u, \"item\": name or it, \"kind\": kind, \"qty\": qty, \"uom\": uom})\n",
        "for r in led.itertuples():\n",
        "    add(r.unit, r.item, \"issue\", r.issue, UNIT_CODE[r.item]); add(r.unit, r.item, \"return\", r.ret, UNIT_CODE[r.item])\n",
        "keys = list(truth)\n",
        "pick = lambda n, f=lambda k: True: [keys[i] for i in rng.choice([j for j, k in enumerate(keys) if f(k)], n, replace=False)]\n",
        "CASE = {}\n",
        "for k in pick(6):                                   # 사례1: 같은 문서번호가 중복 제출\n",
        "    CASE.setdefault(\"중복 행\", []).append(k); subs.append(dict(next(s for s in subs if (s[\"unit\"], s[\"item\"]) == k and s[\"kind\"] == \"issue\")))\n",
        "for k in pick(4, lambda k: k[1] == \"유류\"):         # 사례2: 유류를 kL 단위로 제출(1kL = 1000L)\n",
        "    CASE.setdefault(\"단위 혼용(kL)\", []).append(k)\n",
        "    for s in subs:\n",
        "        if (s[\"unit\"], s[\"item\"]) == k:\n",
        "            s[\"qty\"], s[\"uom\"] = s[\"qty\"] / 1000, \"kL\"\n",
        "for k in pick(5):                                   # 사례3: 불출 후 정정 문서(음수 조정)를 별도로 제출\n",
        "    CASE.setdefault(\"정정 누락\", []).append(k); d = int(rng.integers(5, 20))\n",
        "    next(s for s in subs if (s[\"unit\"], s[\"item\"]) == k and s[\"kind\"] == \"issue\")[\"qty\"] += d\n",
        "    add(k[0], k[1], \"adjust\", -d, UNIT_CODE[k[1]])\n",
        "for k in pick(4, lambda k: k[1].startswith(\"훈련탄\")):   # 사례4: 탄약을 박스(BX, 1BX=20발)로 제출\n",
        "    CASE.setdefault(\"박스·발 혼용\", []).append(k)\n",
        "    for s in subs:\n",
        "        if (s[\"unit\"], s[\"item\"]) == k:\n",
        "            s[\"qty\"], s[\"uom\"] = s[\"qty\"] / 20, \"BX\"\n",
        "for k in pick(5, lambda k: k[1] == \"피복류\"):        # 사례5: 품목명을 줄여서 제출('피복')\n",
        "    CASE.setdefault(\"품목 별칭 누락\", []).append(k)\n",
        "    for s in subs:\n",
        "        if (s[\"unit\"], s[\"item\"]) == k:\n",
        "            s[\"item\"] = \"피복\"\n",
        "S = pd.DataFrame(subs)\n",
        "\n",
        "# 2) 집계 룰셋 v1(AAR 이전) / v2(보정 후)\n",
        "def aggregate(S, ruleset):\n",
        "    d = S.copy()\n",
        "    if ruleset == \"v2\":\n",
        "        d = d.drop_duplicates(\"doc\")\n",
        "        d[\"item\"] = d[\"item\"].replace({\"피복\": \"피복류\"})\n",
        "        d = d[d[\"item\"].isin(UNIT_CODE)]\n",
        "        FACTOR = {(\"kL\", \"L\"): 1000, (\"BX\", \"RD\"): 20}               # (제출 단위, 품목 기준 단위) -> 환산 계수\n",
        "        d[\"qty\"] = d[\"qty\"] * [FACTOR.get((u, UNIT_CODE[i]), 1) for u, i in zip(d[\"uom\"], d[\"item\"])]\n",
        "        sign = {\"issue\": 1, \"return\": -1, \"adjust\": 1}\n",
        "    else:\n",
        "        d = d[d[\"item\"].isin(UNIT_CODE) & (d[\"kind\"] != \"adjust\")]\n",
        "        sign = {\"issue\": 1, \"return\": -1}\n",
        "    d = d.assign(v=d[\"kind\"].map(sign) * d[\"qty\"])\n",
        "    return d.groupby([\"unit\", \"item\"])[\"v\"].sum().round(6)\n",
        "\n",
        "def compare(agg):\n",
        "    tt = pd.Series(truth)\n",
        "    tt.index.names = [\"unit\", \"item\"]\n",
        "    diff = (agg.reindex(tt.index).fillna(0) - tt)\n",
        "    return diff[diff.abs() > 0.5]\n",
        "\n",
        "v1, v2 = compare(aggregate(S, \"v1\")), compare(aggregate(S, \"v2\"))\n",
        "print(f\"[AAR 오집계 분석] 제출 레코드 {len(S)}건, 정답 대조 대상 {len(truth)}개 (부대 x 품목) [교육용가상자료]\")\n",
        "print(f\"룰셋 v1 오집계 {len(v1)}건(오차 합계 {v1.abs().sum():.0f}), 룰셋 v2 오집계 {len(v2)}건\")\n",
        "print(\"\\n[사례별 원인 분석 - v1]\")\n",
        "rows = []\n",
        "for name, ks in CASE.items():\n",
        "    hit = [k for k in ks if k in v1.index]\n",
        "    fix = [k for k in ks if k not in v2.index]\n",
        "    err = float(sum(abs(v1[k]) for k in hit))\n",
        "    rows.append({\"사례\": name, \"발생 셀\": len(ks), \"v1 오류 셀\": len(hit), \"v1 오차\": round(err), \"v2 정상\": f\"{len(fix)}/{len(ks)}\"})\n",
        "print(pd.DataFrame(rows).to_string(index=False))\n",
        "CAUSE = {\"중복 행\": \"문서번호 중복 제거 규칙 없음\", \"단위 혼용(kL)\": \"단위 환산표 없음\", \"정정 누락\": \"정정(음수 조정) 문서를 집계에서 제외\",\n",
        "         \"박스·발 혼용\": \"BX->RD 환산표 없음\", \"품목 별칭 누락\": \"별칭 사전 없고 미등록 품목을 조용히 버림\"}\n",
        "print(\"\\n[원인 -> 룰셋 보정]\")\n",
        "for k, v in CAUSE.items():\n",
        "    print(f\" - {k}: {v} -> v2 패치: \" + {\"중복 행\": \"doc 기준 drop_duplicates\", \"단위 혼용(kL)\": \"kL x1000\", \"정정 누락\": \"adjust 포함 집계\",\n",
        "                                          \"박스·발 혼용\": \"BX x20\", \"품목 별칭 누락\": \"별칭 사전 + 미등록 품목은 로그로 보류\"}[k])\n",
        "\n",
        "# 3) 회귀 시험 및 UAT 체크리스트(자동 점검 20항목)\n",
        "agg2 = aggregate(S, \"v2\")\n",
        "checks = [(\"정답 대조 오집계 0건\", len(v2) == 0), (\"중복 문서 제거\", agg2.equals(aggregate(S.drop_duplicates(\"doc\"), \"v2\"))),\n",
        "          (\"v2 재실행 결과 동일(멱등)\", aggregate(S, \"v2\").equals(agg2)),\n",
        "          (\"kL 부대 4곳 정상\", all(k not in v2.index for k in CASE[\"단위 혼용(kL)\"])), (\"BX 부대 4곳 정상\", all(k not in v2.index for k in CASE[\"박스·발 혼용\"])),\n",
        "          (\"정정 문서 5건 반영\", all(k not in v2.index for k in CASE[\"정정 누락\"])), (\"별칭 5건 반영\", all(k not in v2.index for k in CASE[\"품목 별칭 누락\"])),\n",
        "          (\"정상 부대 v1 결과와 불변\", len(set(truth) - set(v1.index) - set(v2.index)) == len(truth) - len(v1)),\n",
        "          (\"전체 불출 합계 정답과 일치\", abs(agg2.sum() - sum(truth.values())) < 1), (\"부대 24개 모두 집계\", agg2.index.get_level_values(0).nunique() == 24),\n",
        "          (\"품목 11종 모두 집계\", agg2.index.get_level_values(1).nunique() == 11), (\"음수 순불출 0건\", (agg2 >= 0).all()),\n",
        "          (\"미등록 품목 입력 시 오류 아닌 보류\", aggregate(pd.concat([S, pd.DataFrame([{\"doc\": \"X1\", \"unit\": UNITS[0], \"item\": \"미등록\", \"kind\": \"issue\", \"qty\": 5, \"uom\": \"EA\"}])]), \"v2\").shape == agg2.shape),\n",
        "          (\"빈 입력에서도 오류 없음\", aggregate(S.iloc[0:0], \"v2\").empty), (\"처리 결과 부대x품목 단일 키\", agg2.index.is_unique),\n",
        "          (\"v1 대비 오차 감소 100%\", len(v2) == 0 and len(v1) > 0), (\"단위 환산 후 소수 오차 없음\", bool(((agg2 - agg2.round()).abs() < 1e-6).all())),\n",
        "          (\"사례 5유형 모두 재현·분석\", len(CASE) == 5), (\"원인-패치 대응표 작성\", len(CAUSE) == 5), (\"개선 요구 5건 반영\", len(CASE) == 5 and len(v2) == 0)]\n",
        "passed = sum(ok for _, ok in checks)\n",
        "score = 100 * passed / len(checks)\n",
        "print(\"\\n[UAT 체크리스트]\", f\"{passed}/{len(checks)}항목 통과, 점수 {score:.0f}점\")\n",
        "for n, ok in checks:\n",
        "    if not ok:\n",
        "        print(\"  미통과:\", n)\n",
        "print(\"\\n[개선 요구 반영 현황]\")\n",
        "for i, (k, ks) in enumerate(CASE.items(), 1):\n",
        "    print(f\" 요구 {i}. {k} 대응: {'반영 완료' if all(x not in v2.index for x in ks) else '미반영'}\")\n",
        "print(f\"\\n목표(UAT 90점 이상, 개선 요구 5건 반영): {'달성' if score >= 90 and len(v2) == 0 else '미달'}\")\n",
        "print(\"패치 내역: 룰셋 v1 -> v2 (중복 제거, 단위 환산표, 정정 반영, 별칭 사전, 미등록 품목 보류). 재집계 전 담당자가 보류 건을 확인한다.\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<details>\n",
        "<summary><b>💡 [참고] 미션 09 예상 실행 결과 (Output)</b></summary>\n",
        "\n",
        "```text\n",
        "[AAR 오집계 분석] 제출 레코드 539건, 정답 대조 대상 264개 (부대 x 품목) [교육용가상자료]\n",
        "룰셋 v1 오집계 24건(오차 합계 1787), 룰셋 v2 오집계 0건\n",
        "\n",
        "[사례별 원인 분석 - v1]\n",
        "       사례  발생 셀  v1 오류 셀  v1 오차 v2 정상\n",
        "     중복 행     6        6    546   6/6\n",
        "단위 혼용(kL)     4        4    241   4/4\n",
        "    정정 누락     5        5     71   5/5\n",
        "  박스·발 혼용     4        4    367   4/4\n",
        " 품목 별칭 누락     5        5    563   5/5\n",
        "\n",
        "[원인 -> 룰셋 보정]\n",
        " - 중복 행: 문서번호 중복 제거 규칙 없음 -> v2 패치: doc 기준 drop_duplicates\n",
        " - 단위 혼용(kL): 단위 환산표 없음 -> v2 패치: kL x1000\n",
        " - 정정 누락: 정정(음수 조정) 문서를 집계에서 제외 -> v2 패치: adjust 포함 집계\n",
        " - 박스·발 혼용: BX->RD 환산표 없음 -> v2 패치: BX x20\n",
        " - 품목 별칭 누락: 별칭 사전 없고 미등록 품목을 조용히 버림 -> v2 패치: 별칭 사전 + 미등록 품목은 로그로 보류\n",
        "\n",
        "[UAT 체크리스트] 20/20항목 통과, 점수 100점\n",
        "\n",
        "[개선 요구 반영 현황]\n",
        " 요구 1. 중복 행 대응: 반영 완료\n",
        " 요구 2. 단위 혼용(kL) 대응: 반영 완료\n",
        " 요구 3. 정정 누락 대응: 반영 완료\n",
        " 요구 4. 박스·발 혼용 대응: 반영 완료\n",
        " 요구 5. 품목 별칭 누락 대응: 반영 완료\n",
        "\n",
        "목표(UAT 90점 이상, 개선 요구 5건 반영): 달성\n",
        "패치 내역: 룰셋 v1 -> v2 (중복 제거, 단위 환산표, 정정 반영, 별칭 사전, 미등록 품목 보류). 재집계 전 담당자가 보류 건을 확인한다.\n",
        "```\n",
        "</details>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "\n",
        "## 🎯 미션 10. 군수 월간 결산 및 보급 현황 보고서 원클릭 자동 생성 도구 최종 완성\n",
        "**소요시간**: 약 3.0시간\n",
        "\n",
        "### 📋 미션 배경 및 수행 지침\n",
        "#### 미션 배경 및 당위성\n",
        "\n",
        "군수 월간 결산 및 보급 현황 보고서 원클릭 자동 생성 도구를 완성한다. 실제 전술 현장에서는 단순 탐지에 그치지 않고 신속한 위협 판단과 신뢰도 높은 의사결정이 필수적이므로, **수집부터 검증, 집계, 이상 점검, 보고서 생성, 결재 대기 분리까지 한 번에 실행되는 월간 결산 원클릭 도구를 완성한다.** 과업을 완수하여 오판을 방지하고 작전 대응력을 극대화해야 합니다.\n",
        "\n",
        "이 문제를 해결하기 위해 본 미션에서는 **환경 점검 후 CSV·JSON 혼합 자료를 수집하고 검증 룰과 집계, 이상 점검, 신뢰도 점수를 거쳐 24개 부대 보고서 작성하여 원인을 분석하는** 실습을 체계적으로 수행합니다.\n",
        "\n",
        "학습자는 실습가이드에 제시된 총 4개 세부 활동(기본 기능 구현 ➔ 결과 지표 검증 ➔ 파라미터 튜닝 및 도전과제)을 순차적으로 진행하며 핵심 판정 기준을 달성합니다.\n",
        "\n",
        "**이번 결과물:** `dist/dat06_package/, README.md, docs/dat06_final_manual.md` 형태의 결과물을 완성한다.\n",
        "\n",
        "### 🔍 평가 및 검증 기준 (PASS 조건)\n",
        "#### 미션 판정\n",
        "\n",
        "**평가 구분:** 필수\n",
        "\n",
        "**핵심 평가영역:** 상용 소프트웨어 수준의 완성도 및 조직 확산 가치\n",
        "\n",
        "#### 미션 PASS 조건\n",
        "\n",
        "- 정량 기준: 설치부터 실행까지 원클릭 설치 스크립트 완비, 매뉴얼 작성률 100%\n",
        "\n",
        "\n",
        "- 진행 기준: 최종 배포본 생성 및 검수 완료\n",
        "\n",
        "\n",
        "- 검증 방법: Clean 환경에서의 설치 및 초기화 테스트\n",
        "\n",
        "\n",
        "#### 채점자 판정 메모\n",
        "\n",
        "> 단순 코드 실행 여부뿐만 아니라 출력된 수치와 근거 자료가 군 실무 요구사항에 부합하는지 면밀히 확인한다.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"환경 점검부터 4형식 자료 수집, 검증 룰 적용, 월간 결산 집계, 이상치 점검, 신뢰도 점수, 24개 부대 보고서 생성, 3단계 결재 대기 분리까지 한 번에 실행하는 원클릭 결산 도구를 완성하고 설치 스크립트 개요·매뉴얼 목차·자체 점검·브리핑 요약을 출력한다.\"\"\"\n",
        "import csv\n",
        "import importlib.util\n",
        "import io\n",
        "import json\n",
        "import sys\n",
        "import time\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# ---------------------------------------------------------------------------\n",
        "# [교육용가상자료] 가상 월간 결산 원장 생성기 (실제 부대명·품목·수량·재무 정보 없음)\n",
        "# 가상 대대 24개 x (물자 불출 / 수리부속 소모 / 탄약 정산) 품목 원장과 장비 가동 현황을 만든다.\n",
        "# 재고 산식: 기말 = 기초 + 수령 + 반납 - 불출,  다음 달 기초 = 이번 달 기말.\n",
        "# ---------------------------------------------------------------------------\n",
        "UNITS = [f\"가상{i:02d}대대\" for i in range(1, 25)]\n",
        "ITEMS = {\"물자불출\": [\"급식류\", \"피복류\", \"유류\", \"정비소모품\"],\n",
        "         \"수리부속\": [\"필터류\", \"베어링류\", \"전장품\", \"타이어류\"],\n",
        "         \"탄약정산\": [\"훈련탄A\", \"훈련탄B\", \"모의탄\"]}\n",
        "UNIT_CODE = {\"급식류\": \"BX\", \"피복류\": \"EA\", \"유류\": \"L\", \"정비소모품\": \"EA\", \"필터류\": \"EA\", \"베어링류\": \"EA\",\n",
        "             \"전장품\": \"EA\", \"타이어류\": \"EA\", \"훈련탄A\": \"RD\", \"훈련탄B\": \"RD\", \"모의탄\": \"RD\"}\n",
        "LEDGER_COLS = [\"month\", \"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "\n",
        "\n",
        "def make_ledger(n_months=2, seed=60):\n",
        "    \"\"\"n_months개월 원장(list of dict). 둘째 달 기초는 첫째 달 기말과 같다.\"\"\"\n",
        "    rng = np.random.default_rng(seed)\n",
        "    rows, prev = [], {}\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            for cat, items in ITEMS.items():\n",
        "                for it in items:\n",
        "                    base = int(rng.integers(80, 400))\n",
        "                    op = prev.get((u, it), base * 3)\n",
        "                    recv = int(rng.integers(0, base))\n",
        "                    issue = int(rng.integers(base // 4, base // 2 + 1))\n",
        "                    ret = int(issue * rng.uniform(0, 0.15))\n",
        "                    cl = op + recv + ret - issue\n",
        "                    rows.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"cat\": cat, \"item\": it,\n",
        "                                 \"open\": op, \"recv\": recv, \"issue\": issue, \"ret\": ret, \"close\": cl})\n",
        "                    prev[(u, it)] = cl\n",
        "    return rows\n",
        "\n",
        "\n",
        "def make_equip(n_months=2, seed=61):\n",
        "    rng = np.random.default_rng(seed)\n",
        "    out = []\n",
        "    for m in range(n_months):\n",
        "        for u in UNITS:\n",
        "            hold = int(rng.integers(20, 60))\n",
        "            out.append({\"month\": f\"2026-{m + 7:02d}\", \"unit\": u, \"hold\": hold, \"operable\": int(hold * rng.uniform(0.78, 0.97))})\n",
        "    return out\n",
        "\n",
        "LOG = []\n",
        "def stage(name):\n",
        "    def deco(fn):\n",
        "        def run(*a):\n",
        "            t0 = time.perf_counter()\n",
        "            try:\n",
        "                r = fn(*a); LOG.append((name, \"OK\", time.perf_counter() - t0)); return r\n",
        "            except Exception as ex:                 # 한 단계가 실패해도 도구 전체가 죽지 않고 원인을 기록\n",
        "                LOG.append((name, f\"FAIL {repr(ex)[:40]}\", time.perf_counter() - t0)); return None\n",
        "        return run\n",
        "    return deco\n",
        "\n",
        "# ---------------- 0) 설치·환경 점검(원클릭 설치 스크립트 개요) ----------------\n",
        "INSTALL = [\"1. 가상 환경 생성 및 필수 모듈 설치(numpy, pandas, matplotlib)\", \"2. 환경 점검: 모듈·버전 확인\", \"3. 샘플 자료로 시험 실행\", \"4. 실행: run_monthly_close()\", \"5. 결과 확인: 보고서 24건, 결재 대기 목록\"]\n",
        "mods = [\"numpy\", \"pandas\", \"matplotlib\", \"csv\", \"json\"]\n",
        "env_ok = sum(importlib.util.find_spec(m) is not None for m in mods)\n",
        "print(f\"[0] 환경 점검: Python {sys.version_info.major}.{sys.version_info.minor}, 필수 모듈 {env_ok}/{len(mods)} 확인 [교육용가상자료]\")\n",
        "\n",
        "# ---------------- 1) 수집(CSV + JSON 두 형식 혼합) ----------------\n",
        "@stage(\"수집·파싱\")\n",
        "def collect():\n",
        "    rows = [r for r in make_ledger(2) if r[\"month\"] == \"2026-08\"]\n",
        "    half = len(rows) // 2\n",
        "    head = [\"unit\", \"cat\", \"item\", \"open\", \"recv\", \"issue\", \"ret\", \"close\"]\n",
        "    csv_text = \"\\n\".join([\",\".join(head)] + [\",\".join(str(r[h]) for h in head) for r in rows[:half]])\n",
        "    json_text = json.dumps([{h: r[h] for h in head} for r in rows[half:]], ensure_ascii=False)\n",
        "    a = list(csv.DictReader(io.StringIO(csv_text))) + json.loads(json_text)\n",
        "    df = pd.DataFrame(a)\n",
        "    for c in (\"open\", \"recv\", \"issue\", \"ret\", \"close\"):\n",
        "        df[c] = pd.to_numeric(df[c])\n",
        "    return df\n",
        "\n",
        "# ---------------- 2) 검증 룰 ----------------\n",
        "RULES = [(\"V1 산식\", lambda d: d[\"open\"] + d[\"recv\"] + d[\"ret\"] - d[\"issue\"] == d[\"close\"]), (\"V2 음수\", lambda d: (d[[\"open\", \"recv\", \"issue\", \"ret\", \"close\"]] >= 0).all(axis=1)),\n",
        "         (\"V3 가용량\", lambda d: d[\"issue\"] <= d[\"open\"] + d[\"recv\"]), (\"V4 반납\", lambda d: d[\"ret\"] <= d[\"issue\"]), (\"V5 부대\", lambda d: d[\"unit\"].isin(UNITS)),\n",
        "         (\"V6 품목\", lambda d: d[\"item\"].isin(UNIT_CODE))]\n",
        "@stage(\"검증\")\n",
        "def check(df):\n",
        "    bad = pd.Series(False, index=df.index)\n",
        "    for _, f in RULES:\n",
        "        bad |= ~f(df)\n",
        "    return int(bad.sum())\n",
        "\n",
        "@stage(\"집계\")\n",
        "def aggregate(df):\n",
        "    return df.groupby([\"unit\", \"cat\"])[[\"issue\", \"ret\", \"close\"]].sum().unstack(\"cat\")\n",
        "\n",
        "@stage(\"이상 점검\")\n",
        "def anomalies(df):\n",
        "    prev = pd.DataFrame([r for r in make_ledger(2) if r[\"month\"] == \"2026-07\"]).set_index([\"unit\", \"item\"])[\"issue\"]\n",
        "    ratio = df.set_index([\"unit\", \"item\"])[\"issue\"] / prev.clip(lower=1)\n",
        "    return ratio[ratio >= 4.0]\n",
        "\n",
        "@stage(\"신뢰도\")\n",
        "def reliability(df, nbad):\n",
        "    return round(100 - 100 * nbad / len(df), 1)\n",
        "\n",
        "@stage(\"보고서 생성\")\n",
        "def build(df, agg):\n",
        "    out = {}\n",
        "    for u in UNITS:\n",
        "        g = df[df[\"unit\"] == u]\n",
        "        out[u] = {\"unit\": u, \"issue\": int(g[\"issue\"].sum()), \"close\": int(g[\"close\"].sum()), \"status\": \"결재 대기(기안)\", \"published\": False}\n",
        "    return out\n",
        "\n",
        "df = collect()\n",
        "nbad = check(df)\n",
        "agg = aggregate(df)\n",
        "anom = anomalies(df)\n",
        "rel = reliability(df, nbad)\n",
        "reports = build(df, agg)\n",
        "\n",
        "# ---------------- 3) 결과 ----------------\n",
        "print(f\"[1] 수집 {len(df)}행(CSV+JSON 혼합), 검증 위반 {nbad}건, 이상 급증 후보 {len(anom)}건, 자료 신뢰도 {rel}점\")\n",
        "tbl = pd.DataFrame(reports).T[[\"issue\", \"close\", \"status\"]].head(5)\n",
        "print(\"[2] 부대별 결산 보고서(상위 5개 부대) - 모든 보고서는 결재 대기 상태\")\n",
        "print(tbl.to_string())\n",
        "tot = agg[\"issue\"].sum()\n",
        "print(\"[3] 분류별 불출·소모 합계:\", tot.astype(int).to_dict())\n",
        "print(\"[4] 단계별 실행 로그:\")\n",
        "for n, st, t in LOG:\n",
        "    print(f\"   - {n:<8} {st:<5} {t * 1000:.1f}ms\")\n",
        "run_ms = sum(t for _, _, t in LOG) * 1000\n",
        "\n",
        "# ---------------- 4) 자체 점검 ----------------\n",
        "MANUAL = [\"1. 개요·설치\", \"2. 입력 자료 양식\", \"3. 실행 방법(원클릭)\", \"4. 검증 룰 목록\", \"5. 이상 항목 처리\", \"6. 결재선·권한\", \"7. 오류 메시지 조치\", \"8. 배치 운영\", \"9. 개선 이력·문의\"]\n",
        "done_sec = len(MANUAL)\n",
        "checks = [(\"환경 점검 5/5\", env_ok == len(mods)), (\"모든 단계 OK\", all(s == \"OK\" for _, s, _ in LOG)), (\"24개 부대 보고서 생성\", len(reports) == 24),\n",
        "          (\"자동 발간 0건\", not any(r[\"published\"] for r in reports.values())), (\"원장 산식 위반 0건\", nbad == 0),\n",
        "          (\"실행 시간 1분 이내\", run_ms < 60000), (\"매뉴얼 9장 작성(작성률 100%)\", done_sec == len(MANUAL)),\n",
        "          (\"설치 절차 5단계 완비\", len(INSTALL) == 5)]\n",
        "print(\"\\n[5] 자체 점검\")\n",
        "for n, ok in checks:\n",
        "    print(f\"   {'PASS' if ok else 'FAIL'}  {n}\")\n",
        "npass = sum(ok for _, ok in checks)\n",
        "print(\"설치 스크립트 개요:\", \" / \".join(INSTALL))\n",
        "print(\"매뉴얼 목차:\", \" | \".join(MANUAL))\n",
        "asis, tobe = 610, 58\n",
        "print(f\"\\n[브리핑 요약] 24개 부대 결산 보고서를 {run_ms:.0f}ms에 자동 생성(수작업 가정 {asis}분 -> 검토 포함 {tobe}분, {1 - tobe / asis:.0%} 절감 가정값).\")\n",
        "print(f\"자료 신뢰도 {rel}점, 이상 급증 후보 {len(anom)}건은 담당자 확인 대상, 보고서 24건 전부 보급관 -> 군수과장 결재 대기(자동 발간 없음).\")\n",
        "print(f\"자체 점검 {npass}/{len(checks)} PASS. 목표(원클릭 설치·실행 완비, 매뉴얼 100%): {'달성' if npass == len(checks) else '미달'}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<details>\n",
        "<summary><b>💡 [참고] 미션 10 예상 실행 결과 (Output)</b></summary>\n",
        "\n",
        "```text\n",
        "[0] 환경 점검: Python 3.11, 필수 모듈 5/5 확인 [교육용가상자료]\n",
        "[1] 수집 264행(CSV+JSON 혼합), 검증 위반 0건, 이상 급증 후보 9건, 자료 신뢰도 100.0점\n",
        "[2] 부대별 결산 보고서(상위 5개 부대) - 모든 보고서는 결재 대기 상태\n",
        "       issue close     status\n",
        "가상01대대  1147  8915  결재 대기(기안)\n",
        "가상02대대   916  9139  결재 대기(기안)\n",
        "가상03대대   778  7428  결재 대기(기안)\n",
        "가상04대대   882  8357  결재 대기(기안)\n",
        "가상05대대   920  7718  결재 대기(기안)\n",
        "[3] 분류별 불출·소모 합계: {'물자불출': 8270, '수리부속': 8184, '탄약정산': 6743}\n",
        "[4] 단계별 실행 로그:\n",
        "   - 수집·파싱    OK    19.0ms\n",
        "   - 검증       OK    8.2ms\n",
        "   - 집계       OK    13.2ms\n",
        "   - 이상 점검    OK    23.8ms\n",
        "   - 신뢰도      OK    0.0ms\n",
        "   - 보고서 생성   OK    33.2ms\n",
        "\n",
        "[5] 자체 점검\n",
        "   PASS  환경 점검 5/5\n",
        "   PASS  모든 단계 OK\n",
        "   PASS  24개 부대 보고서 생성\n",
        "   PASS  자동 발간 0건\n",
        "   PASS  원장 산식 위반 0건\n",
        "   PASS  실행 시간 1분 이내\n",
        "   PASS  매뉴얼 9장 작성(작성률 100%)\n",
        "   PASS  설치 절차 5단계 완비\n",
        "설치 스크립트 개요: 1. 가상 환경 생성 및 필수 모듈 설치(numpy, pandas, matplotlib) / 2. 환경 점검: 모듈·버전 확인 / 3. 샘플 자료로 시험 실행 / 4. 실행: run_monthly_close() / 5. 결과 확인: 보고서 24건, 결재 대기 목록\n",
        "매뉴얼 목차: 1. 개요·설치 | 2. 입력 자료 양식 | 3. 실행 방법(원클릭) | 4. 검증 룰 목록 | 5. 이상 항목 처리 | 6. 결재선·권한 | 7. 오류 메시지 조치 | 8. 배치 운영 | 9. 개선 이력·문의\n",
        "\n",
        "[브리핑 요약] 24개 부대 결산 보고서를 97ms에 자동 생성(수작업 가정 610분 -> 검토 포함 58분, 90% 절감 가정값).\n",
        "자료 신뢰도 100.0점, 이상 급증 후보 9건은 담당자 확인 대상, 보고서 24건 전부 보급관 -> 군수과장 결재 대기(자동 발간 없음).\n",
        "자체 점검 8/8 PASS. 목표(원클릭 설치·실행 완비, 매뉴얼 100%): 달성\n",
        "```\n",
        "</details>\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}