Upload 5 files

utils/data_loader.py

@@ -0,0 +1,37 @@
+import json
+import requests
+import os
+
+HEADERS = {'User-Agent': 'My Python Application. Contact me at email@example.com'}
+
+def fetch_and_save_chess_data(username, filename):
+    """Fetch chess games data from Chess.com API for a specified username and save to a JSON file."""
+    if os.path.exists(filename):
+        print(f"Loading data from {filename}")
+        with open(filename, 'r') as file:
+            return json.load(file)
+
+    archives_url = f"https://api.chess.com/pub/player/{username}/games/archives"
+    response = requests.get(archives_url, headers=HEADERS)
+
+    if response.status_code != 200:
+        print(f"Error fetching archives for user {username}: {response.status_code}")
+        return []
+
+    archives = response.json().get('archives', [])
+    games = []
+
+    # Fetch game data for each archive URL
+    for archive_url in archives:
+        response = requests.get(archive_url, headers=HEADERS)
+        if response.status_code == 200:
+            games.extend(response.json().get('games', []))
+        else:
+            print(f"Failed to fetch games for {archive_url}")
+
+    # Save the data to a JSON file
+    with open(filename, 'w') as file:
+        json.dump(games, file, indent=4)
+        print(f"Data saved to {filename}")
+
+    return games

utils/game_analysis.py

@@ -0,0 +1,204 @@
+from collections import defaultdict
+from datetime import datetime
+from statistics import median
+import pandas as pd
+
+
+def calculate_probability(numerator, denominator):
+    """Calculate percentage probability."""
+    return (numerator / denominator * 100) if denominator else 0
+
+def analyze_streaks(games_sorted, username):
+    """Analyze win/loss streaks within the same hour."""
+    win_after_win_same_hour = 0
+    loss_after_loss_same_hour = 0
+    total_win_streaks_same_hour = 0
+    total_loss_streaks_same_hour = 0
+
+    previous_result = None
+    previous_hour = None
+
+    for game in games_sorted:
+        end_time = game.get('end_time')
+        if not end_time:
+            continue
+
+        hour_of_day = datetime.fromtimestamp(end_time).hour
+        current_result = get_game_result(game, username)
+
+        if not current_result:
+            continue
+
+        if previous_result and previous_hour == hour_of_day:
+            if previous_result == 'win':
+                total_win_streaks_same_hour += 1
+                if current_result == 'win':
+                    win_after_win_same_hour += 1
+            elif previous_result == 'loss':
+                total_loss_streaks_same_hour += 1
+                if current_result == 'loss':
+                    loss_after_loss_same_hour += 1
+
+        previous_result = current_result
+        previous_hour = hour_of_day
+        
+    print(f"Total win streaks: {total_win_streaks_same_hour}, Wins after win: {win_after_win_same_hour}")
+    print(f"Total loss streaks: {total_loss_streaks_same_hour}, Losses after loss: {loss_after_loss_same_hour}")
+
+    win_probability = calculate_probability(win_after_win_same_hour, total_win_streaks_same_hour)
+    loss_probability = calculate_probability(loss_after_loss_same_hour, total_loss_streaks_same_hour)
+
+    return win_probability, loss_probability
+
+def analyze_sequences(games_sorted, username):
+    """Analyze 'win-loss' and 'loss-win' sequences within the same hour."""
+    win_after_win_loss_same_hour = 0
+    win_after_loss_win_same_hour = 0
+    total_win_loss_sequences_same_hour = 0
+    total_loss_win_sequences_same_hour = 0
+
+    previous_result = None
+    previous_hour = None
+
+    for i, game in enumerate(games_sorted):
+        end_time = game.get('end_time')
+        if not end_time:
+            continue
+
+        hour_of_day = datetime.fromtimestamp(end_time).hour
+        current_result = get_game_result(game, username)
+
+        if not current_result:
+            continue
+
+        if previous_result and previous_hour == hour_of_day:
+            if previous_result == 'win' and current_result == 'loss':
+                total_win_loss_sequences_same_hour += 1
+                next_game_result = get_game_result(games_sorted[i + 1], username) if i + 1 < len(games_sorted) else None
+                if next_game_result == 'win':
+                    win_after_win_loss_same_hour += 1
+            elif previous_result == 'loss' and current_result == 'win':
+                total_loss_win_sequences_same_hour += 1
+                next_game_result = get_game_result(games_sorted[i + 1], username) if i + 1 < len(games_sorted) else None
+                if next_game_result == 'win':
+                    win_after_loss_win_same_hour += 1
+
+        previous_result = current_result
+        previous_hour = hour_of_day
+
+    print(f"Total 'win-loss' sequences: {total_win_loss_sequences_same_hour}, Wins after 'win-loss': {win_after_win_loss_same_hour}")
+    print(f"Total 'loss-win' sequences: {total_loss_win_sequences_same_hour}, Wins after 'loss-win': {win_after_loss_win_same_hour}")
+
+    win_after_win_loss_probability = calculate_probability(win_after_win_loss_same_hour, total_win_loss_sequences_same_hour)
+    win_after_loss_win_probability = calculate_probability(win_after_loss_win_same_hour, total_loss_win_sequences_same_hour)
+
+    return win_after_win_loss_probability, win_after_loss_win_probability
+
+def analyze_games(games, username):
+    """Analyze games by month and return statistics."""
+
+    games_per_month = defaultdict(int)
+    stats_per_month = defaultdict(lambda: defaultdict(int))
+    total_games = 0
+    total_wins = 0
+    total_losses = 0
+    total_timeouts = 0
+
+    for game in games:
+        end_time = game.get('end_time')
+        if not end_time:
+            continue
+
+        end_datetime = datetime.fromtimestamp(end_time)
+        month = end_datetime.strftime('%Y-%m')
+        result = get_game_result(game, username)
+
+        if result == 'win':
+            stats_per_month[month]['wins'] += 1
+            total_wins += 1
+        elif result == 'timeout':
+            stats_per_month[month]['timeouts'] += 1
+            total_timeouts += 1
+            stats_per_month[month]['losses'] += 1  # Count timeout as a loss
+            total_losses += 1
+        elif result == 'loss':
+            stats_per_month[month]['losses'] += 1
+            total_losses += 1
+
+        games_per_month[month] += 1
+        total_games += 1
+
+    total_months_played = len(games_per_month)
+
+    return games_per_month, stats_per_month, total_games, total_wins, total_losses, total_timeouts, total_months_played
+
+def generate_monthly_report(games_per_month, stats_per_month):
+    """Generate a Pandas DataFrame report for monthly analysis including Timeout Rate."""
+    data = []
+    for month, total_games in games_per_month.items():
+        wins = stats_per_month[month]['wins']
+        losses = stats_per_month[month]['losses']
+        timeouts = stats_per_month[month]['timeouts']
+        win_rate = (wins / total_games * 100) if total_games else 0
+        loss_rate = (losses / total_games * 100) if total_games else 0
+        timeout_rate = (timeouts / total_games * 100) if total_games else 0
+
+        data.append({
+            'Month': month,
+            'Games Played': total_games,
+            'Wins': wins,
+            'Losses': losses,
+            'Win Rate (%)': round(win_rate, 1),
+            'Loss Rate (%)': round(loss_rate, 1),
+            'Timeout Rate (%)': round(timeout_rate, 1)
+        })
+
+    return pd.DataFrame(data)
+
+def get_game_result(game, username):
+    """Determine if the user won or lost the game."""
+    result = None
+    if game.get('white', {}).get('username') == username:
+        result = game.get('white', {}).get('result')
+    elif game.get('black', {}).get('username') == username:
+        result = game.get('black', {}).get('result')
+
+    if result == 'win':
+        return 'win'
+    elif result == 'timeout':
+        return 'timeout'  # Explicitly return "timeout"
+    elif result in ['checkmated', 'resigned', 'lose', 'abandoned']:
+        return 'loss'
+    return None
+
+
+def calculate_average_and_median_games(games):
+    """Calculate the average and median number of games played per day."""
+    games_per_day = defaultdict(int)
+
+    for game in games:
+        end_time = game.get('end_time')
+        if not end_time:
+            continue
+
+        end_date = datetime.fromtimestamp(end_time).date()
+        games_per_day[end_date] += 1
+
+    total_days = len(games_per_day)
+    total_games = sum(games_per_day.values())
+    average_games = total_games / total_days if total_days else 0
+    median_games = median(games_per_day.values()) if total_days else 0
+
+    return average_games, median_games
+
+
+def format_duration(total_months):
+    """Format the duration as 'X years, Y months'."""
+    years = total_months // 12
+    months = total_months % 12
+    if years > 0 and months > 0:
+        return f"{years} year(s), {months} month(s)"
+    elif years > 0:
+        return f"{years} year(s)"
+    else:
+        return f"{months} month(s)"

