Ignore local scripts and test folders

scripts/generate-hardcore-leaderboard-json.sh

@@ -1,62 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-cd /home/rbatty/.local/share/psopeeps_site
-
-out="site/generated/hardcore-leaderboard-points.json"
-mkdir -p "$(dirname "$out")"
-
-tmp="$(mktemp "${out}.tmp.XXXXXX")"
-trap 'rm -f "$tmp"' EXIT
-
-docker exec -i psopeeps-web-app python - <<'PY' > "$tmp"
-from app import _hc_combined_payload, _hc_points_row
-from datetime import datetime, timezone
-import json
-
-combined, errors = _hc_combined_payload()
-
-rows = []
-for source_row in combined:
-    points_row = _hc_points_row(source_row)
-
-    rows.append({
-        "PlayerName": (
-            points_row.get("PlayerName")
-            or points_row.get("CharacterName")
-            or source_row.get("character_name")
-            or ""
-        ),
-        "Points": int(points_row.get("Points") or points_row.get("TotalPoints") or 0),
-        "Class": (
-            points_row.get("Class")
-            or source_row.get("character_class")
-            or ""
-        ),
-        "SecID": (
-            points_row.get("SecID")
-            or source_row.get("section_id")
-            or ""
-        ),
-        "Kills": int(points_row.get("Kills") or points_row.get("TotalKills") or source_row.get("total_enemies_killed") or 0),
-        "PlayTimeSeconds": int(points_row.get("PlayTimeSeconds") or source_row.get("play_time_seconds") or 0),
-        "Alive": bool(points_row.get("Alive", True)),
-        "Level": int(points_row.get("Level") or source_row.get("level") or 0),
-        "TotalEXP": int(points_row.get("TotalEXP") or source_row.get("total_exp") or 0),
-    })
-
-rows.sort(key=lambda r: r["Points"], reverse=True)
-
-payload = {
-    "generated_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
-    "stale_after_seconds": 600,
-    "errors": errors,
-    "rows": rows[:100],
-}
-
-print(json.dumps(payload, separators=(",", ":")))
-PY
-
-python3 -m json.tool "$tmp" >/dev/null
-mv -f "$tmp" "$out"
-trap - EXIT

scripts/import-newserv-bestiary-tables.py

@@ -1,87 +0,0 @@
-#!/usr/bin/env python3
-import json
-from pathlib import Path
-
-SOURCE = Path("source-bestiary/local-newserv/system/tables/battle-params.json")
-OUT = Path("site/generated/bestiary/bb")
-
-DIFFICULTY_ORDER = {
-    "Normal": 0,
-    "Hard": 1,
-    "Very Hard": 2,
-    "Ultimate": 3,
-}
-
-def label_episode(table_name):
-    ep, mode = table_name.split("-", 1)
-    return ep.replace("Episode", "Episode "), mode
-
-def enemy_label(value):
-    return str(value).replace("_", " ").title()
-
-def main():
-    data = json.loads(SOURCE.read_text())
-    OUT.mkdir(parents=True, exist_ok=True)
-
-    rows = []
-
-    for table_name, difficulties in data.items():
-        episode, mode = label_episode(table_name)
-
-        for difficulty, entries in difficulties.items():
-            for entry in entries:
-                stats = entry.get("Stats", {})
-                resist = entry.get("ResistData", {})
-                enemies = stats.get("Enemies") or []
-
-                for enemy in enemies:
-                    rows.append({
-                        "version": "bb",
-                        "episode": episode,
-                        "mode": mode,
-                        "difficulty": difficulty,
-                        "enemy": enemy_label(enemy),
-                        "enemy_key": enemy,
-                        "bp_index": entry.get("BPIndex"),
-                        "hp": stats.get("HP", 0),
-                        "atp": stats.get("ATP", 0),
-                        "dfp": stats.get("DFP", 0),
-                        "mst": stats.get("MST", 0),
-                        "ata": stats.get("ATA", 0),
-                        "evp": stats.get("EVP", 0),
-                        "lck": stats.get("LCK", 0),
-                        "esp": stats.get("ESP", 0),
-                        "exp": stats.get("EXP", 0),
-                        "meseta": stats.get("Meseta", 0),
-                        "efr": resist.get("EFR", 0),
-                        "eic": resist.get("EIC", 0),
-                        "eth": resist.get("ETH", 0),
-                        "elt": resist.get("ELT", 0),
-                        "edk": resist.get("EDK", 0),
-                    })
-
-    rows.sort(key=lambda row: (
-        row["episode"],
-        row["mode"],
-        DIFFICULTY_ORDER.get(row["difficulty"], 999),
-        row["enemy"],
-        row["bp_index"] if row["bp_index"] is not None else 9999,
-    ))
-
-    (OUT / "bb.json").write_text(json.dumps(rows, indent=2, sort_keys=True) + "\n")
-    (OUT / "index.json").write_text(json.dumps({
-        "mode": "bestiary",
-        "label": "BB",
-        "tables": [{
-            "version": "bb",
-            "label": "BB",
-            "path": "bb.json",
-            "rows": len(rows),
-        }],
-    }, indent=2, sort_keys=True) + "\n")
-
-    print(f"bb: {len(rows)} rows -> {OUT / 'bb.json'}")
-    print(f"index -> {OUT / 'index.json'}")
-
-if __name__ == "__main__":
-    main()

