"""DATA-N（でーたん）のそろえた表を、プログラムから取る部品。

    !wget -q -O datan.py https://site.data-n-jp.workers.dev/py/datan.py
    import datan

    datan.種類の一覧()
    表 = datan.そろえて取る("aed", 地域=["21", "231002"])  # 都道府県は2桁、市区町村は6桁。なければ全国
    datan.出典(表)
    datan.CSVに保存(表, "aed.csv")  # サイトの保存と同じ形（時刻は 08:30）
    datan.表の説明(表)  # 列の名前・型・値の例と出典の短い文（自分のAIに貼れる）

    datan.時点の一覧("aed", 地域=["212016"])  # いつのデータが読めるか。そろえて取るの ファイル= に書く

そろえるのは、この部品を動かす端末です。そろえた表はDATA-Nのサーバーに残りません。
表を使うときは、提供元とライセンスを書き、DATA-Nがそろえた（加工した）ことを書いてください。どれも表の列に入っています。
「そろえて取る」を1回動かすと、使われ方の記録を1件DATA-Nに送ります（種類、都道府県、読めた提供元の数、読めなかった提供元の数、部品の版。前のデータを読めた提供元があれば、その提供元のidも。読んだファイルと年は送りません）。
使い方：https://site.data-n-jp.workers.dev/guide/python/
"""

import datetime
import decimal
import io
import json
import math
import random
import re
import time
import unicodedata
import urllib.error
import urllib.parse
import urllib.request
import zipfile

import pandas as pd

try:
    from pyproj import Transformer  # 平面直角座標の提供元を読むときだけ使う
except ImportError:
    Transformer = None

__all__ = ["CSVに保存", "そろえて取る", "出典", "時点の一覧", "種類の一覧", "表の説明"]

部品の版 = 2
中継 = "https://relay.data-n-jp.workers.dev"
DATA_N = "https://site.data-n-jp.workers.dev"
名乗り = {"User-Agent": "DATA-N"}  # Python の標準の名乗りのままだと、中継やサイトに弾かれる
間の秒 = 1  # キャッシュに当たらなかったときに、次のファイルを取るまであける秒（元のサイトへの配慮）
最短の秒 = 60 / 120 + 0.05  # キャッシュに当たっても、中継を取る間にあける秒（1分120回を超えない。届く時刻の揺れの分だけ少し長く）
前に取った時 = None
前のデータの記録の上限 = 200  # 記録 take の old に書く提供元の数（読んだ記録 read の old と同じ上限。中継の log.ts の checkTake）
住所の位置の出典 = "位置の一部は「アドレス・ベース・レジストリ」（デジタル庁）を使って住所から求めた"
日時の型 = {"date": "日付", "datetime": "日時", "time": "時刻", "month": "年月"}
種類の表 = {
    "aed": {"名前": "AED", "区分": []},
    "shelter": {"名前": "指定緊急避難場所", "区分": []},
    "childcare": {"名前": "子育て施設", "区分": ["認可外保育", "児童クラブ", "児童遊園", "赤ちゃんの駅", "病児保育", "子育て支援", "児童館", "地域型保育", "認定こども園", "幼稚園", "保育園", "そのほか"]},
    "culture": {"名前": "文化財", "区分": ["市区町村", "都道府県", "国", "そのほか"]},
    "wifi": {"名前": "公衆無線LAN（Wi-Fi）", "区分": []},
    "facility": {"名前": "公共施設", "区分": ["トイレ", "駐車場・駐輪場", "防災・消防", "公園", "子育て", "学校", "図書館・博物館", "スポーツ", "集会・文化", "医療", "福祉・保健", "庁舎・窓口", "住宅", "ごみ・上下水道", "産業・観光", "そのほか"]},
}
コードの表 = {  # 空欄の行を、別の列のコードから名前で埋める表
    "poi": {"1001": "観光案内所", "1002": "自然公園", "1003": "都市公園", "1004": "庭園", "1005": "緑地", "1006": "広場", "1007": "噴水", "1008": "遊園地", "1009": "テーマパーク", "1010": "体験施設", "1011": "映画館", "1012": "劇場", "1013": "演劇場", "1014": "寄席", "1015": "演舞場", "1016": "ホール", "1017": "展示場", "1018": "遊技場", "1019": "競馬等の競走場", "1020": "カジノ", "1021": "カラオケボックス", "1022": "プラネタリウム", "1023": "釣り場", "1024": "遊漁船", "1099": "その他レクリエーション", "1101": "スタジアム", "1102": "陸上競技場", "1103": "野球場", "1104": "球技場", "1105": "バッティング・テニス練習場", "1106": "多目的運動場", "1107": "プール", "1108": "レジャープール", "1109": "目的別プール", "1110": "体育館", "1111": "柔道場", "1112": "剣道場", "1113": "武道場", "1114": "空手・合気道場", "1115": "バレーボールコート", "1116": "テニスコート", "1117": "バスケットボールコート", "1118": "相撲場", "1119": "卓球場", "1120": "弓道場", "1121": "アーチェリー場", "1122": "馬場", "1123": "スケートリンク", "1124": "ローラースケートリンク", "1125": "林間学校施設", "1126": "山小屋", "1127": "避難小屋", "1128": "登山道", "1129": "ボルダリング場", "1130": "ロッククライミングスポット", "1131": "オフロード・モトクロス場", "1132": "マウンテンバイクコース", "1133": "トレーニング場", "1134": "フィットネスクラブ", "1135": "レスリング場", "1136": "ボクシング場", "1137": "ダンススタジオ", "1138": "射撃場", "1139": "ゴルフ場", "1140": "ゴルフ練習場", "1141": "ボウリング場", "1142": "漕艇場", "1143": "ゲートボール クロッケー場", "1144": "スカッシュ・ ラケットボール場", "1145": "ヨットハーバー、マリーナ", "1146": "水上スキー・ウェークボード場", "1147": "サーフィンスポット", "1148": "スキー・ スノーボード場", "1149": "スキージャンプ台", "1150": "ボブスレー・リュージュコース", "1151": "ノルディックウォーキングコース", "1152": "キャンプ場", "1153": "サイクリングコース", "1154": "オリエンテーリングコース", "1155": "ランニングコース", "1156": "フィールドアスレチック", "1157": "海水浴場", "1159": "河川・湖沼等の遊泳場", "1160": "スカイスポーツ施設", "1161": "カーリング場", "1199": "その他スポーツ施設", "1201": "官公署", "1202": "合同庁舎", "1203": "検察庁", "1204": "裁判所", "1205": "法務局", "1206": "法テラス", "1207": "公証役場", "1208": "出入国管理局", "1209": "税関", "1210": "税務署", "1211": "警察署", "1212": "交番", "1213": "運転免許試験場", "1214": "消防署", "1215": "消防署分署", "1216": "郵便局", "1217": "森林管理署", "1218": "気象台", "1219": "職業安定所", "1220": "労働基準監督署", "1221": "社会保険事務所", "1222": "矯正施設", "1223": "自衛隊・米軍", "1224": "外国公館", "1299": "その他国の機関", "1301": "県庁", "1302": "市役所・東京都の区役所", "1303": "町村役場・政令指定都市の区役所", "1304": "役場支所及び出張所", "1305": "市民活動施設", "1306": "産業支援施設", "1307": "公民館", "1308": "公会堂", "1309": "集会施設", "1399": "その他行政サービス施設", "1401": "授乳室", "1402": "保育園", "1403": "児童館（児童センター）", "1404": "学童保育クラブ", "1405": "認定こども園", "1406": "児童相談所", "1407": "福祉事務所", "1408": "老人ホーム", "1409": "老人通所・短期入所介護施設", "1499": "その他の社会福祉施設", "1501": "幼稚園", "1502": "学校", "1503": "小学校", "1504": "中学校", "1505": "高等学校・中等教育学校", "1506": "大学・大学院", "1507": "短期大学", "1508": "高等専門学校", "1509": "特殊学校", "1510": "専修学校・各種学校", "1511": "文教施設", "1512": "図書館", "1513": "研究施設", "1514": "職業・教育支援施設", "1515": "音楽学校", "1516": "自動車教習所", "1517": "外国語学校", "1518": "学習塾・予備校", "1519": "教養・技能教授業", "1599": "その他の教育文化施設", "1601": "病院", "1602": "診療所", "1603": "歯科診療所", "1604": "助産所", "1605": "鍼灸施設", "1606": "保健所", "1607": "献血所", "1608": "救護所", "1609": "動物病院", "1610": "ドラッグストア", "1611": "医薬品小売店", "1612": "調剤薬局", "1613": "その他の医療施設", "1901": "発電所", "1902": "水力発電所", "1903": "火力発電所", "1904": "地熱発電所", "1905": "原子力発電所", "1906": "風力発電所", "1907": "太陽光発電所", "1908": "バイオマス発電所", "1909": "複合型発電所", "1910": "変電所", "1911": "送電線", "1999": "その他エネルギー施設", "2001": "上水道関連施設", "2002": "井戸", "2003": "下水道関連施設", "2004": "廃棄物処理施設", "2005": "資源回収所", "2006": "ごみ焼却場", "2008": "その他処理施設", "2009": "火葬場", "2010": "墓地", "2099": "その他生活インフラ", "2101": "トイレ", "2102": "公衆電話", "2103": "郵便ポスト", "2104": "コインロッカー", "2105": "宅配ロッカー", "2106": "自動販売機", "2107": "ゴミ箱", "2108": "消火器", "2109": "消火栓", "2110": "ＡＥＤ", "2199": "その他生活支援設備", "2201": "避難施設", "2202": "避難場所", "2203": "津波避難施設", "2204": "防災倉庫", "2205": "給水所", "2206": "防波堤", "2207": "防潮堤", "2208": "防火水槽", "2209": "河岸堤防", "2210": "防水施設", "2211": "地すべり防止施設", "2212": "砂防施設", "2299": "その他防災施設", "2301": "ホテル", "2302": "ビジネスホテル", "2303": "リゾートホテル", "2304": "旅館", "2305": "民宿", "2306": "ユースホステル", "2307": "ゲストハウス", "2308": "カプセルホテル", "2309": "ロッジ", "2310": "バンガロー", "2311": "公共宿泊施設", "2312": "ペンション", "2313": "宿坊", "2314": "コテージ・貸別荘", "2315": "研修センター", "2316": "保養所", "2317": "ペットホテル", "2399": "その他宿泊施設", "2401": "レストラン", "2402": "和食", "2403": "イタリアン料理", "2404": "フランス料理", "2405": "中華料理", "2406": "居酒屋", "2407": "ビアガーデン", "2408": "バー", "2409": "ラーメン", "2410": "寿司", "2411": "そば", "2412": "うどん", "2413": "ファーストフード", "2414": "焼肉", "2415": "とんかつ", "2416": "お好み焼き", "2417": "牛丼", "2418": "すき焼き", "2419": "しゃぶしゃぶ", "2420": "焼き鳥", "2421": "カレー", "2422": "喫茶店、カフェ", "2423": "アイスクリーム店", "2424": "インターネットカフェ", "2499": "その他飲食施設", "2501": "銀行", "2502": "両替所", "2503": "ATM", "2504": "消費者金融", "2505": "証券", "2506": "質屋", "2507": "保険", "2508": "協同組合", "2599": "その他金融関連施設", "2601": "百貨店", "2602": "雑貨店", "2603": "商業施設", "2604": "ショッピングモール", "2605": "アウトレットモール", "2606": "スーパーマーケット", "2607": "商店街", "2608": "日用品店", "2609": "100円ショップ", "2610": "リサイクルショップ", "2611": "ギフトショップ", "2612": "レンタルショップ", "2613": "土産物店", "2614": "直売所", "2615": "青空市場・蚤の市", "2699": "その他総合買い物施設", "2701": "食料品店", "2702": "八百屋", "2703": "精肉店", "2704": "鮮魚店", "2705": "つけもの店", "2706": "お菓子屋", "2707": "洋菓子屋", "2708": "和菓子屋", "2709": "パン屋", "2710": "コンビニエンスストア", "2711": "酒屋", "2712": "茶葉販売店", "2713": "コーヒー店", "2714": "米屋", "2715": "豆腐屋", "2716": "かまぼこ等加工食品小売店", "2717": "乾物屋", "2718": "チーズ店", "2719": "チョコレート店", "2720": "乳製品店", "2721": "総菜販売店", "2722": "仕出し屋", "2723": "酒蔵", "2724": "ビール醸造所", "2725": "ワイナリー", "2726": "蒸留所", "2727": "タバコ屋", "2728": "野菜等無人販売所", "2799": "その他食料品販売店", "2801": "紳士衣料店", "2802": "婦人衣料店", "2803": "子供服店", "2804": "仕立屋", "2805": "着物屋", "2806": "革製品店", "2807": "かばん屋", "2808": "靴屋", "2809": "下着屋", "2810": "洋品雑貨屋", "2811": "生地屋", "2812": "裁縫用品店", "2813": "衣類等リフィーム店", "2814": "貸衣装店", "2815": "時計屋", "2816": "帽子店", "2817": "眼鏡屋", "2818": "宝飾店", "2819": "クリーニング店", "2820": "コインランドリー", "2899": "その他服飾関連店", "2901": "建設業", "2902": "工務店", "2903": "建築設計事務所", "2904": "造園店", "2905": "電気工事店", "2906": "ガラス屋", "2907": "アルミサッシ店", "2908": "カギ屋", "2909": "塗装屋", "2910": "塗料店", "2911": "左官屋", "2912": "配管設備店", "2913": "照明設備店", "2914": "空調設備店", "2915": "不動産屋", "2999": "その他建築関連店", "3001": "家具屋", "3002": "建具屋", "3003": "畳屋", "3004": "寝具店", "3005": "カーテン店", "3006": "絨毯屋", "3099": "その他家財、内装店", "3101": "赤ちゃん用品店", "3102": "床屋", "3103": "美容院", "3104": "ビューティーサロン", "3105": "マッサージ、整体店", "3106": "ネイルサービス", "3107": "化粧品店", "3108": "香水店", "3109": "花屋", "3110": "金物屋", "3111": "陶磁器・ガラス器店", "3112": "キッチン用品店", "3113": "風呂用品店", "3114": "防犯・安全用品店", "3115": "電器店", "3116": "パソコン店", "3117": "携帯電話店", "3118": "ホームセンター", "3119": "刃物店", "3120": "旅行代理店", "3121": "チケットオフィス", "3122": "宝くじ屋", "3123": "新聞販売店", "3124": "文房具店", "3125": "引越屋", "3199": "その他生活関連店", "3201": "燃料販売店", "3202": "ガソリンスタンド", "3203": "電気自動車の充電施設", "3204": "水素充填ステーション", "3299": "その他エネルギー販売店", "3301": "自動車販売店", "3302": "自動車修理屋", "3303": "自動車用品店", "3304": "洗車場", "3305": "バイク店", "3306": "自転車屋", "3399": "その他移動関連店", "3401": "アウトドア用品店", "3402": "釣具店", "3403": "船具店", "3404": "狩猟用品店", "3405": "ダイビングショップ", "3406": "スキー用品店", "3407": "スポーツ用品店", "3408": "カメラ屋", "3409": "アンティークショップ", "3410": "美術品店", "3411": "コレクターショップ", "3412": "工芸店", "3413": "窯元", "3414": "ゲームセンター", "3415": "模型店", "3416": "CD店", "3417": "ビデオ店", "3418": "アニメ専門店", "3419": "本屋", "3420": "楽器屋", "3421": "ピアノ屋", "3422": "おもちゃ屋", "3423": "ホビーショップ", "3424": "ペットショップ", "3425": "ドッグラン", "3499": "その他趣味関連店", "3501": "結婚式場", "3502": "葬儀屋", "3503": "宗教関連用品店", "3599": "その他人生関連店", "3601": "事務機器店", "3602": "微章店", "3603": "印章店", "3604": "印刷屋", "3605": "電子機器店", "3606": "鉄工所", "3607": "金属加工所", "3608": "製材所、材木屋", "3609": "石材加工店", "3610": "テント屋", "3611": "養蜂場", "3612": "農機具店", "3613": "農耕用品店", "3614": "製本所", "3615": "花火屋", "3616": "材料置場", "3617": "火薬庫", "3618": "危険物保管所", "3619": "と畜場", "3620": "テレビ局", "3621": "ラジオ局", "3699": "その他産業施設", "3701": "道路", "3702": "トンネル", "3703": "橋", "3704": "インターチェンジ", "3705": "スマートインターチェンジ", "3706": "ジャンクション", "3707": "サービスエリア", "3708": "パーキングエリア", "3709": "料金所", "3710": "道の駅", "3711": "並木", "3712": "横断歩道橋", "3713": "横断歩道", "3714": "信号", "3715": "歩道", "3716": "石段", "3717": "坂", "3718": "地下街・地下鉄等出入口", "3719": "駅", "3720": "ロープウェイ駅", "3721": "ケーブルカー駅", "3722": "ゴンドラリフト駅", "3723": "チェアリフト駅", "3724": "路面電車駅", "3725": "踏切", "3726": "バスターミナル", "3727": "バス停", "3728": "タクシー乗り場", "3729": "レンタカー", "3730": "カーシェアリング地点", "3731": "駐車場", "3732": "駐輪場", "3733": "レンタサイクル", "3734": "オートバイ駐輪場", "3799": "その他陸上交通施設", "3801": "空港", "3802": "ヘリポート", "3899": "その他航空施設", "3901": "港湾", "3902": "フェリー乗り場", "3903": "埠頭", "3904": "桟橋", "3905": "漁港", "3906": "灯台", "3907": "灯標", "3908": "水位観測所", "3909": "渡船発着所", "3910": "観光船発着所", "3999": "その他海上交通施設", "4001": "物流拠点", "4002": "コンテナターミナル", "4003": "航空貨物ターミナル", "4004": "鉄道貨物駅", "4005": "保税地域", "4006": "トラックターミナル", "4007": "卸売市場", "4099": "その他物流施設", "0101": "山", "0102": "カール", "0103": "崖", "0104": "火山", "0105": "カルデラ", "0106": "噴火口・噴気孔", "0107": "尖峰", "0108": "高原", "0109": "丘陵", "0110": "湖沼", "0111": "河川", "0112": "渓谷", "0113": "滝", "0114": "海岸", "0115": "半島", "0116": "湾", "0117": "海峡", "0118": "岬", "0119": "海食洞", "0120": "岩門", "0121": "潮吹穴", "0122": "潮流", "0123": "海中", "0124": "島", "0125": "岩", "0126": "サンゴ礁", "0127": "洞窟", "0128": "湿原", "0129": "砂丘", "0130": "砂浜", "0131": "泉", "0132": "間欠泉", "0133": "万年雪", "0134": "氷河", "0135": "干潟", "0136": "カルスト", "0137": "鍾乳洞", "0198": "陸景その他", "0199": "水景その他", "0201": "ジオパーク", "0202": "花等の名所", "0203": "展望台", "0204": "展望地", "0205": "ビジターセンター", "0206": "ダム", "0207": "せき", "0208": "水門", "0209": "運河", "0210": "溜池等", "0211": "海の駅", "0299": "その他自然関連", "0301": "田", "0302": "畑", "0303": "茶畑", "0304": "果樹園", "0305": "さとうきび畑", "0306": "パイナップル畑", "0307": "わさび畑", "0308": "桑畑", "0309": "ブドウ園", "0310": "その他の樹木畑", "0311": "市民菜園", "0312": "森", "0313": "広葉樹林", "0314": "針葉樹林", "0315": "独立樹 （広葉樹）", "0316": "独立樹 （針葉樹）", "0317": "竹林", "0318": "ヤシ科樹林", "0319": "はい松地", "0320": "笹地", "0321": "荒地", "0322": "塩田", "0323": "芝地", "0324": "牧場", "0325": "牧草地", "0326": "石切場・採石場", "0327": "花壇", "0328": "空地", "0399": "その他土地", "0401": "住宅", "0402": "農家", "0403": "集合住宅", "0404": "寮", "0405": "オフィスビル", "0406": "コワーキングスペース", "0407": "工場", "0408": "造船所", "0409": "製鉄所", "0410": "石油化学コンビナート", "0411": "家畜小屋", "0499": "その他建物", "0501": "風車", "0502": "水車", "0503": "煙突", "0504": "油田・ガス田", "0505": "高塔", "0506": "坑口", "0507": "巨大構造物", "0508": "給水塔", "0509": "サイロ", "0510": "タンク", "0511": "クレーン", "0512": "電波塔", "0513": "公衆電気通信施設", "0514": "火の見", "0599": "その他目標物", "0601": "遺跡", "0602": "古墳", "0603": "史跡", "0604": "天然記念物", "0605": "名勝", "0606": "文化的景観", "0607": "城", "0608": "城跡", "0609": "古戦場", "0610": "歴史的建造物", "0611": "庭園", "0612": "記念碑", "0613": "石碑", "0614": "門", "0615": "屋門", "0616": "鳥居", "0617": "立像", "0618": "路傍祠", "0619": "灯ろう", "0620": "蔵", "0621": "歴史的街並み", "0622": "古民家", "0623": "武家屋敷", "0624": "町屋/町家", "0699": "その他歴史文化", "0701": "神社", "0702": "寺院", "0703": "教会", "0704": "モスク", "0799": "その他宗教施設", "0801": "博物館", "0802": "美術館", "0803": "記念・資料館", "0804": "動物園", "0805": "植物園", "0806": "野鳥観察所", "0807": "水族館", "0808": "その他生き物施設", "0809": "産業観光施設", "0899": "その他の主要・著名な建物", "0901": "温泉", "0902": "鉱泉", "0903": "銭湯", "0904": "足湯", "0999": "その他入浴施設"},
}
注意の表 = {  # データの元が人に渡すときに伝えるよう書いている注意（原文のまま）
    "gsi-shelter": {"題": "国土地理院の「ご利用上の注意」", "項目": ["本データは、災害対策基本法第49条の4・第49条の7に基づき市町村長が指定した指定緊急避難場所・指定避難所の情報を各市町村に登録いただいたものです。なお、最新でない場合や未掲載の場合があるため、最新かつ詳細の状況などは必ず当該市町村にご確認ください。", "「指定緊急避難場所」と「指定避難所」の違いや、指定緊急避難場所が災害種別ごとに指定されていることを理解した上でご利用ください。", "本データは随時更新されますので、ダウンロードや印刷等を行い利用される場合は、ご注意ください。", "本データを用いた情報を第三者に提供する場合は、上記1．～3．の注意事項が正確に伝わるよう、十分にご留意ください。"], "出典と加工": ["出典：国土地理院ウェブサイト（https://www.gsi.go.jp/bousaichiri/hinanbasho.html）", "加工：「指定緊急避難場所データ」（国土地理院）（https://www.gsi.go.jp/bousaichiri/hinanbasho.html）をAIGIDが加工して作成したデータを、DATA-Nが加工して作成"], "ページ": "https://www.gsi.go.jp/bousaichiri/hinanbasho-menseki.html", "ページの言葉": "国土地理院の案内を開く"},
}