utils/probability_analysis.py

@@ -0,0 +1,24 @@
+from collections import defaultdict
+
+def calculate_win_probability(games_sorted, username):
+    """Calculate win probability based on game position in a day."""
+    wins_by_position = defaultdict(int)
+    games_by_position = defaultdict(int)
+    current_day = None
+    game_position = 1
+
+    for game in games_sorted:
+        end_time = game.get('end_time')
+        if not end_time:
+            continue
+
+        result = get_game_result(game, username)
+
+        if result == 'win':
+            wins_by_position[game_position] += 1
+        games_by_position[game_position] += 1
+
+        game_position += 1
+
+    probabilities = {pos: (wins / games_by_position[pos] * 100) for pos, wins in wins_by_position.items()}
+    return probabilities

utils/tilt_detector.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+
+def detect_tilt_streaks(games, username, tilt_streak_count=6, tilt_time_gap=10800):
+    """Detect tilt streaks based on consecutive losses."""
+    games_sorted = sorted(games, key=lambda x: x.get('end_time'))
+    tilt_occurrences = []
+    current_streak = 0
+    streak_start_time = None
+
+    for game in games_sorted:
+        end_time = game.get('end_time')
+        if not end_time:
+            continue
+
+        end_datetime = datetime.fromtimestamp(end_time)
+        result = get_game_result(game, username)
+
+        if result in ['checkmated', 'timeout', 'resigned', 'lose', 'abandoned']:
+            if current_streak == 0:
+                streak_start_time = end_datetime
+            current_streak += 1
+
+            if current_streak >= tilt_streak_count:
+                tilt_occurrences.append({
+                    "start_time": streak_start_time,
+                    "end_time": end_datetime,
+                    "streak_length": current_streak
+                })
+                current_streak = 0
+        else:
+            current_streak = 0
+
+    return tilt_occurrences