秒过分数线数据导入

.gitignore

@@ -32,4 +32,5 @@ src/web_crawler/Throne-of-Magical-Arcana/Throne-of-Magical-Arcana_chapters_with_
 src/web_crawler/Throne-of-Magical-Arcana/Throne-of-Magical-Arcana.jpeg
 src/web_crawler/Throne-of-Magical-Arcana/Throne-of-Magical-Arcana.txt
 src/web_crawler/Throne-of-Magical-Arcana/Throne-of-Magical-Arcana.epub
-.gitignore
+__pycache__/
+*.py[cod]

秒过分数线数据导入/README.md

@@ -0,0 +1,338 @@
+# 上海中考招生计划与成绩导入说明
+
+本文档记录本项目每年从 PDF/图片整理上海中考招生计划、成绩，并导入 MySQL 表 `kylx365_db.MPS_Score` 的需求、步骤和注意事项。  
+当前已完成 2026 年“计划”中的 1、2、3：自主招生、名额到区、名额到校。
+
+## 年度工作范围
+
+每年需要处理两大类数据。
+
+一、计划
+
+1. 自主招生
+2. 名额到区
+3. 名额到校
+4. 1-15 志愿
+
+二、成绩
+
+1. 自主招生
+2. 名额到区
+3. 名额到校
+4. 1-15 志愿
+
+2026 年当前状态：
+
+- 计划/自主招生：已导入
+- 计划/名额到区：已导入
+- 计划/名额到校：已导入
+- 计划/1-15 志愿：待官方文件发布后导入
+- 成绩四类：预计 7 月中旬后导入
+
+## 数据库与核心表
+
+目标数据库：`kylx365_db`
+
+核心表：
+
+- `MPS_School`：学校表，所有学校相关信息以此表为准。
+- `MPS_Score`：计划与成绩表，所有导入结果写入此表。
+
+常用参照查询：
+
+```sql
+SELECT *
+FROM kylx365_db.MPS_School
+WHERE SchoolType1 = '高中';
+```
+
+```sql
+SELECT *
+FROM kylx365_db.MPS_Score
+WHERE ScoreYear = '2025'
+  AND ScoreType = '名额到校'
+  AND DistrictID = 1;
+```
+
+数据库连接信息不要写入 README 或提交到仓库。当前脚本里使用本机已有配置和 PyMySQL 驱动连接，后续最好抽成单独的本地配置文件或环境变量。
+
+## DistrictID 对照
+
+```text
+1  黄浦区
+2  徐汇区
+3  长宁区
+4  静安区
+5  普陀区
+6  虹口区
+7  杨浦区
+8  闵行区
+9  宝山区
+10 嘉定区
+11 浦东新区
+12 金山区
+13 松江区
+14 青浦区
+15 奉贤区
+16 崇明区
+```
+
+## MPS_Score 写入规则
+
+计划类导入一般只写计划数，不写成绩。
+
+通用字段规则：
+
+- `ScoreYear`：年份，例如 `2026`
+- `ScoreType`：`自主招生`、`名额到区`、`名额到校`、`1-15志愿`
+- `DistrictID`：对应区 ID
+- `SchoolTarget`：高中学校 `MPS_School.ID`，以字符串写入
+- `SchoolFullName`：必须使用高中 ID 对应的 `MPS_School.SchoolFullName`
+- `PlanNum`：计划人数
+- `ScoreTotal`、`Score1`、`Score2`、`Score3`、`Score4`：计划导入时填 `0`
+- `ScoreTotalDifferenceValue`：计划导入时填 `0`
+- `PlanNumDifferenceValue`：当前计划数减去上一年同维度计划数
+- `OrderID`：当前计划导入填 `0`
+- `SchoolNumber`、`SchoolNumber2`：当前计划导入填空字符串
+- `SchoolOfGraduation1`：当前计划导入填 `"0"`
+
+名额到校额外规则：
+
+- `SchoolOfGraduation`：初中学校 `MPS_School.ID`
+- `SchoolFullNameJunior`：必须使用初中 ID 对应的 `MPS_School.SchoolFullName`
+- 一条数据的唯一业务维度可按 `ScoreYear + ScoreType + DistrictID + SchoolOfGraduation + SchoolTarget` 理解。
+- 不能用 PDF 里的简称直接写入 `SchoolFullNameJunior` 或 `SchoolFullName`。
+
+自主招生额外规则：
+
+- 普通自主招生拆成：
+  - `1学科`
+  - `2体育`
+  - `3艺术`
+- 国际课程班/中外合作办学拆成：
+  - `4国际(本市)`
+  - `5国际(非本市)`
+- `SchoolTargetRemark2` 可参考上一年同学校同类别备注；体育/艺术通常沿用“市级优秀体育学生”“市级艺术骨干学生”等说明。
+
+名额到区额外规则：
+
+- `SchoolOfGraduation = 0`
+- `SchoolFullNameJunior = NULL`
+- `SchoolTargetRemark = ""`
+- 维度是“区 + 高中”。
+
+## 总体操作流程
+
+每一类数据都按以下流程做：
+
+1. 先研究上一年 PDF 与上一年数据库数据，确认字段含义和写入形态。
+2. 读取新一年 PDF/图片，优先用表格解析；表格解析失败或 PDF 其实是图片时再 OCR/人工读图。
+3. 先匹配学校，不确定的数据不要导入，写入问题清单。
+4. 先 dry-run 或打印 ready 汇总，核对每区行数和计划数。
+5. 只插入新数据，不删除、不修改已有数据。
+6. 导入后查询 `MPS_Score` 总行数、总计划数、分区汇总。
+7. 对问题学校更新 `MPS_School` 后，再运行补录脚本，只补缺失行，并刷新问题清单。
+
+重要原则：
+
+- 凡是弄不清楚的，先不入库，放入 JSON 问题清单。
+- 若某个区解析问题较多，整个区可以先不动，等其他区处理完再单独解决。
+- 每次补录必须跳过已存在业务 key，避免重复插入。
+- 新增/改名学校优先修正 `MPS_School`，再重新匹配导入。
+
+## PDF/图片解析经验
+
+优先级：
+
+1. 有 6 位学校编号：优先用编号匹配。
+2. 有学校全称：用 `SchoolFullName` 匹配。
+3. 有简称或别名：用 `SchoolShortName`、`SchoolOtherName` 匹配。
+4. 仍不能唯一匹配：列为问题数据。
+
+学校名称常见问题：
+
+- PDF 中会使用简称，而且初中简称比高中多。
+- 有学校改名，PDF 可能写成“原名（现新名/校区）”。
+- 有新增学校，学校表中原本没有。
+- OCR 可能把换行、空格、序号、备注混进学校名。
+- 部分 PDF 表格中的学校名可能被拆成多行，需要清理换行再匹配。
+
+本次经验：
+
+- 高中通常有 6 位编号，匹配相对稳定。
+- 名额到校的初中数量多，名称最容易出问题。
+- `SchoolOtherName` 很适合放改名后的现名或曾用名。
+- 对“原名（现某某）”这种文本，匹配时应同时尝试原名、括号内现名、去括号名称。
+- 图片清晰时可以 OCR/读图解决，但要把结果转成结构化行，再按学校表 ID 入库。
+
+## 当前脚本说明
+
+脚本分为三类：主流程脚本、公共解析/补录脚本、2026 一次性补充脚本。后续年度工作时，主流程和公共脚本可以复制改年份；一次性补充脚本主要用于追溯 2026 的特殊处理，不建议直接运行到新年份。
+
+自主招生：
+
+- `import_mps_score_2026.py`
+- 读取 2026 自主招生计划 PDF 与国际课程班/中外合作办学 PDF。
+- 导入 `ScoreType = '自主招生'`。
+- 脚本会在已有 2026 自主招生数据时拒绝再次插入。
+
+名额到区：
+
+- `import_mps_score_quota_2026.py`
+- 读取 16 个区的名额到区 PDF。
+- 支持 `--dry-run`。
+- 如果某区已存在数据，会跳过并报告。
+- 对图片或解析失败区，使用 `import_mps_score_quota_manual_2026.py` 做手工/OCR 补充。
+
+名额到校：
+
+- `research_mps_score_school_quota_2026.py`
+- 负责学校加载、名称清洗、PDF 表格解析、学校匹配。
+- 已支持编号匹配、全称/简称/别名匹配、括号内“现名”匹配、同区唯一包含式匹配。
+
+- `import_mps_score_school_quota_2026.py`
+- 主导入脚本，读取 16 个区名额到校 PDF。
+- 支持 `--dry-run`。
+- 解析不确定的数据写入 `mps_score_school_quota_2026_problems.json`。
+
+- `import_mps_score_school_quota_supplement_2026.py`
+- 用于补充处理徐汇、嘉定等表格/OCR特殊区。
+
+- `import_mps_score_school_quota_hongkou_2026.py`
+- 用于处理虹口图片读图后的结构化数据。
+
+- `fix_mps_score_school_quota_problems_2026.py`
+- 当 `MPS_School` 中新增/修正学校后，重新解析问题区并补插当前能匹配的数据。
+- 会跳过数据库中已存在的 `DistrictID + SchoolOfGraduation + SchoolTarget` 组合。
+- 会刷新 `mps_score_school_quota_2026_problems.json`，只保留仍未解决的问题。
+
+2026 一次性补充脚本：
+
+- `import_mps_score_quota_manual_2026.py`：用于 2026 名额到区图片/OCR特殊区的手工补录，不是新年份通用入口。
+- `import_mps_score_school_quota_hongkou_2026.py`：用于 2026 虹口名额到校图片读图后的手工矩阵导入，不是新年份通用入口。
+- `import_mps_score_school_quota_supplement_2026.py`：包含 2026 徐汇手工矩阵和嘉定特殊 PDF 解析；其中 `collect_jiading` 目前仍被 `fix_mps_score_school_quota_problems_2026.py` 引用，所以不要单独删除。
+
+生成物：
+
+- `__pycache__/` 和 `*.pyc` 是 Python 运行缓存，不属于业务数据或脚本，已在主仓库 `.gitignore` 中忽略。
+
+## 2026 已完成结果
+
+计划/自主招生：
+
+- `ScoreYear = 2026`
+- `ScoreType = 自主招生`
+- 已导入 265 行
+- 计划数合计 7813
+
+计划/名额到区：
+
+- `ScoreYear = 2026`
+- `ScoreType = 名额到区`
+- 已导入 947 行
+- 计划数合计 7171
+
+计划/名额到校：
+
+- `ScoreYear = 2026`
+- `ScoreType = 名额到校`
+- 已导入 3892 行
+- 计划数合计 12833
+- 问题清单 `mps_score_school_quota_2026_problems.json` 已清空
+
+2026 名额到校最终分区汇总：
+
+| DistrictID | 区 | 行数 | 计划数 |
+| --- | --- | ---: | ---: |
+| 1 | 黄浦区 | 217 | 996 |
+| 2 | 徐汇区 | 221 | 899 |
+| 3 | 长宁区 | 63 | 418 |
+| 4 | 静安区 | 271 | 1102 |
+| 5 | 普陀区 | 179 | 736 |
+| 6 | 虹口区 | 80 | 488 |
+| 7 | 杨浦区 | 144 | 707 |
+| 8 | 闵行区 | 460 | 1290 |
+| 9 | 宝山区 | 348 | 1076 |
+| 10 | 嘉定区 | 130 | 612 |
+| 11 | 浦东新区 | 1259 | 2082 |
+| 12 | 金山区 | 56 | 355 |
+| 13 | 松江区 | 190 | 779 |
+| 14 | 青浦区 | 93 | 725 |
+| 15 | 奉贤区 | 131 | 345 |
+| 16 | 崇明区 | 50 | 223 |
+
+## 常用核验 SQL
+
+总量：
+
+```sql
+SELECT COUNT(*) AS c, SUM(PlanNum) AS total
+FROM MPS_Score
+WHERE ScoreYear = '2026'
+  AND ScoreType = '名额到校';
+```
+
+分区：
+
+```sql
+SELECT DistrictID, COUNT(*) AS c, SUM(PlanNum) AS total
+FROM MPS_Score
+WHERE ScoreYear = '2026'
+  AND ScoreType = '名额到校'
+GROUP BY DistrictID
+ORDER BY DistrictID;
+```
+
+检查某区上一年参照：
+
+```sql
+SELECT *
+FROM MPS_Score
+WHERE ScoreYear = '2025'
+  AND ScoreType = '名额到校'
+  AND DistrictID = 1
+ORDER BY ID;
+```
+
+查初中学校名称：
+
+```sql
+SELECT ID, DistrictID, SchoolNumber, SchoolFullName, SchoolShortName, SchoolOtherName
+FROM MPS_School
+WHERE SchoolType1 = '初中'
+  AND (
+    SchoolFullName LIKE '%学校名关键词%'
+    OR SchoolShortName LIKE '%学校名关键词%'
+    OR SchoolOtherName LIKE '%学校名关键词%'
+  );
+```
+
+## 明年复制脚本时要改的地方
+
+把脚本从 2026 复制到新年份后，至少检查这些常量：
+
+- `YEAR`
+- `PREVIOUS_YEAR`
+- `BASE_DIR`
+- PDF 文件名
+- 问题 JSON 文件名
+- 特殊区手工数据脚本中的高中代码、初中代码、计划矩阵
+- 自主招生中国际课程班 PDF 名称
+
+导入前必须确认目标年份目标类型没有已有数据，或脚本明确支持跳过/补录。  
+不要为了重新跑脚本而删除数据库旧数据，除非明确确认要重做且已备份。
+
+## 待办
+
+计划/1-15 志愿：
+
+- 等 2026 官方文件发布后处理。
+- 需要先研究 2025 的 PDF 与数据库写入形态，再决定 `ScoreType`、字段、维度和差值计算。
+
+成绩导入：
+
+- 预计 7 月中旬后开始。
+- 四类成绩都要先研究上一年数据。
+- 成绩类导入会涉及 `ScoreTotal`、`Score1`、`Score2`、`Score3`、`Score4` 等字段，不能沿用计划类全部填 0 的规则。
+- 成绩导入前要明确每个分数列的含义、缺考/无分/未录取的表示方式，以及是否需要计算差值。
+