空白 = r"[ \t\n\r\f\v   -     　﻿]"


def 見出しの形(s):
    """NFKC にして空白と改行をすべて除く（「名称　必須」→「名称必須」）"""
    return re.sub(空白 + "+", "", unicodedata.normalize("NFKC", s))


def 前後の空白を除く(s):
    return re.sub(f"^{空白}+|{空白}+$", "", s)


def 助数詞を除く(v, 言葉):
    """数のうしろの言葉を除く（「1台」「１ 台」→「1」）。当たらなければ、そのまま返す"""
    t = 見出しの形(v)
    for x in 言葉 or []:
        if t.endswith(x):
            return t[: -len(x)]
    return v


def 数にする(s):
    t = 前後の空白を除く(unicodedata.normalize("NFKC", s)).replace(",", "")
    return float(t) if re.fullmatch(r"[+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?", t) else None


def コードの形(s):
    """コードの名前を引く形：NFKC にして空白を除き、1〜4桁の数を4桁にする（「403」→「0403」、古い書き方の「1003a」→「1003」）"""
    m = re.fullmatch(r"([0-9]{1,4})[aA]?", re.sub(空白 + "+", "", unicodedata.normalize("NFKC", s)))
    return m.group(1).zfill(4) if m else None


def 参照データを読む(種類, 都道府県):
    """住所から求めた位置、市区町村の名前、市区町村の外接矩形（DATA-N が都道府県ごとに配っている参照データ）"""
    参照 = {"住所の位置": {}, "市区町村": {}, "外接矩形": {}}
    for 県 in 都道府県:
        with urllib.request.urlopen(urllib.request.Request(f"{DATA_N}/specs/{種類}/{県}.json", headers=名乗り)) as f:
            d = json.load(f)
        参照["住所の位置"].update(d["geocode"])
        参照["市区町村"].update(d["muni"])
        参照["外接矩形"].update(d["bbox"])
    return 参照


class 外す(Exception):
    """この提供元を外す理由。画面と同じく、外したことを書いて、ほかの提供元で続ける"""


class 取得を休んでいる(Exception):
    """DATA-Nがプログラムからの取得を休んでいる。どの提供元でも同じなので、外して続けず、ここで止まる"""


取れない理由 = {  # 中継が断ったときの理由（画面と同じ言葉）
    "not_found": "元のファイルが見つからない",
    "html": "ファイルではなく Web ページだった",
    "too_large": "ファイルが大きすぎる",
    "timeout": "元のサイトが応答しない",
    "upstream": "元のサイトから取れない",
    "rate_limited": "混み合っている",
}


def 待つ秒(言われた秒):
    """中継が混み合っているときに待つ秒。中継が言う秒（Retry-After）が正の数ならその秒、なければ5秒、30秒まで"""
    try:
        秒 = float(言われた秒)
    except (TypeError, ValueError):
        秒 = 0
    return min(秒 if 秒 > 0 else 5, 30)


def 中継から取る(url, 印=None):
    """中継からファイルを取る。印（辞書）を渡すと、中継が知らせる読んだファイルの名前と更新日とキャッシュの状態を入れる。混み合っている（429）ときは、待つ秒に0〜3秒をでたらめに足して待ち、2回までやり直す
    （大勢が同時にやり直して、また混まないように散らす。画面と同じ）。取れないときは、画面と同じ理由でこの提供元を外す"""
    for 回目 in range(3):
        try:
            with urllib.request.urlopen(urllib.request.Request(url, headers=名乗り)) as f:
                if 印 is not None:
                    印["ファイル"] = urllib.parse.unquote(f.headers.get("X-DataN-File") or "")
                    印["更新日"] = f.headers.get("X-DataN-Modified") or ""
                    印["キャッシュ"] = f.headers.get("X-DataN-Cache") or ""
                return f.read()
        except urllib.error.HTTPError as e:  # 中継が断った。理由は中継が返す（{"error": "not_found"} など）
            if e.code == 429 and 回目 < 2:
                e.close()
                time.sleep(待つ秒(e.headers.get("Retry-After")) + random.uniform(0, 3))
                continue
            try:
                理由 = str(json.loads(e.read())["error"])
            except Exception:
                理由 = ""
            if 理由 == "paused":
                raise 取得を休んでいる("DATA-Nは今、プログラムからの取得を休んでいます。ふつうは翌月の1日に戻ります。サイトの画面では今までどおり読めます。そろえた表は、カテゴリのページの「そろえた表を見る」からCSVやGeoJSONで保存できます。") from None
            raise 外す(取れない理由.get(理由, "元のサイトから取れない")) from e
        except OSError as e:
            raise 外す("通信できない") from e


def 表を読む(中身, 元):
    """元のファイルを、見出しの行を含む行の並びにする（CSV、GeoJSON か Excel）。
    壊れたファイル（引用符が閉じない CSV、壊れた Excel、形の違う GeoJSON など）と Web ページは、理由を書いて外す"""
    形式 = 元.get("形式", "csv")
    if 形式 != "xlsx" and 中身.startswith(b"\xd0\xcf\x11\xe0"):
        raise 外す("読めない形式：古い Excel の xls")
    文字 = "" if 形式 == "xlsx" else 中身.decode(元["文字コード"], "replace")
    if 文字[:512].lstrip().lower().startswith(("<!doctype html", "<html")):
        raise 外す("ファイルではなく Web ページだった")
    try:
        if 形式 == "xlsx":
            return エクセルを読む(中身, 元.get("シート"))
        return GeoJSONを読む(文字) if 形式 == "geojson" else CSVを読む(文字)
    except Exception as e:
        raise 外す(f"読めない形式：{形式}。元のファイルが壊れているかもしれない") from e


def CSVを読む(文字):
    """CSV を行の並びにする（空の行は []）。引用符で囲んだ欄の中の区切りと改行は文字のまま、"" は " にする。
    引用符が閉じないまま終わるファイルは、残りを1つの欄にせずに止める"""
    区 = 区切り(文字)
    ふつう = re.compile("[^\r\n" + re.escape(区) + "]*")  # 引用符で囲んでいない欄の文字
    行, i, n = [], 0, len(文字)
    while i < n:
        if 文字[i] in "\r\n":  # 空の行
            行.append([])
            i += 2 if 文字.startswith("\r\n", i) else 1
            continue
        欄 = []
        while True:
            値 = ""
            if 文字.startswith('"', i):
                i += 1
                while True:
                    j = 文字.find('"', i)
                    if j < 0:
                        raise ValueError("CSV の引用符が閉じていない")
                    値 += 文字[i:j]
                    if 文字.startswith('""', j):
                        値, i = 値 + '"', j + 2
                    else:
                        i = j + 1
                        break
            m = ふつう.match(文字, i)  # 閉じた引用符のあとに続く文字も、そのまま足す
            欄.append(値 + m.group())
            i = m.end()
            if i >= n:
                行.append(欄)
                return 行
            if 文字[i] == 区:
                i += 1
                continue
            i += 2 if 文字.startswith("\r\n", i) else 1  # 改行で行を終える
            行.append(欄)
            break
    return 行