scripts/import-newserv-drop-tables.py

@@ -1,187 +0,0 @@
-#!/usr/bin/env python3
-import json
-import re
-from pathlib import Path
-
-NEWSERV = Path.home() / ".local/share/github/psopeeps-newserv"
-PEEPS_OUT = Path("site/generated/drops/peeps")
-HARDCORE_OUT = Path("site/generated/drops/hardcore")
-
-PEEPS_TABLES = {
-    "v1": NEWSERV / "system/tables/rare-table-v1.json",
-    "v2": NEWSERV / "system/tables/rare-table-v2.json",
-    "v3": NEWSERV / "system/tables/rare-table-v3.json",
-    "bb": NEWSERV / "system/tables/rare-table-v4.json",
-}
-
-HARDCORE_TABLES = {
-    "bb": Path("source-drops/hardcore/rare-table-v4.json"),
-}
-
-def strip_json_comments(text):
-    out = []
-    in_str = False
-    esc = False
-    i = 0
-    while i < len(text):
-        c = text[i]
-        n = text[i + 1] if i + 1 < len(text) else ""
-
-        if in_str:
-            out.append(c)
-            if esc:
-                esc = False
-            elif c == "\\":
-                esc = True
-            elif c == '"':
-                in_str = False
-            i += 1
-            continue
-
-        if c == '"':
-            in_str = True
-            out.append(c)
-            i += 1
-            continue
-
-        if c == "/" and n == "/":
-            while i < len(text) and text[i] not in "\r\n":
-                i += 1
-            continue
-
-        out.append(c)
-        i += 1
-
-    return "".join(out)
-
-def quote_hex_numbers(text):
-    return re.sub(r'(?<!["\w])0x[0-9A-Fa-f]+', lambda m: f'"{m.group(0)}"', text)
-
-
-def remove_trailing_commas(text):
-    out = []
-    in_str = False
-    esc = False
-    i = 0
-
-    while i < len(text):
-        c = text[i]
-
-        if in_str:
-            out.append(c)
-            if esc:
-                esc = False
-            elif c == "\\":
-                esc = True
-            elif c == '"':
-                in_str = False
-            i += 1
-            continue
-
-        if c == '"':
-            in_str = True
-            out.append(c)
-            i += 1
-            continue
-
-        if c == ",":
-            j = i + 1
-            while j < len(text) and text[j] in " \t\r\n":
-                j += 1
-            if j < len(text) and text[j] in "}]":
-                i += 1
-                continue
-
-        out.append(c)
-        i += 1
-
-    return "".join(out)
-
-def load_newserv_jsonish(path):
-    text = path.read_text(encoding="utf-8", errors="replace")
-    text = strip_json_comments(text)
-    text = quote_hex_numbers(text)
-    text = remove_trailing_commas(text)
-    return json.loads(text)
-
-def normalize_item_code(value):
-    if isinstance(value, str) and value.startswith("0x"):
-        return "0x" + value[2:].upper()
-    if isinstance(value, int):
-        return f"0x{value:06X}"
-    return str(value)
-
-def flatten_table(version, table):
-    rows = []
-
-    for game_mode, episodes in table.items():
-        if not isinstance(episodes, dict):
-            continue
-        for episode, difficulties in episodes.items():
-            if not isinstance(difficulties, dict):
-                continue
-            for difficulty, section_ids in difficulties.items():
-                if not isinstance(section_ids, dict):
-                    continue
-                for section_id, sources in section_ids.items():
-                    if not isinstance(sources, dict):
-                        continue
-                    for source, drops in sources.items():
-                        if not isinstance(drops, list):
-                            continue
-                        for drop in drops:
-                            if not isinstance(drop, list) or len(drop) < 2:
-                                continue
-
-                            rows.append({
-                                "version": version,
-                                "mode": str(game_mode),
-                                "episode": str(episode),
-                                "difficulty": str(difficulty),
-                                "section_id": str(section_id),
-                                "source": str(source),
-                                "rate": str(drop[0]),
-                                "item_code": normalize_item_code(drop[1]),
-                                "item": str(drop[2]) if len(drop) >= 3 and drop[2] else "",
-                            })
-
-    return rows
-
-def write_group(mode, label, tables, out_dir):
-    out_dir.mkdir(parents=True, exist_ok=True)
-
-    index = {
-        "mode": mode,
-        "label": label,
-        "tables": [],
-    }
-
-    labels = {"v1": "V1", "v2": "V2", "v3": "V3", "bb": "BB"}
-
-    for version, src in tables.items():
-        table = load_newserv_jsonish(src)
-        rows = flatten_table(version, table)
-
-        out_name = f"{version}.json"
-        out_path = out_dir / out_name
-        out_path.write_text(json.dumps(rows, indent=2, sort_keys=True) + "\n")
-
-        index["tables"].append({
-            "version": version,
-            "label": labels[version],
-            "path": out_name,
-            "rows": len(rows),
-        })
-
-        print(f"{mode} {version}: {len(rows)} rows -> {out_path}")
-
-    index_path = out_dir / "index.json"
-    index_path.write_text(json.dumps(index, indent=2, sort_keys=True) + "\n")
-    print(f"{mode} index -> {index_path}")
-
-def main():
-    write_group("peeps", "Peeps", PEEPS_TABLES, PEEPS_OUT)
-    write_group("hardcore", "Hardcore", HARDCORE_TABLES, HARDCORE_OUT)
-
-if __name__ == "__main__":
-    main()

