Tennis Data

def calculate_atp_ranking_points(player_id, time_period='52_weeks'):
    """
    ATP rankings are based on best 18 results in rolling 52-week period
    """
    tournaments = get_player_tournaments(player_id, weeks=52)
    
    # Sort by points earned (descending)
    tournaments.sort(key=lambda t: t.points_earned, reverse=True)
    
    # Count mandatory tournaments
    mandatory = [
        'Grand Slams': 4,
        'Masters 1000': 8,  # Best 8 of 9
        'ATP Finals': 1     # If qualified
    ]
    
    # Take best 18 results
    best_results = tournaments[:18]
    
    total_points = sum(t.points_earned for t in best_results)
    
    return total_points

def calculate_ranking_trend(player_id, weeks=12):
    """
    Analyze ranking stability and momentum
    """
    historical_rankings = get_ranking_history(player_id, weeks)
    
    # Calculate metrics
    current_rank = historical_rankings[0]
    average_rank = np.mean(historical_rankings)
    std_dev = np.std(historical_rankings)
    trend = calculate_linear_trend(historical_rankings)
    
    return {
        'current': current_rank,
        'average': average_rank,
        'volatility': std_dev,
        'trend': 'improving' if trend < 0 else 'declining',
        'trend_slope': trend
    }

hard_court_speeds = {
    'Plexicushion': {'speed': 'medium-fast', 'tournaments': ['Australian Open']},
    'DecoTurf': {'speed': 'medium', 'tournaments': ['US Open']},
    'GreenSet': {'speed': 'medium', 'tournaments': ['Various ATP 500/250']}
}

def calculate_surface_transition_penalty(player_id, from_surface, to_surface, days_gap):
    """
    Players transitioning between surfaces often underperform initially
    """
    transition_difficulty = {
        ('clay', 'grass'): 0.15,      # Hardest transition
        ('grass', 'clay'): 0.15,
        ('clay', 'hard'): 0.08,
        ('hard', 'clay'): 0.08,
        ('grass', 'hard'): 0.10,
        ('hard', 'grass'): 0.10,
    }
    
    base_penalty = transition_difficulty.get((from_surface, to_surface), 0)
    
    # Penalty reduces with more adaptation time
    if days_gap > 14:
        time_adjustment = 0.5
    elif days_gap > 7:
        time_adjustment = 0.7
    else:
        time_adjustment = 1.0
    
    final_penalty = base_penalty * time_adjustment
    
    return final_penalty

scoring_system = {
    'points': ['0', '15', '30', '40', 'Game'],
    'deuce': 'Must win by 2 points',
    'set': 'First to 6 games (must win by 2)',
    'tiebreak': 'First to 7 points at 6-6 in games',
    'final_set': {
        'Grand Slams': 'Varies by tournament',
        'Australian Open': 'Tiebreak at 6-6',
        'French Open': 'No tiebreak (must win by 2)',
        'Wimbledon': 'Tiebreak at 12-12',
        'US Open': 'Tiebreak at 6-6'
    }
}

import httpx
from fastapi import FastAPI

app = FastAPI()

@app.get("/fetch-player-stats")
async def fetch_player_stats(player_id: str):
    """
    Asynchronously fetch player data from API-Tennis
    """
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://api-tennis.com/v1/players/{player_id}",
            headers={"Authorization": f"Bearer {API_KEY}"}
        )
        
        if response.status_code == 200:
            player_data = response.json()
            return player_data
        else:
            # Fallback to mock data provider
            return get_mock_player_data(player_id)

refresh_schedule = {
    'player_rankings': 'weekly',           # Updated Monday mornings
    'match_results': 'daily',              # End of day
    'live_scores': 'real-time',            # If live feature enabled
    'player_stats': 'post-tournament',     # After tournaments conclude
    'historical_data': 'monthly',          # Periodic backfill
}

from datetime import datetime, timedelta
import asyncio

class RateLimiter:
    def __init__(self, max_requests=1000, period_days=30):
        self.max_requests = max_requests
        self.period_days = period_days
        self.requests = []
    
    async def acquire(self):
        """
        Wait if necessary to respect rate limits
        """
        now = datetime.now()
        cutoff = now - timedelta(days=self.period_days)
        
        # Remove old requests
        self.requests = [r for r in self.requests if r > cutoff]
        
        if len(self.requests) >= self.max_requests:
            # Calculate wait time
            oldest_request = min(self.requests)
            wait_until = oldest_request + timedelta(days=self.period_days)
            wait_seconds = (wait_until - now).total_seconds()
            
            if wait_seconds > 0:
                await asyncio.sleep(wait_seconds)
        
        self.requests.append(now)

service_metrics = {
    'first_serve_percentage': 'Percentage of first serves in',
    'first_serve_points_won': 'Points won when first serve lands',
    'second_serve_points_won': 'Points won on second serve',
    'aces': 'Unreturned serves',
    'double_faults': 'Two consecutive faults',
    'break_points_saved': 'Percentage of break points defended'
}

return_metrics = {
    'first_serve_return_points_won': 'Breaking down first serve',
    'second_serve_return_points_won': 'Attacking second serve',
    'break_points_converted': 'Percentage of break opportunities taken',
    'return_games_won': 'Games broken',
}

def get_player_surface_profile(player_id):
    """
    Comprehensive surface performance profile
    """
    surfaces = ['clay', 'hard', 'grass']
    profile = {}
    
    for surface in surfaces:
        matches = get_player_matches(player_id, surface=surface)
        
        profile[surface] = {
            'win_rate': calculate_win_rate(matches),
            'total_matches': len(matches),
            'titles': count_titles(matches),
            'avg_ranking_of_opponents': calculate_avg_opponent_rank(matches),
            'recent_form': get_recent_form(matches, last_n=10)
        }
    
    return profile

data_depth = {
    'rankings': 'Since 1973 (ATP), 1975 (WTA)',
    'match_results': 'Complete from 1990s onward',
    'detailed_stats': 'Comprehensive from 2010+',
    'point_by_point': 'Recent years, major tournaments only'
}