def GeoJSONを読む(文字):
    """項目の名前（出てきた順）と、点の位置（@緯度・@経度）を見出しにする。点でない形は位置を空欄にする。
    全体・点・properties・geometry が辞書（null も可）でないもの、features が並びでないものは止める"""

    def 辞書(v):
        if v is not None and not isinstance(v, dict):
            raise ValueError("GeoJSON の形が違う")
        return v or {}

    def JSONにない値(名前):
        raise ValueError(f"JSON にない値：{名前}")

    全体 = json.loads(文字, parse_constant=JSONにない値)
    if not isinstance(全体, dict):
        raise ValueError("GeoJSON の形が違う")
    点 = 全体.get("features")
    if not isinstance(点, (list, type(None))):
        raise ValueError("GeoJSON の形が違う")
    点 = [(辞書(辞書(f).get("properties")), 辞書(辞書(f).get("geometry"))) for f in 点 or []]
    名前 = []
    for p, _ in 点:
        for k in p:
            if k not in 名前:
                名前.append(k)
    行 = [名前 + ["@緯度", "@経度"]]
    for p, g in 点:
        xy = g.get("coordinates") if g.get("type") == "Point" else None
        位置 = [値の文字(xy[1]), 値の文字(xy[0])] if isinstance(xy, list) and len(xy) >= 2 else ["", ""]
        行.append([値の文字(p.get(k)) for k in 名前] + 位置)
    return 行


def 区切り(文字):
    """区切りの文字。先頭の空でない10行で、タブがカンマより多ければタブ（.csv でもタブ区切りのファイルがある）"""
    行 = [x for x in re.split(r"\r\n|\r|\n", 文字) if x != ""][:10]
    return "\t" if sum(x.count("\t") for x in 行) > sum(x.count(",") for x in 行) else ","


def 値の文字(v):
    """GeoJSON の値を文字にする（整数の値の小数は「35」、真偽は「true」「false」、null と入れ子は空）"""
    if v is None or isinstance(v, (dict, list)):
        return ""
    if isinstance(v, bool):
        return "true" if v else "false"
    if isinstance(v, float) and v.is_integer() and abs(v) < 1e16:
        return str(int(v))
    return str(v)


def そろえてつなぐ(提供元, 共通の列, 数の列, 参照, コードの名前=None, 日時の列=None, 必ずある列=None, 区分の決まり=None, 助数詞=None):
    """提供元ごとにそろえて、1つの表にする。取れない・読めない提供元は、画面と同じく外したことを書いて続ける。
    複数の表を読む提供元（「表」）は表ごとにそろえ、読めた表の分で続ける。同じファイルは1回だけ取る"""
    表たち = []
    取った = {}
    for id, 元 in 提供元.items():
        for 表 in 元.get("表", [{}]):
            名前 = f"{元['提供元']}の{表['表の名前']}" if 表 else 元["提供元"]
            try:
                表たち.append(そろえる(id, {**元, **表}, 共通の列, 数の列, 参照, コードの名前, 日時の列, 必ずある列, 区分の決まり, 取った, 助数詞))
            except 取得を休んでいる:
                raise
            except 外す as e:
                print(f"{名前}は外しました（{e}）")
            except Exception as e:  # 思わぬ誤りも、画面と同じくこの提供元（この表）だけ外す
                print(f"{名前}は外しました（読めなかった：{e!r}）")
    if not 表たち:
        raise ValueError("読めた提供元がありません（外した理由は上に書いたとおり）")
    return pd.concat(表たち, ignore_index=True)


def そろえる(id, 元, 共通の列, 数の列, 参照, コードの名前=None, 日時の列=None, 必ずある列=None, 区分の決まり=None, 取った=None, 助数詞=None):
    """提供元のファイルを中継から取り、共通の列の表にする（利用者が作ったそろえ方は、ファイルを「パス」で取る）。
    コードの名前があれば、その列が空欄の行をコードの列から埋める。日時の列（列 → 「日付」「日時」「時刻」「年月」）は
    決まった形で読み、元の書き方を「（列）_元データ」の列に残す。必ずある列が空の行は「行を整える」で扱う。区分の決まり
    （列 → 決まり）があれば、その列を元の列の言葉から決める。取れない・読めない・見出しが合わないときは、理由を書いて外す"""
    日時の列 = 日時の列 or {}
    必ずある列 = 必ずある列 or []
    区分の決まり = 区分の決まり or {}
    助数詞 = 助数詞 or {}
    列の並び = [x for 列 in 共通の列 for x in ([列, 列 + "_元データ"] if 列 in 日時の列 else [列])]
    if "パス" in 元:
        url = f"{中継}/p/{元['パス']}"
    else:
        url = f"{中継}/s/{id}?r={元['ファイル']}" if "ファイル" in 元 else f"{中継}/s/{id}"
    取った = {} if 取った is None else 取った
    if url not in 取った:
        印 = {}
        取った[url] = (中継から取る(url, 印), 印)
    中身, 印 = 取った[url]
    # どこから来た行か（カタログの名前、読んだファイルの名前とシート、ファイルの更新日、載っている範囲）。分からなければ空欄
    ファイル名 = 印["ファイル"] or None
    if 元.get("シート"):
        ファイル名 = f"{ファイル名 or ''}（{元['シート']}）"
    出所 = [元.get("カタログ"), ファイル名, 印["更新日"] or None, 元.get("元データの範囲")]
    if 中身.startswith(b"\xef\xbb\xbf"):
        中身 = 中身[3:]
    行 = 表を読む(中身, 元)
    見出しの行 = 行[元["見出しの行"] - 1] if len(行) >= 元["見出しの行"] else []  # ファイルが短ければ見出しはない
    見出し = [見出しの形(x) for x in 見出しの行]
    for 位置, 名前 in 元.get("見出しの付け直し", {}).items():
        見出し += [""] * (位置 + 1 - len(見出し))
        見出し[位置] = 名前
    ない = 見つからない見出し(元, 見出し)
    if ない:  # そろえ方を作ったあとに、元のファイルの見出しが変わった（データの行がなくても確かめる）
        並び = "".join(f"「{x}」" for x in ない)
        raise 外す(f"そろえ方が合わない。ファイルの形が変わり、見出し{並び}がない")
    # 全部の欄が空の行は読まない。番号は見出しの下の元の行の番号（どの行がすぐ上の行かを見る）
    データ = [(番号, r) for 番号, r in enumerate(行[元["見出しの行"]:]) if any(前後の空白を除く(c) for c in r)]
    地域 = 元.get("地域")
    候補 = 市区町村の名前(参照["市区町村"], 地域["県"]) if 地域 else []
    # 共通の列に当てはめた文字（数にする前に直す）
    記録 = []
    for 番号, r in データ:
        文字 = {"_番号": 番号}
        for 列 in 共通の列:
            j = 見出し.index(元["列"][列]) if 列 in 元["列"] else -1
            文字[列] = r[j] if 0 <= j < len(r) else ""
        if "平面直角座標" in 元:
            for 向き, k in (("_北", "北"), ("_東", "東")):
                j = 見出し.index(元["平面直角座標"][k])
                文字[向き] = r[j] if j < len(r) else ""
        if 地域:
            j = 見出し.index(地域["列"])
            文字["_地域"] = r[j] if j < len(r) else ""
        記録.append((文字, r))
    記録 = 直す(記録, 元.get("直し方", []), 見出し)
    同じ値の列 = {f["列"] for f in 元.get("直し方", []) if f["直し方"] == "同じ値にする"}
    見る列 = [x for x in 共通の列 if x not in 区分の決まり and x not in 同じ値の列]
    # 分類の列：区分の決まりが見る列のうち、必ずある列と表の名前を除いたもの（上の階層が先。「続きの行」がつなぐのときに見る）
    分類の列 = list(dict.fromkeys(列 for 決まり in 区分の決まり.values() for 列 in 決まり["見る列"] if 列 != "元の表" and 列 not in 必ずある列))
    結果 = []
    for 文字 in 行を整える([x for x, _ in 記録], 見る列, 数の列, 必ずある列, 見出し, 元.get("続きの行"), 分類の列, 日時の列, 元.get("続きの区切り", ""), 助数詞):
        値 = {列: 数にする(助数詞を除く(文字[列], 助数詞.get(列))) if 列 in 数の列 else (前後の空白を除く(文字[列]) or None) for 列 in 共通の列}
        for 列, 埋め方 in (コードの名前 or {}).items():  # 空欄の行は、コードの列から名前を埋める（元の値は上書きしない）
            コード = 値[埋め方["コードの列"]]
            if 値[列] is None and isinstance(コード, str):
                値[列] = 埋め方["名前"].get(コードの形(コード))
        for 列, 決まり in 区分の決まり.items():  # 区分は、埋めたあとの元の列の言葉から決める（元の列は変えない）
            値[列] = 区分を付ける(値, 決まり, 必ずある列, 元.get("表の名前"), 元.get("人が決めた区分"))
        for 列, 型 in 日時の列.items():  # 日付と時間の列は決まった形にし、元の書き方を「（列）_元データ」に残す
            値[列 + "_元データ"] = 値[列]
            値[列] = 日時の形(文字[列], 型)
        if "平面直角座標" in 元:
            p = 元["平面直角座標"]
            北, 東 = 数にする(文字["_北"]), 数にする(文字["_東"])
            値["緯度"], 値["経度"] = (None, None)
            if 北 is not None and 東 is not None:
                値["緯度"], 値["経度"] = Transformer.from_crs(f"EPSG:{6668 + p['系']}", "EPSG:4326").transform(北, 東)
        # 行の市区町村。県や国がまとめて出している版（地域）は行ごとに決める。決まらない行は空欄
        ここ = 元
        if 地域:
            v = 文字["_地域"]
            コード = 住所の市区町村(v, 候補, 参照["市区町村"]) if 地域["決め方"] == "住所" else コードの市区町村(v, 参照["市区町村"])
            if コード in 地域.get("版のある市区町村", []):
                continue  # 別の提供元を外したときは、自分の版がある市区町村の行を除く
            if "読む市区町村" in 地域 and コード not in 地域["読む市区町村"]:
                continue  # 市区町村を選んだときは、県や国がまとめた版からその市区町村の行だけを読む
            m = 参照["市区町村"].get(コード) if コード else None
            ここ = {
                **元,
                "市区町村コード": コード,
                "市区町村名": m["name"] if m else None,
                "郡を含む名前": m["full"] if m else 元["郡を含む名前"],
                "外接矩形": 参照["外接矩形"].get(コード) if コード else 元.get("外接矩形"),
            }
        出どころ = "なし"
        緯度, 経度 = 値["緯度"], 値["経度"]
        値["緯度"] = 値["経度"] = None
        if 元.get("日本測地系") and 緯度 is not None and 経度 is not None:
            緯度, 経度 = 日本測地系から(緯度, 経度)
        戻した = None
        if 緯度 is not None and 経度 is not None and not 元.get("位置を使わない"):
            戻した = 元の位置(緯度, 経度, ここ, 元.get("度分秒"))
        if 戻した:
            値["緯度"], 値["経度"] = 戻した
            出どころ = "元のデータ"
        if 出どころ == "なし" and 値.get("住所") and ここ["市区町村コード"]:
            見つけた = 参照["住所の位置"].get(住所の鍵(値["住所"], ここ))
            if 見つけた and 市区町村の中(見つけた[0], 見つけた[1], ここ):
                値["緯度"], 値["経度"] = 見つけた[0], 見つけた[1]
                出どころ = "住所から求めた" if 見つけた[2] == "番地" else "住所から求めた（おおよそ）"
        結果.append([*(値[列] for 列 in 列の並び), 元["都道府県名"], ここ["市区町村名"], ここ["市区町村コード"], 元["提供元"], *出所, 出どころ])
    表 = pd.DataFrame(結果, columns=[*列の並び, "都道府県名", "市区町村名", "市区町村コード", "提供元", "カタログ", "元のファイル名", "元の更新日", "元データの範囲", "位置の出どころ"])
    表 = 表.astype({列: "float64" for 列 in 数の列})  # 位置がすべて空欄の提供元も数の列にする
    for 列, 型 in 日時の列.items():  # 日付・日時・年月はタイムスタンプ、時刻は0時からの時間（Timedelta）にする
        表[列] = 時刻にする(表[列]) if 型 == "時刻" else 表[列].astype("datetime64[s]")
    return 表


