Fix
This commit is contained in:
devRaGonSa
448
backend/app/rcon_scoreboard_correlation.py
Normal file
448
backend/app/rcon_scoreboard_correlation.py
Normal file
@@ -0,0 +1,448 @@
|
||||
"""Correlate RCON competitive windows with trusted persisted scoreboard matches."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sqlite3
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
from .config import get_storage_path, use_postgres_rcon_storage
|
||||
from .normalizers import normalize_map_name
|
||||
from .scoreboard_origins import resolve_trusted_scoreboard_match_url
|
||||
from .sqlite_utils import connect_sqlite_readonly
|
||||
|
||||
|
||||
MIN_CONFIDENCE_SCORE = 5
|
||||
MAX_CANDIDATES = 200
|
||||
|
||||
|
||||
def resolve_rcon_scoreboard_match_url(
|
||||
*,
|
||||
server_slug: object,
|
||||
map_name: object,
|
||||
started_at: object,
|
||||
ended_at: object,
|
||||
duration_seconds: object = None,
|
||||
player_count: object = None,
|
||||
peak_players: object = None,
|
||||
allied_score: object = None,
|
||||
axis_score: object = None,
|
||||
db_path: Path | None = None,
|
||||
) -> str | None:
|
||||
"""Return a trusted scoreboard URL for an RCON window only on strong evidence."""
|
||||
resolution = resolve_rcon_scoreboard_correlation(
|
||||
server_slug=server_slug,
|
||||
map_name=map_name,
|
||||
started_at=started_at,
|
||||
ended_at=ended_at,
|
||||
duration_seconds=duration_seconds,
|
||||
player_count=player_count,
|
||||
peak_players=peak_players,
|
||||
allied_score=allied_score,
|
||||
axis_score=axis_score,
|
||||
db_path=db_path,
|
||||
)
|
||||
match_url = resolution.get("match_url")
|
||||
return str(match_url) if match_url else None
|
||||
|
||||
|
||||
def resolve_rcon_scoreboard_correlation(
|
||||
*,
|
||||
server_slug: object,
|
||||
map_name: object,
|
||||
started_at: object,
|
||||
ended_at: object,
|
||||
duration_seconds: object = None,
|
||||
player_count: object = None,
|
||||
peak_players: object = None,
|
||||
allied_score: object = None,
|
||||
axis_score: object = None,
|
||||
db_path: Path | None = None,
|
||||
) -> dict[str, object]:
|
||||
"""Return a safe candidate selection summary for one RCON match window."""
|
||||
normalized_server_slug = str(server_slug or "").strip()
|
||||
normalized_map = normalize_map_name(map_name)
|
||||
rcon_start = _parse_timestamp(started_at)
|
||||
rcon_end = _parse_timestamp(ended_at)
|
||||
if not normalized_server_slug or not normalized_map or not rcon_start or not rcon_end:
|
||||
return {"match_url": None, "candidate_count": 0, "reason": "invalid-rcon-window"}
|
||||
if rcon_end < rcon_start:
|
||||
rcon_start, rcon_end = rcon_end, rcon_start
|
||||
|
||||
candidates = _list_persisted_scoreboard_candidates(
|
||||
server_slug=normalized_server_slug,
|
||||
db_path=db_path or get_storage_path(),
|
||||
)
|
||||
scored_candidates = [
|
||||
scored
|
||||
for candidate in candidates
|
||||
if (scored := _score_candidate(
|
||||
candidate,
|
||||
normalized_map=normalized_map,
|
||||
rcon_start=rcon_start,
|
||||
rcon_end=rcon_end,
|
||||
duration_seconds=_coerce_int(duration_seconds),
|
||||
player_count=_coerce_int(player_count),
|
||||
peak_players=_coerce_int(peak_players),
|
||||
allied_score=_coerce_int(allied_score),
|
||||
axis_score=_coerce_int(axis_score),
|
||||
))
|
||||
is not None
|
||||
]
|
||||
if not scored_candidates:
|
||||
return {
|
||||
"match_url": None,
|
||||
"candidate_count": len(candidates),
|
||||
"reason": "no-safe-candidate",
|
||||
}
|
||||
|
||||
scored_candidates.sort(key=lambda item: item["score"], reverse=True)
|
||||
best = scored_candidates[0]
|
||||
if int(best["score"]) < MIN_CONFIDENCE_SCORE:
|
||||
return {
|
||||
"match_url": None,
|
||||
"candidate_count": len(candidates),
|
||||
"reason": "low-confidence",
|
||||
}
|
||||
if len(scored_candidates) > 1 and int(scored_candidates[1]["score"]) >= int(best["score"]):
|
||||
return {
|
||||
"match_url": None,
|
||||
"candidate_count": len(candidates),
|
||||
"reason": "ambiguous-candidate",
|
||||
}
|
||||
return {
|
||||
"match_url": str(best["match_url"]),
|
||||
"candidate_count": len(candidates),
|
||||
"reason": "linked",
|
||||
"selected_candidate": {
|
||||
"external_match_id": best.get("external_match_id"),
|
||||
"correlation_score": int(best["score"]),
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def diagnose_rcon_scoreboard_correlation(
|
||||
*,
|
||||
server_slug: object,
|
||||
map_name: object,
|
||||
started_at: object,
|
||||
ended_at: object,
|
||||
duration_seconds: object = None,
|
||||
player_count: object = None,
|
||||
peak_players: object = None,
|
||||
allied_score: object = None,
|
||||
axis_score: object = None,
|
||||
db_path: Path | None = None,
|
||||
) -> dict[str, object]:
|
||||
"""Describe safe candidate scoring for a single RCON correlation window."""
|
||||
normalized_server_slug = str(server_slug or "").strip()
|
||||
normalized_map = normalize_map_name(map_name)
|
||||
rcon_start = _parse_timestamp(started_at)
|
||||
rcon_end = _parse_timestamp(ended_at)
|
||||
if not normalized_server_slug or not normalized_map or not rcon_start or not rcon_end:
|
||||
return {
|
||||
"candidate_search_window": {
|
||||
"started_at": started_at,
|
||||
"ended_at": ended_at,
|
||||
"candidate_limit": MAX_CANDIDATES,
|
||||
},
|
||||
"candidate_count": 0,
|
||||
"top_candidates": [],
|
||||
"selected_candidate": None,
|
||||
"final_reason": "invalid-rcon-window",
|
||||
}
|
||||
if rcon_end < rcon_start:
|
||||
rcon_start, rcon_end = rcon_end, rcon_start
|
||||
|
||||
candidates = _list_persisted_scoreboard_candidates(
|
||||
server_slug=normalized_server_slug,
|
||||
db_path=db_path or get_storage_path(),
|
||||
)
|
||||
resolution = resolve_rcon_scoreboard_correlation(
|
||||
server_slug=server_slug,
|
||||
map_name=map_name,
|
||||
started_at=started_at,
|
||||
ended_at=ended_at,
|
||||
duration_seconds=duration_seconds,
|
||||
player_count=player_count,
|
||||
peak_players=peak_players,
|
||||
allied_score=allied_score,
|
||||
axis_score=axis_score,
|
||||
db_path=db_path,
|
||||
)
|
||||
summaries = [
|
||||
_diagnostic_candidate_summary(
|
||||
candidate,
|
||||
server_slug=normalized_server_slug,
|
||||
normalized_map=normalized_map,
|
||||
rcon_start=rcon_start,
|
||||
rcon_end=rcon_end,
|
||||
duration_seconds=_coerce_int(duration_seconds),
|
||||
player_count=_coerce_int(player_count),
|
||||
peak_players=_coerce_int(peak_players),
|
||||
allied_score=_coerce_int(allied_score),
|
||||
axis_score=_coerce_int(axis_score),
|
||||
)
|
||||
for candidate in candidates
|
||||
]
|
||||
summaries.sort(
|
||||
key=lambda item: (
|
||||
-int(item["correlation_score"] or -1),
|
||||
str(item.get("external_match_id") or ""),
|
||||
)
|
||||
)
|
||||
selected_id = (
|
||||
resolution.get("selected_candidate", {}).get("external_match_id")
|
||||
if isinstance(resolution.get("selected_candidate"), dict)
|
||||
else None
|
||||
)
|
||||
selected_candidate = next(
|
||||
(item for item in summaries if item.get("external_match_id") == selected_id),
|
||||
None,
|
||||
)
|
||||
return {
|
||||
"candidate_search_window": {
|
||||
"started_at": rcon_start.isoformat().replace("+00:00", "Z"),
|
||||
"ended_at": rcon_end.isoformat().replace("+00:00", "Z"),
|
||||
"candidate_limit": MAX_CANDIDATES,
|
||||
},
|
||||
"candidate_count": len(candidates),
|
||||
"top_candidates": summaries[:5],
|
||||
"selected_candidate": selected_candidate,
|
||||
"final_reason": resolution["reason"],
|
||||
}
|
||||
|
||||
|
||||
def _list_persisted_scoreboard_candidates(
|
||||
*,
|
||||
server_slug: str,
|
||||
db_path: Path,
|
||||
) -> list[dict[str, object]]:
|
||||
if use_postgres_rcon_storage():
|
||||
from .postgres_rcon_storage import list_scoreboard_candidates
|
||||
|
||||
postgres_candidates = list_scoreboard_candidates(
|
||||
server_slug=server_slug,
|
||||
limit=MAX_CANDIDATES,
|
||||
)
|
||||
if postgres_candidates:
|
||||
return postgres_candidates
|
||||
|
||||
try:
|
||||
with connect_sqlite_readonly(db_path) as connection:
|
||||
rows = connection.execute(
|
||||
"""
|
||||
SELECT
|
||||
historical_matches.external_match_id,
|
||||
historical_matches.started_at,
|
||||
historical_matches.ended_at,
|
||||
historical_matches.map_name,
|
||||
historical_matches.map_pretty_name,
|
||||
historical_matches.allied_score,
|
||||
historical_matches.axis_score,
|
||||
historical_matches.raw_payload_ref,
|
||||
historical_servers.slug AS server_slug,
|
||||
COUNT(historical_player_match_stats.id) AS player_count
|
||||
FROM historical_matches
|
||||
INNER JOIN historical_servers
|
||||
ON historical_servers.id = historical_matches.historical_server_id
|
||||
LEFT JOIN historical_player_match_stats
|
||||
ON historical_player_match_stats.historical_match_id = historical_matches.id
|
||||
WHERE historical_servers.slug = ?
|
||||
AND historical_matches.raw_payload_ref IS NOT NULL
|
||||
GROUP BY historical_matches.id
|
||||
ORDER BY COALESCE(historical_matches.ended_at, historical_matches.started_at) DESC
|
||||
LIMIT ?
|
||||
""",
|
||||
(server_slug, MAX_CANDIDATES),
|
||||
).fetchall()
|
||||
except sqlite3.Error:
|
||||
return []
|
||||
|
||||
items: list[dict[str, object]] = []
|
||||
for row in rows:
|
||||
match_url = resolve_trusted_scoreboard_match_url(
|
||||
row["raw_payload_ref"],
|
||||
row["server_slug"],
|
||||
)
|
||||
if not match_url:
|
||||
continue
|
||||
items.append(
|
||||
{
|
||||
"external_match_id": row["external_match_id"],
|
||||
"started_at": row["started_at"],
|
||||
"ended_at": row["ended_at"],
|
||||
"map_name": row["map_name"],
|
||||
"map_pretty_name": row["map_pretty_name"],
|
||||
"allied_score": row["allied_score"],
|
||||
"axis_score": row["axis_score"],
|
||||
"player_count": row["player_count"],
|
||||
"match_url": match_url,
|
||||
}
|
||||
)
|
||||
if items and use_postgres_rcon_storage():
|
||||
from .postgres_rcon_storage import upsert_scoreboard_candidates
|
||||
|
||||
upsert_scoreboard_candidates(server_slug=server_slug, candidates=items)
|
||||
return items
|
||||
|
||||
|
||||
def _score_candidate(
|
||||
candidate: dict[str, object],
|
||||
*,
|
||||
normalized_map: str,
|
||||
rcon_start: datetime,
|
||||
rcon_end: datetime,
|
||||
duration_seconds: int | None,
|
||||
player_count: int | None,
|
||||
peak_players: int | None,
|
||||
allied_score: int | None,
|
||||
axis_score: int | None,
|
||||
) -> dict[str, object] | None:
|
||||
candidate_map = normalize_map_name(
|
||||
candidate.get("map_pretty_name") or candidate.get("map_name")
|
||||
)
|
||||
if candidate_map != normalized_map:
|
||||
return None
|
||||
|
||||
candidate_start = _parse_timestamp(candidate.get("started_at"))
|
||||
candidate_end = _parse_timestamp(candidate.get("ended_at"))
|
||||
if not candidate_start or not candidate_end:
|
||||
return None
|
||||
if candidate_end < candidate_start:
|
||||
candidate_start, candidate_end = candidate_end, candidate_start
|
||||
|
||||
score = 0
|
||||
overlap_seconds = _overlap_seconds(rcon_start, rcon_end, candidate_start, candidate_end)
|
||||
rcon_midpoint = rcon_start + (rcon_end - rcon_start) / 2
|
||||
if overlap_seconds > 0:
|
||||
score += 3
|
||||
if candidate_start <= rcon_midpoint <= candidate_end:
|
||||
score += 2
|
||||
|
||||
closest_edge_distance = min(
|
||||
abs((rcon_start - candidate_start).total_seconds()),
|
||||
abs((rcon_start - candidate_end).total_seconds()),
|
||||
abs((rcon_end - candidate_start).total_seconds()),
|
||||
abs((rcon_end - candidate_end).total_seconds()),
|
||||
)
|
||||
if closest_edge_distance <= 1800:
|
||||
score += 2
|
||||
elif closest_edge_distance <= 3600:
|
||||
score += 1
|
||||
|
||||
candidate_duration = int((candidate_end - candidate_start).total_seconds())
|
||||
if duration_seconds and candidate_duration > 0:
|
||||
if abs(candidate_duration - duration_seconds) <= 1800:
|
||||
score += 1
|
||||
elif overlap_seconds > 0 and duration_seconds <= candidate_duration:
|
||||
score += 1
|
||||
|
||||
candidate_allied_score = _coerce_int(candidate.get("allied_score"))
|
||||
candidate_axis_score = _coerce_int(candidate.get("axis_score"))
|
||||
if (
|
||||
allied_score is not None
|
||||
and axis_score is not None
|
||||
and candidate_allied_score is not None
|
||||
and candidate_axis_score is not None
|
||||
):
|
||||
if candidate_allied_score == allied_score and candidate_axis_score == axis_score:
|
||||
score += 2
|
||||
elif sorted((candidate_allied_score, candidate_axis_score)) == sorted((allied_score, axis_score)):
|
||||
score += 1
|
||||
|
||||
candidate_players = _coerce_int(candidate.get("player_count"))
|
||||
reference_players = peak_players or player_count
|
||||
if candidate_players and reference_players:
|
||||
if abs(candidate_players - reference_players) <= 20:
|
||||
score += 1
|
||||
elif candidate_players >= int(reference_players * 0.75):
|
||||
score += 1
|
||||
|
||||
if score <= 0:
|
||||
return None
|
||||
return {
|
||||
"score": score,
|
||||
"external_match_id": candidate.get("external_match_id"),
|
||||
"match_url": candidate["match_url"],
|
||||
}
|
||||
|
||||
|
||||
def _diagnostic_candidate_summary(
|
||||
candidate: dict[str, object],
|
||||
*,
|
||||
server_slug: str,
|
||||
normalized_map: str,
|
||||
rcon_start: datetime,
|
||||
rcon_end: datetime,
|
||||
duration_seconds: int | None,
|
||||
player_count: int | None,
|
||||
peak_players: int | None,
|
||||
allied_score: int | None,
|
||||
axis_score: int | None,
|
||||
) -> dict[str, object]:
|
||||
match_url = resolve_trusted_scoreboard_match_url(candidate.get("match_url"), server_slug)
|
||||
safe_candidate = {**candidate, "match_url": match_url} if match_url else None
|
||||
scored = (
|
||||
_score_candidate(
|
||||
safe_candidate,
|
||||
normalized_map=normalized_map,
|
||||
rcon_start=rcon_start,
|
||||
rcon_end=rcon_end,
|
||||
duration_seconds=duration_seconds,
|
||||
player_count=player_count,
|
||||
peak_players=peak_players,
|
||||
allied_score=allied_score,
|
||||
axis_score=axis_score,
|
||||
)
|
||||
if safe_candidate
|
||||
else None
|
||||
)
|
||||
map_label = candidate.get("map_pretty_name") or candidate.get("map_name")
|
||||
summary = {
|
||||
"external_match_id": candidate.get("external_match_id"),
|
||||
"started_at": candidate.get("started_at"),
|
||||
"ended_at": candidate.get("ended_at"),
|
||||
"map": map_label,
|
||||
"score": {
|
||||
"allied_score": _coerce_int(candidate.get("allied_score")),
|
||||
"axis_score": _coerce_int(candidate.get("axis_score")),
|
||||
},
|
||||
"match_url": match_url,
|
||||
"correlation_score": int(scored["score"]) if scored else None,
|
||||
}
|
||||
if not match_url:
|
||||
summary["rejection_reason"] = "unsafe-url"
|
||||
elif scored is None:
|
||||
summary["rejection_reason"] = "map-or-window-mismatch"
|
||||
return summary
|
||||
|
||||
|
||||
def _overlap_seconds(
|
||||
first_start: datetime,
|
||||
first_end: datetime,
|
||||
second_start: datetime,
|
||||
second_end: datetime,
|
||||
) -> int:
|
||||
return max(0, int((min(first_end, second_end) - max(first_start, second_start)).total_seconds()))
|
||||
|
||||
|
||||
def _parse_timestamp(value: object) -> datetime | None:
|
||||
if not isinstance(value, str) or not value.strip():
|
||||
return None
|
||||
try:
|
||||
parsed = datetime.fromisoformat(value.strip().replace("Z", "+00:00"))
|
||||
except ValueError:
|
||||
return None
|
||||
if parsed.tzinfo is None:
|
||||
parsed = parsed.replace(tzinfo=timezone.utc)
|
||||
return parsed.astimezone(timezone.utc)
|
||||
|
||||
|
||||
def _coerce_int(value: object) -> int | None:
|
||||
if value is None:
|
||||
return None
|
||||
try:
|
||||
return int(round(float(value)))
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
Reference in New Issue
Block a user