秒过分数线数据导入/fix_mps_score_school_quota_problems_2026.py

@@ -0,0 +1,140 @@
+import json
+import os
+import sys
+
+sys.path.insert(0, "/private/tmp/codex_mysql_driver")
+import pymysql  # noqa: E402
+
+import research_mps_score_school_quota_2026 as parser  # noqa: E402
+from import_mps_score_school_quota_2026 import (  # noqa: E402
+    INSERT_COLUMNS,
+    PROBLEM_FILE,
+    build_record,
+    load_previous_plan_nums,
+)
+from import_mps_score_school_quota_supplement_2026 import collect_jiading  # noqa: E402
+
+
+DISTRICTS_TO_FIX = [7, 8, 9, 10, 11, 12, 13, 14, 15]
+
+
+def existing_keys(cursor):
+    cursor.execute(
+        """
+        SELECT DistrictID, SchoolOfGraduation, SchoolTarget
+        FROM MPS_Score
+        WHERE ScoreYear = '2026' AND ScoreType = '名额到校'
+        """
+    )
+    return {
+        (int(row["DistrictID"]), int(row["SchoolOfGraduation"]), str(row["SchoolTarget"]))
+        for row in cursor.fetchall()
+    }
+
+
+def insert_records(cursor, records):
+    if not records:
+        return 0
+    columns = ", ".join(INSERT_COLUMNS)
+    placeholders = ", ".join(["%s"] * len(INSERT_COLUMNS))
+    sql = f"INSERT INTO MPS_Score ({columns}) VALUES ({placeholders})"
+    cursor.executemany(sql, [[row[column] for column in INSERT_COLUMNS] for row in records])
+    return len(records)
+
+
+def problem_to_json(problem):
+    try:
+        raw, high_method, junior_method = problem
+        return {"raw": raw, "high_match": high_method, "junior_match": junior_method}
+    except Exception:
+        return {"raw": repr(problem)}
+
+
+def collect_regular(district_id, high_by_code, high_by_name, junior_by_code, junior_by_name):
+    district_name = parser.DISTRICTS[district_id]
+    path = os.path.join(parser.BASE_DIR, f"2026名额到校{district_name}.pdf")
+    rows, problems = parser.parse_tables(
+        path, district_id, high_by_code, high_by_name, junior_by_code, junior_by_name
+    )
+    return rows, [problem_to_json(item) for item in problems]
+
+
+def main():
+    conn = pymysql.connect(**parser.DB_CONFIG)
+    try:
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            high_by_code, high_by_name, _ = parser.load_schools(cursor, "高中")
+            junior_by_code, junior_by_name, _ = parser.load_schools(cursor, "初中")
+            previous = load_previous_plan_nums(cursor)
+            keys = existing_keys(cursor)
+
+            all_records = []
+            remaining = {}
+            inserted_summary = {}
+
+            for district_id in DISTRICTS_TO_FIX:
+                if district_id == 10:
+                    rows, problems = collect_jiading(high_by_code, high_by_name, junior_by_name)
+                    json_problems = problems
+                else:
+                    rows, json_problems = collect_regular(
+                        district_id, high_by_code, high_by_name, junior_by_code, junior_by_name
+                    )
+
+                new_records = []
+                for row in rows:
+                    junior, high, _plan_num, _junior_method, _high_method = row
+                    key = (district_id, int(junior["ID"]), str(high["ID"]))
+                    if key in keys:
+                        continue
+                    keys.add(key)
+                    new_records.append(build_record(district_id, row, previous))
+
+                inserted_summary[str(district_id)] = {
+                    "district": parser.DISTRICTS[district_id],
+                    "rows": len(new_records),
+                    "plan": sum(row["PlanNum"] for row in new_records),
+                }
+                all_records.extend(new_records)
+
+                if json_problems:
+                    remaining[str(district_id)] = {
+                        "district": parser.DISTRICTS[district_id],
+                        "status": "partial",
+                        "file": os.path.join(
+                            parser.BASE_DIR, f"2026名额到校{parser.DISTRICTS[district_id]}.pdf"
+                        ),
+                        "problems": json_problems,
+                    }
+
+            inserted = insert_records(cursor, all_records)
+            conn.commit()
+
+            with open(PROBLEM_FILE, "w", encoding="utf-8") as handle:
+                json.dump(remaining, handle, ensure_ascii=False, indent=2, default=str)
+                handle.write("\n")
+
+            print("inserted", inserted)
+            print("inserted_summary", json.dumps(inserted_summary, ensure_ascii=False, default=str))
+            print(
+                "remaining_summary",
+                json.dumps(
+                    {
+                        key: {
+                            "district": value["district"],
+                            "problem_count": len(value.get("problems", [])),
+                        }
+                        for key, value in remaining.items()
+                    },
+                    ensure_ascii=False,
+                ),
+            )
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

秒过分数线数据导入/import_mps_score_2026.py