def 行を整える(記録, 見る列, 数の列, 必ずある列, 見出し, 続きの行=None, 分類の列=(), 日時の列=(), 続きの区切り="", 助数詞=None):
    """必ずある列が空の行を扱う（画面と同じ決まり）。見る列に中身のない行と、合計・注・見出しの繰り返しは除く。
    必ずある列の値が合計の形の行（「計   61施設」）も除く。表の途中の見出しの繰り返しより下で、次に必ずある列の値のある行が
    出るまでの、場所もない行も除く（凡例など）。場所があって必ずある列だけが空の行は、そのまま残す。2列以上に中身があり、
    すぐ上の元の行に必ずある列の値があれば、その行の続きとして必ずある列と場所を上の行から補う（ほかの列はその行の値のまま）。
    どれでもない行は、そのまま残す。
    続きの行が「つなぐ」なら（Excel の折り返し）、値が分類の列だけの行は除き、ほかの列に値がある行と、名称と分類の列のほかが空の行は、
    すぐ上の行の同じ列につないで消す（文字の列の区切りは続きの区切り）。
    分類の列は結合セルなので、空なら上の行の値で埋める（除いた分類だけの行の値も埋める元にする。上の階層の値が変わったら、下の階層は
    続かない。件数を添えた見出しの「〈重要美術品〉 １件」は埋める元にせず、そこで切る。合計や見出しの繰り返しの行でも切る）"""
    見出したち = {x for x in 見出し if x != ""}
    埋める列 = [x for x in 分類の列 if x in 見る列]  # 同じ値にする直し方で全部の行に入れた列は結合セルではない

    助数詞 = 助数詞 or {}

    def そのまま(文字, 列):
        """列の文字（数のうしろの言葉を書いた列は、除いた形）"""
        return 助数詞を除く(文字.get(列, ""), 助数詞.get(列))

    def ある(文字, 列):
        v = そのまま(文字, 列)
        return (数にする(v) if 列 in 数の列 else 前後の空白を除く(v)) not in (None, "")

    def 場所がある(文字):
        住所 = 文字.get("住所", "")
        if (
            前後の空白を除く(住所) != ""
            and 数にする(住所) is None
            and 見出しの形(住所) not in 見出したち
            and not 合計か(住所)
            and not 注か(住所)
        ):
            return True
        if ある(文字, "緯度") and ある(文字, "経度"):
            return True
        return 数にする(文字.get("_北", "")) is not None and 数にする(文字.get("_東", "")) is not None

    def 名前が合計か(文字):
        return any(合計の形か(文字.get(列, "")) for 列 in 必ずある列)

    def ほかの値がある(文字):
        """必ずある列と分類の列のほかに、値があるか（数として読めない値も値とみなす）"""
        return any(前後の空白を除く(文字.get(列, "")) != "" for 列 in 見る列 if 列 not in 必ずある列 and 列 not in 分類の列) or any(
            数にする(文字.get(k, "")) is not None for k in ("_北", "_東")
        )

    def つなぐ(先, 文字):
        """同じ列の値につなぐ。文字の列の区切りは続きの区切り、日付と時間の列は半角の空白。数の列はつながない（上の行が空のときだけ入れる）"""
        for k in ("_北", "_東"):
            if 数にする(文字.get(k, "")) is not None and 数にする(先.get(k, "")) is None:
                先[k] = 文字[k]
        for 列 in 見る列:
            if not ある(文字, 列):
                continue
            今, 前 = 前後の空白を除く(文字[列]), 前後の空白を除く(先.get(列, ""))
            if 列 in 数の列:
                先[列] = 先[列] if ある(先, 列) else 今
            elif 前 == "":
                先[列] = 今
            else:
                先[列] = 前 + (" " if 列 in 日時の列 else 続きの区切り) + 今

    上の分類 = {}  # 分類の列の、下の行を埋める元の値（「つなぐ」のとき）

    def 分類を覚える(文字):
        """行の分類の列の値を、下の行を埋める元として覚える。上の階層の値が変わったら、下の階層は続かない。件数を添えた見出しはそこで切る"""
        変わった = False
        for 列 in 埋める列:
            v = 前後の空白を除く(文字.get(列, ""))
            if v == "":
                if 変わった:
                    上の分類.pop(列, None)
                continue
            変わった = 変わった or 上の分類.get(列) != v
            if re.fullmatch(".*[0-9]件", 見出しの形(v)):
                上の分類.pop(列, None)
            else:
                上の分類[列] = v

    def つないで残す(文字):
        """「つなぐ」の表で行を残す。分類の列が空なら上の行の値で埋める"""
        分類を覚える(文字)
        for 列 in 埋める列:
            if 前後の空白を除く(文字.get(列, "")) == "" and 列 in 上の分類:
                文字[列] = 上の分類[列]
        残す.append(文字)

    def 上の行につなぐ(文字):
        """上の行につなぐ。つないだ分類の列の値が、下の行を埋める元になる"""
        つなぐ(先, 文字)
        for 列 in 埋める列:
            if 前後の空白を除く(文字.get(列, "")) != "":
                上の分類[列] = 前後の空白を除く(先[列])

    # 補う前の値で見る（補った行の下は続きとみなさない）
    名前のある行 = {文字["_番号"]: 文字 for 文字 in 記録 if all(ある(文字, 列) for 列 in 必ずある列) and not 名前が合計か(文字)}
    残す = []
    見出しのあと = False  # 表の途中に見出しの繰り返しが出たあとか（次に必ずある列の値のある行が出るまで）
    先, 先の番号 = None, -2  # つなぐ先の行（名称のある残した行）と、そこにつないだ最後の元の行の番号
    for 文字 in 記録:
        値 = [前後の空白を除く(そのまま(文字, 列)) for 列 in 見る列 if ある(文字, 列)]
        値 += [前後の空白を除く(文字[k]) for k in ("_北", "_東") if 数にする(文字.get(k, "")) is not None]
        if not 値:
            continue  # 中身のない行
        if 名前が合計か(文字):
            上の分類.clear()
            continue
        番号 = 文字["_番号"]
        if 番号 in 名前のある行:
            見出しのあと = False
            # 名称と分類の列だけの行は、上の行の名称の折り返し（注の形の名称はつながない）
            if 続きの行 == "つなぐ" and 先 is not None and 先の番号 == 番号 - 1 and not ほかの値がある(文字) and not 除く行か(値, 見出したち, False, 番号):
                上の行につなぐ(文字)
                先の番号 = 番号
                continue
            if 続きの行 == "つなぐ" and 見出しの繰り返しか(値, 見出したち):
                上の分類.clear()  # 名称の列に値がある見出しの繰り返し：残すが、埋める元にしない
                残す.append(文字)
            elif 続きの行 == "つなぐ":
                つないで残す(文字)
            else:
                残す.append(文字)
            先, 先の番号 = 文字, 番号
            continue
        場所 = 場所がある(文字)
        if 除く行か(値, 見出したち, 場所, 番号):
            見出しのあと = 見出しのあと or (番号 > 0 and 見出しの繰り返しか(値, 見出したち))
            if 見出しの繰り返しか(値, 見出したち) or any(合計か(v) for v in 値):
                上の分類.clear()  # 表の切れ目（注や数字だけの行では切らない）
            continue
        if 見出しのあと and not 場所:
            continue
        if 続きの行 == "つなぐ":
            if not ほかの値がある(文字):
                分類を覚える(文字)  # 値が分類の列だけ：除くが、結合セルの先頭なので下の行を埋める元にする
                continue
            if 先 is not None and 先の番号 == 番号 - 1:
                上の行につなぐ(文字)
                先の番号 = 番号
            else:
                つないで残す(文字)
            continue
        上 = 名前のある行.get(番号 - 1)
        if not 場所 and 上 and len(値) >= 2:
            for 列 in 必ずある列:
                文字[列] = 上[列]
            for k in ("住所", "緯度", "経度", "_北", "_東"):
                if k in 上:
                    文字[k] = 上[k]
            if "_地域" in 上 and 前後の空白を除く(文字.get("_地域", "")) == "":
                文字["_地域"] = 上["_地域"]
        残す.append(文字)
    return 残す


def 合計か(v):
    """「合計」「小計」「総計」「累計」で始まる値か、「計」だけの値"""
    v = 見出しの形(v)
    return v == "計" or v.startswith(("合計", "小計", "総計", "累計"))


def 合計の形か(v):
    """必ずある列の値が合計の形か（「計   61施設」「合計 418施設」。「計画道路」「計量所」には当たらない）"""
    return re.fullmatch("(合計|総計|小計|累計|計)[0-9,]+(施設|件|か所|箇所|ヶ所|台)?", 見出しの形(v)) is not None


def 注か(v):
    """「資料：」「出典」「注：」「※」などで始まる値"""
    return 前後の空白を除く(unicodedata.normalize("NFKC", v)).startswith(("資料:", "資料 ", "出典", "注:", "注 ", "注)", "(注)", "※", "*"))


def 見出しの繰り返しか(値, 見出したち):
    """値が全部、見出しのどれかと同じ行か"""
    return all(見出しの形(v) in 見出したち for v in 値)


def 除く行か(値, 見出したち, 場所, 番号):
    """合計・注・見出しの繰り返しか。値が全部見出しと同じ行、見出しのすぐ下で場所のない行（見出しの2行目）、
    場所がなく「合計」などのある行、場所がなく値が1つだけで注か数の行"""
    if 見出しの繰り返しか(値, 見出したち):
        return True
    if 場所:
        return False
    if 番号 == 0 or any(合計か(v) for v in 値):
        return True
    return len(値) == 1 and (注か(値[0]) or 数にする(値[0]) is not None)


def 見つからない見出し(元, 見出し):
    """そろえ方が使う元の見出し（共通の列への当てはめ、平面直角座標、直し方、地域）のうち、ファイルにないもの"""
    使う = list(元["列"].values())
    if "平面直角座標" in 元:
        使う += [元["平面直角座標"]["北"], 元["平面直角座標"]["東"]]
    for f in 元.get("直し方", []):
        if f["直し方"] == "つなぐ":
            使う += f["列"]
        elif f["直し方"] == "緯度と経度に分ける":
            使う.append(f["列"])
    if "地域" in 元:
        使う.append(元["地域"]["列"])
    return [x for x in dict.fromkeys(使う) if x not in 見出し]


def 直す(記録, 直し方, 見出し):
    """そろえ方の直し方を、書いた順に行う。記録は（共通の列の文字, 元の行）の並び"""
    for f in 直し方:
        if f["直し方"] == "つなぐ":  # 元の列をつないで1つの列にする（空の値は飛ばす）
            位置 = [見出し.index(c) for c in f["列"]]
            for 文字, r in 記録:
                値 = [前後の空白を除く(r[i]) if i < len(r) else "" for i in 位置]
                文字[f["入れる列"]] = f["区切り"].join(v for v in 値 if v != "")
        elif f["直し方"] == "置き換える":  # 値がまるごと同じなら置き換える
            for 文字, _ in 記録:
                if 前後の空白を除く(文字.get(f["列"], "")) == f["前"]:
                    文字[f["列"]] = f["後"]
        elif f["直し方"] == "同じ値にする":
            for 文字, _ in 記録:
                文字[f["列"]] = f["値"]
        elif f["直し方"] == "行を除く":  # 決まった値の行と、（「空欄」があれば）値が空の行を除く
            残す = []
            for 文字, r in 記録:
                v = 前後の空白を除く(文字.get(f["列"], ""))
                if not ((f.get("空欄") and v == "") or ("値" in f and v == f["値"])):
                    残す.append((文字, r))
            記録 = 残す
        elif f["直し方"] == "行を残す":  # 1つの表を分けて読むときに、決まった値の行だけか、それ以外を残す
            残す = []
            for 文字, r in 記録:
                v = 前後の空白を除く(文字.get(f["列"], ""))
                if ("値" not in f or v == f["値"]) and ("値以外" not in f or v != f["値以外"]):
                    残す.append((文字, r))
            記録 = 残す
        elif f["直し方"] == "緯度と経度に分ける":  # 「35.1,136.9」のような1つの列を分ける
            i = 見出し.index(f["列"])
            for 文字, r in 記録:
                分けた = (r[i] if i < len(r) else "").split(f["区切り"])
                文字["緯度"] = 分けた[0]
                文字["経度"] = 分けた[1] if len(分けた) > 1 else ""
    return 記録


def 元の位置(緯度, 経度, 元, 度分秒):
    """市区町村の外なら、緯度と経度を入れ替えて中に入るか、（度分秒のとき）度分秒として読み直して中に入るかを見る"""
    if 市区町村の中(緯度, 経度, 元):
        return 緯度, 経度
    if 市区町村の中(経度, 緯度, 元):
        return 経度, 緯度
    if 度分秒:
        a, b = 度分秒を度に(緯度), 度分秒を度に(経度)
        if a is not None and b is not None and 市区町村の中(a, b, 元):
            return a, b
    return None


def 日本測地系から(緯度, 経度):
    """日本測地系の緯度経度を世界測地系にする（国土地理院の簡易な変換式。数mのずれが残る）"""
    return (
        緯度 - 0.00010695 * 緯度 + 0.000017464 * 経度 + 0.0046017,
        経度 - 0.000046038 * 緯度 - 0.000083043 * 経度 + 0.010040,
    )


def 度分秒を度に(v):
    """38.264152（38度26分41.52秒）を度にする。分か秒が60以上なら None"""
    if not math.isfinite(v):
        return None
    x = math.floor(abs(v) * 1e6 + 0.5)
    度, 分, 秒 = x // 1_000_000, x // 10_000 % 100, x % 10_000
    if 分 >= 60 or 秒 >= 6000:
        return None
    return (-1 if v < 0 else 1) * (度 + 分 / 60 + 秒 / 100 / 3600)


def 市区町村の中(緯度, 経度, 元):
    """日本の範囲と、市区町村の外接矩形（少し広げたもの）の中にあるか"""
    if not (20 <= 緯度 <= 46 and 122 <= 経度 <= 154):
        return False
    if 元.get("外接矩形") is None:
        return True
    西, 南, 東, 北 = 元["外接矩形"]
    return 西 - 0.01 <= 経度 <= 東 + 0.01 and 南 - 0.01 <= 緯度 <= 北 + 0.01


def 住所の鍵(住所, 元):
    """NFKC にして空白を除き、都道府県名と郡名を補う"""
    a = re.sub(空白 + "+", "", unicodedata.normalize("NFKC", 住所))
    県, 名前, 郡を含む名前 = 元["都道府県名"], 元["市区町村名"], 元["郡を含む名前"]
    a = a[len(県):] if a.startswith(県) else a
    if a.startswith(郡を含む名前):
        return 県 + a
    if a.startswith(名前):
        return 県 + 郡を含む名前 + a[len(名前):]
    return 県 + 郡を含む名前 + a


def 市区町村の名前(市区町村, 県):
    """（名前, コード）を長い名前から並べる。郡を含む名前と含まない名前の両方。政令市の区は市にまとめる"""
    候補 = set()
    for c, m in 市区町村.items():
        if m["kind"] == "pref" or (県 and not c.startswith(県)):
            continue
        市 = (m.get("parent") or c) if m["kind"] == "ward" else c
        候補 |= {(m["full"], 市), (m["name"], 市)}
    return sorted(候補, key=lambda x: (-len(x[0]), x[0], x[1]))


def 住所の市区町村(住所, 候補, 市区町村):
    """住所の先頭の市区町村。先頭に都道府県名があれば除いてから当てる"""
    a = re.sub(空白 + "+", "", unicodedata.normalize("NFKC", 住所))
    for m in 市区町村.values():
        if m["kind"] == "pref" and a.startswith(m["name"]):
            a = a[len(m["name"]):]
            break
    return next((c for n, c in 候補 if a.startswith(n)), None)


def コードの市区町村(値, 市区町村):
    """市区町村コード（6桁、または検査数字のない5桁）。政令市の区は市にまとめる"""
    d = re.sub(r"[^0-9]", "", unicodedata.normalize("NFKC", 値))
    c = None
    if len(d) == 6 and d in 市区町村:
        c = d
    elif len(d) == 5:
        c = next((k for k in sorted(市区町村) if k[:5] == d), None)
    if c is None or 市区町村[c]["kind"] == "pref":
        return None
    m = 市区町村[c]
    return (m.get("parent") or c) if m["kind"] == "ward" else c


日付の番号 = {*range(14, 23), *range(27, 37), *range(45, 48), *range(50, 59)}  # 日付・時刻の組み込みの書式
展開の上限 = 100 * 1024 * 1024  # zip の中の1つのファイルを展開してよい大きさ（展開すると巨大になるファイルで止まらないように）


