solver updates

solver.py

@@ -15,6 +15,7 @@ def run_milp_model(data: dict):
     current_squad = data["current_squad"]
     start_itb = data["itb"]
     start_ft = data["ft"]
+    gw_opp_teams = data.get("gw_opp_teams", {})
 
     settings = data.get("settings", {})
 
@@ -141,6 +142,48 @@ def run_milp_model(data: dict):
             prev_w = gws[i - 1]
             gw_ft_gain[w] = gw_ft_value[w] - gw_ft_value[prev_w]
 
+    # --- CROSS-PLAY PENALTY LOGIC ---
+    cp_penalty_expr = {w: 0 for w in gws}
+
+    if settings.get("no_opposing_play") and gw_opp_teams:
+        opp_group = settings.get("opposing_play_group", "all")
+        pen_val = float(settings.get("opposing_play_penalty", 0.5))
+
+        opp_pos = [
+            ("G", "F"),
+            ("G", "M"),
+            ("D", "F"),
+            ("D", "M"),
+            ("F", "G"),
+            ("M", "G"),
+            ("F", "D"),
+            ("M", "D"),
+        ]
+
+        cp_list = []
+        for w in gws:
+            for p1 in players:
+                for p2 in players:
+                    # Look up the pre-calculated dictionary!
+                    if p1 != p2 and (teams[p1], teams[p2]) in gw_opp_teams.get(w, []):
+                        if (
+                            opp_group == "all"
+                            or (positions[p1], positions[p2]) in opp_pos
+                        ):
+                            cp_list.append((p1, p2, w))
+
+        if cp_list:
+            cp_vars = pulp.LpVariable.dicts("cp", cp_list, cat="Binary")
+            for p1, p2, w in cp_list:
+                prob += lineup[p1][w] + lineup[p2][w] <= 1 + cp_vars[(p1, p2, w)]
+                prob += cp_vars[(p1, p2, w)] <= lineup[p1][w]
+                prob += cp_vars[(p1, p2, w)] <= lineup[p2][w]
+
+            for w in gws:
+                cp_penalty_expr[w] = pen_val * pulp.lpSum(
+                    cp_vars[(p1, p2, gw)] for (p1, p2, gw) in cp_list if gw == w
+                )
+
     # --- OBJECTIVE FUNCTION (Decayed to match original) ---
     obj_parts = []
     for i, w in enumerate(gws):
@@ -173,6 +216,9 @@ def run_milp_model(data: dict):
             for p in players:
                 obj_parts.append(-transfer_in[p][w] * ft_use_penalty * decay_factor)
 
+        if cp_penalty_expr[w] != 0:
+            obj_parts.append(-cp_penalty_expr[w] * decay_factor)
+
     prob += pulp.lpSum(obj_parts), "Total_EV_Objective"
 
     # --- ADVANCED HORIZON-LEVEL CONSTRAINTS ---
@@ -419,7 +465,13 @@ def run_milp_model(data: dict):
 
         # THE FIX: Boot up the HiGHS engine instead of CBC
         try:
-            solver = pulp.getSolver("HiGHS", msg=False, timeLimit=time_limit_sec)
+            gap = float(settings.get("gap", 0.005))
+            solver = pulp.getSolver(
+                "HiGHS",
+                msg=False,
+                timeLimit=time_limit_sec,
+                options=["presolve=on", f"mip_rel_gap={gap}"],
+            )
         except pulp.PulpSolverError:
             print("HiGHS not found! Falling back to CBC...")
             solver = pulp.PULP_CBC_CMD(msg=False, timeLimit=time_limit_sec)
@@ -530,14 +582,19 @@ def run_milp_model(data: dict):
             if chip == "bb":
                 gw_pure_ev += sum(raw_ev_matrix[p].get(w, 0) for p in gw_bench_sorted)
             else:
-                # THE FIX 2: Perfectly mimic React's horizonEV fractional bench math
-                of_bench_ws = [0.17, 0.05, 0.02]
+                # THE FIX 2: Stop hardcoding! Use the dynamic weights extracted from React at the top of the file!
                 of_idx = 0
                 for p in gw_bench_sorted:
                     if positions.get(p, "M") == "G":
-                        gw_pure_ev += raw_ev_matrix[p].get(w, 0) * 0.04
+                        # Uses the gk_bench_w parsed at line 46
+                        gw_pure_ev += raw_ev_matrix[p].get(w, 0) * gk_bench_w
                     else:
-                        bw = of_bench_ws[of_idx] if of_idx < len(of_bench_ws) else 0.02
+                        # Uses the of_bench_ws array parsed at line 47
+                        bw = (
+                            of_bench_ws[of_idx]
+                            if of_idx < len(of_bench_ws)
+                            else avg_of_bench_w
+                        )
                         gw_pure_ev += raw_ev_matrix[p].get(w, 0) * bw
                         of_idx += 1
 

solver_engine.py

@@ -1,5 +1,8 @@
+import requests
 from typing import Any
 
+_FIXTURE_CACHE = []
+
 
 def _norm_id_list(raw) -> list[int]:
     if not raw:
@@ -180,6 +183,32 @@ def prep_solver_data(payload_data: dict):
             ev_matrix[pid][gw] = float(raw_ev) * decay_factor
             raw_ev_matrix[pid][gw] = float(raw_ev)
 
+    # --- CROSS-PLAY FIXTURE PREP ---
+    global _FIXTURE_CACHE
+    gw_opp_teams = {w: [] for w in horizon_gws}
+
+    if settings.get("no_opposing_play"):
+        if not _FIXTURE_CACHE:
+            try:
+                # Same fast cache logic as solver_the_real_one
+                _FIXTURE_CACHE = requests.get(
+                    "https://fantasy.premierleague.com/api/fixtures/"
+                ).json()
+            except:  # noqa: E722
+                pass
+
+        # Map the opponent matchups for the solver
+        team_mapping = {v: k for k, v in teams.items()}  # Reverse lookup
+        for f in _FIXTURE_CACHE:
+            w = f.get("event")
+            if w in horizon_gws:
+                home_team = team_mapping.get(f.get("team_h"))
+                away_team = team_mapping.get(f.get("team_a"))
+                if home_team and away_team:
+                    gw_opp_teams[w].extend(
+                        [(home_team, away_team), (away_team, home_team)]
+                    )
+
     return {
         "players": list(buy_prices.keys()),
         "gws": horizon_gws,
@@ -192,4 +221,5 @@ def prep_solver_data(payload_data: dict):
         "itb": float(payload_data["in_the_bank"]),
         "ft": int(payload_data["free_transfers"]),
         "settings": settings,
+        "gw_opp_teams": gw_opp_teams,
     }