@@ -0,0 +1,350 @@
+import re
+import sys
+from collections import defaultdict
+
+import pdfplumber
+
+sys.path.insert(0, "/private/tmp/codex_mysql_driver")
+import pymysql  # noqa: E402
+
+
+DB_CONFIG = {
+    "host": "589ae8e08493d.sh.cdb.myqcloud.com",
+    "port": 8124,
+    "user": "cdb_outerroot",
+    "password": "kylx!@#!QAZ@WSX",
+    "database": "kylx365_db",
+    "charset": "utf8mb4",
+    "connect_timeout": 10,
+    "read_timeout": 30,
+    "write_timeout": 30,
+}
+
+YEAR = "2026"
+SCORE_TYPE = "自主招生"
+
+AUTONOMOUS_PDF = (
+    "/Volumes/程杰外接SD盘/上海中考招生计划/2026/计划/自主招生/"
+    "2026年上海市高中自主招生计划 .pdf"
+)
+INTERNATIONAL_PDF = (
+    "/Volumes/程杰外接SD盘/上海中考招生计划/2026/计划/自主招生/"
+    "2026年上海市高中国际课程班和中外合作办学学校招生计划.pdf"
+)
+
+INSERT_COLUMNS = [
+    "ScoreYear",
+    "ScoreType",
+    "DistrictID",
+    "SchoolOfGraduation",
+    "SchoolFullNameJunior",
+    "SchoolTarget",
+    "SchoolFullName",
+    "SchoolTargetRemark",
+    "PlanNum",
+    "ScoreTotal",
+    "Score1",
+    "Score2",
+    "Score3",
+    "Score4",
+    "SchoolTargetRemark2",
+    "PlanNumDifferenceValue",
+    "ScoreTotalDifferenceValue",
+    "OrderID",
+    "SchoolNumber",
+    "SchoolNumber2",
+    "SchoolOfGraduation1",
+]
+
+
+def clean_code(value):
+    match = re.search(r"\d{6}", str(value or ""))
+    return match.group(0) if match else None
+
+
+def clean_num(value):
+    nums = re.findall(r"\d+", str(value or ""))
+    return int(nums[-1]) if nums else None
+
+
+def connect():
+    return pymysql.connect(**DB_CONFIG)
+
+
+def load_schools(cursor):
+    cursor.execute(
+        """
+        SELECT ID, DistrictID, SchoolNumber, SchoolFullName, SchoolType1, SchoolType2
+        FROM MPS_School
+        WHERE SchoolType1 = '高中' AND SchoolNumber IS NOT NULL AND SchoolNumber <> ''
+        """
+    )
+    by_code = defaultdict(list)
+    for row in cursor.fetchall():
+        by_code[row["SchoolNumber"]].append(row)
+
+    schools = {}
+    for code, rows in by_code.items():
+        rows.sort(
+            key=lambda row: (
+                row["SchoolType2"] is None,
+                row["SchoolType2"] == "",
+                row["ID"],
+            )
+        )
+        schools[code] = rows[0]
+    return schools
+
+
+def load_2025_remarks(cursor):
+    cursor.execute(
+        """
+        SELECT SchoolTarget, SchoolTargetRemark, SchoolTargetRemark2
+        FROM MPS_Score
+        WHERE ScoreYear = '2025'
+          AND ScoreType = '自主招生'
+          AND SchoolTargetRemark IN ('2体育', '3艺术')
+        """
+    )
+    return {
+        (str(row["SchoolTarget"]), row["SchoolTargetRemark"]): row["SchoolTargetRemark2"]
+        for row in cursor.fetchall()
+    }
+
+
+def load_previous_plan_nums(cursor):
+    cursor.execute(
+        """
+        SELECT SchoolTarget, SchoolTargetRemark, PlanNum
+        FROM MPS_Score
+        WHERE ScoreYear = '2025' AND ScoreType = '自主招生'
+        """
+    )
+    return {
+        (str(row["SchoolTarget"]), row["SchoolTargetRemark"]): int(row["PlanNum"] or 0)
+        for row in cursor.fetchall()
+    }
+
+
+def parse_autonomous_pdf(path, schools):
+    rows = []
+    missing_codes = []
+    with pdfplumber.open(path) as pdf:
+        for page in pdf.pages:
+            for table in page.extract_tables():
+                for raw in table:
+                    code = clean_code(raw[1] if len(raw) > 1 else None)
+                    if not code:
+                        continue
+                    school = schools.get(code)
+                    if not school:
+                        missing_codes.append((code, raw))
+                        continue
+                    total, sport, art = [clean_num(cell) for cell in raw[-3:]]
+                    sport = sport or 0
+                    art = art or 0
+                    total = total or 0
+                    rows.append(
+                        {
+                            "school": school,
+                            "total": total,
+                            "subject": total - sport - art,
+                            "sport": sport,
+                            "art": art,
+                        }
+                    )
+    return rows, missing_codes
+
+
+def parse_international_pdf(path, schools):
+    rows = []
+    missing_codes = []
+    with pdfplumber.open(path) as pdf:
+        for page in pdf.pages:
+            for table in page.extract_tables():
+                for raw in table:
+                    code = clean_code(raw[1] if len(raw) > 1 else None)
+                    if not code:
+                        continue
+                    school = schools.get(code)
+                    if not school:
+                        missing_codes.append((code, raw))
+                        continue
+                    total, local, nonlocal_plan = [clean_num(cell) for cell in raw[-3:]]
+                    rows.append(
+                        {
+                            "school": school,
+                            "total": total or 0,
+                            "local": local or 0,
+                            "nonlocal": nonlocal_plan or 0,
+                        }
+                    )
+    return rows, missing_codes
+
+
+def build_record(school, remark, plan_num, remark2, previous_plan_nums):
+    school_target = str(school["ID"])
+    previous = previous_plan_nums.get((school_target, remark), 0)
+    return {
+        "ScoreYear": YEAR,
+        "ScoreType": SCORE_TYPE,
+        "DistrictID": school["DistrictID"],
+        "SchoolOfGraduation": 0,
+        "SchoolFullNameJunior": None,
+        "SchoolTarget": school_target,
+        "SchoolFullName": school["SchoolFullName"],
+        "SchoolTargetRemark": remark,
+        "PlanNum": plan_num,
+        "ScoreTotal": 0,
+        "Score1": 0,
+        "Score2": 0,
+        "Score3": 0,
+        "Score4": 0,
+        "SchoolTargetRemark2": remark2 or "",
+        "PlanNumDifferenceValue": plan_num - previous,
+        "ScoreTotalDifferenceValue": 0,
+        "OrderID": 0,
+        "SchoolNumber": "",
+        "SchoolNumber2": "",
+        "SchoolOfGraduation1": "0",
+    }
+
+
+def build_records(autonomous_rows, international_rows, previous_plan_nums, remark_2025):
+    records = []
+
+    for item in autonomous_rows:
+        school = item["school"]
+        records.append(
+            build_record(
+                school,
+                "1学科",
+                item["subject"],
+                school["SchoolType2"],
+                previous_plan_nums,
+            )
+        )
+        if item["sport"] > 0:
+            records.append(
+                build_record(
+                    school,
+                    "2体育",
+                    item["sport"],
+                    remark_2025.get((str(school["ID"]), "2体育"), "市级优秀体育学生"),
+                    previous_plan_nums,
+                )
+            )
+        if item["art"] > 0:
+            records.append(
+                build_record(
+                    school,
+                    "3艺术",
+                    item["art"],
+                    remark_2025.get((str(school["ID"]), "3艺术"), "市级艺术骨干学生"),
+                    previous_plan_nums,
+                )
+            )
+
+    for item in international_rows:
+        school = item["school"]
+        if item["local"] > 0:
+            records.append(
+                build_record(
+                    school,
+                    "4国际(本市)",
+                    item["local"],
+                    "国际课程班／中外合作办学高中",
+                    previous_plan_nums,
+                )
+            )
+        if item["nonlocal"] > 0:
+            records.append(
+                build_record(
+                    school,
+                    "5国际(非本市)",
+                    item["nonlocal"],
+                    "国际课程班／中外合作办学高中",
+                    previous_plan_nums,
+                )
+            )
+    return records
+
+
+def summarize(records):
+    summary = defaultdict(lambda: {"count": 0, "plan": 0})
+    for row in records:
+        bucket = summary[row["SchoolTargetRemark"]]
+        bucket["count"] += 1
+        bucket["plan"] += row["PlanNum"]
+    return dict(sorted(summary.items()))
+
+
+def main():
+    conn = connect()
+    try:
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute(
+                """
+                SELECT COUNT(*) AS count
+                FROM MPS_Score
+                WHERE ScoreYear = %s AND ScoreType = %s
+                """,
+                (YEAR, SCORE_TYPE),
+            )
+            existing_count = cursor.fetchone()["count"]
+            if existing_count:
+                raise RuntimeError(
+                    f"Refusing to insert: {YEAR} {SCORE_TYPE} already has {existing_count} rows."
+                )
+
+            schools = load_schools(cursor)
+            previous_plan_nums = load_previous_plan_nums(cursor)
+            remark_2025 = load_2025_remarks(cursor)
+
+            autonomous_rows, missing_autonomous = parse_autonomous_pdf(AUTONOMOUS_PDF, schools)
+            international_rows, missing_international = parse_international_pdf(
+                INTERNATIONAL_PDF, schools
+            )
+            missing = missing_autonomous + missing_international
+            if missing:
+                raise RuntimeError(f"Missing school codes: {missing[:10]}")
+
+            records = build_records(
+                autonomous_rows,
+                international_rows,
+                previous_plan_nums,
+                remark_2025,
+            )
+
+            print("autonomous_pdf_rows", len(autonomous_rows))
+            print("international_pdf_rows", len(international_rows))
+            print("insert_rows", len(records))
+            print("summary", summarize(records))
+
+            placeholders = ", ".join(["%s"] * len(INSERT_COLUMNS))
+            columns = ", ".join(INSERT_COLUMNS)
+            sql = f"INSERT INTO MPS_Score ({columns}) VALUES ({placeholders})"
+            values = [[row[column] for column in INSERT_COLUMNS] for row in records]
+            cursor.executemany(sql, values)
+            conn.commit()
+
+            cursor.execute(
+                """
+                SELECT SchoolTargetRemark, COUNT(*) AS count, SUM(PlanNum) AS plan
+                FROM MPS_Score
+                WHERE ScoreYear = %s AND ScoreType = %s
+                GROUP BY SchoolTargetRemark
+                ORDER BY SchoolTargetRemark
+                """,
+                (YEAR, SCORE_TYPE),
+            )
+            print("db_summary", cursor.fetchall())
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

秒过分数线数据导入/import_mps_score_quota_2026.py

