korb 0.2.8__tar.gz → 0.2.9__tar.gz

{korb-0.2.8 → korb-0.2.9}/.gitignore

@@ -6,6 +6,11 @@ __pycache__/
 dist/
 build/
 
+# Coverage
+.coverage
+.coverage.*
+htmlcov/
+
 # Lock file
 uv.lock
 

{korb-0.2.8 → korb-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: korb
-Version: 0.2.8
+Version: 0.2.9
 Summary: A CLI toolkit for DBB basketball league analysis
 Project-URL: Homepage, https://github.com/malvavisc0/korb
 Project-URL: Repository, https://github.com/malvavisc0/korb

korb-0.2.9/korb/__init__.py

@@ -0,0 +1,6 @@
+"""Basketball league analysis package for DBB (Deutscher Basketball Bund).
+
+Target: DBB Version ≤11.50.1-2f7f327 (legacy JSP platform).
+"""
+
+__version__ = "0.2.9"

{korb-0.2.8 → korb-0.2.9}/korb/__main__.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Basketball league CLI for DBB (Deutscher Basketball Bund) data.
 
-Target: DBB Version ≤11.50.0-623b018 (legacy JSP platform).
+Target: DBB Version ≤11.50.1-2f7f327 (legacy JSP platform).
 """
 
 import argparse
@@ -26,7 +26,7 @@ from .schedule import (
     parse_schedule,
     print_schedule,
 )
-from .standings import calculate_standings, print_table
+from .standings import Standing, calculate_standings, print_table
 from .team import get_team_results, print_bars, print_metrics, print_results
 
 
@@ -38,7 +38,7 @@ def _json_out(data: object) -> None:
 def _liga_meta(
     league_info: LeagueInfo,
     ligaid: int | None,
-) -> dict:
+) -> dict[str, object]:
     """Build liga metadata dict for JSON output.
 
     Args:
@@ -54,18 +54,41 @@ def _liga_meta(
     }
 
 
+def _resolve_path(
+    explicit: str | None, ligaid: int | None, filename: str, flag: str, label: str
+) -> str:
+    """Resolve an HTML path from an explicit flag value or --ligaid.
+
+    Exits with an error if neither is provided.
+    """
+    if explicit is not None:
+        return explicit
+    if ligaid is None:
+        print(
+            f"Error: pass {flag} PATH or --ligaid LIGAID for {label}.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    return str(Path("files") / str(ligaid) / filename)
+
+
+def _resolve_results(args: argparse.Namespace, label: str) -> str:
+    """Resolve the results HTML path from --results or --ligaid."""
+    return _resolve_path(
+        args.results, args.ligaid, "ergebnisse.html", "--results", label
+    )
+
+
+def _resolve_schedule(args: argparse.Namespace, label: str) -> str:
+    """Resolve the schedule HTML path from --schedule or --ligaid."""
+    return _resolve_path(
+        args.schedule, args.ligaid, "spielplan.html", "--schedule", label
+    )
+
+
 def cmd_standings(args: argparse.Namespace) -> None:
     """Handle 'standings' subcommand."""
-    fp = args.results
-    if fp is None:
-        if args.ligaid is None:
-            print(
-                "Error: pass --results PATH or --ligaid LIGAID for standings.",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        fp = str(Path("files") / str(args.ligaid) / "ergebnisse.html")
-
+    fp = _resolve_results(args, "standings")
     standings, league_info = calculate_standings(fp)
     if args.json:
         _json_out(
@@ -80,16 +103,7 @@ def cmd_standings(args: argparse.Namespace) -> None:
 
 def cmd_team(args: argparse.Namespace) -> None:
     """Handle 'team' subcommand."""
-    fp = args.results
-    if fp is None:
-        if args.ligaid is None:
-            print(
-                "Error: pass --results PATH or --ligaid LIGAID for team results.",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        fp = str(Path("files") / str(args.ligaid) / "ergebnisse.html")
-
+    fp = _resolve_results(args, "team results")
     results, league_info = get_team_results(args.name, fp)
     if args.json:
         data = [r.to_dict() for r in results]
@@ -112,16 +126,7 @@ def cmd_team(args: argparse.Namespace) -> None:
 
 def cmd_ergebnisse(args: argparse.Namespace) -> None:
     """Handle 'ergebnisse' subcommand."""
-    fp = args.results
-    if fp is None:
-        if args.ligaid is None:
-            print(
-                "Error: pass --results PATH or --ligaid LIGAID for ergebnisse.",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        fp = str(Path("files") / str(args.ligaid) / "ergebnisse.html")
-
+    fp = _resolve_results(args, "ergebnisse")
     games, league_info = read_games(fp)
     filtered = filter_ergebnisse(games, team=args.team)
     filtered.sort(key=lambda g: g.date)
@@ -147,16 +152,7 @@ def cmd_ergebnisse(args: argparse.Namespace) -> None:
 
 def cmd_schedule(args: argparse.Namespace) -> None:
     """Handle 'schedule' subcommand."""
-    html = args.schedule
-    if html is None:
-        if args.ligaid is None:
-            print(
-                "Error: pass --schedule PATH or --ligaid LIGAID for schedule.",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        html = str(Path("files") / str(args.ligaid) / "spielplan.html")
-
+    html = _resolve_schedule(args, "schedule")
     games, league_info = parse_schedule(html)
     filtered = filter_schedule(
         games, show_all=args.all, pending=args.pending, team=args.team
@@ -189,7 +185,7 @@ def cmd_predict(args: argparse.Namespace) -> None:
         sp = sp or str(base / "spielplan.html")
 
     # Check if season is finalized
-    finalized, pending_count = is_season_finalized(sp)
+    finalized, _pending_count = is_season_finalized(sp)
     if finalized:
         print(
             "Error: Season is finalized (no pending games). "
@@ -227,32 +223,8 @@ def _blocks(value: int, scale: int) -> str:
     return "█" * max(0, value // scale)
 
 
-def cmd_top(args: argparse.Namespace) -> None:
-    """Handle 'top' subcommand."""
-
-    fp = args.results
-    if fp is None:
-        if args.ligaid is None:
-            print(
-                "Error: pass --results PATH or --ligaid LIGAID for top.",
-                file=sys.stderr,
-            )
-            sys.exit(1)
-        fp = str(Path("files") / str(args.ligaid) / "ergebnisse.html")
-
-    standings, league_info = calculate_standings(fp)
-    top = standings[: args.n]
-
-    if args.json:
-        _json_out(
-            {
-                **_liga_meta(league_info, args.ligaid),
-                "top": [s.to_dict() for s in top],
-            }
-        )
-        return
-
-    tw = max(4, max(len(s.name) for s in top))
+def _print_top_table(top: list[Standing], tw: int) -> None:
+    """Print the ranked top-teams table."""
     print("\n" + "=" * 70)
     print("  Top Teams — current table")
     print("=" * 70)
@@ -262,22 +234,44 @@ def cmd_top(args: argparse.Namespace) -> None:
     print("-" * len(hdr))
     for i, s in enumerate(top, 1):
         st = s.stats
-        diff = st.diff
-        diff_str = f"+{diff}" if diff > 0 else str(diff)
+        diff_str = f"+{st.diff}" if st.diff > 0 else str(st.diff)
         print(f"{i:>2}  {s.name:<{tw}}  {st.gp:>2}  {st.pts:>3}  {diff_str:>5}")
 
+
+def _print_points_chart(top: list[Standing], tw: int) -> None:
+    """Print the ASCII points bar chart for the top teams."""
     pts_vals = [s.stats.pts for s in top]
     max_pts = max(pts_vals) if pts_vals else 0
+    # Keep chart readable: 1 block per 1–2 points depending on scale.
     scale = 1 if max_pts <= 20 else max(1, max_pts // 20)
     print("\nStandings Points (scaled)")
     print("─────────────────────────")
     for s in top:
-        st = s.stats
-        pts = st.pts
+        pts = s.stats.pts
         print(f"{s.name:<{tw}}  {_blocks(pts, scale):<22}  {pts}")
     print(f"(scale: 1 block ≈ {scale} pts)")
 
 
+def cmd_top(args: argparse.Namespace) -> None:
+    """Handle 'top' subcommand."""
+    fp = _resolve_results(args, "top")
+    standings, league_info = calculate_standings(fp)
+    top = standings[: args.n]
+
+    if args.json:
+        _json_out(
+            {
+                **_liga_meta(league_info, args.ligaid),
+                "top": [s.to_dict() for s in top],
+            }
+        )
+        return
+
+    tw = max(4, max(len(s.name) for s in top))
+    _print_top_table(top, tw)
+    _print_points_chart(top, tw)
+
+
 _BASE = "https://www.basketball-bund.net/public"
 _RESULTS_URL = (
     f"{_BASE}/ergebnisse.jsp?print=1"

{korb-0.2.8 → korb-0.2.9}/korb/core.py

@@ -1,7 +1,7 @@
 """Shared models and utilities for DBB (Deutscher Basketball Bund) analysis.
 
 Provides common types, HTML parsing, and date helpers used across modules.
-Target: DBB Version ≤11.50.0-623b018 (legacy JSP platform).
+Target: DBB Version ≤11.50.1-2f7f327 (legacy JSP platform).
 """
 
 import re
@@ -10,8 +10,11 @@ from dataclasses import dataclass
 from datetime import datetime
 from html.parser import HTMLParser
 from typing import Final
+from zoneinfo import ZoneInfo
 
 DATE_FMT: Final[str] = "%d.%m.%Y %H:%M"
+# DBB schedule times are local German wall-clock times.
+LOCAL_TZ: Final[ZoneInfo] = ZoneInfo("Europe/Berlin")
 _LEAGUE_FALLBACK: Final[str] = "Basketball League"
 
 # Regex for league name in DBB HTML titles like:
@@ -30,7 +33,7 @@ class LeagueInfo:
     name: str
     number: int | None = None
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, object]:
         """Serializable dict."""
         return {"liga_name": self.name, "liga_number": self.number}
 
@@ -46,26 +49,28 @@ class Game:
     away_score: int
 
 
-def parse_date(date_str: str) -> datetime | None:
+def parse_date(date_str: str | None) -> datetime | None:
     """Parse date string in format 'DD.MM.YYYY HH:MM'.
 
     Args:
-        date_str: Date string to parse.
+        date_str: Date string to parse, or None.
 
     Returns:
         Parsed datetime or None if invalid format.
     """
+    if date_str is None:
+        return None
     try:
-        return datetime.strptime(date_str.strip(), DATE_FMT)
-    except (ValueError, AttributeError):
+        return datetime.strptime(date_str.strip(), DATE_FMT).replace(tzinfo=LOCAL_TZ)
+    except ValueError:
         return None
 
 
-def parse_score(score_str: str) -> tuple[int | None, int | None]:
+def parse_score(score_str: str | None) -> tuple[int | None, int | None]:
     """Parse score string in format '79 : 75'.
 
     Args:
-        score_str: Score string to parse.
+        score_str: Score string to parse, or None.
 
     Returns:
         Tuple of (home_score, away_score) or (None, None) if invalid.
@@ -101,12 +106,11 @@ def read_file_safe(filepath: str) -> str:
         sys.exit(1)
 
 
-class _HTMLResultsParser(HTMLParser):
-    """Parse basketball-bund.net HTML results tables."""
+class _DBBRowParser(HTMLParser):
+    """Shared <td>/<tr>/<strike> row-scanning state machine for DBB HTML tables."""
 
     def __init__(self) -> None:
         super().__init__()
-        self.games: list[Game] = []
         self._in_td = False
         self._td_depth = 0
         self._cells: list[str] = []
@@ -137,6 +141,17 @@ class _HTMLResultsParser(HTMLParser):
         if self._in_td and self._td_depth == 1:
             self._current_cell += data
 
+    def _finalize_row(self) -> None:
+        raise NotImplementedError
+
+
+class _HTMLResultsParser(_DBBRowParser):
+    """Parse basketball-bund.net HTML results tables."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.games: list[Game] = []
+
     def _finalize_row(self) -> None:
         """Parse completed row into Game if valid."""
         if len(self._cells) < 6 or self._row_cancelled:

{korb-0.2.8 → korb-0.2.9}/korb/ergebnisse.py

@@ -1,7 +1,7 @@
 """Game results viewer for DBB (Deutscher Basketball Bund) data.
 
 Displays all completed game results for a league with optional team filter.
-Target: DBB Version ≤11.50.0-623b018 (legacy JSP platform).
+Target: DBB Version ≤11.50.1-2f7f327 (legacy JSP platform).
 """
 
 from korb.core import Game, print_header

{korb-0.2.8 → korb-0.2.9}/korb/predict.py

@@ -3,7 +3,7 @@
 Uses a multiplicative efficiency model: each team's offensive and
 defensive ratings (relative to league average) are multiplied to
 predict matchup scores.  Recent games are weighted more heavily.
-Target: DBB Version ≤11.50.0-623b018 (legacy JSP platform).
+Target: DBB Version ≤11.50.1-2f7f327 (legacy JSP platform).
 """
 
 from collections import defaultdict
@@ -37,8 +37,7 @@ def _recency_weight(game: Game, ref_ts: float) -> float:
         Weight between 0 and 1, decreasing with age.
     """
     days_ago = (ref_ts - game.date.timestamp()) / 86400
-    if days_ago < 0:
-        days_ago = 0
+    days_ago = max(days_ago, 0)
     return exp(-0.693 * days_ago / RECENCY_HALF_LIFE)
 
 
@@ -166,9 +165,9 @@ def _build_ratings(
         Dict mapping team name to (off_rating, pts_allowed_rating).
     """
     ratings: dict[str, tuple[float, float]] = {}
-    for name in w_gp:
-        avg_pf = w_pf[name] / w_gp[name]
-        avg_pa = w_pa[name] / w_gp[name]
+    for name, gp_weight in w_gp.items():
+        avg_pf = w_pf[name] / gp_weight
+        avg_pa = w_pa[name] / gp_weight
         raw_off = avg_pf / league_avg
         raw_def = avg_pa / league_avg
 
@@ -244,6 +243,69 @@ def predict_game(
     return "away", ph, pa
 
 
+def _copy_stats(teams_base: dict[str, TeamStats]) -> dict[str, TeamStats]:
+    """Deep-copy current team stats into a fresh defaultdict."""
+    teams: dict[str, TeamStats] = defaultdict(TeamStats)
+    for name, st in teams_base.items():
+        t = teams[name]
+        t.gp, t.w, t.l, t.d, t.pf, t.pa = st.gp, st.w, st.l, st.d, st.pf, st.pa
+    return teams
+
+
+def _pending_games(html_path: str, played: list[Game]) -> list[ScheduledGame]:
+    """Return future scheduled games not already present in results."""
+    played_keys = {(g.home, g.away, g.date.strftime("%d.%m.%Y")) for g in played}
+    schedule, _ = parse_schedule(html_path)
+    pending = [
+        g
+        for g in filter_schedule(schedule, pending=True)
+        if (g.home, g.away, g.date.strftime("%d.%m.%Y")) not in played_keys
+    ]
+    pending.sort(key=lambda g: g.date)
+    return pending
+
+
+def _last_game_times(played: list[Game]) -> dict[str, float]:
+    """Map each team to the timestamp of its most recent played game."""
+    last_game_ts: dict[str, float] = {}
+    for g in played:
+        ts = g.date.timestamp()
+        for name in (g.home, g.away):
+            if ts > last_game_ts.get(name, 0):
+                last_game_ts[name] = ts
+    return last_game_ts
+
+
+def _fatigue(
+    name: str, gt: float, last_game_ts: dict[str, float], threshold_s: float
+) -> float:
+    """Return the fatigue multiplier for a team playing at time ``gt``."""
+    if name in last_game_ts and (gt - last_game_ts[name]) <= threshold_s:
+        return FATIGUE_PENALTY
+    return 1.0
+
+
+def _apply_result(
+    home: TeamStats, away: TeamStats, winner: str, hs: int, as_: int
+) -> None:
+    """Update both teams' stats with a predicted game result."""
+    home.gp += 1
+    away.gp += 1
+    home.pf += hs
+    home.pa += as_
+    away.pf += as_
+    away.pa += hs
+    if winner == "home":
+        home.w += 1
+        away.l += 1
+    elif winner == "away":
+        away.w += 1
+        home.l += 1
+    else:
+        home.d += 1
+        away.d += 1
+
+
 def predict_standings(
     results_path: str,
     html_path: str,
@@ -263,56 +325,20 @@ def predict_standings(
         (game, winner, home_score, away_score) tuples, and league_info
         contains league metadata.
     """
-    rp = results_path
-    teams_base, ratings, league_avg = calc_strength(rp)
-    teams: dict[str, TeamStats] = defaultdict(TeamStats)
+    teams_base, ratings, league_avg = calc_strength(results_path)
+    teams = _copy_stats(teams_base)
 
-    for name, st in teams_base.items():
-        t = teams[name]
-        t.gp = st.gp
-        t.w = st.w
-        t.l = st.l
-        t.d = st.d
-        t.pf = st.pf
-        t.pa = st.pa
-
-    played, league_info = read_games(rp)
-    played_keys: set[tuple[str, str, str]] = {
-        (g.home, g.away, g.date.strftime("%d.%m.%Y")) for g in played
-    }
-
-    schedule, _ = parse_schedule(html_path)
-    pending = [
-        g
-        for g in filter_schedule(schedule, pending=True)
-        if (g.home, g.away, g.date.strftime("%d.%m.%Y")) not in played_keys
-    ]
-
-    pending.sort(key=lambda g: g.date)
-    last_game_ts: dict[str, float] = {}
-    for g in played:
-        ts = g.date.timestamp()
-        for name in (g.home, g.away):
-            if ts > last_game_ts.get(name, 0):
-                last_game_ts[name] = ts
+    played, league_info = read_games(results_path)
+    pending = _pending_games(html_path, played)
 
+    last_game_ts = _last_game_times(played)
     threshold_s = FATIGUE_THRESHOLD_H * 3600
 
     preds: list[tuple[ScheduledGame, str, int, int]] = []
     for game in pending:
         gt = game.date.timestamp()
-        h_fat = (
-            FATIGUE_PENALTY
-            if game.home in last_game_ts
-            and (gt - last_game_ts[game.home]) <= threshold_s
-            else 1.0
-        )
-        a_fat = (
-            FATIGUE_PENALTY
-            if game.away in last_game_ts
-            and (gt - last_game_ts[game.away]) <= threshold_s
-            else 1.0
-        )
+        h_fat = _fatigue(game.home, gt, last_game_ts, threshold_s)
+        a_fat = _fatigue(game.away, gt, last_game_ts, threshold_s)
 
         winner, hs, as_ = predict_game(
             game.home,
@@ -326,24 +352,7 @@ def predict_standings(
         last_game_ts[game.home] = gt
         last_game_ts[game.away] = gt
         preds.append((game, winner, hs, as_))
-
-        h, a = teams[game.home], teams[game.away]
-        h.gp += 1
-        a.gp += 1
-        h.pf += hs
-        h.pa += as_
-        a.pf += as_
-        a.pa += hs
-
-        if winner == "home":
-            h.w += 1
-            a.l += 1
-        elif winner == "away":
-            a.w += 1
-            h.l += 1
-        else:
-            h.d += 1
-            a.d += 1
+        _apply_result(teams[game.home], teams[game.away], winner, hs, as_)
 
     standings = [Standing(n, s) for n, s in teams.items()]
     standings.sort(