Update app.py

app.py

@@ -68,6 +68,177 @@ def get_team_news(team: str, sport: str = "football"):
     headlines = [h.text for h in soup.select("h3")[:5]]
     return " ".join(headlines)
 
+# --- Helpers: NBA preseason scraping (very lightweight best-effort) ---
+def _extract_pairs_from_texts(texts):
+    pairs = []
+    for t in texts:
+        s = t.strip()
+        if not s:
+            continue
+        lowered = s.lower()
+        if " vs " in lowered:
+            sep = " vs "
+        elif " v " in lowered:
+            sep = " v "
+        elif " at " in lowered:
+            sep = " at "
+        else:
+            continue
+        parts = s.split(sep, 1)
+        if len(parts) == 2:
+            home = parts[0].strip()
+            away = parts[1].strip()
+            if home and away:
+                pairs.append({"home": home, "away": away})
+    return pairs
+
+def scrape_nba_preseason_pairs_for_dates(dates):
+    found = []
+    seen = set()
+    headers = {"User-Agent": "Mozilla/5.0"}
+    for d in dates:
+        q = f"NBA preseason {d}"
+        url = f"https://www.google.com/search?q={q}"
+        try:
+            r = requests.get(url, headers=headers, timeout=20)
+            soup = BeautifulSoup(r.text, "html.parser")
+            h3s = [h.text for h in soup.select("h3")[:20]]
+            pairs = _extract_pairs_from_texts(h3s)
+            for p in pairs:
+                key = (p["home"].lower(), p["away"].lower())
+                if key not in seen:
+                    seen.add(key)
+                    found.append(p)
+        except Exception:
+            continue
+    return found
+
+# --- Verdict helpers ---
+def build_soccer_verdict(home, away, agg):
+    oneXtwo = agg.get("oneXtwo", {})
+    over_under = agg.get("over_under", {})
+    pick_1x2 = max(oneXtwo, key=oneXtwo.get) if oneXtwo else "X"
+    conf_1x2 = oneXtwo.get(pick_1x2, 0.0)
+    ou_25 = over_under.get("2.5", {"over": 0.0, "under": 0.0})
+    pick_ou = "Over 2.5" if ou_25.get("over", 0.0) >= ou_25.get("under", 0.0) else "Under 2.5"
+    conf_ou = max(ou_25.get("over", 0.0), ou_25.get("under", 0.0))
+    return f"{home} vs {away}: {pick_1x2} ({conf_1x2:.2f}), {pick_ou} ({conf_ou:.2f})"
+
+# --- Helpers: Football-Data last-5 and simple Poisson model ---
+def football_headers():
+    return {"X-Auth-Token": FOOTBALL_API_KEY}
+
+def fetch_last5_for_team(team_id: int):
+    try:
+        url = f"https://api.football-data.org/v4/teams/{team_id}/matches?status=FINISHED&limit=5"
+        r = requests.get(url, headers=football_headers(), timeout=20)
+        r.raise_for_status()
+        data = r.json()
+        return data.get("matches", [])
+    except Exception:
+        return []
+
+def summarize_form(team_id: int, team_name: str):
+    matches = fetch_last5_for_team(team_id)
+    goals_for = 0
+    goals_against = 0
+    wins = 0
+    draws = 0
+    losses = 0
+    for m in matches:
+        ht = m.get("homeTeam", {})
+        at = m.get("awayTeam", {})
+        score = m.get("score", {}).get("fullTime", {})
+        hg = score.get("home") if score.get("home") is not None else 0
+        ag = score.get("away") if score.get("away") is not None else 0
+        is_home = (ht.get("id") == team_id)
+        gf = hg if is_home else ag
+        ga = ag if is_home else hg
+        goals_for += gf
+        goals_against += ga
+        if gf > ga:
+            wins += 1
+        elif gf == ga:
+            draws += 1
+        else:
+            losses += 1
+    games = max(1, len(matches))
+    avg_for = goals_for / games
+    avg_against = goals_against / games
+    return {
+        "team_id": team_id,
+        "team": team_name,
+        "matches_considered": len(matches),
+        "wins": wins,
+        "draws": draws,
+        "losses": losses,
+        "avg_goals_for": avg_for,
+        "avg_goals_against": avg_against,
+    }
+
+def poisson_pmf(lmbda: float, k: int):
+    if lmbda <= 0:
+        lmbda = 0.0001
+    # simple Poisson PMF: e^-λ λ^k / k!
+    from math import exp
+    # factorial up to 10 safely
+    fact = 1
+    for i in range(2, k + 1):
+        fact *= i
+    return (exp(-lmbda) * (lmbda ** k)) / fact
+
+def match_score_prob(lambda_home: float, lambda_away: float, max_goals: int = 10):
+    matrix = []
+    for h in range(0, max_goals + 1):
+        row = []
+        for a in range(0, max_goals + 1):
+            row.append(poisson_pmf(lambda_home, h) * poisson_pmf(lambda_away, a))
+        matrix.append(row)
+    return matrix
+
+def aggregate_outcomes(prob_matrix, thresholds=(0.5, 1.5, 2.5, 3.5)):
+    max_g = len(prob_matrix) - 1
+    p_home = 0.0
+    p_draw = 0.0
+    p_away = 0.0
+    ou = {t: {"over": 0.0, "under": 0.0} for t in thresholds}
+    total_prob = 0.0
+    for h in range(max_g + 1):
+        for a in range(max_g + 1):
+            p = prob_matrix[h][a]
+            total_prob += p
+            if h > a:
+                p_home += p
+            elif h == a:
+                p_draw += p
+            else:
+                p_away += p
+            s = h + a
+            for t in thresholds:
+                if s > t:
+                    ou[t]["over"] += p
+                else:
+                    ou[t]["under"] += p
+    # double chance
+    dc_1x = p_home + p_draw
+    dc_x2 = p_draw + p_away
+    # normalize tiny drift
+    if abs(total_prob - 1.0) > 1e-6:
+        scale = 1.0 / total_prob
+        p_home *= scale
+        p_draw *= scale
+        p_away *= scale
+        for t in thresholds:
+            ou[t]["over"] *= scale
+            ou[t]["under"] *= scale
+        dc_1x *= scale
+        dc_x2 *= scale
+    return {
+        "oneXtwo": {"1": p_home, "X": p_draw, "2": p_away},
+        "double_chance": {"1X": dc_1x, "X2": dc_x2},
+        "over_under": {str(t): ou[t] for t in thresholds}
+    }
+
 @app.get("/soccer-predictions")
 def soccer_predictions():
     from datetime import timedelta