@@ -0,0 +1,289 @@
+import argparse
+import os
+import re
+import sys
+from collections import defaultdict
+
+import pdfplumber
+
+sys.path.insert(0, "/private/tmp/codex_mysql_driver")
+import pymysql  # noqa: E402
+
+
+DB_CONFIG = {
+    "host": "589ae8e08493d.sh.cdb.myqcloud.com",
+    "port": 8124,
+    "user": "cdb_outerroot",
+    "password": "kylx!@#!QAZ@WSX",
+    "database": "kylx365_db",
+    "charset": "utf8mb4",
+    "connect_timeout": 10,
+    "read_timeout": 30,
+    "write_timeout": 30,
+}
+
+YEAR = "2026"
+PREVIOUS_YEAR = "2025"
+SCORE_TYPE = "名额到区"
+BASE_DIR = "/Volumes/程杰外接SD盘/上海中考招生计划/2026/计划/名额到区"
+
+DISTRICTS = {
+    1: "黄浦区",
+    2: "徐汇区",
+    3: "长宁区",
+    4: "静安区",
+    5: "普陀区",
+    6: "虹口区",
+    7: "杨浦区",
+    8: "闵行区",
+    9: "宝山区",
+    10: "嘉定区",
+    11: "浦东新区",
+    12: "金山区",
+    13: "松江区",
+    14: "青浦区",
+    15: "奉贤区",
+    16: "崇明区",
+}
+
+INSERT_COLUMNS = [
+    "ScoreYear",
+    "ScoreType",
+    "DistrictID",
+    "SchoolOfGraduation",
+    "SchoolFullNameJunior",
+    "SchoolTarget",
+    "SchoolFullName",
+    "SchoolTargetRemark",
+    "PlanNum",
+    "ScoreTotal",
+    "Score1",
+    "Score2",
+    "Score3",
+    "Score4",
+    "SchoolTargetRemark2",
+    "PlanNumDifferenceValue",
+    "ScoreTotalDifferenceValue",
+    "OrderID",
+    "SchoolNumber",
+    "SchoolNumber2",
+    "SchoolOfGraduation1",
+]
+
+
+def clean_code(value):
+    match = re.search(r"\d{6}", str(value or ""))
+    return match.group(0) if match else None
+
+
+def clean_num(value):
+    nums = re.findall(r"\d+", str(value or ""))
+    return int(nums[-1]) if nums else None
+
+
+def connect():
+    return pymysql.connect(**DB_CONFIG)
+
+
+def district_file_name(district_name):
+    return f"2026名额到区{district_name}.pdf"
+
+
+def load_schools(cursor):
+    cursor.execute(
+        """
+        SELECT ID, DistrictID, SchoolNumber, SchoolFullName, SchoolType1, SchoolType2
+        FROM MPS_School
+        WHERE SchoolType1 = '高中' AND SchoolNumber IS NOT NULL AND SchoolNumber <> ''
+        """
+    )
+    by_code = defaultdict(list)
+    for row in cursor.fetchall():
+        by_code[row["SchoolNumber"]].append(row)
+
+    schools = {}
+    for code, rows in by_code.items():
+        rows.sort(
+            key=lambda row: (
+                row["SchoolType2"] is None,
+                row["SchoolType2"] == "",
+                row["ID"],
+            )
+        )
+        schools[code] = rows[0]
+    return schools
+
+
+def load_previous_plan_nums(cursor):
+    cursor.execute(
+        """
+        SELECT DistrictID, SchoolTarget, PlanNum
+        FROM MPS_Score
+        WHERE ScoreYear = %s AND ScoreType = %s
+        """,
+        (PREVIOUS_YEAR, SCORE_TYPE),
+    )
+    return {
+        (int(row["DistrictID"]), str(row["SchoolTarget"])): int(row["PlanNum"] or 0)
+        for row in cursor.fetchall()
+    }
+
+
+def parse_pdf(path, district_name, schools):
+    rows = []
+    missing = []
+    with pdfplumber.open(path) as pdf:
+        for page in pdf.pages:
+            for table in page.extract_tables():
+                for raw in table:
+                    code = clean_code(raw[1] if len(raw) > 1 else None)
+                    if not code:
+                        continue
+                    plan_num = clean_num(raw[-1] if raw else None)
+                    if plan_num is None:
+                        missing.append(("plan_num", raw))
+                        continue
+                    raw_text = " ".join(str(cell or "") for cell in raw)
+                    if district_name[:2] not in raw_text and district_name not in raw_text:
+                        missing.append(("district_mismatch", raw))
+                        continue
+                    school = schools.get(code)
+                    if not school:
+                        missing.append(("school_code", raw))
+                        continue
+                    rows.append({"school": school, "plan_num": plan_num, "raw": raw})
+    return rows, missing
+
+
+def build_record(district_id, parsed_row, previous_plan_nums):
+    school = parsed_row["school"]
+    school_target = str(school["ID"])
+    previous = previous_plan_nums.get((district_id, school_target), 0)
+    plan_num = parsed_row["plan_num"]
+    return {
+        "ScoreYear": YEAR,
+        "ScoreType": SCORE_TYPE,
+        "DistrictID": district_id,
+        "SchoolOfGraduation": 0,
+        "SchoolFullNameJunior": None,
+        "SchoolTarget": school_target,
+        "SchoolFullName": school["SchoolFullName"],
+        "SchoolTargetRemark": "",
+        "PlanNum": plan_num,
+        "ScoreTotal": 0,
+        "Score1": 0,
+        "Score2": 0,
+        "Score3": 0,
+        "Score4": 0,
+        "SchoolTargetRemark2": None,
+        "PlanNumDifferenceValue": plan_num - previous,
+        "ScoreTotalDifferenceValue": 0,
+        "OrderID": 0,
+        "SchoolNumber": "",
+        "SchoolNumber2": "",
+        "SchoolOfGraduation1": "0",
+    }
+
+
+def collect_records(cursor):
+    schools = load_schools(cursor)
+    previous_plan_nums = load_previous_plan_nums(cursor)
+    records_by_district = {}
+    problems = {}
+
+    for district_id, district_name in DISTRICTS.items():
+        cursor.execute(
+            """
+            SELECT COUNT(*) AS count
+            FROM MPS_Score
+            WHERE ScoreYear = %s AND ScoreType = %s AND DistrictID = %s
+            """,
+            (YEAR, SCORE_TYPE, district_id),
+        )
+        existing = cursor.fetchone()["count"]
+        if existing:
+            problems[district_id] = f"already has {existing} rows"
+            continue
+
+        pdf_name = district_file_name(district_name)
+        path = os.path.join(BASE_DIR, pdf_name)
+        if not os.path.exists(path):
+            jpg_path = os.path.join(BASE_DIR, f"2026名额到区{district_name}.jpg")
+            if os.path.exists(jpg_path):
+                problems[district_id] = f"image file requires OCR: {jpg_path}"
+            else:
+                problems[district_id] = f"missing file: {path}"
+            continue
+
+        parsed_rows, parse_problems = parse_pdf(path, district_name, schools)
+        if parse_problems:
+            problems[district_id] = f"parse problems: {parse_problems[:3]}"
+            continue
+        if not parsed_rows:
+            problems[district_id] = "no table rows extracted"
+            continue
+
+        records_by_district[district_id] = [
+            build_record(district_id, row, previous_plan_nums) for row in parsed_rows
+        ]
+
+    return records_by_district, problems
+
+
+def print_summary(records_by_district, problems):
+    for district_id in sorted(records_by_district):
+        records = records_by_district[district_id]
+        print(
+            "ready",
+            district_id,
+            DISTRICTS[district_id],
+            "rows",
+            len(records),
+            "plan",
+            sum(row["PlanNum"] for row in records),
+        )
+    for district_id in sorted(problems):
+        print("problem", district_id, DISTRICTS[district_id], problems[district_id])
+
+
+def insert_records(cursor, records_by_district):
+    rows = [
+        row
+        for district_id in sorted(records_by_district)
+        for row in records_by_district[district_id]
+    ]
+    if not rows:
+        return 0
+    placeholders = ", ".join(["%s"] * len(INSERT_COLUMNS))
+    columns = ", ".join(INSERT_COLUMNS)
+    sql = f"INSERT INTO MPS_Score ({columns}) VALUES ({placeholders})"
+    values = [[row[column] for column in INSERT_COLUMNS] for row in rows]
+    cursor.executemany(sql, values)
+    return len(rows)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+
+    conn = connect()
+    try:
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            records_by_district, problems = collect_records(cursor)
+            print_summary(records_by_district, problems)
+            if args.dry_run:
+                conn.rollback()
+                return
+            inserted = insert_records(cursor, records_by_district)
+            conn.commit()
+            print("inserted", inserted)
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

秒过分数线数据导入/import_mps_score_quota_manual_2026.py