def エクセルを読む(中身, シート=None):
    """Excel（.xlsx）を、CSV と同じ文字の行の並びにする（ふりがなは読まない。日付と時刻の書式は「2026-04-01」「9:00」）"""
    z = zipfile.ZipFile(io.BytesIO(中身))
    名前 = set(z.namelist())

    def 部分(n):
        """名前を挙げたファイルだけを展開する。展開したあとの大きさが上限を超えるものは読まない"""
        if n not in 名前:
            return ""
        大きさ = z.getinfo(n).file_size
        if 大きさ > 展開の上限:
            raise ValueError(f"展開すると大きすぎる：{n}")
        with z.open(n) as f:
            return f.read(大きさ).decode("utf-8", "replace")

    ブック, 関係 = 部分("xl/workbook.xml"), 部分("xl/_rels/workbook.xml.rels")
    行き先 = {属性(t, "Id"): 属性(t, "Target") for t in re.findall(r"<Relationship\b[^>]*>", 関係)}
    一覧 = [(属性(t, "name"), 属性(t, "r:id")) for t in re.findall(r"<sheet\b[^>]*>", ブック)]
    選んだ = next((x for x in 一覧 if x[0] == シート), None) if シート else 一覧[0]
    パス = (行き先.get(選んだ[1]) or "").lstrip("/")
    パス = パス if パス.startswith("xl/") else "xl/" + パス
    年1904 = re.search(r'<workbookPr\b[^>]*date1904="(1|true)"', ブック) is not None
    共有 = [エクセルの文字(x) for x in re.findall(r"<si\b[^>]*?(?:/>|>(.*?)</si>)", 部分("xl/sharedStrings.xml"), re.S)]
    スタイル = 部分("xl/styles.xml")
    書式 = {整数(属性(t, "numFmtId"), -1): 属性(t, "formatCode") or "" for t in re.findall(r"<numFmt\b[^>]*>", スタイル)}
    xfs = re.search(r"<cellXfs\b[^>]*>(.*?)</cellXfs>", スタイル, re.S)
    セルの書式 = []  # スタイルの番号 → (日付か, 秒があるか)
    for t in re.findall(r"<xf\b[^>]*>", xfs[1] if xfs else ""):
        番号 = 整数(属性(t, "numFmtId"), 0)
        コード = 書式.get(番号, "")
        日付 = 番号 in 日付の番号 or (番号 in 書式 and 日付の書式か(コード))
        セルの書式.append((日付, 番号 in (21, 45, 46, 47) or (日付 and "s" in re.sub(r'"[^"]*"', "", コード))))
    行 = []
    for 行の属性, 行の中 in re.findall(r"<row\b([^>]*?)(?:/>|>(.*?)</row>)", 部分(パス), re.S):
        r = 整数(属性(行の属性, "r"), 0)
        while r and len(行) < r - 1:
            行.append([])
        セル = []
        for c, 中 in re.findall(r"<c\b([^>]*?)(?:/>|>(.*?)</c>)", 行の中, re.S):
            位置 = 属性(c, "r")
            i = 列の番号(位置) if 位置 else len(セル)
            t = 属性(c, "t") or "n"
            v = re.search(r"<v(?:\s[^>]*)?>(.*?)</v>", 中, re.S)
            元の値 = 文字に戻す(v[1]) if v else ""
            if t == "s":
                n = 整数(元の値, len(共有))
                値 = 共有[n] if n < len(共有) else ""
            elif t == "inlineStr":
                値 = エクセルの文字(中)
            elif t == "b":
                値 = "TRUE" if 元の値 == "1" else "FALSE" if 元の値 == "0" else 元の値
            elif t in ("str", "e", "d") or 元の値 == "":
                値 = 元の値
            else:
                s = 属性(c, "s")
                s = 0 if s is None else 整数(s, -1)
                日付, 秒 = セルの書式[s] if 0 <= s < len(セルの書式) else (False, False)
                値 = エクセルの日付(元の値, 年1904, 秒) if 日付 else エクセルの数(元の値)
            セル += [""] * (i - len(セル))
            if i < len(セル):
                セル[i] = 値
            else:
                セル.append(値)
        行.append(セル)
    return 行


def 文字に戻す(s):
    """XML の書き方（&amp; など）と、Excel の書き方（_x000D_ など）を文字に戻す"""
    名前つき = {"amp": "&", "lt": "<", "gt": ">", "quot": '"', "apos": "'"}

    def 戻す(m):
        k = m[1]
        return chr(int(k[2:], 16)) if k.startswith("#x") else chr(int(k[1:])) if k.startswith("#") else 名前つき[k]

    s = re.sub(r"&(#x[0-9a-fA-F]+|#[0-9]+|amp|lt|gt|quot|apos);", 戻す, s)
    return re.sub(r"_x([0-9A-Fa-f]{4})_", lambda m: chr(int(m[1], 16)), s)


def 属性(タグ, 名前):
    m = re.search(r"(?:^|\s)" + 名前 + r'="([^"]*)"', タグ)
    return 文字に戻す(m[1]) if m else None


def 整数(v, ないとき):
    return int(v) if v is not None and re.fullmatch(r"[0-9]+", v) else ないとき


def エクセルの文字(xml):
    """<t> の文字をつなぐ（ふりがなの <rPh> は除く）"""
    xml = re.sub(r"<rPh\b.*?</rPh>", "", xml or "", flags=re.S)
    return "".join(文字に戻す(t) for t in re.findall(r"<t(?:\s[^>]*)?>(.*?)</t>", xml, flags=re.S))


def 日付の書式か(コード):
    s = re.sub(r'"[^"]*"|\[[^\]]*\]|\\.|[eE][+-]', "", コード)
    return re.search(r"[yYdDhHsSeEgG]|m", s) is not None and not re.fullmatch(r"(?i)general", s)


def エクセルの数(v):
    """整数の値なら小数を付けない（212016.0 → 212016）。それ以外は最短の書き方"""
    if not re.fullmatch(r"\s*[+-]?([0-9]+\.?[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?\s*", v):
        return v
    f = float(v)
    if f in (float("inf"), float("-inf")):
        return v
    if f.is_integer() and abs(f) < 1e16:
        return str(int(f))
    return v if abs(f) >= 1e16 or abs(f) < 1e-4 else repr(f)


def エクセルの日付(v, 年1904, 秒あり):
    """日付の通し番号を「2026-04-01」、時刻を「9:00」にする"""
    if not re.fullmatch(r"\s*[+-]?([0-9]+\.?[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?\s*", v):
        return v
    f = float(v)
    if f < 0 or f > 2958465:
        return v
    日 = int(f)
    秒 = int((f - 日) * 86400 + 0.5)
    if 秒 >= 86400:
        日, 秒 = 日 + 1, 秒 - 86400
    ずれ = 1462 if 年1904 else 0  # 1904年基準のブックは、番号が1462日少ない
    if 日 + ずれ > 2958465:
        return v  # 9999年12月31日より後になる日付は、元の値のまま
    時分 = f"{秒 // 3600}:{秒 % 3600 // 60:02d}" + (f":{秒 % 60:02d}" if 秒あり else "")
    if 日 == 0 and not 年1904:
        return 時分
    d = datetime.date(1899, 12, 30) + datetime.timedelta(days=日 + ずれ)
    if not 年1904 and 日 < 61:
        d += datetime.timedelta(days=1)  # Excel の 1900年2月29日（ない日）の分
    return d.isoformat() if 秒 == 0 else f"{d.isoformat()} {時分}"


def 列の番号(位置):
    n = 0
    for ch in 位置:
        if not ("A" <= ch <= "Z" or "a" <= ch <= "z"):
            break
        n = n * 26 + (ord(ch.upper()) - 64)
    return n - 1


年号 = {"明治": 1867, "明": 1867, "M": 1867, "大正": 1911, "大": 1911, "T": 1911, "昭和": 1925, "昭": 1925, "S": 1925, "平成": 1988, "平": 1988, "H": 1988, "令和": 2018, "令": 2018, "R": 2018}  # 元年の前の年
年号の形 = "(明治|大正|昭和|平成|令和|[明大昭平令MTSHRmtshr])(元|[0-9]{1,2})"
月日の形 = "(?:年([0-9]{1,2})月([0-9]{1,2})日?|[-/.・]([0-9]{1,2})[-/.・]([0-9]{1,2}))"
月の形 = "(?:年([0-9]{1,2})月?|[-/.・]([0-9]{1,2}))"
時刻の形 = "(午前|午後)?([0-9]{1,2})(?:時(?:([0-9]{1,2})分?|(半))?|:([0-9]{2})(?::([0-9]{2}))?)"
翌の形 = "(?:翌日|翌朝|翌)(.+)"  # 「翌7:00」「翌日7時」「翌朝7時」は24時間足す（31:00）


def 日付にする(列):
    """日付の列（タイムスタンプ）にする。読めない値は空欄"""
    return 列.map(lambda v: 日時の形(v, "日付")).astype("datetime64[s]")


def 日時にする(列):
    """日時の列（タイムスタンプ）にする。読めない値は空欄"""
    return 列.map(lambda v: 日時の形(v, "日時")).astype("datetime64[s]")


def 年月にする(列):
    """年月の列（その月の1日のタイムスタンプ）にする。読めない値は空欄"""
    return 列.map(lambda v: 日時の形(v, "年月")).astype("datetime64[s]")


def 時刻にする(列):
    """時刻の列（その日の0時からの時間。pandas の Timedelta）にする。24:00・25:30・「翌7:00」（31:00）も読む。読めない値は空欄"""
    return pd.to_timedelta(列.map(lambda v: 時刻の値(日時の形(v, "時刻"))), unit="min").astype("timedelta64[s]")


def 時刻の値(s):
    """「25:30」を、0時からの分（1530）にする"""
    return None if s is None else int(s[:-3]) * 60 + int(s[-2:])