@@ -110,6 +281,8 @@ def soccer_predictions():
 
         for match in matches:
             home, away = match["homeTeam"]["name"], match["awayTeam"]["name"]
+            home_id = match["homeTeam"].get("id")
+            away_id = match["awayTeam"].get("id")
 
             home_news = get_team_news(home, "football")
             away_news = get_team_news(away, "football")
@@ -134,24 +307,50 @@ def soccer_predictions():
             emb_away = similarity_model.encode(away + " " + away_news, convert_to_tensor=True)
             similarity = util.pytorch_cos_sim(emb_home, emb_away).item()
 
+            # Form summaries (last-5)
+            form_home = summarize_form(home_id, home) if home_id else None
+            form_away = summarize_form(away_id, away) if away_id else None
+
+            # Simple Poisson lambdas from form with home advantage factor
+            home_lambda = (form_home["avg_goals_for"] if form_home else 1.2) * 1.1
+            away_lambda = (form_away["avg_goals_for"] if form_away else 1.1) * 0.95
+            prob_matrix = match_score_prob(home_lambda, away_lambda)
+            agg = aggregate_outcomes(prob_matrix)
+
+            # LLM reasoning
             context = f"""
             Match: {home} vs {away}.
             Home news: {home_news}.
             Away news: {away_news}.
-            Semantic similarity: {similarity}.
+            Similarity: {similarity:.3f}.
+            Home form (avg GF/GA): {(form_home['avg_goals_for'] if form_home else 'n/a')}/{(form_home['avg_goals_against'] if form_home else 'n/a')}.
+            Away form (avg GF/GA): {(form_away['avg_goals_for'] if form_away else 'n/a')}/{(form_away['avg_goals_against'] if form_away else 'n/a')}.
+            Model 1X2: {agg['oneXtwo']}.
+            O/U ladder: {agg['over_under']}.
+            Double chance: {agg['double_chance']}.
             """
             reasoning = reasoning_model(
-                f"Predict 1X2 and Over/Under 2.5 goals for this soccer match. Context: {context}",
+                f"Provide a concise betting-style verdict (1X2, O/U, double chance) with rationale given the context. Context: {context}",
                 max_length=256
             )[0]['generated_text']
 
             predictions.append({
                 "league": league,
                 "match": f"{home} vs {away}",
+                "structured": {
+                    "oneXtwo": agg["oneXtwo"],
+                    "double_chance": agg["double_chance"],
+                    "over_under": agg["over_under"],
+                },
                 "reason": reasoning,
+                "verdict": build_soccer_verdict(home, away, agg),
                 "news_summary": {
                     home: home_sent,
                     away: away_sent
+                },
+                "form": {
+                    home: form_home,
+                    away: form_away
                 }
             })
 
@@ -281,6 +480,27 @@ def nba_predictions():
             "error": f"NBA API error: {str(e)}"
         }
 
+    if not games:
+        # Try lightweight Google scraping for preseason fixtures
+        scraped_pairs = scrape_nba_preseason_pairs_for_dates(dates)
+        debug_info.append({
+            "note": "No NBA API games; attempted preseason scrape",
+            "dates_queried": dates,
+            "scraped_pairs": scraped_pairs
+        })
+        if not scraped_pairs:
+            return {
+                "date_range": f"{date_from} to {date_to}",
+                "predictions": [],
+                "debug_info": debug_info,
+                "total_predictions": 0
+            }
+        # Build stub games from scraped data
+        games = [{
+            "home_team": {"full_name": p["home"]},
+            "visitor_team": {"full_name": p["away"]}
+        } for p in scraped_pairs]
+
     for g in games:
         home, away = g["home_team"]["full_name"], g["visitor_team"]["full_name"]
 
@@ -309,13 +529,14 @@ def nba_predictions():
         Away news: {away_news}.
         """
         reasoning = reasoning_model(
-            f"Predict winner and Over/Under points for this NBA game. Context: {context}",
+            f"Provide a concise NBA verdict: likely winner and Over/Under guidance. Context: {context}",
             max_length=256
         )[0]['generated_text']
 
         predictions.append({
             "match": f"{home} vs {away}",
             "reason": reasoning,
+            "verdict": f"{home} vs {away}: {reasoning[:140]}...",
             "news_summary": {
                 home: home_sent,
                 away: away_sent