@@ -0,0 +1,232 @@
+import sys
+
+sys.path.insert(0, "/private/tmp/codex_mysql_driver")
+import pymysql  # noqa: E402
+
+from import_mps_score_quota_2026 import (  # noqa: E402
+    DB_CONFIG,
+    INSERT_COLUMNS,
+    SCORE_TYPE,
+    YEAR,
+    build_record,
+    load_previous_plan_nums,
+    load_schools,
+)
+
+
+MANUAL_ROWS = {
+    6: [
+        ("042032", 7),
+        ("102056", 20),
+        ("102057", 14),
+        ("152003", 9),
+        ("012001", 9),
+        ("012003", 2),
+        ("012007", 1),
+        ("012008", 2),
+        ("012009", 3),
+        ("012011", 2),
+        ("042001", 4),
+        ("042008", 2),
+        ("042035", 3),
+        ("043015", 3),
+        ("052001", 5),
+        ("052002", 2),
+        ("053004", 3),
+        ("062002", 2),
+        ("062003", 6),
+        ("062004", 5),
+        ("062011", 2),
+        ("063004", 7),
+        ("064001", 1),
+        ("072002", 2),
+        ("073003", 7),
+        ("073082", 5),
+        ("092001", 8),
+        ("092002", 7),
+        ("093001", 6),
+        ("102004", 12),
+        ("102032", 10),
+        ("103002", 1),
+        ("122001", 4),
+        ("123001", 2),
+        ("122002", 3),
+        ("122003", 2),
+        ("132001", 8),
+        ("132002", 5),
+        ("133001", 4),
+        ("132003", 4),
+        ("133003", 6),
+        ("142001", 4),
+        ("142002", 10),
+        ("142004", 2),
+        ("152001", 10),
+        ("152002", 2),
+        ("152004", 8),
+        ("153001", 7),
+        ("153004", 3),
+        ("153005", 9),
+        ("151078", 2),
+        ("152005", 6),
+        ("162000", 1),
+        ("163002", 3),
+        ("172001", 2),
+        ("173001", 4),
+        ("174003", 2),
+        ("182001", 5),
+        ("183002", 4),
+        ("182002", 3),
+        ("202001", 2),
+        ("202002", 2),
+        ("512000", 2),
+        ("512001", 3),
+    ],
+    10: [
+        ("042032", 11),
+        ("102056", 14),
+        ("102057", 10),
+        ("152003", 10),
+        ("152006", 1),
+        ("012001", 5),
+        ("012003", 3),
+        ("012007", 2),
+        ("012008", 2),
+        ("012010", 10),
+        ("012011", 4),
+        ("042001", 3),
+        ("042008", 3),
+        ("042035", 1),
+        ("043015", 2),
+        ("052001", 6),
+        ("052002", 5),
+        ("053004", 4),
+        ("062002", 9),
+        ("062003", 3),
+        ("062004", 2),
+        ("062011", 4),
+        ("064001", 6),
+        ("072001", 16),
+        ("072002", 9),
+        ("073003", 10),
+        ("073082", 10),
+        ("092001", 5),
+        ("092002", 3),
+        ("093001", 2),
+        ("102004", 3),
+        ("102032", 5),
+        ("103002", 1),
+        ("122001", 5),
+        ("123001", 10),
+        ("122002", 4),
+        ("122003", 2),
+        ("132001", 8),
+        ("132002", 12),
+        ("133001", 9),
+        ("132003", 6),
+        ("133003", 6),
+        ("142001", 14),
+        ("142002", 10),
+        ("142004", 6),
+        ("152001", 3),
+        ("152002", 7),
+        ("152004", 14),
+        ("153001", 5),
+        ("153004", 5),
+        ("153005", 6),
+        ("151078", 2),
+        ("152005", 4),
+        ("162000", 2),
+        ("163002", 3),
+        ("172001", 1),
+        ("173001", 4),
+        ("172002", 2),
+        ("172004", 3),
+        ("174003", 5),
+        ("182001", 14),
+        ("183002", 10),
+        ("182002", 6),
+        ("202001", 3),
+        ("512000", 3),
+    ],
+}
+
+
+def connect():
+    return pymysql.connect(**DB_CONFIG)
+
+
+def build_manual_records(cursor):
+    schools = load_schools(cursor)
+    previous_plan_nums = load_previous_plan_nums(cursor)
+    records_by_district = {}
+
+    for district_id, code_rows in MANUAL_ROWS.items():
+        cursor.execute(
+            """
+            SELECT COUNT(*) AS count
+            FROM MPS_Score
+            WHERE ScoreYear = %s AND ScoreType = %s AND DistrictID = %s
+            """,
+            (YEAR, SCORE_TYPE, district_id),
+        )
+        existing = cursor.fetchone()["count"]
+        if existing:
+            raise RuntimeError(f"District {district_id} already has {existing} rows.")
+
+        records = []
+        for code, plan_num in code_rows:
+            school = schools.get(code)
+            if not school:
+                raise RuntimeError(f"Missing school code {code} in district {district_id}.")
+            records.append(
+                build_record(
+                    district_id,
+                    {"school": school, "plan_num": plan_num},
+                    previous_plan_nums,
+                )
+            )
+        records_by_district[district_id] = records
+
+    return records_by_district
+
+
+def insert_records(cursor, records):
+    placeholders = ", ".join(["%s"] * len(INSERT_COLUMNS))
+    columns = ", ".join(INSERT_COLUMNS)
+    sql = f"INSERT INTO MPS_Score ({columns}) VALUES ({placeholders})"
+    values = [[row[column] for column in INSERT_COLUMNS] for row in records]
+    cursor.executemany(sql, values)
+
+
+def main():
+    conn = connect()
+    try:
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            records_by_district = build_manual_records(cursor)
+            for district_id in sorted(records_by_district):
+                records = records_by_district[district_id]
+                print(
+                    "ready",
+                    district_id,
+                    "rows",
+                    len(records),
+                    "plan",
+                    sum(row["PlanNum"] for row in records),
+                )
+            rows = [
+                row
+                for district_id in sorted(records_by_district)
+                for row in records_by_district[district_id]
+            ]
+            insert_records(cursor, rows)
+            conn.commit()
+            print("inserted", len(rows))
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

秒过分数线数据导入/import_mps_score_school_quota_2026.py

@@ -0,0 +1,224 @@
+import argparse
+import json
+import os
+import sys
+
+sys.path.insert(0, "/private/tmp/codex_mysql_driver")
+import pymysql
+
+import research_mps_score_school_quota_2026 as parser
+
+
+INSERT_COLUMNS = [
+    "ScoreYear",
+    "ScoreType",
+    "DistrictID",
+    "SchoolOfGraduation",
+    "SchoolFullNameJunior",
+    "SchoolTarget",
+    "SchoolFullName",
+    "SchoolTargetRemark",
+    "PlanNum",
+    "ScoreTotal",
+    "Score1",
+    "Score2",
+    "Score3",
+    "Score4",
+    "SchoolTargetRemark2",
+    "PlanNumDifferenceValue",
+    "ScoreTotalDifferenceValue",
+    "OrderID",
+    "SchoolNumber",
+    "SchoolNumber2",
+    "SchoolOfGraduation1",
+]
+
+PROBLEM_FILE = "mps_score_school_quota_2026_problems.json"
+
+
+def load_previous_plan_nums(cursor):
+    cursor.execute(
+        """
+        SELECT DistrictID, SchoolOfGraduation, SchoolTarget, PlanNum
+        FROM MPS_Score
+        WHERE ScoreYear = '2025' AND ScoreType = '名额到校'
+        """
+    )
+    return {
+        (int(row["DistrictID"]), int(row["SchoolOfGraduation"]), str(row["SchoolTarget"])): int(
+            row["PlanNum"] or 0
+        )
+        for row in cursor.fetchall()
+    }
+
+
+def build_record(district_id, row, previous_plan_nums):
+    junior, high, plan_num, _junior_method, _high_method = row
+    previous = previous_plan_nums.get((district_id, int(junior["ID"]), str(high["ID"])), 0)
+    return {
+        "ScoreYear": "2026",
+        "ScoreType": "名额到校",
+        "DistrictID": district_id,
+        "SchoolOfGraduation": int(junior["ID"]),
+        "SchoolFullNameJunior": junior["SchoolFullName"],
+        "SchoolTarget": str(high["ID"]),
+        "SchoolFullName": high["SchoolFullName"],
+        "SchoolTargetRemark": "",
+        "PlanNum": int(plan_num),
+        "ScoreTotal": 0,
+        "Score1": 0,
+        "Score2": 0,
+        "Score3": 0,
+        "Score4": 0,
+        "SchoolTargetRemark2": None,
+        "PlanNumDifferenceValue": int(plan_num) - previous,
+        "ScoreTotalDifferenceValue": 0,
+        "OrderID": 0,
+        "SchoolNumber": "",
+        "SchoolNumber2": "",
+        "SchoolOfGraduation1": "0",
+    }
+
+
+def problem_to_json(problem):
+    try:
+        raw, high_method, junior_method = problem
+        return {
+            "raw": raw,
+            "high_match": high_method,
+            "junior_match": junior_method,
+        }
+    except Exception:
+        return {"raw": repr(problem)}
+
+
+def collect(cursor):
+    high_by_code, high_by_name, _ = parser.load_schools(cursor, "高中")
+    junior_by_code, junior_by_name, _ = parser.load_schools(cursor, "初中")
+    previous_plan_nums = load_previous_plan_nums(cursor)
+
+    records_by_district = {}
+    problems_by_district = {}
+
+    for district_id, district_name in parser.DISTRICTS.items():
+        cursor.execute(
+            """
+            SELECT COUNT(*) AS count
+            FROM MPS_Score
+            WHERE ScoreYear = '2026' AND ScoreType = '名额到校' AND DistrictID = %s
+            """,
+            (district_id,),
+        )
+        existing = cursor.fetchone()["count"]
+        if existing:
+            problems_by_district[str(district_id)] = {
+                "district": district_name,
+                "status": f"already has {existing} rows",
+                "problems": [],
+            }
+            continue
+
+        pdf_path = os.path.join(parser.BASE_DIR, f"2026名额到校{district_name}.pdf")
+        jpg_path = os.path.join(parser.BASE_DIR, f"2026名额到校{district_name}.jpg")
+        if not os.path.exists(pdf_path):
+            problems_by_district[str(district_id)] = {
+                "district": district_name,
+                "status": "image_or_missing",
+                "file": jpg_path if os.path.exists(jpg_path) else pdf_path,
+                "problems": [],
+            }
+            continue
+
+        rows, problems = parser.parse_tables(
+            pdf_path, district_id, high_by_code, high_by_name, junior_by_code, junior_by_name
+        )
+        if not rows:
+            problems_by_district[str(district_id)] = {
+                "district": district_name,
+                "status": "no_safe_rows",
+                "file": pdf_path,
+                "problems": [problem_to_json(item) for item in problems[:200]],
+            }
+            continue
+
+        records_by_district[district_id] = [
+            build_record(district_id, row, previous_plan_nums) for row in rows
+        ]
+        if problems:
+            problems_by_district[str(district_id)] = {
+                "district": district_name,
+                "status": "partial",
+                "file": pdf_path,
+                "problems": [problem_to_json(item) for item in problems[:500]],
+            }
+
+    return records_by_district, problems_by_district
+
+
+def write_problem_file(problems):
+    with open(PROBLEM_FILE, "w", encoding="utf-8") as handle:
+        json.dump(problems, handle, ensure_ascii=False, indent=2, default=str)
+
+
+def insert_records(cursor, records_by_district):
+    rows = [
+        row
+        for district_id in sorted(records_by_district)
+        for row in records_by_district[district_id]
+    ]
+    if not rows:
+        return 0
+    columns = ", ".join(INSERT_COLUMNS)
+    placeholders = ", ".join(["%s"] * len(INSERT_COLUMNS))
+    sql = f"INSERT INTO MPS_Score ({columns}) VALUES ({placeholders})"
+    values = [[row[column] for column in INSERT_COLUMNS] for row in rows]
+    cursor.executemany(sql, values)
+    return len(rows)
+
+
+def main():
+    arg_parser = argparse.ArgumentParser()
+    arg_parser.add_argument("--dry-run", action="store_true")
+    args = arg_parser.parse_args()
+
+    conn = pymysql.connect(**parser.DB_CONFIG)
+    try:
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            records_by_district, problems = collect(cursor)
+            write_problem_file(problems)
+            for district_id in sorted(records_by_district):
+                rows = records_by_district[district_id]
+                print(
+                    "ready",
+                    district_id,
+                    parser.DISTRICTS[district_id],
+                    "rows",
+                    len(rows),
+                    "plan",
+                    sum(row["PlanNum"] for row in rows),
+                )
+            for district_id in sorted(problems, key=int):
+                info = problems[district_id]
+                print(
+                    "problem",
+                    district_id,
+                    info["district"],
+                    info["status"],
+                    "count",
+                    len(info.get("problems", [])),
+                )
+            if args.dry_run:
+                conn.rollback()
+                return
+            inserted = insert_records(cursor, records_by_district)
+            conn.commit()
+            print("inserted", inserted)
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

