412 lines
17 KiB
Python
412 lines
17 KiB
Python
"""
|
||
ui/predictor_ui.py
|
||
------------------
|
||
Prediction generator screen — two tabs inside a ttk.Notebook.
|
||
|
||
Generate tab — pick strategy + game + count → generate tickets → save to DB
|
||
Saved tab — browse all saved predictions, see match count vs last real
|
||
draw, delete individual rows or clear all
|
||
"""
|
||
|
||
import os
|
||
import tkinter as tk
|
||
from tkinter import ttk, filedialog, messagebox
|
||
import logging
|
||
|
||
from db.models import (
|
||
get_all_games, get_game_by_name, get_last_draw,
|
||
insert_prediction, get_predictions,
|
||
delete_prediction, delete_all_predictions,
|
||
)
|
||
from core.predictor import (
|
||
hot_numbers, due_numbers, weighted_random, monte_carlo, positional_pick,
|
||
)
|
||
from core.exporter import export_predictions_excel, export_predictions_csv, ensure_exports_dir
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
_STRATEGIES = {
|
||
"Hot Numbers": hot_numbers,
|
||
"Due Numbers": due_numbers,
|
||
"Weighted Random": weighted_random,
|
||
"Monte Carlo": monte_carlo,
|
||
"Positional": positional_pick,
|
||
}
|
||
|
||
_DESCRIPTIONS = {
|
||
"Hot Numbers": "Top 5 most frequent numbers from the last 100 draws.",
|
||
"Due Numbers": "Numbers most overdue based on expected frequency gap.",
|
||
"Weighted Random": "Random pick weighted by each number's historical frequency.",
|
||
"Monte Carlo": "10,000 simulated draws — pick the most often-selected numbers.",
|
||
"Positional": "Most frequent number at each draw position (1–5).",
|
||
}
|
||
|
||
_TICKET_COUNTS = [str(n) for n in range(1, 11)]
|
||
|
||
|
||
def _count_matches(pred_numbers: str, last_draw) -> str:
|
||
"""Compare prediction numbers to last draw, return 'X/5' string."""
|
||
if last_draw is None:
|
||
return "—"
|
||
try:
|
||
pred_set = {int(n) for n in pred_numbers.split(",")}
|
||
draw_set = {int(n) for n in last_draw["numbers"].split(",")}
|
||
matched = len(pred_set & draw_set)
|
||
return f"{matched}/{len(pred_set)}"
|
||
except Exception:
|
||
return "—"
|
||
|
||
|
||
class PredictorScreen(ttk.Frame):
|
||
def __init__(self, parent, **kwargs):
|
||
super().__init__(parent, **kwargs)
|
||
self._game_id: int | None = None
|
||
self._tickets: list[dict] = []
|
||
self._strategy_name: str = "Hot Numbers"
|
||
self._build_ui()
|
||
|
||
# ── UI construction ───────────────────────────────────────────────────────
|
||
|
||
def _build_ui(self):
|
||
nb = ttk.Notebook(self)
|
||
nb.pack(fill="both", expand=True)
|
||
|
||
gen_frame = ttk.Frame(nb)
|
||
saved_frame = ttk.Frame(nb)
|
||
nb.add(gen_frame, text="Generate")
|
||
nb.add(saved_frame, text="Saved")
|
||
|
||
self._build_generate_tab(gen_frame)
|
||
self._build_saved_tab(saved_frame)
|
||
|
||
# ── Generate tab ──────────────────────────────────────────────────────────
|
||
|
||
def _build_generate_tab(self, parent):
|
||
bar = ttk.Frame(parent, padding=(6, 6, 6, 4))
|
||
bar.pack(fill="x")
|
||
|
||
ttk.Label(bar, text="Game:").pack(side="left")
|
||
self._game_var = tk.StringVar()
|
||
self._game_cb = ttk.Combobox(
|
||
bar, textvariable=self._game_var, state="readonly", width=15
|
||
)
|
||
self._game_cb.pack(side="left", padx=(4, 14))
|
||
self._game_cb.bind("<<ComboboxSelected>>", lambda _: self._on_game_change())
|
||
|
||
ttk.Label(bar, text="Strategy:").pack(side="left")
|
||
self._strategy_var = tk.StringVar(value="Hot Numbers")
|
||
strategy_cb = ttk.Combobox(
|
||
bar, textvariable=self._strategy_var,
|
||
values=list(_STRATEGIES.keys()),
|
||
state="readonly", width=16,
|
||
)
|
||
strategy_cb.pack(side="left", padx=(4, 14))
|
||
strategy_cb.bind("<<ComboboxSelected>>", lambda _: self._on_strategy_change())
|
||
|
||
ttk.Label(bar, text="Tickets:").pack(side="left")
|
||
self._count_var = tk.StringVar(value="1")
|
||
ttk.Combobox(
|
||
bar, textvariable=self._count_var,
|
||
values=_TICKET_COUNTS, state="readonly", width=4,
|
||
).pack(side="left", padx=(4, 0))
|
||
|
||
self._gen_btn = ttk.Button(bar, text="Generate", command=self._generate)
|
||
self._gen_btn.pack(side="left", padx=(14, 0))
|
||
|
||
# Results treeview
|
||
tree_frame = ttk.Frame(parent)
|
||
tree_frame.pack(fill="both", expand=True, padx=6, pady=(4, 0))
|
||
|
||
cols = ("#", "numbers", "bonus")
|
||
self._tree = ttk.Treeview(
|
||
tree_frame, columns=cols, show="headings", selectmode="browse"
|
||
)
|
||
self._tree.heading("#", text="#")
|
||
self._tree.heading("numbers", text="Numbers")
|
||
self._tree.heading("bonus", text="Bonus")
|
||
self._tree.column("#", width=40, anchor="center", stretch=False)
|
||
self._tree.column("numbers", width=280, anchor="w")
|
||
self._tree.column("bonus", width=70, anchor="center", stretch=False)
|
||
|
||
vsb = ttk.Scrollbar(tree_frame, orient="vertical", command=self._tree.yview)
|
||
self._tree.configure(yscrollcommand=vsb.set)
|
||
self._tree.pack(side="left", fill="both", expand=True)
|
||
vsb.pack(side="right", fill="y")
|
||
|
||
# Bottom bar
|
||
bottom = ttk.Frame(parent, padding=(6, 4))
|
||
bottom.pack(fill="x")
|
||
|
||
self._desc_var = tk.StringVar(value=_DESCRIPTIONS["Hot Numbers"])
|
||
ttk.Label(
|
||
bottom, textvariable=self._desc_var,
|
||
foreground="#555555", anchor="w",
|
||
).pack(side="left", fill="x", expand=True)
|
||
|
||
self._status_var = tk.StringVar()
|
||
ttk.Label(bottom, textvariable=self._status_var,
|
||
foreground="#27ae60").pack(side="left", padx=(8, 0))
|
||
|
||
self._save_btn = ttk.Button(
|
||
bottom, text="Save to DB", command=self._save, state="disabled"
|
||
)
|
||
self._save_btn.pack(side="right")
|
||
|
||
ttk.Button(bottom, text="Clear", command=self._clear
|
||
).pack(side="right", padx=(0, 4))
|
||
ttk.Button(bottom, text="Export CSV", command=self._export_csv
|
||
).pack(side="right", padx=(0, 4))
|
||
ttk.Button(bottom, text="Export Excel", command=self._export_excel
|
||
).pack(side="right", padx=(0, 4))
|
||
|
||
# ── Saved tab ─────────────────────────────────────────────────────────────
|
||
|
||
def _build_saved_tab(self, parent):
|
||
# Filter + action bar
|
||
bar = ttk.Frame(parent, padding=(6, 6, 6, 4))
|
||
bar.pack(fill="x")
|
||
|
||
ttk.Label(bar, text="Game:").pack(side="left")
|
||
self._saved_game_var = tk.StringVar(value="All Games")
|
||
self._saved_game_cb = ttk.Combobox(
|
||
bar, textvariable=self._saved_game_var, state="readonly", width=15
|
||
)
|
||
self._saved_game_cb.pack(side="left", padx=(4, 14))
|
||
self._saved_game_cb.bind("<<ComboboxSelected>>", lambda _: self._refresh_saved())
|
||
|
||
ttk.Button(bar, text="↻ Refresh", command=self._refresh_saved).pack(side="left", padx=(0, 4))
|
||
ttk.Button(bar, text="Delete Selected", command=self._delete_selected).pack(side="left", padx=(0, 4))
|
||
ttk.Button(bar, text="Clear All", command=self._clear_all_saved).pack(side="left")
|
||
|
||
self._saved_count_var = tk.StringVar(value="0 saved")
|
||
ttk.Label(bar, textvariable=self._saved_count_var,
|
||
foreground="#777777").pack(side="right")
|
||
|
||
# Treeview
|
||
tree_frame = ttk.Frame(parent)
|
||
tree_frame.pack(fill="both", expand=True, padx=6, pady=(2, 6))
|
||
|
||
s_cols = ("id", "game", "strategy", "numbers", "bonus", "matches", "saved")
|
||
self._saved_tree = ttk.Treeview(
|
||
tree_frame, columns=s_cols, show="headings", selectmode="extended"
|
||
)
|
||
self._saved_tree.heading("id", text="ID")
|
||
self._saved_tree.heading("game", text="Game")
|
||
self._saved_tree.heading("strategy", text="Strategy")
|
||
self._saved_tree.heading("numbers", text="Numbers")
|
||
self._saved_tree.heading("bonus", text="Bonus")
|
||
self._saved_tree.heading("matches", text="Matches")
|
||
self._saved_tree.heading("saved", text="Saved")
|
||
|
||
self._saved_tree.column("id", width=45, anchor="center", stretch=False)
|
||
self._saved_tree.column("game", width=120, anchor="w", stretch=False)
|
||
self._saved_tree.column("strategy", width=120, anchor="w", stretch=False)
|
||
self._saved_tree.column("numbers", width=220, anchor="w")
|
||
self._saved_tree.column("bonus", width=55, anchor="center", stretch=False)
|
||
self._saved_tree.column("matches", width=65, anchor="center", stretch=False)
|
||
self._saved_tree.column("saved", width=130, anchor="center", stretch=False)
|
||
|
||
vsb = ttk.Scrollbar(tree_frame, orient="vertical", command=self._saved_tree.yview)
|
||
hsb = ttk.Scrollbar(tree_frame, orient="horizontal", command=self._saved_tree.xview)
|
||
self._saved_tree.configure(yscrollcommand=vsb.set, xscrollcommand=hsb.set)
|
||
|
||
self._saved_tree.grid(row=0, column=0, sticky="nsew")
|
||
vsb.grid(row=0, column=1, sticky="ns")
|
||
hsb.grid(row=1, column=0, sticky="ew")
|
||
tree_frame.rowconfigure(0, weight=1)
|
||
tree_frame.columnconfigure(0, weight=1)
|
||
|
||
# Colour rows by match count
|
||
self._saved_tree.tag_configure("match_good", foreground="#1e8449")
|
||
self._saved_tree.tag_configure("match_zero", foreground="#aaaaaa")
|
||
|
||
# ── Refresh / data ────────────────────────────────────────────────────────
|
||
|
||
def refresh(self):
|
||
self._load_games()
|
||
self._refresh_saved()
|
||
|
||
def _load_games(self):
|
||
games = get_all_games(active_only=True)
|
||
names = [g["name"] for g in games]
|
||
self._game_cb["values"] = names
|
||
if not self._game_var.get() or self._game_var.get() not in names:
|
||
if names:
|
||
self._game_var.set(names[0])
|
||
game = get_game_by_name(self._game_var.get())
|
||
self._game_id = game["id"] if game else None
|
||
|
||
saved_names = ["All Games"] + names
|
||
self._saved_game_cb["values"] = saved_names
|
||
if self._saved_game_var.get() not in saved_names:
|
||
self._saved_game_var.set("All Games")
|
||
|
||
def _refresh_saved(self):
|
||
name = self._saved_game_var.get()
|
||
game_id = None
|
||
if name != "All Games":
|
||
g = get_game_by_name(name)
|
||
game_id = g["id"] if g else None
|
||
|
||
preds = get_predictions(game_id=game_id, limit=100_000)
|
||
|
||
# Cache last draw per game to avoid repeated DB hits
|
||
last_draw_cache: dict[int, object] = {}
|
||
|
||
self._saved_tree.delete(*self._saved_tree.get_children())
|
||
for p in preds:
|
||
gid = p["game_id"]
|
||
if gid not in last_draw_cache:
|
||
last_draw_cache[gid] = get_last_draw(gid)
|
||
last = last_draw_cache[gid]
|
||
|
||
match_str = _count_matches(p["numbers"], last)
|
||
nums_fmt = " ".join(f"{int(n):02d}" for n in p["numbers"].split(","))
|
||
saved_ts = p["created_at"][:16].replace("T", " ")
|
||
|
||
try:
|
||
matched_n = int(match_str.split("/")[0])
|
||
tag = "match_good" if matched_n > 0 else "match_zero"
|
||
except Exception:
|
||
tag = ""
|
||
|
||
self._saved_tree.insert("", "end",
|
||
iid=str(p["id"]),
|
||
values=(
|
||
p["id"],
|
||
p["game_name"],
|
||
p["strategy"],
|
||
nums_fmt,
|
||
p["bonus"] or "—",
|
||
match_str,
|
||
saved_ts,
|
||
),
|
||
tags=(tag,),
|
||
)
|
||
|
||
count = len(preds)
|
||
self._saved_count_var.set(f"{count} saved prediction{'s' if count != 1 else ''}")
|
||
|
||
# ── Generate tab callbacks ────────────────────────────────────────────────
|
||
|
||
def _on_game_change(self):
|
||
game = get_game_by_name(self._game_var.get())
|
||
self._game_id = game["id"] if game else None
|
||
self._clear()
|
||
|
||
def _on_strategy_change(self):
|
||
self._strategy_name = self._strategy_var.get()
|
||
self._desc_var.set(_DESCRIPTIONS.get(self._strategy_name, ""))
|
||
self._clear()
|
||
|
||
def _generate(self):
|
||
if self._game_id is None:
|
||
self._status_var.set("Select a game first.")
|
||
return
|
||
|
||
strategy_fn = _STRATEGIES[self._strategy_var.get()]
|
||
count = int(self._count_var.get())
|
||
|
||
self._clear()
|
||
self._gen_btn.config(state="disabled", text="Generating…")
|
||
self.update_idletasks()
|
||
|
||
try:
|
||
tickets = [strategy_fn(self._game_id) for _ in range(count)]
|
||
self._tickets = tickets
|
||
self._display(tickets)
|
||
self._save_btn.config(state="normal")
|
||
self._status_var.set(f"{len(tickets)} ticket{'s' if len(tickets) != 1 else ''} generated.")
|
||
logger.info("[PREDICT] %d ticket(s) generated via %s", count, self._strategy_var.get())
|
||
except Exception as e:
|
||
self._status_var.set(f"Error: {e}")
|
||
logger.error("[ERROR] Prediction failed: %s", e, exc_info=True)
|
||
finally:
|
||
self._gen_btn.config(state="normal", text="Generate")
|
||
|
||
def _display(self, tickets):
|
||
self._tree.delete(*self._tree.get_children())
|
||
game = get_game_by_name(self._game_var.get())
|
||
show_bonus = game is not None and game["bonus_count"] > 0
|
||
|
||
for i, t in enumerate(tickets, start=1):
|
||
nums_str = " ".join(f"{n:02d}" for n in t["numbers"])
|
||
bonus_str = str(t["bonus"]) if show_bonus and t["bonus"] is not None else "—"
|
||
self._tree.insert("", "end", values=(i, nums_str, bonus_str))
|
||
|
||
def _save(self):
|
||
if not self._tickets or self._game_id is None:
|
||
return
|
||
strategy_name = self._strategy_var.get()
|
||
saved = 0
|
||
for t in self._tickets:
|
||
insert_prediction(self._game_id, strategy_name, t["numbers"], t["bonus"])
|
||
saved += 1
|
||
self._status_var.set(f"Saved {saved} prediction{'s' if saved != 1 else ''} to DB.")
|
||
self._save_btn.config(state="disabled")
|
||
self._refresh_saved()
|
||
logger.info("[PREDICT] Saved %d prediction(s) to DB", saved)
|
||
|
||
def _clear(self):
|
||
self._tickets = []
|
||
self._tree.delete(*self._tree.get_children())
|
||
self._save_btn.config(state="disabled")
|
||
self._status_var.set("")
|
||
|
||
def _export_excel(self):
|
||
ensure_exports_dir()
|
||
fp = filedialog.asksaveasfilename(
|
||
title="Export predictions",
|
||
defaultextension=".xlsx",
|
||
filetypes=[("Excel workbook", "*.xlsx")],
|
||
initialfile=f"predictions_{__import__('datetime').datetime.now().strftime('%Y%m%d')}.xlsx",
|
||
)
|
||
if not fp:
|
||
return
|
||
try:
|
||
export_predictions_excel(fp, game_id=self._game_id)
|
||
self._status_var.set(f"Exported → {os.path.basename(fp)}")
|
||
except Exception as e:
|
||
messagebox.showerror("Export failed", str(e))
|
||
|
||
def _export_csv(self):
|
||
ensure_exports_dir()
|
||
fp = filedialog.asksaveasfilename(
|
||
title="Export predictions",
|
||
defaultextension=".csv",
|
||
filetypes=[("CSV file", "*.csv")],
|
||
initialfile=f"predictions_{__import__('datetime').datetime.now().strftime('%Y%m%d')}.csv",
|
||
)
|
||
if not fp:
|
||
return
|
||
try:
|
||
export_predictions_csv(fp, game_id=self._game_id)
|
||
self._status_var.set(f"Exported → {os.path.basename(fp)}")
|
||
except Exception as e:
|
||
messagebox.showerror("Export failed", str(e))
|
||
|
||
# ── Saved tab callbacks ───────────────────────────────────────────────────
|
||
|
||
def _delete_selected(self):
|
||
selected = self._saved_tree.selection()
|
||
if not selected:
|
||
return
|
||
for iid in selected:
|
||
pred_id = int(self._saved_tree.item(iid, "values")[0])
|
||
delete_prediction(pred_id)
|
||
self._refresh_saved()
|
||
|
||
def _clear_all_saved(self):
|
||
name = self._saved_game_var.get()
|
||
game_id = None
|
||
if name != "All Games":
|
||
g = get_game_by_name(name)
|
||
game_id = g["id"] if g else None
|
||
|
||
scope = f" for {name}" if game_id else ""
|
||
if not messagebox.askyesno("Clear All",
|
||
f"Delete all saved predictions{scope}?"):
|
||
return
|
||
delete_all_predictions(game_id=game_id)
|
||
self._refresh_saved()
|