Stats Update Pipeline

from PROPPR.StatsUpdateFM.core.pipeline.league_standings import fetch_standings

for league_id in TRACKED_LEAGUES:
    standings = fotmob_client.get_league(
        id=league_id,
        tab='table'
    )
    
    # Parse standings data
    teams = standings.get('table', [{}])[0].get('data', {}).get('table', {}).get('all', [])
    
    # Store in DB
    league_standings_fm.update_one(
        {'league_id': league_id},
        {'$set': {
            'teams': teams,
            'last_updated': datetime.now()
        }},
        upsert=True
    )

for date in date_range(today, today + 14):
    matches = fotmob_client.get_matches_by_date(
        date=date.strftime('%Y%m%d')
    )
    
    for league in matches.get('leagues', []):
        for match in league.get('matches', []):
            fixture_doc = {
                'match_id': match['id'],
                'home_team': match['home']['name'],
                'away_team': match['away']['name'],
                'league_name': league['name'],
                'kick_off_time': match['status']['utcTime'],
                'page_url': match.get('pageUrl')  # For HTML fallback
            }
            
            fixtures_fm.update_one(
                {'match_id': match['id']},
                {'$set': fixture_doc},
                upsert=True
            )

for fixture in recent_fixtures:
    # Try API first
    try:
        data = fotmob_client.get_match_details(fixture['match_id'])
    except CloudflareBlockError:
        # Fallback to HTML scraping
        page_url = fixture_url_mapping_fm.find_one(
            {'fixture_id': str(fixture['match_id'])}
        ).get('page_url')
        
        data = fotmob_client.scrape_match_html(page_url)
    
    # Extract player stats
    lineup = data.get('content', {}).get('lineup', {})
    for side in ['homeTeam', 'awayTeam']:
        for player in lineup.get(side, {}).get('starters', []):
            stats = player.get('stats', [])
            # Process and store...

def aggregate_player_stats(player_id, last_n_games=10):
    """
    Calculate rolling averages for player stats
    """
    games = player_stats_fm.find({
        'player_id': player_id
    }).sort('match_date', -1).limit(last_n_games)
    
    totals = defaultdict(float)
    games_played = 0
    
    for game in games:
        for stat_key in TRACKED_STATS:
            totals[stat_key] += game.get(stat_key, 0)
        games_played += 1
    
    # Calculate averages
    averages = {
        stat: total / games_played
        for stat, total in totals.items()
    }
    
    # Update player document
    player_stats_fm.update_one(
        {'player_id': player_id},
        {'$set': {
            'avg': averages,
            'per_match': averages,
            'games_played': games_played,
            'last_aggregated': datetime.now()
        }}
    )

# Average cards per game
referee_stats_fm.update_one(
    {'referee_id': ref_id},
    {'$set': {
        'avg_yellow_cards': sum(yellows) / len(games),
        'avg_red_cards': sum(reds) / len(games),
        'avg_fouls': sum(fouls) / len(games),
        'games_officiated': len(games)
    }}
)

def predict_starting_lineup(team_id, fixture_id):
    """
    Predict starting XI based on recent lineups and player availability
    """
    # Get last 5 matches
    recent_games = fixtures_fm.find({
        '$or': [{'home_team_id': team_id}, {'away_team_id': team_id}],
        'status': 'Finished'
    }).sort('kick_off_time', -1).limit(5)
    
    # Count player appearances in starting XI
    starter_counts = defaultdict(int)
    for game in recent_games:
        lineup = fixture_api_cache_fm.find_one({'match_id': game['match_id']})
        side = 'homeTeam' if lineup['home_team_id'] == team_id else 'awayTeam'
        
        for player in lineup['content']['lineup'][side]['starters']:
            starter_counts[player['id']] += 1
    
    # Select top 11 players by appearance frequency
    predicted_starters = sorted(
        starter_counts.items(),
        key=lambda x: x[1],
        reverse=True
    )[:11]
    
    # Store prediction
    Predicted_Lines_FM.update_one(
        {'fixture_id': fixture_id, 'team_id': team_id},
        {'$set': {
            'predicted_starters': [p[0] for p in predicted_starters],
            'confidence': calculate_confidence(starter_counts),
            'generated_at': datetime.now()
        }},
        upsert=True
    )

{
  "fixture_id": 4832195,
  "player_id": 823154,
  "player_name": "Erling Haaland",
  "team": "Manchester City",
  "position": "ST",
  "is_predicted_starter": true,
  
  "projections": {
    "projected_goals_avg": 0.78,
    "projected_goals_per_match": 0.82,
    "projected_shots_avg": 4.2,
    "projected_shots_on_target_avg": 2.1,
    "projected_assists_avg": 0.15,
    "projected_tackles_avg": 0.8,
    "projected_fouls_avg": 1.2,
    "projected_yellow_cards_avg": 0.18,
    // ... 40+ more projections
  },
  
  "opponent_defense": {
    "goals_conceded_per_match": 1.4,
    "shots_allowed_per_match": 12.3,
    "vs_position_ST": {
      "goals_allowed_avg": 0.65,
      "shots_allowed_avg": 3.8
    }
  },
  
  "referee": {
    "referee_id": 51234,
    "referee_name": "Michael Oliver",
    "avg_yellow_cards": 3.8,
    "avg_fouls": 22.5
  },
  
  "raw_stats": {
    "avg": { /* Rolling averages */ },
    "per_match": { /* Per-match stats */ },
    "total": { /* Season totals */ },
    "games_played": 25
  }
}

def calculate_projection(player, opponent, referee):
    """
    Multi-factor projection model
    """
    # Base projection from player's recent form
    base = player['avg']['goals']  # Example: 0.75 goals/game
    
    # Opponent adjustment (defensive strength)
    opp_factor = opponent['goals_conceded_per_match'] / LEAGUE_AVG_GOALS
    adjusted = base * opp_factor
    
    # Position-specific opponent adjustment
    vs_position = opponent.get('vs_position', {}).get(player['position'], {})
    if vs_position:
        adjusted *= vs_position.get('goals_allowed_avg', 1.0) / LEAGUE_AVG
    
    # Referee adjustment (for cards/fouls)
    if stat_type in ['yellow_cards', 'fouls']:
        ref_factor = referee['avg_' + stat_type] / LEAGUE_AVG
        adjusted *= ref_factor
    
    # Apply position caps (e.g., GK max 0.05 goals)
    cap = GOAL_POSITION_CAPS.get(player['position'], 1.0)
    final = min(adjusted, cap)
    
    return round(final, 2)

GOAL_POSITION_CAPS = {
    "GK": 0.05, "CB": 0.15, "RB": 0.15, "LB": 0.15,
    "CDM": 0.25, "CM": 0.35, "CAM": 0.65,
    "RM": 0.45, "LM": 0.45, "RW": 0.55, "LW": 0.55,
    "CF": 0.75, "ST": 0.75
}

def generate_player_alert(projection, market_line):
    """
    Compare projection to betting market line
    """
    player_projection = projection['projections']['projected_shots_avg']
    bookmaker_line = market_line['threshold']  # e.g., 3.5
    
    if player_projection > bookmaker_line + EDGE_THRESHOLD:
        alert = {
            'player_name': projection['player_name'],
            'market': 'Player Shots',
            'projection': player_projection,
            'line': bookmaker_line,
            'edge': player_projection - bookmaker_line,
            'direction': 'OVER',
            'confidence': calculate_confidence(projection),
            'generated_at': datetime.now()
        }
        
        player_insight_alerts.insert_one(alert)