秒过分数线数据导入/import_mps_score_school_quota_hongkou_2026.py

@@ -0,0 +1,92 @@
+import sys
+
+sys.path.insert(0, "/private/tmp/codex_mysql_driver")
+import pymysql  # noqa: E402
+
+import research_mps_score_school_quota_2026 as parser  # noqa: E402
+from import_mps_score_school_quota_2026 import INSERT_COLUMNS, build_record, load_previous_plan_nums  # noqa: E402
+
+
+HIGH_CODES = ["092001", "092002", "093001", "042032", "152003", "102057", "102056"]
+
+ROWS = [
+    ("上海市虹口实验学校", [16, 15, 12, 0, 0, 0, 0]),
+    ("上海市曲阳第二中学", [11, 11, 7, 1, 0, 0, 0]),
+    ("上海市钟山初级中学", [9, 8, 6, 0, 0, 1, 0]),
+    ("上海市长青学校", [6, 6, 4, 0, 1, 0, 0]),
+    ("华东师范大学第一附属初级中学", [9, 9, 6, 0, 0, 0, 0]),
+    ("上海市丰镇中学", [10, 10, 8, 0, 0, 0, 0]),
+    ("上海市北郊学校", [6, 4, 4, 0, 0, 0, 0]),
+    ("上海市江湾初级中学", [7, 6, 4, 0, 0, 0, 0]),
+    ("上海市复兴实验中学", [6, 6, 4, 0, 0, 1, 0]),
+    ("上海音乐学院虹口区实验中学", [7, 6, 5, 0, 0, 0, 0]),
+    ("上海市虹口区教育学院实验中学", [6, 5, 4, 0, 0, 0, 1]),
+    ("上海市继光初级中学", [4, 3, 3, 0, 0, 0, 0]),
+    ("上海市海南中学", [1, 1, 2, 0, 0, 0, 0]),
+    ("上海市鲁迅初级中学", [7, 6, 4, 0, 0, 0, 0]),
+    ("上海市第五十二中学", [5, 4, 4, 0, 0, 0, 0]),
+    ("上海师范大学附属虹口中学", [4, 4, 4, 1, 0, 0, 0]),
+    ("同济大学附属澄衷中学", [1, 1, 2, 0, 0, 0, 1]),
+    ("上海世外教育附属虹口区欧阳学校", [4, 4, 4, 0, 0, 0, 0]),
+    ("上海市民办新华初级中学", [15, 14, 11, 0, 0, 0, 1]),
+    ("上海市民办新复兴初级中学", [16, 15, 11, 0, 0, 1, 0]),
+    ("上海市民办新北郊初级中学", [16, 15, 12, 0, 0, 1, 0]),
+    ("上海市民办迅行中学", [7, 7, 5, 0, 0, 0, 0]),
+    ("上海民办克勒外国语学校", [7, 6, 5, 0, 0, 0, 1]),
+]
+
+
+def insert_records(cursor, rows):
+    columns = ", ".join(INSERT_COLUMNS)
+    placeholders = ", ".join(["%s"] * len(INSERT_COLUMNS))
+    sql = f"INSERT INTO MPS_Score ({columns}) VALUES ({placeholders})"
+    values = [[row[column] for column in INSERT_COLUMNS] for row in rows]
+    cursor.executemany(sql, values)
+
+
+def main():
+    conn = pymysql.connect(**parser.DB_CONFIG)
+    try:
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute(
+                """
+                SELECT COUNT(*) AS count
+                FROM MPS_Score
+                WHERE ScoreYear = '2026' AND ScoreType = '名额到校' AND DistrictID = 6
+                """
+            )
+            existing = cursor.fetchone()["count"]
+            if existing:
+                raise RuntimeError(f"District 6 already has {existing} rows.")
+
+            high_by_code, _high_by_name, _ = parser.load_schools(cursor, "高中")
+            _junior_by_code, junior_by_name, _ = parser.load_schools(cursor, "初中")
+            previous = load_previous_plan_nums(cursor)
+
+            parsed_rows = []
+            for junior_name, plans in ROWS:
+                junior, method = parser.match_school(None, junior_name, {}, junior_by_name, 6)
+                if not junior:
+                    raise RuntimeError(f"Cannot match junior school: {junior_name} ({method})")
+                for high_code, plan in zip(HIGH_CODES, plans):
+                    if not plan:
+                        continue
+                    high = high_by_code.get(high_code)
+                    if not high:
+                        raise RuntimeError(f"Cannot match high school code: {high_code}")
+                    parsed_rows.append((junior, high, plan, "name", "code"))
+
+            records = [build_record(6, row, previous) for row in parsed_rows]
+            print("ready 6 虹口区 rows", len(records), "plan", sum(row["PlanNum"] for row in records))
+            insert_records(cursor, records)
+            conn.commit()
+            print("inserted", len(records))
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

秒过分数线数据导入/import_mps_score_school_quota_supplement_2026.py

@@ -0,0 +1,202 @@
+import json
+import sys
+
+import pdfplumber
+
+sys.path.insert(0, "/private/tmp/codex_mysql_driver")
+import pymysql  # noqa: E402
+
+import research_mps_score_school_quota_2026 as parser  # noqa: E402
+from import_mps_score_school_quota_2026 import INSERT_COLUMNS, build_record, load_previous_plan_nums  # noqa: E402
+
+
+XUHUI_HIGH_CODES = [
+    "042008",
+    "042035",
+    "042001",
+    "042002",
+    "043015",
+    "042036",
+    "042032",
+    "102056",
+    "102057",
+    "152003",
+    "152006",
+]
+
+XUHUI_ROWS = [
+    ("041302", [10, 10, 5, 2, 8, 4, 2, 0, 0, 0, 0]),
+    ("041305", [5, 6, 3, 2, 4, 2, 1, 1, 0, 0, 0]),
+    ("041306", [11, 11, 5, 2, 9, 3, 2, 1, 0, 0, 0]),
+    ("041316", [9, 7, 5, 1, 6, 3, 1, 0, 0, 0, 1]),
+    ("041318", [5, 5, 5, 1, 4, 1, 1, 0, 0, 0, 0]),
+    ("041319", [4, 5, 3, 1, 3, 1, 1, 0, 0, 0, 0]),
+    ("041320", [13, 11, 6, 2, 10, 5, 3, 0, 0, 0, 0]),
+    ("041326", [1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]),
+    ("041327", [9, 8, 5, 2, 8, 3, 1, 1, 0, 0, 0]),
+    ("041328", [4, 5, 2, 2, 3, 1, 0, 0, 0, 0, 1]),
+    ("041329", [7, 8, 4, 1, 7, 4, 1, 1, 0, 0, 0]),
+    ("041331", [3, 2, 2, 1, 3, 1, 0, 0, 0, 0, 0]),
+    ("041334", [5, 3, 1, 1, 3, 1, 0, 0, 0, 0, 0]),
+    ("041336", [5, 5, 3, 2, 7, 1, 1, 0, 1, 0, 0]),
+    ("041347", [8, 8, 4, 1, 8, 2, 2, 0, 0, 0, 0]),
+    ("041363", [8, 8, 5, 3, 8, 4, 1, 0, 1, 0, 0]),
+    ("041385", [8, 10, 5, 2, 9, 3, 0, 0, 0, 0, 1]),
+    ("044103", [10, 9, 5, 2, 10, 3, 2, 0, 0, 0, 0]),
+    ("044107", [3, 3, 1, 1, 4, 1, 1, 0, 0, 0, 0]),
+    ("044109", [13, 14, 7, 3, 12, 5, 0, 0, 0, 0, 1]),
+    ("044110", [7, 6, 4, 1, 7, 3, 0, 0, 0, 0, 0]),
+    ("044111", [10, 11, 6, 3, 9, 4, 0, 0, 0, 0, 2]),
+    ("044114", [4, 4, 2, 2, 5, 1, 1, 0, 0, 0, 0]),
+    ("044133", [9, 7, 5, 1, 7, 2, 0, 0, 0, 0, 0]),
+    ("044162", [12, 13, 10, 2, 11, 4, 0, 0, 1, 2, 0]),
+    ("044164", [12, 13, 9, 2, 11, 4, 1, 1, 0, 1, 0]),
+    ("044181", [3, 3, 3, 1, 2, 1, 1, 0, 0, 0, 0]),
+    ("044182", [3, 4, 1, 1, 3, 1, 0, 0, 0, 0, 1]),
+    ("045304", [2, 2, 2, 1, 3, 1, 0, 0, 0, 0, 0]),
+    ("045306", [2, 2, 1, 1, 3, 1, 0, 0, 1, 0, 0]),
+    ("045444", [4, 5, 3, 1, 5, 2, 0, 0, 0, 1, 0]),
+]
+
+JIADING_PDF = (
+    "/Volumes/程杰外接SD盘/上海中考招生计划/2026/计划/名额到校/"
+    "2026名额到校嘉定区.pdf"
+)
+
+
+def make_row(junior, high, plan):
+    return (junior, high, int(plan), "code_or_name", "code")
+
+
+def collect_xuhui(high_by_code, junior_by_code):
+    rows = []
+    problems = []
+    for junior_code, values in XUHUI_ROWS:
+        junior = junior_by_code.get(junior_code)
+        if not junior:
+            problems.append({"type": "junior", "code": junior_code})
+            continue
+        for high_code, plan in zip(XUHUI_HIGH_CODES, values):
+            if not plan:
+                continue
+            high = high_by_code.get(high_code)
+            if not high:
+                problems.append({"type": "high", "code": high_code})
+                continue
+            rows.append(make_row(junior, high, plan))
+    return rows, problems
+
+
+def collect_jiading(high_by_code, high_by_name, junior_by_name):
+    rows = []
+    problems = []
+    with pdfplumber.open(JIADING_PDF) as pdf:
+        for page in pdf.pages:
+            for table in page.extract_tables():
+                for raw in table[2:]:
+                    junior_name = parser.clean_text(raw[0])
+                    if not junior_name:
+                        continue
+                    junior, junior_method = parser.match_school(
+                        None, junior_name, {}, junior_by_name, 10
+                    )
+                    if not junior:
+                        problems.append(
+                            {
+                                "type": "junior",
+                                "name": junior_name,
+                                "method": junior_method,
+                                "raw": raw,
+                            }
+                        )
+                        continue
+                    for col in [1, 4, 7, 10]:
+                        code = parser.clean_code(raw[col] if col < len(raw) else None)
+                        plan = parser.clean_num(raw[col + 2] if col + 2 < len(raw) else None)
+                        if not code or not plan:
+                            continue
+                        high, high_method = parser.match_school(
+                            code, raw[col + 1] if col + 1 < len(raw) else "", high_by_code, high_by_name
+                        )
+                        if not high:
+                            problems.append(
+                                {
+                                    "type": "high",
+                                    "code": code,
+                                    "method": high_method,
+                                    "raw": raw,
+                                }
+                            )
+                            continue
+                        rows.append(make_row(junior, high, plan))
+    return rows, problems
+
+
+def check_empty(cursor, district_id):
+    cursor.execute(
+        """
+        SELECT COUNT(*) AS count
+        FROM MPS_Score
+        WHERE ScoreYear = '2026' AND ScoreType = '名额到校' AND DistrictID = %s
+        """,
+        (district_id,),
+    )
+    count = cursor.fetchone()["count"]
+    if count:
+        raise RuntimeError(f"District {district_id} already has {count} rows.")
+
+
+def insert_records(cursor, rows):
+    if not rows:
+        return 0
+    columns = ", ".join(INSERT_COLUMNS)
+    placeholders = ", ".join(["%s"] * len(INSERT_COLUMNS))
+    sql = f"INSERT INTO MPS_Score ({columns}) VALUES ({placeholders})"
+    values = [[row[column] for column in INSERT_COLUMNS] for row in rows]
+    cursor.executemany(sql, values)
+    return len(rows)
+
+
+def main():
+    conn = pymysql.connect(**parser.DB_CONFIG)
+    problems = {}
+    try:
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            high_by_code, high_by_name, _ = parser.load_schools(cursor, "高中")
+            junior_by_code, junior_by_name, _ = parser.load_schools(cursor, "初中")
+            previous = load_previous_plan_nums(cursor)
+
+            check_empty(cursor, 2)
+            check_empty(cursor, 10)
+
+            xuhui_rows, xuhui_problems = collect_xuhui(high_by_code, junior_by_code)
+            jiading_rows, jiading_problems = collect_jiading(
+                high_by_code, high_by_name, junior_by_name
+            )
+            problems["2"] = {"district": "徐汇区", "problems": xuhui_problems}
+            problems["10"] = {"district": "嘉定区", "problems": jiading_problems}
+
+            records = []
+            for row in xuhui_rows:
+                records.append(build_record(2, row, previous))
+            for row in jiading_rows:
+                records.append(build_record(10, row, previous))
+
+            print("ready 2 徐汇区 rows", len(xuhui_rows), "plan", sum(row[2] for row in xuhui_rows))
+            print("ready 10 嘉定区 rows", len(jiading_rows), "plan", sum(row[2] for row in jiading_rows))
+            print("problems", json.dumps(problems, ensure_ascii=False, default=str))
+
+            inserted = insert_records(cursor, records)
+            conn.commit()
+            with open("mps_score_school_quota_2026_supplement_problems.json", "w", encoding="utf-8") as handle:
+                json.dump(problems, handle, ensure_ascii=False, indent=2, default=str)
+            print("inserted", inserted)
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