def 日時の文字(v, 型):
    """タイムスタンプと時刻（0時からの時間）を、決まった形の文字にする（25時半は 25:30）。空欄は None"""
    if v is None or v != v:
        return None
    if 型 == "時刻":
        分 = int(v.total_seconds() // 60)
        return f"{分 // 60:02d}:{分 % 60:02d}"
    年月 = f"{v.year:04d}-{v.month:02d}"
    if 型 == "年月":
        return 年月
    return f"{年月}-{v.day:02d}" + (f" {v.hour:02d}:{v.minute:02d}" if 型 == "日時" else "")


def 日時の形(v, 型):
    """値を決まった形の文字にする（日付「2026-04-01」、日時「2026-04-01 09:00」、時刻「09:00」、年月「2025-08」）。
    西暦・和暦（明治〜令和、1字の略、英字の略、元年）・8桁と6桁の数字・Excel の通し番号と時刻の小数・「午後5時15分」などを読む。
    時刻は0時からの時間で、24:00・25:30・「翌7:00」（31:00）も読む（47:59 まで）。頭の「'」は外す。読めない値（ない日、年だけなど）は None"""
    if v is None or v != v:
        return None
    if isinstance(v, float) and v.is_integer():
        v = int(v)
    t = 前後の空白を除く(unicodedata.normalize("NFKC", str(v)))
    if t[:1] in ("'", "`"):  # Excel で文字にするための印
        t = 前後の空白を除く(t[1:])
    詰めた = re.sub(空白 + "+", "", t)
    if 詰めた == "":
        return None
    if 型 == "時刻":
        分 = 時刻の分(詰めた)
        return None if 分 is None else f"{分 // 60:02d}:{分 % 60:02d}"
    if 型 == "年月":
        return 年月の部分(詰めた)
    if 型 == "日付":
        分けた = (日, 0) if (日 := 日付の部分(詰めた)) else 日付と時刻に分ける(t)
        if 分けた:
            return 分けた[0] if 分けた[1] == 0 else None  # 時刻がちょうど0:00なら日付として読む
        return 最初の日付(t)  # 値全体が読めないときは、値の中の最初の年月日がそろった日付
    if re.fullmatch(r"[0-9]{5,7}\.[0-9]+", 詰めた):  # 小数のある Excel の通し番号
        日数, 分 = divmod(math.floor(float(詰めた) * 1440 + 0.5), 1440)
        if 日数 > 2958465:
            return None
        日 = (datetime.date(1899, 12, 30) + datetime.timedelta(days=日数)).isoformat()
    else:
        分けた = (日, 0) if (日 := 日付の部分(詰めた)) else 日付と時刻に分ける(t)  # 日付だけなら0時
        if not 分けた:
            return None
        日, 分 = 分けた
    if 分 >= 1440:  # 24時を過ぎる時刻は次の日にする
        日数, 分 = divmod(分, 1440)
        if datetime.date.fromisoformat(日) > datetime.date.max - datetime.timedelta(days=日数):
            return None
        日 = (datetime.date.fromisoformat(日) + datetime.timedelta(days=日数)).isoformat()
    return f"{日} {分 // 60:02d}:{分 % 60:02d}"


def 最初の日付(t):
    """値の中の最初の、年月日がそろった日付（「1925/3/31 （名称変更） 1996/3/19」→ 1925-03-31）。年が1868〜2100の、暦にある日だけ。
    2つの日付をつないで読まないよう空白は除かずに探し、日付の中の空白だけ許す。1字の略は、前が漢字や英字なら別の言葉とみなす。
    すぐあとに時刻が続く値（日付と時刻の値）と、和暦の「-」区切り（「八幡東区昭和2-2-7」のような地名と見分けられない）は読まない"""
    空き = 空白 + "*"
    形 = (
        "(?:(?:^|[^0-9])([0-9]{4})"
        "|(?:(明治|大正|昭和|平成|令和)|(?:^|[^一-龥])([明大昭平令])|(?:^|[^A-Za-z])([MTSHRmtshr]))"
        f"{空き}(元|[0-9]{{1,2}}))"
        f"{空き}(?:年{空き}([0-9]{{1,2}}){空き}月{空き}([0-9]{{1,2}}){空き}日"
        f"|([-/.・]){空き}([0-9]{{1,2}}){空き}[-/.・]{空き}([0-9]{{1,2}})(?![0-9]))"
        f"(?!{空き}T?{空き}(?:午前|午後)?{空き}[0-9]{{1,2}}{空き}(?::|時))"
    )
    for m in re.finditer(形, t):
        年号の名前 = m[2] or m[3] or m[4]
        if 年号の名前 and m[8] == "-":
            continue
        年 = 年号の年(年号の名前, m[5]) if 年号の名前 else int(m[1])
        日 = 暦の日(年, int(m[6] or m[9]), int(m[7] or m[10])) if 1868 <= 年 <= 2100 else None
        if 日:
            return 日
    return None


def 暦の日(年, 月, 日):
    """暦にある日なら「2026-04-01」、ない日（2月30日、4月0日）は None"""
    try:
        return datetime.date(年, 月, 日).isoformat()
    except ValueError:
        return None


def 年号の年(年号の名前, 数):
    """和暦の年を西暦にする（元年は1年。「平成32年」は計算どおり2020年）"""
    return 年号[年号の名前.upper()] + (1 if 数 == "元" else int(数))


def 日付の部分(t):
    """空白を除いた日付の文字。年だけ・年月だけ、月/日/年の順のものは読まない"""
    m = re.fullmatch("([0-9]{4})" + 月日の形, t)
    if m:
        return 暦の日(int(m[1]), int(m[2] or m[4]), int(m[3] or m[5]))
    m = re.fullmatch(年号の形 + 月日の形, t)
    if m:
        return 暦の日(年号の年(m[1], m[2]), int(m[3] or m[5]), int(m[4] or m[6]))
    m = re.fullmatch(r"([0-9]{4})([0-9]{2})([0-9]{2})", t)  # 8桁の数字（年が1868〜2100）
    if m:
        return 暦の日(int(m[1]), int(m[2]), int(m[3])) if 1868 <= int(m[1]) <= 2100 else None
    if re.fullmatch(r"[0-9]{5,7}", t) and int(t) <= 2958465:  # Excel の通し番号（5桁以上の整数）
        return (datetime.date(1899, 12, 30) + datetime.timedelta(days=int(t))).isoformat()
    return None


def 年月の部分(t):
    """空白を除いた年月の文字を「2025-08」にする"""
    m = re.fullmatch("([0-9]{4})" + 月の形, t)
    if m:
        return 暦の月(int(m[1]), int(m[2] or m[3]))
    m = re.fullmatch(年号の形 + 月の形, t)
    if m:
        return 暦の月(年号の年(m[1], m[2]), int(m[3] or m[4]))
    m = re.fullmatch(r"([0-9]{4})([0-9]{2})", t)  # 6桁の数字（年が1868〜2100）
    if m:
        return 暦の月(int(m[1]), int(m[2])) if 1868 <= int(m[1]) <= 2100 else None
    return None


def 暦の月(年, 月):
    return f"{年:04d}-{月:02d}" if 1 <= 年 <= 9999 and 1 <= 月 <= 12 else None


def 時刻の分(t):
    """空白を除いた時刻の文字を、その日の0時からの分にする（24:00 は 1440、25:30 は 1530。48:00 からは None）"""
    m = re.fullmatch(翌の形, t)
    if m:
        分 = 時刻の分(m[1])
        return 分 + 1440 if 分 is not None and 分 < 1440 else None
    if t == "正午":
        return 720
    if re.fullmatch(r"0?\.[0-9]+", t):  # Excel の時刻の小数（1日を1として分に丸める）
        return math.floor(float(t) * 1440 + 0.5)
    m = re.fullmatch(時刻の形, t)
    if not m:
        return None
    時, 分, 秒 = int(m[2]), 30 if m[4] else int(m[3] or m[5] or 0), int(m[6] or 0)
    if 分 > 59 or 秒 > 59:
        return None
    if m[1]:  # 午前0時〜12時は0時〜正午、午後0時〜12時は正午〜24時
        if 時 > 12:
            return None
        時 += 12 if m[1] == "午後" else 0
    全部 = 時 * 60 + 分
    return 全部 if 全部 < 48 * 60 else None


def 日付と時刻に分ける(t):
    """「2026-04-01T09:00」か、空白の前後で日付と時刻に分ける。（日付, 0時からの分）か None"""
    m = re.fullmatch(r"([0-9]{4}-[0-9]{1,2}-[0-9]{1,2})T(.+)", t)
    if m:
        日, 分 = 日付の部分(m[1]), 時刻の分(re.sub(空白 + "+", "", m[2]))
        if 日 and 分 is not None:
            return 日, 分
    for 空き in re.finditer(空白 + "+", t):
        日 = 日付の部分(re.sub(空白 + "+", "", t[: 空き.start()]))
        分 = 時刻の分(re.sub(空白 + "+", "", t[空き.end() :])) if 日 else None
        if 日 and 分 is not None:
            return 日, 分
    return None


def 区分を探す(部分, 決まり):
    """上から順に見て、まるごと同じ値か、言葉のどれかを含み、除く言葉のどれも含まない最初の区分"""
    for x in 決まり["区分"]:
        if 部分 in x.get("同じ値", []):
            return x["名前"]
        if any(w in 部分 for w in x["言葉"]) and not any(w in 部分 for w in x.get("除く言葉", [])):
            return x["名前"]
    return None


def 値から区分を決める(値, 決まり, 区切らない):
    """1つの列の値から決める。区切った中に違う区分が2つ以上出たら決めない（次の列を見る）"""
    v = 見出しの形(値)
    if v == "" or v in 決まり["飛ばす値"]:
        return None
    部分 = [v] if 区切らない else [x for x in re.split("[・,、/;]", v) if x != ""]
    本体 = [x for x in 部分 if not any(a in x for a in 決まり["補助の言葉"])]
    見つけた = {区分を探す(x, 決まり) for x in 本体 or 部分} - {None}
    return 見つけた.pop() if len(見つけた) == 1 else None


def 区分を付ける(値, 決まり, 必ずある列, 表の名前=None, 表の区分=None):
    """1つの行の区分を決める。見る列を順に見て、どの列でも決まらなければ「決まらないとき」の値にする"""
    for 列 in 決まり["見る列"]:
        if 列 == "元の表":
            答え = 表の区分 or (値から区分を決める(表の名前, 決まり, False) if 表の名前 else None)
        else:
            答え = 値から区分を決める(値[列], 決まり, 列 in 必ずある列) if isinstance(値.get(列), str) else None
        if 答え is not None:
            return 答え
    return 決まり["決まらないとき"]


def サイトから読む(パス):
    """サイトの静的なファイル（JSON）を読む"""
    with urllib.request.urlopen(urllib.request.Request(DATA_N + パス, headers=名乗り)) as f:
        return json.load(f)


def 提供元の一覧(種類):
    """種類の提供元。知らない種類は、選べる種類の見方を書いて止める"""
    try:
        return サイトから読む(f"/data/{urllib.parse.quote(種類)}/providers.json")
    except urllib.error.HTTPError as e:
        if e.code != 404:
            raise
        raise ValueError(f"種類「{種類}」は見つかりません。datan.種類の一覧()で選べる種類を見られます") from e


def 配れるか(p):
    """そろえた提供元で、配ってよいライセンスのもの（確認が必要の提供元と、dist が no の提供元は入らない）"""
    return p["stage"] == "aligned" and p["dist"] != "no"


def 種類の一覧():
    """選べる種類の id、名前、入る提供元の数、入らない提供元の数、選べる区分の表"""
    行 = []
    for id, x in 種類の表.items():
        提供元たち = 提供元の一覧(id)
        入る = sum(配れるか(p) for p in 提供元たち)
        行.append([id, x["名前"], 入る, len(提供元たち) - 入る, x["区分"]])
    return pd.DataFrame(行, columns=["種類", "名前", "提供元の数", "入らない提供元の数", "区分"])


def 表に開く(揃え方):
    """揃え方を表ごとの読み方に開く（TS の expandTables と同じ決まり）。tables のない揃え方は1つの表"""
    開いた = []
    for t in 揃え方.get("tables") or []:
        ファイル = t.get("resource") or {}
        読み = {**揃え方["read"], **({"format": ファイル["format"]} if ファイル.get("format") else {}), **t.get("read", {})}
        if "sheet" in t:
            読み["sheet"] = t["sheet"]
        開いた.append(
            {
                **揃え方,
                "read": 読み,
                "map": {**揃え方["map"], **t.get("map", {})},
                "fixes": [*揃え方["fixes"], *t.get("fixes", [])],
                "coord": t["coord"] if "coord" in t else 揃え方["coord"],
                "pos": t.get("pos") or 揃え方["pos"],
                "表の名前": t["label"],
                "ファイル": ファイル.get("id"),
                "人が決めた区分": t.get("category"),
            }
        )
    return 開いた or [揃え方]


def 文字コードを決める(中身, 指定):
    """元のファイルの文字コード（TS の decode と同じ決まり）。BOM があれば BOM のとおり。自動は、UTF-8 として読めなければ Shift_JIS"""
    if 中身.startswith(b"\xef\xbb\xbf"):
        return "utf-8"
    if 中身.startswith((b"\xff\xfe", b"\xfe\xff")):
        return "utf-16"
    if 指定 in ("utf-8", "utf-8-sig"):
        return "utf-8"
    if 指定 == "auto":
        try:
            中身.decode("utf-8")
            return "utf-8"
        except UnicodeDecodeError:
            pass
    return "cp932"


def 範囲の言葉(揃え方, 団体):
    """列「元データの範囲」の値（TS の scopeText と同じ決まり。揃え方の印 scope と area.use から決まる）"""
    地域 = 揃え方.get("area")
    使い方 = (地域.get("use") or "all") if 地域 else None
    範囲 = 揃え方.get("scope")
    型 = 範囲["kind"] if 範囲 else ("pref_facilities" if 使い方 == "adds" else None)
    県 = 団体["pref"][-1] if 団体["pref"][-1:] in ("都", "道", "府", "県") else "県"
    if 型 == "pref_facilities":
        return f"{県}の施設だけ"
    if 揃え方.get("表の名前") and 型 in (None, "part"):
        return f"{県 if 団体['kind'] == 'pref' else '市区町村'}が出した{揃え方['表の名前']}の一覧"
    if 型 == "part":
        return f"一部（{範囲['note']}）"
    if 型 == "all":
        if 団体["kind"] != "pref":
            return "市区町村の全体"
        if 使い方 == "gaps":
            return f"{県}がまとめた市町村の分"
        if 使い方 == "all":
            return "国がまとめた分"
    if 型 is None and 団体["kind"] != "pref":
        return "市区町村が出した一覧"
    return "不明"


def 直し方の辞書(f):
    """揃え方の直し方1つを、道具の辞書にする（TS の fixEntry と同じ決まり。行ごとの直し方でないものは None）"""
    op = f["op"]
    if op == "join":
        return {"直し方": "つなぐ", "列": [見出しの形(c) for c in f["cols"]], "入れる列": f["into"], "区切り": f.get("sep") or ""}
    if op == "replace":
        return {"直し方": "置き換える", "列": f["col"], "前": f["from"], "後": f["to"]}
    if op == "const":
        return {"直し方": "同じ値にする", "列": f["col"], "値": f["value"]}
    if op == "drop_rows":
        return {"直し方": "行を除く", "列": f["col"], **({"値": f["equals"]} if "equals" in f else {}), **({"空欄": True} if f.get("blank") else {})}
    if op == "keep_rows":
        return {"直し方": "行を残す", "列": f["col"], **({"値": f["equals"]} if "equals" in f else {}), **({"値以外": f["not_equals"]} if "not_equals" in f else {})}
    if op == "split_latlon":
        return {"直し方": "緯度と経度に分ける", "列": 見出しの形(f["col"]), "区切り": f.get("sep", ",")}
    return None


def 読み方にする(揃え方, 中身, 形, 提供元, 参照):
    """揃え方（表ごとに開いたもの）を道具の辞書にする（TS の align が返す used と sourceEntry と同じ決まり）。
    形式、文字コード、候補の見出しのどれを使うかは、元のファイルを見て決める"""
    読み = 揃え方["read"]
    形式 = 読み["format"]
    if 形式 not in ("csv", "geojson", "xlsx"):
        raise 外す(f"読めない形式：{形式}")
    if 形式 != "geojson" and 中身.startswith(b"PK"):  # 拡張子が .csv の Excel がある
        形式 = "xlsx"
    元 = {"形式": 形式, "文字コード": "utf-8" if 形式 == "xlsx" else 文字コードを決める(中身, 読み["enc"]), "見出しの行": 読み["header_row"]}
    if 形式 == "xlsx" and 読み.get("sheet"):
        元["シート"] = 読み["sheet"]
    if 読み.get("continuation") == "join":
        元["続きの行"] = "つなぐ"
    if 読み.get("continuation_sep"):
        元["続きの区切り"] = 読み["continuation_sep"]
    直し方 = 揃え方["fixes"]
    付け直し = {f["index"]: 見出しの形(f["name"]) for f in 直し方 if f["op"] == "header_at"}
    if 付け直し:
        元["見出しの付け直し"] = 付け直し
    行 = 表を読む(中身[3:] if 中身.startswith(b"\xef\xbb\xbf") else 中身, 元)
    見出し = [見出しの形(x) for x in 行[元["見出しの行"] - 1]] if len(行) >= 元["見出しの行"] else []
    for 位置, 名前 in 付け直し.items():
        見出し += [""] * (位置 + 1 - len(見出し))
        見出し[位置] = 名前
    平面 = 揃え方["coord"] if (揃え方.get("coord") or {}).get("kind") == "plane" else None
    if 平面 and Transformer is None:
        raise 外す("平面直角座標を読むにはpyprojが要ります（pip install pyproj）")
    元["列"], ない = {}, []
    for c in 形["columns"]:
        if c.get("classify") or (平面 and c["type"] in ("lat", "lon")):
            continue
        当てはめ = 揃え方["map"].get(c["name"])
        if 当てはめ is None:
            if c.get("required"):
                ない.append(c["name"])
            continue
        候補 = [見出しの形(x) for x in (当てはめ if isinstance(当てはめ, list) else [当てはめ])]
        見つけた = next((x for x in 候補 if x in 見出し), None)
        if 見つけた is None:
            ない.append("または".join(候補))
        else:
            元["列"][c["name"]] = 見つけた
    if ない:
        並び = "".join(f"「{x}」" for x in ない)
        raise 外す(f"そろえ方が合わない。ファイルの形が変わり、見出し{並び}がない")
    行の直し方 = [x for x in map(直し方の辞書, 直し方) if x]
    if 行の直し方:
        元["直し方"] = 行の直し方
    if 平面:
        元["平面直角座標"] = {"系": 平面["zone"], "北": 見出しの形(平面["north"]), "東": 見出しの形(平面["east"])}
    if 揃え方.get("pos") == "drop":
        元["位置を使わない"] = True
    if any(f["op"] == "dms" for f in 直し方):
        元["度分秒"] = True
    if any(f["op"] == "tokyo_datum" for f in 直し方):
        元["日本測地系"] = True
    org = 揃え方["org"]
    団体 = 参照["市区町村"][org]
    県の版 = 団体["kind"] == "pref"
    if 揃え方.get("area"):
        地域 = 揃え方["area"]
        元["地域"] = {"決め方": "住所" if 地域["from"] == "address" else "コード", "列": 見出しの形(地域["col"]), "県": org[:2] if 県の版 else None}
        if 揃え方.get("版のある市区町村"):  # 別の提供元を外したときは、自分の版がある市区町村の行を読まない
            元["地域"]["版のある市区町村"] = 揃え方["版のある市区町村"]
    return {
        **元,
        "市区町村コード": None if 県の版 else org,
        "都道府県名": 団体["pref"],
        "市区町村名": None if 県の版 else 団体["name"],
        "郡を含む名前": 団体["full"],
        "提供元": 揃え方.get("name") or 団体["name"],
        "カタログ": 提供元.get("catalog") or None,
        "元データの範囲": 範囲の言葉(揃え方, 団体),
        "外接矩形": 参照["外接矩形"].get(org),
        **({"表の名前": 揃え方["表の名前"]} if 揃え方.get("表の名前") else {}),
        **({"ファイル": 揃え方["ファイル"]} if 揃え方.get("ファイル") else {}),
        **({"人が決めた区分": 揃え方["人が決めた区分"]} if 揃え方.get("人が決めた区分") else {}),
    }


def 区分の決まりにする(k):
    """種類の形の classify を道具の辞書にする（TS の classifyEntry と同じ決まり。言葉は見出しと同じ形にする）"""

    def 言葉(a):
        return [見出しの形(w) for w in a or []]

    区分 = [{"名前": x["name"], "言葉": 言葉(x["words"]), "除く言葉": 言葉(x.get("not")), "同じ値": 言葉(x.get("same"))} for x in k["labels"]]
    return {"見る列": k["from"], "決まらないとき": k["rest"], "飛ばす値": 言葉(k.get("skip")), "補助の言葉": 言葉(k.get("aside")), "区分": 区分}


def 種類の決まり(形):
    """種類の形から、そろえる道具に渡す値を作る"""
    列 = 形["columns"]
    コードの名前 = {c["name"]: {"コードの列": c["fill"]["from"], "名前": コードの表.get(c["fill"]["table"], {})} for c in 列 if c.get("fill")}
    return {
        "共通の列": [c["name"] for c in 列],
        "数の列": [c["name"] for c in 列 if c["type"] in ("int", "float", "lat", "lon")],
        "コードの名前": コードの名前 or None,
        "日時の列": {c["name"]: 日時の型[c["type"]] for c in 列 if c["type"] in 日時の型},
        "必ずある列": [c["name"] for c in 列 if c.get("required")],
        "区分の決まり": {c["name"]: 区分の決まりにする(c["classify"]) for c in 列 if c.get("classify")},
        "助数詞": {c["name"]: c["units"] for c in 列 if c.get("units")},
    }


def 間をあけて取る(url, 取った):
    """中継からファイルを1本取る。同じファイルは1回だけ。キャッシュに当たっても、前に取ってから最短の秒はあける（1分の上限を超えない）。
    キャッシュに当たらなかったら、次を取るまでさらに間をあける（元のサイトへの配慮）"""
    global 前に取った時
    if url in 取った:
        return
    if 前に取った時 is not None:
        待つ = 最短の秒 - (time.monotonic() - 前に取った時)
        if 待つ > 0:
            time.sleep(待つ)
    前に取った時 = time.monotonic()
    印 = {}
    try:
        取った[url] = (中継から取る(url, 印), 印)
    finally:
        if 印.get("キャッシュ") != "hit":
            time.sleep(間の秒)


def 提供元をそろえる(揃え方, 提供元, 形, 決まり, 参照):
    """1つの提供元を表ごとにそろえる。（読めた表の並び, 読めなかった表の並び）を返す。取れない・読めない表は、理由を書いて飛ばす"""
    id = 揃え方["id"]
    取った = {}
    表たち, 読めなかった = [], []
    for 開いた in 表に開く(揃え方):
        名前 = 開いた.get("表の名前")
        表示 = 提供元["name"] + (f"の{名前}" if 名前 else "")
        try:
            url = f"{中継}/s/{id}?r={開いた['ファイル']}" if 開いた.get("ファイル") else f"{中継}/s/{id}"
            間をあけて取る(url, 取った)
            元 = 読み方にする(開いた, 取った[url][0], 形, 提供元, 参照)
            表たち.append(そろえる(id, 元, 決まり["共通の列"], 決まり["数の列"], 参照, 決まり["コードの名前"], 決まり["日時の列"], 決まり["必ずある列"], 決まり["区分の決まり"], 取った, 決まり["助数詞"]))
        except 取得を休んでいる as e:
            raise 取得を休んでいる(f"{e}（データをさがす：{DATA_N}/data/）") from None
        except 外す as e:
            理由 = str(e)
        except Exception as e:  # 思わぬ誤りも、画面と同じくこの提供元（この表）だけ飛ばす
            理由 = f"思わぬ誤り：{e!r}"
        else:
            continue
        print(f"{表示}は読めませんでした（{理由}）")
        読めなかった.append({"id": id, "提供元": 提供元["name"], "表": 名前, "理由": 理由})
    return 表たち, 読めなかった


def 地域の提供元(コード, 揃え方たち, 市区町村):
    """その市区町村の行を出す提供元の id（apps/site/src/lib/scope.ts の areaSources、lib/pick-region.ts の regionProviders と同じ決まり）。
    その市区町村が出した一覧と、県や国がまとめた一覧。県の施設の一覧は、その市区町村が出した読める一覧があるか、県の施設の一覧に行があるとき"""
    m = 市区町村.get(コード)
    市 = m["parent"] if m and m["kind"] == "ward" and m.get("parent") else コード
    自分の一覧 = any(s["org"] == 市 and not s.get("area") and not s.get("issue") for s in 揃え方たち)
    出す = []
    for s in 揃え方たち:
        if s.get("issue"):
            continue
        地域 = s.get("area")
        if not 地域:
            if s["org"] == 市:
                出す.append(s["id"])
        elif s["org"].startswith("00") or s["org"][:2] == 市[:2]:
            行 = s.get("rowMunis")
            if 地域.get("use") != "adds" or 自分の一覧 or 行 is None or 市 in 行:
                出す.append(s["id"])
    return 市, 出す


def 地域の形(地域):
    """地域を文字の並びにして確かめる"""
    if 地域 is None:
        return []
    並び = [地域] if isinstance(地域, str) else list(地域)
    for c in 並び:
        if not (isinstance(c, str) and re.fullmatch("[0-9]{2}|[0-9]{6}", c)):
            raise ValueError(f"地域「{c}」の書き方が違います。都道府県は2桁（\"21\"）、市区町村は6桁（\"232017\"）の文字で書きます")
    return 並び


def 地域を選ぶ(地域, 提供元たち, 揃え方たち, 市区町村):
    """提供元の id → 行をしぼる市区町村の集まり（None はしぼらない）。都道府県を選ぶとその都道府県の提供元の全部の行、
    市区町村を選ぶと、その市区町村が出した一覧と、県や国がまとめた一覧のその市区町村の行になる。なければ全国"""
    if not 地域:
        return {p["id"]: None for p in 提供元たち}
    選んだ = {}
    市区町村だけ = []
    for c in 地域:
        if len(c) == 6 and 市区町村.get(c, {}).get("kind") != "pref":
            市区町村だけ.append(c)
            continue
        ids = [p["id"] for p in 提供元たち if p["prefCode"] == c[:2]]
        選んだ.update(dict.fromkeys(ids))
        if not ids:
            print(f"地域「{c}」には、そろえた提供元がありません")
    for c in 市区町村だけ:
        市, ids = 地域の提供元(c, 揃え方たち, 市区町村) if c in 市区町村 else (c, [])
        for id in ids:
            if 選んだ.get(id, set()) is not None:
                選んだ.setdefault(id, set()).add(市)
        if not ids:
            print(f"地域「{c}」には、そろえた提供元がありません")
    return 選んだ


def 注意を書く(注意たち):
    """データの元が人に渡すときに伝えるよう書いている注意を、原文のまま書く（文の中で番号を指すので、番号つきで書く）"""
    for n in 注意たち:
        print(n["題"])
        for 番号, x in enumerate(n["項目"], 1):
            print(f"{番号}．{x}")
        print("出典と加工の書き方")
        for x in n["出典と加工"]:
            print(x)
        print(f"{n['ページの言葉']}：{n['ページ']}")


def 区分の形(区分, 形):
    """選んだ区分を確かめる。（列の名前, 値の並び）を返す。列は種類の形の印 show.narrow の列（TS の categoryChoices と同じ決まり）"""
    if 区分 is None:
        return None, None
    並び = [区分] if isinstance(区分, str) else list(区分)
    列 = (形.get("show") or {}).get("narrow")
    決まり = next((c["classify"] for c in 形["columns"] if c["name"] == 列 and c.get("classify")), None)
    if not 決まり:
        raise ValueError(f"種類「{形['id']}」では、区分を選べません")
    選べる = list(dict.fromkeys([*(x["name"] for x in 決まり["labels"]), 決まり["rest"]]))
    違う = [x for x in 並び if x not in 選べる]
    if 違う:
        raise ValueError(f"区分「{'、'.join(map(str, 違う))}」はありません。選べるのは、{'、'.join(選べる)}です")
    return 列, 並び


def 記録を送る(種類, 県たち, 読めた, 読めなかった, 前のデータ=()):
    """使われ方の記録を1件送る（種類、都道府県、読めた提供元の数、読めなかった提供元の数、部品の版。前のデータを読めた提供元が
    あれば、その提供元の id も。読んだファイルと年は送らない）。送れなくても止まらない"""
    try:
        中身 = {"t": 種類, "prefs": 県たち, "ok": 読めた, "fail": 読めなかった, "v": 部品の版}
        if 前のデータ:
            中身["old"] = list(前のデータ)[:前のデータの記録の上限]
        本文 = json.dumps(中身).encode()
        req = urllib.request.Request(f"{中継}/log/take", data=本文, headers={**名乗り, "Content-Type": "application/json"}, method="POST")
        with urllib.request.urlopen(req, timeout=5):
            pass
    except Exception:
        pass


def 地域の束(種類, 地域, 提供元たち):
    """選んだ地域の都道府県の揃え方と参照データを読む。（県たち, 束たち, 参照, 揃え方たち）を返す。部品より新しければ、取り直すよう知らせる"""
    県のある = {p["prefCode"] for p in 提供元たち}
    県たち = sorted({c[:2] for c in 地域} & 県のある if 地域 else 県のある)
    if not 県たち:
        raise ValueError(f"地域「{'、'.join(地域)}」には、そろえた提供元がありません")
    束たち = [サイトから読む(f"/specs/{urllib.parse.quote(種類)}/{県}.json") for 県 in 県たち]
    if max(x.get("part", 0) for x in 束たち) > 部品の版:
        print(f"新しい部品があります。{DATA_N}/py/datan.py を取り直してください")
    参照 = {"住所の位置": {}, "市区町村": {}, "外接矩形": {}}
    揃え方たち = {}
    for x in 束たち:
        参照["住所の位置"].update(x["geocode"])
        参照["市区町村"].update(x["muni"])
        参照["外接矩形"].update(x["bbox"])
        揃え方たち.update({s["id"]: s for s in x["sources"]})
    return 県たち, 束たち, 参照, 揃え方たち


def 配る提供元に分ける(対象):
    """（読む提供元, 入れなかった提供元）に分ける。入れなかった提供元があれば書く。読める提供元がなければ止める"""
    読む = [p for p in 対象 if 配れるか(p)]
    入れなかった = [{"id": p["id"], "提供元": p["name"], "ライセンス": p.get("licenseNames", ""), "元のページ": p["page"], "理由": "配っていない" if p["stage"] == "aligned" else "確認が必要"} for p in 対象 if not 配れるか(p)]
    if 入れなかった:
        並び = "、".join(x["提供元"] for x in 入れなかった[:10]) + ("ほか" if len(入れなかった) > 10 else "")
        print(f"入るのは、DATA-Nがライセンスを確かめられた{len(読む)}の提供元です。残りの{len(入れなかった)}は、元のページで見られます（{並び}。表.attrs[\"入れなかった\"]）")
    if not 読む:
        raise ValueError("選んだ地域に、配っている提供元がありません")
    return 読む, 入れなかった


def 時点の言葉(データ):
    """時点の言い方（TS の versionDate・versionText と同じ決まり）。「2016年」「2022年6月」「2026年3月1日」。
    更新日で決めた時点は「（更新日）」を添える。分からなければ「今のデータ」"""
    if not データ.get("date"):
        return "今のデータ"
    # 年月だけの日付もあるので、短いほうに合わせる（strict=False）
    部分 = zip(データ["date"].split("-"), "年月日", strict=False)
    言葉 = "".join(f"{int(x)}{字}" for x, 字 in 部分)
    return 言葉 + ("（更新日）" if データ.get("by") == "modified" else "")


def 合わないデータの言葉(合わない):
    """そろえ方が合わないデータの文（TS の offText と同じ決まり）"""
    並び = "、".join(時点の言葉(x) for x in 合わない[:2])
    return f"{並び}{f'など{len(合わない)}つ' if len(合わない) > 2 else ''}のデータは、そろえ方が合いません"


def 時点の一覧(種類, 地域=None):
    """提供元ごとの読めるデータの表を返す。列は提供元のid、提供元、地域（そろえて取るの地域に書ける）、時点、行の数（ファイル全体。分からなければ空）、
    最初に読むか（そろえて取るが何も書かなくても読むデータ）、ファイルのid（選べないデータは空）で、提供元の中は新しい順。
    地域の書き方は そろえて取る と同じ。中継には取りに行かず、記録も送らない。
    別のデータを読むときは、そろえて取るの ファイル= に、提供元のid → ファイルのid の辞書を書く。
    今のそろえ方で読めないデータは表に入れず、文に書く（一覧.attrs["そろえ方が合わないデータ"]）"""
    地域 = 地域の形(地域)
    提供元たち = 提供元の一覧(種類)
    対象 = 提供元たち
    if 地域:
        _, _, 参照, 揃え方たち = 地域の束(種類, 地域, 提供元たち)
        選んだ = 地域を選ぶ(地域, 提供元たち, list(揃え方たち.values()), 参照["市区町村"])
        対象 = [p for p in 提供元たち if p["id"] in 選んだ and p["id"] in 揃え方たち]
    読む, 入れなかった = 配る提供元に分ける(対象)
    行, 合わない = [], []
    for p in 読む:
        選べる = p.get("vers") or {}
        for データ in 選べる.get("list") or [{**(p.get("when") or {}), "now": True}]:
            行.append([p["id"], p["name"], p["org"], 時点の言葉(データ), データ.get("rows"), bool(データ.get("now")), データ.get("id") or None])
        if 選べる.get("off"):
            合わない.append({"id": p["id"], "提供元": p["name"], "時点": [時点の言葉(x) for x in 選べる["off"]], "元のページ": p["page"]})
            if len(合わない) <= 10:
                print(f"{p['name']}の{合わないデータの言葉(選べる['off'])}（元のページ：{p['page']}）")
    if len(合わない) > 10:
        print(f"ほかに{len(合わない) - 10}の提供元にも、そろえ方が合わないデータがあります（一覧.attrs[\"そろえ方が合わないデータ\"]）")
    一覧 = pd.DataFrame(行, columns=["提供元のid", "提供元", "地域", "時点", "行の数", "最初に読む", "ファイルのid"]).astype({"行の数": "Int64"})
    一覧.attrs["そろえ方が合わないデータ"] = 合わない
    一覧.attrs["入れなかった"] = 入れなかった
    return 一覧


def 読むデータを決める(ファイル, 読む, 種類):
    """ファイル（提供元のid → ファイルのid）を確かめ、提供元のid → 読むデータにする。最初のデータは入れない（中継に r を付けずに読む。
    TS の readVersion と同じ決まり）。全部を読み始めてから気づかないよう、書き間違いは取りに行く前に止める"""
    if ファイル is None:
        return {}
    見方 = f"datan.時点の一覧(\"{種類}\")で、読めるデータを見られます"
    if not isinstance(ファイル, dict):
        raise ValueError(f"ファイルは、提供元のid → ファイルのidの辞書で書きます。{見方}")
    提供元 = {p["id"]: p for p in 読む}
    読むデータ = {}
    for id, ファイルのid in ファイル.items():
        if id not in 提供元:
            raise ValueError(f"提供元「{id}」は、選んだ地域で読む提供元にありません。{見方}")
        選べる = (提供元[id].get("vers") or {}).get("list") or []
        データ = next((x for x in 選べる if ファイルのid and x["id"] == ファイルのid), None)
        if データ is None:
            raise ValueError(f"{提供元[id]['name']}のデータ「{ファイルのid}」は選べません。{見方}")
        if not データ.get("now"):
            読むデータ[id] = データ
    return 読むデータ


def 前のデータか(p, データ):
    """選んで前のデータを読むか（記録の old。TS の pickedOld と同じ決まり）。選べるいちばん新しいデータを選んだときは入れない"""
    return データ is not p["vers"]["list"][0]


def 選んだデータの揃え方(揃え方, データ):
    """選んだデータを読むときの揃え方（TS の versionSource と同じ決まり）。読むファイルを指し、形式が違えば形式を替え、Excel なら文字コードの指定を消す"""
    読み = 揃え方["read"]
    if データ.get("format") and データ["format"] != 読み["format"]:
        読み = {**読み, "format": データ["format"], **({"enc": "auto"} if データ["format"] == "xlsx" else {})}
    return {**揃え方, "read": 読み, "ファイル": データ["id"]}


def 外すの形(外す):
    """外す提供元を文字の並びにする"""
    if 外す is None:
        return []
    return [外す] if isinstance(外す, str) else list(外す)


def 別の提供元(読む, 揃え方たち):
    """同じ地域を別の提供元も出している提供元（サイトの lib/pick-region.ts の otherProviders と同じ決まり）。
    読む提供元のうち、市区町村の一覧を県などがまとめた版（area.use が gaps）で、読む市区町村の版が同じ範囲にあるもの"""

    def まとめた版か(s):
        return (s.get("area") or {}).get("use") == "gaps"

    def 届く(s, コード):
        return s["org"].startswith("00") or s["org"][:2] == コード[:2]

    持ち主 = [p["org"] for p in 読む if not 揃え方たち[p["id"]].get("area") and not re.fullmatch("[0-9]{2}000[0-9]", p["org"])]
    return [p for p in 読む if まとめた版か(揃え方たち[p["id"]]) and any(届く(揃え方たち[p["id"]], c) for c in 持ち主)]


def 外せるか確かめる(外す提供元, 読む, 揃え方たち):
    """外す提供元の書き間違いは、取りに行く前に止める。外せるのは、市区町村の一覧を県などがまとめた提供元"""
    読む提供元 = {p["id"] for p in 読む}
    for id in 外す提供元:
        if id not in 読む提供元:
            raise ValueError(f"提供元「{id}」は、選んだ地域で読む提供元にありません")
        if (揃え方たち[id].get("area") or {}).get("use") != "gaps":
            raise ValueError(f"提供元「{id}」は外せません。外せるのは、市区町村の分を県などがまとめた提供元です（表.attrs[\"別の提供元\"]）")


def 重なりを書く(別):
    """同じ場所が重なることを知らせる（決めたこと92）"""
    並び = "、".join(f"{x['提供元']}（{x['id']}）" for x in 別[:10]) + ("ほか" if len(別) > 10 else "")
    print(f"同じ地域を別の提供元も出しています：{並び}。同じ場所が重なることがあります。外すと、自分の一覧がある市区町村は、その一覧だけを読みます（外す=[\"{別[0]['id']}\"]。表.attrs[\"別の提供元\"]）")


def そろえて取る(種類, 地域=None, 区分=None, ファイル=None, 外す=None):
    """そろえた表を取る。種類は datan.種類の一覧() の id、地域は都道府県の2桁と市区町村の6桁の並び（なければ全国）、区分は選ぶ区分の並び。
    ファイルは、最初のデータと違うデータを読む提供元（提供元のid → ファイルのid の辞書。datan.時点の一覧() で見られる）。
    外すは、同じ地域を別の提供元も出しているときに外す提供元の並び（外すと、自分の一覧がある市区町村は、その一覧だけを読む。外せる提供元は 表.attrs["別の提供元"]）。書かなければ全部の行を読む。
    提供元を1つずつ順に中継から取り、この端末でそろえてつなぐ。行ごとに出典の3列（ライセンス、元のページ、DATA-Nのそろえ方）を付ける。
    配っていない提供元は入れない（表.attrs["入れなかった"]）。読めなかった提供元は理由を書いて続ける（表.attrs["読めなかった"]）。
    終わったら、使われ方の記録を1件送る（種類、都道府県、読めた数と読めなかった数。前のデータを読めた提供元があれば、その提供元の id も）。送れなくても止まらない"""
    地域 = 地域の形(地域)
    外す提供元 = 外すの形(外す)  # 引数の「外す」は、読めない提供元を飛ばす例外の「外す」とは別のもの
    提供元たち = 提供元の一覧(種類)
    県たち, 束たち, 参照, 揃え方たち = 地域の束(種類, 地域, 提供元たち)
    形 = 束たち[0]["type"]
    区分の列, 区分の値 = 区分の形(区分, 形)
    決まり = 種類の決まり(形)
    選んだ = 地域を選ぶ(地域, 提供元たち, list(揃え方たち.values()), 参照["市区町村"])
    読む, 入れなかった = 配る提供元に分ける([p for p in 提供元たち if p["id"] in 選んだ and p["id"] in 揃え方たち])
    読むデータ = 読むデータを決める(ファイル, 読む, 種類)
    外せるか確かめる(外す提供元, 読む, 揃え方たち)
    重なる = [{"id": p["id"], "提供元": p["name"]} for p in 別の提供元(読む, 揃え方たち) if p["id"] not in 外す提供元]
    # 自分の版がある市区町村（サイトの prefBundle の own）。外した提供元は、読む市区町村がどれもここにあれば行がないので、取りに行かない
    自分の版 = sorted({c for x in 束たち for c in x.get("own", [])})
    読む = [p for p in 読む if not (p["id"] in 外す提供元 and 選んだ[p["id"]] is not None and 選んだ[p["id"]] <= set(自分の版))]
    if not 読む:
        raise ValueError("外した提供元のほかに、選んだ地域で読む提供元がありません")
    for p in 読む:
        if p["id"] in 読むデータ:
            print(f"{p['name']}は、{時点の言葉(読むデータ[p['id']])}のデータを読みます")
    print(f"{len(読む)}の提供元を順に読みます")
    表たち, 読めなかった, 注意, 前のデータ = [], [], {}, []
    読めた = 0
    前の知らせ = time.monotonic()
    for 何番目, p in enumerate(読む, 1):
        揃え方 = 揃え方たち[p["id"]]
        if p["id"] in 読むデータ:
            揃え方 = 選んだデータの揃え方(揃え方, 読むデータ[p["id"]])
        if p["id"] in 外す提供元:
            揃え方 = {**揃え方, "版のある市区町村": 自分の版}
        読めた表, 読めなかった表 = 提供元をそろえる(揃え方, p, 形, 決まり, 参照)
        読めなかった += 読めなかった表
        読めた += bool(読めた表)
        if 読めた表 and p["id"] in 読むデータ and 前のデータか(p, 読むデータ[p["id"]]):
            前のデータ.append(p["id"])
        if 読めた表 and p.get("notice") in 注意の表:
            注意[p["notice"]] = 注意の表[p["notice"]]
        しぼる = 選んだ[p["id"]]
        for t in 読めた表:
            if しぼる is not None:
                t = t[t["市区町村コード"].isin(しぼる)]
            t = t.assign(**{"ライセンス": p.get("licenseNames", ""), "元のページ": p["page"], "DATA-Nのそろえ方": そろえ方のページ(種類, p["id"])})
            表たち.append(t)
        # 途中の知らせは、10の提供元ごとか、前の知らせから10秒たったとき（47の提供元で80秒ほど何も出なかった）
        if 何番目 < len(読む) and (何番目 % 10 == 0 or time.monotonic() - 前の知らせ >= 10):
            print(f"{len(読む)}のうち{何番目}まで読みました")
            前の知らせ = time.monotonic()
    記録を送る(種類, 県たち, 読めた, len(読む) - 読めた, 前のデータ)
    if not 読めた:
        raise ValueError("読めた提供元がありません（読めなかった理由は上に書いたとおり）")
    行のある = [t for t in 表たち if len(t)]
    表 = pd.concat(行のある or 表たち[:1], ignore_index=True)
    if 区分の列:
        表 = 表[表[区分の列].isin(区分の値)].reset_index(drop=True)
    表.attrs["読めなかった"] = 読めなかった
    表.attrs["入れなかった"] = 入れなかった
    表.attrs["注意"] = list(注意.values())
    表.attrs["別の提供元"] = 重なる
    表.attrs["日時の列"] = 決まり["日時の列"]
    表.attrs["種類"] = 種類
    緯度の列 = [c["name"] for c in 形["columns"] if c["type"] == "lat"]
    位置 = int(表[緯度の列[0]].notna().sum()) if 緯度の列 else 0
    print(f"{読めた}の提供元の{len(表):,}行をそろえました（位置が分かるのは{位置:,}行）")
    if 重なる:
        重なりを書く(重なる)
    注意を書く(表.attrs["注意"])
    return 表


def そろえ方のページ(種類, id):
    """列「DATA-Nのそろえ方」の URL（そろえ方のページ。id から種類の分を除く）"""
    return f"{DATA_N}/data/{種類}/{id.removeprefix(種類 + '-')}/"


def 出典(表):
    """提供元ごとのカタログ、ライセンス、元のページ、そろえ方のページ、行の数の表。使うときは、提供元とライセンスを書き、
    DATA-Nがそろえた（加工した）ことを書く。住所から位置を求めた行があれば、その出典も書く。データの元の注意があれば、原文のまま書く"""
    if 表["位置の出どころ"].astype(str).str.startswith("住所から求めた").any():
        print(住所の位置の出典)
    注意を書く(表.attrs.get("注意", []))
    列 = ["提供元", "カタログ", "ライセンス", "元のページ", "DATA-Nのそろえ方"]
    return 表.groupby(列, dropna=False, sort=False).size().reset_index(name="行の数")


class 説明文(str):
    """そのまま見せる文（ノートの最後の行に書くと、引用符や改行の記号を付けずに出る）"""

    def __repr__(self):
        return str(self)


def 例の言葉(v, 型):
    """値の例1つ（保存と同じ形。改行は空白にし、40字まで）"""
    文字 = " ".join(str(v if isinstance(v, str) else 保存の値(v, 型)).split())
    return 文字 if len(文字) <= 40 else 文字[:39] + "…"


def 型の言葉(列, 型):
    """列の型（数・文字・日付・日時・時刻・年月・真偽）。日付と時間は表.attrs["日時の列"] の型"""
    if 型:
        return 型
    if pd.api.types.is_bool_dtype(列):
        return "真偽"
    if pd.api.types.is_numeric_dtype(列):
        return "数"
    if pd.api.types.is_datetime64_any_dtype(列):
        return "日時"
    if pd.api.types.is_timedelta64_dtype(列):
        return "時刻"
    return "文字"


def 表の説明(表):
    """表の列の名前・型・空でない行の数・値の例3つと出典を、短い文にする。自分の AI にコードを書いてもらうときに、
    そのまま貼れる。文を作るだけで、どこにも送らない"""
    日時の列 = 表.attrs.get("日時の列", {})
    名前 = 種類の表.get(表.attrs.get("種類"), {}).get("名前")
    頭 = f"pandasの表です（{len(表):,}行・{len(表.columns)}列）。"
    if 名前:
        頭 += f"DATA-Nでそろえた「{名前}」のデータです。"
    行たち = [頭, "列（名前：型、空でない行の数、値の例）"]
    for i, 列名 in enumerate(表.columns):
        列 = 表.iloc[:, i]
        型 = 日時の列.get(列名)
        値 = 列.dropna()
        if 値.dtype == object:
            値 = 値[値.astype(str).str.strip() != ""]
        例 = []
        for v in 値.head(1000).tolist():
            言葉 = 例の言葉(v, 型)
            if 言葉 and 言葉 not in 例:
                例.append(言葉)
            if len(例) == 3:
                break
        例の文 = "、例：" + "".join(f"「{x}」" for x in 例) if 例 else ""
        行たち.append(f"- {列名}：{型の言葉(列, 型)}、{len(値):,}行{例の文}")
    if {"提供元", "ライセンス"} <= set(表.columns) and len(表):
        組 = 表.groupby(["提供元", "ライセンス"], dropna=False, sort=False).size().sort_values(ascending=False, kind="stable")
        並び = "、".join(f"{元}（{権利}）" for 元, 権利 in 組.index[:5])
        ほか = f"ほか{len(組) - 5}" if len(組) > 5 else ""
        行たち.append(f"出典：{並び}{ほか}。DATA-Nがそろえた（加工した）表です。")
    return 説明文("\n".join(行たち))


def 保存の欄(文字):
    """CSV の1つの欄（サイトの保存 lib/save.ts の csvCell と同じ決まり）。= か @ で始まる文字は、表計算のソフトが数式として
    動かさないように頭に ' を付ける。区切り・引用符・改行を含むときは引用符で囲む"""
    if 文字[:1] in ("=", "@"):
        文字 = "'" + 文字
    return '"' + 文字.replace('"', '""') + '"' if re.search('[",\r\n]', 文字) else 文字


def 保存の値(v, 型=None):
    """1つの値を、サイトの保存と同じ形の欄にする。時刻「08:30」「25:30」、日付「2026-04-01」、日時「2026-04-01 09:00」、年月「2025-08」、
    数「35.42」「3」、空欄は空の文字。型は「日付」「日時」「時刻」「年月」（分からなければ、タイムスタンプは時刻があるかで決める）"""
    if isinstance(v, str):
        return 保存の欄(v)
    if v is None or (pd.api.types.is_scalar(v) and pd.isna(v)):
        return ""
    if isinstance(v, datetime.timedelta):
        秒 = int(v.total_seconds())
        分 = abs(秒) // 60
        return f"{'-' if 秒 < 0 else ''}{分 // 60:02d}:{分 % 60:02d}"  # 列どうしを引いた値は負になることがある
    if isinstance(v, datetime.datetime):
        年月 = f"{v.year:04d}-{v.month:02d}"
        if 型 == "年月":
            return 年月
        時刻 = f" {v.hour:02d}:{v.minute:02d}" if 型 == "日時" or (型 is None and (v.hour or v.minute)) else ""
        return f"{年月}-{v.day:02d}{時刻}"
    if isinstance(v, float):
        return format(decimal.Decimal(repr(float(v))), "f").removesuffix(".0")
    return 保存の欄(str(v))


def 保存の列(列, 型):
    """1つの列を、欄の並びにする。型が分からないタイムスタンプの列は、時刻のある値があれば日時、なければ日付とする"""
    if 型 is None and pd.api.types.is_datetime64_any_dtype(列):
        値 = 列.dropna()
        型 = "日時" if (値 != 値.dt.normalize()).any() else "日付"
    return [保存の値(v, 型) for v in 列.tolist()]


def CSVに保存(表, ファイル名):
    """表を CSV のファイルに保存する。サイトの保存と同じ形（BOM 付きの UTF-8、行の終わりは CRLF。時刻は「08:30」、日付は「2026-04-01」）。
    pandas の to_csv では、時刻が「0 days 08:30:00」の形になる。表の行と列をしぼったり、列を足したりしてもそのまま保存できる"""
    日時の列 = 表.attrs.get("日時の列", {})
    列たち = [保存の列(表.iloc[:, i], 日時の列.get(名前)) for i, 名前 in enumerate(表.columns)]
    with open(ファイル名, "w", encoding="utf-8-sig", newline="") as f:
        f.write(",".join(保存の欄(str(x)) for x in 表.columns) + "\r\n")
        f.writelines(",".join(r) + "\r\n" for r in zip(*列たち, strict=True))
    print(f"{ファイル名}に{len(表):,}行を保存しました")