scripts/write-server-status-json.py

@@ -1,103 +0,0 @@
-#!/usr/bin/env python3
-import json
-import os
-import urllib.parse
-import urllib.request
-from datetime import datetime, timezone
-from pathlib import Path
-
-PROMETHEUS_URL = os.environ.get("PROMETHEUS_URL", "http://5.0.0.20:9090").rstrip("/")
-SOURCE_URL = os.environ.get("SERVER_STATUS_SOURCE_URL", "").strip()
-OUTPUT_PATH = Path(os.environ.get("SERVER_STATUS_JSON", "site/server-status.json"))
-TIMEOUT_SECONDS = float(os.environ.get("PROMETHEUS_TIMEOUT_SECONDS", "5"))
-
-def write_data(data):
-    if not isinstance(data.get("servers"), list):
-        raise SystemExit("server status JSON missing servers array")
-
-    data["generated_at"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-
-    OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)
-    tmp_path = OUTPUT_PATH.with_name(OUTPUT_PATH.name + ".tmp")
-    tmp_path.write_text(json.dumps(data, separators=(",", ":")) + "\n")
-    os.replace(tmp_path, OUTPUT_PATH)
-    print(f"wrote {OUTPUT_PATH}")
-
-def prom_value(query):
-    url = PROMETHEUS_URL + "/api/v1/query?" + urllib.parse.urlencode({"query": query})
-    with urllib.request.urlopen(url, timeout=TIMEOUT_SECONDS) as response:
-        body = json.loads(response.read().decode("utf-8"))
-
-    result = body.get("data", {}).get("result", [])
-    if not result:
-        return 0
-    return int(float(result[0]["value"][1]))
-
-def q(metric, labels):
-    label_text = ",".join(f'{key}="{value}"' for key, value in labels.items())
-    return f"sum({metric}{{{label_text}}}) or vector(0)"
-
-def newserv(region, service, ship, version):
-    return prom_value(q("pso_newserv_clients_connected", {
-        "region": region,
-        "service": service,
-        "ship": ship,
-        "version": version,
-    }))
-
-def adhoc(region, game):
-    return prom_value(q("psppeeps_adhoc_connected_clients_by_product", {
-        "region": region,
-        "service": f"{region}-psppeeps-adhoc",
-        "ship": "psp",
-        "game": game,
-    }))
-
-def row(label, players):
-    return {"label": label, "players": int(players)}
-
-def main():
-    if SOURCE_URL:
-        with urllib.request.urlopen(SOURCE_URL, timeout=TIMEOUT_SECONDS) as response:
-            write_data(json.loads(response.read().decode("utf-8")))
-        return
-
-    us_alis_v2 = newserv("us", "us-newserv-live", "live", "v2")
-    us_alis_v3 = newserv("us", "us-newserv-live", "live", "v3")
-    us_alis_bb = newserv("us", "us-newserv-live", "live", "v4")
-    us_abion_hcbb = newserv("us", "us-newserv-hardcore", "hardcore", "v4")
-    us_adhoc_psp1 = adhoc("us", "psp1")
-    us_adhoc_psp2i = adhoc("us", "psp2i")
-
-    eu_palma_v2 = newserv("eu", "eu-newserv-live", "live", "v2")
-    eu_palma_v3 = newserv("eu", "eu-newserv-live", "live", "v3")
-    eu_palma_bb = newserv("eu", "eu-newserv-live", "live", "v4")
-    eu_aiedo_hcbb = newserv("eu", "eu-newserv-hardcore", "hardcore", "v4")
-    eu_adhoc_psp1 = adhoc("eu", "psp1")
-    eu_adhoc_psp2i = adhoc("eu", "psp2i")
-
-    write_data({
-        "servers": [
-            {
-                "label": "US Server",
-                "players": us_alis_v2 + us_alis_v3 + us_alis_bb + us_abion_hcbb + us_adhoc_psp1 + us_adhoc_psp2i,
-                "ships": [
-                    {"label": "Alis", "rows": [row("V2", us_alis_v2), row("V3", us_alis_v3), row("BB", us_alis_bb)]},
-                    {"label": "Abion", "rows": [row("HC/BB", us_abion_hcbb)]},
-                    {"label": "AdHoc-US", "rows": [row("PSP1", us_adhoc_psp1), row("PSP2i", us_adhoc_psp2i)]},
-                ],
-            },
-            {
-                "label": "EU Server",
-                "players": eu_palma_v2 + eu_palma_v3 + eu_palma_bb + eu_aiedo_hcbb + eu_adhoc_psp1 + eu_adhoc_psp2i,
-                "ships": [
-                    {"label": "Palma", "rows": [row("V2", eu_palma_v2), row("V3", eu_palma_v3), row("BB", eu_palma_bb)]},
-                    {"label": "Aiedo", "rows": [row("HC/BB", eu_aiedo_hcbb)]},
-                    {"label": "AdHoc-EU", "rows": [row("PSP1", eu_adhoc_psp1), row("PSP2i", eu_adhoc_psp2i)]},
-                ],
-            },
-        ],
-    })
-
-if __name__ == "__main__":
-    main()