秒过分数线数据导入/mps_score_school_quota_2026_problems.json

@@ -0,0 +1 @@
+{}

秒过分数线数据导入/mps_score_school_quota_2026_supplement_problems.json

@@ -0,0 +1,71 @@
+{
+  "2": {
+    "district": "徐汇区",
+    "problems": []
+  },
+  "10": {
+    "district": "嘉定区",
+    "problems": [
+      {
+        "type": "junior",
+        "name": "上海市民办嘉宜初级中学",
+        "method": "not_found",
+        "raw": [
+          "上海市民办嘉宜初级中学",
+          "",
+          "",
+          "",
+          "142001",
+          "上海市嘉定区\n第一中学",
+          "8",
+          "142002",
+          "上海交通大学附属\n中学嘉定分校",
+          "9",
+          "142004",
+          "上海师范大学附属中\n学嘉定新城分校",
+          "5"
+        ]
+      },
+      {
+        "type": "junior",
+        "name": "上海嘉定区世外学校",
+        "method": "not_found",
+        "raw": [
+          "上海嘉定区世外学校",
+          "",
+          "",
+          "",
+          "142001",
+          "上海市嘉定区\n第一中学",
+          "4",
+          "142002",
+          "上海交通大学附属\n中学嘉定分校",
+          "4",
+          "142004",
+          "上海师范大学附属中\n学嘉定新城分校",
+          "2"
+        ]
+      },
+      {
+        "type": "junior",
+        "name": "上海市嘉定区嘉一实验初级中学",
+        "method": "not_found",
+        "raw": [
+          "上海市嘉定区嘉一实验初级中学",
+          "",
+          "",
+          "",
+          "142001",
+          "上海市嘉定区\n第一中学",
+          "5",
+          "142002",
+          "上海交通大学附属\n中学嘉定分校",
+          "5",
+          "142004",
+          "上海师范大学附属中\n学嘉定新城分校",
+          "3"
+        ]
+      }
+    ]
+  }
+}

秒过分数线数据导入/research_mps_score_school_quota_2026.py

@@ -0,0 +1,425 @@
+import os
+import re
+import sys
+from collections import defaultdict
+
+import pdfplumber
+
+sys.path.insert(0, "/private/tmp/codex_mysql_driver")
+import pymysql  # noqa: E402
+
+
+DB_CONFIG = {
+    "host": "589ae8e08493d.sh.cdb.myqcloud.com",
+    "port": 8124,
+    "user": "cdb_outerroot",
+    "password": "kylx!@#!QAZ@WSX",
+    "database": "kylx365_db",
+    "charset": "utf8mb4",
+    "connect_timeout": 10,
+    "read_timeout": 30,
+}
+
+BASE_DIR = "/Volumes/程杰外接SD盘/上海中考招生计划/2026/计划/名额到校"
+YEAR = "2026"
+SCORE_TYPE = "名额到校"
+
+DISTRICTS = {
+    1: "黄浦区",
+    2: "徐汇区",
+    3: "长宁区",
+    4: "静安区",
+    5: "普陀区",
+    6: "虹口区",
+    7: "杨浦区",
+    8: "闵行区",
+    9: "宝山区",
+    10: "嘉定区",
+    11: "浦东新区",
+    12: "金山区",
+    13: "松江区",
+    14: "青浦区",
+    15: "奉贤区",
+    16: "崇明区",
+}
+
+NOISE = set("不得转载未经许可允许可经载转许未得允，")
+
+HIGH_ALIAS_CODES = {
+    "华二": "152003",
+    "华师大二附中": "152003",
+    "华东师范大学第二附属中学": "152003",
+    "上中": "042032",
+    "上海中学": "042032",
+    "复附": "102057",
+    "复旦附中": "102057",
+    "交附": "102056",
+    "交大附中": "102056",
+    "上师大": "152006",
+    "上师大附中": "152006",
+    "上师附中": "152006",
+    "华二普陀": "073082",
+    "二中": "072002",
+    "曹杨二中": "072002",
+    "晋元": "072001",
+    "宜川": "073003",
+    "上师附中宝山": "132003",
+    "格致奉贤": "012002",
+    "格致中学奉贤校区": "012002",
+}
+
+
+def clean_text(value):
+    text = str(value or "")
+    text = text.replace("\n", "")
+    text = "".join(ch for ch in text if ch not in NOISE)
+    text = re.sub(r"\s+", "", text)
+    return text
+
+
+def clean_code(value):
+    match = re.search(r"\d{6}", str(value or ""))
+    return match.group(0) if match else None
+
+
+def clean_num(value):
+    text = clean_text(value)
+    if text in {"", "/", "／", "-", "—"}:
+        return None
+    match = re.search(r"-?\d+", text)
+    return int(match.group(0)) if match else None
+
+
+def is_dataish(row):
+    cells = [clean_text(cell) for cell in row]
+    joined = "".join(cells[:4])
+    return bool(re.search(r"\d{6}", joined)) or any("中学" in cell or "学校" in cell for cell in cells[:4])
+
+
+def school_key(name):
+    name = clean_text(name)
+    for token in ["上海市", "上海", "区", "初级", "高级", "中学", "学校", "实验"]:
+        name = name.replace(token, "")
+    return name
+
+
+def add_name(names, value, school):
+    value = clean_text(value)
+    if value:
+        names[value].append(school)
+        key = school_key(value)
+        if key and key != value:
+            names[key].append(school)
+
+
+def name_variants(name):
+    cleaned = clean_text(name)
+    variants = []
+
+    def add(value):
+        value = clean_text(value)
+        if value and value not in variants:
+            variants.append(value)
+
+    add(cleaned)
+    for part in re.findall(r"[（(]现([^）)]+)[）)]", cleaned):
+        add(part)
+    add(re.sub(r"[（(].*?[）)]", "", cleaned))
+    return variants
+
+
+def load_schools(cursor, school_type):
+    cursor.execute(
+        """
+        SELECT ID, DistrictID, SchoolNumber, SchoolFullName, SchoolShortName, SchoolOtherName, SchoolType1
+        FROM MPS_School
+        WHERE SchoolType1 = %s
+        """,
+        (school_type,),
+    )
+    by_code = {}
+    by_name = defaultdict(list)
+    rows = cursor.fetchall()
+    seen_names = defaultdict(set)
+    for row in rows:
+        if row["SchoolNumber"]:
+            by_code[row["SchoolNumber"]] = row
+        for field in ["SchoolFullName", "SchoolShortName", "SchoolOtherName"]:
+            value = row[field]
+            cleaned = clean_text(value)
+            if cleaned and row["ID"] not in seen_names[cleaned]:
+                add_name(by_name, value, row)
+                seen_names[cleaned].add(row["ID"])
+    return by_code, by_name, rows
+
+
+def match_school(code, name, by_code, by_name, district_id=None):
+    if code and code in by_code:
+        return by_code[code], "code"
+    cleaned = clean_text(name)
+    if by_code is not None:
+        for alias, alias_code in HIGH_ALIAS_CODES.items():
+            if alias in cleaned and alias_code in by_code:
+                return by_code[alias_code], f"alias:{alias}"
+    candidates = []
+    for variant in name_variants(name):
+        if variant in by_name:
+            candidates.extend(by_name[variant])
+        else:
+            key = school_key(variant)
+            if key in by_name:
+                candidates.extend(by_name[key])
+        if candidates:
+            break
+    if candidates:
+        seen = set()
+        candidates = [row for row in candidates if not (row["ID"] in seen or seen.add(row["ID"]))]
+    if district_id is not None:
+        district_candidates = [row for row in candidates if row["DistrictID"] == district_id]
+        if len(district_candidates) == 1:
+            return district_candidates[0], "name_district"
+    if len(candidates) == 1:
+        return candidates[0], "name"
+    if candidates:
+        return None, f"ambiguous:{[row['SchoolFullName'] for row in candidates[:4]]}"
+    if district_id is not None:
+        fuzzy_candidates = []
+        for variant in name_variants(name):
+            if len(variant) < 6:
+                continue
+            for school_list in by_name.values():
+                for row in school_list:
+                    if row["DistrictID"] != district_id:
+                        continue
+                    fields = [
+                        clean_text(row["SchoolFullName"]),
+                        clean_text(row["SchoolShortName"]),
+                        clean_text(row["SchoolOtherName"]),
+                    ]
+                    if any(variant in field or field in variant for field in fields if field):
+                        fuzzy_candidates.append(row)
+        if fuzzy_candidates:
+            seen = set()
+            fuzzy_candidates = [
+                row for row in fuzzy_candidates if not (row["ID"] in seen or seen.add(row["ID"]))
+            ]
+            if len(fuzzy_candidates) == 1:
+                return fuzzy_candidates[0], "name_contains_district"
+            return None, f"ambiguous_contains:{[row['SchoolFullName'] for row in fuzzy_candidates[:4]]}"
+    return None, "not_found"
+
+
+def extract_codes_from_header(header_rows, col_index):
+    for row in header_rows:
+        if col_index < len(row):
+            code = clean_code(row[col_index])
+            if code:
+                return code
+    return None
+
+
+def extract_name_from_header(header_rows, col_index):
+    parts = []
+    for row in header_rows:
+        if col_index < len(row):
+            value = clean_text(row[col_index])
+            value = re.sub(r"^(委属|区属)?市?实验性示范性高中分配结果", "", value)
+            value = value.replace("区属名额数", "").replace("委属名额", "")
+            if value and not re.fullmatch(r"\d{6}", value) and "计划数" not in value and "合计" not in value:
+                parts.append(value)
+    return "".join(parts)
+
+
+def data_start_index(table):
+    for index, row in enumerate(table):
+        left_header = "".join(clean_text(cell) for cell in row[:2])
+        if any(token in left_header for token in ["初中代码", "初中学校名称", "学校代码", "学校名称"]):
+            continue
+        first_cell = clean_text(row[0] if row else "")
+        first_code = clean_code(row[0] if row else "")
+        second_code = clean_code(row[1] if len(row) > 1 else "")
+        left_code = first_code or (second_code if re.fullmatch(r"\d{1,3}", first_cell) else None)
+        if left_code and any(clean_num(cell) is not None for cell in row[1:]):
+            return index
+        if index > 0 and any(clean_num(cell) is not None for cell in row[2:]):
+            if any("中学" in clean_text(cell) or "学校" in clean_text(cell) for cell in row[:3]):
+                return index
+    return None
+
+
+def parse_long_table(table, district_id, high_by_code, high_by_name, junior_by_code, junior_by_name, state=None):
+    rows = []
+    problems = []
+    state = state if state is not None else {}
+    current_high_code = state.get("high_code")
+    current_high_name = state.get("high_name")
+    data_rows = table[1:] if table and any("招生学校代码" in clean_text(cell) for cell in table[0]) else table
+    for raw in data_rows:
+        if len(raw) >= 5:
+            high_code = clean_code(raw[0]) or current_high_code
+            high_name = clean_text(raw[1]) or current_high_name
+            junior_code = clean_code(raw[2])
+            junior_name = clean_text(raw[3])
+            plan_num = clean_num(raw[4])
+            if clean_code(raw[0]):
+                current_high_code = high_code
+                current_high_name = high_name
+                state["high_code"] = current_high_code
+                state["high_name"] = current_high_name
+        elif len(raw) >= 3 and current_high_code:
+            high_code = current_high_code
+            high_name = current_high_name
+            junior_code = clean_code(raw[0])
+            junior_name = clean_text(raw[1])
+            plan_num = clean_num(raw[2])
+        else:
+            continue
+        if clean_code(raw[0]):
+            current_high_code = high_code
+            current_high_name = high_name
+            state["high_code"] = current_high_code
+            state["high_name"] = current_high_name
+        if plan_num is None or plan_num == 0:
+            continue
+        high, high_method = match_school(high_code, high_name, high_by_code, high_by_name)
+        junior, junior_method = match_school(
+            junior_code, junior_name, junior_by_code, junior_by_name, district_id
+        )
+        if not high or not junior:
+            problems.append((raw, high_method, junior_method))
+            continue
+        rows.append((junior, high, plan_num, junior_method, high_method))
+    return rows, problems
+
+
+def parse_matrix_table(table, district_id, high_by_code, high_by_name, junior_by_code, junior_by_name):
+    start = data_start_index(table)
+    if start is None:
+        return [], [("no_data_start", table[:3])]
+    header_rows = table[:start]
+    data_rows = table[start:]
+
+    # Locate the junior-code/name columns using the first data row.
+    sample = data_rows[0]
+    code_col = 0
+    name_col = 1 if len(sample) > 1 else 0
+    for i, cell in enumerate(sample[:4]):
+        if clean_code(cell):
+            code_col = i
+            same_cell_text = clean_text(cell)
+            name_col = i if re.sub(r"\d{6}", "", same_cell_text) else min(i + 1, len(sample) - 1)
+            break
+    first_target_col = name_col + 1
+
+    targets = {}
+    target_problems = []
+    for col in range(first_target_col, max(len(row) for row in table)):
+        header_name = extract_name_from_header(header_rows, col)
+        if not header_name or "合计" in header_name or "总计" in header_name:
+            continue
+        code = extract_codes_from_header(header_rows, col)
+        high, method = match_school(code, header_name, high_by_code, high_by_name)
+        if high:
+            targets[col] = (high, method)
+        else:
+            target_problems.append((col, header_name, method))
+
+    rows = []
+    problems = []
+    for raw in data_rows:
+        junior_code = clean_code(raw[code_col] if code_col < len(raw) else None)
+        junior_name = clean_text(raw[name_col] if name_col < len(raw) else None)
+        if not junior_code and (not junior_name or "合计" in junior_name):
+            continue
+        junior, junior_method = match_school(
+            junior_code, junior_name, junior_by_code, junior_by_name, district_id
+        )
+        if not junior:
+            problems.append((raw, "junior", junior_method))
+            continue
+        for col, (high, high_method) in targets.items():
+            plan_num = clean_num(raw[col] if col < len(raw) else None)
+            if plan_num is None or plan_num == 0:
+                continue
+            rows.append((junior, high, plan_num, junior_method, high_method))
+    return rows, target_problems + problems
+
+
+def parse_tables(path, district_id, high_by_code, high_by_name, junior_by_code, junior_by_name):
+    all_rows = []
+    all_problems = []
+    long_state = {}
+    with pdfplumber.open(path) as pdf:
+        for page in pdf.pages:
+            for table in page.extract_tables():
+                if not table:
+                    continue
+                first = [clean_text(cell) for cell in table[0]]
+                is_long = (
+                    any("招生学校代码" in cell for cell in first)
+                    and any("初中学校代码" in cell for cell in first)
+                ) or (long_state.get("high_code") and len(table[0]) == 3 and clean_code(table[0][0]))
+                if is_long:
+                    rows, problems = parse_long_table(
+                        table, district_id, high_by_code, high_by_name, junior_by_code, junior_by_name, long_state
+                    )
+                else:
+                    rows, problems = parse_matrix_table(
+                        table, district_id, high_by_code, high_by_name, junior_by_code, junior_by_name
+                    )
+                all_rows.extend(rows)
+                all_problems.extend(problems)
+    return all_rows, all_problems
+
+
+def main():
+    conn = pymysql.connect(**DB_CONFIG)
+    try:
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            high_by_code, high_by_name, _ = load_schools(cursor, "高中")
+            junior_by_code, junior_by_name, _ = load_schools(cursor, "初中")
+            cursor.execute(
+                """
+                SELECT DistrictID, COUNT(*) AS count
+                FROM MPS_Score
+                WHERE ScoreYear = %s AND ScoreType = %s
+                GROUP BY DistrictID
+                """,
+                (YEAR, SCORE_TYPE),
+            )
+            existing = {row["DistrictID"]: row["count"] for row in cursor.fetchall()}
+
+            for district_id, district_name in DISTRICTS.items():
+                if existing.get(district_id):
+                    print("existing", district_id, district_name, existing[district_id])
+                    continue
+                pdf_path = os.path.join(BASE_DIR, f"2026名额到校{district_name}.pdf")
+                jpg_path = os.path.join(BASE_DIR, f"2026名额到校{district_name}.jpg")
+                if not os.path.exists(pdf_path):
+                    if os.path.exists(jpg_path):
+                        print("problem", district_id, district_name, "image", jpg_path)
+                    else:
+                        print("problem", district_id, district_name, "missing")
+                    continue
+                rows, problems = parse_tables(
+                    pdf_path, district_id, high_by_code, high_by_name, junior_by_code, junior_by_name
+                )
+                print(
+                    "district",
+                    district_id,
+                    district_name,
+                    "rows",
+                    len(rows),
+                    "plan",
+                    sum(row[2] for row in rows),
+                    "problems",
+                    len(problems),
+                )
+                for problem in problems[:8]:
+                    print("  problem_sample", problem)
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()