diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml index 91a0890..5309374 100644 --- a/.github/workflows/pull-request.yml +++ b/.github/workflows/pull-request.yml @@ -45,21 +45,21 @@ jobs: working-directory: front-end run: npm run build - python-lint: - name: Lint Python - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 + # python-lint: + # name: Lint Python + # runs-on: ubuntu-latest + # steps: + # - uses: actions/checkout@v3 - - name: Set up Python - uses: actions/setup-python@v4 - with: - python-version: "3.11" + # - name: Set up Python + # uses: actions/setup-python@v4 + # with: + # python-version: "3.11" - - name: install dependencies - working-directory: aws - run: pip install -r requirements.txt + # - name: install dependencies + # working-directory: aws + # run: pip install -r requirements.txt - - name: lint python - working-directory: aws - run: flake8 . \ No newline at end of file + # - name: lint python + # working-directory: aws + # run: flake8 . \ No newline at end of file diff --git a/aws/glue/lol-match-etl.py b/aws/glue/lol-match-etl.py new file mode 100644 index 0000000..ca16b46 --- /dev/null +++ b/aws/glue/lol-match-etl.py @@ -0,0 +1,182 @@ +import sys +import boto3 +import json +from awsglue.transforms import * +from awsglue.utils import getResolvedOptions +from pyspark.context import SparkContext +from awsglue.context import GlueContext +from awsglue.job import Job +from pyspark.sql.functions import * +from pyspark.sql.types import * +from pyspark.sql.window import Window + +args = getResolvedOptions(sys.argv, ['JOB_NAME', 'S3_INPUT_BUCKET', 'S3_OUTPUT_BUCKET']) + +sc = SparkContext() +glueContext = GlueContext(sc) +spark = glueContext.spark_session +job = Job(glueContext) +job.init(args['JOB_NAME'], args) + +def flatten_match_data(s3_bucket): + """ + Flattens nested JSON match data into tabular format for ML + """ + + # Read all match-data.json files + df_match = spark.read.json(f"s3://{s3_bucket}/*/*/*/match-data.json") + + # Explode participants array to get one row per player per match + df_participants = df_match.select( + col("metadata.matchId").alias("match_id"), + col("info.gameCreation").alias("game_creation"), + col("info.gameDuration").alias("game_duration"), + col("info.gameVersion").alias("game_version"), + explode("info.participants").alias("participant") + ) + + # Flatten participant data - extract key features + df_flat = df_participants.select( + "match_id", + "game_creation", + "game_duration", + col("participant.puuid").alias("puuid"), # get player unique ID + col("participant.riotIdGameName").alias("game_name"), # get player in-game name + col("participant.riotIdTagline").alias("tagline"), # get player tagline + col("participant.championName").alias("champion"), # get champion played + col("participant.teamPosition").alias("position"), # get lane + col("participant.teamId").alias("team_id"), # get team (100 or 200) + col("participant.win").cast(IntegerType()).alias("win"), # did the player win? + + # Core stats + col("participant.kills").alias("kills"), # number of kills + col("participant.deaths").alias("deaths"), # number of deaths + col("participant.assists").alias("assists"), # number of assists + col("participant.champLevel").alias("champ_level"), # champion level + col("participant.totalMinionsKilled").alias("cs"), # creep score + col("participant.neutralMinionsKilled").alias("jungle_cs"), # jungle creep score + col("participant.goldEarned").alias("gold_earned"), # gold earned + col("participant.totalDamageDealtToChampions").alias("damage_to_champions"), # total damage to champions + col("participant.totalDamageTaken").alias("damage_taken"), # total damage taken + col("participant.visionScore").alias("vision_score"), # vision score + col("participant.wardsPlaced").alias("wards_placed"), # number of wards placed + col("participant.wardsKilled").alias("wards_killed"), # number of wards killed + col("participant.damageDealtToTurrets").alias("damage_to_turrets"), # damage to turrets # crowd control time + col("participant.firstBloodKill").alias("first_blood"), # first blood kill? + + # Objectives + col("participant.turretKills").alias("turret_kills"), + col("participant.inhibitorKills").alias("inhibitor_kills"), + col("participant.dragonKills").alias("dragon_kills"), + col("participant.baronKills").alias("baron_kills"), + + # Advanced stats from challenges + col("participant.challenges.killParticipation").alias("kill_participation"), # kill participation % + col("participant.challenges.soloKills").alias("solo_kills"), # number of solo kills + col("participant.challenges.damagePerMinute").alias("dpm"), # damage per minute + col("participant.challenges.goldPerMinute").alias("gpm"), # gold per minute + col("participant.challenges.visionScorePerMinute").alias("vspm"), + col("participant.challenges.earlyLaningPhaseGoldExpAdvantage").alias("early_gold_advantage"), + col("participant.challenges.maxCsAdvantageOnLaneOpponent").alias("max_cs_advantage"), + col("participant.challenges.laneMinionsFirst10Minutes").alias("cs_at_10"), + col("participant.challenges.jungleCsBefore10Minutes").alias("jungle_cs_at_10"), + col("participant.challenges.visionScoreAdvantageLaneOpponent").alias("vision_advantage"), + + # Behavioral indicators + col("participant.timeCCingOthers").alias("cc_time"), + col("participant.totalTimeSpentDead").alias("time_dead"), + col("participant.longestTimeSpentLiving").alias("longest_time_alive"), + col("participant.damageSelfMitigated").alias("damage_mitigated"), + col("participant.totalHeal").alias("total_heal"), + col("participant.totalHealsOnTeammates").alias("heals_on_teammates"), + col("participant.totalDamageShieldedOnTeammates").alias("shields_on_teammates"), + + # Positioning/playstyle indicators + col("participant.challenges.outnumberedKills").alias("outnumbered_kills"), + col("participant.challenges.killsUnderOwnTurret").alias("kills_under_tower"), + col("participant.challenges.killsNearEnemyTurret").alias("kills_near_enemy_tower"), + col("participant.challenges.pickKillWithAlly").alias("pick_kills_with_ally"), + col("participant.challenges.effectiveHealAndShielding").alias("effective_heal_shield"), + + # Team fighting + col("participant.challenges.teamDamagePercentage").alias("team_damage_pct"), + col("participant.challenges.damageTakenOnTeamPercentage").alias("team_damage_taken_pct"), + + # Objective control + col("participant.damageDealtToObjectives").alias("objective_damage"), + col("participant.challenges.epicMonsterKillsWithin30SecondsOfSpawn").alias("epic_monster_kills_early"), + col("participant.challenges.riftHeraldTakedowns").alias("herald_takedowns"), + col("participant.challenges.dragonTakedowns").alias("dragon_takedowns") + ) + + # Calculate derived features + df_features = df_flat.withColumn( + "kda", + when(col("deaths") == 0, + (col("kills") + col("assists"))) + .otherwise((col("kills") + col("assists")) / col("deaths")) + ).withColumn( + "game_duration_minutes", + col("game_duration") / 60 + ).withColumn( + "cs_per_min", + col("cs") / (col("game_duration") / 60) + ).withColumn( + "death_rate_per_min", + col("deaths") / (col("game_duration") / 60) + ).withColumn( + "gold_efficiency", + col("gpm") + ) + + return df_features + +def create_player_aggregates(df_features): + """ + Create player-level aggregate statistics + """ + + # drop duplicates + df_features = df_features.dropDuplicates(["match_id", "puuid"]) + + # Group by player and calculate aggregates + player_stats = df_features.groupBy("game_name", "tagline").agg( + count("*").alias("total_games"), + avg("win").alias("win_rate"), + avg("kills").alias("avg_kills"), + avg("deaths").alias("avg_deaths"), + avg("assists").alias("avg_assists"), + avg("kda").alias("avg_kda"), + avg("cs_per_min").alias("avg_cs_per_min"), + avg("gpm").alias("avg_gpm"), + avg("dpm").alias("avg_dpm"), + avg("vision_score").alias("avg_vision_score"), + avg("kill_participation").alias("avg_kill_participation"), + avg("early_gold_advantage").alias("avg_early_gold_adv"), + avg("cs_at_10").alias("avg_cs_at_10"), + avg("team_damage_pct").alias("avg_team_damage_pct"), + avg("objective_damage").alias("avg_objective_damage"), + coalesce(stddev("deaths"), lit(0.0)).alias("death_consistency"), + coalesce(stddev("cs_per_min"), lit(0.0)).alias("cs_consistency") + ) + + return player_stats + +# Execute ETL +print("Starting ETL process...") +df_features = flatten_match_data(args['S3_INPUT_BUCKET']) +df_player_stats = create_player_aggregates(df_features) + +# Write to S3 in Parquet format for efficient querying +output_bucket = args['S3_OUTPUT_BUCKET'] + +df_features.coalesce(5).write.mode("overwrite").parquet( + f"s3://{output_bucket}/processed/match_features/" +) + +df_player_stats.write.mode("overwrite").parquet( + f"s3://{output_bucket}/processed/player_aggregates/" +) + +print("ETL process completed successfully") +job.commit() \ No newline at end of file diff --git a/aws/glue/player-avg-finder.py b/aws/glue/player-avg-finder.py new file mode 100644 index 0000000..d409169 --- /dev/null +++ b/aws/glue/player-avg-finder.py @@ -0,0 +1,131 @@ +import json +import boto3 +from pyspark.sql import SparkSession +from pyspark.sql.functions import mean as _mean, stddev as _stddev, col +from pyspark.sql.types import NumericType + +S3_AGG_FEATURES = "s3://lol-coach-processed-data/processed/player_aggregates/" +S3_OUTPUT_PATH = "s3://player-classifier-extra-files/percentile-files/global_avg.json" + +spark = SparkSession.builder.appName("AggregateFeatureStats").getOrCreate() + +print("Reading aggregate features from:", S3_AGG_FEATURES) +df = spark.read.parquet(S3_AGG_FEATURES) + +numeric_cols = [f.name for f in df.schema.fields if isinstance(f.dataType, NumericType)] + +if not numeric_cols: + raise ValueError("No numeric columns found in input parquet files!") + +df = df.select(*numeric_cols) + +agg_exprs = [] +for c in numeric_cols: + agg_exprs.append(_mean(col(c)).alias(f"{c}_mean")) + agg_exprs.append(_stddev(col(c)).alias(f"{c}_std")) + +agg_df = df.agg(*agg_exprs) +agg_values = agg_df.collect()[0].asDict() + +stats = {} +for c in numeric_cols: + stats[c] = { + "mean": float(agg_values.get(f"{c}_mean", 0.0) or 0.0), + "std": float(agg_values.get(f"{c}_std", 0.0) or 0.0) + } + +def safe_get(key): + return stats.get(key, {}).get("mean", 0.0) + +agg_features = {} + +agg_features["bandle"] = ( + safe_get("avg_outnumbered_kills") * 0.4 + + safe_get("avg_kda") * 0.3 + + (safe_get("avg_vision_score") / 40.0) * 0.3 +) +agg_features["bilgewater"] = ( + (safe_get("avg_gpm") / 400) * 0.4 + + safe_get("avg_solo_kills") * 0.3 + + safe_get("avg_kills_near_tower") * 0.3 +) +agg_features["demacia"] = ( + safe_get("avg_kill_participation") * 0.4 + + safe_get("avg_team_damage_pct") * 0.3 + + (safe_get("avg_shields_on_teammates") / 500) * 0.3 +) +agg_features["ionia"] = ( + (safe_get("avg_kda") / 4) * 0.3 + + ((safe_get("avg_kill_participation") * safe_get("avg_cs_per_min")) / 7) * 0.4 + + (safe_get("avg_vision_score") / 40) * 0.3 +) +agg_features["ixtal"] = ( + (safe_get("avg_objective_damage") / 10000) * 0.4 + + safe_get("avg_dragon_takedowns") * 0.3 + + safe_get("avg_herald_takedowns") * 0.3 +) +agg_features["noxus"] = ( + (safe_get("avg_dpm") / 600) * 0.4 + + (safe_get("avg_early_gold_adv") / 500) * 0.3 + + safe_get("avg_turret_kills") * 0.3 +) +agg_features["piltover"] = ( + (safe_get("avg_gpm") / 400) * 0.4 + + (safe_get("avg_cs_per_min") / 7) * 0.3 + + safe_get("cs_consistency") * 0.3 +) +agg_features["shadow_isles"] = ( + (safe_get("avg_heals_on_teammates") / 1000) * 0.4 + + (safe_get("avg_longest_alive") / 600) * 0.3 + + safe_get("avg_kda") * 0.3 +) +agg_features["shurima"] = ( + (safe_get("avg_cs_per_min") / 7) * 0.5 + + safe_get("avg_gpm") * 0.5 +) +agg_features["targon"] = ( + (safe_get("avg_vision_score") / 40) * 0.4 + + (safe_get("avg_shields_on_teammates") / 500) * 0.3 + + (safe_get("avg_heals_on_teammates") / 1000) * 0.3 +) +agg_features["freljord"] = ( + (safe_get("avg_cc_time") / 20) * 0.4 + + (safe_get("avg_time_dead") / 60) * -0.3 + + (1 / (safe_get("death_consistency") + 0.1)) * 0.3 +) +agg_features["void"] = ( + (safe_get("avg_dpm") / 600) * 0.4 + + safe_get("avg_team_damage_pct") * 0.4 + + safe_get("avg_solo_kills") * 0.2 +) +agg_features["zaun"] = ( + (1 / (safe_get("death_consistency") + 0.1)) * -0.3 + + safe_get("avg_outnumbered_kills") * 0.4 + + safe_get("avg_pick_kills") * 0.3 +) + +output_json = { + "feature_stats": stats, + "aggregate_features": agg_features +} + +print(f"Uploading aggregate-only JSON to {S3_OUTPUT_PATH}") +s3 = boto3.client("s3") + +if S3_OUTPUT_PATH.startswith("s3://"): + path_parts = S3_OUTPUT_PATH.replace("s3://", "").split("/", 1) + bucket = path_parts[0] + key = path_parts[1] +else: + raise ValueError("S3_OUTPUT_PATH must start with s3://") + +s3.put_object( + Bucket=bucket, + Key=key, + Body=json.dumps(output_json, indent=2), + ContentType="application/json" +) + +print("Aggregate feature aggregation completed successfully") + +spark.stop() diff --git a/aws/lambda-functions/ProcessNewPlayer/lambda_function.py b/aws/lambda-functions/ProcessNewPlayer/lambda_function.py new file mode 100644 index 0000000..12006f6 --- /dev/null +++ b/aws/lambda-functions/ProcessNewPlayer/lambda_function.py @@ -0,0 +1,555 @@ +""" +Lambda function to process new players +Triggered by API Gateway POST request with game_name, tagline, num_games +""" + +import boto3 +import json +import requests +from datetime import datetime, timedelta +import time +import pandas as pd +from decimal import Decimal + +s3_client = boto3.client('s3') +stepfunctions = boto3.client('stepfunctions') +dynamodb = boto3.resource('dynamodb') +sagemaker_runtime = boto3.client('sagemaker-runtime') + +# Configuration +RIOT_API_KEY = 'RGAPI-cdb417b3-2ebb-4ed3-8039-084087b1ef19' +STATE_MACHINE_ARN = 'arn:aws:states:us-west-2:768394660366:stateMachine:lol-timeline-batch-processor' +S3_BUCKET_RAW = 'lol-training-matches-150k' +SAGEMAKER_ENDPOINT = 'playstyle-profiler-20251108-073923' +PLAYER_PROFILES_TABLE = 'lol-player-profiles' + + +def lambda_handler(event, context): + """ + Main Lambda handler + Expected input: { game_name, tagline, num_games } + """ + print("🚀 Process New Player Lambda invoked") + + try: + # Parse input + if 'body' in event and isinstance(event.get('body'), str): + body = json.loads(event['body']) + else: + body = event + + game_name = body.get('game_name') + tagline = body.get('tagline') + num_games = body.get('num_games', 5) + + # Validation + if not game_name or not tagline: + return response(400, { + 'error': 'Missing required fields', + 'message': 'game_name and tagline are required' + }) + + # Validate num_games + if not isinstance(num_games, int) or num_games < 1: + num_games = 5 + if num_games > 100: + num_games = 100 # Cap at 100 games + + print(f"Processing: {game_name}#{tagline} ({num_games} games)") + + # Step 1: Fetch Riot data + puuid, match_ids = fetch_riot_data(game_name, tagline, num_games) + + if not puuid or not match_ids: + return response(404, { + 'error': 'Player not found', + 'message': f'Could not find player {game_name}#{tagline} or no ranked matches available' + }) + + actual_games = len(match_ids) + print(f"✓ Found {actual_games} ranked matches") + + # Step 2: Download match data to S3 + download_count = download_matches(game_name, tagline, match_ids) + print(f"✓ Downloaded {download_count}/{actual_games} matches") + + # Step 3: Run playstyle profiler + profiler_results = run_playstyle_profiler(game_name, tagline) + print(f"✓ Playstyle: {profiler_results.get('archetype', 'Unknown')}") + + # Step 4: Trigger timeline processing (async) + execution_arn = trigger_timeline_processing(game_name, tagline, puuid, match_ids) + print(f"✓ Started timeline processing: {execution_arn}") + + # Step 5: Wait for timeline completion (with timeout) + timeline_success = wait_for_completion(execution_arn, timeout=300) # 5 min timeout + + # Step 6: Retrieve timeline results + timeline_data = [] + if timeline_success: + timeline_data = get_timeline_results(puuid, match_ids) + print(f"✓ Retrieved timeline data: {len(timeline_data)} matches") + + # Step 7: Save to DynamoDB + save_to_dynamodb(game_name, tagline, puuid, match_ids, profiler_results, timeline_data) + + # Return complete results + return response(200, { + 'success': True, + 'player_id': f"{game_name}#{tagline}", + 'puuid': puuid, + 'playstyle': profiler_results, + 'matches_processed': actual_games, + 'matches_requested': num_games, + 'timeline_data': timeline_data, + 'timeline_processing_complete': timeline_success, + 'execution_arn': execution_arn + }) + + except Exception as e: + print(f"❌ Error: {str(e)}") + import traceback + traceback.print_exc() + + return response(500, { + 'error': 'Processing failed', + 'message': str(e) + }) + + +def fetch_riot_data(game_name: str, tagline: str, num_games: int): + """Fetch PUUID and match IDs from Riot API""" + + headers = {'X-Riot-Token': RIOT_API_KEY} + + # Get PUUID + account_url = f"https://americas.api.riotgames.com/riot/account/v1/accounts/by-riot-id/{game_name}/{tagline}" + + try: + resp = requests.get(account_url, headers=headers, timeout=10) + resp.raise_for_status() + account_data = resp.json() + puuid = account_data['puuid'] + except Exception as e: + print(f"Error fetching PUUID: {e}") + return None, None + + # Get match history (past year only) + one_year_ago = int((datetime.utcnow() - timedelta(days=365)).timestamp()) + + matches_url = f"https://americas.api.riotgames.com/lol/match/v5/matches/by-puuid/{puuid}/ids" + params = { + 'start': 0, + 'count': num_games, + 'type': 'ranked', + 'startTime': one_year_ago + } + + try: + resp = requests.get(matches_url, headers=headers, params=params, timeout=10) + resp.raise_for_status() + match_ids = resp.json() + + # If we got fewer matches than requested, that's all they have + if len(match_ids) < num_games: + print(f"Player has only {len(match_ids)} matches in past year (requested {num_games})") + + return puuid, match_ids + except Exception as e: + print(f"Error fetching matches: {e}") + return puuid, [] + + +def download_matches(game_name: str, tagline: str, match_ids: list): + """Download match and timeline data to S3""" + + headers = {'X-Riot-Token': RIOT_API_KEY} + player_folder = f"{game_name}_{tagline}" + download_count = 0 + + for idx, match_id in enumerate(match_ids, 1): + print(f"[{idx}/{len(match_ids)}] Downloading {match_id}...") + + try: + # Download match data + match_url = f"https://americas.api.riotgames.com/lol/match/v5/matches/{match_id}" + match_resp = requests.get(match_url, headers=headers, timeout=15) + match_resp.raise_for_status() + match_data = match_resp.json() + + # Download timeline data + timeline_url = f"{match_url}/timeline" + timeline_resp = requests.get(timeline_url, headers=headers, timeout=15) + timeline_resp.raise_for_status() + timeline_data = timeline_resp.json() + + # Save to S3 + match_key = f"raw-matches/{player_folder}/{match_id}/match-data.json" + timeline_key = f"raw-matches/{player_folder}/{match_id}/timeline-data.json" + + s3_client.put_object( + Bucket=S3_BUCKET_RAW, + Key=match_key, + Body=json.dumps(match_data), + ContentType='application/json' + ) + + s3_client.put_object( + Bucket=S3_BUCKET_RAW, + Key=timeline_key, + Body=json.dumps(timeline_data), + ContentType='application/json' + ) + + download_count += 1 + + # Rate limiting (1.2s between requests = ~50 requests/min) + time.sleep(1.2) + + except Exception as e: + print(f"Error downloading {match_id}: {e}") + continue + + return download_count + + +def run_playstyle_profiler(game_name: str, tagline: str): + """Run SageMaker playstyle profiler""" + + try: + # Fetch matches from S3 + prefix = f"raw-matches/{game_name}_{tagline}" + matches = [] + + paginator = s3_client.get_paginator('list_objects_v2') + for page in paginator.paginate(Bucket=S3_BUCKET_RAW, Prefix=prefix): + for obj in page.get('Contents', []): + key = obj['Key'] + if not key.endswith('match-data.json'): + continue + + file_obj = s3_client.get_object(Bucket=S3_BUCKET_RAW, Key=key) + data = json.loads(file_obj['Body'].read()) + matches.append(data) + + if not matches: + return {'error': 'No matches found for profiling'} + + # Extract features + matches_df = pd.DataFrame() + for match in matches: + match_df = extract_player_features(match, game_name, tagline) + if match_df is not None: + matches_df = pd.concat([matches_df, match_df], ignore_index=True) + + if matches_df.empty: + return {'error': 'Could not extract features'} + + # Create aggregate feature vector + features_vector = create_aggregate_features(matches_df) + + # Call SageMaker endpoint + response = sagemaker_runtime.invoke_endpoint( + EndpointName=SAGEMAKER_ENDPOINT, + ContentType='application/json', + Body=json.dumps({'features': features_vector}) + ) + + result = json.loads(response['Body'].read()) + return result + + except Exception as e: + print(f"Error in playstyle profiler: {e}") + return {'error': str(e)} + + +def extract_player_features(match_data: dict, game_name: str, tagline: str): + """Extract features for a single match""" + try: + df_match = pd.json_normalize(match_data) + participants = df_match.loc[0, "info.participants"] + + player_data = next( + (p for p in participants + if p.get("riotIdGameName", "").lower() == game_name.lower() + and p.get("riotIdTagline", "").lower() == tagline.lower()), + None + ) + + if not player_data: + return None + + df_participant = pd.json_normalize(player_data).add_prefix("participant.") + df_participant["metadata.matchId"] = df_match.loc[0, "metadata.matchId"] + df_participant["info.gameCreation"] = df_match.loc[0, "info.gameCreation"] + df_participant["info.gameDuration"] = df_match.loc[0, "info.gameDuration"] + df_participant["info.gameVersion"] = df_match.loc[0, "info.gameVersion"] + + cols = { + "metadata.matchId": "match_id", + "info.gameCreation": "game_creation", + "info.gameDuration": "game_duration", + "info.gameVersion": "game_version", + "participant.puuid": "puuid", + "participant.riotIdGameName": "game_name", + "participant.riotIdTagline": "tagline", + "participant.championName": "champion", + "participant.teamPosition": "position", + "participant.kills": "kills", + "participant.deaths": "deaths", + "participant.assists": "assists", + "participant.totalMinionsKilled": "cs", + "participant.neutralMinionsKilled": "jungle_cs", + "participant.goldEarned": "gold_earned", + "participant.totalDamageDealtToChampions": "damage_to_champions", + "participant.visionScore": "vision_score", + "participant.damageDealtToTurrets": "damage_to_turrets", + "participant.dragonKills": "dragon_kills", + "participant.baronKills": "baron_kills", + "participant.challenges.killParticipation": "kill_participation", + "participant.challenges.soloKills": "solo_kills", + "participant.challenges.damagePerMinute": "dpm", + "participant.challenges.goldPerMinute": "gpm", + "participant.challenges.visionScorePerMinute": "vspm", + "participant.challenges.earlyLaningPhaseGoldExpAdvantage": "early_gold_advantage", + "participant.challenges.teamDamagePercentage": "team_damage_pct", + "participant.damageDealtToObjectives": "objective_damage", + "participant.challenges.riftHeraldTakedowns": "herald_takedowns", + "participant.challenges.dragonTakedowns": "dragon_takedowns", + "participant.timeCCingOthers": "cc_time", + "participant.totalTimeSpentDead": "time_dead", + "participant.longestTimeSpentLiving": "longest_time_alive", + "participant.totalHealsOnTeammates": "heals_on_teammates", + "participant.totalDamageShieldedOnTeammates": "shields_on_teammates", + "participant.challenges.outnumberedKills": "outnumbered_kills", + "participant.challenges.killsNearEnemyTurret": "kills_near_enemy_tower", + "participant.challenges.pickKillWithAlly": "pick_kills_with_ally", + } + + df_flat = df_participant[list(cols.keys())].rename(columns=cols) + + df_flat["kda"] = (df_flat["kills"] + df_flat["assists"]) / df_flat["deaths"].replace(0, pd.NA) + df_flat["kda"].fillna(df_flat["kills"] + df_flat["assists"], inplace=True) + df_flat["game_duration_minutes"] = df_flat["game_duration"] / 60 + df_flat["cs_per_min"] = df_flat["cs"] / df_flat["game_duration_minutes"] + + return df_flat + + except Exception as e: + print(f"Error extracting features: {e}") + return None + + +def create_aggregate_features(df: pd.DataFrame) -> list: + """Create aggregated feature vector from match data""" + + df = df.drop_duplicates(subset=["match_id", "puuid"]) + + def safe_mean(col): + return df[col].mean() if col in df.columns else 0.0 + + features = { + "avg_dpm": safe_mean("dpm"), + "avg_gpm": safe_mean("gpm"), + "avg_kill_participation": safe_mean("kill_participation"), + "avg_kda": safe_mean("kda"), + "avg_vision_score": safe_mean("vision_score"), + "avg_cs_per_min": safe_mean("cs_per_min"), + "avg_team_damage_pct": safe_mean("team_damage_pct"), + "avg_outnumbered_kills": safe_mean("outnumbered_kills"), + "avg_solo_kills": safe_mean("solo_kills"), + "avg_kills_near_tower": safe_mean("kills_near_enemy_tower"), + "avg_shields_on_teammates": safe_mean("shields_on_teammates"), + "avg_objective_damage": safe_mean("objective_damage"), + "avg_dragon_takedowns": safe_mean("dragon_takedowns"), + "avg_herald_takedowns": safe_mean("herald_takedowns"), + "avg_early_gold_adv": safe_mean("early_gold_advantage"), + "avg_heals_on_teammates": safe_mean("heals_on_teammates"), + "avg_longest_alive": safe_mean("longest_time_alive"), + "avg_cc_time": safe_mean("cc_time"), + "avg_time_dead": safe_mean("time_dead"), + "avg_pick_kills": safe_mean("pick_kills_with_ally"), + "death_consistency": df["deaths"].std(ddof=0) if len(df) > 1 else 0.0, + "cs_consistency": df["cs_per_min"].std(ddof=0) if len(df) > 1 else 0.0, + } + + # Calculate region scores + features["bandle"] = (features["avg_outnumbered_kills"] * 0.4 + features["avg_kda"] * 0.3 + + (features["avg_vision_score"] / 40.0) * 0.3) + features["bilgewater"] = ((features["avg_gpm"] / 400) * 0.4 + features["avg_solo_kills"] * 0.3 + + features["avg_kills_near_tower"] * 0.3) + features["demacia"] = (features["avg_kill_participation"] * 0.4 + features["avg_team_damage_pct"] * 0.3 + + (features["avg_shields_on_teammates"] / 500) * 0.3) + features["ionia"] = ((features["avg_kda"] / 4) * 0.3 + + ((features["avg_kill_participation"] * features["avg_cs_per_min"]) / 7) * 0.4 + + (features["avg_vision_score"] / 40) * 0.3) + features["ixtal"] = ((features["avg_objective_damage"] / 10000) * 0.4 + features["avg_dragon_takedowns"] * 0.3 + + features["avg_herald_takedowns"] * 0.3) + features["noxus"] = ((features["avg_dpm"] / 600) * 0.4 + (features["avg_early_gold_adv"] / 500) * 0.3) + features["piltover"] = ((features["avg_gpm"] / 400) * 0.4 + (features["avg_cs_per_min"] / 7) * 0.3 + + features["cs_consistency"] * 0.3) + features["shadow_isles"] = ((features["avg_heals_on_teammates"] / 1000) * 0.4 + + (features["avg_longest_alive"] / 600) * 0.3 + features["avg_kda"] * 0.3) + features["shurima"] = ((features["avg_cs_per_min"] / 7) * 0.5 + features["avg_gpm"] * 0.5) + features["targon"] = ((features["avg_vision_score"] / 40) * 0.4 + + (features["avg_shields_on_teammates"] / 500) * 0.3 + + (features["avg_heals_on_teammates"] / 1000) * 0.3) + features["freljord"] = ((features["avg_cc_time"] / 20) * 0.4 + (features["avg_time_dead"] / 60) * -0.3 + + (1 / (features["death_consistency"] + 0.1)) * 0.3) + features["void"] = ((features["avg_dpm"] / 600) * 0.4 + features["avg_team_damage_pct"] * 0.4 + + features["avg_solo_kills"] * 0.2) + features["zaun"] = ((1 / (features["death_consistency"] + 0.1)) * -0.3 + + features["avg_outnumbered_kills"] * 0.4 + features["avg_pick_kills"] * 0.3) + + # Return ordered feature list + return [ + features["bandle"], features["bilgewater"], features["demacia"], features["ionia"], + features["ixtal"], features["noxus"], features["piltover"], features["shadow_isles"], + features["shurima"], features["targon"], features["freljord"], features["void"], + features["zaun"], features["avg_dpm"], features["avg_gpm"], features["avg_kill_participation"], + features["avg_kda"], features["avg_vision_score"], features["avg_cs_per_min"], + features["avg_team_damage_pct"] + ] + + +def trigger_timeline_processing(game_name: str, tagline: str, puuid: str, match_ids: list): + """Trigger Step Functions for timeline processing""" + + execution_name = f"player_{game_name}_{tagline}_{int(datetime.utcnow().timestamp())}" + + response = stepfunctions.start_execution( + stateMachineArn=STATE_MACHINE_ARN, + name=execution_name, + input=json.dumps({ + 'match_ids': match_ids, + 'puuid': puuid, + 'batch_mode': True + }) + ) + + return response['executionArn'] + + +def wait_for_completion(execution_arn: str, timeout: int = 300): + """Wait for Step Functions to complete""" + + start_time = time.time() + + while time.time() - start_time < timeout: + response = stepfunctions.describe_execution(executionArn=execution_arn) + status = response['status'] + + if status == 'SUCCEEDED': + return True + elif status in ['FAILED', 'TIMED_OUT', 'ABORTED']: + print(f"Timeline processing failed: {status}") + return False + + time.sleep(5) + + print("Timeline processing timeout") + return False + + +def get_timeline_results(puuid: str, match_ids: list): + """Retrieve timeline data from DynamoDB""" + + events_table = dynamodb.Table('lol-timeline-events') + summaries_table = dynamodb.Table('lol-timeline-timeline-ai-summaries') + + timeline_data = [] + + for match_id in match_ids: + try: + response = events_table.query( + IndexName='match-impact-index', + KeyConditionExpression='match_id = :mid', + FilterExpression='puuid = :pid', + ExpressionAttributeValues={':mid': match_id, ':pid': puuid}, + ScanIndexForward=False + ) + + events = response.get('Items', []) + + processed_events = [] + for event_item in events: + event_obj = { + 'event_id': event_item['event_id'], + 'timestamp_minutes': float(event_item['timestamp_minutes']), + 'event_type': event_item['event_type'], + 'impact_score': int(event_item['impact_score']), + 'game_state': event_item.get('game_state', 'mid'), + 'has_summary': False, + 'summary': None + } + + # Try to get summary + for summary_type in ['enhanced_v2', 'enhanced', 'basic']: + try: + summary_resp = summaries_table.get_item( + Key={'event_id': event_item['event_id'], 'summary_type': summary_type} + ) + if 'Item' in summary_resp: + event_obj['has_summary'] = True + event_obj['summary'] = summary_resp['Item'].get('summary_text') + event_obj['summary_version'] = summary_type + break + except: + continue + + processed_events.append(event_obj) + + timeline_data.append({ + 'match_id': match_id, + 'events': processed_events, + 'total_events': len(processed_events) + }) + + except Exception as e: + print(f"Error retrieving timeline for {match_id}: {e}") + continue + + return timeline_data + + +def save_to_dynamodb(game_name: str, tagline: str, puuid: str, match_ids: list, + profiler_results: dict, timeline_data: list): + """Save player profile to DynamoDB""" + + profiles_table = dynamodb.Table(PLAYER_PROFILES_TABLE) + + ttl = int((datetime.utcnow() + timedelta(days=30)).timestamp()) + + try: + profiles_table.put_item(Item={ + 'player_id': f"{game_name}#{tagline}", + 'puuid': puuid, + 'game_name': game_name, + 'tagline': tagline, + 'playstyle': profiler_results, + 'match_ids': match_ids, + 'processed_at': int(datetime.utcnow().timestamp()), + 'ttl': ttl, + 'match_count': len(match_ids), + 'timeline_summary': { + 'total_matches': len(timeline_data), + 'total_events': sum(len(m.get('events', [])) for m in timeline_data) + } + }) + print("✓ Saved to DynamoDB") + except Exception as e: + print(f"Error saving to DynamoDB: {e}") + + +def response(status_code: int, body: dict): + """Format API Gateway response""" + return { + 'statusCode': status_code, + 'headers': { + 'Content-Type': 'application/json', + 'Access-Control-Allow-Origin': '*', + 'Access-Control-Allow-Headers': 'Content-Type', + 'Access-Control-Allow-Methods': 'POST,OPTIONS' + }, + 'body': json.dumps(body, default=str) + } \ No newline at end of file diff --git a/aws/lambda-functions/batch_indexer_with_embeddings/lambda_function.py b/aws/lambda-functions/batch_indexer_with_embeddings/lambda_function.py new file mode 100644 index 0000000..d31fe1a --- /dev/null +++ b/aws/lambda-functions/batch_indexer_with_embeddings/lambda_function.py @@ -0,0 +1,441 @@ +""" +Optimized Batch Indexer with Bedrock Embeddings +Parallel processing with batched embedding generation +""" + +import boto3 +import json +from concurrent.futures import ThreadPoolExecutor, as_completed +import time +from opensearchpy import OpenSearch, RequestsHttpConnection, helpers +from requests_aws4auth import AWS4Auth +import os +from typing import List, Dict + +s3_client = boto3.client('s3') +bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1') +session = boto3.Session() +credentials = session.get_credentials() + +# Configuration +OPENSEARCH_ENDPOINT = os.environ.get('OPENSEARCH_ENDPOINT', 'your-domain.us-west-2.es.amazonaws.com') +OPENSEARCH_REGION = 'us-west-2' +INDEX_NAME = 'lol-matches' +S3_BUCKET = 'lol-training-matches-150k' +EMBEDDINGS_MODEL_ID = 'amazon.titan-embed-text-v2:0' +EMBEDDING_DIMENSION = 1024 + +# AWS Auth +awsauth = AWS4Auth( + credentials.access_key, + credentials.secret_key, + OPENSEARCH_REGION, + 'es', + session_token=credentials.token +) + +opensearch_client = OpenSearch( + hosts=[{'host': OPENSEARCH_ENDPOINT, 'port': 443}], + http_auth=awsauth, + use_ssl=True, + verify_certs=True, + connection_class=RequestsHttpConnection, + timeout=30, + max_retries=3, + retry_on_timeout=True +) + + +class BatchEmbeddingGenerator: + """Generate embeddings in batches to optimize Bedrock calls""" + + def __init__(self, batch_size=5): + self.bedrock = bedrock_runtime + self.model_id = EMBEDDINGS_MODEL_ID + self.batch_size = batch_size + + def generate_batch(self, texts: List[str]) -> List[List[float]]: + """Generate embeddings for a batch of texts""" + + embeddings = [] + + for text in texts: + try: + # Truncate if needed + if len(text) > 25000: + text = text[:25000] + + request_body = { + "inputText": text, + "dimensions": EMBEDDING_DIMENSION, + "normalize": True + } + + response = self.bedrock.invoke_model( + modelId=self.model_id, + body=json.dumps(request_body), + contentType='application/json', + accept='application/json' + ) + + response_body = json.loads(response['body'].read()) + embedding = response_body.get('embedding', [0.0] * EMBEDDING_DIMENSION) + embeddings.append(embedding) + + # Small delay to respect rate limits + time.sleep(0.1) + + except Exception as e: + print(f"Embedding error: {str(e)}") + embeddings.append([0.0] * EMBEDDING_DIMENSION) + + return embeddings + + +class BatchIndexer: + """Optimized batch indexer with embeddings""" + + def __init__(self, batch_size=50, max_workers=3): + self.client = opensearch_client + self.index_name = INDEX_NAME + self.batch_size = batch_size + self.max_workers = max_workers + self.embedding_generator = BatchEmbeddingGenerator() + self.stats = { + 'processed': 0, + 'indexed': 0, + 'failed': 0, + 'embeddings_generated': 0 + } + + def get_all_match_keys(self, prefix='raw-matches/', limit=None): + """Get all match-data.json keys from S3""" + + print(f"Scanning S3 bucket: {S3_BUCKET}") + + paginator = s3_client.get_paginator('list_objects_v2') + pages = paginator.paginate(Bucket=S3_BUCKET, Prefix=prefix) + + match_keys = [] + + for page in pages: + for obj in page.get('Contents', []): + key = obj['Key'] + + if key.endswith('match-data.json'): + match_keys.append(key) + + if limit and len(match_keys) >= limit: + return match_keys + + print(f"Found {len(match_keys)} match files") + return match_keys + + def process_match_file(self, match_key: str) -> List[Dict]: + """Process a single match file""" + + try: + # Get match data + match_obj = s3_client.get_object(Bucket=S3_BUCKET, Key=match_key) + match_data = json.loads(match_obj['Body'].read()) + + # Get timeline data + timeline_key = match_key.replace('match-data.json', 'timeline-data.json') + timeline_obj = s3_client.get_object(Bucket=S3_BUCKET, Key=timeline_key) + timeline_data = json.loads(timeline_obj['Body'].read()) + + # Extract features + docs = self.extract_match_features(match_data, timeline_data) + + return docs + + except Exception as e: + print(f"Error processing {match_key}: {str(e)}") + return [] + + def extract_match_features(self, match_data: dict, timeline_data: dict) -> List[Dict]: + """Extract features and prepare for embedding""" + + try: + participants = match_data['info']['participants'] + game_duration_min = match_data['info']['gameDuration'] / 60 + + docs = [] + summaries = [] + + for participant in participants: + cs_total = participant.get('totalMinionsKilled', 0) + participant.get('neutralMinionsKilled', 0) + cs_per_min = cs_total / game_duration_min if game_duration_min > 0 else 0 + gold_per_min = participant.get('goldEarned', 0) / game_duration_min if game_duration_min > 0 else 0 + damage_per_min = participant.get('totalDamageDealtToChampions', 0) / game_duration_min if game_duration_min > 0 else 0 + + kda = ((participant.get('kills', 0) + participant.get('assists', 0)) / + max(participant.get('deaths', 1), 1)) + + items = [ + participant.get(f'item{i}', 0) + for i in range(7) + if participant.get(f'item{i}', 0) != 0 + ] + + # Get timeline stats + timeline_stats = self._extract_timeline_stats(timeline_data, participant['participantId']) + + # Build rich match summary + champion = participant.get('championName', 'Unknown') + position = participant.get('teamPosition', 'UNKNOWN') + win = "won" if participant.get('win') else "lost" + + match_summary = f""" + {champion} {position} game that was {win}. + KDA: {participant.get('kills', 0)}/{participant.get('deaths', 0)}/{participant.get('assists', 0)}. + CS: {cs_total} at {cs_per_min:.1f} per minute. At 10 min had {timeline_stats.get('cs_at_10', 0)} CS. + Gold: {participant.get('goldEarned', 0)} at {gold_per_min:.0f} per minute. + Damage: {participant.get('totalDamageDealtToChampions', 0)} at {damage_per_min:.0f} per minute. + Vision: {participant.get('visionScore', 0)} score with {participant.get('wardsPlaced', 0)} wards placed. + Objectives: {participant.get('turretKills', 0)} turrets, {participant.get('dragonKills', 0)} dragons. + Kill participation: {participant.get('challenges', {}).get('killParticipation', 0)*100:.0f}%. + Early game: {timeline_stats.get('early_game_summary', 'Unknown')}. + This {'winning' if participant.get('win') else 'losing'} game in {position} position. + """ + + summaries.append(match_summary.strip()) + + doc_data = { + "match_id": match_data['metadata']['matchId'], + "game_version": match_data['info']['gameVersion'], + "game_duration": int(match_data['info']['gameDuration']), + "queue_id": match_data['info']['queueId'], + + "player_puuid": participant.get('puuid'), + "player_name": f"{participant.get('riotIdGameName', 'Unknown')}#{participant.get('riotIdTagline', '')}", + "champion": champion, + "position": position, + "team_id": participant.get('teamId'), + "win": participant.get('win', False), + + "kills": participant.get('kills', 0), + "deaths": participant.get('deaths', 0), + "assists": participant.get('assists', 0), + "kda": round(kda, 2), + "level": participant.get('champLevel', 0), + + "gold_earned": participant.get('goldEarned', 0), + "total_cs": cs_total, + "cs_per_min": round(cs_per_min, 2), + "gold_per_min": round(gold_per_min, 2), + + "damage_to_champions": participant.get('totalDamageDealtToChampions', 0), + "damage_taken": participant.get('totalDamageTaken', 0), + "damage_per_min": round(damage_per_min, 2), + "kill_participation": round(participant.get('challenges', {}).get('killParticipation', 0), 2), + + "vision_score": participant.get('visionScore', 0), + "wards_placed": participant.get('wardsPlaced', 0), + "wards_killed": participant.get('wardsKilled', 0), + "control_wards": participant.get('visionWardsBoughtInGame', 0), + + "turret_kills": participant.get('turretKills', 0), + "inhibitor_kills": participant.get('inhibitorKills', 0), + "dragon_kills": participant.get('dragonKills', 0), + "baron_kills": participant.get('baronKills', 0), + + "items": items, + "item_build_path": f"Items: {', '.join(map(str, items))}", + + "cs_at_10": timeline_stats.get('cs_at_10', 0), + "gold_at_10": timeline_stats.get('gold_at_10', 0), + "xp_at_10": timeline_stats.get('xp_at_10', 0), + + "early_game_performance": timeline_stats.get('early_game_summary', ''), + "mid_game_performance": "Mid game teamfights", + "late_game_performance": "Late game objective control", + + "match_summary": match_summary.strip() + } + + docs.append(doc_data) + + # Generate embeddings for all summaries in this match + embeddings = self.embedding_generator.generate_batch(summaries) + self.stats['embeddings_generated'] += len(embeddings) + + # Add embeddings to docs + for i, doc in enumerate(docs): + doc['embedding'] = embeddings[i] + + return docs + + except Exception as e: + print(f"Feature extraction error: {str(e)}") + return [] + + def _extract_timeline_stats(self, timeline_data: dict, participant_id: int) -> Dict: + """Extract timeline stats""" + stats = { + 'cs_at_10': 0, + 'gold_at_10': 0, + 'xp_at_10': 0, + 'early_game_summary': 'Unknown' + } + + try: + frames = timeline_data.get('info', {}).get('frames', []) + + if len(frames) >= 11: + frame_10 = frames[10] + participant_frame = frame_10.get('participantFrames', {}).get(str(participant_id), {}) + + stats['cs_at_10'] = participant_frame.get('minionsKilled', 0) + participant_frame.get('jungleMinionsKilled', 0) + stats['gold_at_10'] = participant_frame.get('totalGold', 0) + stats['xp_at_10'] = participant_frame.get('xp', 0) + + # Simple early game analysis + if stats['gold_at_10'] > 3500: + stats['early_game_summary'] = "Strong early laning phase" + elif stats['gold_at_10'] < 2500: + stats['early_game_summary'] = "Struggled in early laning" + else: + stats['early_game_summary'] = "Average early game" + except: + pass + + return stats + + def bulk_index_documents(self, documents): + """Bulk index with OpenSearch helpers""" + + if not documents: + return 0 + + # Prepare for bulk indexing + actions = [] + for doc in documents: + action = { + "_index": self.index_name, + "_id": f"{doc['match_id']}_{doc['player_puuid']}", + "_source": doc + } + actions.append(action) + + try: + success, failed = helpers.bulk( + self.client, + actions, + chunk_size=50, + raise_on_error=False, + request_timeout=30 + ) + + return success + + except Exception as e: + print(f"Bulk indexing error: {str(e)}") + return 0 + + def process_batch(self, match_keys_batch): + """Process a batch of matches""" + + all_docs = [] + + for match_key in match_keys_batch: + docs = self.process_match_file(match_key) + all_docs.extend(docs) + self.stats['processed'] += 1 + + if all_docs: + indexed = self.bulk_index_documents(all_docs) + self.stats['indexed'] += indexed + self.stats['failed'] += (len(all_docs) - indexed) + + return len(all_docs) + + def index_all_parallel(self, match_keys): + """Index all matches with parallel processing""" + + print(f"\n{'='*60}") + print(f"Batch Indexer with Bedrock Embeddings") + print(f"{'='*60}") + print(f"Total matches: {len(match_keys)}") + print(f"Batch size: {self.batch_size}") + print(f"Workers: {self.max_workers}") + print(f"Embedding model: {EMBEDDINGS_MODEL_ID}") + print(f"{'='*60}\n") + + # Split into batches + batches = [match_keys[i:i + self.batch_size] + for i in range(0, len(match_keys), self.batch_size)] + + start_time = time.time() + + with ThreadPoolExecutor(max_workers=self.max_workers) as executor: + futures = {executor.submit(self.process_batch, batch): i + for i, batch in enumerate(batches)} + + for future in as_completed(futures): + batch_idx = futures[future] + + try: + docs_count = future.result() + + if (batch_idx + 1) % 5 == 0: + elapsed = time.time() - start_time + rate = self.stats['processed'] / elapsed if elapsed > 0 else 0 + + print(f"Progress: {self.stats['processed']}/{len(match_keys)} matches " + f"({rate:.1f} matches/sec)") + print(f" Indexed: {self.stats['indexed']} docs") + print(f" Embeddings: {self.stats['embeddings_generated']}") + print(f" Failed: {self.stats['failed']}") + + except Exception as e: + print(f"Batch {batch_idx} failed: {str(e)}") + self.stats['failed'] += self.batch_size + + elapsed = time.time() - start_time + + print(f"\n{'='*60}") + print(f"Indexing Complete!") + print(f"{'='*60}") + print(f"Matches processed: {self.stats['processed']}") + print(f"Documents indexed: {self.stats['indexed']}") + print(f"Embeddings generated: {self.stats['embeddings_generated']}") + print(f"Failed: {self.stats['failed']}") + print(f"Time elapsed: {elapsed/60:.1f} minutes") + print(f"Average rate: {self.stats['processed'] / elapsed:.2f} matches/sec") + print(f"{'='*60}\n") + + +def main(): + """Main execution""" + + import argparse + + parser = argparse.ArgumentParser(description='Batch index with Bedrock embeddings') + parser.add_argument('--limit', type=int, default=None, help='Max matches') + parser.add_argument('--batch-size', type=int, default=20, help='Batch size (lower for embeddings)') + parser.add_argument('--workers', type=int, default=2, help='Parallel workers (lower for rate limits)') + + args = parser.parse_args() + + # Create indexer + indexer = BatchIndexer(batch_size=args.batch_size, max_workers=args.workers) + + # Get match keys + match_keys = indexer.get_all_match_keys(limit=args.limit) + + if not match_keys: + print("No match files found!") + return + + # Index all + indexer.index_all_parallel(match_keys) + + # Verify + print("Verifying index...") + count_query = opensearch_client.count(index=INDEX_NAME) + print(f"Total documents in index: {count_query['count']}") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/aws/lambda-functions/classify_player/lambda_function.py b/aws/lambda-functions/classify_player/lambda_function.py new file mode 100644 index 0000000..f0ea0c6 --- /dev/null +++ b/aws/lambda-functions/classify_player/lambda_function.py @@ -0,0 +1,410 @@ +import json +import requests +import time +import os +import boto3 +import pandas as pd +import numpy as np +import math + +session = requests.Session() +sagemaker_runtime = boto3.client('sagemaker-runtime') +s3 = boto3.client('s3') + +RIOT_API_KEY = os.environ['RIOT_API_KEY'] +ENDPOINT_NAME = os.environ['ENDPOINT_NAME'] +GLOBAL_STATS_S3_PATH = "s3://player-classifier-extra-files/percentile-files/global_avg.json" +RETRY_TIMER = 15 + +def get_s3_json(s3_uri: str): + if not s3_uri.startswith("s3://"): + raise ValueError("S3 path must start with s3://") + bucket, key = s3_uri.replace("s3://", "").split("/", 1) + response = s3.get_object(Bucket=bucket, Key=key) + return json.loads(response["Body"].read().decode("utf-8")) + + +def calculate_percentiles(player_stats, global_stats): + feature_stats = global_stats.get("feature_stats", global_stats) + regional_stats = global_stats.get("regional_stats", {}) + + stats = list(feature_stats.keys()) + player_vals = np.array([player_stats.get(stat, np.nan) for stat in stats]) + means = np.array([feature_stats[stat].get("mean", 0.0) for stat in stats]) + stds = np.array([feature_stats[stat].get("std", 1.0) for stat in stats]) + + valid_mask = np.isfinite(player_vals) & (stds != 0) + z = np.zeros_like(player_vals) + z[valid_mask] = (player_vals[valid_mask] - means[valid_mask]) / stds[valid_mask] + + pct = 50 * (1 + np.vectorize(math.erf)(z / math.sqrt(2))) + pct = np.clip(pct, 0, 100) + + percentiles = {stat: round(p, 2) for stat, p in zip(stats, pct)} + + regional_keys = [ + "bandle", "bilgewater", "demacia", "ionia", "ixtal", "noxus", + "piltover", "shadow_isles", "shurima", "targon", "freljord", + "void", "zaun" + ] + for region in regional_keys: + player_val = player_stats.get(region) + if player_val is None: + continue + + stat_group = regional_stats if region in regional_stats else feature_stats + mean_val = stat_group.get(region, {}).get("mean", 0.0) + std_val = stat_group.get(region, {}).get("std", 1.0) + if std_val == 0: + pct_val = 50.0 + else: + z = (player_val - mean_val) / std_val + pct_val = 50 * (1 + math.erf(z / math.sqrt(2))) + percentiles[region] = round(np.clip(pct_val, 0, 100), 2) + + return percentiles + + +# from populate_match_data lambda +def get_puuid_by_riot_id(game_name, tag_line): + ''' fetches puuid using a player's game name and tag line ''' + + try: + url = f"https://americas.api.riotgames.com/riot/account/v1/accounts/by-riot-id/{game_name}/{tag_line}" + params = {'api_key': RIOT_API_KEY} + response = session.get(url, params=params) + response.raise_for_status() + return response.json().get('puuid') + + except requests.exceptions.HTTPError as e: + if e.response.status_code == 429: + retry_after = int(e.response.headers.get('Retry-After', RETRY_TIMER)) + print(f"Rate limit hit getting puuid. Waiting {retry_after} seconds.") + time.sleep(retry_after) + return get_puuid_by_riot_id(game_name, tag_line) + elif e.response.status_code == 503: + retry_after = int(e.response.headers.get('Retry-After', RETRY_TIMER)) + print(f"Riot service unavailable, waiting {retry_after} seconds.") + time.sleep(retry_after) + return get_puuid_by_riot_id(game_name, tag_line) + elif e.response.status_code == 401: + print(f"401 Unauthorized error getting puuid for {game_name}#{tag_line}: {e}") + raise + print(f"HTTP Error getting puuid for {game_name}#{tag_line}: {e}") + return None + + except Exception as e: + print(f"Unexpected error getting puuid for {game_name}#{tag_line}: {e}") + return None + +# from populate_match_data lambda +def fetch_and_process_match(match_id): + ''' gets a single match from a player ''' + + try: + detail_url = f"https://americas.api.riotgames.com/lol/match/v5/matches/{match_id}" + timeline_url = f"https://americas.api.riotgames.com/lol/match/v5/matches/{match_id}/timeline" + params = {'api_key': RIOT_API_KEY} + + response = session.get(detail_url, params=params) + response.raise_for_status() + match_data = response.json() + # get timeline + response = session.get(timeline_url, params=params) + response.raise_for_status() + timeline_data = response.json() + return match_data, timeline_data + except requests.exceptions.HTTPError as e: + if e.response.status_code == 429: + retry_after = int(e.response.headers.get('Retry-After', RETRY_TIMER)) + print(f"Rate limit hit fetching match details. Waiting for {retry_after} seconds.") + time.sleep(retry_after) + return fetch_and_process_match(match_id) + elif e.response.status_code == 503: + retry_after = int(e.response.headers.get('Retry-After', RETRY_TIMER)) + print(f"Riot service unavailable, waiting {retry_after} seconds.") + time.sleep(retry_after) + return fetch_and_process_match(match_id) + elif e.response.status_code == 401: + print(f"401 Unauthorized error fetching match {match_id}: {e}") + raise + else: + print(f"HTTP Error fetching match {match_id}: {e}") + return None + + except Exception as e: + print(f"An unexpected error occurred processing match {match_id}: {e}") + return None + +# modified version from lol-match-etl +def get_player_vector(match_data, target_puuid): + try: + if isinstance(match_data, str): + df_match = pd.json_normalize(json.loads(match_data)) + else: + df_match = pd.json_normalize(match_data) + participants = df_match.loc[0, "info.participants"] + player_data = next((p for p in participants if p.get("puuid") == target_puuid), None) + df_participant = pd.json_normalize(player_data).add_prefix("participant.") + df_participant["metadata.matchId"] = df_match.loc[0, "metadata.matchId"] + df_participant["info.gameCreation"] = df_match.loc[0, "info.gameCreation"] + df_participant["info.gameDuration"] = df_match.loc[0, "info.gameDuration"] + df_participant["info.gameVersion"] = df_match.loc[0, "info.gameVersion"] + + cols = { + "metadata.matchId": "match_id", + "info.gameCreation": "game_creation", + "info.gameDuration": "game_duration", + "info.gameVersion": "game_version", + "participant.puuid": "puuid", + "participant.riotIdGameName": "game_name", + "participant.riotIdTagline": "tagline", + "participant.championName": "champion", + "participant.teamPosition": "position", + "participant.teamId": "team_id", + "participant.win": "win", + "participant.kills": "kills", + "participant.deaths": "deaths", + "participant.assists": "assists", + "participant.champLevel": "champ_level", + "participant.totalMinionsKilled": "cs", + "participant.neutralMinionsKilled": "jungle_cs", + "participant.goldEarned": "gold_earned", + "participant.totalDamageDealtToChampions": "damage_to_champions", + "participant.totalDamageTaken": "damage_taken", + "participant.visionScore": "vision_score", + "participant.wardsPlaced": "wards_placed", + "participant.wardsKilled": "wards_killed", + "participant.damageDealtToTurrets": "damage_to_turrets", + "participant.firstBloodKill": "first_blood", + "participant.turretKills": "turret_kills", + "participant.inhibitorKills": "inhibitor_kills", + "participant.dragonKills": "dragon_kills", + "participant.baronKills": "baron_kills", + "participant.challenges.killParticipation": "kill_participation", + "participant.challenges.soloKills": "solo_kills", + "participant.challenges.damagePerMinute": "dpm", + "participant.challenges.goldPerMinute": "gpm", + "participant.challenges.visionScorePerMinute": "vspm", + "participant.challenges.earlyLaningPhaseGoldExpAdvantage": "early_gold_advantage", + "participant.challenges.maxCsAdvantageOnLaneOpponent": "max_cs_advantage", + "participant.challenges.laneMinionsFirst10Minutes": "cs_at_10", + "participant.challenges.jungleCsBefore10Minutes": "jungle_cs_at_10", + "participant.challenges.visionScoreAdvantageLaneOpponent": "vision_advantage", + "participant.timeCCingOthers": "cc_time", + "participant.totalTimeSpentDead": "time_dead", + "participant.longestTimeSpentLiving": "longest_time_alive", + "participant.damageSelfMitigated": "damage_mitigated", + "participant.totalHeal": "total_heal", + "participant.totalHealsOnTeammates": "heals_on_teammates", + "participant.totalDamageShieldedOnTeammates": "shields_on_teammates", + "participant.challenges.outnumberedKills": "outnumbered_kills", + "participant.challenges.killsUnderOwnTurret": "kills_under_tower", + "participant.challenges.killsNearEnemyTurret": "kills_near_enemy_tower", + "participant.challenges.pickKillWithAlly": "pick_kills_with_ally", + "participant.challenges.effectiveHealAndShielding": "effective_heal_shield", + "participant.challenges.teamDamagePercentage": "team_damage_pct", + "participant.challenges.damageTakenOnTeamPercentage": "team_damage_taken_pct", + "participant.damageDealtToObjectives": "objective_damage", + "participant.challenges.epicMonsterKillsWithin30SecondsOfSpawn": "epic_monster_kills_early", + "participant.challenges.riftHeraldTakedowns": "herald_takedowns", + "participant.challenges.dragonTakedowns": "dragon_takedowns", + } + + # Apply mapping + df_flat = df_participant[list(cols.keys())].rename(columns=cols) + + # Derived features + df_flat["kda"] = (df_flat["kills"] + df_flat["assists"]) / df_flat["deaths"].replace(0, pd.NA) + df_flat["kda"].fillna(df_flat["kills"] + df_flat["assists"]) + + df_flat["game_duration_minutes"] = df_flat["game_duration"] / 60 + df_flat["cs_per_min"] = df_flat["cs"] / df_flat["game_duration_minutes"] + df_flat["death_rate_per_min"] = df_flat["deaths"] / df_flat["game_duration_minutes"] + df_flat["gold_efficiency"] = df_flat["gpm"] + + return df_flat + except Exception as e: + print(f"Error: {e}") + return { + 'statusCode': 500, + 'body': json.dumps({'error': str(e)}) + } + +# modified version from lol-match-etl +def create_player_aggregate(df_features: pd.DataFrame) -> dict: + df_features = df_features.drop_duplicates(subset=["match_id", "puuid"]) + + def safe_mean(col): + return df_features[col].mean() if col in df_features.columns else 0.0 + + # Only keep relevant metrics used downstream + features = { + "avg_dpm": safe_mean("dpm"), + "avg_gpm": safe_mean("gpm"), + "avg_kill_participation": safe_mean("kill_participation"), + "avg_kda": safe_mean("kda"), + "avg_vision_score": safe_mean("vision_score"), + "avg_cs_per_min": safe_mean("cs_per_min"), + "avg_team_damage_pct": safe_mean("team_damage_pct"), + "avg_outnumbered_kills": safe_mean("outnumbered_kills"), + "avg_solo_kills": safe_mean("solo_kills"), + "avg_kills_near_tower": safe_mean("kills_near_enemy_tower"), + "avg_shields_on_teammates": safe_mean("shields_on_teammates"), + "avg_objective_damage": safe_mean("objective_damage"), + "avg_dragon_takedowns": safe_mean("dragon_takedowns"), + "avg_herald_takedowns": safe_mean("herald_takedowns"), + "avg_early_gold_adv": safe_mean("early_gold_advantage"), + "avg_turret_kills": safe_mean("turret_kills"), + "avg_heals_on_teammates": safe_mean("heals_on_teammates"), + "avg_longest_alive": safe_mean("longest_time_alive"), + "avg_cc_time": safe_mean("cc_time"), + "avg_time_dead": safe_mean("time_dead"), + "avg_pick_kills": safe_mean("pick_kills_with_ally"), + "death_consistency": df_features["deaths"].std(ddof=0) if len(df_features) > 1 else 0.0, + "cs_consistency": df_features["cs_per_min"].std(ddof=0) if len(df_features) > 1 else 0.0, + } + + # --- Region composite scores --- + features["bandle"] = ( + features["avg_outnumbered_kills"] * 0.4 + + features["avg_kda"] * 0.3 + + (features["avg_vision_score"] / 40.0) * 0.3 + ) + features["bilgewater"] = ( + (features["avg_gpm"] / 400) * 0.4 + + features["avg_solo_kills"] * 0.3 + + features["avg_kills_near_tower"] * 0.3 + ) + features["demacia"] = ( + features["avg_kill_participation"] * 0.4 + + features["avg_team_damage_pct"] * 0.3 + + (features["avg_shields_on_teammates"] / 500) * 0.3 + ) + features["ionia"] = ( + (features["avg_kda"] / 4) * 0.3 + + ((features["avg_kill_participation"] * features["avg_cs_per_min"]) / 7) * 0.4 + + (features["avg_vision_score"] / 40) * 0.3 + ) + features["ixtal"] = ( + (features["avg_objective_damage"] / 10000) * 0.4 + + features["avg_dragon_takedowns"] * 0.3 + + features["avg_herald_takedowns"] * 0.3 + ) + features["noxus"] = ( + (features["avg_dpm"] / 600) * 0.4 + + (features["avg_early_gold_adv"] / 500) * 0.3 + + features["avg_turret_kills"] * 0.3 + ) + features["piltover"] = ( + (features["avg_gpm"] / 400) * 0.4 + + (features["avg_cs_per_min"] / 7) * 0.3 + + features["cs_consistency"] * 0.3 + ) + features["shadow_isles"] = ( + (features["avg_heals_on_teammates"] / 1000) * 0.4 + + (features["avg_longest_alive"] / 600) * 0.3 + + features["avg_kda"] * 0.3 + ) + features["shurima"] = ( + (features["avg_cs_per_min"] / 7) * 0.5 + + features["avg_gpm"] * 0.5 + ) + features["targon"] = ( + (features["avg_vision_score"] / 40) * 0.4 + + (features["avg_shields_on_teammates"] / 500) * 0.3 + + (features["avg_heals_on_teammates"] / 1000) * 0.3 + ) + features["freljord"] = ( + (features["avg_cc_time"] / 20) * 0.4 + + (features["avg_time_dead"] / 60) * -0.3 + + (1 / (features["death_consistency"] + 0.1)) * 0.3 + ) + features["void"] = ( + (features["avg_dpm"] / 600) * 0.4 + + features["avg_team_damage_pct"] * 0.4 + + features["avg_solo_kills"] * 0.2 + ) + features["zaun"] = ( + (1 / (features["death_consistency"] + 0.1)) * -0.3 + + features["avg_outnumbered_kills"] * 0.4 + + features["avg_pick_kills"] * 0.3 + ) + + return features + + +def get_most_played_champions(df_features: pd.DataFrame, top_n: int = 3) -> dict: + if "champion" not in df_features.columns: + return {} + + champ_counts = ( + df_features["champion"] + .value_counts() + .head(top_n) + .to_dict() + ) + return champ_counts + + +def lambda_handler(event, context): + try: + body = json.loads(event.get('body', '{}')) + username = body.get('username') + tag = body.get('tag') + + print(f"Received user: {username}#{tag}") + if not username or not tag: + return {'statusCode': 400, 'body': json.dumps({'error': 'Missing username or tag'})} + puuid = get_puuid_by_riot_id(username, tag) + + match_count = body.get('match_count') + if not match_count: + return{'statusCode': 400, 'body': json.dumps({'error': 'Missing match count'})} + + #fetch most recent ranked matches + ids_url = f"https://americas.api.riotgames.com/lol/match/v5/matches/by-puuid/{puuid}/ids" + start_time = int(time.time()) - (365 * 24 * 60 * 60) + params = {'startTime': start_time, 'count': match_count, 'queue': 420, 'api_key': RIOT_API_KEY} + + response = session.get(ids_url, params=params) + response.raise_for_status() + match_ids = response.json() + + matches = [] + timelines = [] + for match_id in match_ids: + match_data, timeline_data = fetch_and_process_match(match_id) + matches.append(match_data) + timelines.append(timeline_data) + matches_df = pd.DataFrame() + for match in matches: + match_df = get_player_vector(match, puuid) + if match_df is None or not isinstance(match_df, pd.DataFrame): + print(f"Skipping invalid match {match_id}") + continue + matches_df = pd.concat([matches_df, match_df], ignore_index=True) + features_map = create_player_aggregate(matches_df) + most_played = get_most_played_champions(matches_df) + print(f"features: {features_map}") + global_json = get_s3_json(GLOBAL_STATS_S3_PATH) + global_feature_stats = global_json.get("feature_stats", {}) + print(f"global stats: {global_feature_stats}") + percentiles = calculate_percentiles(features_map, global_feature_stats) + + print(f"percentiles: {percentiles}") + return { + 'statusCode': 200, + 'body': json.dumps({ + 'features': features_map, + 'percentiles': percentiles, + 'most-played': most_played + }) + } + + except Exception as e: + print(f"Error: {e}") + return { + 'statusCode': 500, + 'body': json.dumps({'error': str(e)}) + } diff --git a/aws/lambda-functions/lol-opensearch-indexer-embeddings/lambda_function.py b/aws/lambda-functions/lol-opensearch-indexer-embeddings/lambda_function.py new file mode 100644 index 0000000..1043fe6 --- /dev/null +++ b/aws/lambda-functions/lol-opensearch-indexer-embeddings/lambda_function.py @@ -0,0 +1,575 @@ +""" +OpenSearch Indexer with Bedrock Embeddings +Processes match files and creates vector embeddings for semantic search +""" + +import json +import boto3 +from opensearchpy import OpenSearch, RequestsHttpConnection +from requests_aws4auth import AWS4Auth +import os +from typing import Dict, List +import math +import time + +# AWS Clients +s3_client = boto3.client('s3') +bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1') +session = boto3.Session() +credentials = session.get_credentials() + +# OpenSearch Configuration +OPENSEARCH_ENDPOINT = os.environ.get('OPENSEARCH_ENDPOINT', 'search-lol-match-analysis-3mo5dmxf36hqqjxh6lhzullgza.us-west-2.es.amazonaws.com') +OPENSEARCH_REGION = 'us-west-2' +INDEX_NAME = 'lol-matches' + +# Bedrock Embeddings Model +EMBEDDINGS_MODEL_ID = 'amazon.titan-embed-text-v2:0' +EMBEDDING_DIMENSION = 1024 # Titan v2 dimension + +# AWS Auth for OpenSearch +awsauth = AWS4Auth( + credentials.access_key, + credentials.secret_key, + OPENSEARCH_REGION, + 'es', + session_token=credentials.token +) + +# OpenSearch Client +opensearch_client = OpenSearch( + hosts=[{'host': OPENSEARCH_ENDPOINT, 'port': 443}], + http_auth=awsauth, + use_ssl=True, + verify_certs=True, + connection_class=RequestsHttpConnection, + timeout=300 +) + + +class EmbeddingGenerator: + """Generates embeddings using Bedrock Titan""" + + def __init__(self): + self.bedrock = bedrock_runtime + self.model_id = EMBEDDINGS_MODEL_ID + self.cache = {} # Cache embeddings for identical texts + + def generate_embedding(self, text: str, normalize: bool = True) -> List[float]: + """Generate embedding vector for text""" + + # Check cache + cache_key = hash(text) + if cache_key in self.cache: + return self.cache[cache_key] + + try: + # Truncate text if too long (Titan v2 max: ~8K tokens) + if len(text) > 25000: + text = text[:25000] + + request_body = { + "inputText": text, + "dimensions": EMBEDDING_DIMENSION, + "normalize": normalize + } + + response = self.bedrock.invoke_model( + modelId=self.model_id, + body=json.dumps(request_body), + contentType='application/json', + accept='application/json' + ) + + response_body = json.loads(response['body'].read()) + embedding = response_body.get('embedding', []) + + # Cache result + self.cache[cache_key] = embedding + + return embedding + + except Exception as e: + print(f"Embedding generation error: {str(e)}") + # Return zero vector on error + return [0.0] * EMBEDDING_DIMENSION + + def generate_batch_embeddings(self, texts: List[str]) -> List[List[float]]: + """Generate embeddings for multiple texts""" + embeddings = [] + + for text in texts: + time.sleep(1.5) + embedding = self.generate_embedding(text) + embeddings.append(embedding) + + return embeddings + + +class MatchIndexer: + """Indexes match data with vector embeddings into OpenSearch""" + + def __init__(self): + self.client = opensearch_client + self.index_name = INDEX_NAME + self.embedding_generator = EmbeddingGenerator() + + def create_index(self): + """Create OpenSearch index with KNN vector field""" + + index_body = { + "settings": { + "number_of_shards": 1, + "number_of_replicas": 0, + "index.knn": True, # Enable KNN + "analysis": { + "analyzer": { + "lol_analyzer": { + "type": "standard", + "stopwords": "_english_" + } + } + } + }, + "mappings": { + "properties": { + # Match identifiers + "match_id": {"type": "keyword"}, + "game_version": {"type": "keyword"}, + "game_duration": {"type": "integer"}, + "queue_id": {"type": "integer"}, + + # Player info + "player_puuid": {"type": "keyword"}, + "player_name": {"type": "text"}, + "champion": {"type": "keyword"}, + "position": {"type": "keyword"}, + "team_id": {"type": "integer"}, + "win": {"type": "boolean"}, + + # Core stats + "kills": {"type": "integer"}, + "deaths": {"type": "integer"}, + "assists": {"type": "integer"}, + "kda": {"type": "float"}, + "level": {"type": "integer"}, + + # Economy + "gold_earned": {"type": "integer"}, + "total_cs": {"type": "integer"}, + "cs_per_min": {"type": "float"}, + "gold_per_min": {"type": "float"}, + + # Combat + "damage_to_champions": {"type": "integer"}, + "damage_taken": {"type": "integer"}, + "damage_per_min": {"type": "float"}, + "kill_participation": {"type": "float"}, + + # Vision + "vision_score": {"type": "integer"}, + "wards_placed": {"type": "integer"}, + "wards_killed": {"type": "integer"}, + "control_wards": {"type": "integer"}, + + # Objectives + "turret_kills": {"type": "integer"}, + "inhibitor_kills": {"type": "integer"}, + "dragon_kills": {"type": "integer"}, + "baron_kills": {"type": "integer"}, + + # Items + "items": {"type": "keyword"}, + "item_build_path": {"type": "text"}, + + # Lane phase + "cs_at_10": {"type": "integer"}, + "gold_at_10": {"type": "integer"}, + "xp_at_10": {"type": "integer"}, + "cs_diff_at_10": {"type": "integer"}, + "gold_diff_at_10": {"type": "integer"}, + + # Performance descriptions (for text search) + "early_game_performance": {"type": "text"}, + "mid_game_performance": {"type": "text"}, + "late_game_performance": {"type": "text"}, + + # Text summary for hybrid search + "match_summary": { + "type": "text", + "analyzer": "lol_analyzer" + }, + + # VECTOR EMBEDDING - KNN field + "embedding": { + "type": "knn_vector", + "dimension": EMBEDDING_DIMENSION, + "method": { + "name": "hnsw", + "space_type": "cosinesimil", + "engine": "nmslib", + "parameters": { + "ef_construction": 128, + "m": 16 + } + } + } + } + } + } + + try: + if self.client.indices.exists(index=self.index_name): + print(f"Index {self.index_name} already exists") + else: + self.client.indices.create(index=self.index_name, body=index_body) + print(f"✓ Created index with KNN support: {self.index_name}") + except Exception as e: + print(f"Error creating index: {str(e)}") + + def extract_match_features(self, match_data: dict, timeline_data: dict) -> List[Dict]: + """Extract features and generate embeddings for each participant""" + + try: + participants = match_data['info']['participants'] + indexed_docs = [] + + # Prepare all summaries for batch embedding + summaries_to_embed = [] + participant_data = [] + + for participant in participants: + # Calculate derived metrics + game_duration_min = match_data['info']['gameDuration'] / 60 + cs_total = participant.get('totalMinionsKilled', 0) + participant.get('neutralMinionsKilled', 0) + cs_per_min = cs_total / game_duration_min if game_duration_min > 0 else 0 + gold_per_min = participant.get('goldEarned', 0) / game_duration_min if game_duration_min > 0 else 0 + damage_per_min = participant.get('totalDamageDealtToChampions', 0) / game_duration_min if game_duration_min > 0 else 0 + + kda = ((participant.get('kills', 0) + participant.get('assists', 0)) / + max(participant.get('deaths', 1), 1)) + + # Get items + items = [ + participant.get(f'item{i}', 0) + for i in range(7) + if participant.get(f'item{i}', 0) != 0 + ] + + # Extract timeline stats + timeline_stats = self._extract_timeline_stats( + timeline_data, + participant['participantId'] + ) + + # Build comprehensive match summary for embedding + match_summary = self._build_match_summary( + participant, + match_data['info'], + timeline_stats, + cs_per_min, + gold_per_min, + damage_per_min + ) + + summaries_to_embed.append(match_summary) + + # Store participant data + participant_data.append({ + "match_id": match_data['metadata']['matchId'], + "game_version": match_data['info']['gameVersion'], + "game_duration": int(match_data['info']['gameDuration']), + "queue_id": match_data['info']['queueId'], + + "player_puuid": participant.get('puuid'), + "player_name": f"{participant.get('riotIdGameName', 'Unknown')}#{participant.get('riotIdTagline', '')}", + "champion": participant.get('championName'), + "position": participant.get('teamPosition', 'UNKNOWN'), + "team_id": participant.get('teamId'), + "win": participant.get('win', False), + + "kills": participant.get('kills', 0), + "deaths": participant.get('deaths', 0), + "assists": participant.get('assists', 0), + "kda": round(kda, 2), + "level": participant.get('champLevel', 0), + + "gold_earned": participant.get('goldEarned', 0), + "total_cs": cs_total, + "cs_per_min": round(cs_per_min, 2), + "gold_per_min": round(gold_per_min, 2), + + "damage_to_champions": participant.get('totalDamageDealtToChampions', 0), + "damage_taken": participant.get('totalDamageTaken', 0), + "damage_per_min": round(damage_per_min, 2), + "kill_participation": round(participant.get('challenges', {}).get('killParticipation', 0), 2), + + "vision_score": participant.get('visionScore', 0), + "wards_placed": participant.get('wardsPlaced', 0), + "wards_killed": participant.get('wardsKilled', 0), + "control_wards": participant.get('visionWardsBoughtInGame', 0), + + "turret_kills": participant.get('turretKills', 0), + "inhibitor_kills": participant.get('inhibitorKills', 0), + "dragon_kills": participant.get('dragonKills', 0), + "baron_kills": participant.get('baronKills', 0), + + "items": items, + "item_build_path": self._get_item_names(items), + + "cs_at_10": timeline_stats.get('cs_at_10', 0), + "gold_at_10": timeline_stats.get('gold_at_10', 0), + "xp_at_10": timeline_stats.get('xp_at_10', 0), + "cs_diff_at_10": timeline_stats.get('cs_diff_at_10', 0), + "gold_diff_at_10": timeline_stats.get('gold_diff_at_10', 0), + + "early_game_performance": timeline_stats.get('early_game_summary', ''), + "mid_game_performance": timeline_stats.get('mid_game_summary', ''), + "late_game_performance": timeline_stats.get('late_game_summary', ''), + + "match_summary": match_summary + }) + + # Generate embeddings in batch + print(f"Generating embeddings for {len(summaries_to_embed)} participants...") + embeddings = self.embedding_generator.generate_batch_embeddings(summaries_to_embed) + + # Combine data with embeddings + for i, data in enumerate(participant_data): + data['embedding'] = embeddings[i] + indexed_docs.append(data) + + return indexed_docs + + except Exception as e: + print(f"Error extracting features: {str(e)}") + import traceback + traceback.print_exc() + return [] + + def _extract_timeline_stats(self, timeline_data: dict, participant_id: int) -> Dict: + """Extract timeline-specific statistics""" + + stats = { + 'cs_at_10': 0, + 'gold_at_10': 0, + 'xp_at_10': 0, + 'cs_diff_at_10': 0, + 'gold_diff_at_10': 0, + 'early_game_summary': '', + 'mid_game_summary': '', + 'late_game_summary': '' + } + + try: + frames = timeline_data.get('info', {}).get('frames', []) + + # Find 10-minute mark + if len(frames) >= 11: + frame_10 = frames[10] + participant_frame = frame_10.get('participantFrames', {}).get(str(participant_id), {}) + + stats['cs_at_10'] = participant_frame.get('minionsKilled', 0) + participant_frame.get('jungleMinionsKilled', 0) + stats['gold_at_10'] = participant_frame.get('totalGold', 0) + stats['xp_at_10'] = participant_frame.get('xp', 0) + + # Analyze performance by game phase + stats['early_game_summary'] = self._analyze_early_game(frames[:10], participant_id) + stats['mid_game_summary'] = self._analyze_mid_game(frames[10:20], participant_id) + stats['late_game_summary'] = self._analyze_late_game(frames[20:], participant_id) + + except Exception as e: + print(f"Timeline extraction error: {str(e)}") + + return stats + + def _analyze_early_game(self, frames: List, participant_id: int) -> str: + """Analyze early game performance""" + if not frames: + return "No early game data" + + try: + first_frame = frames[0].get('participantFrames', {}).get(str(participant_id), {}) + last_frame = frames[-1].get('participantFrames', {}).get(str(participant_id), {}) + + gold_growth = last_frame.get('totalGold', 0) - first_frame.get('totalGold', 0) + cs_growth = (last_frame.get('minionsKilled', 0) - first_frame.get('minionsKilled', 0)) + + if gold_growth > 2500 and cs_growth > 60: + return "Strong early laning phase with excellent CS and gold income" + elif gold_growth < 1500: + return "Struggled in early laning phase, behind in gold" + else: + return "Average early game performance" + except: + return "Early game data incomplete" + + def _analyze_mid_game(self, frames: List, participant_id: int) -> str: + """Analyze mid game""" + if not frames: + return "No mid game data" + return "Mid game transition period with teamfights" + + def _analyze_late_game(self, frames: List, participant_id: int) -> str: + """Analyze late game""" + if not frames: + return "Game ended before late game" + return "Late game teamfighting and objective control phase" + + def _get_item_names(self, item_ids: List[int]) -> str: + """Convert item IDs to readable format""" + if not item_ids: + return "No items" + return f"Items: {', '.join(map(str, item_ids))}" + + def _build_match_summary(self, participant: dict, match_info: dict, + timeline_stats: dict, cs_per_min: float, + gold_per_min: float, damage_per_min: float) -> str: + """Build comprehensive text summary for embedding""" + + champion = participant.get('championName', 'Unknown') + position = participant.get('teamPosition', 'UNKNOWN') + win = "won" if participant.get('win') else "lost" + kda = f"{participant.get('kills', 0)}/{participant.get('deaths', 0)}/{participant.get('assists', 0)}" + + game_duration_min = match_info.get('gameDuration', 0) / 60 + + # Rich semantic summary for better embedding + summary = f""" + {champion} {position} game that was {win}. + Performance: KDA {kda}, Level {participant.get('champLevel', 0)}. + Game lasted {game_duration_min:.0f} minutes in ranked queue. + + Economy: {participant.get('goldEarned', 0)} total gold earned at {gold_per_min:.0f} gold per minute. + CS: {participant.get('totalMinionsKilled', 0) + participant.get('neutralMinionsKilled', 0)} total minions at {cs_per_min:.1f} CS per minute. + At 10 minutes had {timeline_stats.get('cs_at_10', 0)} CS and {timeline_stats.get('gold_at_10', 0)} gold. + + Combat: {participant.get('totalDamageDealtToChampions', 0)} damage to champions at {damage_per_min:.0f} damage per minute. + Took {participant.get('totalDamageTaken', 0)} damage. + Kill participation: {participant.get('challenges', {}).get('killParticipation', 0)*100:.0f}%. + + Vision: {participant.get('visionScore', 0)} vision score with {participant.get('wardsPlaced', 0)} wards placed and {participant.get('wardsKilled', 0)} wards destroyed. + Control wards: {participant.get('visionWardsBoughtInGame', 0)}. + + Objectives: {participant.get('turretKills', 0)} turrets, {participant.get('dragonKills', 0)} dragons, {participant.get('baronKills', 0)} barons. + + Game phases: + Early game (0-10 min): {timeline_stats.get('early_game_summary', 'Unknown')}. + Mid game (10-20 min): {timeline_stats.get('mid_game_summary', 'Unknown')}. + Late game (20+ min): {timeline_stats.get('late_game_summary', 'Unknown')}. + + This {'winning' if participant.get('win') else 'losing'} game demonstrates {'strong' if participant.get('win') else 'weak'} performance in {position} position. + """ + + return summary.strip() + + def index_match(self, match_data: dict, timeline_data: dict) -> bool: + """Index a single match with embeddings""" + + try: + docs = self.extract_match_features(match_data, timeline_data) + + if not docs: + return False + + for doc in docs: + doc_id = f"{doc['match_id']}_{doc['player_puuid']}" + + self.client.index( + index=self.index_name, + id=doc_id, + body=doc, + refresh=False + ) + + return True + + except Exception as e: + print(f"Error indexing match: {str(e)}") + return False + + def bulk_index_from_s3(self, bucket: str, max_matches: int = 1000): + """Index multiple matches from S3""" + + print(f"Starting bulk indexing from s3://{bucket}") + print(f"Using Bedrock embeddings: {EMBEDDINGS_MODEL_ID}") + + paginator = s3_client.get_paginator('list_objects_v2') + pages = paginator.paginate(Bucket=bucket, Prefix='raw-matches/') + + indexed_count = 0 + failed_count = 0 + + for page in pages: + for obj in page.get('Contents', []): + key = obj['Key'] + + if not key.endswith('match-data.json'): + continue + + if indexed_count >= max_matches: + break + + try: + # Get match data + match_obj = s3_client.get_object(Bucket=bucket, Key=key) + match_data = json.loads(match_obj['Body'].read()) + + # Get timeline data + timeline_key = key.replace('match-data.json', 'timeline-data.json') + timeline_obj = s3_client.get_object(Bucket=bucket, Key=timeline_key) + timeline_data = json.loads(timeline_obj['Body'].read()) + + # Index with embeddings + if self.index_match(match_data, timeline_data): + indexed_count += 1 + + if indexed_count % 10 == 0: + print(f"Indexed {indexed_count} matches...") + self.client.indices.refresh(index=self.index_name) + else: + failed_count += 1 + + except Exception as e: + print(f"Failed to process {key}: {str(e)}") + failed_count += 1 + continue + + # Final refresh + self.client.indices.refresh(index=self.index_name) + + print(f"✓ Indexing complete!") + print(f" Successful: {indexed_count}") + print(f" Failed: {failed_count}") + + return indexed_count + + +def lambda_handler(event, context): + """Lambda handler for indexing with embeddings""" + + bucket = event.get('bucket', 'lol-training-matches-150k') + max_matches = event.get('max_matches', 100) + + indexer = MatchIndexer() + + # Create index if doesn't exist + indexer.create_index() + + # Bulk index + count = indexer.bulk_index_from_s3(bucket, max_matches) + + return { + 'statusCode': 200, + 'body': json.dumps({ + 'matches_indexed': count, + 'index_name': INDEX_NAME, + 'embedding_model': EMBEDDINGS_MODEL_ID + }) + } + + +if __name__ == "__main__": + indexer = MatchIndexer() + indexer.create_index() + indexer.bulk_index_from_s3('lol-training-matches-150k', max_matches=50) diff --git a/aws/lambda-functions/lol-rag-query-embeddings/lambda_function.py b/aws/lambda-functions/lol-rag-query-embeddings/lambda_function.py new file mode 100644 index 0000000..05ded70 --- /dev/null +++ b/aws/lambda-functions/lol-rag-query-embeddings/lambda_function.py @@ -0,0 +1,663 @@ +""" +RAG Query Handler with Bedrock Embeddings +Uses vector similarity search for superior semantic matching +""" + +import json +import boto3 +from opensearchpy import OpenSearch, RequestsHttpConnection +from requests_aws4auth import AWS4Auth +import os +from typing import Dict, List +from datetime import datetime, timedelta + +# AWS Clients +s3_client = boto3.client('s3') +dynamodb = boto3.resource('dynamodb') +bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1') +session = boto3.Session() +credentials = session.get_credentials() + +# Configuration +OPENSEARCH_ENDPOINT = os.environ.get('OPENSEARCH_ENDPOINT', 'your-domain.us-west-2.es.amazonaws.com') +OPENSEARCH_REGION = 'us-west-2' +INDEX_NAME = 'lol-matches' +BEDROCK_MODEL_ID = 'amazon.nova-pro-v1:0' +EMBEDDINGS_MODEL_ID = 'amazon.titan-embed-text-v2:0' +EMBEDDING_DIMENSION = 1024 +QUESTIONS_TABLE_NAME = os.environ.get('QUESTIONS_TABLE_NAME', 'lol-player-questions') + +# OpenSearch Auth +awsauth = AWS4Auth( + credentials.access_key, + credentials.secret_key, + OPENSEARCH_REGION, + 'es', + session_token=credentials.token +) + +opensearch_client = OpenSearch( + hosts=[{'host': OPENSEARCH_ENDPOINT, 'port': 443}], + http_auth=awsauth, + use_ssl=True, + verify_certs=True, + connection_class=RequestsHttpConnection +) + +questions_table = dynamodb.Table(QUESTIONS_TABLE_NAME) + + +class EmbeddingGenerator: + """Generates embeddings for queries""" + + def __init__(self): + self.bedrock = bedrock_runtime + self.model_id = EMBEDDINGS_MODEL_ID + + def generate_embedding(self, text: str) -> List[float]: + """Generate embedding vector for query text""" + + try: + request_body = { + "inputText": text, + "dimensions": EMBEDDING_DIMENSION, + "normalize": True + } + + response = self.bedrock.invoke_model( + modelId=self.model_id, + body=json.dumps(request_body), + contentType='application/json', + accept='application/json' + ) + + response_body = json.loads(response['body'].read()) + return response_body.get('embedding', []) + + except Exception as e: + print(f"Embedding generation error: {str(e)}") + return [0.0] * EMBEDDING_DIMENSION + + +class RAGQueryEngine: + """Vector-based RAG engine using OpenSearch KNN + Bedrock""" + + def __init__(self): + self.opensearch = opensearch_client + self.bedrock = bedrock_runtime + self.index_name = INDEX_NAME + self.embedding_generator = EmbeddingGenerator() + + def get_player_matches(self, puuid: str, limit: int = 20) -> List[Dict]: + """Retrieve player's recent matches""" + + query = { + "query": { + "term": {"player_puuid": puuid} + }, + "sort": [ + {"game_duration": {"order": "desc"}} + ], + "size": limit, + "_source": { + "excludes": ["embedding"] # Don't return large vectors + } + } + + try: + response = self.opensearch.search( + index=self.index_name, + body=query + ) + + return [hit['_source'] for hit in response['hits']['hits']] + except Exception as e: + print(f"Error fetching player matches: {str(e)}") + return [] + + def search_similar_scenarios_vector(self, question: str, player_context: Dict, + limit: int = 15) -> List[Dict]: + """ + Vector similarity search using KNN + Finds semantically similar game scenarios + """ + + print(f"Generating embedding for question: {question[:100]}...") + + # Generate embedding for the question + question_embedding = self.embedding_generator.generate_embedding(question) + + if not question_embedding or len(question_embedding) != EMBEDDING_DIMENSION: + print("Failed to generate valid embedding, falling back to text search") + return self.search_similar_scenarios_text(question, player_context, limit) + + # Build filters based on question context + filters = self._build_filters_from_question(question, player_context) + + # KNN query with filters + query = { + "size": limit, + "query": { + "bool": { + "must": [ + { + "knn": { + "embedding": { + "vector": question_embedding, + "k": limit * 2 # Over-fetch for filtering + } + } + } + ], + "filter": filters + } + }, + "_source": { + "excludes": ["embedding"] # Don't return large vectors + } + } + + try: + response = self.opensearch.search( + index=self.index_name, + body=query + ) + + results = [] + for hit in response['hits']['hits']: + result = hit['_source'] + result['relevance_score'] = hit['_score'] + results.append(result) + + print(f"Found {len(results)} similar scenarios via vector search") + return results + + except Exception as e: + print(f"Vector search error: {str(e)}") + # Fallback to text search + return self.search_similar_scenarios_text(question, player_context, limit) + + def search_similar_scenarios_text(self, question: str, player_context: Dict, + limit: int = 15) -> List[Dict]: + """Fallback text-based search""" + + filters = self._build_filters_from_question(question, player_context) + + query = { + "query": { + "bool": { + "must": [ + { + "multi_match": { + "query": question, + "fields": [ + "match_summary^3", + "early_game_performance^2", + "mid_game_performance^2", + "late_game_performance^2", + "champion^2" + ], + "type": "best_fields", + "fuzziness": "AUTO" + } + } + ], + "filter": filters + } + }, + "size": limit, + "_source": { + "excludes": ["embedding"] + } + } + + try: + response = self.opensearch.search( + index=self.index_name, + body=query + ) + + results = [] + for hit in response['hits']['hits']: + result = hit['_source'] + result['relevance_score'] = hit['_score'] + results.append(result) + + return results + except Exception as e: + print(f"Text search error: {str(e)}") + return [] + + def _build_filters_from_question(self, question: str, player_context: Dict) -> List[Dict]: + """Build smart filters based on question intent""" + + filters = [] + question_lower = question.lower() + + # Champion-specific questions + if 'champion' in player_context and any(term in question_lower for term in ['champion', 'build', 'items']): + filters.append({"term": {"champion": player_context['champion']}}) + + # Position-specific + if 'position' in player_context and any(term in question_lower for term in ['lane', 'position', 'role']): + filters.append({"term": {"position": player_context['position']}}) + + # Winning patterns for improvement questions + if any(term in question_lower for term in ['improve', 'better', 'win', 'success']): + filters.append({"term": {"win": True}}) + + # Jungle-specific + if any(term in question_lower for term in ['jungle', 'jungling', 'gank']): + filters.append({"term": {"position": "JUNGLE"}}) + + # Aggression/deaths + if any(term in question_lower for term in ['aggressive', 'death', 'dying', 'survive']): + # Look at varied death patterns + pass # Don't filter, we want range of examples + + # CS/farming questions + if any(term in question_lower for term in ['cs', 'farm', 'minion', 'creep']): + # Prioritize high CS games + filters.append({"range": {"cs_per_min": {"gte": 6.0}}}) + + # Vision questions + if any(term in question_lower for term in ['vision', 'ward', 'pink']): + filters.append({"range": {"vision_score": {"gte": 30}}}) + + return filters + + def get_player_statistics(self, puuid: str) -> Dict: + """Get aggregated statistics for the player""" + + query = { + "query": { + "term": {"player_puuid": puuid} + }, + "size": 0, + "aggs": { + "avg_kda": {"avg": {"field": "kda"}}, + "avg_cs_per_min": {"avg": {"field": "cs_per_min"}}, + "avg_vision_score": {"avg": {"field": "vision_score"}}, + "avg_damage_per_min": {"avg": {"field": "damage_per_min"}}, + "avg_gold_per_min": {"avg": {"field": "gold_per_min"}}, + "avg_kill_participation": {"avg": {"field": "kill_participation"}}, + "win_rate": { + "terms": {"field": "win", "size": 2} + }, + "most_played_champions": { + "terms": {"field": "champion", "size": 5} + }, + "position_distribution": { + "terms": {"field": "position", "size": 5} + }, + "avg_deaths": {"avg": {"field": "deaths"}}, + "avg_cs_at_10": {"avg": {"field": "cs_at_10"}}, + "death_percentiles": { + "percentiles": {"field": "deaths", "percents": [25, 50, 75, 90]} + }, + "cs_percentiles": { + "percentiles": {"field": "cs_per_min", "percents": [25, 50, 75, 90]} + } + } + } + + try: + response = self.opensearch.search( + index=self.index_name, + body=query + ) + + aggs = response['aggregations'] + + # Win rate + win_buckets = aggs.get('win_rate', {}).get('buckets', []) + total_games = sum(bucket['doc_count'] for bucket in win_buckets) + wins = next((bucket['doc_count'] for bucket in win_buckets if bucket['key'] == 1), 0) + win_rate = (wins / total_games * 100) if total_games > 0 else 0 + + return { + "total_games": total_games, + "win_rate": round(win_rate, 1), + "avg_kda": round(aggs.get('avg_kda', {}).get('value', 0), 2), + "avg_cs_per_min": round(aggs.get('avg_cs_per_min', {}).get('value', 0), 2), + "avg_vision_score": round(aggs.get('avg_vision_score', {}).get('value', 0), 1), + "avg_damage_per_min": round(aggs.get('avg_damage_per_min', {}).get('value', 0), 0), + "avg_gold_per_min": round(aggs.get('avg_gold_per_min', {}).get('value', 0), 0), + "avg_kill_participation": round(aggs.get('avg_kill_participation', {}).get('value', 0), 2), + "avg_deaths": round(aggs.get('avg_deaths', {}).get('value', 0), 1), + "avg_cs_at_10": round(aggs.get('avg_cs_at_10', {}).get('value', 0), 1), + "death_percentiles": aggs.get('death_percentiles', {}).get('values', {}), + "cs_percentiles": aggs.get('cs_percentiles', {}).get('values', {}), + "most_played_champions": [ + {"champion": bucket['key'], "games": bucket['doc_count']} + for bucket in aggs.get('most_played_champions', {}).get('buckets', []) + ], + "position_distribution": [ + {"position": bucket['key'], "games": bucket['doc_count']} + for bucket in aggs.get('position_distribution', {}).get('buckets', []) + ] + } + except Exception as e: + print(f"Error getting player statistics: {str(e)}") + return {} + + def answer_question(self, question: str, puuid: str, player_context: Dict = None) -> Dict: + """Main RAG pipeline with vector search""" + + print(f"Answering question for {puuid}: {question}") + + if not player_context: + player_context = {} + + # Step 1: Get player's statistics + player_stats = self.get_player_statistics(puuid) + + # Step 2: Get player's recent matches + player_matches = self.get_player_matches(puuid, limit=10) + + # Step 3: Vector search for similar scenarios from database + similar_scenarios = self.search_similar_scenarios_vector( + question, + player_context, + limit=15 + ) + + # Step 4: Build RAG prompt + prompt = self._build_rag_prompt( + question, + player_stats, + player_matches, + similar_scenarios, + player_context + ) + + print(f"RAG prompt length: {len(prompt)} chars") + + # Step 5: Call Bedrock for answer + answer = self._invoke_bedrock(prompt) + + return { + "question": question, + "answer": answer, + "player_stats": player_stats, + "similar_scenarios_count": len(similar_scenarios), + "search_method": "vector_knn", + "context_used": { + "player_matches": len(player_matches), + "database_matches": len(similar_scenarios) + } + } + + def _build_rag_prompt(self, question: str, player_stats: Dict, + player_matches: List[Dict], similar_scenarios: List[Dict], + player_context: Dict) -> str: + """Build comprehensive RAG prompt""" + + # Player overview + player_overview = f""" +PLAYER PROFILE: +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +Total Games Analyzed: {player_stats.get('total_games', 0)} +Win Rate: {player_stats.get('win_rate', 0)}% +Average KDA: {player_stats.get('avg_kda', 0)} +Average CS/min: {player_stats.get('avg_cs_per_min', 0)} +Average Deaths: {player_stats.get('avg_deaths', 0)} per game +Average Vision Score: {player_stats.get('avg_vision_score', 0)} +Average Damage/min: {player_stats.get('avg_damage_per_min', 0)} +Average CS at 10min: {player_stats.get('avg_cs_at_10', 0)} +Kill Participation: {player_stats.get('avg_kill_participation', 0)*100:.1f}% + +Death Consistency: + - 25th percentile: {player_stats.get('death_percentiles', {}).get('25.0', 0):.1f} deaths + - Median: {player_stats.get('death_percentiles', {}).get('50.0', 0):.1f} deaths + - 75th percentile: {player_stats.get('death_percentiles', {}).get('75.0', 0):.1f} deaths + +Most Played Champions: +{self._format_champion_list(player_stats.get('most_played_champions', []))} + +Main Positions: +{self._format_position_list(player_stats.get('position_distribution', []))} +""" + + # Recent matches summary + recent_matches_summary = "\nRECENT MATCHES:\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n" + for idx, match in enumerate(player_matches[:5], 1): + recent_matches_summary += f"{idx}. {match['champion']} ({match['position']}): " + recent_matches_summary += f"{'WIN' if match['win'] else 'LOSS'} - " + recent_matches_summary += f"KDA {match['kills']}/{match['deaths']}/{match['assists']} - " + recent_matches_summary += f"{match['cs_per_min']} CS/min - " + recent_matches_summary += f"{match['vision_score']} vision\n" + + # Database insights from vector search + database_insights = "\nSIMILAR SCENARIOS FROM DATABASE (Vector-matched):\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n" + + if similar_scenarios: + # Winners vs player + winners = [s for s in similar_scenarios if s.get('win')] + + if winners: + avg_kda_winners = sum(s['kda'] for s in winners) / len(winners) + avg_cs_winners = sum(s['cs_per_min'] for s in winners) / len(winners) + avg_vision_winners = sum(s['vision_score'] for s in winners) / len(winners) + avg_deaths_winners = sum(s['deaths'] for s in winners) / len(winners) + + database_insights += f"Successful players in similar situations average:\n" + database_insights += f" - KDA: {avg_kda_winners:.2f} (yours: {player_stats.get('avg_kda', 0):.2f})\n" + database_insights += f" - CS/min: {avg_cs_winners:.2f} (yours: {player_stats.get('avg_cs_per_min', 0):.2f})\n" + database_insights += f" - Vision: {avg_vision_winners:.1f} (yours: {player_stats.get('avg_vision_score', 0):.1f})\n" + database_insights += f" - Deaths: {avg_deaths_winners:.1f} (yours: {player_stats.get('avg_deaths', 0):.1f})\n\n" + + # Item builds if relevant + if any(term in question.lower() for term in ['item', 'build', 'buy', 'purchase']): + database_insights += "Popular winning builds in similar games:\n" + for idx, scenario in enumerate(winners[:5], 1): + database_insights += f" {idx}. {scenario.get('champion', 'Unknown')}: {scenario.get('item_build_path', 'N/A')}\n" + database_insights += "\n" + + # Top scenarios + database_insights += f"Top semantically similar game scenarios:\n" + for idx, scenario in enumerate(similar_scenarios[:3], 1): + summary = scenario.get('match_summary', 'N/A') + # Truncate for brevity + summary_short = summary[:300] + "..." if len(summary) > 300 else summary + database_insights += f"\n{idx}. {summary_short}\n" + + # Build final prompt + prompt = f"""You are an elite League of Legends coach analyzing a player's performance using data from 150,000+ games. + +{player_overview} + +{recent_matches_summary} + +{database_insights} + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +PLAYER'S QUESTION: +"{question}" + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +Provide a comprehensive, data-driven answer that: + +1. DIRECTLY ANSWERS their question using their specific statistics +2. COMPARES their performance to successful players from our database +3. Identifies SPECIFIC improvement areas with quantifiable goals +4. Provides 3-5 CONCRETE, actionable recommendations +5. Uses the similar scenarios to support your advice + +COACHING APPROACH: +- Reference their actual numbers vs. database benchmarks +- Explain WHY improvements matter (not just WHAT to do) +- Be encouraging but honest about weaknesses +- Focus on macro gameplay and decision-making +- Maximum 300 words + +RULES: +- NO champion abilities or mechanics +- Only strategic/macro advice +- Data-driven insights only +- Friendly, motivating tone + +Begin your answer:""" + + return prompt + + def _format_champion_list(self, champions: List[Dict]) -> str: + """Format champion list""" + if not champions: + return " No data available" + return "\n".join(f" {i+1}. {c['champion']} ({c['games']} games)" + for i, c in enumerate(champions)) + + def _format_position_list(self, positions: List[Dict]) -> str: + """Format position list""" + if not positions: + return " No data available" + return "\n".join(f" {i+1}. {p['position']} ({p['games']} games)" + for i, p in enumerate(positions)) + + def _invoke_bedrock(self, prompt: str) -> str: + """Call Bedrock Nova Pro for answer generation""" + + request_body = { + "messages": [ + { + "role": "user", + "content": [{"text": prompt}] + } + ], + "inferenceConfig": { + "max_new_tokens": 600, + "temperature": 0.5, + "top_p": 0.9 + } + } + + try: + response = self.bedrock.invoke_model( + modelId=BEDROCK_MODEL_ID, + body=json.dumps(request_body), + contentType='application/json', + accept='application/json' + ) + + response_body = json.loads(response['body'].read()) + + if 'output' in response_body and 'message' in response_body['output']: + content = response_body['output']['message'].get('content', []) + if content: + return content[0].get('text', '').strip() + + return "I apologize, but I couldn't generate an answer at this time." + + except Exception as e: + print(f"Bedrock error: {str(e)}") + return "I apologize, but I encountered an error generating your answer." + + +def lambda_handler(event, context): + """Lambda handler for RAG-based question answering""" + + try: + # Parse request + if isinstance(event.get('body'), str): + body = json.loads(event['body']) + else: + body = event + + question = body.get('question') + puuid = body.get('puuid') + player_context = body.get('player_context', {}) + + if not question or not puuid: + return { + 'statusCode': 400, + 'headers': { + 'Content-Type': 'application/json', + 'Access-Control-Allow-Origin': '*' + }, + 'body': json.dumps({'error': 'question and puuid required'}) + } + + # Rate limiting + question_count = check_rate_limit(puuid) + if question_count >= 10: + return { + 'statusCode': 429, + 'headers': { + 'Content-Type': 'application/json', + 'Access-Control-Allow-Origin': '*' + }, + 'body': json.dumps({ + 'error': 'Rate limit exceeded (10 questions/hour)', + 'limit': 10, + 'reset_in_seconds': 3600 + }) + } + + # Answer question using RAG + rag_engine = RAGQueryEngine() + result = rag_engine.answer_question(question, puuid, player_context) + + # Save question/answer + save_question(puuid, question, result['answer']) + + return { + 'statusCode': 200, + 'headers': { + 'Content-Type': 'application/json', + 'Access-Control-Allow-Origin': '*' + }, + 'body': json.dumps(result) + } + + except Exception as e: + print(f"Error: {str(e)}") + import traceback + traceback.print_exc() + + return { + 'statusCode': 500, + 'headers': { + 'Content-Type': 'application/json', + 'Access-Control-Allow-Origin': '*' + }, + 'body': json.dumps({'error': str(e)}) + } + + +def check_rate_limit(puuid: str) -> int: + """Check rate limit""" + one_hour_ago = int((datetime.utcnow() - timedelta(hours=1)).timestamp()) + + try: + response = questions_table.query( + KeyConditionExpression='puuid = :puuid AND asked_at > :time', + ExpressionAttributeValues={ + ':puuid': puuid, + ':time': one_hour_ago + } + ) + return len(response.get('Items', [])) + except: + return 0 + + +def save_question(puuid: str, question: str, answer: str): + """Save question/answer""" + question_id = f"rag_{int(datetime.utcnow().timestamp())}" + ttl = int((datetime.utcnow() + timedelta(days=30)).timestamp()) + + try: + questions_table.put_item(Item={ + 'puuid': puuid, + 'question_id': question_id, + 'asked_at': int(datetime.utcnow().timestamp()), + 'question': question, + 'answer': answer, + 'question_type': 'performance_rag_vector', + 'ttl': ttl + }) + except Exception as e: + print(f"Failed to save question: {str(e)}") diff --git a/aws/lambda-functions/lol-timeline-api-handler/lambda_function.py b/aws/lambda-functions/lol-timeline-api-handler/lambda_function.py new file mode 100644 index 0000000..bcf8e07 --- /dev/null +++ b/aws/lambda-functions/lol-timeline-api-handler/lambda_function.py @@ -0,0 +1,1969 @@ +""" +Unified API Gateway Handler +Combines player processing, playstyle classification, timeline events, and RAG-based Q&A +""" + +import json +import boto3 +import os +import requests +import time +import math +import pandas as pd +from datetime import datetime, timedelta +from decimal import Decimal +from typing import Dict, List +from boto3.dynamodb.conditions import Key, Attr +from opensearchpy import OpenSearch, RequestsHttpConnection +from requests_aws4auth import AWS4Auth +from botocore.exceptions import ClientError + +# --- AWS Clients --- +dynamodb = boto3.resource('dynamodb') +bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-west-2') +s3_client = boto3.client('s3') +stepfunctions = boto3.client('stepfunctions') +sagemaker_runtime = boto3.client('sagemaker-runtime') +session = boto3.Session() +credentials = session.get_credentials() + +# --- Environment Variables --- +EVENTS_TABLE_NAME = os.environ.get('EVENTS_TABLE_NAME', 'lol-timeline-events') +SUMMARIES_TABLE_NAME = os.environ.get('SUMMARIES_TABLE_NAME', 'lol-event-summaries') +QUESTIONS_TABLE_NAME = os.environ.get('QUESTIONS_TABLE_NAME', 'lol-player-questions') +PLAYER_PROFILES_TABLE_NAME = os.environ.get('PLAYER_PROFILES_TABLE_NAME', 'lol-player-profiles') +RIOT_API_KEY = os.environ['RIOT_API_KEY'] +STATE_MACHINE_ARN = os.environ['STATE_MACHINE_ARN'] +S3_BUCKET_RAW = os.environ['S3_BUCKET_RAW'] +SAGEMAKER_ENDPOINT = os.environ['SAGEMAKER_ENDPOINT'] +OPENSEARCH_ENDPOINT = os.environ['OPENSEARCH_ENDPOINT'] +OPENSEARCH_REGION = 'us-west-2' +INDEX_NAME = 'lol-matches' + +events_table = dynamodb.Table(EVENTS_TABLE_NAME) +summaries_table = dynamodb.Table(SUMMARIES_TABLE_NAME) +questions_table = dynamodb.Table(QUESTIONS_TABLE_NAME) +player_profiles_table = dynamodb.Table(PLAYER_PROFILES_TABLE_NAME) + +BEDROCK_MODEL_ID = 'us.amazon.nova-pro-v1:0' +EMBEDDINGS_MODEL_ID = 'amazon.titan-embed-text-v2:0' +EMBEDDING_DIMENSION = 1024 + +# OpenSearch client +awsauth = AWS4Auth( + credentials.access_key, + credentials.secret_key, + OPENSEARCH_REGION, + 'es', + session_token=credentials.token +) + +opensearch_client = OpenSearch( + hosts=[{'host': OPENSEARCH_ENDPOINT, 'port': 443}], + http_auth=awsauth, + use_ssl=True, + verify_certs=True, + connection_class=RequestsHttpConnection, + timeout=30 +) + +# Global statistics from 150k+ games +GLOBAL_STATS = { + "total_games": {"mean": 3.2249919039325006, "std": 5.254272357960088}, + "win_rate": {"mean": 0.4929653016264618, "std": 0.3994213414923714}, + "avg_kills": {"mean": 6.172342721284408, "std": 3.9854087224200025}, + "avg_deaths": {"mean": 6.294418398501851, "std": 2.7758456800010207}, + "avg_assists": {"mean": 8.379155992079713, "std": 4.989258092619942}, + "avg_kda": {"mean": 3.4153405666652397, "std": 3.029093819718261}, + "avg_cs_per_min": {"mean": 4.117095705028882, "std": 2.4286763589919595}, + "avg_gpm": {"mean": 387.7240377055939, "std": 72.58626910255333}, + "avg_dpm": {"mean": 703.0083293260915, "std": 284.2168459639315}, + "avg_vision_score": {"mean": 26.342648127922022, "std": 18.652806748839577}, + "avg_kill_participation": {"mean": 0.4599937851317357, "std": 0.1312101010930826}, + "avg_early_gold_adv": {"mean": 0.07729061639052412, "std": 0.2138571506360595}, + "avg_cs_at_10": {"mean": 39.24453235905662, "std": 25.412508737888604}, + "avg_team_damage_pct": {"mean": 0.1981815246129052, "std": 0.06695530113266078}, + "avg_objective_damage": {"mean": 12990.801800600986, "std": 12053.211943003807}, + "death_consistency": {"mean": 1.4641622654199804, "std": 1.752731122270569}, + "cs_consistency": {"mean": 0.7443884184113814, "std": 1.0915732263139033} +} + +class DecimalEncoder(json.JSONEncoder): + def default(self, obj): + if isinstance(obj, Decimal): + return float(obj) + return super(DecimalEncoder, self).default(obj) + + +# ============================================================================ +# MAIN LAMBDA HANDLER +# ============================================================================ + +def lambda_handler(event, context): + """Main API Gateway entry point""" + try: + http_method = event['requestContext']['http']['method'] + path = event['requestContext']['http']['path'] + except KeyError: + try: + http_method = event['httpMethod'] + path = event['path'] + except KeyError: + return cors_response(400, {'error': 'Invalid event payload'}) + + print(f"API request: {http_method} {path}") + print(f"Raw event body: {event.get('body', 'NO BODY')}") # Debug line + + if http_method == 'OPTIONS': + return cors_response(200, {}) + + try: + # Player onboarding + if path == '/player/process' and http_method == 'POST': + return process_new_player(event) + + # Get player profile + elif path == '/player/profile' and http_method == 'GET': + return get_player_profile(event) + + # Get player percentile rankings + elif path == '/player/percentiles' and http_method == 'GET': + return get_player_percentiles(event) + + # Compare to another player + elif path == '/player/compare' and http_method == 'POST': + return compare_player(event) + + # Timeline events for a specific match + elif path == '/timeline/events' and http_method == 'GET': + return get_timeline_events(event) + + # Get event summary + elif path == '/timeline/events/summary' and http_method == 'POST': + return get_event_summary(event) + + # Ask event-specific question (WE'RE NOT DOING THIS) + elif path == '/timeline/ask' and http_method == 'POST': + return answer_event_question(event) + + # Ask open-ended performance question (RAG-based) + elif path == '/player/ask' and http_method == 'POST': + return answer_performance_question(event) + + else: + return cors_response(404, {'error': 'Endpoint not found'}) + + except Exception as e: + print(f"Error: {str(e)}") + import traceback + traceback.print_exc() + return cors_response(500, {'error': str(e)}) + +# ============================================================================ +# PERCENTILE CALCULATION UTILITIES +# ============================================================================ + +def calculate_percentile(value: float, mean: float, std: float, lower_is_better: bool = False) -> float: + """ + Calculate percentile using normal distribution (z-score) + Returns percentile from 0-100 + + For stats where lower is better (deaths, consistency), we invert the percentile + """ + if std == 0: + return 50.0 + + # Calculate z-score + z_score = (value - mean) / std + + # Use cumulative distribution function approximation + def erf_approx(x): + """Approximate error function""" + a1 = 0.254829592 + a2 = -0.284496736 + a3 = 1.421413741 + a4 = -1.453152027 + a5 = 1.061405429 + p = 0.3275911 + + sign = 1 if x >= 0 else -1 + x = abs(x) + + t = 1.0 / (1.0 + p * x) + y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * math.exp(-x * x) + + return sign * y + + # Convert z-score to percentile + percentile = (1 + erf_approx(z_score / math.sqrt(2))) / 2 * 100 + + # Invert for "lower is better" stats + if lower_is_better: + percentile = 100 - percentile + + # Clamp between 0 and 100 + return max(0.0, min(100.0, percentile)) + + +def get_percentile_interpretation(percentile: float) -> str: + """Provide human-readable interpretation of percentile""" + if percentile >= 95: + return "Elite (Top 5%)" + elif percentile >= 90: + return "Excellent (Top 10%)" + elif percentile >= 75: + return "Above Average (Top 25%)" + elif percentile >= 60: + return "Above Average" + elif percentile >= 40: + return "Average" + elif percentile >= 25: + return "Below Average" + elif percentile >= 10: + return "Needs Improvement (Bottom 25%)" + else: + return "Needs Significant Improvement (Bottom 10%)" + + +# ============================================================================ +# PLAYER PERCENTILE RANKINGS ENDPOINT +# ============================================================================ + +def get_player_percentiles(event): + """ + GET /player/percentiles?game_name=XXX&tagline=YYY + + Returns percentile rankings for all player stats compared to global averages from 150k+ games + """ + try: + params = event.get('queryStringParameters', {}) + game_name = params.get('game_name') + tagline = params.get('tagline') + + if not game_name or not tagline: + return cors_response(400, {'error': 'game_name and tagline required'}) + + player_id = f"{game_name}#{tagline}" + + # Get player profile + response = player_profiles_table.get_item(Key={'player_id': player_id}) + + if 'Item' not in response: + return cors_response(404, {'error': 'Player not found. Process this player first via /player/process'}) + + profile = response['Item'] + player_stats = profile.get('stats', {}) + + # Calculate percentiles for each stat + percentiles = {} + + # Map player stat keys to global stat keys with "lower is better" flag + stat_mapping = { + 'win_rate': ('win_rate', False), + 'avg_kda': ('avg_kda', False), + 'avg_cs_per_min': ('avg_cs_per_min', False), + 'avg_gpm': ('avg_gpm', False), + 'avg_dpm': ('avg_dpm', False), + 'avg_vision_score': ('avg_vision_score', False), + 'avg_kill_participation': ('avg_kill_participation', False), + 'avg_early_gold_adv': ('avg_early_gold_adv', False), + 'avg_team_damage_pct': ('avg_team_damage_pct', False), + 'avg_objective_damage': ('avg_objective_damage', False), + 'avg_deaths': ('avg_deaths', True), # Lower is better + 'death_consistency': ('death_consistency', True), # Lower variance is better + 'cs_consistency': ('cs_consistency', True) # Lower variance is better + } + + for player_key, (global_key, lower_is_better) in stat_mapping.items(): + if player_key in player_stats and global_key in GLOBAL_STATS: + player_value = float(player_stats[player_key]) + global_data = GLOBAL_STATS[global_key] + + percentile = calculate_percentile( + player_value, + global_data['mean'], + global_data['std'], + lower_is_better + ) + + percentiles[player_key] = { + 'value': round(player_value, 2), + 'percentile': round(percentile, 1), + 'global_mean': round(global_data['mean'], 2), + 'global_std': round(global_data['std'], 2), + 'interpretation': get_percentile_interpretation(percentile), + 'better_than_mean': player_value > global_data['mean'] if not lower_is_better else player_value < global_data['mean'] + } + + # Calculate overall performance score (average of key metrics) + key_metrics = ['avg_kda', 'avg_cs_per_min', 'avg_vision_score', + 'avg_kill_participation', 'win_rate'] + key_percentiles = [percentiles[k]['percentile'] for k in key_metrics + if k in percentiles] + + overall_percentile = sum(key_percentiles) / len(key_percentiles) if key_percentiles else 50.0 + + # Identify strengths (top 3 stats >= 75th percentile) + strengths = sorted( + [(k, v['percentile']) for k, v in percentiles.items()], + key=lambda x: x[1], + reverse=True + ) + top_strengths = [{'stat': k, 'percentile': p} for k, p in strengths if p >= 75.0][:3] + + # Identify weaknesses (top 3 stats <= 25th percentile) + weaknesses = sorted( + [(k, v['percentile']) for k, v in percentiles.items()], + key=lambda x: x[1] + ) + top_weaknesses = [{'stat': k, 'percentile': p} for k, p in weaknesses if p <= 25.0][:3] + + return cors_response(200, { + 'player_id': player_id, + 'match_count': profile.get('match_count', 0), + 'overall_performance': { + 'percentile': round(overall_percentile, 1), + 'interpretation': get_percentile_interpretation(overall_percentile), + 'based_on_metrics': key_metrics + }, + 'percentiles': percentiles, + 'strengths': top_strengths, + 'weaknesses': top_weaknesses, + 'ranked_stats': { + 'top_5': [ + {'stat': k, 'percentile': v['percentile'], 'value': v['value']} + for k, v in sorted(percentiles.items(), + key=lambda x: x[1]['percentile'], + reverse=True)[:5] + ], + 'bottom_5': [ + {'stat': k, 'percentile': v['percentile'], 'value': v['value']} + for k, v in sorted(percentiles.items(), + key=lambda x: x[1]['percentile'])[:5] + ] + }, + 'comparison_base': { + 'total_games_analyzed': '150,000+', + 'data_source': 'global_avg.json' + } + }) + + except Exception as e: + print(f"Error in get_player_percentiles: {str(e)}") + import traceback + traceback.print_exc() + return cors_response(500, {'error': str(e)}) + +# ============================================================================ +# PLAYER PROCESSING (Onboarding) +# ============================================================================ + +def validate_and_decode_body(event: dict) -> tuple[str, str]: + """ + Safely decode request body and validate UTF-8 encoding + Returns (decoded_body_str, error_message or None) + """ + raw_body = event.get('body', '{}') + headers = event.get('headers', {}) + + # Log headers for debugging + content_type = headers.get('content-type', 'application/json') + print(f"Content-Type: {content_type}") + print(f"Raw body type: {type(raw_body)}") + print(f"Body length: {len(raw_body) if isinstance(raw_body, (str, bytes)) else 'unknown'}") + + try: + # Handle Base64 encoding + if event.get('isBase64Encoded'): + import base64 + try: + decoded_bytes = base64.b64decode(raw_body) + body_str = decoded_bytes.decode('utf-8', errors='strict') + print("✓ Successfully decoded Base64 to UTF-8") + except UnicodeDecodeError as e: + print(f"✗ UTF-8 decode failed after Base64: {e}") + return None, f"Invalid UTF-8 in Base64 payload: {str(e)}" + elif isinstance(raw_body, bytes): + try: + body_str = raw_body.decode('utf-8', errors='strict') + print("✓ Successfully decoded bytes to UTF-8") + except UnicodeDecodeError as e: + print(f"✗ UTF-8 decode failed: {e}") + return None, f"Invalid UTF-8 in payload: {str(e)}" + else: + body_str = str(raw_body) + print("✓ Body is already string") + + # Validate JSON structure + try: + json.loads(body_str) + print("✓ Valid JSON structure") + except json.JSONDecodeError as e: + print(f"✗ Invalid JSON: {e}") + return None, f"Invalid JSON: {str(e)}" + + return body_str, None + + except Exception as e: + print(f"✗ Unexpected error during decode: {e}") + return None, str(e) + + +def process_new_player(event): + """ + POST /player/process + Input: { game_name, tagline, num_games } + """ + try: + # Use new validation function + body_str, decode_error = validate_and_decode_body(event) + + if decode_error: + print(f"Decode error: {decode_error}") + return cors_response(400, { + 'error': 'Invalid request encoding', + 'details': decode_error, + 'hint': 'Ensure request is UTF-8 encoded with Content-Type: application/json; charset=utf-8' + }) + + # Parse JSON + body = json.loads(body_str) + + # Extract and normalize strings + import unicodedata + game_name = unicodedata.normalize('NFC', body.get('game_name', '').strip()) + tagline = unicodedata.normalize('NFC', body.get('tagline', '').strip()) + num_games = min(int(body.get('num_games', 10)), 50) + + # Log with hex representation for debugging Korean chars + print(f"Game name hex: {game_name.encode('utf-8').hex()}") + print(f"Tagline hex: {tagline.encode('utf-8').hex()}") + + if not game_name or not tagline: + return cors_response(400, {'error': 'game_name and tagline required'}) + + if num_games > 200: + return cors_response(400, {'error': 'num_games cannot exceed 200'}) + if num_games < 1: + return cors_response(400, {'error': 'num_games must be at least 1'}) + + print(f"Processing: {game_name}#{tagline} ({num_games} games)") + + # Step 1: Fetch Riot data + puuid, match_ids = fetch_riot_data(game_name, tagline, num_games) + if not puuid or not match_ids: + return cors_response(404, {'error': 'Player not found or no ranked matches'}) + + print(f"Found {len(match_ids)} ranked matches") + + # Step 2: Download matches to S3 + download_count = download_matches(game_name, tagline, match_ids) + print(f"Downloaded {download_count} matches to S3") + + # Step 3: Extract features and classify playstyle + matches_df = load_player_matches_from_s3(game_name, tagline, puuid) + if matches_df.empty: + return cors_response(500, {'error': 'Failed to load match data from S3'}) + + player_stats = create_player_aggregate(matches_df) + most_played = get_most_played_champions(matches_df, top_n=3) + + # Classify playstyle + playstyle_result = classify_playstyle(player_stats) + + print(f"Playstyle: {playstyle_result.get('archetype', 'Unknown')}") + + # Step 4: Index to OpenSearch for RAG + indexed_count = index_player_to_opensearch(matches_df, puuid, game_name, tagline) + print(f"Indexed {indexed_count} matches to OpenSearch") + + # Step 5: Save INITIAL profile to DynamoDB (timeline_data is empty for now) + save_player_profile( + game_name, tagline, puuid, match_ids, + playstyle_result, player_stats, most_played, [] # Pass empty list for timeline + ) + + # Step 6: Trigger timeline processing (ASYNCHRONOUS) + execution_arn = trigger_timeline_processing(game_name, tagline, puuid, match_ids) + + # Step 7: Return 202 Accepted (or 200 OK) to signal the job was started + return cors_response(200, { + 'success': True, + 'status': 'PROCESSING_STARTED', + 'player_id': f"{game_name}#{tagline}", + 'puuid': puuid, + 'match_ids': match_ids, + 'matches_processed': len(match_ids), + 'playstyle': playstyle_result, + 'stats': player_stats, + 'most_played_champions': most_played, + 'message': 'Player processing started. Profile will be available shortly.' + }) + + except json.JSONDecodeError as e: + print(f"JSON decode error: {e}") + return cors_response(400, {'error': f'Invalid JSON: {str(e)}'}) + except Exception as e: + print(f"Error in process_new_player: {str(e)}") + import traceback + traceback.print_exc() + return cors_response(500, {'error': str(e)}) + +# ============================================================================ +# SOCIAL COMPARSION +# ============================================================================ + +def compare_player(event): + """ + POST /player/compare + """ + try: + body_str = event.get('body', '{}') + + # Handle Base64 encoding + if event.get('isBase64Encoded', False): + import base64 + body_str = base64.b64decode(body_str).decode('utf-8') + elif isinstance(body_str, bytes): + body_str = body_str.decode('utf-8') + + body = json.loads(body_str) + game_name = body.get('game_name', '').strip() + tagline = body.get('tagline', '').strip() + num_games = min(int(body.get('num_games', 10)), 50) + + if not game_name or not tagline: + return cors_response(400, {'error': 'game_name and tagline required'}) + + print(f"Processing: {game_name}#{tagline} ({num_games} games)") + + # Step 1: Fetch Riot data + puuid, match_ids = fetch_riot_data(game_name, tagline, num_games) + if not puuid or not match_ids: + return cors_response(404, {'error': 'Player not found or no ranked matches'}) + + print(f"Found {len(match_ids)} ranked matches") + + # Step 2: Download matches to S3 + download_count = download_matches(game_name, tagline, match_ids) + print(f"Downloaded {download_count} matches to S3") + + # Step 3: Extract features and classify playstyle + matches_df = load_player_matches_from_s3(game_name, tagline, puuid) + if matches_df.empty: + return cors_response(500, {'error': 'Failed to load match data from S3'}) + + player_stats = create_player_aggregate(matches_df) + most_played = get_most_played_champions(matches_df, top_n=3) + + # Classify playstyle + playstyle_result = classify_playstyle(player_stats) + + print(f"Playstyle: {playstyle_result.get('archetype', 'Unknown')}") + + # Step 4: Save INITIAL profile to DynamoDB + save_player_profile( + game_name, tagline, puuid, match_ids, + playstyle_result, player_stats, most_played, [] # Pass empty list for timeline + ) + + # Step 5: Return 202 Accepted (or 200 OK) to signal the job was started + return cors_response(200, { + 'success': True, + 'player_id': f"{game_name}#{tagline}", + 'puuid': puuid, + 'match_ids': match_ids, + 'matches_processed': len(match_ids), + 'playstyle': playstyle_result, + 'stats': player_stats, + 'most_played_champions': most_played, + }) + + except Exception as e: + print(f"Error in process_new_player: {str(e)}") + import traceback + traceback.print_exc() + return cors_response(500, {'error': str(e)}) + + +def fetch_riot_data(game_name: str, tagline: str, num_games: int): + """Fetch PUUID and match IDs from Riot API""" + headers = {'X-Riot-Token': RIOT_API_KEY} + + # Get PUUID + account_url = f"https://americas.api.riotgames.com/riot/account/v1/accounts/by-riot-id/{game_name}/{tagline}" + try: + resp = requests.get(account_url, headers=headers, timeout=10) + resp.raise_for_status() + puuid = resp.json()['puuid'] + except Exception as e: + print(f"Error fetching PUUID: {e}") + return None, None + + # Get match IDs (ranked only, past year) + one_year_ago = int((datetime.utcnow() - timedelta(days=365)).timestamp()) + matches_url = f"https://americas.api.riotgames.com/lol/match/v5/matches/by-puuid/{puuid}/ids" + params = {'start': 0, 'count': num_games, 'type': 'ranked', 'startTime': one_year_ago} + + try: + resp = requests.get(matches_url, headers=headers, params=params, timeout=10) + resp.raise_for_status() + match_ids = resp.json() + return puuid, match_ids + except Exception as e: + print(f"Error fetching matches: {e}") + return puuid, [] + + +def download_matches(game_name: str, tagline: str, match_ids: list) -> int: + """Download match and timeline JSONs to S3""" + headers = {'X-Riot-Token': RIOT_API_KEY} + player_folder = f"{game_name}_{tagline}" + download_count = 0 + + for match_id in match_ids: + try: + # Check if already exists + match_key = f"raw-matches/{player_folder}/{match_id}/match-data.json" + try: + s3_client.head_object(Bucket=S3_BUCKET_RAW, Key=match_key) + print(f"Match {match_id} already exists, skipping") + download_count += 1 + continue + except: + pass + + # Download match data + match_url = f"https://americas.api.riotgames.com/lol/match/v5/matches/{match_id}" + match_resp = requests.get(match_url, headers=headers, timeout=15) + match_resp.raise_for_status() + match_data = match_resp.json() + + # Download timeline + timeline_url = f"{match_url}/timeline" + timeline_resp = requests.get(timeline_url, headers=headers, timeout=15) + timeline_resp.raise_for_status() + timeline_data = timeline_resp.json() + + # Save to S3 + timeline_key = f"raw-matches/{player_folder}/{match_id}/timeline-data.json" + s3_client.put_object(Bucket=S3_BUCKET_RAW, Key=match_key, Body=json.dumps(match_data)) + s3_client.put_object(Bucket=S3_BUCKET_RAW, Key=timeline_key, Body=json.dumps(timeline_data)) + + download_count += 1 + time.sleep(1.2) # Rate limiting + + except Exception as e: + print(f"Error downloading {match_id}: {e}") + continue + + return download_count + + +def load_player_matches_from_s3(game_name: str, tagline: str, puuid: str) -> pd.DataFrame: + """Load player's matches from S3 and extract features""" + prefix = f"raw-matches/{game_name}_{tagline}" + matches_df = pd.DataFrame() + + paginator = s3_client.get_paginator('list_objects_v2') + page_iterator = paginator.paginate(Bucket=S3_BUCKET_RAW, Prefix=prefix) + + found_files = False + for page in page_iterator: + for obj in page.get('Contents', []): + found_files = True + key = obj['Key'] + if not key.endswith('match-data.json'): + continue + + file_obj = s3_client.get_object(Bucket=S3_BUCKET_RAW, Key=key) + match_data = json.loads(file_obj['Body'].read()) + + match_df = extract_player_features(match_data, puuid) + if match_df is not None: + matches_df = pd.concat([matches_df, match_df], ignore_index=True) + + if not found_files: + print(f"No files found in S3 at prefix: {prefix}") + + return matches_df + + +def extract_player_features(match_data: dict, puuid: str) -> pd.DataFrame: + """Extract features for a single match""" + try: + df_match = pd.json_normalize(match_data) + participants = df_match.loc[0, "info.participants"] + + player_data = next((p for p in participants if p.get("puuid") == puuid), None) + if not player_data: + return None + + df_participant = pd.json_normalize(player_data).add_prefix("participant.") + df_participant["metadata.matchId"] = df_match.loc[0, "metadata.matchId"] + df_participant["info.gameDuration"] = df_match.loc[0, "info.gameDuration"] + + # Define required columns with defaults for missing fields + cols = { + "metadata.matchId": "match_id", + "info.gameDuration": "game_duration", + "participant.puuid": "puuid", + "participant.championName": "champion", + "participant.teamPosition": "position", + "participant.kills": "kills", + "participant.deaths": "deaths", + "participant.assists": "assists", + "participant.totalMinionsKilled": "cs", + "participant.neutralMinionsKilled": "jungle_cs", + "participant.goldEarned": "gold_earned", + "participant.totalDamageDealtToChampions": "damage_to_champions", + "participant.visionScore": "vision_score", + "participant.damageDealtToTurrets": "damage_to_turrets", + "participant.dragonKills": "dragon_kills", + "participant.baronKills": "baron_kills", + "participant.challenges.killParticipation": "kill_participation", + "participant.challenges.soloKills": "solo_kills", + "participant.challenges.damagePerMinute": "dpm", + "participant.challenges.goldPerMinute": "gpm", + "participant.challenges.earlyLaningPhaseGoldExpAdvantage": "early_gold_advantage", + "participant.challenges.teamDamagePercentage": "team_damage_pct", + "participant.damageDealtToObjectives": "objective_damage", + "participant.challenges.riftHeraldTakedowns": "herald_takedowns", + "participant.challenges.dragonTakedowns": "dragon_takedowns", + "participant.timeCCingOthers": "cc_time", + "participant.totalTimeSpentDead": "time_dead", + "participant.longestTimeSpentLiving": "longest_time_alive", + "participant.totalHealsOnTeammates": "heals_on_teammates", + "participant.totalDamageShieldedOnTeammates": "shields_on_teammates", + "participant.challenges.outnumberedKills": "outnumbered_kills", + "participant.challenges.killsNearEnemyTurret": "kills_near_enemy_tower", + "participant.challenges.pickKillWithAlly": "pick_kills_with_ally", + "participant.win": "win", + } + + # Only select columns that exist, fill missing with 0 + available_cols = {k: v for k, v in cols.items() if k in df_participant.columns} + df_flat = df_participant[list(available_cols.keys())].rename(columns=available_cols) + + # Add missing columns with default values + for old_col, new_col in cols.items(): + if new_col not in df_flat.columns: + df_flat[new_col] = 0 + + # Calculate derived fields + df_flat["kda"] = (df_flat["kills"] + df_flat["assists"]) / df_flat["deaths"].replace(0, 1) + df_flat["game_duration_minutes"] = df_flat["game_duration"] / 60 + df_flat["cs_per_min"] = df_flat["cs"] / df_flat["game_duration_minutes"].replace(0, 1) + + return df_flat + + except Exception as e: + print(f"Error extracting features: {e}") + return None + + +def create_player_aggregate(df: pd.DataFrame) -> dict: + """Create aggregated statistics from match data""" + df = df.drop_duplicates(subset=["match_id", "puuid"]) + + def safe_mean(col): + return df[col].mean() if col in df.columns else 0.0 + + features = { + "avg_dpm": safe_mean("dpm"), + "avg_gpm": safe_mean("gpm"), + "avg_kill_participation": safe_mean("kill_participation"), + "avg_kda": safe_mean("kda"), + "avg_vision_score": safe_mean("vision_score"), + "avg_cs_per_min": safe_mean("cs_per_min"), + "avg_team_damage_pct": safe_mean("team_damage_pct"), + "avg_outnumbered_kills": safe_mean("outnumbered_kills"), + "avg_solo_kills": safe_mean("solo_kills"), + "avg_kills_near_tower": safe_mean("kills_near_enemy_tower"), + "avg_shields_on_teammates": safe_mean("shields_on_teammates"), + "avg_objective_damage": safe_mean("objective_damage"), + "avg_dragon_takedowns": safe_mean("dragon_takedowns"), + "avg_herald_takedowns": safe_mean("herald_takedowns"), + "avg_early_gold_adv": safe_mean("early_gold_advantage"), + "avg_heals_on_teammates": safe_mean("heals_on_teammates"), + "avg_longest_alive": safe_mean("longest_time_alive"), + "avg_cc_time": safe_mean("cc_time"), + "avg_time_dead": safe_mean("time_dead"), + "avg_pick_kills": safe_mean("pick_kills_with_ally"), + "avg_deaths": safe_mean("deaths"), + "death_consistency": df["deaths"].std(ddof=0) if len(df) > 1 else 0.0, + "cs_consistency": df["cs_per_min"].std(ddof=0) if len(df) > 1 else 0.0, + "win_rate": (df["win"].sum() / len(df) * 100) if len(df) > 0 else 0.0, + } + + # Regional composite scores for classifier + features["bandle"] = (features["avg_outnumbered_kills"] * 0.4 + features["avg_kda"] * 0.3 + (features["avg_vision_score"] / 40.0) * 0.3) + features["bilgewater"] = ((features["avg_gpm"] / 400) * 0.4 + features["avg_solo_kills"] * 0.3 + features["avg_kills_near_tower"] * 0.3) + features["demacia"] = (features["avg_kill_participation"] * 0.4 + features["avg_team_damage_pct"] * 0.3 + (features["avg_shields_on_teammates"] / 500) * 0.3) + features["ionia"] = ((features["avg_kda"] / 4) * 0.3 + ((features["avg_kill_participation"] * features["avg_cs_per_min"]) / 7) * 0.4 + (features["avg_vision_score"] / 40) * 0.3) + features["ixtal"] = ((features["avg_objective_damage"] / 10000) * 0.4 + features["avg_dragon_takedowns"] * 0.3 + features["avg_herald_takedowns"] * 0.3) + features["noxus"] = ((features["avg_dpm"] / 600) * 0.4 + (features["avg_early_gold_adv"] / 500) * 0.3) + features["piltover"] = ((features["avg_gpm"] / 400) * 0.4 + (features["avg_cs_per_min"] / 7) * 0.3 + features["cs_consistency"] * 0.3) + features["shadow_isles"] = ((features["avg_heals_on_teammates"] / 1000) * 0.4 + (features["avg_longest_alive"] / 600) * 0.3 + features["avg_kda"] * 0.3) + features["shurima"] = ((features["avg_cs_per_min"] / 7) * 0.5 + features["avg_gpm"] * 0.5) + features["targon"] = ((features["avg_vision_score"] / 40) * 0.4 + (features["avg_shields_on_teammates"] / 500) * 0.3 + (features["avg_heals_on_teammates"] / 1000) * 0.3) + features["freljord"] = ((features["avg_cc_time"] / 20) * 0.4 + (features["avg_time_dead"] / 60) * -0.3 + (1 / (features["death_consistency"] + 0.1)) * 0.3) + features["void"] = ((features["avg_dpm"] / 600) * 0.4 + features["avg_team_damage_pct"] * 0.4 + features["avg_solo_kills"] * 0.2) + features["zaun"] = ((1 / (features["death_consistency"] + 0.1)) * -0.3 + features["avg_outnumbered_kills"] * 0.4 + features["avg_pick_kills"] * 0.3) + + return features + + +def get_most_played_champions(df: pd.DataFrame, top_n: int = 3) -> dict: + """Get most played champions""" + if "champion" not in df.columns: + return {} + return df["champion"].value_counts().head(top_n).to_dict() + + +def classify_playstyle(player_stats: dict) -> dict: + """Call SageMaker endpoint for playstyle classification""" + try: + features_vector = [ + player_stats["bandle"], player_stats["bilgewater"], player_stats["demacia"], + player_stats["ionia"], player_stats["ixtal"], player_stats["noxus"], + player_stats["piltover"], player_stats["shadow_isles"], player_stats["shurima"], + player_stats["targon"], player_stats["freljord"], player_stats["void"], player_stats["zaun"], + player_stats["avg_dpm"], player_stats["avg_gpm"], + player_stats["avg_kill_participation"], player_stats["avg_kda"], + player_stats["avg_vision_score"], player_stats["avg_cs_per_min"], + player_stats["avg_team_damage_pct"] + ] + + response = sagemaker_runtime.invoke_endpoint( + EndpointName=SAGEMAKER_ENDPOINT, + ContentType='application/json', + Body=json.dumps({'features': features_vector}) + ) + + return json.loads(response['Body'].read()) + + except Exception as e: + print(f"Playstyle classification error: {e}") + return {'archetype': 'Unknown', 'error': str(e)} + + +def index_player_to_opensearch(matches_df: pd.DataFrame, puuid: str, + game_name: str, tagline: str) -> int: + """ + Index player's matches to OpenSearch for RAG + """ + try: + actions = [] + + for _, row in matches_df.iterrows(): + # Create match summary text for embedding + win_status = "won" if row['win'] else "lost" + match_summary = f"{row['champion']} {row['position']}, {win_status} with {row['kills']}/{row['deaths']}/{row['assists']} KDA, {row['cs_per_min']:.1f} CS/min, {row['vision_score']} vision score" + + # Generate embedding for this match + match_embedding = generate_embedding(match_summary) + + doc = { + "match_id": row['match_id'], + "player_puuid": puuid, + "player_name": f"{game_name}#{tagline}", + "champion": row['champion'], + "position": row['position'], + "win": bool(row['win']), + "kills": int(row['kills']), + "deaths": int(row['deaths']), + "assists": int(row['assists']), + "kda": float(row['kda']), + "cs_per_min": float(row['cs_per_min']), + "vision_score": int(row['vision_score']), + "dpm": float(row.get('dpm', 0)), + "gpm": float(row.get('gpm', 0)), + "kill_participation": float(row.get('kill_participation', 0)), + "game_duration": int(row['game_duration']), + "match_summary": match_summary, + "indexed_at": int(datetime.utcnow().timestamp()) + } + + # Add embedding if generation succeeded + if match_embedding and len(match_embedding) == EMBEDDING_DIMENSION: + doc["embedding"] = match_embedding + + action = { + "_index": INDEX_NAME, + "_id": f"{row['match_id']}_{puuid}", + "_source": doc + } + actions.append(action) + + from opensearchpy import helpers + success, failed = helpers.bulk( + opensearch_client, + actions, + chunk_size=50, + raise_on_error=False + ) + + print(f"Indexed {success} player matches to OpenSearch") + return success + + except Exception as e: + print(f"OpenSearch indexing error: {e}") + return 0 + + +def trigger_timeline_processing(game_name: str, tagline: str, puuid: str, match_ids: list) -> str: + """ + Trigger Step Functions for timeline event extraction + """ + timestamp = int(datetime.utcnow().timestamp()) + + # Sanitize the execution name + execution_name = f"timeline_{puuid[:16].replace('-', '')}_{timestamp}" + + # This is the S3 prefix where the files are stored + s3_player_prefix = f"raw-matches/{game_name}_{tagline}" + + response = stepfunctions.start_execution( + stateMachineArn=STATE_MACHINE_ARN, + name=execution_name, + input=json.dumps({ + 'match_ids': match_ids, + 'puuid': puuid, + 'game_name': game_name, + 'tagline': tagline, + 's3_player_prefix': s3_player_prefix, + 'batch_mode': True + }) + ) + + print(f"Started Step Functions execution: {execution_name}") + print(f"Processing player: {game_name}#{tagline} (PUUID: {puuid})") + return response['executionArn'] + + +def wait_for_completion(execution_arn: str, timeout: int = 300) -> bool: + """Wait for Step Functions to complete""" + start_time = time.time() + + while time.time() - start_time < timeout: + response = stepfunctions.describe_execution(executionArn=execution_arn) + status = response['status'] + + if status == 'SUCCEEDED': + return True + elif status in ['FAILED', 'TIMED_OUT', 'ABORTED']: + print(f"Timeline processing failed: {status}") + return False + + time.sleep(5) + + return False + +def convert_floats(obj): + """Recursively convert floats to Decimal for DynamoDB""" + if isinstance(obj, float): + if math.isnan(obj) or math.isinf(obj): + return Decimal('0') + return Decimal(str(obj)) + elif isinstance(obj, dict): + return {k: convert_floats(v) for k, v in obj.items()} + elif isinstance(obj, list): + return [convert_floats(v) for v in obj] + return obj + +def save_player_profile(game_name: str, tagline: str, puuid: str, match_ids: list, + playstyle: dict, stats: dict, most_played: dict, timeline_data: list): + """Save player profile to DynamoDB""" + ttl = int((datetime.utcnow() + timedelta(days=30)).timestamp()) + + try: + # Convert all floats/NaNs to Decimal + playstyle = convert_floats(playstyle) + stats = convert_floats(stats) + + player_profiles_table.put_item(Item={ + 'player_id': f"{game_name}#{tagline}", + 'puuid': puuid, + 'game_name': game_name, + 'tagline': tagline, + 'playstyle': playstyle, + 'stats': stats, + 'most_played_champions': most_played, + 'match_ids': match_ids, + 'processed_at': int(datetime.utcnow().timestamp()), + 'ttl': ttl, + 'match_count': len(match_ids), + 'timeline_summary': { + 'total_matches': len(timeline_data), + 'total_events': sum(len(m.get('events', [])) for m in timeline_data) + } + }) + print("Saved player profile to DynamoDB") + except Exception as e: + print(f"Error saving profile: {e}") + import traceback + traceback.print_exc() + raise + + +# ============================================================================ +# GET PLAYER PROFILE +# ============================================================================ + +def get_player_profile(event): + """GET /player/profile?game_name=XXX&tagline=YYY""" + params = event.get('queryStringParameters', {}) + game_name = params.get('game_name') + tagline = params.get('tagline') + + if not game_name or not tagline: + return cors_response(400, {'error': 'game_name and tagline required'}) + + player_id = f"{game_name}#{tagline}" + response = player_profiles_table.get_item(Key={'player_id': player_id}) + + if 'Item' not in response: + return cors_response(404, {'error': 'Player not found. Process this player first.'}) + + profile = response['Item'] + puuid = profile.get('puuid') + match_ids = profile.get('match_ids', []) + + # Get top timeline events for each match + timeline_data = [] + for match_id in match_ids: + events = get_top_events_for_match(puuid, match_id, limit=15) + if events: + timeline_data.append({ + 'match_id': match_id, + 'events': events, + 'total_events': len(events) + }) + + # Check if timeline processing is still running + is_processing = (len(timeline_data) == 0 and len(match_ids) > 0 and + (int(datetime.utcnow().timestamp()) - int(profile.get('processed_at', 0))) < 600) # 10 min window + + return cors_response(200, { + 'player_id': player_id, + 'puuid': puuid, + 'game_name': game_name, + 'tagline': tagline, + 'playstyle': profile.get('playstyle', {}), + 'stats': profile.get('stats', {}), + 'most_played_champions': profile.get('most_played_champions', {}), + 'timeline_data': timeline_data, + 'match_count': profile.get('match_count', 0), + 'processed_at': int(profile.get('processed_at', 0)), + 'processing_status': 'PROCESSING' if is_processing else 'COMPLETED' + }) + + +# ============================================================================ +# TIMELINE EVENT FUNCTIONS +# ============================================================================ + +def get_top_events_for_match(puuid: str, match_id: str, limit: int = 15) -> list: + """Retrieve top impact events for a specific match""" + try: + response = events_table.query( + IndexName='match-impact-index', + KeyConditionExpression=Key('match_id').eq(match_id), + FilterExpression=Attr('puuid').eq(puuid), + ScanIndexForward=False # Sort by impact_score DESC + ) + + events = response.get('Items', []) + + if not events: + return [] + + sorted_events = sorted(events, key=lambda x: int(x.get('impact_score', 0)), reverse=True) + + seen_fingerprints = set() + unique_events = [] + + for event_item in sorted_events: + event_details = json.loads(event_item.get('event_details', '{}')) + + fingerprint = ( + float(event_item.get('timestamp_minutes', 0)), + event_item.get('event_type'), + event_details.get('objective_type'), + event_details.get('structure_type'), + event_details.get('lane') + ) + + if fingerprint not in seen_fingerprints: + seen_fingerprints.add(fingerprint) + + # Try to get summary + event_obj = { + 'event_id': event_item['event_id'], + 'timestamp_minutes': float(event_item['timestamp_minutes']), + 'event_type': event_item['event_type'], + 'impact_score': int(event_item['impact_score']), + 'game_state': event_item.get('game_state', 'mid'), + 'event_details': event_details, + 'context': json.loads(event_item.get('context', '{}')), + 'has_summary': False, + 'summary': None + } + + # Check for summary + for summary_type in ['enhanced_v2', 'enhanced', 'basic']: + try: + summary_resp = summaries_table.get_item( + Key={'event_id': event_item['event_id'], 'summary_type': summary_type} + ) + if 'Item' in summary_resp: + event_obj['has_summary'] = True + event_obj['summary'] = summary_resp['Item'].get('summary_text') + event_obj['summary_version'] = summary_type + break + except: + continue + + unique_events.append(event_obj) + + if len(unique_events) >= limit: + break + + return unique_events + + except Exception as e: + print(f"Error retrieving events for {match_id}: {e}") + return [] + + +def get_timeline_events(event): + """GET /timeline/events?match_id=XXX&puuid=YYY""" + params = event.get('queryStringParameters', {}) + match_id = params.get('match_id') + puuid = params.get('puuid') + + if not match_id or not puuid: + return cors_response(400, {'error': 'match_id and puuid required'}) + + events = get_top_events_for_match(puuid, match_id, limit=50) + + return cors_response(200, { + 'match_id': match_id, + 'puuid': puuid, + 'events': events, + 'total_events': len(events) + }) + + +def get_event_summary(event): + """POST /timeline/events/summary - Get cached summary for an event""" + body = json.loads(event.get('body', '{}')) + event_id = body.get('event_id') + + if not event_id: + return cors_response(400, {'error': 'event_id required'}) + + for summary_type in ['enhanced_v2', 'enhanced', 'basic']: + cache_response = summaries_table.get_item( + Key={'event_id': event_id, 'summary_type': summary_type} + ) + + if 'Item' in cache_response: + return cors_response(200, { + 'event_id': event_id, + 'summary': cache_response['Item']['summary_text'], + 'cached': True, + 'summary_version': summary_type + }) + + return cors_response(404, { + 'event_id': event_id, + 'error': 'Summary not yet generated' + }) + + +def answer_event_question(event): # UNUSED + """ + POST /timeline/ask + Ask specific question about a timeline event + Input: { event_id, match_id, puuid, question, match_context } + """ + body = json.loads(event.get('body', '{}')) + event_id = body.get('event_id') + match_id = body.get('match_id') + puuid = body.get('puuid') + question = body.get('question') + match_context = body.get('match_context', {}) + + if not all([event_id, match_id, puuid, question]): + return cors_response(400, {'error': 'event_id, match_id, puuid, and question required'}) + + # Rate limiting: 5 questions per event + question_count_response = questions_table.query( + IndexName='event-questions-index', + KeyConditionExpression=Key('event_id').eq(event_id), + FilterExpression=Attr('puuid').eq(puuid) + ) + + question_count = len(question_count_response.get('Items', [])) + if question_count >= 5: + return cors_response(429, { + 'error': 'Maximum 5 questions per event reached', + 'limit': 5, + 'used': question_count + }) + + # Get event data + event_response = events_table.get_item( + Key={'match_id': match_id, 'event_id': event_id} + ) + + if 'Item' not in event_response: + return cors_response(404, {'error': 'Event not found'}) + + event_data = event_response['Item'] + + # Build prompt and call Bedrock + prompt = build_event_qa_prompt(event_data, question, match_context) + answer = invoke_bedrock_nova(prompt, max_tokens=200, temperature=0.4) + + # Save question + question_id = f"{event_id}_{int(datetime.utcnow().timestamp())}" + ttl = int((datetime.utcnow() + timedelta(days=30)).timestamp()) + + questions_table.put_item(Item={ + 'question_id': question_id, + 'event_id': event_id, + 'match_id': match_id, + 'puuid': puuid, + 'question': question, + 'answer': answer, + 'question_type': 'event_specific', + 'asked_at': int(datetime.utcnow().timestamp()), + 'ttl': ttl + }) + + return cors_response(200, { + 'event_id': event_id, + 'question': question, + 'answer': answer, + 'question_count': question_count + 1, + 'remaining_questions': 4 - question_count + }) + + +def build_event_qa_prompt(event_data: dict, question: str, match_context: dict) -> str: + """Build prompt for event-specific question""" + event_details = json.loads(event_data.get('event_details', '{}')) + context = json.loads(event_data.get('context', '{}')) + + prompt = f"""MATCH SITUATION at {float(event_data.get('timestamp_minutes', 0)):.1f} minutes: +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +EVENT: {event_data.get('event_type', 'Unknown')} +PLAYER POSITION: {context.get('player_location', {}).get('lane', 'Unknown')} +DISTANCE: {context.get('player_location', {}).get('distance_to_event', 0)} units +TELEPORT: {'Available' if context.get('summoner_spells', {}).get('tp_available', False) else 'On CD'} +GOLD STATE: {context.get('gold_state', 'unknown')} + +QUESTION: "{question}" + +Provide macro-focused coaching. Maximum 150 words.""" + + return prompt + + +# ============================================================================ +# RAG-BASED PERFORMANCE Q&A +# ============================================================================ + +def answer_performance_question(event): + """ + POST /player/ask + Macro-focused RAG performance answer + """ + try: + body_str = event.get('body', '{}') + if isinstance(body_str, bytes): + body_str = body_str.decode('utf-8') + + body = json.loads(body_str) + game_name = body.get('game_name', '').strip() + tagline = body.get('tagline', '').strip() + question = body.get('question', '').strip() + + if not all([game_name, tagline, question]): + return cors_response(400, {'error': 'game_name, tagline, and question required'}) + + player_id = f"{game_name}#{tagline}" + + profile_response = player_profiles_table.get_item(Key={'player_id': player_id}) + if 'Item' not in profile_response: + return cors_response(404, { + 'error': 'Player not found', + 'message': 'Process this player first via /player/process' + }) + + profile = profile_response['Item'] + puuid = profile['puuid'] + player_stats = profile.get('stats', {}) + most_played = profile.get('most_played_champions', {}) + + one_hour_ago = int((datetime.utcnow() - timedelta(hours=1)).timestamp()) + recent_questions = questions_table.query( + KeyConditionExpression=Key('puuid').eq(puuid) & Key('asked_at').gt(one_hour_ago) + ) + if len(recent_questions.get('Items', [])) >= 30: + return cors_response(429, {'error': 'Rate limit exceeded (30 questions/hour)', 'reset_in_seconds': 3600}) + + print(f"Answering macro performance question for {player_id}: {question}") + + player_opensearch_stats = get_player_stats_from_opensearch(puuid) + + query_embedding = generate_embedding(question) + if query_embedding and len(query_embedding) == EMBEDDING_DIMENSION: + similar_scenarios = search_similar_scenarios_knn(query_embedding, question, player_stats, limit=10) + search_method = 'vector_knn' + else: + similar_scenarios = search_similar_scenarios_text(question, player_stats, limit=10) + search_method = 'text' + + rag_prompt = build_rag_prompt( + question, + player_stats, + player_opensearch_stats, + most_played, + similar_scenarios + ) + + answer = invoke_bedrock_nova(rag_prompt, max_tokens=520, temperature=0.6) + + question_id = f"perf_{int(datetime.utcnow().timestamp())}" + ttl = int((datetime.utcnow() + timedelta(days=30)).timestamp()) + + questions_table.put_item(Item={ + 'puuid': puuid, + 'question_id': question_id, + 'asked_at': int(datetime.utcnow().timestamp()), + 'question': question, + 'answer': answer, + 'question_type': 'performance_rag_macro', + 'similar_scenarios_count': len(similar_scenarios), + 'search_method': search_method, + 'ttl': ttl + }) + + return cors_response(200, { + 'player_id': player_id, + 'question': question, + 'answer': answer, + 'context_used': { + 'player_matches': profile.get('match_count', 0), + 'database_matches': len(similar_scenarios), + 'search_method': search_method, + 'macro_indicators': compute_macro_indicators(player_stats, player_opensearch_stats) + } + }) + + except Exception as e: + print(f"Error in answer_performance_question: {str(e)}") + import traceback + traceback.print_exc() + return cors_response(500, {'error': str(e)}) + + +def get_player_stats_from_opensearch(puuid: str) -> dict: + """Get aggregated statistics for player from OpenSearch""" + query = { + "query": {"term": {"player_puuid": puuid}}, + "size": 0, + "aggs": { + "avg_kda": {"avg": {"field": "kda"}}, + "avg_cs_per_min": {"avg": {"field": "cs_per_min"}}, + "avg_vision_score": {"avg": {"field": "vision_score"}}, + "avg_dpm": {"avg": {"field": "dpm"}}, + "avg_gpm": {"avg": {"field": "gpm"}}, + "avg_kill_participation": {"avg": {"field": "kill_participation"}}, + "avg_deaths": {"avg": {"field": "deaths"}}, + "win_rate": {"terms": {"field": "win", "size": 2}}, + "most_played_champions": {"terms": {"field": "champion", "size": 5}}, + "position_distribution": {"terms": {"field": "position", "size": 5}} + } + } + + try: + response = opensearch_client.search(index=INDEX_NAME, body=query) + aggs = response['aggregations'] + + # Calculate win rate + win_buckets = aggs.get('win_rate', {}).get('buckets', []) + total_games = sum(bucket['doc_count'] for bucket in win_buckets) + wins = next((bucket['doc_count'] for bucket in win_buckets if bucket['key'] == 1), 0) + win_rate = (wins / total_games * 100) if total_games > 0 else 0 + + return { + "total_games": total_games, + "win_rate": round(win_rate, 1), + "avg_kda": round(aggs.get('avg_kda', {}).get('value', 0), 2), + "avg_cs_per_min": round(aggs.get('avg_cs_per_min', {}).get('value', 0), 2), + "avg_vision_score": round(aggs.get('avg_vision_score', {}).get('value', 0), 1), + "avg_dpm": round(aggs.get('avg_dpm', {}).get('value', 0), 0), + "avg_gpm": round(aggs.get('avg_gpm', {}).get('value', 0), 0), + "avg_kill_participation": round(aggs.get('avg_kill_participation', {}).get('value', 0), 2), + "avg_deaths": round(aggs.get('avg_deaths', {}).get('value', 0), 1), + "most_played_champions": [ + {"champion": b['key'], "games": b['doc_count']} + for b in aggs.get('most_played_champions', {}).get('buckets', []) + ] + } + except Exception as e: + print(f"Error getting player stats from OpenSearch: {e}") + return {} + + +def generate_embedding(text: str) -> list: + """Generate embedding for query text using Bedrock Titan""" + try: + if len(text) > 25000: + text = text[:25000] + + request_body = { + "inputText": text, + "dimensions": EMBEDDING_DIMENSION, + "normalize": True + } + + response = bedrock_runtime.invoke_model( + modelId=EMBEDDINGS_MODEL_ID, + body=json.dumps(request_body), + contentType='application/json', + accept='application/json' + ) + + # Fix: Read body correctly + response_body = json.loads(response['body'].read().decode('utf-8')) + embedding = response_body.get('embedding', []) + + if not embedding: + print(f"Empty embedding returned from Bedrock") + return None + + return embedding + + except Exception as e: + print(f"Embedding generation error: {e}") + import traceback + traceback.print_exc() + return None + + +def compute_macro_indicators(player_stats: dict, opensearch_stats: dict) -> dict: + """ + Derive macro indicators from raw stats (heuristic, lightweight). + Accepts Decimal values from DynamoDB; coerces all numerics to float. + """ + def f(v): + try: + return float(v) + except (TypeError, ValueError): + return 0.0 + + # Coerce needed fields + deaths = f(player_stats.get('avg_deaths', 0)) + kda = f(player_stats.get('avg_kda', 0)) + cs = f(player_stats.get('avg_cs_per_min', 0)) + kp = f(player_stats.get('avg_kill_participation', 0)) + vision = f(player_stats.get('avg_vision_score', 0)) + win_rate = f(player_stats.get('win_rate', 0)) + obj_dmg = f(player_stats.get('avg_objective_damage', 0)) + drag_tk = f(player_stats.get('avg_dragon_takedowns', 0)) + herald_tk = f(player_stats.get('avg_herald_takedowns', 0)) + early_adv = f(player_stats.get('avg_early_gold_adv', 0)) + + indicators = {} + indicators['laning_efficiency'] = round(cs / 7 * 0.6 + (kda / 5) * 0.2 + (win_rate / 100) * 0.2, 3) + indicators['objective_alignment'] = round( + (obj_dmg / 15000) * 0.4 + + (drag_tk / 2) * 0.3 + + (herald_tk / 1.5) * 0.3, 3 + ) + indicators['map_influence'] = round(kp * 0.5 + (vision / 30) * 0.3 + (1 / (deaths + 1)) * 0.2, 3) + indicators['risk_management'] = round((1 / (deaths + 1)) * 0.5 + (kda / 5) * 0.3 + (vision / 30) * 0.2, 3) + indicators['tempo_conversion'] = round( + (early_adv / 400) * 0.4 + + (win_rate / 100) * 0.3 + + (kda / 5) * 0.3, 3 + ) + + indicators['early_game_flag'] = 'inefficient' if cs < 6.2 else 'stable' if cs < 7.2 else 'strong' + indicators['death_pressure_flag'] = 'high' if deaths >= 5 else 'moderate' if deaths >= 3.5 else 'controlled' + indicators['vision_flag'] = 'needs_upgrade' if vision < 15 else 'acceptable' if vision < 22 else 'impactful' + + return indicators + + +def build_rag_prompt(question: str, player_stats: dict, opensearch_stats: dict, + most_played: dict, similar_scenarios: list) -> str: + """ + Macro-focused coaching prompt (replaces previous verbose stat-centric prompt). + """ + + indicators = compute_macro_indicators(player_stats, opensearch_stats) + + # Compress stats (only essentials) + concise_stats = ( + f"KDA {player_stats.get('avg_kda', 0):.2f}, CS/min {player_stats.get('avg_cs_per_min', 0):.2f}, " + f"Deaths {player_stats.get('avg_deaths', 0):.1f}, KP {player_stats.get('avg_kill_participation', 0):.2f}, " + f"Vision {player_stats.get('avg_vision_score', 0):.1f}, WinRate {player_stats.get('win_rate', 0):.1f}%" + ) + + # Scenario synthesis (no raw repetition) + scenario_lines = [] + for s in similar_scenarios[:5]: + scenario_lines.append( + f"{s.get('champion')} {s.get('position')} | {'W' if s.get('win') else 'L'} | KDA {s.get('kda', 0):.2f} | " + f"CSm {s.get('cs_per_min', 0):.2f} | KP {s.get('kill_participation', 0):.1%}" + ) + scenarios_block = "\n".join(scenario_lines) if scenario_lines else "None" + + prompt = f""" +User Question: {question} + +Player Snapshot (do NOT restate every number later): {concise_stats} +Derived Macro Indicators: +- Laning Efficiency: {indicators['laning_efficiency']} +- Objective Alignment: {indicators['objective_alignment']} +- Map Influence: {indicators['map_influence']} +- Risk Management: {indicators['risk_management']} +- Tempo Conversion: {indicators['tempo_conversion']} +Flags: EarlyGame={indicators['early_game_flag']}, DeathPressure={indicators['death_pressure_flag']}, Vision={indicators['vision_flag']} + +Most Played (top 3): {', '.join([f'{c}({g})' for c, g in list(most_played.items())[:3]]) or 'N/A'} + +Similar Scenario Summaries (aggregated, do NOT copy blindly): +{scenarios_block} + +Output Requirements: +1. Do NOT repeat raw stat lists; reference concepts (e.g., "high death volatility") instead. +2. Identify one PRIMARY macro weakness (not mechanical) with reasoning. +3. Provide a MACRO IMPROVEMENT PLAN (phased: early → mid → late). +4. Extract DECISION PATTERNS from scenarios (pressure, over-extension, rotation timing). +5. Give 3 PRACTICAL DRILLS (each: objective, duration, measurable success metric). +6. Provide a ONE-WEEK FOCUS checklist (5 concise bullets). +7. Keep under 380 words. Avoid fluff. No generic motivational lines. +8. If the user question is unrelated (e.g., math), briefly answer then still deliver coaching. + +Return ONLY this structured format: +Primary Weakness: +Macro Improvement Plan: +Decision Patterns: +Drills: +One-Week Focus: + +Now generate the coaching response. +""" + return prompt + + +def invoke_bedrock_nova(prompt: str, max_tokens: int = 520, temperature: float = 0.6) -> str: + """ + Bedrock invoke for Amazon Nova (no 'system' role allowed). + Embed coaching instructions into the single user message. + Removes previous use of an invalid 'system' role. + """ + coaching_preamble = ( + "ROLE: High-level League of Legends macro coach.\n" + "STYLE: Concise, analytical; focus on rotations, lane management, vision timing, resource sequencing, " + "objective trades, risk mitigation. Do NOT repeat raw numeric stat lists; refer to conceptual patterns.\n" + "AVOID: Fluff, motivational filler, verbatim stat dumps." + ) + + request_body = { + "messages": [ + { + "role": "user", + "content": [{ + "text": f"{coaching_preamble}\n\nTASK INPUT:\n{prompt}" + }] + } + ], + "inferenceConfig": { + "max_new_tokens": max_tokens, + "temperature": temperature, + "top_p": 0.9 + } + } + + max_retries = 3 + base_delay = 2 + + for attempt in range(max_retries): + try: + response = bedrock_runtime.invoke_model( + modelId=BEDROCK_MODEL_ID, + body=json.dumps(request_body), + contentType='application/json', + accept='application/json' + ) + raw = response['body'].read().decode('utf-8', errors='replace') + try: + body = json.loads(raw) + except json.JSONDecodeError: + print(f"Bedrock response not JSON: {raw[:400]}") + return "Model response parsing error." + + # Expected structure: body['output']['message']['content'][0]['text'] + out = ( + body.get('output', {}) + .get('message', {}) + .get('content', []) + ) + if out and isinstance(out, list): + text_candidate = out[0].get('text') + if text_candidate: + return text_candidate.strip() + + # Fallback: search for any 'text' field + def find_text(node): + if isinstance(node, dict): + if 'text' in node and isinstance(node['text'], str): + return node['text'] + for v in node.values(): + found = find_text(v) + if found: + return found + elif isinstance(node, list): + for v in node: + found = find_text(v) + if found: + return found + return None + + fallback = find_text(body) + if fallback: + return fallback.strip() + + print(f"Unexpected Bedrock output structure: {json.dumps(body)[:500]}") + return "No answer generated." + except ClientError as e: + code = e.response['Error'].get('Code', '') + print(f"Bedrock ClientError {code}: {e}") + if code in ('ThrottlingException', 'TooManyRequestsException') and attempt < max_retries - 1: + delay = base_delay * (2 ** attempt) + time.sleep(delay) + continue + return "Bedrock error." + except Exception as e: + print(f"Unexpected Bedrock exception: {e}") + if attempt < max_retries - 1: + time.sleep(base_delay * (2 ** attempt)) + continue + return "Unexpected error." + return "System busy." + + +# ============================================================================ +# UTILITY FUNCTIONS +# ============================================================================ + +def cors_response(status_code: int, body: dict) -> dict: + """CORS-enabled API Gateway response""" + return { + 'statusCode': status_code, + 'headers': { + 'Content-Type': 'application/json', + 'Access-Control-Allow-Origin': '*', + 'Access-Control-Allow-Headers': 'Content-Type,Authorization', + 'Access-Control-Allow-Methods': 'GET,POST,OPTIONS' + }, + 'body': json.dumps(body, cls=DecimalEncoder) + } + +def search_similar_scenarios_knn(query_embedding: list, question: str, player_stats: dict, limit: int = 10) -> list: + """ + Search for similar match scenarios using KNN vector search in OpenSearch + """ + try: + # Build KNN query + knn_query = { + "size": limit, + "query": { + "knn": { + "embedding": { + "vector": query_embedding, + "k": limit + + } + } + }, + "_source": [ + "match_id", "player_name", "champion", "position", "win", + "kills", "deaths", "assists", "kda", "cs_per_min", + "vision_score", "dpm", "gpm", "kill_participation", + "match_summary" + ] + } + + response = opensearch_client.search(index=INDEX_NAME, body=knn_query) + + scenarios = [] + for hit in response['hits']['hits']: + source = hit['_source'] + scenarios.append({ + 'match_id': source.get('match_id'), + 'player_name': source.get('player_name'), + 'champion': source.get('champion'), + 'position': source.get('position'), + 'win': source.get('win'), + 'kda': source.get('kda'), + 'cs_per_min': source.get('cs_per_min'), + 'vision_score': source.get('vision_score'), + 'dpm': source.get('dpm'), + 'gpm': source.get('gpm'), + 'kill_participation': source.get('kill_participation'), + 'summary': source.get('match_summary', ''), + 'relevance_score': hit['_score'] + + }) + + print(f"KNN search returned {len(scenarios)} scenarios") + return scenarios + + except Exception as e: + print(f"KNN search error: {e}") + import traceback + traceback.print_exc() + return [] + + +def search_similar_scenarios_text(question: str, player_stats: dict, limit: int = 10) -> list: + """ + Fallback text-based search when embedding fails + + """ + try: + # Extract keywords from question + keywords = question.lower().split() + search_terms = [k for k in keywords if len(k) > 3][:5] # Top 5 meaningful words + + # Build multi-match query + text_query = { + "size": limit, + "query": { + "bool": { + "should": [ + { + "multi_match": { + "query": " ".join(search_terms), + "fields": ["match_summary^2", "champion", "position"], + "type": "best_fields" + } + }, + { + "range": { + "kda": { + "gte": max(0, player_stats.get('avg_kda', 2) - 1), + "lte": player_stats.get('avg_kda', 2) + 1 + } + } + } + ] + } + }, + "_source": [ + "match_id", "player_name", "champion", "position", "win", + "kills", "deaths", "assists", "kda", "cs_per_min", + "vision_score", "dpm", "gpm", "kill_participation", + "match_summary" + ] + } + + response = opensearch_client.search(index=INDEX_NAME, body=text_query) + + scenarios = [] + for hit in response['hits']['hits']: + source = hit['_source'] + scenarios.append({ + 'match_id': source.get('match_id'), + 'player_name': source.get('player_name'), + 'champion': source.get('champion'), + 'position': source.get('position'), + 'win': source.get('win'), + 'kda': source.get('kda'), + 'cs_per_min': source.get('cs_per_min'), + 'vision_score': source.get('vision_score'), + 'dpm': source.get('dpm'), + 'gpm': source.get('gpm'), + 'kill_participation': source.get('kill_participation'), + 'summary': source.get('match_summary', ''), + 'relevance_score': hit['_score'] + }) + + print(f"Text search returned {len(scenarios)} scenarios") + return scenarios + + except Exception as e: + print(f"Text search error: {e}") + import traceback + traceback.print_exc() + return [] + + +def build_rag_prompt(question: str, player_stats: dict, opensearch_stats: dict, + most_played: dict, similar_scenarios: list) -> str: + """ + Macro-focused coaching prompt (replaces previous verbose stat-centric prompt). + """ + + indicators = compute_macro_indicators(player_stats, opensearch_stats) + + # Compress stats (only essentials) + concise_stats = ( + f"KDA {player_stats.get('avg_kda', 0):.2f}, CS/min {player_stats.get('avg_cs_per_min', 0):.2f}, " + f"Deaths {player_stats.get('avg_deaths', 0):.1f}, KP {player_stats.get('avg_kill_participation', 0):.2f}, " + f"Vision {player_stats.get('avg_vision_score', 0):.1f}, WinRate {player_stats.get('win_rate', 0):.1f}%" + ) + + # Scenario synthesis (no raw repetition) + scenario_lines = [] + for s in similar_scenarios[:5]: + scenario_lines.append( + f"{s.get('champion')} {s.get('position')} | {'W' if s.get('win') else 'L'} | KDA {s.get('kda', 0):.2f} | " + f"CSm {s.get('cs_per_min', 0):.2f} | KP {s.get('kill_participation', 0):.1%}" + ) + scenarios_block = "\n".join(scenario_lines) if scenario_lines else "None" + + prompt = f""" +User Question: {question} + +Player Snapshot (do NOT restate every number later): {concise_stats} +Derived Macro Indicators: +- Laning Efficiency: {indicators['laning_efficiency']} +- Objective Alignment: {indicators['objective_alignment']} +- Map Influence: {indicators['map_influence']} +- Risk Management: {indicators['risk_management']} +- Tempo Conversion: {indicators['tempo_conversion']} +Flags: EarlyGame={indicators['early_game_flag']}, DeathPressure={indicators['death_pressure_flag']}, Vision={indicators['vision_flag']} + +Most Played (top 3): {', '.join([f'{c}({g})' for c, g in list(most_played.items())[:3]]) or 'N/A'} + +Similar Scenario Summaries (aggregated, do NOT copy blindly): +{scenarios_block} + +Output Requirements: +1. Do NOT repeat raw stat lists; reference concepts (e.g., "high death volatility") instead. +2. Identify one PRIMARY macro weakness (not mechanical) with reasoning. +3. Provide a MACRO IMPROVEMENT PLAN (phased: early → mid → late). +4. Extract DECISION PATTERNS from scenarios (pressure, over-extension, rotation timing). +5. Give 3 PRACTICAL DRILLS (each: objective, duration, measurable success metric). +6. Provide a ONE-WEEK FOCUS checklist (5 concise bullets). +7. Keep under 380 words. Avoid fluff. No generic motivational lines. +8. If the user question is unrelated (e.g., math), briefly answer then still deliver coaching. + +Return ONLY this structured format: +Primary Weakness: +Macro Improvement Plan: +Decision Patterns: +Drills: +One-Week Focus: + +Now generate the coaching response. +""" + return prompt + + +def invoke_bedrock_nova(prompt: str, max_tokens: int = 520, temperature: float = 0.6) -> str: + """ + Bedrock invoke for Amazon Nova (no 'system' role allowed). + Embed coaching instructions into the single user message. + Removes previous use of an invalid 'system' role. + """ + coaching_preamble = ( + "ROLE: High-level League of Legends macro coach.\n" + "STYLE: Concise, analytical; focus on rotations, lane management, vision timing, resource sequencing, " + "objective trades, risk mitigation. Do NOT repeat raw numeric stat lists; refer to conceptual patterns.\n" + "AVOID: Fluff, motivational filler, verbatim stat dumps." + ) + + request_body = { + "messages": [ + { + "role": "user", + "content": [{ + "text": f"{coaching_preamble}\n\nTASK INPUT:\n{prompt}" + }] + } + ], + "inferenceConfig": { + "max_new_tokens": max_tokens, + "temperature": temperature, + "top_p": 0.9 + } + } + + max_retries = 3 + base_delay = 2 + + for attempt in range(max_retries): + try: + response = bedrock_runtime.invoke_model( + modelId=BEDROCK_MODEL_ID, + body=json.dumps(request_body), + contentType='application/json', + accept='application/json' + ) + raw = response['body'].read().decode('utf-8', errors='replace') + try: + body = json.loads(raw) + except json.JSONDecodeError: + print(f"Bedrock response not JSON: {raw[:400]}") + return "Model response parsing error." + + # Expected structure: body['output']['message']['content'][0]['text'] + out = ( + body.get('output', {}) + .get('message', {}) + .get('content', []) + ) + if out and isinstance(out, list): + text_candidate = out[0].get('text') + if text_candidate: + return text_candidate.strip() + + # Fallback: search for any 'text' field + def find_text(node): + if isinstance(node, dict): + if 'text' in node and isinstance(node['text'], str): + return node['text'] + for v in node.values(): + found = find_text(v) + if found: + return found + elif isinstance(node, list): + for v in node: + found = find_text(v) + if found: + return found + return None + + fallback = find_text(body) + if fallback: + return fallback.strip() + + print(f"Unexpected Bedrock output structure: {json.dumps(body)[:500]}") + return "No answer generated." + except ClientError as e: + code = e.response['Error'].get('Code', '') + print(f"Bedrock ClientError {code}: {e}") + if code in ('ThrottlingException', 'TooManyRequestsException') and attempt < max_retries - 1: + delay = base_delay * (2 ** attempt) + time.sleep(delay) + continue + return "Bedrock error." + except Exception as e: + print(f"Unexpected Bedrock exception: {e}") + if attempt < max_retries - 1: + time.sleep(base_delay * (2 ** attempt)) + continue + return "Unexpected error." + return "System busy." diff --git a/aws/lambda-functions/lol-timeline-event-processor/lambda_function.py b/aws/lambda-functions/lol-timeline-event-processor/lambda_function.py new file mode 100644 index 0000000..d296af6 --- /dev/null +++ b/aws/lambda-functions/lol-timeline-event-processor/lambda_function.py @@ -0,0 +1,871 @@ +""" +Processes timeline-data.json files and extracts critical events +ENHANCED: Better distance calculations, wave state estimation, team composition tracking +Triggered by S3 upload events +""" + +import json +import boto3 +import os +import math +from datetime import datetime, timedelta +from decimal import Decimal +from typing import Dict, List, Tuple +import uuid + +s3_client = boto3.client('s3') +dynamodb = boto3.resource('dynamodb') + +# Get table names from environment variables +EVENTS_TABLE_NAME = os.environ.get('EVENTS_TABLE_NAME', 'lol-timeline-events') +METADATA_TABLE_NAME = os.environ.get('METADATA_TABLE_NAME', 'lol-player-timeline-metadata') + +events_table = dynamodb.Table(EVENTS_TABLE_NAME) +metadata_table = dynamodb.Table(METADATA_TABLE_NAME) + +# Summoner spell cooldowns (in seconds) +SUMMONER_SPELL_COOLDOWNS = { + 'SummonerFlash': 300, + 'SummonerTeleport': 360, + 'SummonerIgnite': 180, + 'SummonerHeal': 240, + 'SummonerBarrier': 180, + 'SummonerExhaust': 210, + 'SummonerSmite': 90, + 'SummonerGhost': 180, + 'SummonerCleanse': 210, +} + + +class TimelineEventExtractor: + """ + Extracts critical moments from League of Legends timeline data + Now tracks player location, summoner spells, and wave states + """ + + CRITICAL_EVENT_TYPES = [ + 'CHAMPION_KILL', + 'ELITE_MONSTER_KILL', + 'BUILDING_KILL', + 'CHAMPION_SPECIAL_KILL', + ] + + OBJECTIVE_VALUES = { + 'DRAGON': 1000, + 'BARON_NASHOR': 3000, + 'RIFTHERALD': 1500, + 'HORDE': 500, # Voidgrub + 'TOWER_PLATE': 300, + 'OUTER_TURRET': 800, + 'INNER_TURRET': 1000, + 'BASE_TURRET': 1200, + 'NEXUS_TURRET': 1500, + 'INHIBITOR': 1500 + } + + def __init__(self): + self.events = [] + self.summoner_spell_tracker = {} + + def extract_critical_moments(self, timeline_data: dict, + match_data: dict, + target_puuid: str) -> Tuple[List[Dict], Dict]: + """ + Identifies critical moments that significantly impacted game outcome + Returns: (critical_moments, player_context) + """ + critical_moments = [] + + frames = timeline_data.get('info', {}).get('frames', []) + participant_map = self._build_participant_map(match_data) + target_participant_id = self._get_participant_id(match_data, target_puuid) + + if not target_participant_id: + print(f"Warning: Could not find participant ID for {target_puuid}") + return [], {} + + # Extract player's team and get player context early + target_team = participant_map.get(target_participant_id, {}).get('team') + player_context = self._get_player_context(match_data, target_puuid) + + # Initialize summoner spell tracker for the player + self._initialize_summoner_tracker(match_data, target_participant_id) + + print(f"Player Context: {player_context}") + print(f"Player Summoner Spells: {self.summoner_spell_tracker.get(target_participant_id, {})}") + + for frame_idx, frame in enumerate(frames): + timestamp = frame.get('timestamp', 0) / 1000 / 60 # Convert to minutes + + # Track summoner spell usage in this frame + self._track_summoner_spells(frame, timestamp) + + # Extract events from this frame + for event in frame.get('events', []): + event_type = event.get('type') + + if event_type in self.CRITICAL_EVENT_TYPES: + critical_event = self._analyze_event( + event, frame, timestamp, participant_map, + target_participant_id, target_team, player_context + ) + + if critical_event: + critical_moments.append(critical_event) + + # Detect teamfights + teamfights = self._detect_teamfights( + frames, participant_map, target_participant_id, target_team, player_context + ) + critical_moments.extend(teamfights) + + # Sort by impact score + critical_moments.sort(key=lambda x: x['impact_score'], reverse=True) + + # Return top 15 moments + player context + return critical_moments[:15], player_context + + def _initialize_summoner_tracker(self, match_data: dict, target_participant_id: int): + """Initialize summoner spell tracking for the target player""" + participants = match_data.get('info', {}).get('participants', []) + for participant in participants: + if participant['participantId'] == target_participant_id: + spell1 = participant.get('summoner1Id') + spell2 = participant.get('summoner2Id') + + # Map spell IDs to names (common ones) + spell_map = { + 4: 'SummonerFlash', + 12: 'SummonerTeleport', + 14: 'SummonerIgnite', + 7: 'SummonerHeal', + 21: 'SummonerBarrier', + 3: 'SummonerExhaust', + 11: 'SummonerSmite', + 6: 'SummonerGhost', + 1: 'SummonerCleanse', + } + + self.summoner_spell_tracker[target_participant_id] = { + 'spell1': { + 'name': spell_map.get(spell1, 'Unknown'), + 'id': spell1, + 'last_used': -1000 + }, + 'spell2': { + 'name': spell_map.get(spell2, 'Unknown'), + 'id': spell2, + 'last_used': -1000 + } + } + break + + def _track_summoner_spells(self, frame: dict, current_timestamp: float): + """Track when summoner spells are used (approximation)""" + # Note: Timeline API doesn't explicitly track summoner usage + # We estimate based on kill participation and assume Flash/TP were used + pass + + def _get_summoner_cooldowns(self, participant_id: int, current_timestamp: float) -> Dict: + """Calculate current summoner spell cooldowns""" + spell_data = self.summoner_spell_tracker.get(participant_id, {}) + + if not spell_data: + return { + 'flash_cooldown': 0, + 'other_cooldown': 0, + 'other_spell': 'Unknown', + 'tp_available': False + } + + spell1 = spell_data.get('spell1', {}) + spell2 = spell_data.get('spell2', {}) + + # Calculate cooldowns + spell1_name = spell1.get('name', 'Unknown') + spell2_name = spell2.get('name', 'Unknown') + + spell1_cd = SUMMONER_SPELL_COOLDOWNS.get(spell1_name, 300) + spell2_cd = SUMMONER_SPELL_COOLDOWNS.get(spell2_name, 300) + + spell1_last_used = spell1.get('last_used', -1000) + spell2_last_used = spell2.get('last_used', -1000) + + time_since_spell1 = (current_timestamp - spell1_last_used) * 60 + time_since_spell2 = (current_timestamp - spell2_last_used) * 60 + + spell1_remaining = max(0, spell1_cd - time_since_spell1) + spell2_remaining = max(0, spell2_cd - time_since_spell2) + + # Identify Flash and other spell + flash_cd = 0 + other_cd = 0 + other_spell = 'Unknown' + tp_available = False + + if spell1_name == 'SummonerFlash': + flash_cd = int(spell1_remaining) + other_cd = int(spell2_remaining) + other_spell = spell2_name.replace('Summoner', '') + elif spell2_name == 'SummonerFlash': + flash_cd = int(spell2_remaining) + other_cd = int(spell1_remaining) + other_spell = spell1_name.replace('Summoner', '') + else: + other_cd = int(spell1_remaining) + other_spell = spell1_name.replace('Summoner', '') + + if spell1_name == 'SummonerTeleport' and spell1_remaining == 0: + tp_available = True + elif spell2_name == 'SummonerTeleport' and spell2_remaining == 0: + tp_available = True + + return { + 'flash_cooldown': flash_cd, + 'other_cooldown': other_cd, + 'other_spell': other_spell, + 'tp_available': tp_available + } + + def _calculate_distance(self, pos1: dict, pos2: dict) -> float: + """Calculate Euclidean distance between two positions""" + x1, y1 = pos1.get('x', 0), pos1.get('y', 0) + x2, y2 = pos2.get('x', 0), pos2.get('y', 0) + return math.sqrt((x2 - x1)**2 + (y2 - y1)**2) + + def _get_player_location_context(self, frame: dict, target_participant_id: int, + event_position: dict) -> Dict: + """Get player's location relative to the event""" + participant_frames = frame.get('participantFrames', {}) + player_frame = participant_frames.get(str(target_participant_id), {}) + + player_position = player_frame.get('position', {'x': 0, 'y': 0}) + + distance = self._calculate_distance(player_position, event_position) + player_lane = self._get_lane_from_position(player_position) + + return { + 'position': player_position, + 'lane': player_lane, + 'distance_to_event': int(distance) + } + + def _get_player_context(self, match_data: dict, target_puuid: str) -> Dict: + """ + Extracts player context from match data + """ + participants = match_data.get('info', {}).get('participants', []) + for participant in participants: + if participant.get('puuid') == target_puuid: + return { + 'champion': participant.get('championName', 'Champion'), + 'position': participant.get('teamPosition', 'Role'), + 'lane': participant.get('lane', 'UNKNOWN'), + 'role': participant.get('role', 'SOLO'), + 'team_id': participant.get('teamId'), + 'summoner_name': participant.get('riotIdGameName', 'Unknown'), + 'summoner_tag': participant.get('riotIdTagline', 'Unknown') + } + + return { + 'champion': 'Champion', + 'position': 'Role', + 'lane': 'UNKNOWN', + 'role': 'SOLO' + } + + def _analyze_event(self, event: dict, frame: dict, + timestamp: float, participant_map: dict, + target_participant_id: int, target_team: int, + player_context: Dict = None) -> Dict: + """ + Analyzes individual event for criticality + Now includes player location and summoner spell data + """ + event_type = event.get('type') + impact_score = 0 + event_details = {} + event_position = event.get('position', {'x': 7200, 'y': 7200}) + + # Get player location context + player_location = self._get_player_location_context( + frame, target_participant_id, event_position + ) + + # Get summoner spell cooldowns + summoner_spells = self._get_summoner_cooldowns(target_participant_id, timestamp) + + if event_type == 'CHAMPION_KILL': + killer_id = event.get('killerId') + victim_id = event.get('victimId') + assisting_ids = event.get('assistingParticipantIds', []) + + is_player_involved = ( + killer_id == target_participant_id or + victim_id == target_participant_id or + target_participant_id in assisting_ids + ) + + if not is_player_involved: + killer_team = participant_map.get(killer_id, {}).get('team') + if killer_team != target_team: + return None + + shutdown_bounty = event.get('bounty', 0) + + impact_score = 50 + if len(assisting_ids) >= 3: + impact_score += 30 + if shutdown_bounty > 500: + impact_score += 100 + if killer_id == target_participant_id: + impact_score += 20 + elif victim_id == target_participant_id: + impact_score += 25 + + event_details = { + 'killer': participant_map.get(killer_id, {}).get('champion'), + 'killer_name': participant_map.get(killer_id, {}).get('name'), + 'victim': participant_map.get(victim_id, {}).get('champion'), + 'victim_name': participant_map.get(victim_id, {}).get('name'), + 'assistants': [ + participant_map.get(aid, {}).get('champion') + for aid in assisting_ids + ], + 'shutdown_gold': int(shutdown_bounty), + 'event_position_x': event_position.get('x', 0), + 'event_position_y': event_position.get('y', 0), + 'event_position_lane': self._get_lane_from_position(event_position), + 'player_role': ( + 'killer' if killer_id == target_participant_id + else 'victim' if victim_id == target_participant_id + else 'assistant' if target_participant_id in assisting_ids + else 'team_involved' + ) + } + + context = self._build_event_context(frame, participant_map, target_team) + context['player_location'] = player_location + context['summoner_spells'] = summoner_spells + + return { + 'event_id': f"KILL_{timestamp:.1f}_{uuid.uuid4().hex[:8]}", + 'timestamp_minutes': float(timestamp), + 'event_type': 'KILL', + 'impact_score': int(impact_score), + 'event_details': event_details, + 'game_state': self._get_game_state(timestamp), + 'context': context, + 'player_context': player_context + } + + elif event_type == 'ELITE_MONSTER_KILL': + monster_type = event.get('monsterType') + killer_team_id = event.get('killerTeamId') + + is_player_team = (killer_team_id == target_team) + + impact_score = self.OBJECTIVE_VALUES.get(monster_type, 500) + if is_player_team: + impact_score += 100 + else: + impact_score += 60 + + event_details = { + 'objective_type': monster_type, + 'securing_team': 'PLAYER_TEAM' if is_player_team else 'ENEMY_TEAM', + 'killer_id': event.get('killerId'), + 'event_position_x': event_position.get('x', 0), + 'event_position_y': event_position.get('y', 0), + 'event_position_lane': self._get_lane_from_position(event_position) + } + + context = self._build_event_context(frame, participant_map, target_team) + context['player_location'] = player_location + context['summoner_spells'] = summoner_spells + + return { + 'event_id': f"OBJECTIVE_{timestamp:.1f}_{uuid.uuid4().hex[:8]}", + 'timestamp_minutes': float(timestamp), + 'event_type': 'OBJECTIVE', + 'impact_score': int(impact_score), + 'event_details': event_details, + 'game_state': self._get_game_state(timestamp), + 'context': context, + 'player_context': player_context + } + + elif event_type == 'BUILDING_KILL': + building_type = event.get('buildingType') + killer_team_id = event.get('killerTeamId') + lane = event.get('laneType', 'UNKNOWN') + + is_player_team = (killer_team_id == target_team) + + if 'INHIBITOR' in building_type: + impact_score = self.OBJECTIVE_VALUES['INHIBITOR'] + else: + impact_score = self.OBJECTIVE_VALUES.get('OUTER_TURRET', 600) + + if is_player_team: + impact_score += 40 + else: + impact_score += 25 + + event_details = { + 'structure_type': building_type, + 'lane': lane, + 'destroying_team': 'PLAYER_TEAM' if is_player_team else 'ENEMY_TEAM', + 'event_position_x': event_position.get('x', 0), + 'event_position_y': event_position.get('y', 0), + 'event_position_lane': self._get_lane_from_position(event_position) + } + + context = self._build_event_context(frame, participant_map, target_team) + context['player_location'] = player_location + context['summoner_spells'] = summoner_spells + + return { + 'event_id': f"STRUCTURE_{timestamp:.1f}_{uuid.uuid4().hex[:8]}", + 'timestamp_minutes': float(timestamp), + 'event_type': 'STRUCTURE', + 'impact_score': int(impact_score), + 'event_details': event_details, + 'game_state': self._get_game_state(timestamp), + 'context': context, + 'player_context': player_context + } + + return None + + def _detect_teamfights(self, frames: List[dict], + participant_map: dict, + target_participant_id: int, + target_team: int, + player_context: Dict = None) -> List[Dict]: + """ + Detects teamfights by clustering kills/deaths in time and space + """ + teamfights = [] + + kill_events = [] + for frame in frames: + timestamp = frame.get('timestamp', 0) / 1000 / 60 + + for event in frame.get('events', []): + if event.get('type') == 'CHAMPION_KILL': + kill_events.append({ + 'timestamp': timestamp, + 'position': event.get('position', {}), + 'killer_id': event.get('killerId'), + 'victim_id': event.get('victimId'), + 'assisting_ids': event.get('assistingParticipantIds', []), + 'frame': frame + }) + + i = 0 + while i < len(kill_events): + cluster = [kill_events[i]] + j = i + 1 + + while j < len(kill_events): + time_diff = abs(kill_events[j]['timestamp'] - kill_events[i]['timestamp']) + + if time_diff <= 0.5: # Within 30 seconds + cluster.append(kill_events[j]) + j += 1 + else: + break + + if len(cluster) >= 3: + all_participants = set() + player_involved = False + cluster_positions = [k['position'] for k in cluster] + avg_position = self._get_average_position(cluster_positions) + + for kill in cluster: + all_participants.add(kill['killer_id']) + all_participants.add(kill['victim_id']) + all_participants.update(kill['assisting_ids']) + + if target_participant_id in [kill['killer_id'], kill['victim_id']] or \ + target_participant_id in kill['assisting_ids']: + player_involved = True + + if len(all_participants) >= 6 and player_involved: + player_team_kills = sum( + 1 for kill in cluster + if participant_map.get(kill['killer_id'], {}).get('team') == target_team + ) + enemy_kills = len(cluster) - player_team_kills + + outcome = 'WON' if player_team_kills > enemy_kills else \ + 'LOST' if enemy_kills > player_team_kills else 'EVEN' + + # Get player location context for teamfight + first_frame = cluster[0]['frame'] + player_location = self._get_player_location_context( + first_frame, target_participant_id, avg_position + ) + summoner_spells = self._get_summoner_cooldowns( + target_participant_id, cluster[0]['timestamp'] + ) + + context = { + 'player_location': player_location, + 'summoner_spells': summoner_spells, + 'gold_difference': 0, + 'gold_state': 'unknown' + } + + teamfights.append({ + 'event_id': f"TEAMFIGHT_{cluster[0]['timestamp']:.1f}_{uuid.uuid4().hex[:8]}", + 'timestamp_minutes': float(cluster[0]['timestamp']), + 'event_type': 'TEAMFIGHT', + 'impact_score': int(150 + (len(cluster) * 50)), + 'event_details': { + 'kills_count': len(cluster), + 'participants_count': len(all_participants), + 'player_team_kills': player_team_kills, + 'enemy_team_kills': enemy_kills, + 'outcome': outcome, + 'duration_seconds': int((cluster[-1]['timestamp'] - cluster[0]['timestamp']) * 60), + 'event_position_x': avg_position.get('x', 0), + 'event_position_y': avg_position.get('y', 0), + 'event_position_lane': self._get_lane_from_position(avg_position) + }, + 'game_state': self._get_game_state(cluster[0]['timestamp']), + 'context': context, + 'player_context': player_context + }) + + i = j if j > i + 1 else i + 1 + + return teamfights + + def _get_lane_from_position(self, position: dict) -> str: + """ + Determine lane from X/Y coordinates + League map is roughly 14400x14400 + """ + x = position.get('x', 7200) + y = position.get('y', 7200) + + if x < 4800: + return 'BOT' + elif x > 9600: + return 'TOP' + elif y > 7200: + return 'TOP' + elif y < 7200: + return 'BOT' + return 'MID' + + def _get_average_position(self, positions: List[dict]) -> dict: + """ + Calculate average position from multiple coordinates + """ + if not positions: + return {'x': 0, 'y': 0} + + avg_x = sum(p.get('x', 0) for p in positions) / len(positions) + avg_y = sum(p.get('y', 0) for p in positions) / len(positions) + + return {'x': int(avg_x), 'y': int(avg_y)} + + def _build_participant_map(self, match_data: dict) -> Dict: + """ + Creates mapping of participantId to player info + """ + participant_map = {} + + participants = match_data.get('info', {}).get('participants', []) + for participant in participants: + participant_map[participant['participantId']] = { + 'name': f"{participant.get('riotIdGameName', 'Unknown')}", + 'champion': participant.get('championName'), + 'team': participant.get('teamId'), + 'position': participant.get('teamPosition'), + 'lane': participant.get('lane'), + 'role': participant.get('role'), + 'puuid': participant.get('puuid') + } + + return participant_map + + def _get_participant_id(self, match_data: dict, puuid: str) -> int: + """ + Gets participant ID for given PUUID + """ + participants = match_data.get('info', {}).get('participants', []) + for participant in participants: + if participant.get('puuid') == puuid: + return participant['participantId'] + return None + + def _build_event_context(self, frame: dict, participant_map: dict, + target_team: int) -> Dict: + """ + Builds contextual information for the event + """ + participant_frames = frame.get('participantFrames', {}) + + team_100_gold = sum( + p.get('totalGold', 0) + for p_id, p in participant_frames.items() + if participant_map.get(int(p_id), {}).get('team') == 100 + ) + team_200_gold = sum( + p.get('totalGold', 0) + for p_id, p in participant_frames.items() + if participant_map.get(int(p_id), {}).get('team') == 200 + ) + + if target_team == 100: + gold_diff = team_100_gold - team_200_gold + else: + gold_diff = team_200_gold - team_100_gold + + return { + 'gold_difference': int(gold_diff), + 'gold_state': 'ahead' if gold_diff > 1000 else 'behind' if gold_diff < -1000 else 'even' + } + + def _get_game_state(self, timestamp: float) -> str: + """ + Determines game state based on timestamp + """ + if timestamp < 15: + return 'early' + elif timestamp < 25: + return 'mid' + else: + return 'late' + +def lambda_handler(event, context): + """ + Processes timeline data - handles both S3 triggers and Step Functions invocations + """ + + print(f"Timeline Processor Lambda invoked. Event keys: {list(event.keys())}") + processing_results = [] + + try: + # Case 1: S3 Trigger (direct upload) + if 'Records' in event and event['Records'][0].get('s3'): + print("Handling S3 trigger event") + return handle_s3_trigger(event) + + # Case 2: Step Functions invocation + elif 'match_id' in event and 'puuid' in event: + print("Handling Step Functions invocation") + return handle_step_functions_invocation(event) + + else: + print(f"Unknown event type. Event structure: {json.dumps(event)[:500]}") + raise ValueError("Invalid event payload. Expected S3 trigger or Step Functions payload.") + + except Exception as e: + print(f"Error processing timeline: {str(e)}") + import traceback + traceback.print_exc() + + return { + 'statusCode': 500, + 'body': json.dumps({'error': str(e)}) + } + + +def handle_s3_trigger(event): + """Handle S3 upload trigger""" + import urllib.parse + + processing_results = [] + + for record in event['Records']: + bucket = record['s3']['bucket']['name'] + key = urllib.parse.unquote_plus(record['s3']['object']['key']) + + print(f"Processing S3 file: s3://{bucket}/{key}") + + result = process_timeline_file(bucket, key) + if result: + processing_results.append(result) + + return { + 'statusCode': 200, + 'body': json.dumps({ + 'message': f'Processed {len(processing_results)} match files', + 'results': processing_results + }) + } + + +def handle_step_functions_invocation(event): + """Handle Step Functions invocation""" + match_id = event['match_id'] + puuid = event['puuid'] + force_reprocess = event.get('force_reprocess', False) + + print(f"Processing match {match_id} for player {puuid}") + + # Check if already processed + if not force_reprocess: + try: + response = metadata_table.get_item( + Key={'puuid': puuid, 'match_id': match_id} + ) + if 'Item' in response: + print(f"Match {match_id} already processed, skipping") + return { + 'statusCode': 200, + 'already_processed': True, + 'match_id': match_id + } + except Exception as e: + print(f"Error checking metadata: {e}") + + # Get game_name and tagline directly from the event payload + game_name = event.get('game_name') + tagline = event.get('tagline') + + player_folder = None + + if game_name and tagline: + player_folder = f"{game_name}_{tagline}" + print(f"Received player folder from event: {player_folder}") + else: + print(f"Warning: game_name/tagline not in Step Functions event for match {match_id}.") + pass + + if not player_folder: + # This is the error your log shows + print(f"Could not find S3 folder for match {match_id}. Event data missing game_name/tagline.") + return { + 'statusCode': 404, + 'error': f'Match data S3 folder not found for {match_id}. Event missing game_name/tagline.' + } + + # Construct S3 key directly + bucket = os.environ.get('S3_BUCKET_RAW', 'lol-training-matches-150k') + timeline_key = f"raw-matches/{player_folder}/{match_id}/timeline-data.json" + + # Process the file, passing the known PUUID + result = process_timeline_file(bucket, timeline_key, target_puuid_from_event=puuid) + + if result: + return { + 'statusCode': 200, + 'match_id': match_id, + 'events_extracted': result.get('events_found', 0) + } + else: + return { + 'statusCode': 500, + 'error': 'Failed to process timeline' + } + + +def process_timeline_file(bucket: str, key: str, target_puuid_from_event: str = None): + """ + Core processing logic - extracted to be used by both trigger types + """ + try: + parts = key.split('/') + if len(parts) < 4: + print(f"Invalid key format: {key}") + return None + + player_folder = parts[1] + match_id = parts[2] + + # Get match data + match_key = key.replace('timeline-data.json', 'match-data.json') + print(f"Looking for match data at: {match_key}") + + try: + match_obj = s3_client.get_object(Bucket=bucket, Key=match_key) + match_data = json.loads(match_obj['Body'].read()) + except s3_client.exceptions.NoSuchKey: + print(f"ERROR: match-data.json not found at {match_key}") + return None + + target_puuid = target_puuid_from_event + + if not target_puuid: + # Fallback for S3 trigger (not Step Functions) + print(f"PUUID not passed from event, deriving from folder name: {player_folder}") + player_folder_parts = player_folder.split('_') + if len(player_folder_parts) >= 2: + target_game_name = player_folder_parts[0] + target_tagline = '_'.join(player_folder_parts[1:]) + + for p in match_data.get('info', {}).get('participants', []): + if p.get('riotIdGameName') == target_game_name and \ + p.get('riotIdTagline') == target_tagline: + target_puuid = p.get('puuid') + break + + if not target_puuid: + print(f"Warning: Could not find PUUID for {player_folder}") + return None + + # Get timeline data + timeline_obj = s3_client.get_object(Bucket=bucket, Key=key) + timeline_data = json.loads(timeline_obj['Body'].read()) + + print(f"Extracting events for match {match_id}, player {target_puuid}") + + # Extract critical moments + extractor = TimelineEventExtractor() + critical_moments, player_context = extractor.extract_critical_moments( + timeline_data, match_data, target_puuid + ) + + print(f"Extracted {len(critical_moments)} critical moments") + + # Save to DynamoDB + save_count = 0 + if critical_moments: + with events_table.batch_writer() as batch: + for moment in critical_moments: + item = { + 'match_id': match_id, + 'event_id': moment['event_id'], + 'puuid': target_puuid, + 'timestamp_minutes': Decimal(str(moment['timestamp_minutes'])), + 'event_type': moment['event_type'], + 'impact_score': moment['impact_score'], + 'game_state': moment['game_state'], + 'event_details': json.dumps(moment['event_details']), + 'context': json.dumps(moment.get('context', {})), + 'player_context': json.dumps(moment.get('player_context', {})), + 'created_at': int(datetime.utcnow().timestamp()) + } + batch.put_item(Item=item) + save_count += 1 + + print(f"Saved {save_count} events to DynamoDB") + + # Save metadata + metadata_table.put_item(Item={ + 'puuid': target_puuid, + 'match_id': match_id, + 'champion': player_context.get('champion'), + 'lane': player_context.get('lane'), + 'position': player_context.get('position'), + 'processed_timestamp': int(datetime.utcnow().timestamp()), + 'events_count': len(critical_moments), + 'processing_status': 'completed', + 'player_folder': player_folder, + 's3_key': key + }) + + print(f"✓ Successfully processed {key}") + return {'match_id': match_id, 'events_found': save_count} + + except Exception as e: + print(f"Error in process_timeline_file: {str(e)}") + import traceback + traceback.print_exc() + return None \ No newline at end of file diff --git a/aws/lambda-functions/lol-timeline-summary-generator/lambda_function.py b/aws/lambda-functions/lol-timeline-summary-generator/lambda_function.py new file mode 100644 index 0000000..b50c8e7 --- /dev/null +++ b/aws/lambda-functions/lol-timeline-summary-generator/lambda_function.py @@ -0,0 +1,893 @@ +""" +Enhanced Bedrock Coaching Generator with Macro Focus +Generates personalized coaching summaries with reduced hallucinations +""" + +import json +import boto3 +import re +import math +from datetime import datetime, timedelta +from typing import Dict, List, Tuple, Optional + +# AWS clients +dynamodb = boto3.resource('dynamodb') +bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1') +s3_client = boto3.client('s3') + +# DynamoDB tables +summaries_table = dynamodb.Table('lol-timeline-timeline-ai-summaries') + +BEDROCK_MODEL_ID = 'amazon.nova-pro-v1:0' +MAX_TOKENS = 300 +TEMPERATURE = 0.3 # Lowered for less hallucination + + +class RobustContextExtractor: + """Extracts rich metrics with robust JSON parsing""" + + def __init__(self, timeline_data: dict, match_data: dict): + self.timeline_data = timeline_data + self.match_data = match_data + self.frames = timeline_data.get('info', {}).get('frames', []) + self.participants = self._build_participant_map(match_data) + + def _safe_json_parse(self, json_str: str, default: dict = None) -> dict: + """Robustly parse JSON with multiple fallback strategies""" + if default is None: + default = {} + + if not json_str or not isinstance(json_str, str): + return default + + # Try direct parse first + try: + return json.loads(json_str) + except json.JSONDecodeError: + pass + + # Try removing problematic characters + try: + cleaned = json_str.replace('\x00', '').replace('\n', ' ') + return json.loads(cleaned) + except json.JSONDecodeError: + pass + + # Try extracting valid JSON substrings + try: + match = re.search(r'\{.*\}', json_str) + if match: + return json.loads(match.group()) + except json.JSONDecodeError: + pass + + print(f"⚠️ Failed to parse JSON: {json_str[:100]}") + return default + + def _build_participant_map(self, match_data: dict) -> Dict: + """Build participant metadata from match data""" + pmap = {} + try: + for p in match_data.get('info', {}).get('participants', []): + p_id = p.get('participantId') + pmap[p_id] = { + 'name': p.get('riotIdGameName', 'Unknown'), + 'champion': p.get('championName', 'Unknown'), + 'team': p.get('teamId'), + 'role': p.get('teamPosition', 'UNKNOWN'), + 'puuid': p.get('puuid'), + # New: Add final stats for context + 'final_kda': f"{p.get('kills', 0)}/{p.get('deaths', 0)}/{p.get('assists', 0)}", + 'win': p.get('win', False) + } + except Exception as e: + print(f"Error building participant map: {str(e)}") + + return pmap + + def get_frame_at_timestamp(self, timestamp_minutes: float) -> Tuple[dict, int]: + """Find the closest frame to event timestamp""" + if not self.frames: + return {}, -1 + + timestamp_ms = timestamp_minutes * 60 * 1000 + + closest_frame = None + closest_diff = float('inf') + closest_idx = -1 + + for idx, frame in enumerate(self.frames): + frame_time = frame.get('timestamp', 0) + diff = abs(frame_time - timestamp_ms) + + if diff < closest_diff: + closest_diff = diff + closest_frame = frame + closest_idx = idx + + return closest_frame or {}, closest_idx + + def get_player_frame_stats(self, participant_id: int, frame: dict) -> Dict: + """Extract detailed stats for player at frame""" + participant_frames = frame.get('participantFrames', {}) + player_frame = participant_frames.get(str(participant_id), {}) + + champion_stats = player_frame.get('championStats', {}) + damage_stats = player_frame.get('damageStats', {}) + + return { + 'level': player_frame.get('level', 1), + 'minions_killed': player_frame.get('minionsKilled', 0), + 'jungle_minions': player_frame.get('jungleMinionsKilled', 0), + 'total_gold': player_frame.get('totalGold', 0), + 'current_gold': player_frame.get('currentGold', 0), + 'xp': player_frame.get('xp', 0), + 'position': player_frame.get('position', {'x': 0, 'y': 0}), + 'stats': { + 'health': { + 'current': champion_stats.get('health', 0), + 'max': champion_stats.get('healthMax', 0) + }, + 'armor': champion_stats.get('armor', 0), + 'mr': champion_stats.get('magicResist', 0), + 'ad': champion_stats.get('attackDamage', 0), + 'ap': champion_stats.get('abilityPower', 0), + }, + 'damage': { + 'total_damage_dealt': damage_stats.get('totalDamageDone', 0), + 'total_damage_taken': damage_stats.get('totalDamageTaken', 0) + } + } + + def get_team_stats(self, frame: dict, team_id: int) -> Dict: + """Get aggregated team statistics at this frame""" + participant_frames = frame.get('participantFrames', {}) + + team_members = [ + p_id for p_id, p_info in self.participants.items() + if p_info.get('team') == team_id + ] + + total_gold = 0 + total_kills = 0 + avg_level = 0 + + for p_id in team_members: + p_frame = participant_frames.get(str(p_id), {}) + total_gold += p_frame.get('totalGold', 0) + avg_level += p_frame.get('level', 0) + + return { + 'total_gold': total_gold, + 'avg_level': avg_level / max(len(team_members), 1), + 'member_count': len(team_members) + } + + def calculate_distance(self, pos1: dict, pos2: dict) -> float: + """Euclidean distance between two positions""" + x1 = pos1.get('x', 0) + y1 = pos1.get('y', 0) + x2 = pos2.get('x', 0) + y2 = pos2.get('y', 0) + return math.sqrt((x2 - x1)**2 + (y2 - y1)**2) + + def get_location_context(self, player_pos: dict, event_pos: dict) -> Dict: + """Get spatial relationship context""" + distance = self.calculate_distance(player_pos, event_pos) + + # Classify distance (in game units) + if distance < 1500: + proximity = "IMMEDIATE" + elif distance < 3000: + proximity = "CLOSE" + elif distance < 5000: + proximity = "MEDIUM" + elif distance < 8000: + proximity = "FAR" + else: + proximity = "VERY_FAR" + + # Classify location + map_center_x, map_center_y = 7500, 7500 + event_x = event_pos.get('x', 0) + event_y = event_pos.get('y', 0) + + # Determine quadrant and lane + if event_x < 4000: + if event_y < 4000: + location = "BOTTOM_JUNGLE" + elif event_y > 10000: + location = "BOTTOM_LANE" + else: + location = "BOTTOM_RIVER" + elif event_x > 10000: + if event_y < 4000: + location = "TOP_LANE" + elif event_y > 10000: + location = "TOP_JUNGLE" + else: + location = "TOP_RIVER" + else: + if event_y < 6000: + location = "MID_LANE" + elif event_y > 9000: + location = "MID_LANE" + else: + location = "CENTER" + + return { + 'distance_units': int(distance), + 'proximity': proximity, + 'location': location, + 'event_x': int(event_x), + 'event_y': int(event_y), + 'player_x': int(player_pos.get('x', 0)), + 'player_y': int(player_pos.get('y', 0)) + } + + +class EnhancedBedrockCoachingGenerator: + """Generates personalized coaching with macro focus and hallucination prevention""" + + # Forbidden terms that indicate ability hallucination + ABILITY_RED_FLAGS = [ + 'ultimate', 'ult ', ' q ', ' w ', ' e ', ' r ', + 'passive', 'combo', 'cast', 'channel', + 'skill shot', 'skillshot', 'execute', + 'dash', 'leap', 'blink', 'jump' + ] + + # Allowed terms even if they contain red flags + ALLOWED_TERMS = [ + 'teleport', 'flash', 'tp ', 'recall', + 'ult point', 'ultimate objective' # Context matters + ] + + def __init__(self): + self.bedrock = bedrock_runtime + self.model_id = BEDROCK_MODEL_ID + self.rejected_count = 0 + self.total_count = 0 + + def generate_event_summary(self, event: Dict, context_extractor: RobustContextExtractor) -> str: + """Generate coaching summary with spatial context and validation""" + + self.total_count += 1 + + # Parse event data robustly + player_context = self._extract_player_context(event, context_extractor) + event_details = self._extract_event_details(event) + location_context = self._extract_location_context(event, context_extractor) + + if not player_context.get('champion'): + print(f" ⚠️ Could not determine champion for event {event.get('event_id')}") + return "" + + # Get enhanced metrics + enhanced_metrics = self._get_enhanced_metrics(event, context_extractor, player_context) + + # Build coaching prompt + coaching_prompt = self._build_coaching_prompt( + event, + player_context, + event_details, + location_context, + enhanced_metrics, + context_extractor + ) + + print(f"🎯 Coaching Prompt Preview:\n{coaching_prompt[:300]}...\n") + + summary = self._invoke_bedrock(coaching_prompt, player_context.get('champion')) + + # Log rejection rate + if self.total_count % 5 == 0: + rejection_rate = (self.rejected_count / self.total_count) * 100 + print(f"📊 Rejection Rate: {rejection_rate:.1f}% ({self.rejected_count}/{self.total_count})") + + return summary + + def _get_enhanced_metrics(self, event: Dict, extractor: RobustContextExtractor, + player_context: Dict) -> Dict: + """Extract enhanced metrics for better coaching context""" + + timestamp = float(event.get('timestamp_minutes', 0)) + frame, frame_idx = extractor.get_frame_at_timestamp(timestamp) + + metrics = { + 'player_stats': {}, + 'team_comparison': {}, + 'wave_state': 'unknown', + 'objective_timers': {} + } + + if not frame: + return metrics + + try: + # Find participant ID + puuid = event.get('puuid') + participant_id = None + team_id = None + + for p_id, p_info in extractor.participants.items(): + if p_info.get('puuid') == puuid: + participant_id = p_id + team_id = p_info.get('team') + break + + if not participant_id: + return metrics + + # Get player stats + player_stats = extractor.get_player_frame_stats(participant_id, frame) + metrics['player_stats'] = { + 'level': player_stats['level'], + 'gold': player_stats['total_gold'], + 'cs': player_stats['minions_killed'] + player_stats['jungle_minions'], + 'health_percent': int((player_stats['stats']['health']['current'] / + max(player_stats['stats']['health']['max'], 1)) * 100) + } + + # Get team comparison + if team_id: + player_team_stats = extractor.get_team_stats(frame, team_id) + enemy_team_id = 200 if team_id == 100 else 100 + enemy_team_stats = extractor.get_team_stats(frame, enemy_team_id) + + gold_diff = player_team_stats['total_gold'] - enemy_team_stats['total_gold'] + level_diff = player_team_stats['avg_level'] - enemy_team_stats['avg_level'] + + metrics['team_comparison'] = { + 'gold_difference': int(gold_diff), + 'level_difference': round(level_diff, 1), + 'gold_state': 'ahead' if gold_diff > 2000 else 'behind' if gold_diff < -2000 else 'even' + } + + # Estimate wave state based on CS + expected_cs = timestamp * 4 # Rough estimate: ~4 CS per minute + cs_diff = metrics['player_stats']['cs'] - expected_cs + + if cs_diff > 10: + metrics['wave_state'] = 'ahead_in_lane' + elif cs_diff < -10: + metrics['wave_state'] = 'behind_in_lane' + else: + metrics['wave_state'] = 'even_in_lane' + + # Objective timers (approximations based on game time) + if timestamp >= 5: + metrics['objective_timers']['dragon_available'] = timestamp >= 5 + if timestamp >= 8: + metrics['objective_timers']['herald_available'] = timestamp >= 8 and timestamp < 20 + if timestamp >= 20: + metrics['objective_timers']['baron_available'] = timestamp >= 20 + + except Exception as e: + print(f"Error extracting enhanced metrics: {str(e)}") + + return metrics + + def _extract_player_context(self, event: Dict, extractor: RobustContextExtractor) -> Dict: + """Robustly extract player context""" + player_context_str = event.get('player_context', '{}') + if isinstance(player_context_str, dict) and 'S' in player_context_str: + player_context_str = player_context_str['S'] + + player_context = extractor._safe_json_parse(player_context_str, {}) + + # Fallback: try to get from participants if extraction failed + if not player_context.get('champion'): + puuid = event.get('puuid', '') + for p_id, p_info in extractor.participants.items(): + if p_info.get('puuid') == puuid: + player_context = { + 'champion': p_info.get('champion', 'Unknown'), + 'position': p_info.get('role', 'UNKNOWN'), + 'team_id': p_info.get('team'), + 'summoner_name': p_info.get('name', 'Player'), + } + break + + return player_context + + def _extract_event_details(self, event: Dict) -> Dict: + """Extract event details""" + event_details_str = event.get('event_details', '{}') + if isinstance(event_details_str, dict) and 'S' in event_details_str: + event_details_str = event_details_str['S'] + + extractor = RobustContextExtractor({}, {}) + return extractor._safe_json_parse(event_details_str, {}) + + def _extract_location_context(self, event: Dict, extractor: RobustContextExtractor) -> Dict: + """Extract location and positioning data""" + context_str = event.get('context', '{}') + if isinstance(context_str, dict) and 'S' in context_str: + context_str = context_str['S'] + + context = extractor._safe_json_parse(context_str, {}) + + player_pos = context.get('player_location', {}).get('position', {'x': 0, 'y': 0}) + event_details = self._extract_event_details(event) + event_pos = { + 'x': event_details.get('event_position_x', 0), + 'y': event_details.get('event_position_y', 0) + } + + location = extractor.get_location_context(player_pos, event_pos) + location['player_lane'] = context.get('player_location', {}).get('lane', 'UNKNOWN') + location['summoner_spells'] = context.get('summoner_spells', {}) + + return location + + def _build_coaching_prompt(self, event: Dict, player_context: Dict, + event_details: Dict, location_context: Dict, + enhanced_metrics: Dict, + extractor: RobustContextExtractor) -> str: + """Build detailed coaching prompt focused on macro gameplay""" + + timestamp = float(event.get('timestamp_minutes', 0)) + champion = player_context.get('champion', 'Unknown') + position = player_context.get('position', 'UNKNOWN') + event_type = event.get('event_type', 'UNKNOWN') + + # Check if player was actively involved in the event + player_role = event_details.get('player_role', 'spectator') + was_participant = player_role in ['killer', 'victim', 'assistant'] + + # If player participated, distance is effectively 0 + if was_participant: + distance = 0 + proximity = "PARTICIPANT" + event_location = location_context.get('location', 'UNKNOWN') + player_lane = location_context.get('player_lane', 'UNKNOWN') + else: + distance = location_context.get('distance_units', 0) + proximity = location_context.get('proximity', 'UNKNOWN') + event_location = location_context.get('location', 'UNKNOWN') + player_lane = location_context.get('player_lane', 'UNKNOWN') + + # Summoner spell context + summoner_spells = location_context.get('summoner_spells', {}) + flash_cd = summoner_spells.get('flash_cooldown', 0) + other_spell = summoner_spells.get('other_spell', 'Unknown') + other_cd = summoner_spells.get('other_cooldown', 0) + tp_available = summoner_spells.get('tp_available', False) + + spell_status = [] + if tp_available: + spell_status.append("✓ Teleport AVAILABLE") + elif other_spell == 'Teleport': + spell_status.append(f"✗ Teleport on CD ({other_cd}s)") + + if flash_cd == 0: + spell_status.append("✓ Flash available") + else: + spell_status.append(f"✗ Flash on CD ({flash_cd}s)") + + spell_info = " | ".join(spell_status) if spell_status else "Summoner status unknown" + + # Enhanced metrics + player_stats = enhanced_metrics.get('player_stats', {}) + team_comp = enhanced_metrics.get('team_comparison', {}) + wave_state = enhanced_metrics.get('wave_state', 'unknown') + + stats_line = "" + if player_stats: + stats_line = f"Level {player_stats.get('level', '?')}, {player_stats.get('cs', '?')} CS, {player_stats.get('gold', 0)}g" + + team_state = "" + if team_comp: + gold_diff = team_comp.get('gold_difference', 0) + if abs(gold_diff) >= 1000: + team_state = f"Team is {abs(gold_diff)}g {'AHEAD' if gold_diff > 0 else 'BEHIND'}" + else: + team_state = "Team gold is EVEN" + + # Build event-specific context + event_context = self._build_event_specific_context(event_type, event_details, player_context) + + # Determine coaching focus based on participation + if was_participant: + # Player was involved - focus on cost-benefit analysis + coaching_focus = f"""COACHING FOCUS: +The player ({champion}) was an ACTIVE PARTICIPANT in this event as {player_role}. +Analyze whether participating in this event was the correct macro decision. + +Consider: +- What did the player sacrifice to be here? (Wave state, CS, tower plates) +- What did the team gain? (Gold, objectives, map pressure) +- Was this the highest priority action at {timestamp:.1f} minutes? +- What should the player do AFTER this event? (Push, recall, rotate, take objective)""" + else: + # Player was not involved - focus on rotation decision + coaching_focus = f"""COACHING FOCUS: +The player ({champion}) was NOT involved in this event (distance: {distance} units). +Analyze whether the player made the correct rotation decision. + +Consider: +- Should they have rotated to help? (Distance: {distance} units, {proximity}) +- Was staying in {player_lane} the better choice? +- What were they doing instead? (Pushing, farming, taking objectives) +- Did their decision maximize team advantage?""" + + prompt = f"""MATCH SITUATION at {timestamp:.1f} minutes: +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +PLAYER: {champion} ({position} role) +CURRENT POSITION: {player_lane} lane +{stats_line} +{team_state} + +EVENT: {event_type} +EVENT LOCATION: {event_location} +{'PLAYER PARTICIPATION: Active participant ('+player_role+')' if was_participant else 'DISTANCE FROM PLAYER: '+str(distance)+' units ('+proximity+')'} + +SUMMONER SPELLS: {spell_info} + +WAVE STATE: {wave_state} + +{event_context} + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +{coaching_focus} + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +Provide macro-focused coaching for {champion}. + +STRICT REQUIREMENTS: +- Focus ONLY on: map rotations, wave management, objective priority, vision control +- NO champion abilities, combos, or specific mechanics +- Maximum 100 words + +FORMAT: +1. Describe what happened and the player's involvement (1-2 sentences) +2. Analyze the macro decision: Was participating/not participating the right choice? +3. ONE specific actionable tip for similar situations""" + + return prompt + + def _build_event_specific_context(self, event_type: str, event_details: Dict, + player_context: Dict) -> str: + """Build context specific to the event type""" + + if event_type == "OBJECTIVE": + obj_type = event_details.get('objective_type', 'Unknown') + securing_team = event_details.get('securing_team', 'Unknown') + + obj_values = { + 'DRAGON': '1000g + permanent buff', + 'BARON_NASHOR': '3000g + Baron buff (significant)', + 'RIFTHERALD': '1500g + tower pressure', + 'HORDE': '500g + team stats' + } + obj_value = obj_values.get(obj_type, 'Unknown value') + + return f"OBJECTIVE DETAILS:\n- Type: {obj_type} ({obj_value})\n- Secured by: {securing_team}" + + elif event_type == "KILL": + victim = event_details.get('victim', 'Unknown') + killer = event_details.get('killer', 'Unknown') + player_role = event_details.get('player_role', 'unknown') + assistants = event_details.get('assistants', []) + shutdown_gold = event_details.get('shutdown_gold', 0) + + # Calculate gold value + base_kill_gold = 300 + total_kill_gold = base_kill_gold + shutdown_gold + assist_gold = int(total_kill_gold * 0.5) if assistants else 0 + + involvement_text = "" + if player_role == 'killer': + involvement_text = f"You got the kill: +{total_kill_gold}g" + elif player_role == 'assistant': + involvement_text = f"You assisted: +{assist_gold}g" + elif player_role == 'victim': + involvement_text = "You died: Gave enemy gold and map pressure" + else: + involvement_text = "Your team was involved" + + return f"KILL DETAILS:\n- Victim: {victim}\n- Killer: {killer}\n- Assistants: {len(assistants)}\n- {involvement_text}\n- Shutdown value: {shutdown_gold}g" + + elif event_type == "STRUCTURE": + structure = event_details.get('structure_type', 'Unknown') + destroying_team = event_details.get('destroying_team', 'Unknown') + lane = event_details.get('lane', 'Unknown') + + structure_values = { + 'TOWER_BUILDING': '250-300g split + map pressure', + 'INHIBITOR': '50g each + super minions (huge)' + } + structure_value = structure_values.get(structure, 'Unknown value') + + return f"STRUCTURE DETAILS:\n- Type: {structure} ({structure_value})\n- Lane: {lane}\n- Destroyed by: {destroying_team}" + + elif event_type == "TEAMFIGHT": + outcome = event_details.get('outcome', 'Unknown') + player_kills = event_details.get('player_team_kills', 0) + enemy_kills = event_details.get('enemy_team_kills', 0) + duration = event_details.get('duration_seconds', 0) + + return f"TEAMFIGHT DETAILS:\n- Outcome: {outcome}\n- Score: {player_kills} kills vs {enemy_kills} deaths\n- Duration: {duration} seconds\n- Approximate gold swing: {abs(player_kills - enemy_kills) * 300}g" + + return "" + + def _invoke_bedrock(self, user_prompt: str, champion: str) -> str: + """Call Bedrock API with macro-focused system prompt and validation""" + + system_prompt = [{ + "text": """You are an elite League of Legends macro strategy coach. You analyze rotations, wave management, and objective priority. + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +CRITICAL RULES - VIOLATIONS RESULT IN REJECTED RESPONSE: +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +1. NEVER mention champion abilities (Q, W, E, R, ultimate, passive, combos) +2. NEVER describe champion mechanics or kits +3. ONLY discuss: Teleport, Flash, map rotations, wave states, objective timing +4. If you don't know something, focus on general positioning instead of guessing + +COACHING APPROACH: +- If player WAS INVOLVED: Analyze cost-benefit of their participation +- If player WAS NOT INVOLVED: Analyze their rotation decision + +FOCUS ON MACRO DECISIONS: +✓ Cost-benefit analysis (what did they gain vs sacrifice?) +✓ Wave management (push, freeze, recall) +✓ Objective trading (give up X to take Y) +✓ Post-event sequencing (what to do after the play) +✓ Timing windows (when to move based on distance and summoner spells) + +RESPONSE STRUCTURE (100 words max): +1. What happened + player's involvement (1-2 sentences) +2. Cost-benefit analysis OR rotation analysis (1-2 sentences) +3. ONE actionable tip for similar situations (1 sentence) + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +GOOD EXAMPLES - WHEN PLAYER PARTICIPATED: +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +"Darius assisted Diana in securing a kill on Gnar in mid lane at 11 minutes. While the kill netted your team 268 gold and removed Gnar from the map temporarily, Darius left a large top wave crashing into his tower, sacrificing approximately 120 gold and experience. Given the team was already 3600 gold ahead, the better decision would have been to finish pushing the top wave, then recall to buy items. Against a losing opponent, prioritize your own gold and experience leads over low-value kills." + +"Your team secured the Ocean Dragon at 16 minutes while you were 9500 units away in top lane. Since you couldn't reach the objective even with Teleport on cooldown, staying top to push the wave was the optimal play. This forced the enemy top laner to choose between helping at Dragon or losing tower plates. After your team secures an objective while you're split pushing, immediately look to back and regroup for the next objective timer." + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +GOOD EXAMPLES - WHEN PLAYER DID NOT PARTICIPATE: +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +"The Rift Herald was secured at top river, 10,500 units from where you were pushing bottom lane. With Teleport on cooldown and your team already securing the objective, you made the correct decision to continue pushing. This created map pressure and forced the enemy bot laner to stay in lane. When objectives are being taken without you and you can't rotate in time, always look to apply pressure elsewhere to prevent enemy rotations." + +"A teamfight broke out mid lane, 7600 units from your bot lane position. With Flash and Teleport both available, you should have immediately started rotating toward the fight. Even though the fight may end before you arrive, positioning yourself closer creates pressure and allows you to help secure follow-up objectives like towers or Dragon. Track teamfight patterns and begin moving 10-15 seconds before fights typically start." + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +BAD EXAMPLES - NEVER DO THIS: +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +"Use your ultimate to dash to the fight" ← WRONG: Mentions abilities +"Chain your Q into E combo" ← WRONG: Discusses mechanics +"Your passive would have helped" ← WRONG: References kit +"Execute with ultimate" ← WRONG: Ability-focused +"Flash in and use your combo" ← WRONG: Tactical execution""" + }] + + request_body = { + "messages": [ + { + "role": "user", + "content": [{"text": user_prompt}] + } + ], + "system": system_prompt, + "inferenceConfig": { + "max_new_tokens": MAX_TOKENS, + "temperature": TEMPERATURE, + "top_p": 0.85, + "top_k": 50 + } + } + + try: + response = bedrock_runtime.invoke_model( + modelId=self.model_id, + body=json.dumps(request_body), + contentType='application/json', + accept='application/json' + ) + + response_body = json.loads(response['body'].read()) + + if 'output' in response_body and 'message' in response_body['output']: + content = response_body['output']['message'].get('content', []) + if content: + summary = content[0].get('text', '').strip() + clean_summary = self._clean_response(summary) + + # Validate response + validated = self._validate_response(clean_summary, champion) + + if not validated: + self.rejected_count += 1 + print(f"❌ REJECTED response for {champion} (contained ability references)") + return "" + + return validated + + return "" + + except Exception as e: + print(f"❌ Bedrock error: {str(e)}") + return "" + + def _validate_response(self, text: str, champion: str) -> str: + """Validate response doesn't contain ability hallucinations""" + + if not text or len(text) < 20: + return "" + + text_lower = ' ' + text.lower() + ' ' + + # Check for red flags + for red_flag in self.ABILITY_RED_FLAGS: + if red_flag in text_lower: + # Check if it's in an allowed context + is_allowed = False + for allowed in self.ALLOWED_TERMS: + if allowed in text_lower: + # Additional check: make sure the red flag isn't near the allowed term + allowed_pos = text_lower.find(allowed) + red_pos = text_lower.find(red_flag) + if abs(allowed_pos - red_pos) < 20: # Within 20 characters + is_allowed = True + break + + if not is_allowed: + print(f"⚠️ Validation failed: Found '{red_flag.strip()}' in response") + return "" + + return text + + def _clean_response(self, text: str) -> str: + """Clean response of formatting artifacts""" + # Remove XML tags + text = re.sub(r'<[^>]+>', '', text) + # Remove code blocks + text = re.sub(r'```[\s\S]*?```', '', text) + # Normalize whitespace + text = ' '.join(text.split()).strip() + + return text if len(text) > 15 else "" + + +def lambda_handler(event, context): + """Enhanced Lambda handler with better metrics""" + + print("🚀 Enhanced Bedrock Coaching Generator v2.0") + print(f"Event keys: {event.keys() if isinstance(event, dict) else 'Not a dict'}") + + try: + # Parse input + if 'body' in event and isinstance(event.get('body'), str): + body = json.loads(event['body']) + else: + body = event + + match_id = body.get('match_id') + puuid = body.get('puuid') + player_folder = body.get('player_folder') + + # Reconstruct player_folder if missing + if not player_folder and 'events' in body and body['events']: + events_list = body['events'] + if isinstance(events_list, dict) and 'Items' in events_list: + events_list = events_list['Items'] + + if events_list: + first_event = events_list[0] + pc_str = first_event.get('player_context', {}) + if isinstance(pc_str, dict) and 'S' in pc_str: + pc_str = pc_str['S'] + + extractor_temp = RobustContextExtractor({}, {}) + player_context = extractor_temp._safe_json_parse(pc_str, {}) + + summoner_name = player_context.get('summoner_name', '') + summoner_tag = player_context.get('summoner_tag', '') + + if summoner_name and summoner_tag: + player_folder = f"{summoner_name}_{summoner_tag}" + + if not all([match_id, puuid, player_folder]): + return { + 'statusCode': 400, + 'body': json.dumps({'error': f'Missing fields - match_id={match_id}, puuid={puuid}, player_folder={player_folder}'}) + } + + # Load timeline and match data + s3_bucket = 'lol-training-matches-150k' + base_path = f'raw-matches/{player_folder}/{match_id}' + + try: + timeline_obj = s3_client.get_object(Bucket=s3_bucket, Key=f'{base_path}/timeline-data.json') + timeline_data = json.loads(timeline_obj['Body'].read()) + + match_obj = s3_client.get_object(Bucket=s3_bucket, Key=f'{base_path}/match-data.json') + match_data = json.loads(match_obj['Body'].read()) + except Exception as e: + return {'statusCode': 404, 'body': json.dumps({'error': f'S3 load failed: {str(e)}'})} + + # Initialize components + context_extractor = RobustContextExtractor(timeline_data, match_data) + generator = EnhancedBedrockCoachingGenerator() + + # Process events + raw_events = body.get('events', []) + if isinstance(raw_events, dict) and 'Items' in raw_events: + raw_events = raw_events['Items'] + + summaries_generated = 0 + errors = [] + + print(f"📝 Processing {len(raw_events[:15])} events...") + + for idx, event_item in enumerate(raw_events[:15], 1): + try: + print(f"\n{'='*60}") + print(f"Event {idx}/15: {event_item.get('event_type', {}).get('S', 'UNKNOWN')}") + print(f"{'='*60}") + + # Parse event + event = { + 'event_id': event_item.get('event_id', {}).get('S') if isinstance(event_item.get('event_id'), dict) else event_item.get('event_id'), + 'timestamp_minutes': float(event_item.get('timestamp_minutes', {}).get('N', 0) if isinstance(event_item.get('timestamp_minutes'), dict) else event_item.get('timestamp_minutes', 0)), + 'event_type': event_item.get('event_type', {}).get('S') if isinstance(event_item.get('event_type'), dict) else event_item.get('event_type'), + 'event_details': event_item.get('event_details', {}).get('S') if isinstance(event_item.get('event_details'), dict) else event_item.get('event_details'), + 'player_context': event_item.get('player_context', {}).get('S') if isinstance(event_item.get('player_context'), dict) else event_item.get('player_context'), + 'context': event_item.get('context', {}).get('S') if isinstance(event_item.get('context'), dict) else event_item.get('context'), + 'puuid': puuid + } + + # Generate summary + summary = generator.generate_event_summary(event, context_extractor) + + if summary and len(summary) > 15: + summaries_table.put_item(Item={ + 'event_id': event['event_id'], + 'summary_type': 'enhanced_v2', + 'match_id': match_id, + 'puuid': puuid, + 'summary_text': summary, + 'generated_at': int(datetime.utcnow().timestamp()), + 'ttl': int((datetime.utcnow() + timedelta(days=7)).timestamp()), + 'model_version': 'nova-pro-v1-macro-focused' + }) + summaries_generated += 1 + print(f"✅ Generated: {summary[:80]}...") + else: + print(f"⚠️ No valid summary generated (likely rejected for ability mentions)") + + except Exception as e: + error_msg = f"{event_item.get('event_id')}: {str(e)}" + print(f"❌ {error_msg}") + errors.append(error_msg) + + # Final statistics + rejection_rate = (generator.rejected_count / max(generator.total_count, 1)) * 100 + + return { + 'statusCode': 200, + 'body': json.dumps({ + 'summaries_generated': summaries_generated, + 'events_processed': len(raw_events[:15]), + 'rejection_rate': f"{rejection_rate:.1f}%", + 'rejections': generator.rejected_count, + 'errors': errors if errors else None + }) + } + + except Exception as e: + print(f"💥 Fatal error: {str(e)}") + import traceback + traceback.print_exc() + return {'statusCode': 500, 'body': json.dumps({'error': str(e)})} \ No newline at end of file diff --git a/aws/sagemaker/jobs/deploy_endpoints.ipynb b/aws/sagemaker/jobs/deploy_endpoints.ipynb new file mode 100644 index 0000000..1457504 --- /dev/null +++ b/aws/sagemaker/jobs/deploy_endpoints.ipynb @@ -0,0 +1,138 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "execution_state": "idle", + "id": "75f75515-acf9-4860-ba5f-450fb79c3313", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sagemaker.config INFO - Fetched defaults config from location: /etc/xdg/sagemaker/config.yaml\n", + "sagemaker.config INFO - Not applying SDK defaults from location: /home/sagemaker-user/.config/sagemaker/config.yaml\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3Bucket\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3ObjectKeyPrefix\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3Bucket\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3ObjectKeyPrefix\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.Model.VpcConfig\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3Bucket\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3ObjectKeyPrefix\n", + "------!Model deployed to endpoint: playstyle-profiler-20251108-073923\n", + "Model deployed to: playstyle-profiler-20251108-073923\n" + ] + } + ], + "source": [ + "!python3 sagemaker_deployment.py \\\n", + " --role-arn arn:aws:iam::768394660366:role/datazone_usr_role_5i1vmxossv3f2o_b1rxf3f1mnfnv4 \\\n", + " --bucket lol-coach-processed-data \\\n", + " --action deploy-profiler \\\n", + " --model-data s3://lol-coach-processed-data/models/playstyle-profiler/sagemaker-scikit-learn-2025-11-05-03-06-41-484/output/model.tar.gz" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "execution_state": "idle", + "id": "e982eca7-69b2-494b-8e85-cb460c1a1ab9", + "metadata": { + "execution": { + "iopub.execute_input": "2025-11-08T00:01:37.578499Z", + "iopub.status.busy": "2025-11-08T00:01:37.578200Z", + "iopub.status.idle": "2025-11-08T00:02:09.088373Z", + "shell.execute_reply": "2025-11-08T00:02:09.087301Z", + "shell.execute_reply.started": "2025-11-08T00:01:37.578465Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1. Deleting Endpoint: playstyle-profiler-20251107-235250...\n", + " ...Waiting for endpoint to delete...\n", + " ...Endpoint deleted.\n", + "\n", + "2. Deleting Endpoint Config: playstyle-profiler-20251107-235250...\n", + " ...Endpoint Config deleted.\n", + "\n", + "3. Deleting Model: sagemaker-scikit-learn-2025-11-07-23-53-03-206...\n", + " ...Model deleted.\n", + "\n", + "All resources successfully deleted\n" + ] + } + ], + "source": [ + "import boto3\n", + "\n", + "ENDPOINT_NAME = \"playstyle-profiler-20251107-235250\" # <-- ENDPOINT NAME\n", + "\n", + "sm_client = boto3.client('sagemaker')\n", + "\n", + "try:\n", + " endpoint_desc = sm_client.describe_endpoint(EndpointName=ENDPOINT_NAME)\n", + " endpoint_config_name = endpoint_desc['EndpointConfigName']\n", + " \n", + " config_desc = sm_client.describe_endpoint_config(EndpointConfigName=endpoint_config_name)\n", + " model_name = config_desc['ProductionVariants'][0]['ModelName']\n", + " \n", + " # --- 1. Delete the Endpoint ---\n", + " print(f\"1. Deleting Endpoint: {ENDPOINT_NAME}...\")\n", + " sm_client.delete_endpoint(EndpointName=ENDPOINT_NAME)\n", + " print(\" ...Waiting for endpoint to delete...\")\n", + " waiter = sm_client.get_waiter('endpoint_deleted')\n", + " waiter.wait(EndpointName=ENDPOINT_NAME)\n", + " print(\" ...Endpoint deleted.\")\n", + "\n", + " # --- 2. Delete the Endpoint Config ---\n", + " print(f\"\\n2. Deleting Endpoint Config: {endpoint_config_name}...\")\n", + " sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)\n", + " print(\" ...Endpoint Config deleted.\")\n", + "\n", + " # --- 3. Delete the Model ---\n", + " print(f\"\\n3. Deleting Model: {model_name}...\")\n", + " sm_client.delete_model(ModelName=model_name)\n", + " print(\" ...Model deleted.\")\n", + " \n", + " print(\"\\nAll resources successfully deleted\")\n", + "\n", + "except Exception as e:\n", + " print(f\"Error: {e}\")\n", + " print(\"Please delete resources manually in the AWS SageMaker console.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7676e6e0-b48d-4f4b-9582-01c17c85903f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/aws/sagemaker/jobs/hypothetical_simulator.py b/aws/sagemaker/jobs/hypothetical_simulator.py new file mode 100644 index 0000000..7dfd2a5 --- /dev/null +++ b/aws/sagemaker/jobs/hypothetical_simulator.py @@ -0,0 +1,396 @@ +import pandas as pd +import numpy as np +from sklearn.ensemble import GradientBoostingClassifier +from sklearn.model_selection import train_test_split +import torch +import torch.nn as nn +import joblib +from typing import Dict, List, Tuple + +class TeamfightOutcomePredictor(nn.Module): + """ + Neural network to predict teamfight outcomes based on game state + """ + + def __init__(self, input_dim: int = 50): + super(TeamfightOutcomePredictor, self).__init__() + + self.network = nn.Sequential( + nn.Linear(input_dim, 128), + nn.ReLU(), + nn.Dropout(0.3), + nn.Linear(128, 64), + nn.ReLU(), + nn.Dropout(0.2), + nn.Linear(64, 32), + nn.ReLU(), + nn.Linear(32, 2) # Binary outcome: win/loss + ) + + def forward(self, x): + return self.network(x) + +class HypotheticalSimulator: + """ + Simulates alternative decision outcomes in critical game moments + """ + + def __init__(self): + self.teamfight_model = None + self.objective_model = None + self.positioning_model = None + + def prepare_teamfight_features(self, moment: Dict, match_data: Dict, + timeline_data: Dict) -> np.ndarray: + """ + Extracts features for teamfight outcome prediction + """ + timestamp = moment['timestamp'] + frame_idx = int(timestamp / 60) # Assuming 1 minute per frame + + # Get game state at moment + frames = timeline_data.get('info', {}).get('frames', []) + if frame_idx >= len(frames): + frame_idx = len(frames) - 1 + + frame = frames[frame_idx] + participants = frame.get('participantFrames', {}) + + # Team composition features + blue_team_ids = [1, 2, 3, 4, 5] + red_team_ids = [6, 7, 8, 9, 10] + + features = [] + + # === GOLD DIFFERENTIAL === + blue_gold = sum([participants.get(str(pid), {}).get('totalGold', 0) + for pid in blue_team_ids]) + red_gold = sum([participants.get(str(pid), {}).get('totalGold', 0) + for pid in red_team_ids]) + features.append((blue_gold - red_gold) / 1000) # Normalize + + # === LEVEL DIFFERENTIAL === + blue_levels = [participants.get(str(pid), {}).get('level', 0) + for pid in blue_team_ids] + red_levels = [participants.get(str(pid), {}).get('level', 0) + for pid in red_team_ids] + features.append(sum(blue_levels) - sum(red_levels)) + + # === HEALTH/ALIVE COUNT === + # This would require more detailed data + # For now, use placeholder + features.extend([5, 5]) # Assume all alive + + # === POSITIONING FEATURES === + # Distance from objectives, spread, etc. + blue_positions = [] + red_positions = [] + + for pid in blue_team_ids: + pos = participants.get(str(pid), {}).get('position', {}) + blue_positions.append((pos.get('x', 0), pos.get('y', 0))) + + for pid in red_team_ids: + pos = participants.get(str(pid), {}).get('position', {}) + red_positions.append((pos.get('x', 0), pos.get('y', 0))) + + # Calculate team spread (cohesion) + blue_spread = self._calculate_team_spread(blue_positions) + red_spread = self._calculate_team_spread(red_positions) + features.extend([blue_spread / 1000, red_spread / 1000]) + + # === ULTIMATE AVAILABILITY === + # Would need to track ultimate cooldowns + # Placeholder for now + features.extend([0.6, 0.6]) # Assume 60% ultimate availability + + # === SUMMONER SPELLS === + # Placeholder + features.extend([0.7, 0.7]) # Assume 70% summoner availability + + # === CHAMPION-SPECIFIC POWER SPIKES === + # Would require champion analysis + features.extend([1.0, 1.0]) + + # === OBJECTIVE PRESSURE === + # Distance to nearest objective + features.extend([0.5, 0.5]) + + # Pad features to reach input_dim + while len(features) < 50: + features.append(0.0) + + return np.array(features[:50], dtype=np.float32) + + def _calculate_team_spread(self, positions: List[Tuple[float, float]]) -> float: + """ + Calculates how spread out a team is (cohesion metric) + """ + if len(positions) < 2: + return 0.0 + + distances = [] + for i in range(len(positions)): + for j in range(i + 1, len(positions)): + dist = np.sqrt( + (positions[i][0] - positions[j][0]) ** 2 + + (positions[i][1] - positions[j][1]) ** 2 + ) + distances.append(dist) + + return np.mean(distances) if distances else 0.0 + + def simulate_alternative_decision(self, moment: Dict, alternative: str, + match_data: Dict, timeline_data: Dict) -> Dict: + """ + Simulates what would happen with an alternative decision + + Examples: + - "focus jinx instead of malphite" + - "take baron instead of dragon" + - "retreat instead of fight" + """ + + # Parse alternative decision + decision_type = self._classify_decision(alternative) + + # Get current state features + base_features = self.prepare_teamfight_features(moment, match_data, timeline_data) + + # Modify features based on alternative + modified_features = self._apply_decision_modification( + base_features, + decision_type, + alternative + ) + + # Predict outcomes + base_outcome = self._predict_outcome(base_features) + alternative_outcome = self._predict_outcome(modified_features) + + # Generate explanation + explanation = self._generate_explanation( + moment, + alternative, + base_outcome, + alternative_outcome, + match_data, + timeline_data + ) + + return { + 'original_decision': moment.get('details', {}), + 'alternative_decision': alternative, + 'original_win_probability': float(base_outcome['win_probability']), + 'alternative_win_probability': float(alternative_outcome['win_probability']), + 'probability_improvement': float( + alternative_outcome['win_probability'] - base_outcome['win_probability'] + ), + 'explanation': explanation, + 'recommendation': self._generate_recommendation( + base_outcome, alternative_outcome + ) + } + + def _classify_decision(self, alternative: str) -> str: + """ + Classifies the type of alternative decision + """ + alternative_lower = alternative.lower() + + if 'focus' in alternative_lower or 'target' in alternative_lower: + return 'TARGET_PRIORITY' + elif 'baron' in alternative_lower or 'dragon' in alternative_lower: + return 'OBJECTIVE_CHOICE' + elif 'retreat' in alternative_lower or 'disengage' in alternative_lower: + return 'ENGAGEMENT_DECISION' + elif 'engage' in alternative_lower or 'fight' in alternative_lower: + return 'ENGAGEMENT_DECISION' + else: + return 'POSITIONING' + + def _apply_decision_modification(self, features: np.ndarray, + decision_type: str, alternative: str) -> np.ndarray: + """ + Modifies feature vector based on alternative decision + """ + modified = features.copy() + + if decision_type == 'TARGET_PRIORITY': + # If focusing a different target (e.g., ADC vs Tank) + # Increase effective damage output, reduce time to kill + modified[10:15] *= 1.3 # Boost damage-related features + + elif decision_type == 'OBJECTIVE_CHOICE': + # Different objective = different positioning + modified[15:20] *= 0.8 # Adjust positioning features + + elif decision_type == 'ENGAGEMENT_DECISION': + if 'retreat' in alternative.lower(): + # Retreating = preserve resources + modified[5:10] *= 1.2 # Boost survival features + else: + # Engaging = risk/reward + modified[5:10] *= 0.7 # Reduce survival features + modified[10:15] *= 1.4 # Increase damage potential + + return modified + + def _predict_outcome(self, features: np.ndarray) -> Dict: + """ + Predicts outcome probabilities using trained model + """ + if self.teamfight_model is None: + # If model not loaded, return dummy prediction + return { + 'win_probability': 0.5 + np.random.randn() * 0.15, + 'confidence': 0.7 + } + + # Use actual model + with torch.no_grad(): + features_tensor = torch.FloatTensor(features).unsqueeze(0) + output = self.teamfight_model(features_tensor) + probabilities = torch.softmax(output, dim=1) + + return { + 'win_probability': float(probabilities[0][1]), + 'confidence': float(torch.max(probabilities)) + } + + def _generate_explanation(self, moment: Dict, alternative: str, + base_outcome: Dict, alt_outcome: Dict, + match_data: Dict, timeline_data: Dict) -> str: + """ + Generates natural language explanation of the simulation + """ + timestamp_str = self._format_timestamp(moment['timestamp']) + + if moment['type'] == 'TEAMFIGHT': + kills = moment['details'].get('kills', 0) + explanation = f"At {timestamp_str}, during the teamfight where {kills} champions died, " + + if 'focus' in alternative.lower(): + # Parse target names + explanation += f"if you had {alternative}, our analysis shows a " + improvement = (alt_outcome['win_probability'] - base_outcome['win_probability']) * 100 + + if improvement > 10: + explanation += f"{improvement:.0f}% higher probability of winning the fight. " + explanation += "This is because the alternative target had lower defensive stats and was positioned away from their support. " + explanation += "Eliminating them would have removed the enemy team's primary damage source, allowing your carries to survive longer." + elif improvement > 0: + explanation += f"{improvement:.0f}% slightly higher probability of winning. " + explanation += "However, the difference is marginal as both targets were viable options in that situation." + else: + explanation += f"actually a {abs(improvement):.0f}% lower probability of success. " + explanation += "Your original target priority was correct given the positioning and cooldowns available." + + elif moment['type'] == 'OBJECTIVE': + monster = moment['details'].get('monster_type', 'objective') + explanation += f"At {timestamp_str}, regarding the {monster}, " + explanation += f"if you had {alternative}, " + + improvement = (alt_outcome['win_probability'] - base_outcome['win_probability']) * 100 + if improvement > 0: + explanation += f"you would have had a {improvement:.0f}% better chance of securing the objective. " + else: + explanation += f"you would have had a {abs(improvement):.0f}% worse outcome. " + + return explanation + + def _format_timestamp(self, seconds: float) -> str: + """ + Formats timestamp as MM:SS + """ + minutes = int(seconds // 60) + secs = int(seconds % 60) + return f"{minutes}:{secs:02d}" + + def _generate_recommendation(self, base_outcome: Dict, alt_outcome: Dict) -> str: + """ + Generates actionable recommendation + """ + improvement = (alt_outcome['win_probability'] - base_outcome['win_probability']) * 100 + + if improvement > 15: + return "STRONG RECOMMENDATION: The alternative decision would have significantly improved your chances. Practice identifying similar situations." + elif improvement > 5: + return "MODERATE RECOMMENDATION: The alternative decision is better, but the difference is small. Both options were viable." + elif improvement > -5: + return "NEUTRAL: Both decisions had similar outcomes. Your choice was reasonable." + else: + return "YOUR DECISION WAS CORRECT: The alternative would have been worse. Good decision-making!" + + def train_model(self, training_data: pd.DataFrame): + """ + Trains the teamfight outcome prediction model + """ + # Prepare training data + # Assumes training_data has features and 'outcome' column (1=win, 0=loss) + + X = training_data.drop(['outcome', 'match_id'], axis=1, errors='ignore').values + y = training_data['outcome'].values + + X_train, X_test, y_train, y_test = train_test_split( + X, y, test_size=0.2, random_state=42 + ) + + # Initialize model + input_dim = X_train.shape[1] + self.teamfight_model = TeamfightOutcomePredictor(input_dim=input_dim) + + # Training loop + criterion = nn.CrossEntropyLoss() + optimizer = torch.optim.Adam(self.teamfight_model.parameters(), lr=0.001) + + # Convert to tensors + X_train_tensor = torch.FloatTensor(X_train) + y_train_tensor = torch.LongTensor(y_train) + + # Train + epochs = 100 + batch_size = 64 + + for epoch in range(epochs): + for i in range(0, len(X_train_tensor), batch_size): + batch_X = X_train_tensor[i:i+batch_size] + batch_y = y_train_tensor[i:i+batch_size] + + optimizer.zero_grad() + outputs = self.teamfight_model(batch_X) + loss = criterion(outputs, batch_y) + loss.backward() + optimizer.step() + + if (epoch + 1) % 10 == 0: + print(f"Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}") + + # Evaluate + with torch.no_grad(): + X_test_tensor = torch.FloatTensor(X_test) + outputs = self.teamfight_model(X_test_tensor) + _, predicted = torch.max(outputs.data, 1) + accuracy = (predicted == torch.LongTensor(y_test)).sum().item() / len(y_test) + print(f"Test Accuracy: {accuracy:.4f}") + + def save_model(self, path: str): + """ + Saves the trained model + """ + torch.save(self.teamfight_model.state_dict(), f"{path}/teamfight_model.pth") + + def load_model(self, path: str, input_dim: int = 50): + """ + Loads a trained model + """ + self.teamfight_model = TeamfightOutcomePredictor(input_dim=input_dim) + self.teamfight_model.load_state_dict(torch.load(f"{path}/teamfight_model.pth")) + self.teamfight_model.eval() + +if __name__ == "__main__": + # Training example + simulator = HypotheticalSimulator() + # simulator.train_model(training_data) + # simulator.save_model("/opt/ml/model") + print("Hypothetical Simulator ready") \ No newline at end of file diff --git a/aws/sagemaker/jobs/inference.py b/aws/sagemaker/jobs/inference.py new file mode 100644 index 0000000..e49051a --- /dev/null +++ b/aws/sagemaker/jobs/inference.py @@ -0,0 +1,46 @@ + +import joblib +import os +import json +import numpy as np + +def model_fn(model_dir): + '''Loads the model''' + model_path = os.path.join(model_dir, 'playstyle_profiler.pkl') + model_artifacts = joblib.load(model_path) + return model_artifacts + +def input_fn(request_body, content_type='application/json'): + '''Deserializes input data''' + if content_type == 'application/json': + data = json.loads(request_body) + return data + raise ValueError(f'Unsupported content type: {content_type}') + +def predict_fn(input_data, model_artifacts): + '''Makes predictions''' + scaler = model_artifacts['scaler'] + kmeans = model_artifacts['kmeans'] + pca = model_artifacts['pca'] + archetype_names = model_artifacts['archetype_names'] + + # Extract features + features = input_data['features'] + X = np.array(features).reshape(1, -1) + + # Transform and predict + X_scaled = scaler.transform(X) + X_pca = pca.transform(X_scaled) + cluster = kmeans.predict(X_pca)[0] + + return { + 'cluster': int(cluster), + 'archetype': archetype_names[cluster]['name'], + 'profile': archetype_names[cluster]['profile'] + } + +def output_fn(prediction, accept='application/json'): + '''Serializes predictions''' + if accept == 'application/json': + return json.dumps(prediction), accept + raise ValueError(f'Unsupported accept type: {accept}') diff --git a/aws/sagemaker/jobs/playstyle_profiler_training.py b/aws/sagemaker/jobs/playstyle_profiler_training.py new file mode 100644 index 0000000..5487d79 --- /dev/null +++ b/aws/sagemaker/jobs/playstyle_profiler_training.py @@ -0,0 +1,600 @@ +import pandas as pd +import numpy as np +from sklearn.preprocessing import StandardScaler +from sklearn.cluster import KMeans +from sklearn.decomposition import PCA +from sklearn.ensemble import RandomForestClassifier +from sklearn.model_selection import train_test_split, cross_val_score +from sklearn.metrics import silhouette_score +import joblib +import json +import os +from typing import Dict, List +import argparse + +class PlaystyleProfiler: + """ + Machine Learning model for player playstyle profiling and archetype classification + Maps playstyles to 13 League of Legends regions based on thematic characteristics + """ + + def __init__(self): + self.scaler = StandardScaler() + self.kmeans = None + self.pca = None + self.archetype_names = {} + self.feature_importance = {} + + # Region characteristics for mapping + self.region_themes = { + 'Bandle City': ['whimsical', 'unpredictable', 'mobile', 'creative'], + 'Bilgewater': ['aggressive', 'opportunistic', 'risky', 'gold-focused'], + 'Demacia': ['honorable', 'protective', 'teamfight', 'consistent'], + 'Ionia': ['balanced', 'harmonious', 'skillful', 'adaptable'], + 'Ixtal': ['jungle-focused', 'elemental', 'objective-control', 'hidden'], + 'Noxus': ['dominant', 'aggressive', 'conquest', 'powerful'], + 'Piltover': ['efficient', 'innovative', 'calculated', 'wealthy'], + 'Shadow Isles': ['draining', 'persistent', 'sustain', 'deaths-dance'], + 'Shurima': ['late-game', 'scaling', 'empire-building', 'patient'], + 'Targon': ['supportive', 'protective', 'vision', 'celestial'], + 'The Freljord': ['tanky', 'survival', 'cc-heavy', 'enduring'], + 'The Void': ['consuming', 'chaotic', 'damage-focused', 'relentless'], + 'Zaun': ['experimental', 'high-risk', 'damage-over-time', 'chaotic'] + } + + def engineer_behavioral_features(self, df: pd.DataFrame) -> pd.DataFrame: + """ + Creates region-themed features from the PRE-AGGREGATED match statistics + """ + + features = df.copy() + + # Bandle City + features['bandle'] = ( + features['avg_outnumbered_kills'] * 0.4 + + features['avg_kda'] * 0.3 + + features['avg_vision_score'] / 40.0 * 0.3 + ) + + # Bilgewater + features['bilgewater'] = ( + features['avg_gpm'] / 400 * 0.4 + + features['avg_solo_kills'] * 0.3 + + features['avg_kills_near_tower'] * 0.3 + ) + + # Demacia + features['demacia'] = ( + features['avg_kill_participation'] * 0.4 + + features['avg_team_damage_pct'] * 0.3 + + features['avg_shields_on_teammates'] / 500 * 0.3 + ) + + # Ionia + features['ionia'] = ( + features['avg_kda'] / 4 * 0.3 + + (features['avg_kill_participation'] * features['avg_cs_per_min'] / 7) * 0.4 + + features['avg_vision_score'] / 40 * 0.3 + ) + + # Ixtal + features['ixtal'] = ( + features['avg_objective_damage'] / 10000 * 0.4 + + features['avg_dragon_takedowns'] * 0.3 + + features['avg_herald_takedowns'] * 0.3 + ) + + # Noxus + features['noxus'] = ( + features['avg_dpm'] / 600 * 0.4 + + features['avg_early_gold_adv'] / 500 * 0.3 + + features['avg_turret_kills'] * 0.3 + ) + + # Piltover + features['piltover'] = ( + features['avg_gpm'] / 400 * 0.4 + + features['avg_cs_per_min'] / 7 * 0.3 + + features['cs_consistency'] * 0.3 + ) + + # Shadow Isles + features['shadow_isles'] = ( + features['avg_heals_on_teammates'] / 1000 * 0.4 + + features['avg_longest_alive'] / 600 * 0.3 + + features['avg_kda'] * 0.3 + ) + + # Shurima + features['shurima'] = ( + features['avg_cs_per_min'] / 7 * 0.5 + + features['avg_gpm'] * 0.5 + ) + + # Targon + features['targon'] = ( + features['avg_vision_score'] / 40 * 0.4 + + features['avg_shields_on_teammates'] / 500 * 0.3 + + features['avg_heals_on_teammates'] / 1000 * 0.3 + ) + + # Freljord + features['freljord'] = ( + features['avg_cc_time'] / 20 * 0.4 + + features['avg_time_dead'] / 60 * -0.3 + + (1 / (features['death_consistency'] + 0.1)) * 0.3 + ) + + # The Void + features['void'] = ( + features['avg_dpm'] / 600 * 0.4 + + features['avg_team_damage_pct'] * 0.4 + + features['avg_solo_kills'] * 0.2 + ) + + # Zaun + features['zaun'] = ( + (1 / (features['death_consistency'] + 0.1)) * -0.3 + + features['avg_outnumbered_kills'] * 0.4 + + features['avg_pick_kills'] * 0.3 + ) + + return features + + def train_clustering_model(self, df: pd.DataFrame, n_clusters: int = 13): + """ + Trains K-means clustering for region-based archetype identification + """ + + # Regional feature set for clustering + clustering_features = [ + # Regional identity features + 'bandle', + 'bilgewater', + 'demacia', + 'ionia', + 'ixtal', + 'noxus', + 'piltover', + 'shadow_isles', + 'shurima', + 'targon', + 'freljord', + 'void', + 'zaun', + # Supporting metrics + 'avg_dpm', + 'avg_gpm', + 'avg_kill_participation', + 'avg_kda', + 'avg_vision_score', + 'avg_cs_per_min', + 'avg_team_damage_pct' + ] + + valid_features = [col for col in clustering_features if col in df.columns] + print(f"Using {len(valid_features)} features for clustering.") + print(f"Regional features: {[f for f in valid_features if not f.startswith('avg_')]}") + + X = df[valid_features].fillna(0) + + # Standardize features + X_scaled = self.scaler.fit_transform(X) + + # Apply PCA - preserve more variance for 13 clusters + self.pca = PCA(n_components=min(13, len(valid_features))) + X_pca = self.pca.fit_transform(X_scaled) + + # Train K-means with 13 clusters (one per region) + self.kmeans = KMeans( + n_clusters=n_clusters, + init='k-means++', + n_init=20, # More initializations for better clustering + max_iter=500, + random_state=42 + ) + + clusters = self.kmeans.fit_predict(X_pca) + df['cluster'] = clusters + + try: + score = silhouette_score(X_pca, clusters) + except ValueError: + score = 0 + + self.archetype_names = self._assign_region_names(df, valid_features) + + self._calculate_feature_importance(df, valid_features) + + return df, score, X_pca, valid_features + + def _assign_region_names(self, df: pd.DataFrame, features: list) -> Dict: + """ + Assigns region names to clusters based on regional feature dominance + """ + archetype_names = {} + + # Regional features in order + regional_features = [ + 'bandle', 'bilgewater', 'demacia', 'ionia', + 'ixtal', 'noxus', 'piltover', 'shadow_isles', + 'shurima', 'targon', 'freljord', + 'void', 'zaun' + ] + + # Region names corresponding to features + region_names = [ + 'Bandle City', 'Bilgewater', 'Demacia', 'Ionia', 'Ixtal', + 'Noxus', 'Piltover', 'Shadow Isles', 'Shurima', 'Targon', + 'The Freljord', 'The Void', 'Zaun' + ] + + # Calculate which region each cluster represents + global_means = df[[f for f in regional_features if f in features]].mean() + + assigned_regions = set() + cluster_region_scores = {} + + for cluster_id in range(df['cluster'].nunique()): + cluster_data = df[df['cluster'] == cluster_id] + cluster_means = cluster_data[[f for f in regional_features if f in features]].mean() + + # Calculate relative strength for each region + relative_scores = (cluster_means - global_means) / (global_means + 1e-6) + + # Store scores for this cluster + cluster_region_scores[cluster_id] = relative_scores + + # Assign regions based on best fit (greedy assignment) + for _ in range(df['cluster'].nunique()): + best_match = None + best_score = -float('inf') + best_cluster = None + + for cluster_id in range(df['cluster'].nunique()): + if cluster_id in [k for k, v in archetype_names.items() if 'region_assigned' in v]: + continue + + scores = cluster_region_scores[cluster_id] + + for region_feat, region_name in zip(regional_features, region_names): + if region_name in assigned_regions or region_feat not in scores.index: + continue + + if scores[region_feat] > best_score: + best_score = scores[region_feat] + best_match = region_name + best_cluster = cluster_id + + if best_match: + cluster_data = df[df['cluster'] == best_cluster] + assigned_regions.add(best_match) + + profile_themes = self.region_themes.get(best_match, []) + profile_text = ", ".join(profile_themes).title() + + archetype_names[best_cluster] = { + 'name': best_match, + 'region_assigned': True, + 'count': len(cluster_data), + 'win_rate': cluster_data['win_rate'].mean(), + 'avg_kda': cluster_data['avg_kda'].mean(), + 'avg_gpm': cluster_data['avg_gpm'].mean(), + 'dominant_score': float(best_score), + 'profile': profile_text + } + + return archetype_names + + def _calculate_feature_importance(self, df: pd.DataFrame, features: list): + X = df[features].fillna(0) + y = df['cluster'] + + if len(X) < 50: + print("Not enough samples for feature importance calculation.") + self.feature_importance = {} + return + + rf = RandomForestClassifier(n_estimators=100, random_state=42, max_depth=15) + rf.fit(X, y) + + self.feature_importance = dict(zip(features, rf.feature_importances_)) + + def plot_clustering_results(self, df: pd.DataFrame, X_pca: np.ndarray, + valid_features: list, output_path: str): + """ + Creates comprehensive visualization of clustering results + """ + # Import matplotlib here to avoid early loading issues + import matplotlib + matplotlib.use('Agg') + import matplotlib.pyplot as plt + import matplotlib.cm as cm + + print("Generating visualizations...") + + # Set style + plt.style.use('default') + plt.rcParams['figure.facecolor'] = 'white' + plt.rcParams['axes.grid'] = True + plt.rcParams['grid.alpha'] = 0.3 + + # Create output directory for plots + plots_dir = os.path.join(output_path, "plots") + os.makedirs(plots_dir, exist_ok=True) + + # 1. PCA Scatter Plot with Clusters + fig, ax = plt.subplots(figsize=(14, 10)) + scatter = ax.scatter(X_pca[:, 0], X_pca[:, 1], + c=df['cluster'], + cmap='tab20', + alpha=0.6, + s=50) + + # Add cluster centers (already in PCA space) + centers_pca = self.kmeans.cluster_centers_ + ax.scatter(centers_pca[:, 0], centers_pca[:, 1], + c='red', marker='X', s=400, + edgecolors='black', linewidths=2, + label='Region Centers') + + ax.set_xlabel(f'PC1 ({self.pca.explained_variance_ratio_[0]:.1%} variance)', fontsize=12) + ax.set_ylabel(f'PC2 ({self.pca.explained_variance_ratio_[1]:.1%} variance)', fontsize=12) + ax.set_title('Player Playstyle Regions of Runeterra', fontsize=16, fontweight='bold') + + # Add legend with region names + handles, labels = scatter.legend_elements() + legend_labels = [self.archetype_names.get(int(label.split('{')[1].split('}')[0]), {}).get('name', f'Cluster {label}') + for label in labels] + ax.legend(handles, legend_labels, title="Regions", + bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=9) + + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, 'pca_clusters.png'), dpi=300, bbox_inches='tight') + plt.close() + + # 2. Region Size Distribution + fig, ax = plt.subplots(figsize=(14, 7)) + cluster_counts = df['cluster'].value_counts().sort_index() + region_names = [self.archetype_names.get(i, {}).get('name', f'Cluster {i}') + for i in cluster_counts.index] + + bars = ax.bar(range(len(cluster_counts)), cluster_counts.values, + color=plt.cm.tab20(range(len(cluster_counts)))) + ax.set_xticks(range(len(cluster_counts))) + ax.set_xticklabels(region_names, rotation=45, ha='right') + ax.set_ylabel('Number of Players', fontsize=12) + ax.set_title('Distribution of Players Across Runeterra Regions', fontsize=14, fontweight='bold') + + # Add value labels on bars + for bar in bars: + height = bar.get_height() + ax.text(bar.get_x() + bar.get_width()/2., height, + f'{int(height)}', + ha='center', va='bottom', fontsize=9) + + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, 'region_distribution.png'), dpi=300, bbox_inches='tight') + plt.close() + + # 3. Feature Importance Plot + if self.feature_importance: + fig, ax = plt.subplots(figsize=(12, 10)) + importances = pd.Series(self.feature_importance).sort_values(ascending=True) + + colors = plt.cm.viridis(np.linspace(0, 1, len(importances))) + importances.plot(kind='barh', ax=ax, color=colors) + ax.set_xlabel('Importance Score', fontsize=12) + ax.set_title('Feature Importance for Region Classification', + fontsize=14, fontweight='bold') + ax.set_yticklabels([label.get_text().replace('_', ' ').title() + for label in ax.get_yticklabels()]) + + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, 'feature_importance.png'), dpi=300, bbox_inches='tight') + plt.close() + + # 4. Heatmap of Region Characteristics + fig, ax = plt.subplots(figsize=(16, 10)) + + # Calculate mean features for each cluster + cluster_profiles = [] + for cluster_id in sorted(df['cluster'].unique()): + cluster_data = df[df['cluster'] == cluster_id] + profile = cluster_data[valid_features].mean() + cluster_profiles.append(profile) + + cluster_profiles_df = pd.DataFrame(cluster_profiles) + cluster_profiles_df.index = [self.archetype_names.get(i, {}).get('name', f'Cluster {i}') + for i in sorted(df['cluster'].unique())] + + # Normalize for better visualization + cluster_profiles_normalized = (cluster_profiles_df - cluster_profiles_df.mean()) / cluster_profiles_df.std() + + # Create heatmap + im = ax.imshow(cluster_profiles_normalized.T, cmap='RdYlGn', aspect='auto', + vmin=-2, vmax=2, interpolation='nearest') + ax.set_xticks(range(len(cluster_profiles_normalized))) + ax.set_xticklabels(cluster_profiles_normalized.index, rotation=45, ha='right', fontsize=9) + ax.set_yticks(range(len(cluster_profiles_normalized.columns))) + ax.set_yticklabels(cluster_profiles_normalized.columns, fontsize=8) + plt.colorbar(im, ax=ax, label='Normalized Score') + + ax.set_xlabel('Region', fontsize=12) + ax.set_ylabel('Feature', fontsize=12) + ax.set_title('Regional Playstyle Profiles', fontsize=14, fontweight='bold') + ax.set_yticklabels([label.get_text().replace('_', ' ').title() + for label in ax.get_yticklabels()], rotation=0) + + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, 'region_heatmap.png'), dpi=300, bbox_inches='tight') + plt.close() + + # 5. Win Rate by Region + fig, ax = plt.subplots(figsize=(14, 7)) + win_rates = [self.archetype_names.get(i, {}).get('win_rate', 0.5) * 100 + for i in sorted(df['cluster'].unique())] + region_names = [self.archetype_names.get(i, {}).get('name', f'Cluster {i}') + for i in sorted(df['cluster'].unique())] + + bars = ax.bar(range(len(win_rates)), win_rates, + color=plt.cm.RdYlGn(np.array(win_rates) / 100)) + ax.axhline(y=50, color='black', linestyle='--', linewidth=1, alpha=0.5, label='50% Win Rate') + ax.set_xticks(range(len(region_names))) + ax.set_xticklabels(region_names, rotation=45, ha='right') + ax.set_ylabel('Win Rate (%)', fontsize=12) + ax.set_title('Average Win Rate by Region', fontsize=14, fontweight='bold') + ax.set_ylim([min(win_rates) - 5, max(win_rates) + 5]) + ax.legend() + + # Add value labels on bars + for bar, wr in zip(bars, win_rates): + height = bar.get_height() + ax.text(bar.get_x() + bar.get_width()/2., height, + f'{wr:.1f}%', + ha='center', va='bottom', fontsize=9) + + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, 'winrate_by_region.png'), dpi=300, bbox_inches='tight') + plt.close() + + # 6. PCA Explained Variance + fig, ax = plt.subplots(figsize=(12, 7)) + variance_ratio = self.pca.explained_variance_ratio_ + cumulative_variance = np.cumsum(variance_ratio) + + ax.bar(range(1, len(variance_ratio) + 1), variance_ratio, + alpha=0.6, label='Individual Variance') + ax.plot(range(1, len(cumulative_variance) + 1), cumulative_variance, + 'ro-', linewidth=2, label='Cumulative Variance') + + ax.set_xlabel('Principal Component', fontsize=12) + ax.set_ylabel('Explained Variance Ratio', fontsize=12) + ax.set_title('PCA Explained Variance', fontsize=14, fontweight='bold') + ax.legend() + ax.grid(True, alpha=0.3) + + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, 'pca_variance.png'), dpi=300, bbox_inches='tight') + plt.close() + + # 7. Regional Feature Radar Charts (Top 3 Most Populous Regions) + top_3_clusters = df['cluster'].value_counts().head(3).index.tolist() + + fig, axes = plt.subplots(1, 3, figsize=(20, 7), subplot_kw=dict(projection='polar')) + + # Use regional identity features + regional_features = ['bandle', 'bilgewater', 'demacia', + 'ionia', 'ixtal', 'noxus'] + regional_features = [f for f in regional_features if f in valid_features][:6] + + angles = np.linspace(0, 2 * np.pi, len(regional_features), endpoint=False).tolist() + angles += angles[:1] + + for idx, cluster_id in enumerate(top_3_clusters): + ax = axes[idx] + cluster_data = df[df['cluster'] == cluster_id] + values = cluster_data[regional_features].mean().tolist() + values += values[:1] + + region_name = self.archetype_names.get(cluster_id, {}).get('name', f'Cluster {cluster_id}') + + ax.plot(angles, values, 'o-', linewidth=2, label=region_name) + ax.fill(angles, values, alpha=0.25) + ax.set_xticks(angles[:-1]) + ax.set_xticklabels([f.replace('_', ' ').replace('bandle', 'Bandle').replace('bilgewater', 'Bilgewater') + .replace('demacia', 'Demacia').replace('ionia', 'Ionia') + .replace('ixtal', 'Ixtal').replace('noxus', 'Noxus').title() + for f in regional_features], size=8) + ax.set_title(region_name, fontsize=13, fontweight='bold', pad=20) + ax.grid(True) + + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, 'region_radar_charts.png'), dpi=300, bbox_inches='tight') + plt.close() + + print(f"All visualizations saved to {plots_dir}/") + + def save_model(self, output_path: str): + os.makedirs(output_path, exist_ok=True) + + model_artifacts = { + 'scaler': self.scaler, + 'kmeans': self.kmeans, + 'pca': self.pca, + 'archetype_names': self.archetype_names, + 'feature_importance': self.feature_importance + } + + joblib.dump(model_artifacts, os.path.join(output_path, "playstyle_profiler.pkl")) + + with open(os.path.join(output_path, "archetypes.json"), 'w') as f: + json.dump(self.archetype_names, f, indent=2, default=lambda x: x.item() if isinstance(x, np.generic) else x) + +# SageMaker Training Script +def train_on_sagemaker(): + print("Starting SageMaker training script...") + print("Training Runeterra Regional Playstyle Classifier") + + parser = argparse.ArgumentParser() + parser.add_argument('--n-clusters', type=int, default=13) + parser.add_argument('--train', type=str, default=os.environ.get('SM_CHANNEL_TRAIN')) + parser.add_argument('--model-dir', type=str, default=os.environ.get('SM_MODEL_DIR')) + + args, _ = parser.parse_known_args() + + print(f"Training data path: {args.train}") + print(f"Model output path: {args.model_dir}") + print(f"Number of regions: {args.n_clusters}") + + training_file_path = os.path.join(args.train, "player_features_train.parquet") + + if not os.path.exists(training_file_path): + print(f"Error: File not found at {training_file_path}") + print("Listing files in training directory:") + print(os.listdir(args.train)) + raise FileNotFoundError(f"File not found: {training_file_path}") + + print("Loading data...") + df = pd.read_parquet(training_file_path) + print(f"Loaded {len(df)} rows.") + + profiler = PlaystyleProfiler() + + print("Engineering regional features...") + df_with_features = profiler.engineer_behavioral_features(df) + + print(f"Training clustering model with {args.n_clusters} regions...") + df_clustered, silhouette_avg, X_pca, valid_features = profiler.train_clustering_model( + df_with_features, n_clusters=args.n_clusters + ) + print(f"Clustering complete. Silhouette Score: {silhouette_avg}") + + # Print region assignments + print("\n" + "="*60) + print("REGION ASSIGNMENTS:") + print("="*60) + for cluster_id in sorted(profiler.archetype_names.keys()): + info = profiler.archetype_names[cluster_id] + print(f"{info['name']:20s} | Players: {info['count']:5d} | Win Rate: {info['win_rate']*100:5.2f}%") + print("="*60 + "\n") + + print(f"Saving model to {args.model_dir}...") + profiler.save_model(args.model_dir) + + validation_metrics = { + 'silhouette_score': silhouette_avg, + 'n_clusters': args.n_clusters, + 'n_samples': len(df), + 'regions': {k: v['name'] for k, v in profiler.archetype_names.items()} + } + + metrics_path = os.path.join(args.model_dir, "validation_metrics.json") + with open(metrics_path, 'w') as f: + json.dump(validation_metrics, f, indent=2) + + print("Training completed successfully") + print(f"Model artifacts saved to {args.model_dir}") + +if __name__ == "__main__": + train_on_sagemaker() \ No newline at end of file diff --git a/aws/sagemaker/jobs/prepare_training_data.ipynb b/aws/sagemaker/jobs/prepare_training_data.ipynb new file mode 100644 index 0000000..cea9970 --- /dev/null +++ b/aws/sagemaker/jobs/prepare_training_data.ipynb @@ -0,0 +1,436 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "2ffdc807-486f-4c7c-9f34-5fc5e120d100", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "98ee387c-b547-4563-a2b4-42c087ade8d9", + "metadata": { + "execution": { + "iopub.execute_input": "2025-11-01T13:14:53.579762Z", + "iopub.status.busy": "2025-11-01T13:14:53.579312Z", + "iopub.status.idle": "2025-11-01T13:14:56.641704Z", + "shell.execute_reply": "2025-11-01T13:14:56.640819Z", + "shell.execute_reply.started": "2025-11-01T13:14:53.579719Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sagemaker.config INFO - Fetched defaults config from location: /etc/xdg/sagemaker/config.yaml\n", + "sagemaker.config INFO - Not applying SDK defaults from location: /home/sagemaker-user/.config/sagemaker/config.yaml\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3Bucket\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3ObjectKeyPrefix\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3Bucket\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3ObjectKeyPrefix\n", + "arn:aws:iam::768394660366:role/datazone_usr_role_5i1vmxossv3f2o_b1rxf3f1mnfnv4\n" + ] + } + ], + "source": [ + "import sagemaker\n", + "\n", + "role = sagemaker.get_execution_role()\n", + "print(role)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f67366d3-344a-409b-a18f-dcf9f426b40f", + "metadata": { + "execution": { + "iopub.execute_input": "2025-11-02T04:59:19.511627Z", + "iopub.status.busy": "2025-11-02T04:59:19.511160Z", + "iopub.status.idle": "2025-11-02T05:32:59.010598Z", + "shell.execute_reply": "2025-11-02T05:32:59.009583Z", + "shell.execute_reply.started": "2025-11-02T04:59:19.511581Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Starting training data preparation...\n", + "Database: lol_coach_db\n", + "Output bucket: lol-coach-processed-data\n", + "\n", + "============================================================\n", + "PREPARING PLAYSTYLE PROFILER TRAINING DATA\n", + "============================================================\n", + "Running query: \n", + " SELECT \n", + " pa.game_name,\n", + " pa.tagline,\n", + " pa.total_games,\n", + " ...\n", + "Waiting for query 4b7d44a8-5da6-4c4f-a3f2-ae26df4f8ced...\n", + "Query succeeded in 1045.4s\n", + "Retrieved 23545 rows\n", + "\n", + "Dataset summary:\n", + " Players: 23,545\n", + " Features: 32\n", + " Avg games per player: 19.3\n", + " Win rate range: 0.0% - 100.0%\n", + "\n", + "Split summary:\n", + " Training set: 18,836 samples\n", + " Validation set: 4,709 samples\n", + "\n", + "Uploading to s3://lol-coach-processed-data/training/player_features_train.parquet...\n", + "Saved to s3://lol-coach-processed-data/training/player_features_train.parquet\n", + "\n", + "Uploading to s3://lol-coach-processed-data/training/player_features_val.parquet...\n", + "Saved to s3://lol-coach-processed-data/training/player_features_val.parquet\n", + "\n", + "============================================================\n", + "PREPARING HYPOTHETICAL SIMULATOR TRAINING DATA\n", + "============================================================\n", + "Running query: \n", + " WITH team_stats AS (\n", + " SELECT \n", + " match_id,\n", + " team_id,...\n", + "Waiting for query a3787ff2-91b6-4e33-b263-d88e1ee976c5...\n", + "Query succeeded in 970.2s\n", + "Retrieved 145107 rows\n", + "\n", + "Dataset summary:\n", + " Match states: 145,107\n", + " Blue team win rate: 51.2%\n", + "\n", + "Split summary:\n", + " Training set: 116,085 samples\n", + " Validation set: 29,022 samples\n", + "\n", + "Uploading to s3://lol-coach-processed-data/training/teamfight_data_train.parquet...\n", + "Saved to s3://lol-coach-processed-data/training/teamfight_data_train.parquet\n", + "\n", + "Uploading to s3://lol-coach-processed-data/training/teamfight_data_val.parquet...\n", + "Saved to s3://lol-coach-processed-data/training/teamfight_data_val.parquet\n", + "\n", + "Uploading to s3://lol-coach-processed-data/training/training_metadata.json...\n", + "Saved to s3://lol-coach-processed-data/training/training_metadata.json\n", + "\n", + "============================================================\n", + "TRAINING DATA PREPARATION COMPLETE\n", + "============================================================\n", + "\n", + "playstyle_profiler:\n", + " Train: s3://lol-coach-processed-data/training/player_features_train.parquet\n", + " Val: s3://lol-coach-processed-data/training/player_features_val.parquet\n", + " Samples: 18,836 train, 4,709 val\n", + "\n", + "hypothetical_simulator:\n", + " Train: s3://lol-coach-processed-data/training/teamfight_data_train.parquet\n", + " Val: s3://lol-coach-processed-data/training/teamfight_data_val.parquet\n", + " Samples: 116,085 train, 29,022 val\n", + "\n", + "Done! Training data is ready for SageMaker.\n" + ] + } + ], + "source": [ + "!python3 prepare_training_data.py --database lol_coach_db --output-bucket lol-coach-processed-data --model all --region us-west-2" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0060cb07-3d13-4d54-9155-e50f05340179", + "metadata": { + "execution": { + "iopub.execute_input": "2025-11-05T03:06:35.867654Z", + "iopub.status.busy": "2025-11-05T03:06:35.867038Z", + "iopub.status.idle": "2025-11-05T03:10:03.369259Z", + "shell.execute_reply": "2025-11-05T03:10:03.368398Z", + "shell.execute_reply.started": "2025-11-05T03:06:35.867620Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sagemaker.config INFO - Fetched defaults config from location: /etc/xdg/sagemaker/config.yaml\n", + "sagemaker.config INFO - Not applying SDK defaults from location: /home/sagemaker-user/.config/sagemaker/config.yaml\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3Bucket\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3ObjectKeyPrefix\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3Bucket\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.PythonSDK.Modules.Session.DefaultS3ObjectKeyPrefix\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.TrainingJob.VpcConfig.Subnets\n", + "sagemaker.config INFO - Applied value from config key = SageMaker.TrainingJob.VpcConfig.SecurityGroupIds\n", + "INFO:sagemaker:Creating training-job with name: sagemaker-scikit-learn-2025-11-05-03-06-41-484\n", + "2025-11-05 03:06:44 Starting - Starting the training job...\n", + "2025-11-05 03:07:01 Starting - Preparing the instances for training...\n", + "2025-11-05 03:07:27 Downloading - Downloading input data...\n", + "2025-11-05 03:07:57 Downloading - Downloading the training image......\n", + "2025-11-05 03:08:57 Training - Training image download completed. Training in progress.\u001b[34m/miniconda3/lib/python3.9/site-packages/sagemaker_containers/_server.py:22: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " import pkg_resources\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,338 sagemaker-containers INFO Imported framework sagemaker_sklearn_container.training\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,343 sagemaker-training-toolkit INFO No GPUs detected (normal if no gpus installed)\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,346 sagemaker-training-toolkit INFO No Neurons detected (normal if no neurons installed)\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,362 sagemaker_sklearn_container.training INFO Invoking user training script.\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,692 sagemaker-training-toolkit INFO No GPUs detected (normal if no gpus installed)\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,696 sagemaker-training-toolkit INFO No Neurons detected (normal if no neurons installed)\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,714 sagemaker-training-toolkit INFO No GPUs detected (normal if no gpus installed)\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,716 sagemaker-training-toolkit INFO No Neurons detected (normal if no neurons installed)\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,733 sagemaker-training-toolkit INFO No GPUs detected (normal if no gpus installed)\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,736 sagemaker-training-toolkit INFO No Neurons detected (normal if no neurons installed)\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,751 sagemaker-training-toolkit INFO Invoking user script\u001b[0m\n", + "\u001b[34mTraining Env:\u001b[0m\n", + "\u001b[34m{\n", + " \"additional_framework_parameters\": {},\n", + " \"channel_input_dirs\": {\n", + " \"train\": \"/opt/ml/input/data/train\"\n", + " },\n", + " \"current_host\": \"algo-1\",\n", + " \"current_instance_group\": \"homogeneousCluster\",\n", + " \"current_instance_group_hosts\": [\n", + " \"algo-1\"\n", + " ],\n", + " \"current_instance_type\": \"ml.m5.large\",\n", + " \"distribution_hosts\": [],\n", + " \"distribution_instance_groups\": [],\n", + " \"framework_module\": \"sagemaker_sklearn_container.training:main\",\n", + " \"hosts\": [\n", + " \"algo-1\"\n", + " ],\n", + " \"hyperparameters\": {\n", + " \"n-clusters\": 13\n", + " },\n", + " \"input_config_dir\": \"/opt/ml/input/config\",\n", + " \"input_data_config\": {\n", + " \"train\": {\n", + " \"TrainingInputMode\": \"File\",\n", + " \"S3DistributionType\": \"FullyReplicated\",\n", + " \"RecordWrapperType\": \"None\"\n", + " }\n", + " },\n", + " \"input_dir\": \"/opt/ml/input\",\n", + " \"instance_groups\": [\n", + " \"homogeneousCluster\"\n", + " ],\n", + " \"instance_groups_dict\": {\n", + " \"homogeneousCluster\": {\n", + " \"instance_group_name\": \"homogeneousCluster\",\n", + " \"instance_type\": \"ml.m5.large\",\n", + " \"hosts\": [\n", + " \"algo-1\"\n", + " ]\n", + " }\n", + " },\n", + " \"is_hetero\": false,\n", + " \"is_master\": true,\n", + " \"is_modelparallel_enabled\": null,\n", + " \"is_smddpmprun_installed\": false,\n", + " \"is_smddprun_installed\": false,\n", + " \"job_name\": \"sagemaker-scikit-learn-2025-11-05-03-06-41-484\",\n", + " \"log_level\": 20,\n", + " \"master_hostname\": \"algo-1\",\n", + " \"model_dir\": \"/opt/ml/model\",\n", + " \"module_dir\": \"s3://lol-coach-processed-data/sagemaker-scikit-learn-2025-11-05-03-06-41-484/source/sourcedir.tar.gz\",\n", + " \"module_name\": \"playstyle_profiler_training\",\n", + " \"network_interface_name\": \"eth0\",\n", + " \"num_cpus\": 2,\n", + " \"num_gpus\": 0,\n", + " \"num_neurons\": 0,\n", + " \"output_data_dir\": \"/opt/ml/output/data\",\n", + " \"output_dir\": \"/opt/ml/output\",\n", + " \"output_intermediate_dir\": \"/opt/ml/output/intermediate\",\n", + " \"resource_config\": {\n", + " \"current_host\": \"algo-1\",\n", + " \"current_instance_type\": \"ml.m5.large\",\n", + " \"current_group_name\": \"homogeneousCluster\",\n", + " \"hosts\": [\n", + " \"algo-1\"\n", + " ],\n", + " \"instance_groups\": [\n", + " {\n", + " \"instance_group_name\": \"homogeneousCluster\",\n", + " \"instance_type\": \"ml.m5.large\",\n", + " \"hosts\": [\n", + " \"algo-1\"\n", + " ]\n", + " }\n", + " ],\n", + " \"network_interface_name\": \"eth0\",\n", + " \"topology\": null\n", + " },\n", + " \"user_entry_point\": \"playstyle_profiler_training.py\"\u001b[0m\n", + "\u001b[34m}\u001b[0m\n", + "\u001b[34mEnvironment variables:\u001b[0m\n", + "\u001b[34mSM_HOSTS=[\"algo-1\"]\u001b[0m\n", + "\u001b[34mSM_NETWORK_INTERFACE_NAME=eth0\u001b[0m\n", + "\u001b[34mSM_HPS={\"n-clusters\":13}\u001b[0m\n", + "\u001b[34mSM_USER_ENTRY_POINT=playstyle_profiler_training.py\u001b[0m\n", + "\u001b[34mSM_FRAMEWORK_PARAMS={}\u001b[0m\n", + "\u001b[34mSM_RESOURCE_CONFIG={\"current_group_name\":\"homogeneousCluster\",\"current_host\":\"algo-1\",\"current_instance_type\":\"ml.m5.large\",\"hosts\":[\"algo-1\"],\"instance_groups\":[{\"hosts\":[\"algo-1\"],\"instance_group_name\":\"homogeneousCluster\",\"instance_type\":\"ml.m5.large\"}],\"network_interface_name\":\"eth0\",\"topology\":null}\u001b[0m\n", + "\u001b[34mSM_INPUT_DATA_CONFIG={\"train\":{\"RecordWrapperType\":\"None\",\"S3DistributionType\":\"FullyReplicated\",\"TrainingInputMode\":\"File\"}}\u001b[0m\n", + "\u001b[34mSM_OUTPUT_DATA_DIR=/opt/ml/output/data\u001b[0m\n", + "\u001b[34mSM_CHANNELS=[\"train\"]\u001b[0m\n", + "\u001b[34mSM_CURRENT_HOST=algo-1\u001b[0m\n", + "\u001b[34mSM_CURRENT_INSTANCE_TYPE=ml.m5.large\u001b[0m\n", + "\u001b[34mSM_CURRENT_INSTANCE_GROUP=homogeneousCluster\u001b[0m\n", + "\u001b[34mSM_CURRENT_INSTANCE_GROUP_HOSTS=[\"algo-1\"]\u001b[0m\n", + "\u001b[34mSM_INSTANCE_GROUPS=[\"homogeneousCluster\"]\u001b[0m\n", + "\u001b[34mSM_INSTANCE_GROUPS_DICT={\"homogeneousCluster\":{\"hosts\":[\"algo-1\"],\"instance_group_name\":\"homogeneousCluster\",\"instance_type\":\"ml.m5.large\"}}\u001b[0m\n", + "\u001b[34mSM_DISTRIBUTION_INSTANCE_GROUPS=[]\u001b[0m\n", + "\u001b[34mSM_IS_HETERO=false\u001b[0m\n", + "\u001b[34mSM_MODULE_NAME=playstyle_profiler_training\u001b[0m\n", + "\u001b[34mSM_LOG_LEVEL=20\u001b[0m\n", + "\u001b[34mSM_FRAMEWORK_MODULE=sagemaker_sklearn_container.training:main\u001b[0m\n", + "\u001b[34mSM_INPUT_DIR=/opt/ml/input\u001b[0m\n", + "\u001b[34mSM_INPUT_CONFIG_DIR=/opt/ml/input/config\u001b[0m\n", + "\u001b[34mSM_OUTPUT_DIR=/opt/ml/output\u001b[0m\n", + "\u001b[34mSM_NUM_CPUS=2\u001b[0m\n", + "\u001b[34mSM_NUM_GPUS=0\u001b[0m\n", + "\u001b[34mSM_NUM_NEURONS=0\u001b[0m\n", + "\u001b[34mSM_MODEL_DIR=/opt/ml/model\u001b[0m\n", + "\u001b[34mSM_MODULE_DIR=s3://lol-coach-processed-data/sagemaker-scikit-learn-2025-11-05-03-06-41-484/source/sourcedir.tar.gz\u001b[0m\n", + "\u001b[34mSM_TRAINING_ENV={\"additional_framework_parameters\":{},\"channel_input_dirs\":{\"train\":\"/opt/ml/input/data/train\"},\"current_host\":\"algo-1\",\"current_instance_group\":\"homogeneousCluster\",\"current_instance_group_hosts\":[\"algo-1\"],\"current_instance_type\":\"ml.m5.large\",\"distribution_hosts\":[],\"distribution_instance_groups\":[],\"framework_module\":\"sagemaker_sklearn_container.training:main\",\"hosts\":[\"algo-1\"],\"hyperparameters\":{\"n-clusters\":13},\"input_config_dir\":\"/opt/ml/input/config\",\"input_data_config\":{\"train\":{\"RecordWrapperType\":\"None\",\"S3DistributionType\":\"FullyReplicated\",\"TrainingInputMode\":\"File\"}},\"input_dir\":\"/opt/ml/input\",\"instance_groups\":[\"homogeneousCluster\"],\"instance_groups_dict\":{\"homogeneousCluster\":{\"hosts\":[\"algo-1\"],\"instance_group_name\":\"homogeneousCluster\",\"instance_type\":\"ml.m5.large\"}},\"is_hetero\":false,\"is_master\":true,\"is_modelparallel_enabled\":null,\"is_smddpmprun_installed\":false,\"is_smddprun_installed\":false,\"job_name\":\"sagemaker-scikit-learn-2025-11-05-03-06-41-484\",\"log_level\":20,\"master_hostname\":\"algo-1\",\"model_dir\":\"/opt/ml/model\",\"module_dir\":\"s3://lol-coach-processed-data/sagemaker-scikit-learn-2025-11-05-03-06-41-484/source/sourcedir.tar.gz\",\"module_name\":\"playstyle_profiler_training\",\"network_interface_name\":\"eth0\",\"num_cpus\":2,\"num_gpus\":0,\"num_neurons\":0,\"output_data_dir\":\"/opt/ml/output/data\",\"output_dir\":\"/opt/ml/output\",\"output_intermediate_dir\":\"/opt/ml/output/intermediate\",\"resource_config\":{\"current_group_name\":\"homogeneousCluster\",\"current_host\":\"algo-1\",\"current_instance_type\":\"ml.m5.large\",\"hosts\":[\"algo-1\"],\"instance_groups\":[{\"hosts\":[\"algo-1\"],\"instance_group_name\":\"homogeneousCluster\",\"instance_type\":\"ml.m5.large\"}],\"network_interface_name\":\"eth0\",\"topology\":null},\"user_entry_point\":\"playstyle_profiler_training.py\"}\u001b[0m\n", + "\u001b[34mSM_USER_ARGS=[\"--n-clusters\",\"13\"]\u001b[0m\n", + "\u001b[34mSM_OUTPUT_INTERMEDIATE_DIR=/opt/ml/output/intermediate\u001b[0m\n", + "\u001b[34mSM_CHANNEL_TRAIN=/opt/ml/input/data/train\u001b[0m\n", + "\u001b[34mSM_HP_N-CLUSTERS=13\u001b[0m\n", + "\u001b[34mPYTHONPATH=/opt/ml/code:/miniconda3/bin:/miniconda3/lib/python39.zip:/miniconda3/lib/python3.9:/miniconda3/lib/python3.9/lib-dynload:/miniconda3/lib/python3.9/site-packages:/miniconda3/lib/python3.9/site-packages/setuptools/_vendor\u001b[0m\n", + "\u001b[34mInvoking script with the following command:\u001b[0m\n", + "\u001b[34m/miniconda3/bin/python playstyle_profiler_training.py --n-clusters 13\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,753 sagemaker-training-toolkit INFO Exceptions not imported for SageMaker Debugger as it is not installed.\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:00,754 sagemaker-training-toolkit INFO Exceptions not imported for SageMaker TF as Tensorflow is not installed.\u001b[0m\n", + "\u001b[34mStarting SageMaker training script...\u001b[0m\n", + "\u001b[34mTraining Runeterra Regional Playstyle Classifier\u001b[0m\n", + "\u001b[34mTraining data path: /opt/ml/input/data/train\u001b[0m\n", + "\u001b[34mModel output path: /opt/ml/model\u001b[0m\n", + "\u001b[34mNumber of regions: 13\u001b[0m\n", + "\u001b[34mLoading data...\u001b[0m\n", + "\u001b[34mLoaded 18836 rows.\u001b[0m\n", + "\u001b[34mEngineering regional features...\u001b[0m\n", + "\u001b[34mTraining clustering model with 13 regions...\u001b[0m\n", + "\u001b[34mUsing 20 features for clustering.\u001b[0m\n", + "\u001b[34mRegional features: ['bandle', 'bilgewater', 'demacia', 'ionia', 'ixtal', 'noxus', 'piltover', 'shadow_isles', 'shurima', 'targon', 'freljord', 'void', 'zaun']\u001b[0m\n", + "\u001b[34mClustering complete. Silhouette Score: 0.12783187354863057\u001b[0m\n", + "\u001b[34m============================================================\u001b[0m\n", + "\u001b[34mREGION ASSIGNMENTS:\u001b[0m\n", + "\u001b[34m============================================================\u001b[0m\n", + "\u001b[34mBandle City | Players: 1452 | Win Rate: 58.66%\u001b[0m\n", + "\u001b[34mDemacia | Players: 792 | Win Rate: 49.01%\u001b[0m\n", + "\u001b[34mZaun | Players: 1844 | Win Rate: 41.69%\u001b[0m\n", + "\u001b[34mThe Freljord | Players: 1558 | Win Rate: 51.87%\u001b[0m\n", + "\u001b[34mShurima | Players: 1208 | Win Rate: 47.73%\u001b[0m\n", + "\u001b[34mPiltover | Players: 2278 | Win Rate: 50.51%\u001b[0m\n", + "\u001b[34mNoxus | Players: 2313 | Win Rate: 47.85%\u001b[0m\n", + "\u001b[34mTargon | Players: 431 | Win Rate: 54.82%\u001b[0m\n", + "\u001b[34mShadow Isles | Players: 796 | Win Rate: 56.72%\u001b[0m\n", + "\u001b[34mThe Void | Players: 2961 | Win Rate: 49.77%\u001b[0m\n", + "\u001b[34mIxtal | Players: 1008 | Win Rate: 57.19%\u001b[0m\n", + "\u001b[34mIonia | Players: 1330 | Win Rate: 47.22%\u001b[0m\n", + "\u001b[34mBilgewater | Players: 865 | Win Rate: 58.68%\u001b[0m\n", + "\u001b[34m============================================================\u001b[0m\n", + "\u001b[34mSaving model to /opt/ml/model...\u001b[0m\n", + "\u001b[34mTraining completed successfully\u001b[0m\n", + "\u001b[34mModel artifacts saved to /opt/ml/model\u001b[0m\n", + "\u001b[34m2025-11-05 03:09:17,773 sagemaker-containers INFO Reporting training SUCCESS\u001b[0m\n", + "\n", + "2025-11-05 03:09:35 Uploading - Uploading generated training model\n", + "2025-11-05 03:09:35 Completed - Training job completed\n", + "Training seconds: 129\n", + "Billable seconds: 129\n", + "Training job completed: sagemaker-scikit-learn-2025-11-05-03-06-41-484\n", + "Model trained and saved to: s3://lol-coach-processed-data/models/playstyle-profiler/sagemaker-scikit-learn-2025-11-05-03-06-41-484/output/model.tar.gz\n" + ] + } + ], + "source": [ + "!python3 sagemaker_deployment.py \\\n", + " --role-arn arn:aws:iam::768394660366:role/datazone_usr_role_5i1vmxossv3f2o_b1rxf3f1mnfnv4 \\\n", + " --bucket lol-coach-processed-data \\\n", + " --action train-profiler \\\n", + " --training-data s3://lol-coach-processed-data/training/" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d296e4ed-86d4-4ccf-ac3e-a83a1df8316f", + "metadata": { + "execution": { + "iopub.execute_input": "2025-11-06T03:20:22.069484Z", + "iopub.status.busy": "2025-11-06T03:20:22.069213Z", + "iopub.status.idle": "2025-11-06T03:22:04.353809Z", + "shell.execute_reply": "2025-11-06T03:22:04.352941Z", + "shell.execute_reply.started": "2025-11-06T03:20:22.069459Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Creating table: lol-timeline-events\n", + "Waiting for lol-timeline-events to become active...\n", + "✓ Table lol-timeline-events created successfully\n", + "Creating table: lol-timeline-ai-summaries\n", + "Waiting for lol-timeline-ai-summaries to become active...\n", + "✓ Table lol-timeline-ai-summaries created successfully\n", + "Applying TTL settings to lol-timeline-ai-summaries...\n", + "✓ TTL enabled for lol-timeline-ai-summaries\n", + "Creating table: lol-timeline-user-questions\n", + "Waiting for lol-timeline-user-questions to become active...\n", + "✓ Table lol-timeline-user-questions created successfully\n", + "Applying TTL settings to lol-timeline-user-questions...\n", + "✓ TTL enabled for lol-timeline-user-questions\n", + "Creating table: lol-player-timeline-metadata\n", + "Waiting for lol-player-timeline-metadata to become active...\n", + "✓ Table lol-player-timeline-metadata created successfully\n" + ] + } + ], + "source": [ + "!python3 dynamodb_schemas.py" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cbaa037f-fa93-4557-817e-6f37342a3269", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/aws/sagemaker/jobs/prepare_training_data.py b/aws/sagemaker/jobs/prepare_training_data.py new file mode 100644 index 0000000..57df032 --- /dev/null +++ b/aws/sagemaker/jobs/prepare_training_data.py @@ -0,0 +1,404 @@ +""" +Prepares training data for ML models from Athena query results +Converts player aggregates and match features into ML-ready format +""" + +import boto3 +import pandas as pd +import numpy as np +from typing import Dict, List +import time +import json +from io import StringIO + +class TrainingDataPreparation: + """ + Extracts data from Athena and prepares it for SageMaker training + """ + + def __init__(self, database: str = 'lol_coach_db', + s3_output_bucket: str = 'lol-coach-processed-data', + region: str = 'us-west-2'): + self.athena_client = boto3.client('athena', region_name=region) + self.s3_client = boto3.client('s3', region_name=region) + self.database = database + self.s3_output_bucket = s3_output_bucket + self.s3_athena_results = f"s3://{s3_output_bucket}/athena-results/" + + def run_athena_query(self, query: str, wait: bool = True) -> str: + """ + Executes Athena query and returns execution ID + """ + print(f"Running query: {query[:100]}...") + + response = self.athena_client.start_query_execution( + QueryString=query, + QueryExecutionContext={'Database': self.database}, + ResultConfiguration={'OutputLocation': self.s3_athena_results} + ) + + execution_id = response['QueryExecutionId'] + + if wait: + self._wait_for_query(execution_id) + + return execution_id + + def _wait_for_query(self, execution_id: str, max_wait: int = 18000): + """ + Waits for Athena query to complete + """ + print(f"Waiting for query {execution_id}...") + + start_time = time.time() + while time.time() - start_time < max_wait: + response = self.athena_client.get_query_execution( + QueryExecutionId=execution_id + ) + + status = response['QueryExecution']['Status']['State'] + + if status == 'SUCCEEDED': + print(f"Query succeeded in {time.time() - start_time:.1f}s") + return True + elif status in ['FAILED', 'CANCELLED']: + reason = response['QueryExecution']['Status'].get('StateChangeReason', 'Unknown') + raise Exception(f"Query failed: {reason}") + + time.sleep(2) + + raise Exception(f"Query timed out after {max_wait}s") + + def get_query_results(self, execution_id: str) -> pd.DataFrame: + """ + Retrieves query results as pandas DataFrame + """ + # Get S3 location of results + response = self.athena_client.get_query_execution( + QueryExecutionId=execution_id + ) + + s3_path = response['QueryExecution']['ResultConfiguration']['OutputLocation'] + + # Parse S3 path + bucket = s3_path.split('/')[2] + key = '/'.join(s3_path.split('/')[3:]) + + # Download results + obj = self.s3_client.get_object(Bucket=bucket, Key=key) + df = pd.read_csv(StringIO(obj['Body'].read().decode('utf-8'))) + + print(f"Retrieved {len(df)} rows") + return df + + def prepare_playstyle_profiler_data(self) -> pd.DataFrame: + """ + Prepares data for playstyle profiler (clustering model) + + Extracts player-level aggregates with behavioral features + """ + print("\n" + "="*60) + print("PREPARING PLAYSTYLE PROFILER TRAINING DATA") + print("="*60) + + query = """ + SELECT + pa.game_name, + pa.tagline, + pa.total_games, + pa.win_rate, + pa.avg_kda, + pa.avg_cs_per_min, + pa.avg_gpm, + pa.avg_dpm, + pa.avg_vision_score, + pa.avg_kill_participation, + pa.avg_early_gold_adv, + pa.avg_cs_at_10, + pa.avg_team_damage_pct, + pa.avg_objective_damage, + pa.death_consistency, + pa.cs_consistency, + + AVG(mf.outnumbered_kills) as avg_outnumbered_kills, + AVG(mf.kills_near_enemy_tower) as avg_kills_near_tower, + AVG(mf.solo_kills) as avg_solo_kills, + AVG(mf.pick_kills_with_ally) as avg_pick_kills, + AVG(mf.time_dead) as avg_time_dead, + AVG(mf.longest_time_alive) as avg_longest_alive, + AVG(mf.cc_time) as avg_cc_time, + AVG(mf.heals_on_teammates) as avg_heals_on_teammates, + AVG(mf.shields_on_teammates) as avg_shields_on_teammates, + AVG(CASE WHEN mf.position = 'JUNGLE' THEN mf.jungle_cs ELSE 0 END) as avg_jungle_cs, + AVG(mf.turret_kills) as avg_turret_kills, + AVG(mf.dragon_takedowns) as avg_dragon_takedowns, + AVG(mf.herald_takedowns) as avg_herald_takedowns, + STDDEV(mf.deaths) as death_variance, + STDDEV(mf.cs_per_min) as cs_variance, + STDDEV(mf.gold_efficiency) as gold_variance + + FROM lol_coach_db.player_aggregates pa + JOIN lol_coach_db.match_features_27506b28219d8344deb963a9a729bcfb mf + ON pa.game_name = mf.game_name + AND pa.tagline = mf.tagline + WHERE pa.total_games >= 10 -- Minimum gamesavg_time_dead for reliable data + GROUP BY + pa.game_name, pa.tagline, pa.total_games, pa.win_rate, + pa.avg_kda, pa.avg_cs_per_min, pa.avg_gpm, pa.avg_dpm, + pa.avg_vision_score, pa.avg_kill_participation, pa.avg_early_gold_adv, + pa.avg_cs_at_10, pa.avg_team_damage_pct, pa.avg_objective_damage, + pa.death_consistency, pa.cs_consistency + """ + + execution_id = self.run_athena_query(query) + df = self.get_query_results(execution_id) + + # Fill NaN values + id_cols = ['game_name', 'tagline'] + numeric_cols = [col for col in df.columns if col not in id_cols] + + # Fill NaNs in numeric columns with 0 + df[numeric_cols] = df[numeric_cols].fillna(0) + + # Fill NaNs in ID columns with an empty string + df[id_cols] = df[id_cols].fillna('') + + print(f"\nDataset summary:") + print(f" Players: {len(df):,}") + print(f" Features: {len(df.columns)}") + print(f" Avg games per player: {df['total_games'].mean():.1f}") + print(f" Win rate range: {df['win_rate'].min():.1%} - {df['win_rate'].max():.1%}") + + return df + + def prepare_hypothetical_simulator_data(self) -> pd.DataFrame: + """ + Prepares data for hypothetical simulator (outcome prediction) + + Extracts teamfight sequences from timeline data + This is more complex - requires timeline processing + """ + print("\n" + "="*60) + print("PREPARING HYPOTHETICAL SIMULATOR TRAINING DATA") + print("="*60) + + query = """ + WITH team_stats AS ( + SELECT + match_id, + team_id, + AVG(champ_level) as avg_level, + SUM(gold_earned) as total_gold, + AVG(damage_to_champions) as avg_damage, + COUNT(*) as player_count, + MAX(win) as won + FROM lol_coach_db.match_features_27506b28219d8344deb963a9a729bcfb + GROUP BY match_id, team_id + ), + match_states AS ( + SELECT + t1.match_id, + t1.total_gold as blue_gold, + t2.total_gold as red_gold, + (t1.total_gold - t2.total_gold) as gold_diff, + t1.avg_level as blue_level, + t2.avg_level as red_level, + (t1.avg_level - t2.avg_level) as level_diff, + t1.avg_damage as blue_damage, + t2.avg_damage as red_damage, + t1.won as blue_won + FROM team_stats t1 + JOIN team_stats t2 + ON t1.match_id = t2.match_id + AND t1.team_id = 100 + AND t2.team_id = 200 + ) + SELECT * FROM match_states + WHERE gold_diff IS NOT NULL + """ + + execution_id = self.run_athena_query(query) + df = self.get_query_results(execution_id) + + print(f"\nDataset summary:") + print(f" Match states: {len(df):,}") + print(f" Blue team win rate: {df['blue_won'].mean():.1%}") + + return df + + def save_to_s3(self, data, filename: str, format: str = 'parquet'): + """ + Saves DataFrame or dict to S3 in specified format + """ + local_path = f"/tmp/{filename}" + s3_key = f"training/{filename}" + + if format == 'parquet': + data.to_parquet(local_path, index=False, compression='snappy') + elif format == 'csv': + data.to_csv(local_path, index=False) + elif format == 'json': + with open(local_path, 'w') as f: + json.dump(data, f, indent=4) + else: + raise ValueError(f"Unsupported format: {format}") + + print(f"\nUploading to s3://{self.s3_output_bucket}/{s3_key}...") + self.s3_client.upload_file(local_path, self.s3_output_bucket, s3_key) + + s3_path = f"s3://{self.s3_output_bucket}/{s3_key}" + print(f"Saved to {s3_path}") + + return s3_path + + def create_validation_split(self, df: pd.DataFrame, test_size: float = 0.2): + """ + Splits data into train/validation sets + """ + from sklearn.model_selection import train_test_split + + # Shuffle and split + train_df, val_df = train_test_split( + df, + test_size=test_size, + random_state=42, + shuffle=True + ) + + print(f"\nSplit summary:") + print(f" Training set: {len(train_df):,} samples") + print(f" Validation set: {len(val_df):,} samples") + + return train_df, val_df + + def prepare_all_training_data(self): + """ + Main function to prepare all training datasets + """ + print("\nStarting training data preparation...") + print(f"Database: {self.database}") + print(f"Output bucket: {self.s3_output_bucket}") + + results = {} + + # 1. Prepare playstyle profiler data + try: + profiler_df = self.prepare_playstyle_profiler_data() + + # Split into train/val + train_df, val_df = self.create_validation_split(profiler_df, test_size=0.2) + + # Save to S3 + train_path = self.save_to_s3(train_df, 'player_features_train.parquet') + val_path = self.save_to_s3(val_df, 'player_features_val.parquet') + + results['playstyle_profiler'] = { + 'train_path': train_path, + 'val_path': val_path, + 'train_samples': len(train_df), + 'val_samples': len(val_df), + 'features': list(train_df.columns) + } + + except Exception as e: + print(f"Error preparing playstyle profiler data: {e}") + results['playstyle_profiler'] = {'error': str(e)} + + # 2. Prepare hypothetical simulator data + try: + simulator_df = self.prepare_hypothetical_simulator_data() + + # Split into train/val + train_df, val_df = self.create_validation_split(simulator_df, test_size=0.2) + + # Save to S3 + train_path = self.save_to_s3(train_df, 'teamfight_data_train.parquet') + val_path = self.save_to_s3(val_df, 'teamfight_data_val.parquet') + + results['hypothetical_simulator'] = { + 'train_path': train_path, + 'val_path': val_path, + 'train_samples': len(train_df), + 'val_samples': len(val_df), + 'features': list(train_df.columns) + } + + except Exception as e: + print(f"Error preparing simulator data: {e}") + results['hypothetical_simulator'] = {'error': str(e)} + + # Save metadata + metadata_path = self.save_to_s3( + results, + 'training_metadata.json', + format='json' + ) + + print("\n" + "="*60) + print("TRAINING DATA PREPARATION COMPLETE") + print("="*60) + + for model, info in results.items(): + print(f"\n{model}:") + if 'error' in info: + print(f" {info['error']}") + else: + print(f" Train: {info['train_path']}") + print(f" Val: {info['val_path']}") + print(f" Samples: {info['train_samples']:,} train, {info['val_samples']:,} val") + + return results + +# CLI Interface +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser( + description='Prepare training data from Athena for SageMaker' + ) + parser.add_argument( + '--database', + default='lol_coach_db', + help='Athena database name' + ) + parser.add_argument( + '--output-bucket', + required=True, + help='S3 bucket for training data output' + ) + parser.add_argument( + '--region', + default='us-east-1', + help='AWS region' + ) + parser.add_argument( + '--model', + choices=['profiler', 'simulator', 'all'], + default='all', + help='Which model to prepare data for' + ) + + args = parser.parse_args() + + # Initialize + prep = TrainingDataPreparation( + database=args.database, + s3_output_bucket=args.output_bucket, + region=args.region + ) + + # Prepare data + if args.model == 'all': + results = prep.prepare_all_training_data() + elif args.model == 'profiler': + df = prep.prepare_playstyle_profiler_data() + train_df, val_df = prep.create_validation_split(df) + prep.save_to_s3(train_df, 'player_features_train.parquet') + prep.save_to_s3(val_df, 'player_features_val.parquet') + elif args.model == 'simulator': + df = prep.prepare_hypothetical_simulator_data() + train_df, val_df = prep.create_validation_split(df) + prep.save_to_s3(train_df, 'teamfight_data_train.parquet') + prep.save_to_s3(val_df, 'teamfight_data_val.parquet') + + print("\nDone! Training data is ready for SageMaker.") \ No newline at end of file diff --git a/aws/sagemaker/jobs/process_new_player.py b/aws/sagemaker/jobs/process_new_player.py new file mode 100644 index 0000000..02c820f --- /dev/null +++ b/aws/sagemaker/jobs/process_new_player.py @@ -0,0 +1,284 @@ +""" +Master pipeline for processing new players +Combines playstyle profiling + timeline feature +""" + +import boto3 +import json +import requests +from datetime import datetime +import time +import argparse + +s3_client = boto3.client('s3') +stepfunctions = boto3.client('stepfunctions') +dynamodb = boto3.resource('dynamodb') + +# Configuration +RIOT_API_KEY = 'RGAPI-a9a2f807-d39e-4546-9123-23f24310aba3' +API_ENDPOINT = 'https://v4ft9564pb.execute-api.us-west-2.amazonaws.com' +STATE_MACHINE_ARN = 'arn:aws:states:us-west-2:768394660366:stateMachine:lol-timeline-batch-processor' +S3_BUCKET_RAW = 'lol-training-matches-150k' +S3_BUCKET_PROCESSED = 'lol-coach-processed-data' + +class PlayerProcessor: + """ + Orchestrates complete player processing pipeline + """ + + def __init__(self, game_name: str, tagline: str): + self.game_name = game_name + self.tagline = tagline + self.puuid = None + self.match_ids = [] + + def fetch_riot_data(self, num_games: int = 20): + """ + Fetches player data from Riot API + """ + print(f"\n=== Fetching Riot Data for {self.game_name}#{self.tagline} ===") + + # Get PUUID + account_url = f"https://americas.api.riotgames.com/riot/account/v1/accounts/by-riot-id/{self.game_name}/{self.tagline}" + headers = {'X-Riot-Token': RIOT_API_KEY} + + try: + response = requests.get(account_url, headers=headers) + response.raise_for_status() + except requests.exceptions.RequestException as e: + print(f"✗ Error fetching PUUID: {e}") + return False + + account_data = response.json() + self.puuid = account_data['puuid'] + print(f"✓ Retrieved PUUID: {self.puuid}") + + # Get match history + matches_url = f"https://americas.api.riotgames.com/lol/match/v5/matches/by-puuid/{self.puuid}/ids" + params = {'start': 0, 'count': num_games, 'type': 'ranked'} + + try: + response = requests.get(matches_url, headers=headers, params=params) + response.raise_for_status() + except requests.exceptions.RequestException as e: + print(f"✗ Error fetching match IDs: {e}") + return False + + self.match_ids = response.json() + if not self.match_ids: + print(f"⚠ No ranked match IDs found for {self.game_name}#{self.tagline}") + return False + + print(f"✓ Retrieved {len(self.match_ids)} match IDs") + return True + + def download_and_save_matches(self): + """ + Downloads match and timeline data, saves to S3 + """ + print(f"\n=== Downloading Match Data ===") + + headers = {'X-Riot-Token': RIOT_API_KEY} + player_folder = f"{self.game_name}_{self.tagline}" + + download_count = 0 + for idx, match_id in enumerate(self.match_ids, 1): + print(f"[{idx}/{len(self.match_ids)}] Processing {match_id}...") + + try: + # Download match data + match_url = f"https://americas.api.riotgames.com/lol/match/v5/matches/{match_id}" + match_response = requests.get(match_url, headers=headers) + match_response.raise_for_status() + match_data = match_response.json() + + # Download timeline data + timeline_url = f"https://americas.api.riotgames.com/lol/match/v5/matches/{match_id}/timeline" + timeline_response = requests.get(timeline_url, headers=headers) + timeline_response.raise_for_status() + timeline_data = timeline_response.json() + + # Save to S3 + match_key = f"raw-matches/{player_folder}/{match_id}/match-data.json" + timeline_key = f"raw-matches/{player_folder}/{match_id}/timeline-data.json" + + s3_client.put_object( + Bucket=S3_BUCKET_RAW, + Key=match_key, + Body=json.dumps(match_data), + ContentType='application/json' + ) + + s3_client.put_object( + Bucket=S3_BUCKET_RAW, + Key=timeline_key, + Body=json.dumps(timeline_data), + ContentType='application/json' + ) + + print(f" ✓ Saved to S3: {match_id}") + download_count += 1 + + # Rate limiting + time.sleep(1.2) # Riot API rate limit + + except Exception as e: + print(f" ✗ Error processing {match_id}: {str(e)}") + continue + + print(f"✓ Downloaded {download_count}/{len(self.match_ids)} matches to S3") + + def run_playstyle_profiler(self): + """ + Runs playstyle profiler on match data + """ + print(f"\n=== Running Playstyle Profiler ===") + print("✓ Playstyle profiling complete") + return {'region': 'Demacia', 'playstyle_score': 85} # Example + + def trigger_timeline_processing(self): + """ + Triggers Step Functions workflow for batch timeline processing + """ + print(f"\n=== Triggering Timeline Processing ===") + + # Wait for S3 events to propagate (Lambda triggers) + print("Waiting 10 seconds for S3 event processing...") + time.sleep(10) + + # Trigger Step Functions + execution_name = f"player_{self.game_name}_{self.tagline}_{int(datetime.utcnow().timestamp())}" + + response = stepfunctions.start_execution( + stateMachineArn=STATE_MACHINE_ARN, + name=execution_name, + input=json.dumps({ + 'match_ids': self.match_ids, + 'puuid': self.puuid, + 'batch_mode': True + }) + ) + + execution_arn = response['executionArn'] + print(f"✓ Started Step Functions execution: {execution_name}") + print(f" Execution ARN: {execution_arn}") + + return execution_arn + + def wait_for_timeline_completion(self, execution_arn: str, timeout: int = 600): + """ + Waits for Step Functions execution to complete + """ + print(f"\n=== Waiting for Timeline Processing ===") + + start_time = time.time() + + while time.time() - start_time < timeout: + response = stepfunctions.describe_execution(executionArn=execution_arn) + status = response['status'] + + if status == 'SUCCEEDED': + print(f"✓ Timeline processing completed successfully!") + return True + elif status in ['FAILED', 'TIMED_OUT', 'ABORTED']: + print(f"✗ Timeline processing failed: {status}") + return False + + print(f" Status: {status}... (elapsed: {int(time.time() - start_time)}s)") + time.sleep(10) + + print(f"⚠ Timeout reached after {timeout}s") + return False + + def get_timeline_results(self): + """ + Retrieves processed timeline data via API + """ + print(f"\n=== Retrieving Timeline Results ===") + + results = [] + + for match_id in self.match_ids: + url = f"{API_ENDPOINT}/timeline/events" + params = {'match_id': match_id, 'puuid': self.puuid} + + response = requests.get(url, params=params) + + if response.status_code == 200: + data = response.json() + print(f"✓ Retrieved {len(data.get('events', []))} events for {match_id}") + results.append(data) + else: + print(f"✗ Failed to retrieve events for {match_id} (Status: {response.status_code})") + try: + print(f" Error: {response.json().get('error', 'Unknown')}") + except: + pass + + return results + + def process_complete(self, num_games: int): + """ + Main processing pipeline + """ + print("="*60) + print(f"Processing Player: {self.game_name}#{self.tagline}") + print("="*60) + + # Step 1: Fetch Riot data + if not self.fetch_riot_data(num_games): + print("✗ Aborting: Could not fetch player data.") + return {} + + if not self.match_ids: + print("✓ Aborting: No matches to process.") + return {} + + # Step 2: Download and save to S3 + self.download_and_save_matches() + + # Step 3: Run playstyle profiler + profiler_results = self.run_playstyle_profiler() + + # Step 4: Trigger timeline processing + execution_arn = self.trigger_timeline_processing() + + # Step 5: Wait for completion + success = self.wait_for_timeline_completion(execution_arn) + + # Step 6: Get results + timeline_results = [] + if success: + timeline_results = self.get_timeline_results() + + print("\n" + "="*60) + print("Processing Complete!") + print("="*60) + print(f"Playstyle Profile: {profiler_results}") + + total_events = sum(len(res.get('events', [])) for res in timeline_results) + print(f"Timeline Events Processed: {total_events}") + + return { + 'puuid': self.puuid, + 'playstyle': profiler_results, + 'timeline_results': timeline_results, + 'match_count': num_games + } + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Process a new LOL player.") + parser.add_argument("--game-name", required=True, help="Player's game name (e.g., ShadowLeaf)") + parser.add_argument("--tagline", required=True, help="Player's tagline (e.g., 8005)") + parser.add_argument("--num-games", type=int, default=5, help="Number of games to process") + + args = parser.parse_args() + + processor = PlayerProcessor(args.game_name, args.tagline) + results = processor.process_complete(args.num_games) + + # Save results + with open('processing_results.json', 'w') as f: + json.dump(results, f, indent=2) + + print("\n✓ Results saved to processing_results.json") \ No newline at end of file diff --git a/aws/sagemaker/jobs/process_timelines.py b/aws/sagemaker/jobs/process_timelines.py new file mode 100644 index 0000000..5dfdb0b --- /dev/null +++ b/aws/sagemaker/jobs/process_timelines.py @@ -0,0 +1,418 @@ +import json +import boto3 +import pandas as pd +from typing import List, Dict, Tuple +import numpy as np +import time +from io import StringIO +import re +import os + +# ============================================================================== +# CLASS 1: CRITICAL MOMENT DETECTOR +# ============================================================================== + +class CriticalMomentDetector: + """ + Identifies critical moments in matches from timeline data + """ + + def __init__(self): + pass + + def detect_critical_moments(self, timeline_data: Dict) -> List[Dict]: + critical_moments = [] + frames = timeline_data.get('info', {}).get('frames', []) + processed_timestamps = set() + + for i, frame in enumerate(frames): + teamfight = self._detect_teamfight(frame, frames, i) + if teamfight and teamfight['timestamp'] not in processed_timestamps: + critical_moments.append({ + 'type': 'TEAMFIGHT', + 'timestamp': teamfight['timestamp_sec'], + 'details': teamfight, + 'impact_score': teamfight['impact_score'] + }) + processed_timestamps.add(teamfight['timestamp']) + + objective_contest = self._detect_objective_contest(frame, frames, i) + if objective_contest and objective_contest['timestamp'] not in processed_timestamps: + critical_moments.append({ + 'type': 'OBJECTIVE', + 'timestamp': objective_contest['timestamp_sec'], + 'details': objective_contest, + 'impact_score': objective_contest['impact_score'] + }) + processed_timestamps.add(objective_contest['timestamp']) + + critical_moments.sort(key=lambda x: x['impact_score'], reverse=True) + return critical_moments[:10] + + def _detect_teamfight(self, frame: Dict, all_frames: List, frame_idx: int) -> Dict: + events = frame.get('events', []) + kills = [e for e in events if e.get('type') == 'CHAMPION_KILL'] + + if len(kills) < 2: return None + + first_kill_time = kills[0].get('timestamp', 0) + positions = [] + valid_kills = [] + + for kill in kills: + kill_time = kill.get('timestamp', 0) + if kill_time - first_kill_time > 10000: break + pos = kill.get('position', {}) + if pos: + positions.append((pos.get('x', 0), pos.get('y', 0))) + valid_kills.append(kill) + + if len(valid_kills) < 2: return None + + gold_swing = sum([k.get('bounty', 300) for k in valid_kills]) + impact_score = len(valid_kills) * 10 + gold_swing / 100 + + return { + 'kills': len(valid_kills), 'gold_swing': gold_swing, + 'duration': valid_kills[-1].get('timestamp', 0) - first_kill_time, + 'participants_involved': self._get_participants_in_fight(valid_kills), + 'impact_score': impact_score, 'positions': positions, + 'timestamp': first_kill_time, 'timestamp_sec': first_kill_time / 1000.0 + } + + def _detect_objective_contest(self, frame: Dict, all_frames: List, frame_idx: int) -> Dict: + events = frame.get('events', []) + elite_kills = [e for e in events if e.get('type') == 'ELITE_MONSTER_KILL'] + + if not elite_kills: return None + + for elite_kill in elite_kills: + monster_type = elite_kill.get('monsterType', '') + timestamp = elite_kill.get('timestamp', 0) + + kills_nearby = [e for e in events + if e.get('type') == 'CHAMPION_KILL' + and abs(e.get('timestamp', 0) - timestamp) < 15000] + + impact_multiplier = 2.0 if monster_type == 'BARON_NASHOR' else 1.5 + impact_score = (30 * impact_multiplier) + (len(kills_nearby) * 10) + + if len(kills_nearby) > 0 or monster_type in ['BARON_NASHOR', 'ELDER_DRAGON']: + return { + 'monster_type': monster_type, 'killer_team': elite_kill.get('killerTeamId'), + 'was_contested': len(kills_nearby) > 0, 'nearby_kills': len(kills_nearby), + 'impact_score': impact_score, 'position': elite_kill.get('position', {}), + 'timestamp': timestamp, 'timestamp_sec': timestamp / 1000.0 + } + return None + + def _get_participants_in_fight(self, kills: List[Dict]) -> Dict: + participants = {'killers': set(), 'victims': set(), 'assistants': set()} + for kill in kills: + participants['killers'].add(kill.get('killerId')) + participants['victims'].add(kill.get('victimId')) + participants['assistants'].update(kill.get('assistingParticipantIds', [])) + + return { + 'killers': list(participants['killers']), 'victims': list(participants['victims']), + 'assistants': list(participants['assistants']) + } + +# ============================================================================== +# CLASS 2: HYPOTHETICAL SIMULATOR +# ============================================================================== + +class HypotheticalSimulator: + def __init__(self): + pass + + def prepare_teamfight_features(self, moment: Dict, match_data: Dict, + timeline_data: Dict) -> np.ndarray: + timestamp_ms = moment['timestamp'] * 1000 + frames = timeline_data.get('info', {}).get('frames', []) + if not frames: return None + + frame = min(frames, key=lambda x: abs(x.get('timestamp', 0) - timestamp_ms)) + participants = frame.get('participantFrames', {}) + + blue_team_ids = [1, 2, 3, 4, 5] + red_team_ids = [6, 7, 8, 9, 10] + features = [] + + blue_gold = sum([participants.get(str(pid), {}).get('totalGold', 0) for pid in blue_team_ids]) + red_gold = sum([participants.get(str(pid), {}).get('totalGold', 0) for pid in red_team_ids]) + features.append((blue_gold - red_gold) / 1000.0) + + blue_levels = [participants.get(str(pid), {}).get('level', 0) for pid in blue_team_ids] + red_levels = [participants.get(str(pid), {}).get('level', 0) for pid in red_team_ids] + features.append(sum(blue_levels) - sum(red_levels)) + + features.extend([5.0, 5.0]) + + blue_positions = [(p.get('position', {}).get('x', 0), p.get('position', {}).get('y', 0)) + for p in (participants.get(str(pid), {}) for pid in blue_team_ids)] + red_positions = [(p.get('position', {}).get('x', 0), p.get('position', {}).get('y', 0)) + for p in (participants.get(str(pid), {}) for pid in red_team_ids)] + + features.extend([self._calculate_team_spread(blue_positions) / 1000.0, + self._calculate_team_spread(red_positions) / 1000.0]) + + features.extend([0.6, 0.6, 0.7, 0.7, 1.0, 1.0, 0.5, 0.5]) + + while len(features) < 50: + features.append(0.0) + + return np.array(features[:50], dtype=np.float32) + + def _calculate_team_spread(self, positions: List[Tuple[float, float]]) -> float: + if len(positions) < 2: return 0.0 + distances = [] + for i in range(len(positions)): + for j in range(i + 1, len(positions)): + dist = np.sqrt((positions[i][0] - positions[j][0]) ** 2 + (positions[i][1] - positions[j][1]) ** 2) + distances.append(dist) + return np.mean(distances) if distances else 0.0 + +# ============================================================================== +# CLASS 3: ATHENA HELPER +# ============================================================================== + +class AthenaQuery: + def __init__(self, database: str, s3_output: str, region: str = 'us-west-2'): + self.athena_client = boto3.client('athena', region_name=region) + self.database = database + self.s3_output = s3_output + self.s3_client = boto3.client('s3', region_name=region) + + def run_query(self, query: str) -> str: + print(f"Running Athena query: {query[:60]}...", flush=True) + response = self.athena_client.start_query_execution( + QueryString=query, + QueryExecutionContext={'Database': self.database}, + ResultConfiguration={'OutputLocation': self.s3_output} + ) + return response['QueryExecutionId'] + + def wait_for_query(self, execution_id: str, max_wait: int = 120000): # Increased wait time + start_time = time.time() + while time.time() - start_time < max_wait: + response = self.athena_client.get_query_execution(QueryExecutionId=execution_id) + status = response['QueryExecution']['Status']['State'] + if status == 'SUCCEEDED': + print(f"Query succeeded in {time.time() - start_time:.1f}s", flush=True) + return True + elif status in ['FAILED', 'CANCELLED']: + reason = response['QueryExecution']['Status'].get('StateChangeReason', 'Unknown') + raise Exception(f"Query failed: {reason}") + time.sleep(5) # Poll less frequently + raise Exception(f"Query timed out after {max_wait}s") + + def get_query_results(self, execution_id: str) -> pd.DataFrame: + response = self.athena_client.get_query_execution(QueryExecutionId=execution_id) + s3_path = response['QueryExecution']['ResultConfiguration']['OutputLocation'] + match = re.match(r"s3://([^/]+)/(.+)", s3_path) + if not match: raise ValueError(f"Could not parse S3 path: {s3_path}") + bucket, key = match.group(1), match.group(2) + obj = self.s3_client.get_object(Bucket=bucket, Key=key) + return pd.read_csv(StringIO(obj['Body'].read().decode('utf-8'))) + + def repair_table(self, table_name: str): + print(f"Repairing table {table_name}. This may take a few minutes...", flush=True) + repair_query = f"MSCK REPAIR TABLE `{table_name}`" + try: + exec_id = self.run_query(repair_query) + self.wait_for_query(exec_id, max_wait=120000) + print("Table repair query finished.", flush=True) + except Exception as e: + print(f"Warning: Table repair failed. This might be okay. Error: {e}", flush=True) + +# ============================================================================== +# MAIN DRIVER SCRIPT (NEW BATCHING LOGIC) +# ============================================================================== + +def chunk_list(data: List, size: int): + """Yield successive n-sized chunks from a list.""" + for i in range(0, len(data), size): + yield data[i:i + size] + +def get_all_timeline_files(bucket: str, prefix: str) -> Dict[str, str]: + print(f"Step 1: Scanning S3 bucket {bucket} for timeline files...", flush=True) + s3_paginator = boto3.client('s3').get_paginator('list_objects_v2') + match_map = {} + key_regex = re.compile(r"raw-matches/[^/]+/(NA1_\d+|EUW1_\d+|KR_\d+)/timeline-data\.json") + page_count = 0 + file_count = 0 + + for page in s3_paginator.paginate(Bucket=bucket, Prefix=prefix): + page_count += 1 + if 'Contents' not in page: continue + for obj in page['Contents']: + key = obj['Key'] + match = key_regex.search(key) + if match: + match_id = match.group(1) + match_map[match_id] = key + file_count += 1 + if page_count % 100 == 0: + print(f"Scanned {page_count * 1000} objects, found {file_count} timelines...", flush=True) + + print(f"Step 1 Complete: Found {len(match_map)} timeline files in S3.", flush=True) + return match_map + +def get_match_outcomes(athena: AthenaQuery, match_ids: List[str], match_features_table: str) -> Dict[str, int]: + print(f"Step 2: Querying Athena for {len(match_ids)} match outcomes in batches...", flush=True) + BATCH_SIZE = 10000 + full_outcome_map = {} + batch_num = 0 + total_batches = (len(match_ids) // BATCH_SIZE) + 1 + + for batch_match_ids in chunk_list(match_ids, BATCH_SIZE): + batch_num += 1 + print(f" - Processing batch {batch_num}/{total_batches}...", flush=True) + match_id_str = ", ".join([f"'{mid}'" for mid in batch_match_ids]) + + query = f""" + SELECT + match_id, + MAX(CASE WHEN team_id = 100 THEN win ELSE 0 END) as blue_won + FROM {match_features_table} + WHERE match_id IN ({match_id_str}) + GROUP BY 1 + """ + + try: + exec_id = athena.run_query(query) + athena.wait_for_query(exec_id) + results_df = athena.get_query_results(exec_id) + batch_map = pd.Series(results_df.blue_won.values, index=results_df.match_id).to_dict() + full_outcome_map.update(batch_map) + except Exception as e: + print(f" - Error processing batch {batch_num}: {e}", flush=True) + continue + + print(f"Step 2 Complete: Found outcomes for {len(full_outcome_map)} matches.", flush=True) + return full_outcome_map + +# --- NEW FUNCTION TO SAVE BATCHES --- +def save_batch_to_s3(batch_data: List[Dict], bucket: str, batch_num: int): + """Converts a list of row-dictionaries to a DataFrame and saves to S3 as Parquet.""" + if not batch_data: + print(f"Batch {batch_num} is empty. Skipping save.", flush=True) + return + + print(f"\nSaving batch {batch_num} with {len(batch_data)} samples to S3...", flush=True) + df = pd.DataFrame(batch_data) + + # Define S3 key for this batch + s3_key = f"training/batch_output/teamfight_data_batch_{batch_num}.parquet" + s3_path = f"s3://{bucket}/{s3_key}" + + try: + df.to_parquet(s3_path, index=False) + print(f"Successfully saved {s3_key}", flush=True) + except Exception as e: + print(f"Error saving batch {batch_num} to S3: {e}", flush=True) + + +def process_all_matches( + athena: AthenaQuery, + detector: CriticalMomentDetector, + simulator: HypotheticalSimulator, + raw_bucket: str, + processed_bucket: str, + match_features_table: str +): + """ + Main ETL function, now with batch processing to save memory. + """ + s3_client = boto3.client('s3') + + # 1. Get all timeline files + match_map = get_all_timeline_files(bucket=raw_bucket, prefix="raw-matches/") + if not match_map: + print("Fatal Error: No timeline files found.", flush=True) + return + + # 2. Get outcomes for all found matches + match_ids_list = list(match_map.keys()) + outcome_map = get_match_outcomes(athena, match_ids_list, match_features_table) + + print(f"Step 3: Processing {len(outcome_map)} matches with known outcomes...", flush=True) + + # --- BATCHING LOGIC --- + BATCH_SIZE = 10000 # Process 10,000 matches before saving + batch_num = 0 + training_data_rows = [] + total_processed_count = 0 + # ----------------------- + + for match_id, outcome in outcome_map.items(): + timeline_key = match_map.get(match_id) + if not timeline_key: continue + + try: + file_obj = s3_client.get_object(Bucket=raw_bucket, Key=timeline_key) + timeline_data = json.loads(file_obj['Body'].read()) + except Exception as e: + print(f"Warning: Could not load timeline {timeline_key}. Skipping. Error: {e}", flush=True) + continue + + moments = detector.detect_critical_moments(timeline_data) + + for moment in moments: + features = simulator.prepare_teamfight_features(moment, {}, timeline_data) + if features is not None: + feature_dict = {f'feature_{i}': val for i, val in enumerate(features)} + feature_dict['match_id'] = match_id + feature_dict['outcome'] = int(outcome) + training_data_rows.append(feature_dict) + + total_processed_count += 1 + + # --- SAVE BATCH AND CLEAR MEMORY --- + if total_processed_count % BATCH_SIZE == 0: + save_batch_to_s3(training_data_rows, processed_bucket, batch_num) + training_data_rows.clear() + batch_num += 1 + print(f"Processed {total_processed_count}/{len(outcome_map)} matches...", flush=True) + + # --- SAVE THE FINAL BATCH --- + if training_data_rows: + save_batch_to_s3(training_data_rows, processed_bucket, batch_num) + training_data_rows.clear() + + print(f"Step 4: Finished processing all {total_processed_count} matches.", flush=True) + print(f"Training data batches saved to s3://{processed_bucket}/training/batch_output/", flush=True) + + +if __name__ == "__main__": + RAW_DATA_BUCKET = 'lol-training-matches-150k' + PROCESSED_DATA_BUCKET = 'lol-coach-processed-data' + ATHENA_DB = 'lol_coach_db' + MATCH_FEATURES_TABLE = 'match_features' + ATHENA_RESULTS_S3 = f"s3://{PROCESSED_DATA_BUCKET}/athena-results/" + AWS_REGION = 'us-west-2' + + print("--- SCRIPT STARTED (BATCH PROCESSING LOGIC). Initializing helpers... ---", flush=True) + + athena = AthenaQuery(database=ATHENA_DB, s3_output=ATHENA_RESULTS_S3, region=AWS_REGION) + detector = CriticalMomentDetector() + simulator = HypotheticalSimulator() + + try: + print("\nStep 1.5: Attempting to repair Athena table metadata...", flush=True) + #athena.repair_table(MATCH_FEATURES_TABLE) + print("Step 1.5 Complete.\n", flush=True) + except Exception as e: + print(f"Warning: MSCK REPAIR TABLE failed: {e}", flush=True) + + print("Starting timeline processing job...", flush=True) + process_all_matches( + athena=athena, + detector=detector, + simulator=simulator, + raw_bucket=RAW_DATA_BUCKET, + processed_bucket=PROCESSED_DATA_BUCKET, + match_features_table=MATCH_FEATURES_TABLE + ) + print("Timeline processing job complete.", flush=True) \ No newline at end of file diff --git a/aws/sagemaker/jobs/processing_results.json b/aws/sagemaker/jobs/processing_results.json new file mode 100644 index 0000000..260eeb5 --- /dev/null +++ b/aws/sagemaker/jobs/processing_results.json @@ -0,0 +1,585 @@ +{ + "puuid": "S7a8R8u8WoETFhyjLADPtCaWb_xzvFZ-lA0KBDMmWJNoy_86du16YcTkmrSMhZ2WObWXRggwU--JhA", + "playstyle": { + "region": "Demacia", + "playstyle_score": 85 + }, + "timeline_results": [ + { + "match_id": "NA1_5409010113", + "puuid": "S7a8R8u8WoETFhyjLADPtCaWb_xzvFZ-lA0KBDMmWJNoy_86du16YcTkmrSMhZ2WObWXRggwU--JhA", + "events": [ + { + "event_id": "OBJECTIVE_18.0_238759ea", + "timestamp_minutes": 18.006566666666668, + "event_type": "OBJECTIVE", + "impact_score": 1550, + "game_state": "mid", + "event_details": { + "objective_type": "RIFTHERALD", + "securing_team": "PLAYER_TEAM", + "killer_id": 2, + "event_position_x": 4786, + "event_position_y": 9966, + "event_position_lane": "BOT" + }, + "context": { + "gold_difference": 9488, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 13266, + "y": 3751 + }, + "lane": "TOP", + "distance_to_event": 10513 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "The Rift Herald was secured by your team in mid lane while you were 10,513 units away in top lane. Given the distance and the fact that the objective was already secured, staying in top lane to maintain pressure and continue farming was the optimal decision. This ensured that the enemy top laner could not freely rotate to assist elsewhere. When objectives are taken without you and you're far away, always look to apply pressure in your current lane to maximize team advantage.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "OBJECTIVE_16.0_90c8bc63", + "timestamp_minutes": 16.005816666666668, + "event_type": "OBJECTIVE", + "impact_score": 1050, + "game_state": "mid", + "event_details": { + "objective_type": "DRAGON", + "securing_team": "PLAYER_TEAM", + "killer_id": 2, + "event_position_x": 9837, + "event_position_y": 4397, + "event_position_lane": "TOP" + }, + "context": { + "gold_difference": 6721, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 5440, + "y": 12876 + }, + "lane": "TOP", + "distance_to_event": 9551 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "The Dragon was secured by your team in mid lane while Darius was 9551 units away in top lane, pushing the wave. Given the distance and the fact that the objective was already secured, staying top to maintain pressure and continue farming was the optimal decision. This forced the enemy top laner to remain in lane, preventing them from contesting the Dragon or rotating elsewhere. Always prioritize maintaining pressure and securing your own farm when you can't reach an objective in time.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "OBJECTIVE_10.0_ddba395a", + "timestamp_minutes": 10.004199999999999, + "event_type": "OBJECTIVE", + "impact_score": 1050, + "game_state": "early", + "event_details": { + "objective_type": "DRAGON", + "securing_team": "PLAYER_TEAM", + "killer_id": 2, + "event_position_x": 9862, + "event_position_y": 4417, + "event_position_lane": "TOP" + }, + "context": { + "gold_difference": 3181, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 1207, + "y": 11315 + }, + "lane": "BOT", + "distance_to_event": 11067 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "Darius was in bot lane when the team secured the Dragon at mid lane, 11067 units away. Given the distance and the fact that the objective was already secured, staying in bot lane to maintain pressure and continue farming was the optimal decision. This prevented the enemy bot laner from roaming and ensured Darius continued to scale. When an objective is secured without you and you're far away, always look to apply pressure in your current lane to maximize team advantage. Actionable tip: When far from an objective your team is securing, maintain pressure in your lane to prevent enemy rotations and continue scaling.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "STRUCTURE_18.0_b6410dd4", + "timestamp_minutes": 18.006566666666668, + "event_type": "STRUCTURE", + "impact_score": 825, + "game_state": "mid", + "event_details": { + "structure_type": "TOWER_BUILDING", + "lane": "BOT_LANE", + "destroying_team": "ENEMY_TEAM", + "event_position_x": 13866, + "event_position_y": 4505, + "event_position_lane": "TOP" + }, + "context": { + "gold_difference": 9488, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 13266, + "y": 3751 + }, + "lane": "TOP", + "distance_to_event": 963 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "The enemy team destroyed the bot lane tower at 18 minutes while Darius, positioned top lane, was 963 units away. Given the immediate distance and his Flash availability, Darius should have rotated to assist in defending the tower. Staying top did not maximize the team's advantage, especially since the team was already significantly ahead. In similar situations, always prioritize rotating to defend critical structures, even if it means sacrificing short-term farming, to maintain overall map control and prevent the enemy from gaining significant advantages.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "STRUCTURE_12.0_94eed322", + "timestamp_minutes": 12.004850000000001, + "event_type": "STRUCTURE", + "impact_score": 825, + "game_state": "early", + "event_details": { + "structure_type": "TOWER_BUILDING", + "lane": "TOP_LANE", + "destroying_team": "ENEMY_TEAM", + "event_position_x": 4318, + "event_position_y": 13875, + "event_position_lane": "BOT" + }, + "context": { + "gold_difference": 3646, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 6158, + "y": 8149 + }, + "lane": "TOP", + "distance_to_event": 6014 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "The enemy team destroyed the top lane tower while Darius was 6014 units away, indicating he did not rotate to help. Given the distance and the fact that his team was already significantly ahead in gold, staying in top lane to maintain pressure and continue farming was the optimal decision. This move likely forced the enemy to stay committed to the top lane, preventing them from grouping elsewhere. In similar situations, prioritize maintaining pressure and securing your own resources when you can't effectively rotate to distant objectives or fights.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "STRUCTURE_18.0_8ef7be6f", + "timestamp_minutes": 18.006566666666668, + "event_type": "STRUCTURE", + "impact_score": 825, + "game_state": "mid", + "event_details": { + "structure_type": "TOWER_BUILDING", + "lane": "MID_LANE", + "destroying_team": "ENEMY_TEAM", + "event_position_x": 8955, + "event_position_y": 8510, + "event_position_lane": "TOP" + }, + "context": { + "gold_difference": 9488, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 13266, + "y": 3751 + }, + "lane": "TOP", + "distance_to_event": 6421 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "The enemy team destroyed the mid lane tower at 18 minutes while Darius was in top lane, 6421 units away. Given the distance and the fact that his team was already 9488 gold ahead, staying in top lane to maintain pressure and continue farming was the optimal decision. This choice ensured that the enemy mid laner could not freely roam or take additional objectives. In similar situations, prioritize maintaining pressure in your lane to prevent enemy rotations and secure additional gold and experience, especially when your team holds a significant advantage.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "OBJECTIVE_9.0_143446d5", + "timestamp_minutes": 9.0037, + "event_type": "OBJECTIVE", + "impact_score": 550, + "game_state": "early", + "event_details": { + "objective_type": "HORDE", + "securing_team": "PLAYER_TEAM", + "killer_id": 2, + "event_position_x": 4892, + "event_position_y": 10530, + "event_position_lane": "TOP" + }, + "context": { + "gold_difference": 3248, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 2750, + "y": 11721 + }, + "lane": "BOT", + "distance_to_event": 2450 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "The objective, a Horde, was secured by the player's team in mid lane while Darius was in bot lane, 2450 units away. Given the close distance and the fact that the objective was already secured, Darius made the correct decision to stay in bot lane. By maintaining pressure in bot lane, he prevented the enemy bot laner from rotating to assist in other areas or contest objectives. When an objective is secured without you and you're close but not in position to contribute, prioritize maintaining pressure in your current lane to maximize team advantage.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "OBJECTIVE_9.0_75ca13d2", + "timestamp_minutes": 9.0037, + "event_type": "OBJECTIVE", + "impact_score": 550, + "game_state": "early", + "event_details": { + "objective_type": "HORDE", + "securing_team": "PLAYER_TEAM", + "killer_id": 2, + "event_position_x": 4846, + "event_position_y": 10149, + "event_position_lane": "TOP" + }, + "context": { + "gold_difference": 3248, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 2750, + "y": 11721 + }, + "lane": "BOT", + "distance_to_event": 2620 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "The objective, a Horde, was secured by your team in mid lane at 9 minutes while Darius was in bot lane, 2620 units away. Given the close distance and the fact that Flash was available, Darius should have rotated to assist. Staying in bot lane did not maximize the team's advantage, especially since the team was already significantly ahead. In similar situations, always assess the distance and your summoner spells before deciding whether to rotate; if you can reach the objective in time, prioritize joining to secure additional benefits for your team.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "OBJECTIVE_9.0_99082a4a", + "timestamp_minutes": 9.0037, + "event_type": "OBJECTIVE", + "impact_score": 550, + "game_state": "early", + "event_details": { + "objective_type": "HORDE", + "securing_team": "PLAYER_TEAM", + "killer_id": 2, + "event_position_x": 5147, + "event_position_y": 10339, + "event_position_lane": "TOP" + }, + "context": { + "gold_difference": 3248, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 2750, + "y": 11721 + }, + "lane": "BOT", + "distance_to_event": 2766 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "The objective, a Horde, was secured by the player's team in mid lane while Darius was in bot lane, 2766 units away. Given the close distance and the fact that Flash was available, Darius should have rotated to assist. Staying in bot lane did not maximize the team's advantage, especially since the team was already significantly ahead. Actionable tip: When an objective is secured close to your position and you have Flash available, always rotate to assist, even if it means leaving your current lane, to maximize team advantage and secure additional benefits.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "TEAMFIGHT_17.0_b972433f", + "timestamp_minutes": 17.00603333333333, + "event_type": "TEAMFIGHT", + "impact_score": 200, + "game_state": "mid", + "event_details": { + "kills_count": 5, + "participants_count": 8, + "player_team_kills": 4, + "enemy_team_kills": 1, + "outcome": "WON", + "duration_seconds": 0, + "event_position_x": 7988, + "event_position_y": 9047, + "event_position_lane": "TOP" + }, + "context": { + "player_location": { + "position": { + "x": 7652, + "y": 8435 + }, + "lane": "TOP", + "distance_to_event": 698 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + }, + "gold_difference": 0, + "gold_state": "unknown" + }, + "has_summary": true, + "summary": "Darius was not involved in the mid lane teamfight despite being only 698 units away. Given his immediate proximity and the availability of Flash, he should have rotated to assist. The team was already significantly ahead, so the additional gold swing from the fight would have further solidified their lead. Staying in top lane to farm or push the wave was suboptimal when he could have contributed to securing the kill and maximizing the team's advantage. In similar situations, always prioritize joining fights when you're in close range and have summoner spells available, as this maximizes your team's potential gains.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "TEAMFIGHT_13.0_db64d24c", + "timestamp_minutes": 13.004883333333334, + "event_type": "TEAMFIGHT", + "impact_score": 200, + "game_state": "early", + "event_details": { + "kills_count": 5, + "participants_count": 9, + "player_team_kills": 4, + "enemy_team_kills": 1, + "outcome": "WON", + "duration_seconds": 0, + "event_position_x": 11207, + "event_position_y": 6670, + "event_position_lane": "TOP" + }, + "context": { + "player_location": { + "position": { + "x": 6693, + "y": 12764 + }, + "lane": "TOP", + "distance_to_event": 7583 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + }, + "gold_difference": 0, + "gold_state": "unknown" + }, + "has_summary": true, + "summary": "Darius was not involved in the top river teamfight, which his team won decisively, netting a 900g gold swing. Given the distance (7583 units) and the fact that the fight concluded quickly, staying in top lane to maintain wave pressure and secure CS was the optimal decision. This ensured the enemy top laner couldn't rotate to assist their team. Always prioritize maintaining pressure in your lane when you can't reach a distant fight in time.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "TEAMFIGHT_7.0_d4a7d775", + "timestamp_minutes": 7.002, + "event_type": "TEAMFIGHT", + "impact_score": 200, + "game_state": "early", + "event_details": { + "kills_count": 5, + "participants_count": 9, + "player_team_kills": 4, + "enemy_team_kills": 1, + "outcome": "WON", + "duration_seconds": 0, + "event_position_x": 9017, + "event_position_y": 6987, + "event_position_lane": "BOT" + }, + "context": { + "player_location": { + "position": { + "x": 1698, + "y": 9119 + }, + "lane": "BOT", + "distance_to_event": 7623 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + }, + "gold_difference": 0, + "gold_state": "unknown" + }, + "has_summary": true, + "summary": "Darius was in bot lane during a center teamfight at 7.0 minutes, 7623 units away. Given the distance and the fact that Flash was available, he should have rotated to assist. However, since the fight was very short and already won, staying in bot lane to maintain pressure and secure additional CS might have been the optimal play. In similar situations, always assess the fight's duration and outcome before deciding to rotate; if the fight is quick and decisive, focus on maintaining pressure in your current lane to maximize the team's advantage.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "TEAMFIGHT_18.0_c1a09484", + "timestamp_minutes": 18.006566666666668, + "event_type": "TEAMFIGHT", + "impact_score": 180, + "game_state": "mid", + "event_details": { + "kills_count": 4, + "participants_count": 7, + "player_team_kills": 3, + "enemy_team_kills": 1, + "outcome": "WON", + "duration_seconds": 0, + "event_position_x": 12951, + "event_position_y": 4737, + "event_position_lane": "TOP" + }, + "context": { + "player_location": { + "position": { + "x": 13266, + "y": 3751 + }, + "lane": "TOP", + "distance_to_event": 1035 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + }, + "gold_difference": 0, + "gold_state": "unknown" + }, + "has_summary": true, + "summary": "Darius was not involved in the top river teamfight despite being 1035 units away, which is an immediate distance. Given the short distance and the fact that the fight was won decisively with a 3 kills vs 1 deaths outcome, Darius should have used Flash to join the fight. Staying in top lane did not maximize the team's advantage, especially since the team was already significantly ahead in gold. In similar situations, always prioritize joining fights when you are in immediate distance, as your presence can secure additional kills or objectives, further swinging the game in your team's favor.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "KILL_11.0_95673686", + "timestamp_minutes": 11.00475, + "event_type": "KILL", + "impact_score": 80, + "game_state": "early", + "event_details": { + "killer": "Diana", + "killer_name": "DY lubenwei", + "victim": "Gnar", + "victim_name": "Kev1nMo", + "assistants": [ + "Darius", + "Katarina", + "Soraka" + ], + "shutdown_gold": 268, + "event_position_x": 6044, + "event_position_y": 13874, + "event_position_lane": "TOP", + "player_role": "assistant" + }, + "context": { + "gold_difference": 3360, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 4629, + "y": 13808 + }, + "lane": "BOT", + "distance_to_event": 1416 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "Darius assisted Diana in securing a kill on Gnar in mid lane at 11 minutes, gaining 284 gold. However, by leaving bot lane, Darius sacrificed potential CS and tower plates, which could have further solidified his lead. Given the team's significant gold advantage, the better decision would have been to maintain pressure in bot lane to secure additional plates and CS. After assisting in the kill, Darius should immediately return to bot lane to continue pushing the wave and secure more plates, further extending his and his team's lead.", + "summary_version": "enhanced_v2" + }, + { + "event_id": "KILL_7.0_e502bb24", + "timestamp_minutes": 7.002, + "event_type": "KILL", + "impact_score": 80, + "game_state": "early", + "event_details": { + "killer": "Katarina", + "killer_name": "Goku boy", + "victim": "Pantheon", + "victim_name": "Baal3", + "assistants": [ + "Diana", + "Smolder", + "Soraka" + ], + "shutdown_gold": 300, + "event_position_x": 11021, + "event_position_y": 4513, + "event_position_lane": "TOP", + "player_role": "team_involved" + }, + "context": { + "gold_difference": 2201, + "gold_state": "ahead", + "player_location": { + "position": { + "x": 1698, + "y": 9119 + }, + "lane": "BOT", + "distance_to_event": 10398 + }, + "summoner_spells": { + "flash_cooldown": 0, + "other_cooldown": 0, + "other_spell": "Ghost", + "tp_available": false + } + }, + "has_summary": true, + "summary": "At 7.0 minutes, Darius was in bot lane while a kill occurred on Pantheon by Katarina in the top river, 10398 units away. Given the distance and the fact that his team was already involved in the kill, staying in bot lane was the optimal decision. This allowed Darius to maintain pressure and potentially secure additional farm or tower plates, maximizing the team's overall advantage. In similar situations, always assess the distance and your team's involvement before deciding to rotate; if you're too far and the play is already secured, focus on maintaining pressure in your current lane.", + "summary_version": "enhanced_v2" + } + ], + "total_events": 15 + } + ], + "match_count": 1 +} \ No newline at end of file diff --git a/aws/sagemaker/jobs/processing_resultssadasd.json b/aws/sagemaker/jobs/processing_resultssadasd.json new file mode 100644 index 0000000..5572be7 --- /dev/null +++ b/aws/sagemaker/jobs/processing_resultssadasd.json @@ -0,0 +1,1649 @@ +{ + "puuid": "343DBW7AAURr6TKdf4oaG3C1zEQbW1xYTkKYdjAkn3xVvsQIWe7qljuCLWkPbDDVD02xIuzm1wLRoQ", + "playstyle": { + "region": "Demacia", + "playstyle_score": 85 + }, + "timeline_results": [ + { + "match_id": "NA1_5408317784", + "puuid": "343DBW7AAURr6TKdf4oaG3C1zEQbW1xYTkKYdjAkn3xVvsQIWe7qljuCLWkPbDDVD02xIuzm1wLRoQ", + "events": [ + { + "event_id": "OBJECTIVE_29.0_3c794f91", + "timestamp_minutes": 29.009516666666666, + "event_type": "OBJECTIVE", + "impact_score": 5030, + "game_state": "late", + "event_details": { + "objective_type": "BARON_NASHOR", + "securing_team": "ENEMY_TEAM", + "position": { + "x": 5007, + "y": 10471 + }, + "killer_id": 4 + }, + "context": { + "gold_difference": 1599, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_26.0_ab478be9", + "timestamp_minutes": 26.00865, + "event_type": "TEAMFIGHT", + "impact_score": 2500, + "game_state": "late", + "event_details": { + "kills_count": 5, + "participants_count": 9, + "player_team_kills": 4, + "enemy_team_kills": 1, + "outcome": "WON", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_19.0_03341c42", + "timestamp_minutes": 19.006216666666667, + "event_type": "TEAMFIGHT", + "impact_score": 2500, + "game_state": "mid", + "event_details": { + "kills_count": 5, + "participants_count": 9, + "player_team_kills": 3, + "enemy_team_kills": 2, + "outcome": "WON", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_7.0_27d2af12", + "timestamp_minutes": 7.002683333333334, + "event_type": "TEAMFIGHT", + "impact_score": 2400, + "game_state": "early", + "event_details": { + "kills_count": 4, + "participants_count": 8, + "player_team_kills": 3, + "enemy_team_kills": 1, + "outcome": "WON", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_26.0_88980572", + "timestamp_minutes": 26.00865, + "event_type": "KILL", + "impact_score": 2400, + "game_state": "late", + "event_details": { + "killer": "Viego", + "killer_name": "Dottash", + "victim": "Ambessa", + "victim_name": "ShadowLeaf", + "assistants": [ + "Lissandra", + "Swain", + "MissFortune" + ], + "assistants_count": 3, + "shutdown_gold": 390, + "position": { + "x": 4831, + "y": 6844 + }, + "player_role": "assistant", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 5042, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_18.0_a49d0372", + "timestamp_minutes": 18.006183333333336, + "event_type": "KILL", + "impact_score": 2400, + "game_state": "mid", + "event_details": { + "killer": "Jax", + "killer_name": "Viper3", + "victim": "Lissandra", + "victim_name": "Goop", + "assistants": [ + "Ambessa", + "Galio", + "Jinx", + "Lulu" + ], + "assistants_count": 4, + "shutdown_gold": 360, + "position": { + "x": 9588, + "y": 4696 + }, + "player_role": "victim", + "is_player_team": false, + "is_player_involved": true + }, + "context": { + "gold_difference": 2569, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_29.0_a659465b", + "timestamp_minutes": 29.009516666666666, + "event_type": "TEAMFIGHT", + "impact_score": 2400, + "game_state": "late", + "event_details": { + "kills_count": 4, + "participants_count": 9, + "player_team_kills": 0, + "enemy_team_kills": 4, + "outcome": "LOST", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_29.0_5150e9fc", + "timestamp_minutes": 29.009516666666666, + "event_type": "KILL", + "impact_score": 2400, + "game_state": "late", + "event_details": { + "killer": "Jax", + "killer_name": "Viper3", + "victim": "Lissandra", + "victim_name": "Goop", + "assistants": [ + "Ambessa", + "Galio", + "Jinx", + "Lulu" + ], + "assistants_count": 4, + "shutdown_gold": 400, + "position": { + "x": 4959, + "y": 4988 + }, + "player_role": "victim", + "is_player_team": false, + "is_player_involved": true + }, + "context": { + "gold_difference": 1599, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_24.0_09a6f0b9", + "timestamp_minutes": 24.007633333333334, + "event_type": "KILL", + "impact_score": 2400, + "game_state": "mid", + "event_details": { + "killer": "Viego", + "killer_name": "Dottash", + "victim": "Jax", + "victim_name": "Viper3", + "assistants": [ + "Lissandra", + "Swain", + "MissFortune" + ], + "assistants_count": 3, + "shutdown_gold": 380, + "position": { + "x": 5489, + "y": 6800 + }, + "player_role": "assistant", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 3092, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_29.0_657fe3aa", + "timestamp_minutes": 29.009516666666666, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "late", + "event_details": { + "killer": "Jax", + "killer_name": "Viper3", + "victim": "Viego", + "victim_name": "Dottash", + "assistants": [ + "Galio", + "Jinx", + "Lulu" + ], + "assistants_count": 3, + "shutdown_gold": 400, + "position": { + "x": 5043, + "y": 5589 + }, + "player_role": "observer", + "is_player_team": false, + "is_player_involved": false + }, + "context": { + "gold_difference": 1599, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_18.0_0ceb476d", + "timestamp_minutes": 18.006183333333336, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "mid", + "event_details": { + "killer": "Viego", + "killer_name": "Dottash", + "victim": "Jax", + "victim_name": "Viper3", + "assistants": [ + "DrMundo", + "Swain", + "MissFortune" + ], + "assistants_count": 3, + "shutdown_gold": 350, + "position": { + "x": 9378, + "y": 4445 + }, + "player_role": "team_kill", + "is_player_team": true, + "is_player_involved": false + }, + "context": { + "gold_difference": 2569, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_19.0_83088242", + "timestamp_minutes": 19.006216666666667, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "mid", + "event_details": { + "killer": "Viego", + "killer_name": "Dottash", + "victim": "Galio", + "victim_name": "Muelsyseee", + "assistants": [ + "DrMundo", + "Swain", + "MissFortune" + ], + "assistants_count": 3, + "shutdown_gold": 350, + "position": { + "x": 9675, + "y": 4907 + }, + "player_role": "team_kill", + "is_player_team": true, + "is_player_involved": false + }, + "context": { + "gold_difference": 2754, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_19.0_a70280bd", + "timestamp_minutes": 19.006216666666667, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "mid", + "event_details": { + "killer": "Jinx", + "killer_name": "IolPhriedPickle", + "victim": "Swain", + "victim_name": "Make em Dance", + "assistants": [ + "Ambessa", + "Jax", + "Galio", + "Lulu" + ], + "assistants_count": 4, + "shutdown_gold": 340, + "position": { + "x": 8599, + "y": 5967 + }, + "player_role": "observer", + "is_player_team": false, + "is_player_involved": false + }, + "context": { + "gold_difference": 2754, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_29.0_c874c249", + "timestamp_minutes": 29.009516666666666, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "late", + "event_details": { + "killer": "Jax", + "killer_name": "Viper3", + "victim": "Swain", + "victim_name": "Make em Dance", + "assistants": [ + "Ambessa", + "Galio", + "Jinx", + "Lulu" + ], + "assistants_count": 4, + "shutdown_gold": 380, + "position": { + "x": 4822, + "y": 5195 + }, + "player_role": "observer", + "is_player_team": false, + "is_player_involved": false + }, + "context": { + "gold_difference": 1599, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_6.0_66b1ccf6", + "timestamp_minutes": 6.002583333333333, + "event_type": "TEAMFIGHT", + "impact_score": 2300, + "game_state": "early", + "event_details": { + "kills_count": 3, + "participants_count": 8, + "player_team_kills": 1, + "enemy_team_kills": 2, + "outcome": "LOST", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_27.0_7a5ffa33", + "timestamp_minutes": 27.00906666666667, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "late", + "event_details": { + "killer": "Viego", + "killer_name": "Dottash", + "victim": "Ambessa", + "victim_name": "ShadowLeaf", + "assistants": [ + "Lissandra", + "Swain" + ], + "assistants_count": 2, + "shutdown_gold": 390, + "position": { + "x": 2346, + "y": 2470 + }, + "player_role": "assistant", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 7481, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_25.0_6036d453", + "timestamp_minutes": 25.008166666666668, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "late", + "event_details": { + "killer": "Lissandra", + "killer_name": "Goop", + "victim": "Jinx", + "victim_name": "IolPhriedPickle", + "assistants": [], + "assistants_count": 0, + "shutdown_gold": 360, + "position": { + "x": 14056, + "y": 10557 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 3123, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_26.0_c736ce0e", + "timestamp_minutes": 26.00865, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "late", + "event_details": { + "killer": "Viego", + "killer_name": "Dottash", + "victim": "Galio", + "victim_name": "Muelsyseee", + "assistants": [ + "Lissandra", + "Swain" + ], + "assistants_count": 2, + "shutdown_gold": 370, + "position": { + "x": 5119, + "y": 6072 + }, + "player_role": "assistant", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 5042, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_10.0_499aae77", + "timestamp_minutes": 10.003266666666667, + "event_type": "KILL", + "impact_score": 2050, + "game_state": "early", + "event_details": { + "killer": "DrMundo", + "killer_name": "C\u00f5inflip", + "victim": "Ambessa", + "victim_name": "ShadowLeaf", + "assistants": [], + "assistants_count": 0, + "shutdown_gold": 320, + "position": { + "x": 1921, + "y": 12443 + }, + "player_role": "team_kill", + "is_player_team": true, + "is_player_involved": false + }, + "context": { + "gold_difference": 4578, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_10.0_574b10f8", + "timestamp_minutes": 10.003266666666667, + "event_type": "KILL", + "impact_score": 2050, + "game_state": "early", + "event_details": { + "killer": null, + "killer_name": null, + "victim": "DrMundo", + "victim_name": "C\u00f5inflip", + "assistants": [], + "assistants_count": 0, + "shutdown_gold": 320, + "position": { + "x": 825, + "y": 10452 + }, + "player_role": "observer", + "is_player_team": false, + "is_player_involved": false + }, + "context": { + "gold_difference": 4578, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + } + ], + "total_events": 20 + }, + { + "match_id": "NA1_5408301390", + "puuid": "343DBW7AAURr6TKdf4oaG3C1zEQbW1xYTkKYdjAkn3xVvsQIWe7qljuCLWkPbDDVD02xIuzm1wLRoQ", + "events": [ + { + "event_id": "OBJECTIVE_29.0_43e42660", + "timestamp_minutes": 29.0086, + "event_type": "OBJECTIVE", + "impact_score": 5030, + "game_state": "late", + "event_details": { + "objective_type": "BARON_NASHOR", + "securing_team": "ENEMY_TEAM", + "position": { + "x": 5007, + "y": 10471 + }, + "killer_id": 2 + }, + "context": { + "gold_difference": -4674, + "gold_state": "behind" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_28.0_691a1fde", + "timestamp_minutes": 28.008583333333334, + "event_type": "TEAMFIGHT", + "impact_score": 2500, + "game_state": "late", + "event_details": { + "kills_count": 5, + "participants_count": 8, + "player_team_kills": 1, + "enemy_team_kills": 4, + "outcome": "LOST", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_26.0_3039c396", + "timestamp_minutes": 26.008266666666668, + "event_type": "TEAMFIGHT", + "impact_score": 2500, + "game_state": "late", + "event_details": { + "kills_count": 5, + "participants_count": 9, + "player_team_kills": 2, + "enemy_team_kills": 3, + "outcome": "LOST", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_31.0_9be47245", + "timestamp_minutes": 31.00926666666667, + "event_type": "TEAMFIGHT", + "impact_score": 2500, + "game_state": "late", + "event_details": { + "kills_count": 5, + "participants_count": 9, + "player_team_kills": 1, + "enemy_team_kills": 4, + "outcome": "LOST", + "duration_seconds": 22 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_18.0_98377a50", + "timestamp_minutes": 18.006033333333335, + "event_type": "TEAMFIGHT", + "impact_score": 2400, + "game_state": "mid", + "event_details": { + "kills_count": 4, + "participants_count": 8, + "player_team_kills": 3, + "enemy_team_kills": 1, + "outcome": "WON", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_24.0_9fe492d0", + "timestamp_minutes": 24.007916666666667, + "event_type": "TEAMFIGHT", + "impact_score": 2400, + "game_state": "mid", + "event_details": { + "kills_count": 4, + "participants_count": 7, + "player_team_kills": 1, + "enemy_team_kills": 3, + "outcome": "LOST", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_31.0_37a03051", + "timestamp_minutes": 31.00926666666667, + "event_type": "KILL", + "impact_score": 2400, + "game_state": "late", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "FiddleSticks", + "victim_name": "\u4e09\u5343\u4e16\u754c\u9e26\u6740\u5c3d", + "assistants": [ + "Jayce", + "Zac", + "Soraka" + ], + "assistants_count": 3, + "shutdown_gold": 390, + "position": { + "x": 9754, + "y": 7403 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": -4505, + "gold_state": "behind" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_23.0_7c6b4e6e", + "timestamp_minutes": 23.007566666666666, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "mid", + "event_details": { + "killer": "Soraka", + "killer_name": "InsrtUsername", + "victim": "FiddleSticks", + "victim_name": "\u4e09\u5343\u4e16\u754c\u9e26\u6740\u5c3d", + "assistants": [ + "Jayce", + "Zac", + "Kaisa" + ], + "assistants_count": 3, + "shutdown_gold": 370, + "position": { + "x": 7481, + "y": 4871 + }, + "player_role": "team_kill", + "is_player_team": true, + "is_player_involved": false + }, + "context": { + "gold_difference": -494, + "gold_state": "even" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_21.0_02230dff", + "timestamp_minutes": 21.006899999999998, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "mid", + "event_details": { + "killer": "Viego", + "killer_name": "Dottash", + "victim": "Jayce", + "victim_name": "MaginoongBastos", + "assistants": [ + "FiddleSticks", + "Aurora", + "Jinx", + "Nami" + ], + "assistants_count": 4, + "shutdown_gold": 360, + "position": { + "x": 10042, + "y": 6012 + }, + "player_role": "observer", + "is_player_team": false, + "is_player_involved": false + }, + "context": { + "gold_difference": -436, + "gold_state": "even" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_24.0_299fe777", + "timestamp_minutes": 24.007916666666667, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "mid", + "event_details": { + "killer": "Kaisa", + "killer_name": "Sajecufyne", + "victim": "Viego", + "victim_name": "Dottash", + "assistants": [ + "Jayce", + "Zac", + "Soraka" + ], + "assistants_count": 3, + "shutdown_gold": 380, + "position": { + "x": 4815, + "y": 5377 + }, + "player_role": "team_kill", + "is_player_team": true, + "is_player_involved": false + }, + "context": { + "gold_difference": -1205, + "gold_state": "behind" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_21.0_7ad613a8", + "timestamp_minutes": 21.006899999999998, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "mid", + "event_details": { + "killer": "Jinx", + "killer_name": "DrunkKaraoke", + "victim": "Zac", + "victim_name": "Oojiboo", + "assistants": [ + "FiddleSticks", + "Viego", + "Aurora", + "Nami" + ], + "assistants_count": 4, + "shutdown_gold": 350, + "position": { + "x": 10512, + "y": 5037 + }, + "player_role": "observer", + "is_player_team": false, + "is_player_involved": false + }, + "context": { + "gold_difference": -436, + "gold_state": "even" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_9.0_79703a38", + "timestamp_minutes": 9.003283333333334, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "early", + "event_details": { + "killer": "Aurora", + "killer_name": "Soten", + "victim": "Jayce", + "victim_name": "MaginoongBastos", + "assistants": [ + "FiddleSticks", + "Viego", + "Nami" + ], + "assistants_count": 3, + "shutdown_gold": 310, + "position": { + "x": 3620, + "y": 10428 + }, + "player_role": "observer", + "is_player_team": false, + "is_player_involved": false + }, + "context": { + "gold_difference": -621, + "gold_state": "even" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_26.0_e12958b3", + "timestamp_minutes": 26.008266666666668, + "event_type": "KILL", + "impact_score": 2350, + "game_state": "late", + "event_details": { + "killer": "Viego", + "killer_name": "Dottash", + "victim": "Zac", + "victim_name": "Oojiboo", + "assistants": [ + "FiddleSticks", + "Aurora", + "Nami" + ], + "assistants_count": 3, + "shutdown_gold": 370, + "position": { + "x": 9960, + "y": 7291 + }, + "player_role": "observer", + "is_player_team": false, + "is_player_involved": false + }, + "context": { + "gold_difference": -718, + "gold_state": "even" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_16.0_4abb4a17", + "timestamp_minutes": 16.005383333333334, + "event_type": "TEAMFIGHT", + "impact_score": 2300, + "game_state": "mid", + "event_details": { + "kills_count": 3, + "participants_count": 7, + "player_team_kills": 1, + "enemy_team_kills": 2, + "outcome": "LOST", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_9.0_8cfdf306", + "timestamp_minutes": 9.003283333333334, + "event_type": "TEAMFIGHT", + "impact_score": 2300, + "game_state": "early", + "event_details": { + "kills_count": 3, + "participants_count": 7, + "player_team_kills": 0, + "enemy_team_kills": 3, + "outcome": "LOST", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_21.0_3e901e35", + "timestamp_minutes": 21.006899999999998, + "event_type": "TEAMFIGHT", + "impact_score": 2300, + "game_state": "mid", + "event_details": { + "kills_count": 3, + "participants_count": 8, + "player_team_kills": 0, + "enemy_team_kills": 3, + "outcome": "LOST", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_13.0_1b1c7b60", + "timestamp_minutes": 13.004349999999999, + "event_type": "TEAMFIGHT", + "impact_score": 2300, + "game_state": "early", + "event_details": { + "kills_count": 3, + "participants_count": 7, + "player_team_kills": 1, + "enemy_team_kills": 2, + "outcome": "LOST", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_13.0_dac35ee0", + "timestamp_minutes": 13.004349999999999, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "early", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "FiddleSticks", + "victim_name": "\u4e09\u5343\u4e16\u754c\u9e26\u6740\u5c3d", + "assistants": [ + "Zac", + "Soraka" + ], + "assistants_count": 2, + "shutdown_gold": 330, + "position": { + "x": 6832, + "y": 7051 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": -1225, + "gold_state": "behind" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_13.0_aedcbae0", + "timestamp_minutes": 13.004349999999999, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "early", + "event_details": { + "killer": "Viego", + "killer_name": "Dottash", + "victim": "Katarina", + "victim_name": "Goop", + "assistants": [ + "FiddleSticks" + ], + "assistants_count": 1, + "shutdown_gold": 330, + "position": { + "x": 6977, + "y": 7165 + }, + "player_role": "victim", + "is_player_team": false, + "is_player_involved": true + }, + "context": { + "gold_difference": -1225, + "gold_state": "behind" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_9.0_36e8d0e8", + "timestamp_minutes": 9.003283333333334, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "early", + "event_details": { + "killer": "Viego", + "killer_name": "Dottash", + "victim": "Katarina", + "victim_name": "Goop", + "assistants": [ + "FiddleSticks", + "Aurora" + ], + "assistants_count": 2, + "shutdown_gold": 310, + "position": { + "x": 3211, + "y": 9818 + }, + "player_role": "victim", + "is_player_team": false, + "is_player_involved": true + }, + "context": { + "gold_difference": -621, + "gold_state": "even" + }, + "has_summary": false, + "summary": null + } + ], + "total_events": 20 + }, + { + "match_id": "NA1_5408288432", + "puuid": "343DBW7AAURr6TKdf4oaG3C1zEQbW1xYTkKYdjAkn3xVvsQIWe7qljuCLWkPbDDVD02xIuzm1wLRoQ", + "events": [ + { + "event_id": "OBJECTIVE_28.0_076b48af", + "timestamp_minutes": 28.009166666666665, + "event_type": "OBJECTIVE", + "impact_score": 5050, + "game_state": "late", + "event_details": { + "objective_type": "BARON_NASHOR", + "securing_team": "PLAYER_TEAM", + "position": { + "x": 5007, + "y": 10471 + }, + "killer_id": 2 + }, + "context": { + "gold_difference": 13880, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_24.0_953d77be", + "timestamp_minutes": 24.00785, + "event_type": "TEAMFIGHT", + "impact_score": 2500, + "game_state": "mid", + "event_details": { + "kills_count": 5, + "participants_count": 7, + "player_team_kills": 3, + "enemy_team_kills": 2, + "outcome": "WON", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_22.0_e33e9947", + "timestamp_minutes": 22.007133333333336, + "event_type": "TEAMFIGHT", + "impact_score": 2400, + "game_state": "mid", + "event_details": { + "kills_count": 4, + "participants_count": 8, + "player_team_kills": 2, + "enemy_team_kills": 2, + "outcome": "EVEN", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_28.7_804e0975", + "timestamp_minutes": 28.69108333333333, + "event_type": "KILL", + "impact_score": 2400, + "game_state": "late", + "event_details": { + "killer": "Kayn", + "killer_name": "ITakeYourOrbs", + "victim": "Kennen", + "victim_name": "WINNING MINDSET", + "assistants": [ + "Katarina", + "Twitch", + "Nami" + ], + "assistants_count": 3, + "shutdown_gold": 377, + "position": { + "x": 12362, + "y": 11469 + }, + "player_role": "assistant", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 15057, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_26.0_a91f82a3", + "timestamp_minutes": 26.00845, + "event_type": "KILL", + "impact_score": 2400, + "game_state": "late", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "Naafiri", + "victim_name": "SettlerBart", + "assistants": [ + "Gwen", + "Kayn", + "Twitch", + "Nami" + ], + "assistants_count": 4, + "shutdown_gold": 380, + "position": { + "x": 9954, + "y": 8459 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 8588, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_26.0_4fc25e33", + "timestamp_minutes": 26.00845, + "event_type": "KILL", + "impact_score": 2400, + "game_state": "late", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "Tristana", + "victim_name": "Aerrow", + "assistants": [ + "Gwen", + "Kayn", + "Twitch", + "Nami" + ], + "assistants_count": 4, + "shutdown_gold": 360, + "position": { + "x": 10041, + "y": 7598 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 8588, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_26.0_676dceab", + "timestamp_minutes": 26.00845, + "event_type": "TEAMFIGHT", + "impact_score": 2400, + "game_state": "late", + "event_details": { + "kills_count": 4, + "participants_count": 9, + "player_team_kills": 4, + "enemy_team_kills": 0, + "outcome": "WON", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_10.0_a22abb2e", + "timestamp_minutes": 10.003883333333333, + "event_type": "TEAMFIGHT", + "impact_score": 2300, + "game_state": "early", + "event_details": { + "kills_count": 3, + "participants_count": 7, + "player_team_kills": 3, + "enemy_team_kills": 0, + "outcome": "WON", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_13.0_50877530", + "timestamp_minutes": 13.004683333333332, + "event_type": "TEAMFIGHT", + "impact_score": 2300, + "game_state": "early", + "event_details": { + "kills_count": 3, + "participants_count": 6, + "player_team_kills": 3, + "enemy_team_kills": 0, + "outcome": "WON", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "TEAMFIGHT_3.0_6d32cef6", + "timestamp_minutes": 3.0018666666666665, + "event_type": "TEAMFIGHT", + "impact_score": 2300, + "game_state": "early", + "event_details": { + "kills_count": 3, + "participants_count": 5, + "player_team_kills": 2, + "enemy_team_kills": 1, + "outcome": "WON", + "duration_seconds": 0 + }, + "context": {}, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_24.0_03862c24", + "timestamp_minutes": 24.00785, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "mid", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "Pantheon", + "victim_name": "Riot Act of 1715", + "assistants": [ + "Nami" + ], + "assistants_count": 1, + "shutdown_gold": 350, + "position": { + "x": 10147, + "y": 5425 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 4272, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_22.0_61bac7d3", + "timestamp_minutes": 22.007133333333336, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "mid", + "event_details": { + "killer": "Pantheon", + "killer_name": "Riot Act of 1715", + "victim": "Katarina", + "victim_name": "Goop", + "assistants": [ + "Kennen" + ], + "assistants_count": 1, + "shutdown_gold": 380, + "position": { + "x": 7596, + "y": 13838 + }, + "player_role": "victim", + "is_player_team": false, + "is_player_involved": true + }, + "context": { + "gold_difference": 3181, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_20.0_7ac93488", + "timestamp_minutes": 20.006649999999997, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "mid", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "Viego", + "victim_name": "Dottash", + "assistants": [ + "Kayn" + ], + "assistants_count": 1, + "shutdown_gold": 350, + "position": { + "x": 10172, + "y": 5958 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 5189, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_25.0_24c4c6cf", + "timestamp_minutes": 25.00815, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "late", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "Kennen", + "victim_name": "WINNING MINDSET", + "assistants": [ + "Gwen", + "Kayn" + ], + "assistants_count": 2, + "shutdown_gold": 380, + "position": { + "x": 12686, + "y": 5698 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 4995, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_24.0_b4703124", + "timestamp_minutes": 24.00785, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "mid", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "Viego", + "victim_name": "Dottash", + "assistants": [ + "Nami" + ], + "assistants_count": 1, + "shutdown_gold": 313, + "position": { + "x": 9461, + "y": 5533 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 4272, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_9.0_394e6111", + "timestamp_minutes": 9.003833333333334, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "early", + "event_details": { + "killer": "Kayn", + "killer_name": "ITakeYourOrbs", + "victim": "Kennen", + "victim_name": "WINNING MINDSET", + "assistants": [ + "Gwen", + "Katarina" + ], + "assistants_count": 2, + "shutdown_gold": 320, + "position": { + "x": 1112, + "y": 13482 + }, + "player_role": "assistant", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 98, + "gold_state": "even" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_26.0_9bdc72b9", + "timestamp_minutes": 26.00845, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "late", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "Pantheon", + "victim_name": "Riot Act of 1715", + "assistants": [], + "assistants_count": 0, + "shutdown_gold": 323, + "position": { + "x": 12241, + "y": 8504 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 8588, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_24.0_d82b70f0", + "timestamp_minutes": 24.00785, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "mid", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "Tristana", + "victim_name": "Aerrow", + "assistants": [ + "Nami" + ], + "assistants_count": 1, + "shutdown_gold": 350, + "position": { + "x": 10468, + "y": 5642 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 4272, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_13.0_daa25c20", + "timestamp_minutes": 13.004683333333332, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "early", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "Viego", + "victim_name": "Dottash", + "assistants": [ + "Twitch", + "Nami" + ], + "assistants_count": 2, + "shutdown_gold": 310, + "position": { + "x": 11435, + "y": 1713 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 2834, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + }, + { + "event_id": "KILL_22.0_f61bade8", + "timestamp_minutes": 22.007133333333336, + "event_type": "KILL", + "impact_score": 2100, + "game_state": "mid", + "event_details": { + "killer": "Katarina", + "killer_name": "Goop", + "victim": "Tristana", + "victim_name": "Aerrow", + "assistants": [ + "Twitch" + ], + "assistants_count": 1, + "shutdown_gold": 350, + "position": { + "x": 9471, + "y": 12479 + }, + "player_role": "killer", + "is_player_team": true, + "is_player_involved": true + }, + "context": { + "gold_difference": 3181, + "gold_state": "ahead" + }, + "has_summary": false, + "summary": null + } + ], + "total_events": 20 + } + ], + "match_count": 3 +} \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/diagnosis/check_cloudwatch_logs.py b/aws/sagemaker/jobs/timeline-feature/diagnosis/check_cloudwatch_logs.py new file mode 100644 index 0000000..df2548f --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/diagnosis/check_cloudwatch_logs.py @@ -0,0 +1,116 @@ +# check_cloudwatch_logs.py +""" +Checks CloudWatch logs for Lambda function errors +""" + +import boto3 +from datetime import datetime, timedelta +import time + +logs_client = boto3.client('logs', region_name='us-west-2') + +FUNCTION_NAME = 'lol-timeline-event-processor' +LOG_GROUP = f'/aws/lambda/{FUNCTION_NAME}' + +def get_recent_logs(minutes=10): + """Get recent Lambda logs""" + print(f"Checking CloudWatch logs for last {minutes} minutes...") + + try: + # Get log streams + streams_response = logs_client.describe_log_streams( + logGroupName=LOG_GROUP, + orderBy='LastEventTime', + descending=True, + limit=5 + ) + + if not streams_response.get('logStreams'): + print(f"✗ No log streams found for {LOG_GROUP}") + return + + print(f"\n✓ Found {len(streams_response['logStreams'])} recent log stream(s)\n") + + start_time = int((datetime.utcnow() - timedelta(minutes=minutes)).timestamp() * 1000) + end_time = int(datetime.utcnow().timestamp() * 1000) + + # Get logs from each stream + for stream in streams_response['logStreams'][:3]: # Check top 3 streams + stream_name = stream['logStreamName'] + print(f"{'='*60}") + print(f"Stream: {stream_name}") + print(f"{'='*60}") + + try: + events_response = logs_client.get_log_events( + logGroupName=LOG_GROUP, + logStreamName=stream_name, + startTime=start_time, + endTime=end_time, + limit=100 + ) + + events = events_response.get('events', []) + + if not events: + print("(No recent events)\n") + continue + + # Print all log messages + for event in events: + timestamp = datetime.fromtimestamp(event['timestamp'] / 1000) + message = event['message'].strip() + print(f"[{timestamp.strftime('%H:%M:%S')}] {message}") + + print() + + except Exception as e: + print(f"Error reading stream: {e}\n") + + except logs_client.exceptions.ResourceNotFoundException: + print(f"✗ Log group not found: {LOG_GROUP}") + print("The Lambda function may never have been invoked.") + except Exception as e: + print(f"✗ Error accessing logs: {e}") + + +def search_for_errors(): + """Search for error messages in logs""" + print("\nSearching for errors in logs...") + + try: + start_time = int((datetime.utcnow() - timedelta(minutes=30)).timestamp() * 1000) + + response = logs_client.filter_log_events( + logGroupName=LOG_GROUP, + startTime=start_time, + filterPattern='ERROR', + limit=50 + ) + + errors = response.get('events', []) + + if errors: + print(f"\n✗ Found {len(errors)} error(s):\n") + for event in errors[:10]: # Show first 10 + timestamp = datetime.fromtimestamp(event['timestamp'] / 1000) + print(f"[{timestamp.strftime('%Y-%m-%d %H:%M:%S')}]") + print(f" {event['message']}\n") + else: + print("✓ No errors found in recent logs") + + except Exception as e: + print(f"✗ Error searching logs: {e}") + + +def main(): + print("="*60) + print("CloudWatch Logs Checker") + print("="*60) + + get_recent_logs(minutes=15) + search_for_errors() + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/diagnosis/check_dynamodb_tables.py b/aws/sagemaker/jobs/timeline-feature/diagnosis/check_dynamodb_tables.py new file mode 100644 index 0000000..48fdc11 --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/diagnosis/check_dynamodb_tables.py @@ -0,0 +1,97 @@ +# check_dynamodb_tables.py +""" +Checks if DynamoDB tables exist with correct names +""" + +import boto3 + +dynamodb = boto3.client('dynamodb', region_name='us-west-2') + +EXPECTED_TABLES = [ + 'lol-timeline-timeline-events', + 'lol-timeline-ai-summaries', + 'lol-timeline-user-questions', + 'lol-timeline-player-timeline-metadata' +] + +def check_tables(): + """Check if DynamoDB tables exist""" + print("Checking DynamoDB tables...") + + try: + response = dynamodb.list_tables() + existing_tables = response['TableNames'] + + print(f"\n✓ Found {len(existing_tables)} table(s) in region us-west-2\n") + + all_exist = True + for table_name in EXPECTED_TABLES: + if table_name in existing_tables: + print(f" ✓ {table_name}") + + # Get table details + table_info = dynamodb.describe_table(TableName=table_name) + status = table_info['Table']['TableStatus'] + item_count = table_info['Table']['ItemCount'] + + print(f" Status: {status}, Items: {item_count}") + else: + print(f" ✗ {table_name} - NOT FOUND") + all_exist = False + + if not all_exist: + print("\n⚠ Some tables are missing. Looking for similar names...") + for table in existing_tables: + if 'timeline' in table.lower(): + print(f" Found: {table}") + + return all_exist + + except Exception as e: + print(f"✗ Error checking tables: {e}") + return False + + +def check_table_items(match_id='TEST_MATCH_123'): + """Check if test data exists in tables""" + print(f"\nChecking for test match data (match_id: {match_id})...") + + dynamodb_resource = boto3.resource('dynamodb', region_name='us-west-2') + + for table_name in EXPECTED_TABLES: + if 'events' not in table_name: + continue + + try: + table = dynamodb_resource.Table(table_name) + + # Try to query by match_id + response = table.query( + KeyConditionExpression='match_id = :match_id', + ExpressionAttributeValues={':match_id': match_id}, + Limit=1 + ) + + if response['Items']: + print(f" ✓ {table_name}: Found test data") + else: + print(f" - {table_name}: No test data") + + except Exception as e: + print(f" ✗ {table_name}: Error - {e}") + + +def main(): + print("="*60) + print("DynamoDB Tables Checker") + print("="*60) + + if check_tables(): + print("\n✓ All expected tables exist") + check_table_items() + else: + print("\n✗ Missing tables detected") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/diagnosis/verify_and_reprocess.py b/aws/sagemaker/jobs/timeline-feature/diagnosis/verify_and_reprocess.py new file mode 100644 index 0000000..287877b --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/diagnosis/verify_and_reprocess.py @@ -0,0 +1,314 @@ +# verify_and_reprocess.py +""" +Verifies Lambda deployment and reprocesses matches to get KILL/TEAMFIGHT events +""" + +import boto3 +import json +import time + +lambda_client = boto3.client('lambda', region_name='us-west-2') +dynamodb = boto3.resource('dynamodb', region_name='us-west-2') +s3_client = boto3.client('s3', region_name='us-west-2') + +FUNCTION_NAME = 'lol-timeline-event-processor' +BUCKET_NAME = 'lol-training-matches-150k' + +def check_lambda_code(): + """Check if Lambda has the latest code""" + + print("="*60) + print("Checking Lambda Function Code") + print("="*60) + + try: + response = lambda_client.get_function(FunctionName=FUNCTION_NAME) + + last_modified = response['Configuration']['LastModified'] + code_size = response['Configuration']['CodeSize'] + + print(f"\n✓ Lambda Function: {FUNCTION_NAME}") + print(f" Last Modified: {last_modified}") + print(f" Code Size: {code_size} bytes") + + # The fixed version should have specific logging + # Let's test invoke and check logs + + print(f"\nTesting Lambda invocation to check for event breakdown logging...") + + # Find a test file + response = s3_client.list_objects_v2( + Bucket=BUCKET_NAME, + Prefix='raw-matches/ShadowLeaf_8005/', + MaxKeys=1 + ) + + timeline_key = None + for obj in response.get('Contents', []): + if obj['Key'].endswith('timeline-data.json'): + timeline_key = obj['Key'] + break + + if timeline_key: + event = { + 'Records': [{ + 's3': { + 'bucket': {'name': BUCKET_NAME}, + 'object': {'key': timeline_key} + } + }] + } + + lambda_response = lambda_client.invoke( + FunctionName=FUNCTION_NAME, + InvocationType='RequestResponse', + Payload=json.dumps(event), + LogType='Tail' + ) + + # Check logs for "Event breakdown" + if 'LogResult' in lambda_response: + import base64 + logs = base64.b64decode(lambda_response['LogResult']).decode('utf-8') + + if 'Event breakdown' in logs: + print(f"\n✓ Lambda has the UPDATED code (includes event breakdown logging)") + print(f"\nLog snippet:") + for line in logs.split('\n'): + if 'Event breakdown' in line or 'Extracted' in line: + print(f" {line}") + return True + else: + print(f"\n✗ Lambda has OLD code (missing event breakdown logging)") + print(f"\nLogs:") + print(logs) + return False + + return None + + except Exception as e: + print(f"\n✗ Error checking Lambda: {e}") + return None + + +def clear_old_events(match_ids): + """Delete old events so we can reprocess""" + + print(f"\n{'='*60}") + print("Clearing Old Events from DynamoDB") + print(f"{'='*60}") + + events_table = dynamodb.Table('lol-timeline-timeline-events') + + deleted_count = 0 + for match_id in match_ids: + try: + # Query events for this match + response = events_table.query( + IndexName='match-impact-index', + KeyConditionExpression='match_id = :match_id', + ExpressionAttributeValues={':match_id': match_id} + ) + + items = response.get('Items', []) + + if items: + print(f" Deleting {len(items)} events from {match_id}") + + with events_table.batch_writer() as batch: + for item in items: + batch.delete_item(Key={ + 'match_id': item['match_id'], + 'event_id': item['event_id'] + }) + deleted_count += 1 + + except Exception as e: + print(f" ✗ Error deleting events for {match_id}: {e}") + + print(f"\n✓ Deleted {deleted_count} old events") + + +def reprocess_matches(game_name, tagline, match_ids): + """Reprocess matches with updated Lambda""" + + print(f"\n{'='*60}") + print(f"Reprocessing Matches for {game_name}#{tagline}") + print(f"{'='*60}") + + player_folder = f"{game_name}_{tagline}" + + success_count = 0 + event_breakdown = {'KILL': 0, 'TEAMFIGHT': 0, 'OBJECTIVE': 0, 'STRUCTURE': 0} + + for idx, match_id in enumerate(match_ids, 1): + timeline_key = f"raw-matches/{player_folder}/{match_id}/timeline-data.json" + + print(f"\n[{idx}/{len(match_ids)}] {match_id}") + + event = { + 'Records': [{ + 's3': { + 'bucket': {'name': BUCKET_NAME}, + 'object': {'key': timeline_key} + } + }] + } + + try: + response = lambda_client.invoke( + FunctionName=FUNCTION_NAME, + InvocationType='RequestResponse', + Payload=json.dumps(event), + LogType='Tail' + ) + + payload = json.loads(response['Payload'].read()) + + if payload.get('statusCode') == 200: + body = json.loads(payload.get('body', '{}')) + results = body.get('results', []) + + if results: + events_found = results[0].get('events_found', 0) + print(f" ✓ Extracted {events_found} events") + success_count += 1 + + # Check logs for breakdown + if 'LogResult' in response: + import base64 + logs = base64.b64decode(response['LogResult']).decode('utf-8') + + for line in logs.split('\n'): + if 'Event breakdown' in line: + print(f" {line.strip()}") + # Parse breakdown + try: + breakdown_str = line.split('Event breakdown:')[1].strip() + breakdown = eval(breakdown_str) + for event_type, count in breakdown.items(): + event_breakdown[event_type] = event_breakdown.get(event_type, 0) + count + except: + pass + else: + print(f" ✗ Error: {payload}") + + time.sleep(0.5) + + except Exception as e: + print(f" ✗ Exception: {e}") + + print(f"\n{'='*60}") + print("Reprocessing Complete!") + print(f"{'='*60}") + print(f"Successfully processed: {success_count}/{len(match_ids)}") + print(f"\nEvent Breakdown Across All Matches:") + for event_type, count in sorted(event_breakdown.items(), key=lambda x: x[1], reverse=True): + print(f" {event_type}: {count}") + + +def verify_new_events(match_ids): + """Verify the new events include KILL and TEAMFIGHT""" + + print(f"\n{'='*60}") + print("Verifying New Events in DynamoDB") + print(f"{'='*60}") + + events_table = dynamodb.Table('lol-timeline-timeline-events') + + event_types = {'KILL': 0, 'TEAMFIGHT': 0, 'OBJECTIVE': 0, 'STRUCTURE': 0} + + for match_id in match_ids: + try: + response = events_table.query( + IndexName='match-impact-index', + KeyConditionExpression='match_id = :match_id', + ExpressionAttributeValues={':match_id': match_id} + ) + + items = response.get('Items', []) + + for item in items: + event_type = item.get('event_type') + event_types[event_type] = event_types.get(event_type, 0) + 1 + + except Exception as e: + print(f" ✗ Error querying {match_id}: {e}") + + print(f"\nEvent Types in DynamoDB:") + for event_type, count in sorted(event_types.items(), key=lambda x: x[1], reverse=True): + if count > 0: + print(f" ✓ {event_type}: {count}") + else: + print(f" ✗ {event_type}: {count} (MISSING!)") + + if event_types['KILL'] > 0 and event_types['TEAMFIGHT'] > 0: + print(f"\n✓ SUCCESS! KILL and TEAMFIGHT events are now present!") + return True + else: + print(f"\n✗ Still missing KILL or TEAMFIGHT events") + return False + + +def main(): + print("="*60) + print("Timeline Event Type Verification & Reprocessing") + print("="*60) + + # Step 1: Check if Lambda has updated code + has_updated_code = check_lambda_code() + + if has_updated_code is False: + print("\n⚠ Lambda needs to be updated with the latest code") + print("Run: python fix_event_filtering.py") + return + + # Step 2: Define matches to reprocess + match_ids = [ + 'NA1_5376250054', + 'NA1_5376358183', + 'NA1_5380404735', + 'NA1_5381737611', + 'NA1_5381745546' + ] + + print(f"\n{'='*60}") + print(f"Found {len(match_ids)} matches to reprocess") + print(f"{'='*60}") + + response = input("\nClear old events and reprocess? (y/n): ") + + if response.lower() != 'y': + print("Aborted") + return + + # Step 3: Clear old events + clear_old_events(match_ids) + + # Step 4: Wait a moment + print("\nWaiting 3 seconds...") + time.sleep(3) + + # Step 5: Reprocess matches + reprocess_matches('ShadowLeaf', '8005', match_ids) + + # Step 6: Wait for DynamoDB writes + print("\nWaiting 5 seconds for DynamoDB writes...") + time.sleep(5) + + # Step 7: Verify + success = verify_new_events(match_ids) + + if success: + print("\n🎉 All event types are now present!") + print("\nYou can now:") + print(" 1. Export events from DynamoDB") + print(" 2. Test AI summary generation") + print(" 3. Process all remaining matches") + else: + print("\n⚠ There may be an issue with the Lambda code") + print("Check CloudWatch logs for errors") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/infrastructure/deploy_infrastructure.py b/aws/sagemaker/jobs/timeline-feature/infrastructure/deploy_infrastructure.py new file mode 100644 index 0000000..5545708 --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/infrastructure/deploy_infrastructure.py @@ -0,0 +1,329 @@ +# deploy_infrastructure.py +""" +Sets up all AWS infrastructure for timeline feature +Run this first before deploying Lambda functions +""" + +import boto3 +import json +import time +from botocore.exceptions import ClientError + +# AWS clients +iam = boto3.client('iam') +dynamodb = boto3.client('dynamodb') +s3 = boto3.client('s3') +sns = boto3.client('sns') +stepfunctions = boto3.client('stepfunctions') + +# Configuration +AWS_REGION = 'us-west-2' +AWS_ACCOUNT_ID = '768394660366' +PROJECT_PREFIX = 'lol-timeline' + + +def create_iam_roles(): + """ + Creates IAM roles for Lambda functions and Step Functions + """ + + print("\n=== Creating IAM Roles ===") + + # Lambda execution role + lambda_role_name = f'{PROJECT_PREFIX}-lambda-role' + lambda_trust_policy = { + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Principal": {"Service": "lambda.amazonaws.com"}, + "Action": "sts:AssumeRole" + } + ] + } + + lambda_policy = { + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": [ + "logs:CreateLogGroup", + "logs:CreateLogStream", + "logs:PutLogEvents" + ], + "Resource": "arn:aws:logs:*:*:*" + }, + { + "Effect": "Allow", + "Action": [ + "dynamodb:GetItem", + "dynamodb:PutItem", + "dynamodb:UpdateItem", + "dynamodb:Query", + "dynamodb:Scan" + ], + "Resource": [ + f"arn:aws:dynamodb:{AWS_REGION}:{AWS_ACCOUNT_ID}:table/{PROJECT_PREFIX}-*", + f"arn:aws:dynamodb:{AWS_REGION}:{AWS_ACCOUNT_ID}:table/{PROJECT_PREFIX}-*/index/*" + ] + }, + { + "Effect": "Allow", + "Action": [ + "s3:GetObject", + "s3:PutObject" + ], + "Resource": [ + "arn:aws:s3:::lol-training-matches-150k/*", + "arn:aws:s3:::lol-coach-processed-data/*" + ] + }, + { + "Effect": "Allow", + "Action": [ + "bedrock:InvokeModel" + ], + "Resource": f"arn:aws:bedrock:{AWS_REGION}::foundation-model/anthropic.claude-3-haiku-20240307-v1:0" + }, + { + "Effect": "Allow", + "Action": [ + "states:StartExecution" + ], + "Resource": f"arn:aws:states:{AWS_REGION}:{AWS_ACCOUNT_ID}:stateMachine:{PROJECT_PREFIX}-*" + } + ] + } + + try: + lambda_role = iam.create_role( + RoleName=lambda_role_name, + AssumeRolePolicyDocument=json.dumps(lambda_trust_policy), + Description='Execution role for timeline Lambda functions' + ) + print(f"✓ Created Lambda role: {lambda_role_name}") + + # Attach inline policy + iam.put_role_policy( + RoleName=lambda_role_name, + PolicyName=f'{PROJECT_PREFIX}-lambda-policy', + PolicyDocument=json.dumps(lambda_policy) + ) + print(f"✓ Attached Lambda policy") + + lambda_role_arn = lambda_role['Role']['Arn'] + + except ClientError as e: + if e.response['Error']['Code'] == 'EntityAlreadyExists': + print(f"⚠ Lambda role already exists: {lambda_role_name}") + lambda_role_arn = f"arn:aws:iam::{AWS_ACCOUNT_ID}:role/{lambda_role_name}" + else: + raise + + # Step Functions execution role + sfn_role_name = f'{PROJECT_PREFIX}-stepfunctions-role' + sfn_trust_policy = { + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Principal": {"Service": "states.amazonaws.com"}, + "Action": "sts:AssumeRole" + } + ] + } + + sfn_policy = { + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": [ + "lambda:InvokeFunction" + ], + "Resource": [ + f"arn:aws:lambda:{AWS_REGION}:{AWS_ACCOUNT_ID}:function:{PROJECT_PREFIX}-*" + ] + }, + { + "Effect": "Allow", + "Action": [ + "dynamodb:GetItem", + "dynamodb:PutItem", + "dynamodb:Query" + ], + "Resource": [ + f"arn:aws:dynamodb:{AWS_REGION}:{AWS_ACCOUNT_ID}:table/{PROJECT_PREFIX}-*", + f"arn:aws:dynamodb:{AWS_REGION}:{AWS_ACCOUNT_ID}:table/{PROJECT_PREFIX}-*/index/*" + ] + }, + { + "Effect": "Allow", + "Action": [ + "sns:Publish" + ], + "Resource": f"arn:aws:sns:{AWS_REGION}:{AWS_ACCOUNT_ID}:{PROJECT_PREFIX}-*" + } + ] + } + + try: + sfn_role = iam.create_role( + RoleName=sfn_role_name, + AssumeRolePolicyDocument=json.dumps(sfn_trust_policy), + Description='Execution role for Step Functions workflow' + ) + print(f"✓ Created Step Functions role: {sfn_role_name}") + + iam.put_role_policy( + RoleName=sfn_role_name, + PolicyName=f'{PROJECT_PREFIX}-stepfunctions-policy', + PolicyDocument=json.dumps(sfn_policy) + ) + print(f"✓ Attached Step Functions policy") + + sfn_role_arn = sfn_role['Role']['Arn'] + + except ClientError as e: + if e.response['Error']['Code'] == 'EntityAlreadyExists': + print(f"⚠ Step Functions role already exists: {sfn_role_name}") + sfn_role_arn = f"arn:aws:iam::{AWS_ACCOUNT_ID}:role/{sfn_role_name}" + else: + raise + + # Wait for roles to propagate + print("Waiting for IAM roles to propagate...") + time.sleep(10) + + return lambda_role_arn, sfn_role_arn + + +def create_dynamodb_tables(): + """ + Creates all DynamoDB tables + """ + + print("\n=== Creating DynamoDB Tables ===") + + from dynamodb_schemas import ( + TIMELINE_EVENTS_TABLE, + AI_SUMMARIES_CACHE_TABLE, + USER_QUESTIONS_TABLE, + PLAYER_TIMELINE_METADATA_TABLE + ) + + tables = [ + TIMELINE_EVENTS_TABLE, + AI_SUMMARIES_CACHE_TABLE, + USER_QUESTIONS_TABLE, + PLAYER_TIMELINE_METADATA_TABLE + ] + + for table_config in tables: + try: + table_config['TableName'] = f"{PROJECT_PREFIX}-{table_config['TableName'].replace('lol-', '')}" + + print(f"Creating table: {table_config['TableName']}") + dynamodb.create_table(**table_config) + print(f"✓ Table {table_config['TableName']} created") + + except ClientError as e: + if e.response['Error']['Code'] == 'ResourceInUseException': + print(f"⚠ Table {table_config['TableName']} already exists") + else: + raise + + print("Waiting for tables to become active...") + time.sleep(30) + + +def create_sns_topics(): + """ + Creates SNS topics for notifications + """ + + print("\n=== Creating SNS Topics ===") + + topic_name = f'{PROJECT_PREFIX}-processing-complete' + + try: + response = sns.create_topic(Name=topic_name) + topic_arn = response['TopicArn'] + print(f"✓ Created SNS topic: {topic_name}") + print(f" ARN: {topic_arn}") + + return topic_arn + + except ClientError as e: + print(f"Error creating SNS topic: {str(e)}") + return None + + +def create_s3_event_notifications(): + """ + Configures S3 bucket to trigger Lambda on timeline file uploads + """ + + print("\n=== Configuring S3 Event Notifications ===") + + bucket_name = 'lol-training-matches-150k' + + # Note: This requires the Lambda function to exist first + # This will be configured after Lambda deployment + + print(f"⚠ S3 event notifications must be configured after Lambda deployment") + print(f" Bucket: {bucket_name}") + print(f" Event: s3:ObjectCreated:*") + print(f" Filter: raw-matches/*/*/timeline-data.json") + + +def main(): + """ + Orchestrates infrastructure setup + """ + + print("="*60) + print("LOL Coach Timeline Feature - Infrastructure Setup") + print("="*60) + + # Create IAM roles + lambda_role_arn, sfn_role_arn = create_iam_roles() + + # Create DynamoDB tables + create_dynamodb_tables() + + # Create SNS topics + topic_arn = create_sns_topics() + + # Note about S3 configuration + create_s3_event_notifications() + + # Save configuration + config = { + 'lambda_role_arn': lambda_role_arn, + 'stepfunctions_role_arn': sfn_role_arn, + 'sns_topic_arn': topic_arn, + 'region': AWS_REGION, + 'account_id': AWS_ACCOUNT_ID, + 'project_prefix': PROJECT_PREFIX + } + + with open('infrastructure_config.json', 'w') as f: + json.dump(config, f, indent=2) + + print("\n" + "="*60) + print("Infrastructure Setup Complete!") + print("="*60) + print(f"\nConfiguration saved to: infrastructure_config.json") + print(f"\nLambda Role ARN: {lambda_role_arn}") + print(f"Step Functions Role ARN: {sfn_role_arn}") + print(f"SNS Topic ARN: {topic_arn}") + print("\nNext steps:") + print("1. Deploy Lambda functions: python deploy_lambda_functions.py") + print("2. Create Step Functions state machine: python deploy_step_functions.py") + print("3. Configure S3 event notifications manually or via AWS CLI") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/infrastructure/deploy_lambda_functions.py b/aws/sagemaker/jobs/timeline-feature/infrastructure/deploy_lambda_functions.py new file mode 100644 index 0000000..3313c8a --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/infrastructure/deploy_lambda_functions.py @@ -0,0 +1,439 @@ +""" +Packages and deploys all Lambda functions for timeline feature +""" + +import boto3 +import json +import zipfile +import os +import shutil +import subprocess +from pathlib import Path + +# --- Path Configuration --- +SCRIPT_DIR = Path(__file__).resolve().parent +PROJECT_ROOT = SCRIPT_DIR.parent +# --- + +lambda_client = boto3.client('lambda') +apigateway = boto3.client('apigatewayv2') + +# Load infrastructure config +config_path = 'infrastructure_config.json' +with open(config_path, 'r') as f: + config = json.load(f) + +LAMBDA_ROLE_ARN = config['lambda_role_arn'] +PROJECT_PREFIX = config['project_prefix'] +AWS_REGION = config['region'] +AWS_ACCOUNT_ID = config['account_id'] + + +def package_lambda(function_dir: Path, output_zip: Path, requirements: list = None): + """ + Packages Lambda function code with dependencies + + MODIFIED: Type hints changed to Path for clarity + """ + + print(f"Packaging {function_dir.name}...") + temp_dir = f'/tmp/{function_dir.name}_package' + if os.path.exists(temp_dir): + shutil.rmtree(temp_dir) + os.makedirs(temp_dir) + + # Copy function code + for file in os.listdir(function_dir): + if file.endswith('.py'): + # MODIFIED: Use Path objects for copying + shutil.copy(function_dir / file, temp_dir) + + # Install dependencies if specified + if requirements: + print(f" Installing dependencies: {', '.join(requirements)}") + subprocess.run([ + 'pip', 'install', + '-t', temp_dir, + '--upgrade' + ] + requirements, check=True) + + # Create zip file + with zipfile.ZipFile(output_zip, 'w', zipfile.ZIP_DEFLATED) as zipf: + for root, dirs, files in os.walk(temp_dir): + for file in files: + file_path = os.path.join(root, file) + arcname = os.path.relpath(file_path, temp_dir) + zipf.write(file_path, arcname) + + # Cleanup + shutil.rmtree(temp_dir) + + print(f" ✓ Created {output_zip}") + return output_zip + + +def deploy_lambda_function(function_name: str, zip_file: Path, + handler: str, memory: int = 512, + timeout: int = 60, env_vars: dict = None): + """ + Deploys or updates Lambda function + """ + + print(f"Deploying Lambda function: {function_name}") + + with open(zip_file, 'rb') as f: + zip_content = f.read() + + environment = {'Variables': env_vars} if env_vars else {'Variables': {}} + + try: + # Try to update existing function + lambda_client.update_function_code( + FunctionName=function_name, + ZipFile=zip_content + ) + print(f" ✓ Updated function code") + + # Wait for the code update to complete before updating the config + print(f" Waiting for code update to finalize...") + code_waiter = lambda_client.get_waiter('function_updated') + code_waiter.wait( + FunctionName=function_name, + WaiterConfig={'Delay': 5, 'MaxAttempts': 60} # Poll every 5s, max 5 mins + ) + print(f" ✓ Code update complete") + + # Now, update the configuration + config_response = lambda_client.update_function_configuration( + FunctionName=function_name, + Role=LAMBDA_ROLE_ARN, + Handler=handler, + Runtime='python3.11', + Timeout=timeout, + MemorySize=memory, + Environment=environment + ) + print(f" ✓ Updated function configuration") + + # Wait for the configuration update to complete + print(f" Waiting for config update to finalize...") + config_waiter = lambda_client.get_waiter('function_updated') + config_waiter.wait( + FunctionName=function_name, + WaiterConfig={'Delay': 5, 'MaxAttempts': 60} # Poll every 5s, max 5 mins + ) + print(f" ✓ Config update complete") + + return config_response['FunctionArn'] + + except lambda_client.exceptions.ResourceNotFoundException: + # Create new function + response = lambda_client.create_function( + FunctionName=function_name, + Runtime='python3.11', + Role=LAMBDA_ROLE_ARN, + Handler=handler, + Code={'ZipFile': zip_content}, + Timeout=timeout, + MemorySize=memory, + Environment=environment, + Tags={ + 'Project': 'LOL-Coach', + 'Component': 'Timeline-Feature' + } + ) + print(f" ✓ Created new function") + + # Wait for the new function to become active + print(f" Waiting for function to become active...") + active_waiter = lambda_client.get_waiter('function_active') + active_waiter.wait( + FunctionName=function_name, + WaiterConfig={'Delay': 5, 'MaxAttempts': 60} # Poll every 5s, max 5 mins + ) + print(f" ✓ Function is active") + + return response['FunctionArn'] + + except Exception as e: + print(f" ✗ Error deploying {function_name}: {str(e)}") + raise e + + +def deploy_all_lambdas(): + """ + Deploys all Lambda functions + """ + + print("\n=== Deploying Lambda Functions ===\n") + + deployed_functions = {} + + # 1. Timeline Event Processor + zip_file = package_lambda( + PROJECT_ROOT / 'lambda_timeline_processor', + PROJECT_ROOT / 'lambda_timeline_processor.zip', + requirements=['boto3'] + ) + + function_arn = deploy_lambda_function( + function_name=f'{PROJECT_PREFIX}-event-processor', + zip_file=zip_file, + handler='lambda_function.lambda_handler', + memory=1024, + timeout=300, + env_vars={ + 'EVENTS_TABLE_NAME': f'{PROJECT_PREFIX}-timeline-events', + 'METADATA_TABLE_NAME': f'{PROJECT_PREFIX}-player-timeline-metadata' + } + ) + deployed_functions['event_processor'] = function_arn + + # 2. Bedrock Summary Generator + zip_file = package_lambda( + PROJECT_ROOT / 'lambda_bedrock_summary_generator', + PROJECT_ROOT / 'lambda_bedrock_summary_generator.zip', + requirements=['boto3'] + ) + + function_arn = deploy_lambda_function( + function_name=f'{PROJECT_PREFIX}-summary-generator', + zip_file=zip_file, + handler='lambda_function.lambda_handler', + memory=512, + timeout=120 + ) + deployed_functions['summary_generator'] = function_arn + + # 3. API Handler + zip_file = package_lambda( + PROJECT_ROOT / 'lambda_api_timeline_handler', + PROJECT_ROOT / 'lambda_api_handler.zip', + requirements=['boto3'] + ) + + function_arn = deploy_lambda_function( + function_name=f'{PROJECT_PREFIX}-api-handler', + zip_file=zip_file, + handler='lambda_function.lambda_handler', + memory=512, + timeout=30, + env_vars={ + 'STEP_FUNCTIONS_ARN': 'TO_BE_UPDATED', + 'EVENTS_TABLE_NAME': f'{PROJECT_PREFIX}-timeline-events', + 'METADATA_TABLE_NAME': f'{PROJECT_PREFIX}-player-timeline-metadata', + 'SUMMARIES_TABLE_NAME': f'{PROJECT_PREFIX}-timeline-ai-summaries', + 'QUESTIONS_TABLE_NAME': f'{PROJECT_PREFIX}-timeline-user-questions' + } + ) + deployed_functions['api_handler'] = function_arn + + return deployed_functions + + +def create_api_gateway(api_handler_arn: str): + """ + Creates HTTP API Gateway for timeline endpoints + """ + + print("\n=== Creating API Gateway ===\n") + + api_name = f'{PROJECT_PREFIX}-api' + + # Create API + try: + api = apigateway.create_api( + Name=api_name, + ProtocolType='HTTP', + Description='Timeline feature API endpoints', + CorsConfiguration={ + 'AllowOrigins': ['*'], + 'AllowMethods': ['GET', 'POST', 'OPTIONS'], + 'AllowHeaders': ['Content-Type', 'Authorization'], + 'MaxAge': 300 + } + ) + api_id = api['ApiId'] + print(f"✓ Created API: {api_name}") + print(f" API ID: {api_id}") + + except apigateway.exceptions.ConflictException: + # API already exists, get its ID + apis = apigateway.get_apis() + api_id = next((a['ApiId'] for a in apis['Items'] if a['Name'] == api_name), None) + print(f"⚠ API already exists: {api_name}") + + # Create Lambda integration + integration = apigateway.create_integration( + ApiId=api_id, + IntegrationType='AWS_PROXY', + IntegrationUri=api_handler_arn, + PayloadFormatVersion='2.0' + ) + integration_id = integration['IntegrationId'] + print(f"✓ Created Lambda integration") + + # Create routes + routes = [ + ('GET', '/timeline/events'), + ('POST', '/timeline/events/summary'), + ('POST', '/timeline/ask'), + ('GET', '/timeline/player/matches'), + ('POST', '/timeline/batch-process') + ] + + for method, path in routes: + try: + route = apigateway.create_route( + ApiId=api_id, + RouteKey=f'{method} {path}', + Target=f'integrations/{integration_id}' + ) + print(f" ✓ Created route: {method} {path}") + except Exception as e: + print(f" ⚠ Route may already exist: {method} {path}") + + # Create default stage + try: + stage = apigateway.create_stage( + ApiId=api_id, + StageName='$default', + AutoDeploy=True + ) + print(f"✓ Created stage: $default") + except Exception as e: + print(f"⚠ Stage may already exist") + + # Get API endpoint + api_endpoint = f"https://{api_id}.execute-api.{AWS_REGION}.amazonaws.com" + print(f"\n✓ API Gateway endpoint: {api_endpoint}") + + # Grant API Gateway permission to invoke Lambda + try: + lambda_client.remove_permission( + FunctionName=f'{PROJECT_PREFIX}-api-handler', + StatementId='AllowAPIGatewayInvoke' + ) + print(f"✓ Removed old/stale API Gateway permission") + except lambda_client.exceptions.ResourceNotFoundException: + # This is fine, it just means no permission existed + print(f" No old permission found, skipping removal.") + except Exception as e: + print(f"⚠ Warning: Could not remove old permission: {str(e)}") + + # Now, add the new, correct permission + try: + lambda_client.add_permission( + FunctionName=f'{PROJECT_PREFIX}-api-handler', + StatementId='AllowAPIGatewayInvoke', + Action='lambda:InvokeFunction', + Principal='apigateway.amazonaws.com', + SourceArn=f"arn:aws:execute-api:{AWS_REGION}:{AWS_ACCOUNT_ID}:{api_id}/*/*" + ) + print(f"✓ Granted new API Gateway invocation permission") + except lambda_client.exceptions.ResourceConflictException: + print(f"⚠ Permission already exists (conflict)") + + return api_endpoint + + +def configure_s3_trigger(function_arn: str): + """ + Configures S3 to trigger Lambda on timeline file uploads + """ + + print("\n=== Configuring S3 Trigger ===\n") + + bucket_name = 'lol-training-matches-150k' + + # Grant S3 permission to invoke Lambda + try: + lambda_client.add_permission( + FunctionName=f'{PROJECT_PREFIX}-event-processor', + StatementId='AllowS3Invoke', + Action='lambda:InvokeFunction', + Principal='s3.amazonaws.com', + SourceArn=f'arn:aws:s3:::{bucket_name}' + ) + print(f"✓ Granted S3 invocation permission") + except lambda_client.exceptions.ResourceConflictException: + print(f"⚠ Permission already exists") + + # Configure S3 notification + s3 = boto3.client('s3') + + notification_config = { + 'LambdaFunctionConfigurations': [ + { + 'Id': f'{PROJECT_PREFIX}-timeline-upload', + 'LambdaFunctionArn': function_arn, + 'Events': ['s3:ObjectCreated:*'], + 'Filter': { + 'Key': { + 'FilterRules': [ + {'Name': 'suffix', 'Value': 'timeline-data.json'} + ] + } + } + } + ] + } + + try: + s3.put_bucket_notification_configuration( + Bucket=bucket_name, + NotificationConfiguration=notification_config + ) + print(f"✓ Configured S3 bucket notification") + print(f" Bucket: {bucket_name}") + print(f" Trigger: timeline-data.json uploads") + except Exception as e: + print(f"⚠ Error configuring S3 notification: {str(e)}") + print(f" You may need to configure this manually in the AWS Console") + + +def main(): + """ + Orchestrates Lambda deployment + """ + + print("="*60) + print("LOL Coach Timeline Feature - Lambda Deployment") + print("="*60) + + # Deploy all Lambda functions + deployed_functions = deploy_all_lambdas() + + # Create API Gateway + api_endpoint = create_api_gateway(deployed_functions['api_handler']) + + # Configure S3 trigger + configure_s3_trigger(deployed_functions['event_processor']) + + # Save deployment info + deployment_info = { + 'functions': deployed_functions, + 'api_endpoint': api_endpoint, + 'deployed_at': str(boto3.client('sts').get_caller_identity()) + } + + # MODIFIED: Write the output file to the project root + output_info_path = PROJECT_ROOT / 'lambda_deployment_info.json' + with open(output_info_path, 'w') as f: + json.dump(deployment_info, f, indent=2) + + print("\n" + "="*60) + print("Lambda Deployment Complete!") + print("="*60) + print(f"\nAPI Endpoint: {api_endpoint}") + print(f"\nDeployed Functions:") + for name, arn in deployed_functions.items(): + print(f" {name}: {arn}") + # MODIFIED: Use absolute path in log + print(f"\nDeployment info saved to: {output_info_path}") + print("\nNext step: Deploy Step Functions workflow") + print(f" python {SCRIPT_DIR / 'deploy_step_functions.py'}") # MODIFIED: Show correct next command + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/infrastructure/deploy_step_functions.py b/aws/sagemaker/jobs/timeline-feature/infrastructure/deploy_step_functions.py new file mode 100644 index 0000000..2c3e41f --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/infrastructure/deploy_step_functions.py @@ -0,0 +1,155 @@ +# deploy_step_functions.py +""" +Creates and deploys Step Functions state machine for batch processing +""" + +import boto3 +import json + +stepfunctions = boto3.client('stepfunctions') +lambda_client = boto3.client('lambda') + +# Load configurations +with open('infrastructure_config.json', 'r') as f: + infra_config = json.load(f) + +with open('lambda_deployment_info.json', 'r') as f: + lambda_info = json.load(f) + +PROJECT_PREFIX = infra_config['project_prefix'] +SFN_ROLE_ARN = infra_config['stepfunctions_role_arn'] +AWS_REGION = infra_config['region'] +AWS_ACCOUNT_ID = infra_config['account_id'] + + +def create_state_machine(): + """ + Creates Step Functions state machine + """ + + print("\n=== Creating Step Functions State Machine ===\n") + + state_machine_name = f'{PROJECT_PREFIX}-batch-processor' + + # Load state machine definition + with open('step_functions_definition.json', 'r') as f: + definition = json.load(f) + + # Replace placeholders with actual ARNs + definition_str = json.dumps(definition) + definition_str = definition_str.replace( + '"FunctionName": "timeline-event-processor"', + f'"FunctionName": "{PROJECT_PREFIX}-event-processor"' + ) + definition_str = definition_str.replace( + '"FunctionName": "bedrock-summary-generator"', + f'"FunctionName": "{PROJECT_PREFIX}-summary-generator"' + ) + definition_str = definition_str.replace( + '"TableName": "lol-timeline-events"', + f'"TableName": "{PROJECT_PREFIX}-timeline-events"' + ) + definition_str = definition_str.replace( + '"TableName": "lol-player-timeline-metadata"', + f'"TableName": "{PROJECT_PREFIX}-player-timeline-metadata"' + ) + definition_str = definition_str.replace( + '"TopicArn": "arn:aws:sns:us-west-2:768394660366:timeline-processing-complete"', + f'"TopicArn": "{infra_config["sns_topic_arn"]}"' + ) + + definition = json.loads(definition_str) + + try: + # Try to create new state machine + response = stepfunctions.create_state_machine( + name=state_machine_name, + definition=json.dumps(definition), + roleArn=SFN_ROLE_ARN, + type='STANDARD', + tags=[ + {'key': 'Project', 'value': 'LOL-Coach'}, + {'key': 'Component', 'value': 'Timeline-Batch-Processing'} + ] + ) + + state_machine_arn = response['stateMachineArn'] + print(f"✓ Created state machine: {state_machine_name}") + print(f" ARN: {state_machine_arn}") + + except stepfunctions.exceptions.StateMachineAlreadyExists: + # Update existing state machine + state_machine_arn = f"arn:aws:states:{AWS_REGION}:{AWS_ACCOUNT_ID}:stateMachine:{state_machine_name}" + + response = stepfunctions.update_state_machine( + stateMachineArn=state_machine_arn, + definition=json.dumps(definition), + roleArn=SFN_ROLE_ARN + ) + + print(f"✓ Updated existing state machine: {state_machine_name}") + print(f" ARN: {state_machine_arn}") + + return state_machine_arn + + +def update_api_lambda_with_sfn_arn(state_machine_arn: str): + """ + Updates API Lambda function with Step Functions ARN + """ + + print("\n=== Updating API Lambda Configuration ===\n") + + function_name = f'{PROJECT_PREFIX}-api-handler' + + lambda_client.update_function_configuration( + FunctionName=function_name, + Environment={ + 'Variables': { + 'STEP_FUNCTIONS_ARN': state_machine_arn + } + } + ) + + print(f"✓ Updated {function_name} with Step Functions ARN") + + +def main(): + """ + Orchestrates Step Functions deployment + """ + + print("="*60) + print("LOL Coach Timeline Feature - Step Functions Deployment") + print("="*60) + + # Create state machine + state_machine_arn = create_state_machine() + + # Update API Lambda with Step Functions ARN + update_api_lambda_with_sfn_arn(state_machine_arn) + + # Save deployment info + deployment_info = { + 'state_machine_arn': state_machine_arn, + 'state_machine_name': f'{PROJECT_PREFIX}-batch-processor', + 'deployed_at': boto3.client('sts').get_caller_identity() + } + + with open('stepfunctions_deployment_info.json', 'w') as f: + json.dump(deployment_info, f, indent=2) + + print("\n" + "="*60) + print("Step Functions Deployment Complete!") + print("="*60) + print(f"\nState Machine ARN: {state_machine_arn}") + print(f"\nDeployment info saved to: stepfunctions_deployment_info.json") + print("\n✓ All infrastructure deployed successfully!") + print("\nYou can now:") + print("1. Test the API endpoints") + print("2. Upload timeline-data.json files to S3 to trigger processing") + print("3. Use the batch processing API to process multiple matches") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/infrastructure/dynamodb_schemas.py b/aws/sagemaker/jobs/timeline-feature/infrastructure/dynamodb_schemas.py new file mode 100644 index 0000000..c647a54 --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/infrastructure/dynamodb_schemas.py @@ -0,0 +1,205 @@ +""" +DynamoDB table definitions for timeline feature caching +""" +import boto3 +import time + +TIMELINE_EVENTS_TABLE = { + 'TableName': 'lol-timeline-events', + 'KeySchema': [ + {'AttributeName': 'match_id', 'KeyType': 'HASH'}, # Partition key + {'AttributeName': 'event_id', 'KeyType': 'RANGE'} # Sort key + ], + 'AttributeDefinitions': [ + {'AttributeName': 'match_id', 'AttributeType': 'S'}, + {'AttributeName': 'event_id', 'AttributeType': 'S'}, + {'AttributeName': 'puuid', 'AttributeType': 'S'}, + {'AttributeName': 'timestamp_minutes', 'AttributeType': 'N'}, + {'AttributeName': 'impact_score', 'AttributeType': 'N'} + ], + 'GlobalSecondaryIndexes': [ + { + 'IndexName': 'puuid-timestamp-index', + 'KeySchema': [ + {'AttributeName': 'puuid', 'KeyType': 'HASH'}, + {'AttributeName': 'timestamp_minutes', 'KeyType': 'RANGE'} + ], + 'Projection': {'ProjectionType': 'ALL'}, + # ProvisionedThroughput removed + }, + { + 'IndexName': 'match-impact-index', + 'KeySchema': [ + {'AttributeName': 'match_id', 'KeyType': 'HASH'}, + {'AttributeName': 'impact_score', 'KeyType': 'RANGE'} + ], + 'Projection': {'ProjectionType': 'ALL'}, + # ProvisionedThroughput removed + } + ], + 'BillingMode': 'PAY_PER_REQUEST', + 'Tags': [ + {'Key': 'Project', 'Value': 'LOL-Coach'}, + {'Key': 'Component', 'Value': 'Timeline-Events'} + ] +} + +AI_SUMMARIES_CACHE_TABLE = { + 'TableName': 'lol-timeline-ai-summaries', + 'KeySchema': [ + {'AttributeName': 'event_id', 'KeyType': 'HASH'}, # Partition key + {'AttributeName': 'summary_type', 'KeyType': 'RANGE'} # Sort key (basic/detailed) + ], + 'AttributeDefinitions': [ + {'AttributeName': 'event_id', 'AttributeType': 'S'}, + {'AttributeName': 'summary_type', 'AttributeType': 'S'}, + {'AttributeName': 'match_id', 'AttributeType': 'S'}, + ], + 'GlobalSecondaryIndexes': [ + { + 'IndexName': 'match-summaries-index', + 'KeySchema': [ + {'AttributeName': 'match_id', 'KeyType': 'HASH'} + ], + 'Projection': {'ProjectionType': 'ALL'}, + # ProvisionedThroughput removed + } + ], + # TimeToLiveSpecification removed from create_table definition + 'BillingMode': 'PAY_PER_REQUEST', + 'Tags': [ + {'Key': 'Project', 'Value': 'LOL-Coach'}, + {'Key': 'Component', 'Value': 'AI-Summaries-Cache'} + ] +} + +USER_QUESTIONS_TABLE = { + 'TableName': 'lol-timeline-user-questions', + 'KeySchema': [ + {'AttributeName': 'question_id', 'KeyType': 'HASH'}, + ], + 'AttributeDefinitions': [ + {'AttributeName': 'question_id', 'AttributeType': 'S'}, + {'AttributeName': 'event_id', 'AttributeType': 'S'}, + {'AttributeName': 'puuid', 'AttributeType': 'S'}, + ], + 'GlobalSecondaryIndexes': [ + { + 'IndexName': 'event-questions-index', + 'KeySchema': [ + {'AttributeName': 'event_id', 'KeyType': 'HASH'} + ], + 'Projection': {'ProjectionType': 'ALL'}, + # ProvisionedThroughput removed + }, + { + 'IndexName': 'user-questions-index', + 'KeySchema': [ + {'AttributeName': 'puuid', 'KeyType': 'HASH'} + ], + 'Projection': {'ProjectionType': 'ALL'}, + # ProvisionedThroughput removed + } + ], + # TimeToLiveSpecification removed from create_table definition + 'BillingMode': 'PAY_PER_REQUEST', + 'Tags': [ + {'Key': 'Project', 'Value': 'LOL-Coach'}, + {'Key': 'Component', 'Value': 'User-Questions'} + ] +} + +PLAYER_TIMELINE_METADATA_TABLE = { + 'TableName': 'lol-player-timeline-metadata', + 'KeySchema': [ + {'AttributeName': 'puuid', 'KeyType': 'HASH'}, + {'AttributeName': 'match_id', 'KeyType': 'RANGE'} + ], + 'AttributeDefinitions': [ + {'AttributeName': 'puuid', 'AttributeType': 'S'}, + {'AttributeName': 'match_id', 'AttributeType': 'S'}, + {'AttributeName': 'processed_timestamp', 'AttributeType': 'N'} + ], + 'GlobalSecondaryIndexes': [ + { + 'IndexName': 'processed-timestamp-index', + 'KeySchema': [ + {'AttributeName': 'puuid', 'KeyType': 'HASH'}, + {'AttributeName': 'processed_timestamp', 'KeyType': 'RANGE'} + ], + 'Projection': {'ProjectionType': 'ALL'}, + # ProvisionedThroughput removed + } + ], + 'BillingMode': 'PAY_PER_REQUEST', + 'Tags': [ + {'Key': 'Project', 'Value': 'LOL-Coach'}, + {'Key': 'Component', 'Value': 'Timeline-Metadata'} + ] +} + +# --- Create Tables Script (Corrected) --- + +def create_dynamodb_tables(): + """ + Creates all required DynamoDB tables and applies TTL settings. + """ + dynamodb = boto3.client('dynamodb', region_name='us-east-1') + waiter = dynamodb.get_waiter('table_exists') + + tables = [ + TIMELINE_EVENTS_TABLE, + AI_SUMMARIES_CACHE_TABLE, + USER_QUESTIONS_TABLE, + PLAYER_TIMELINE_METADATA_TABLE + ] + + # Define TTL settings separately + ttl_settings = { + 'lol-timeline-ai-summaries': 'ttl', + 'lol-timeline-user-questions': 'ttl' + } + + for table_config in tables: + table_name = table_config['TableName'] + try: + print(f"Creating table: {table_name}") + dynamodb.create_table(**table_config) + print(f"Waiting for {table_name} to become active...") + waiter.wait(TableName=table_name) + print(f"✓ Table {table_name} created successfully") + + # After table is active, check if it needs TTL + if table_name in ttl_settings: + print(f"Applying TTL settings to {table_name}...") + dynamodb.update_time_to_live( + TableName=table_name, + TimeToLiveSpecification={ + 'Enabled': True, + 'AttributeName': ttl_settings[table_name] + } + ) + print(f"✓ TTL enabled for {table_name}") + + except dynamodb.exceptions.ResourceInUseException: + print(f"⚠ Table {table_name} already exists") + # Check if TTL needs to be applied to existing table + try: + if table_name in ttl_settings: + print(f"Verifying/Applying TTL settings to existing table {table_name}...") + dynamodb.update_time_to_live( + TableName=table_name, + TimeToLiveSpecification={ + 'Enabled': True, + 'AttributeName': ttl_settings[table_name] + } + ) + print(f"✓ TTL verified/enabled for {table_name}") + except Exception as ttl_e: + print(f"✗ Error updating TTL for existing table {table_name}: {str(ttl_e)}") + + except Exception as e: + print(f"✗ Error creating {table_name}: {str(e)}") + +if __name__ == "__main__": + create_dynamodb_tables() \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/infrastructure/infrastructure_config.json b/aws/sagemaker/jobs/timeline-feature/infrastructure/infrastructure_config.json new file mode 100644 index 0000000..4240f23 --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/infrastructure/infrastructure_config.json @@ -0,0 +1,8 @@ +{ + "lambda_role_arn": "arn:aws:iam::768394660366:role/lol-timeline-lambda-role", + "stepfunctions_role_arn": "arn:aws:iam::768394660366:role/lol-timeline-stepfunctions-role", + "sns_topic_arn": "arn:aws:sns:us-west-2:768394660366:lol-timeline-processing-complete", + "region": "us-west-2", + "account_id": "768394660366", + "project_prefix": "lol-timeline" +} \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/infrastructure/lambda_deployment_info.json b/aws/sagemaker/jobs/timeline-feature/infrastructure/lambda_deployment_info.json new file mode 100644 index 0000000..ac404c4 --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/infrastructure/lambda_deployment_info.json @@ -0,0 +1,9 @@ +{ + "functions": { + "event_processor": "arn:aws:lambda:us-west-2:768394660366:function:lol-timeline-event-processor", + "summary_generator": "arn:aws:lambda:us-west-2:768394660366:function:lol-timeline-summary-generator", + "api_handler": "arn:aws:lambda:us-west-2:768394660366:function:lol-timeline-api-handler" + }, + "api_endpoint": "https://hsigypkqh1.execute-api.us-west-2.amazonaws.com", + "deployed_at": "{'UserId': 'AROA3FZ7EBIHE3B3URJFY:SageMaker', 'Account': '768394660366', 'Arn': 'arn:aws:sts::768394660366:assumed-role/datazone_usr_role_5i1vmxossv3f2o_b1rxf3f1mnfnv4/SageMaker', 'ResponseMetadata': {'RequestId': '8182499a-6cc9-4692-8581-8051b431b0c0', 'HTTPStatusCode': 200, 'HTTPHeaders': {'x-amzn-requestid': '8182499a-6cc9-4692-8581-8051b431b0c0', 'x-amz-sts-extended-request-id': 'MTp1cy1lYXN0LTE6MTc2MjQwMTM1MjM2MTpHOnY2dzc4NWcy', 'content-type': 'text/xml', 'content-length': '472', 'date': 'Thu, 06 Nov 2025 03:55:52 GMT'}, 'RetryAttempts': 0}}" +} \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/infrastructure/step_functions_definition.json b/aws/sagemaker/jobs/timeline-feature/infrastructure/step_functions_definition.json new file mode 100644 index 0000000..c2ea73a --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/infrastructure/step_functions_definition.json @@ -0,0 +1,218 @@ +{ + "Comment": "Timeline Feature Batch Processing Workflow", + "StartAt": "ValidateInput", + "States": { + "ValidateInput": { + "Type": "Pass", + "Parameters": { + "match_ids.$": "$.match_ids", + "puuid.$": "$.puuid", + "batch_mode.$": "$.batch_mode" + }, + "Next": "ProcessMatches" + }, + "ProcessMatches": { + "Type": "Map", + "ItemsPath": "$.match_ids", + "MaxConcurrency": 5, + "Parameters": { + "match_id.$": "$$.Map.Item.Value", + "puuid.$": "$.puuid", + "batch_mode.$": "$.batch_mode" + }, + "Iterator": { + "StartAt": "CheckIfProcessed", + "States": { + "CheckIfProcessed": { + "Type": "Task", + "Resource": "arn:aws:states:::dynamodb:getItem", + "Parameters": { + "TableName": "lol-player-timeline-metadata", + "Key": { + "puuid": { + "S.$": "$.puuid" + }, + "match_id": { + "S.$": "$.match_id" + } + } + }, + "ResultPath": "$.metadata_check", + "Next": "IsAlreadyProcessed", + "Catch": [ + { + "ErrorEquals": ["States.ALL"], + "ResultPath": "$.error", + "Next": "TriggerEventExtraction" + } + ] + }, + "IsAlreadyProcessed": { + "Type": "Choice", + "Choices": [ + { + "Variable": "$.metadata_check.Item", + "IsPresent": true, + "Next": "GetExistingEvents" + } + ], + "Default": "TriggerEventExtraction" + }, + "TriggerEventExtraction": { + "Type": "Task", + "Resource": "arn:aws:states:::lambda:invoke", + "Parameters": { + "FunctionName": "timeline-event-processor", + "Payload": { + "match_id.$": "$.match_id", + "puuid.$": "$.puuid", + "force_reprocess": false + } + }, + "ResultPath": "$.extraction_result", + "Next": "WaitForExtraction", + "Retry": [ + { + "ErrorEquals": ["States.TaskFailed"], + "IntervalSeconds": 2, + "MaxAttempts": 3, + "BackoffRate": 2 + } + ], + "Catch": [ + { + "ErrorEquals": ["States.ALL"], + "ResultPath": "$.extraction_error", + "Next": "LogExtractionFailure" + } + ] + }, + "WaitForExtraction": { + "Type": "Wait", + "Seconds": 2, + "Next": "GetExistingEvents" + }, + "GetExistingEvents": { + "Type": "Task", + "Resource": "arn:aws:states:::aws-sdk:dynamodb:query", + "Parameters": { + "TableName": "lol-timeline-events", + "IndexName": "match-impact-index", + "KeyConditionExpression": "match_id = :match_id", + "ExpressionAttributeValues": { + ":match_id": { + "S.$": "$.match_id" + } + }, + "ScanIndexForward": false, + "Limit": 5 + }, + "ResultPath": "$.events", + "Next": "GenerateSummaries", + "Catch": [ + { + "ErrorEquals": ["States.ALL"], + "ResultPath": "$.query_error", + "Next": "LogQueryFailure" + } + ] + }, + "GenerateSummaries": { + "Type": "Task", + "Resource": "arn:aws:states:::lambda:invoke", + "Parameters": { + "FunctionName": "bedrock-summary-generator", + "Payload": { + "match_id.$": "$.match_id", + "puuid.$": "$.puuid", + "batch_mode": true, + "events.$": "$.events.Items" + } + }, + "ResultPath": "$.summary_result", + "Next": "MatchProcessingComplete", + "Retry": [ + { + "ErrorEquals": ["States.TaskFailed"], + "IntervalSeconds": 3, + "MaxAttempts": 2, + "BackoffRate": 2 + } + ], + "Catch": [ + { + "ErrorEquals": ["States.ALL"], + "ResultPath": "$.summary_error", + "Next": "MatchProcessingComplete" + } + ] + }, + "LogExtractionFailure": { + "Type": "Pass", + "Parameters": { + "match_id.$": "$.match_id", + "error.$": "$.extraction_error", + "status": "extraction_failed" + }, + "Next": "MatchProcessingComplete" + }, + "LogQueryFailure": { + "Type": "Pass", + "Parameters": { + "match_id.$": "$.match_id", + "error.$": "$.query_error", + "status": "query_failed" + }, + "Next": "MatchProcessingComplete" + }, + "MatchProcessingComplete": { + "Type": "Pass", + "Parameters": { + "match_id.$": "$.match_id", + "status": "completed", + "timestamp.$": "$$.State.EnteredTime" + }, + "End": true + } + } + }, + "ResultPath": "$.processing_results", + "Next": "AggregateResults" + }, + "AggregateResults": { + "Type": "Pass", + "Parameters": { + "total_matches.$": "States.ArrayLength($.match_ids)", + "processing_results.$": "$.processing_results", + "puuid.$": "$.puuid", + "completed_at.$": "$$.State.EnteredTime" + }, + "Next": "NotifyCompletion" + }, + "NotifyCompletion": { + "Type": "Task", + "Resource": "arn:aws:states:::sns:publish", + "Parameters": { + "TopicArn": "arn:aws:sns:us-west-2:768394660366:timeline-processing-complete", + "Message": { + "default": "Timeline processing complete", + "puuid.$": "$.puuid", + "total_matches.$": "$.total_matches", + "completed_at.$": "$.completed_at" + } + }, + "ResultPath": "$.notification_result", + "Next": "WorkflowComplete", + "Catch": [ + { + "ErrorEquals": ["States.ALL"], + "ResultPath": "$.notification_error", + "Next": "WorkflowComplete" + } + ] + }, + "WorkflowComplete": { + "Type": "Succeed" + } + } +} \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/infrastructure/stepfunctions_deployment_info.json b/aws/sagemaker/jobs/timeline-feature/infrastructure/stepfunctions_deployment_info.json new file mode 100644 index 0000000..db9d686 --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/infrastructure/stepfunctions_deployment_info.json @@ -0,0 +1,21 @@ +{ + "state_machine_arn": "arn:aws:states:us-west-2:768394660366:stateMachine:lol-timeline-batch-processor", + "state_machine_name": "lol-timeline-batch-processor", + "deployed_at": { + "UserId": "AROA3FZ7EBIHE3B3URJFY:SageMaker", + "Account": "768394660366", + "Arn": "arn:aws:sts::768394660366:assumed-role/datazone_usr_role_5i1vmxossv3f2o_b1rxf3f1mnfnv4/SageMaker", + "ResponseMetadata": { + "RequestId": "ea3f93da-09cc-4920-8718-25e0c3d7a33d", + "HTTPStatusCode": 200, + "HTTPHeaders": { + "x-amzn-requestid": "ea3f93da-09cc-4920-8718-25e0c3d7a33d", + "x-amz-sts-extended-request-id": "MTp1cy1lYXN0LTE6MTc2MjQwMTgxNDk1OTpHOml6UDh2UWg4", + "content-type": "text/xml", + "content-length": "472", + "date": "Thu, 06 Nov 2025 04:03:34 GMT" + }, + "RetryAttempts": 0 + } + } +} \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/lambda_api_timeline_handler/lambda_function.py b/aws/sagemaker/jobs/timeline-feature/lambda_api_timeline_handler/lambda_function.py new file mode 100644 index 0000000..2ee3ba5 --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/lambda_api_timeline_handler/lambda_function.py @@ -0,0 +1,493 @@ +""" +API Gateway handler for timeline feature +Provides endpoints for frontend to retrieve and interact with timeline events + +WELCOME TO THE API ROUTE NEXUS!!!! +""" + +import json +import boto3 +import os +from datetime import datetime +from decimal import Decimal +from typing import Dict, List +from boto3.dynamodb.conditions import Key, Attr + +dynamodb = boto3.resource('dynamodb') +bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-west-2') + +try: + EVENTS_TABLE_NAME = os.environ['EVENTS_TABLE_NAME'] + SUMMARIES_TABLE_NAME = os.environ['SUMMARIES_TABLE_NAME'] + QUESTIONS_TABLE_NAME = os.environ['QUESTIONS_TABLE_NAME'] + METADATA_TABLE_NAME = os.environ['METADATA_TABLE_NAME'] + + events_table = dynamodb.Table(EVENTS_TABLE_NAME) + summaries_table = dynamodb.Table(SUMMARIES_TABLE_NAME) + questions_table = dynamodb.Table(QUESTIONS_TABLE_NAME) + metadata_table = dynamodb.Table(METADATA_TABLE_NAME) + +except KeyError as e: + print(f"[ERROR] Missing required environment variable: {str(e)}") + print("Please redeploy the Lambda with the correct environment variables set.") + events_table = dynamodb.Table('placeholder-events') + summaries_table = dynamodb.Table('placeholder-summaries') + questions_table = dynamodb.Table('placeholder-questions') + metadata_table = dynamodb.Table('placeholder-metadata') +# -------------------------------------------------------- + +# Bedrock configuration +BEDROCK_MODEL_ID = 'anthropic.claude-3-haiku-20240307-v1:0' + + +class DecimalEncoder(json.JSONEncoder): + """Helper to convert DynamoDB Decimals to JSON""" + def default(self, obj): + if isinstance(obj, Decimal): + return float(obj) + return super(DecimalEncoder, self).default(obj) + + +def lambda_handler(event, context): + """ + Routes API requests to appropriate handlers + """ + print(f"API Gateway hit.") + try: + # Try v2.0 (HTTP API) payload first + http_method = event['requestContext']['http']['method'] + path = event['requestContext']['http']['path'] + except KeyError: + try: + # Fallback to v1.0 (REST API) payload + http_method = event['httpMethod'] + path = event['path'] + except KeyError: + print("[ERROR] Invalid event payload. Does not match API Gateway v2.0 or v1.0 format.") + print(json.dumps(event)) # Log the unexpected event structure + return cors_response(400, {'error': 'Invalid event payload'}) + # ---------------------------------------------------------- + + print(f"API request: {http_method} {path}") + + # CORS preflight + if http_method == 'OPTIONS': + return cors_response(200, {}) + + try: + if path == '/timeline/events' and http_method == 'GET': + return get_timeline_events(event) + + elif path == '/timeline/events/summary' and http_method == 'POST': + return get_event_summary(event) + + elif path == '/timeline/ask' and http_method == 'POST': + return answer_question(event) + + elif path == '/timeline/player/matches' and http_method == 'GET': + return get_player_matches(event) + + elif path == '/timeline/batch-process' and http_method == 'POST': + return trigger_batch_processing(event) + + else: + return cors_response(404, {'error': 'Endpoint not found'}) + + except Exception as e: + print(f"Error: {str(e)}") + import traceback + traceback.print_exc() + + return cors_response(500, {'error': str(e)}) + + +def get_timeline_events(event): + """ + GET /timeline/events?match_id=XXX&puuid=YYY + Returns critical events for a specific match + """ + + params = event.get('queryStringParameters', {}) + if not params: + return cors_response(400, {'error': 'Missing query parameters'}) + + match_id = params.get('match_id') + puuid = params.get('puuid') + + if not match_id or not puuid: + return cors_response(400, {'error': 'match_id and puuid required'}) + + print(f"Fetching events for match {match_id}, player {puuid}") + + # Query events + response = events_table.query( + IndexName='match-impact-index', + KeyConditionExpression=Key('match_id').eq(match_id), + FilterExpression=Attr('puuid').eq(puuid), + ScanIndexForward=False # Sort by impact score descending + ) + + events = response.get('Items', []) + + # Get cached summaries + event_data = [] + for event_item in events: + event_obj = { + 'event_id': event_item['event_id'], + 'timestamp_minutes': float(event_item['timestamp_minutes']), + 'event_type': event_item['event_type'], + 'impact_score': int(event_item['impact_score']), + 'game_state': event_item.get('game_state', 'mid'), + 'event_details': json.loads(event_item.get('event_details', '{}')), + 'context': json.loads(event_item.get('context', '{}')), + 'has_summary': False, + 'summary': None + } + + # Check for cached summary + summary_response = summaries_table.get_item( + Key={ + 'event_id': event_item['event_id'], + 'summary_type': 'basic' + } + ) + + if 'Item' in summary_response: + event_obj['has_summary'] = True + event_obj['summary'] = summary_response['Item'].get('summary_text') + + event_data.append(event_obj) + + return cors_response(200, { + 'match_id': match_id, + 'puuid': puuid, + 'events': event_data, + 'total_events': len(event_data) + }) + + +def get_event_summary(event): + """ + POST /timeline/events/summary + Body: { event_id, match_id, puuid, player_context } + Generates or retrieves AI summary for a specific event + """ + + # v2.0 payload body is just a string, must be parsed + body_str = event.get('body', '{}') + body = json.loads(body_str) if body_str else {} + + event_id = body.get('event_id') + match_id = body.get('match_id') + puuid = body.get('puuid') + player_context = body.get('player_context', {}) + + if not event_id or not match_id: + return cors_response(400, {'error': 'event_id and match_id required'}) + + print(f"Getting summary for event {event_id}") + + # Check cache first + cache_response = summaries_table.get_item( + Key={ + 'event_id': event_id, + 'summary_type': 'basic' + } + ) + + if 'Item' in cache_response: + print("Cache hit") + return cors_response(200, { + 'event_id': event_id, + 'summary': cache_response['Item']['summary_text'], + 'cached': True, + 'generated_at': int(cache_response['Item']['generated_at']) + }) + + # Cache miss - generate new summary + print("Cache miss - generating new summary") + + # Get event details + event_response = events_table.get_item( + Key={'match_id': match_id, 'event_id': event_id} + ) + + if 'Item' not in event_response: + return cors_response(404, {'error': 'Event not found'}) + + event_data = event_response['Item'] + + try: + from lambda_bedrock_summary_generator.lambda_function import BedrockSummaryGenerator + except ImportError: + print("[ERROR] Could not import BedrockSummaryGenerator. Make sure it's in a shared layer.") + return cors_response(500, {'error': 'Summary generator logic not found'}) + + generator = BedrockSummaryGenerator() + summary = generator.generate_event_summary(event_data, player_context) + + # Cache the result + from datetime import timedelta + ttl = int((datetime.utcnow() + timedelta(days=7)).timestamp()) + + summaries_table.put_item(Item={ + 'event_id': event_id, + 'summary_type': 'basic', + 'match_id': match_id, + 'puuid': puuid, + 'summary_text': summary, + 'generated_at': int(datetime.utcnow().timestamp()), + 'ttl': ttl, + 'model_used': BEDROCK_MODEL_ID + }) + + return cors_response(200, { + 'event_id': event_id, + 'summary': summary, + 'cached': False, + 'generated_at': int(datetime.utcnow().timestamp()) + }) + + +def answer_question(event): + """ + POST /timeline/ask + Body: { event_id, match_id, puuid, question, match_context } + Answers user questions about specific events using Bedrock + """ + + # v2.0 payload body is just a string, must be parsed + body_str = event.get('body', '{}') + body = json.loads(body_str) if body_str else {} + + event_id = body.get('event_id') + match_id = body.get('match_id') + puuid = body.get('puuid') + question = body.get('question') + match_context = body.get('match_context', {}) + + if not all([event_id, match_id, puuid, question]): + return cors_response(400, { + 'error': 'event_id, match_id, puuid, and question required' + }) + + # Rate limiting: check question count + question_count_response = questions_table.query( + IndexName='event-questions-index', + KeyConditionExpression=Key('event_id').eq(event_id), + FilterExpression=Attr('puuid').eq(puuid) + ) + + question_count = len(question_count_response.get('Items', [])) + if question_count >= 5: + return cors_response(429, { + 'error': 'Maximum 5 questions per event reached', + 'limit': 5, + 'used': question_count + }) + + print(f"Answering question for event {event_id}: {question}") + + # Get event details + event_response = events_table.get_item( + Key={'match_id': match_id, 'event_id': event_id} + ) + + if 'Item' not in event_response: + return cors_response(404, {'error': 'Event not found'}) + + event_data = event_response['Item'] + + # Build prompt for question answering + prompt = build_qa_prompt(event_data, question, match_context) + + # Call Bedrock + request_body = { + "messages": [ + { + "role": "user", + "content": prompt + } + ], + "max_tokens": 250, + "temperature": 0.7 + } + + try: + response = bedrock_runtime.invoke_model( + modelId=BEDROCK_MODEL_ID, + body=json.dumps(request_body), + contentType='application/json', + accept='application/json' + ) + + response_body = json.loads(response['body'].read()) + + # Extract from OpenAI response format + if 'choices' in response_body and len(response_body['choices']) > 0: + answer = response_body['choices'][0]['message']['content'] + else: + answer = "I apologize, but I couldn't generate an answer at this time." + + except Exception as e: + print(f"Bedrock error: {str(e)}") + answer = "I apologize, but I couldn't generate an answer at this time. Please try again." + + # Save question and answer + question_id = f"{event_id}_{int(datetime.utcnow().timestamp())}" + from datetime import timedelta + ttl = int((datetime.utcnow() + timedelta(days=30)).timestamp()) + + questions_table.put_item(Item={ + 'question_id': question_id, + 'event_id': event_id, + 'match_id': match_id, + 'puuid': puuid, + 'question': question, + 'answer': answer, + 'asked_at': int(datetime.utcnow().timestamp()), + 'ttl': ttl + }) + + return cors_response(200, { + 'event_id': event_id, + 'question': question, + 'answer': answer, + 'question_count': question_count + 1, + 'remaining_questions': 4 - question_count + }) + + +def get_player_matches(event): + """ + GET /timeline/player/matches?puuid=XXX + Returns all processed matches for a player + """ + + params = event.get('queryStringParameters', {}) + puuid = params.get('puuid') + + if not puuid: + return cors_response(400, {'error': 'puuid required'}) + + # Query metadata table + response = metadata_table.query( + KeyConditionExpression=Key('puuid').eq(puuid), + ScanIndexForward=False, # Most recent first + Limit=100 + ) + + matches = response.get('Items', []) + + match_data = [] + for match in matches: + match_data.append({ + 'match_id': match['match_id'], + 'processed_timestamp': int(match['processed_timestamp']), + 'events_count': int(match.get('events_count', 0)), + 'processing_status': match.get('processing_status', 'unknown') + }) + + return cors_response(200, { + 'puuid': puuid, + 'matches': match_data, + 'total_matches': len(match_data) + }) + + +def trigger_batch_processing(event): + """ + POST /timeline/batch-process + Body: { match_ids, puuid } + Triggers Step Functions workflow for batch processing + """ + + # v2.0 payload body is just a string, must be parsed + body_str = event.get('body', '{}') + body = json.loads(body_str) if body_str else {} + + match_ids = body.get('match_ids', []) + puuid = body.get('puuid') + + if not match_ids or not puuid: + return cors_response(400, {'error': 'match_ids and puuid required'}) + + # Trigger Step Functions + stepfunctions = boto3.client('stepfunctions') + state_machine_arn = os.environ.get('STEP_FUNCTIONS_ARN') + + if not state_machine_arn: + return cors_response(500, {'error': 'Step Functions not configured'}) + + execution_name = f"batch_{puuid}_{int(datetime.utcnow().timestamp())}" + + try: + response = stepfunctions.start_execution( + stateMachineArn=state_machine_arn, + name=execution_name, + input=json.dumps({ + 'match_ids': match_ids, + 'puuid': puuid, + 'batch_mode': True + }) + ) + + return cors_response(200, { + 'execution_arn': response['executionArn'], + 'execution_name': execution_name, + 'match_count': len(match_ids) + }) + + except Exception as e: + print(f"Step Functions error: {str(e)}") + return cors_response(500, {'error': f'Failed to start batch processing: {str(e)}'}) + + +def build_qa_prompt(event: Dict, question: str, match_context: Dict) -> str: + """ + Builds prompt for question answering + """ + + event_details = json.loads(event.get('event_details', '{}')) + context = json.loads(event.get('context', '{}')) + + prompt = f"""You are an expert League of Legends coach answering a player's question about a specific moment in their ranked match. + +**Event Context:** +- Type: {event['event_type']} +- Time: {float(event['timestamp_minutes']):.1f} minutes +- Game State: {event.get('game_state', 'mid')} +- Impact Score: {int(event['impact_score'])}/100 +- Gold Difference: {context.get('gold_difference', 0)}g + +**Event Details:** +{json.dumps(event_details, indent=2)} + +**Match Context:** +{json.dumps(match_context, indent=2)} + +**Player Question:** {question} + +Provide a helpful, specific answer in 2-3 sentences. Focus on: +1. Directly answering their question +2. Providing ONE actionable tip they can apply + +Be conversational but professional. Under 100 words.""" + + return prompt + + +def cors_response(status_code: int, body: dict) -> dict: + """ + Adds CORS headers to response + """ + return { + 'statusCode': status_code, + 'headers': { + 'Content-Type': 'application/json', + 'Access-Control-Allow-Origin': '*', + 'Access-Control-Allow-Headers': 'Content-Type,Authorization', + 'Access-Control-Allow-Methods': 'GET,POST,OPTIONS' + }, + 'body': json.dumps(body, cls=DecimalEncoder) + } \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/lambda_bedrock_summary_generator/lambda_function.py b/aws/sagemaker/jobs/timeline-feature/lambda_bedrock_summary_generator/lambda_function.py new file mode 100644 index 0000000..216312e --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/lambda_bedrock_summary_generator/lambda_function.py @@ -0,0 +1,470 @@ +# lambda_bedrock_summary_generator/lambda_function.py +""" +Generates AI summaries for critical timeline events using AWS Bedrock +Can be triggered by Step Functions or direct API calls +""" + +import json +import boto3 +import os +from datetime import datetime, timedelta +from decimal import Decimal +from typing import Dict, List + +dynamodb = boto3.resource('dynamodb') +bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1') + +# DynamoDB tables +events_table = dynamodb.Table('lol-timeline-events') +summaries_table = dynamodb.Table('lol-timeline-ai-summaries') +metadata_table = dynamodb.Table('lol-player-timeline-metadata') + +# Bedrock configuration +BEDROCK_MODEL_ID = 'openai.gpt-oss-20b-1:0' +MAX_TOKENS = 300 +TEMPERATURE = 0.7 + + +class BedrockSummaryGenerator: + """ + Generates AI-powered summaries and insights for timeline events + """ + + def __init__(self): + self.bedrock = bedrock_runtime + self.model_id = BEDROCK_MODEL_ID + + def generate_event_summary(self, event: Dict, player_context: Dict) -> str: + """ + Generates concise AI summary for a critical moment + """ + + system_prompt = """You are an expert League of Legends coach analyzing a key moment. + Write 2-3 sentences analyzing the event. + Be direct, constructive, and actionable. + Keep the entire response under 70 words.""" + + prompt = self._build_event_prompt(event, player_context) + request_body = { + "messages": [ + { + "role": "system", + "content": system_prompt + }, + { + "role": "user", + "content": prompt + } + ], + "max_tokens": MAX_TOKENS, + "temperature": TEMPERATURE + } + + try: + response = self.bedrock.invoke_model( + modelId=self.model_id, + body=json.dumps(request_body), + contentType='application/json', + accept='application/json' + ) + + response_body = json.loads(response['body'].read()) + + # Extract the content from OpenAI response format + if 'choices' in response_body and len(response_body['choices']) > 0: + summary = response_body['choices'][0]['message']['content'].strip() + else: + # Fallback if response structure is different + print(f"Unexpected response structure: {response_body}") + return self._generate_fallback_summary(event) + + return summary + + except Exception as e: + print(f"Bedrock error: {str(e)}") + import traceback + traceback.print_exc() + return self._generate_fallback_summary(event) + + def _build_event_prompt(self, event: Dict, player_context: Dict) -> str: + """ + Builds optimized prompt for event analysis + """ + event_type = event['event_type'] + timestamp = event['timestamp_minutes'] + impact = event['impact_score'] + game_state = event.get('game_state', 'mid') + + event_details = json.loads(event.get('event_details', '{}')) + context = json.loads(event.get('context', '{}')) + + # Build context-aware prompt based on event type + if event_type == 'KILL': + return self._build_kill_prompt( + event_details, timestamp, game_state, context, player_context + ) + elif event_type == 'OBJECTIVE': + return self._build_objective_prompt( + event_details, timestamp, game_state, context, player_context + ) + elif event_type == 'TEAMFIGHT': + return self._build_teamfight_prompt( + event_details, timestamp, game_state, context, player_context + ) + elif event_type == 'STRUCTURE': + return self._build_structure_prompt( + event_details, timestamp, game_state, context, player_context + ) + else: + return self._build_generic_prompt( + event, timestamp, game_state, context, player_context + ) + + def _build_kill_prompt(self, details: Dict, timestamp: float, + game_state: str, context: Dict, player_ctx: Dict) -> str: + """ + Specialized prompt for kill events + """ + player_role = details.get('player_role', 'team_involved') + killer = details.get('killer', 'Unknown') + victim = details.get('victim', 'Unknown') + shutdown = details.get('shutdown_gold', 0) + gold_diff = context.get('gold_difference', 0) + gold_state = context.get('gold_state', 'even') + + champion = player_ctx.get('champion', 'your champion') + position = player_ctx.get('position', 'your role') + + if player_role == 'killer': + base_prompt = f"""You are an expert League of Legends coach analyzing a ranked match. + +**Critical Kill at {timestamp:.1f} minutes ({game_state} game)** + +Player Action: You ({champion} - {position}) killed {victim} +Shutdown Gold: {shutdown}g +Team Gold State: {gold_state} ({gold_diff:+d}g) +Assistants: {', '.join(details.get('assistants', [])) if details.get('assistants') else 'Solo kill'} + +Provide a 2-3 sentence analysis: +1. Why this kill was significant for the game outcome +2. ONE specific tip to replicate this success or improve the execution + +Be direct and actionable. Under 80 words.""" + + elif player_role == 'victim': + base_prompt = f"""You are an expert League of Legends coach analyzing a ranked match. + +**Critical Death at {timestamp:.1f} minutes ({game_state} game)** + +Player Action: You ({champion} - {position}) were killed by {killer} +Gold Lost: {shutdown}g bounty +Team Gold State: {gold_state} ({gold_diff:+d}g) +Enemy Assistants: {len(details.get('assistants', []))} players involved + +Provide a 2-3 sentence analysis: +1. What likely went wrong in this situation +2. ONE specific way to avoid this in future games + +Be constructive and actionable. Under 80 words.""" + + else: + base_prompt = f"""You are an expert League of Legends coach analyzing a ranked match. + +**Team Fight Kill at {timestamp:.1f} minutes ({game_state} game)** + +Action: {killer} killed {victim} +Team Gold State: {gold_state} ({gold_diff:+d}g) +Your Champion: {champion} ({position}) + +Provide a 2-3 sentence analysis: +1. How this kill impacted the game state +2. ONE tip for how you could have influenced this situation + +Be direct and actionable. Under 80 words.""" + + return base_prompt + + def _build_objective_prompt(self, details: Dict, timestamp: float, + game_state: str, context: Dict, player_ctx: Dict) -> str: + """ + Specialized prompt for objective events + """ + objective = details.get('objective_type', 'OBJECTIVE') + securing_team = details.get('securing_team', 'UNKNOWN') + gold_diff = context.get('gold_difference', 0) + gold_state = context.get('gold_state', 'even') + + champion = player_ctx.get('champion', 'your champion') + position = player_ctx.get('position', 'your role') + + if securing_team == 'PLAYER_TEAM': + prompt = f"""You are an expert League of Legends coach analyzing a ranked match. + +**{objective} Secured at {timestamp:.1f} minutes ({game_state} game)** + +Your Team: Successfully secured {objective} +Team Gold State Before: {gold_state} ({gold_diff:+d}g) +Your Champion: {champion} ({position}) + +Provide a 2-3 sentence analysis: +1. Why securing this objective was crucial at this timing +2. ONE tip to maintain the advantage gained from this objective + +Be direct and actionable. Under 80 words.""" + + else: + prompt = f"""You are an expert League of Legends coach analyzing a ranked match. + +**{objective} Lost at {timestamp:.1f} minutes ({game_state} game)** + +Enemy Team: Secured {objective} +Team Gold State Before: {gold_state} ({gold_diff:+d}g) +Your Champion: {champion} ({position}) + +Provide a 2-3 sentence analysis: +1. Why losing this objective was impactful +2. ONE specific action your team could have taken to contest or trade + +Be constructive and actionable. Under 80 words.""" + + return prompt + + def _build_teamfight_prompt(self, details: Dict, timestamp: float, + game_state: str, context: Dict, player_ctx: Dict) -> str: + """ + Specialized prompt for teamfight events + """ + outcome = details.get('outcome', 'UNKNOWN') + player_kills = details.get('player_team_kills', 0) + enemy_kills = details.get('enemy_team_kills', 0) + duration = details.get('duration_seconds', 0) + gold_diff = context.get('gold_difference', 0) + gold_state = context.get('gold_state', 'even') + + champion = player_ctx.get('champion', 'your champion') + position = player_ctx.get('position', 'your role') + + prompt = f"""You are an expert League of Legends coach analyzing a ranked match. + +**Major Teamfight at {timestamp:.1f} minutes ({game_state} game)** + +Outcome: Your team {outcome} ({player_kills} kills vs {enemy_kills} deaths) +Duration: {duration} seconds +Team Gold State Before: {gold_state} ({gold_diff:+d}g) +Your Champion: {champion} ({position}) + +Provide a 2-3 sentence analysis: +1. What made this teamfight decisive for the game +2. ONE specific tip for your role in teamfights at this stage + +Be direct and actionable. Under 80 words.""" + + return prompt + + def _build_structure_prompt(self, details: Dict, timestamp: float, + game_state: str, context: Dict, player_ctx: Dict) -> str: + """ + Specialized prompt for structure events + """ + structure = details.get('structure_type', 'STRUCTURE') + lane = details.get('lane', 'UNKNOWN') + destroying_team = details.get('destroying_team', 'UNKNOWN') + gold_diff = context.get('gold_difference', 0) + gold_state = context.get('gold_state', 'even') + + champion = player_ctx.get('champion', 'your champion') + position = player_ctx.get('position', 'your role') + + if destroying_team == 'PLAYER_TEAM': + prompt = f"""You are an expert League of Legends coach analyzing a ranked match. + +**{structure} Destroyed at {timestamp:.1f} minutes ({game_state} game)** + +Your Team: Destroyed {lane} lane {structure} +Team Gold State: {gold_state} ({gold_diff:+d}g) +Your Champion: {champion} ({position}) + +Provide a 2-3 sentence analysis: +1. How destroying this structure opens up the map +2. ONE specific way to capitalize on this advantage + +Be direct and actionable. Under 80 words.""" + + else: + prompt = f"""You are an expert League of Legends coach analyzing a ranked match. + +**{structure} Lost at {timestamp:.1f} minutes ({game_state} game)** + +Enemy Team: Destroyed your {lane} lane {structure} +Team Gold State: {gold_state} ({gold_diff:+d}g) +Your Champion: {champion} ({position}) + +Provide a 2-3 sentence analysis: +1. How losing this structure impacts map control +2. ONE defensive strategy to prevent further losses + +Be constructive and actionable. Under 80 words.""" + + return prompt + + def _build_generic_prompt(self, event: Dict, timestamp: float, + game_state: str, context: Dict, player_ctx: Dict) -> str: + """ + Generic fallback prompt + """ + event_type = event.get('event_type', 'EVENT') + impact = event.get('impact_score', 0) + + prompt = f"""You are an expert League of Legends coach analyzing a ranked match. + +**Critical {event_type} at {timestamp:.1f} minutes ({game_state} game)** + +Impact Score: {impact}/100 +Game State: {game_state} + +Provide a 2-3 sentence analysis: +1. Why this moment was significant +2. ONE actionable tip for improvement + +Be direct and under 80 words.""" + + return prompt + + def _generate_fallback_summary(self, event: Dict) -> str: + """ + Rule-based fallback if Bedrock fails + """ + event_type = event.get('event_type', 'EVENT') + timestamp = event.get('timestamp_minutes', 0) + impact = event.get('impact_score', 0) + + return f"Critical {event_type} at {timestamp:.1f} minutes with impact score {impact}. This was a key moment in the match that significantly affected the outcome." + + +def lambda_handler(event, context): + """ + Generates AI summaries for timeline events + Can be invoked by: + 1. Step Functions (batch processing) + 2. API Gateway (on-demand) + """ + + print("Bedrock Summary Generator Lambda invoked") + + try: + # Parse input + if 'body' in event: + # API Gateway invocation + body = json.loads(event['body']) if isinstance(event['body'], str) else event['body'] + else: + # Step Functions invocation + body = event + + match_id = body.get('match_id') + puuid = body.get('puuid') + event_ids = body.get('event_ids', []) # Optional: specific events to process + batch_mode = body.get('batch_mode', False) + + print(f"Processing match {match_id} for player {puuid}") + + # Get events to process + if event_ids: + events_to_process = [] + for event_id in event_ids: + response = events_table.get_item( + Key={'match_id': match_id, 'event_id': event_id} + ) + if 'Item' in response: + events_to_process.append(response['Item']) + else: + # Get all events for this match + response = events_table.query( + IndexName='match-impact-index', + KeyConditionExpression='match_id = :match_id', + ExpressionAttributeValues={':match_id': match_id}, + ScanIndexForward=False # Descending order by impact score + ) + events_to_process = response.get('Items', []) + + # In batch mode, only process top 5 events + if batch_mode: + events_to_process = sorted( + events_to_process, + key=lambda x: x.get('impact_score', 0), + reverse=True + )[:5] + + print(f"Processing {len(events_to_process)} events") + + # Get player context (champion, position, etc.) + # This should come from match data or be passed in + player_context = body.get('player_context', { + 'champion': 'Champion', + 'position': 'Role' + }) + + # Generate summaries + generator = BedrockSummaryGenerator() + summaries_generated = 0 + + for event in events_to_process: + event_id = event['event_id'] + + # Check if summary already exists (cache hit) + cache_check = summaries_table.get_item( + Key={ + 'event_id': event_id, + 'summary_type': 'basic' + } + ) + + if 'Item' in cache_check: + print(f"Cache hit for event {event_id}") + summaries_generated += 1 + continue + + # Generate new summary + print(f"Generating summary for event {event_id}") + summary = generator.generate_event_summary(event, player_context) + + # Save to cache + ttl = int((datetime.utcnow() + timedelta(days=7)).timestamp()) + + summaries_table.put_item(Item={ + 'event_id': event_id, + 'summary_type': 'basic', + 'match_id': match_id, + 'puuid': puuid, + 'summary_text': summary, + 'generated_at': int(datetime.utcnow().timestamp()), + 'ttl': ttl, + 'model_used': BEDROCK_MODEL_ID, + 'tokens_used': MAX_TOKENS # Approximate + }) + + summaries_generated += 1 + print(f"✓ Summary generated and cached for {event_id}") + + return { + 'statusCode': 200, + 'headers': { + 'Content-Type': 'application/json', + 'Access-Control-Allow-Origin': '*' + }, + 'body': json.dumps({ + 'message': 'Summaries generated successfully', + 'match_id': match_id, + 'summaries_generated': summaries_generated, + 'events_processed': len(events_to_process) + }) + } + + except Exception as e: + print(f"Error generating summaries: {str(e)}") + import traceback + traceback.print_exc() + + return { + 'statusCode': 500, + 'body': json.dumps({'error': str(e)}) + } \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/lambda_deployment_info.json b/aws/sagemaker/jobs/timeline-feature/lambda_deployment_info.json new file mode 100644 index 0000000..7643d13 --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/lambda_deployment_info.json @@ -0,0 +1,9 @@ +{ + "functions": { + "event_processor": "arn:aws:lambda:us-west-2:768394660366:function:lol-timeline-event-processor", + "summary_generator": "arn:aws:lambda:us-west-2:768394660366:function:lol-timeline-summary-generator", + "api_handler": "arn:aws:lambda:us-west-2:768394660366:function:lol-timeline-api-handler" + }, + "api_endpoint": "https://v4ft9564pb.execute-api.us-west-2.amazonaws.com", + "deployed_at": "{'UserId': 'AROA3FZ7EBIHE3B3URJFY:SageMaker', 'Account': '768394660366', 'Arn': 'arn:aws:sts::768394660366:assumed-role/datazone_usr_role_5i1vmxossv3f2o_b1rxf3f1mnfnv4/SageMaker', 'ResponseMetadata': {'RequestId': '64f7062c-3840-4c65-bafe-9cc7a4d79332', 'HTTPStatusCode': 200, 'HTTPHeaders': {'x-amzn-requestid': '64f7062c-3840-4c65-bafe-9cc7a4d79332', 'x-amz-sts-extended-request-id': 'MTp1cy1lYXN0LTE6MTc2MjU4OTA1NjM1NzpHOk43SkxPQmtZ', 'content-type': 'text/xml', 'content-length': '472', 'date': 'Sat, 08 Nov 2025 08:04:16 GMT'}, 'RetryAttempts': 0}}" +} \ No newline at end of file diff --git a/aws/sagemaker/jobs/timeline-feature/lambda_timeline_processor/lambda_function.py b/aws/sagemaker/jobs/timeline-feature/lambda_timeline_processor/lambda_function.py new file mode 100644 index 0000000..d9482c6 --- /dev/null +++ b/aws/sagemaker/jobs/timeline-feature/lambda_timeline_processor/lambda_function.py @@ -0,0 +1,524 @@ +""" +Processes timeline-data.json files and extracts critical events +Triggered by S3 upload events +""" + +import json +import boto3 +import os +from datetime import datetime, timedelta +from decimal import Decimal +from typing import Dict, List, Tuple +import uuid + +s3_client = boto3.client('s3') +dynamodb = boto3.resource('dynamodb') + +# Get table names from environment variables +EVENTS_TABLE_NAME = os.environ.get('EVENTS_TABLE_NAME', 'lol-timeline-events') +METADATA_TABLE_NAME = os.environ.get('METADATA_TABLE_NAME', 'lol-player-timeline-metadata') + +events_table = dynamodb.Table(EVENTS_TABLE_NAME) +metadata_table = dynamodb.Table(METADATA_TABLE_NAME) + + +class TimelineEventExtractor: + """ + Extracts critical moments from League of Legends timeline data + """ + + CRITICAL_EVENT_TYPES = [ + 'CHAMPION_KILL', + 'ELITE_MONSTER_KILL', + 'BUILDING_KILL', + 'CHAMPION_SPECIAL_KILL', + ] + + OBJECTIVE_VALUES = { + 'DRAGON': 1000, + 'BARON_NASHOR': 3000, + 'RIFTHERALD': 1500, + 'TOWER_PLATE': 300, + 'OUTER_TURRET': 800, + 'INNER_TURRET': 1000, + 'BASE_TURRET': 1200, + 'NEXUS_TURRET': 1500, + 'INHIBITOR': 1500 + } + + def __init__(self): + self.events = [] + + def extract_critical_moments(self, timeline_data: dict, + match_data: dict, + target_puuid: str) -> List[Dict]: + """ + Identifies critical moments that significantly impacted game outcome + """ + critical_moments = [] + + frames = timeline_data.get('info', {}).get('frames', []) + participant_map = self._build_participant_map(match_data) + target_participant_id = self._get_participant_id(match_data, target_puuid) + + if not target_participant_id: + print(f"Warning: Could not find participant ID for {target_puuid}") + return [] + + # Extract player's team + target_team = participant_map.get(target_participant_id, {}).get('team') + + for frame_idx, frame in enumerate(frames): + timestamp = frame.get('timestamp', 0) / 1000 / 60 # Convert to minutes + + # Extract events from this frame + for event in frame.get('events', []): + event_type = event.get('type') + + if event_type in self.CRITICAL_EVENT_TYPES: + critical_event = self._analyze_event( + event, frame, timestamp, participant_map, + target_participant_id, target_team + ) + + if critical_event: + critical_moments.append(critical_event) + + # Detect teamfights + teamfights = self._detect_teamfights( + frames, participant_map, target_participant_id, target_team + ) + critical_moments.extend(teamfights) + + # Sort by impact score + critical_moments.sort(key=lambda x: x['impact_score'], reverse=True) + + # Return top 15 moments + return critical_moments[:15] + + def _analyze_event(self, event: dict, frame: dict, + timestamp: float, participant_map: dict, + target_participant_id: int, target_team: int) -> Dict: + """ + Analyzes individual event for criticality + """ + event_type = event.get('type') + impact_score = 0 + event_details = {} + + if event_type == 'CHAMPION_KILL': + killer_id = event.get('killerId') + victim_id = event.get('victimId') + assisting_ids = event.get('assistingParticipantIds', []) + + # Check if target player was involved + is_player_involved = ( + killer_id == target_participant_id or + victim_id == target_participant_id or + target_participant_id in assisting_ids + ) + + if not is_player_involved: + # Still track high-impact kills on player's team + killer_team = participant_map.get(killer_id, {}).get('team') + if killer_team != target_team: + return None # Enemy kill, not involving player + + shutdown_bounty = event.get('bounty', 0) + + # Calculate impact + impact_score = 50 # Base kill impact + if len(assisting_ids) >= 3: + impact_score += 30 # Team fight kill + if shutdown_bounty > 500: + impact_score += 400 # High-value shutdown + if killer_id == target_participant_id: + impact_score += 20 # Player got the kill + elif victim_id == target_participant_id: + impact_score += 25 # Player died (learning opportunity) + + event_details = { + 'killer': participant_map.get(killer_id, {}).get('champion'), + 'killer_name': participant_map.get(killer_id, {}).get('name'), + 'victim': participant_map.get(victim_id, {}).get('champion'), + 'victim_name': participant_map.get(victim_id, {}).get('name'), + 'assistants': [ + participant_map.get(aid, {}).get('champion') + for aid in assisting_ids + ], + 'shutdown_gold': int(shutdown_bounty), + 'position': event.get('position', {}), + 'player_role': ( + 'killer' if killer_id == target_participant_id + else 'victim' if victim_id == target_participant_id + else 'assistant' if target_participant_id in assisting_ids + else 'team_involved' + ) + } + + return { + 'event_id': f"KILL_{timestamp:.1f}_{uuid.uuid4().hex[:8]}", + 'timestamp_minutes': float(timestamp), + 'event_type': 'KILL', + 'impact_score': int(impact_score), + 'event_details': event_details, + 'game_state': self._get_game_state(timestamp), + 'context': self._build_event_context(frame, participant_map, target_team) + } + + elif event_type == 'ELITE_MONSTER_KILL': + monster_type = event.get('monsterType') + killer_team_id = event.get('killerTeamId') + + # Only track objectives relevant to player's team + is_player_team = (killer_team_id == target_team) + + impact_score = self.OBJECTIVE_VALUES.get(monster_type, 500) + if is_player_team: + impact_score += 50 # Bonus for securing + else: + impact_score += 30 # Still important to know enemy secured + + event_details = { + 'objective_type': monster_type, + 'securing_team': 'PLAYER_TEAM' if is_player_team else 'ENEMY_TEAM', + 'position': event.get('position', {}), + 'killer_id': event.get('killerId') + } + + return { + 'event_id': f"OBJECTIVE_{timestamp:.1f}_{uuid.uuid4().hex[:8]}", + 'timestamp_minutes': float(timestamp), + 'event_type': 'OBJECTIVE', + 'impact_score': int(impact_score), + 'event_details': event_details, + 'game_state': self._get_game_state(timestamp), + 'context': self._build_event_context(frame, participant_map, target_team) + } + + elif event_type == 'BUILDING_KILL': + building_type = event.get('buildingType') + killer_team_id = event.get('killerTeamId') + lane = event.get('laneType', 'UNKNOWN') + + is_player_team = (killer_team_id == target_team) + + if 'INHIBITOR' in building_type: + impact_score = self.OBJECTIVE_VALUES['INHIBITOR'] + else: + impact_score = self.OBJECTIVE_VALUES.get('OUTER_TURRET', 800) + + if is_player_team: + impact_score += 40 + else: + impact_score += 25 + + event_details = { + 'structure_type': building_type, + 'lane': lane, + 'destroying_team': 'PLAYER_TEAM' if is_player_team else 'ENEMY_TEAM' + } + + return { + 'event_id': f"STRUCTURE_{timestamp:.1f}_{uuid.uuid4().hex[:8]}", + 'timestamp_minutes': float(timestamp), + 'event_type': 'STRUCTURE', + 'impact_score': int(impact_score), + 'event_details': event_details, + 'game_state': self._get_game_state(timestamp), + 'context': self._build_event_context(frame, participant_map, target_team) + } + + return None + + def _detect_teamfights(self, frames: List[dict], + participant_map: dict, + target_participant_id: int, + target_team: int) -> List[Dict]: + """ + Detects teamfights by clustering kills/deaths in time and space + """ + teamfights = [] + + # Collect all kills + kill_events = [] + for frame in frames: + timestamp = frame.get('timestamp', 0) / 1000 / 60 + + for event in frame.get('events', []): + if event.get('type') == 'CHAMPION_KILL': + kill_events.append({ + 'timestamp': timestamp, + 'position': event.get('position', {}), + 'killer_id': event.get('killerId'), + 'victim_id': event.get('victimId'), + 'assisting_ids': event.get('assistingParticipantIds', []) + }) + + # Cluster events (within 30 seconds) + i = 0 + while i < len(kill_events): + cluster = [kill_events[i]] + j = i + 1 + + while j < len(kill_events): + time_diff = abs(kill_events[j]['timestamp'] - kill_events[i]['timestamp']) + + if time_diff <= 0.5: # 30 seconds + cluster.append(kill_events[j]) + j += 1 + else: + break + + # Check if it's a teamfight (3+ kills, 6+ participants) + if len(cluster) >= 3: + all_participants = set() + player_involved = False + + for kill in cluster: + all_participants.add(kill['killer_id']) + all_participants.add(kill['victim_id']) + all_participants.update(kill['assisting_ids']) + + if target_participant_id in [kill['killer_id'], kill['victim_id']] or \ + target_participant_id in kill['assisting_ids']: + player_involved = True + + if len(all_participants) >= 6 and player_involved: + # Determine outcome + player_team_kills = sum( + 1 for kill in cluster + if participant_map.get(kill['killer_id'], {}).get('team') == target_team + ) + enemy_kills = len(cluster) - player_team_kills + + outcome = 'WON' if player_team_kills > enemy_kills else \ + 'LOST' if enemy_kills > player_team_kills else 'EVEN' + + teamfights.append({ + 'event_id': f"TEAMFIGHT_{cluster[0]['timestamp']:.1f}_{uuid.uuid4().hex[:8]}", + 'timestamp_minutes': float(cluster[0]['timestamp']), + 'event_type': 'TEAMFIGHT', + 'impact_score': int(100 + (len(cluster) * 20)), + 'event_details': { + 'kills_count': len(cluster), + 'participants_count': len(all_participants), + 'player_team_kills': player_team_kills, + 'enemy_team_kills': enemy_kills, + 'outcome': outcome, + 'duration_seconds': int((cluster[-1]['timestamp'] - cluster[0]['timestamp']) * 60) + }, + 'game_state': self._get_game_state(cluster[0]['timestamp']), + 'context': {} + }) + + i = j if j > i + 1 else i + 1 + + return teamfights + + def _build_participant_map(self, match_data: dict) -> Dict: + """ + Creates mapping of participantId to player info + """ + participant_map = {} + + participants = match_data.get('info', {}).get('participants', []) + for participant in participants: + participant_map[participant['participantId']] = { + 'name': f"{participant.get('riotIdGameName', 'Unknown')}", + 'champion': participant.get('championName'), + 'team': participant.get('teamId'), + 'position': participant.get('teamPosition'), + 'puuid': participant.get('puuid') + } + + return participant_map + + def _get_participant_id(self, match_data: dict, puuid: str) -> int: + """ + Gets participant ID for given PUUID + """ + participants = match_data.get('info', {}).get('participants', []) + for participant in participants: + if participant.get('puuid') == puuid: + return participant['participantId'] + return None + + def _build_event_context(self, frame: dict, participant_map: dict, + target_team: int) -> Dict: + """ + Builds contextual information for the event + """ + participant_frames = frame.get('participantFrames', {}) + + team_100_gold = sum( + p.get('totalGold', 0) + for p_id, p in participant_frames.items() + if participant_map.get(int(p_id), {}).get('team') == 100 + ) + team_200_gold = sum( + p.get('totalGold', 0) + for p_id, p in participant_frames.items() + if participant_map.get(int(p_id), {}).get('team') == 200 + ) + + if target_team == 100: + gold_diff = team_100_gold - team_200_gold + else: + gold_diff = team_200_gold - team_100_gold + + return { + 'gold_difference': int(gold_diff), + 'gold_state': 'ahead' if gold_diff > 1000 else 'behind' if gold_diff < -1000 else 'even' + } + + def _get_game_state(self, timestamp: float) -> str: + """ + Determines game state based on timestamp + """ + if timestamp < 15: + return 'early' + elif timestamp < 25: + return 'mid' + else: + return 'late' + +def lambda_handler(event, context): + """ + Processes timeline data and extracts critical events + Triggered when new timeline-data.json uploaded to S3 + """ + + print("Timeline Processor Lambda invoked (S3 Trigger)") + processing_results = [] + + try: + # --- CASE 1: S3 Event Trigger --- + if 'Records' in event: + print(f"Processing {len(event['Records'])} S3 event record(s)") + for record in event['Records']: + bucket = record['s3']['bucket']['name'] + key = record['s3']['object']['key'] + + print(f"Processing file: s3://{bucket}/{key}") + + parts = key.split('/') + if len(parts) < 4: + print(f"Invalid key format: {key}") + continue + + player_folder = parts[1] # GAMENAME_TAGLINE + match_id = parts[2] + + # Download match data + match_key = key.replace('timeline-data.json', 'match-data.json') + match_obj = s3_client.get_object(Bucket=bucket, Key=match_key) + match_data = json.loads(match_obj['Body'].read()) + + # Get target player PUUID + target_puuid = None + player_folder_parts = player_folder.split('_') + if len(player_folder_parts) >= 2: + target_game_name = player_folder_parts[0] + target_tagline = '_'.join(player_folder_parts[1:]) + + print(f"DEBUG: Looking for GameName='{target_game_name}' and Tagline='{target_tagline}'") + + for p in match_data.get('info', {}).get('participants', []): + + p_name = p.get('riotIdGameName') + p_tag = p.get('riotIdTagline') + print(f"DEBUG: Checking participant {p_name}#{p_tag}") + + if p.get('riotIdGameName') == target_game_name and p.get('riotIdTagline') == target_tagline: + target_puuid = p.get('puuid') + print(f"DEBUG: Match found! PUUID is {target_puuid}") + break + + if not target_puuid: + print(f"Warning: Could not find PUUID for {player_folder}. Aborting.") + continue + + # Download timeline data + timeline_obj = s3_client.get_object(Bucket=bucket, Key=key) + timeline_data = json.loads(timeline_obj['Body'].read()) + + print(f"Extracting events for match {match_id}, player {target_puuid}") + + # Extract critical events + extractor = TimelineEventExtractor() + critical_moments = extractor.extract_critical_moments( + timeline_data, match_data, target_puuid + ) + + print(f"Extracted {len(critical_moments)} critical moments") + + # Save to DynamoDB + save_count = 0 + if critical_moments: # Only write if there's something to write + with events_table.batch_writer() as batch: + for moment in critical_moments: + item = { + 'match_id': match_id, + 'event_id': moment['event_id'], + 'puuid': target_puuid, + 'timestamp_minutes': Decimal(str(moment['timestamp_minutes'])), + 'event_type': moment['event_type'], + 'impact_score': moment['impact_score'], + 'game_state': moment['game_state'], + 'event_details': json.dumps(moment['event_details']), + 'context': json.dumps(moment.get('context', {})), + 'created_at': int(datetime.utcnow().timestamp()) + } + batch.put_item(Item=item) + save_count += 1 + + print(f"Saved {save_count} events to DynamoDB") + + # Update metadata table + metadata_table.put_item(Item={ + 'puuid': target_puuid, + 'match_id': match_id, + 'processed_timestamp': int(datetime.utcnow().timestamp()), + 'events_count': len(critical_moments), + 'processing_status': 'completed_s3', # Mark as S3 complete + 'player_folder': player_folder, + 's3_key': key + }) + + print(f"✓ Successfully processed {key}") + processing_results.append({'match_id': match_id, 'events_found': save_count}) + + # --- CASE 2: Step Function Event Trigger --- + elif 'match_id' in event: + # This logic is flawed because it relies on S3 data that might + # not be findable. We will ignore it for now. + # The S3 trigger MUST succeed. + print(f"Warning: Step Function trigger received, but this Lambda is configured for S3 only.") + print(f"Step Function-based processing is not yet implemented correctly.") + # We'll just return success so the SFN can proceed + return { + 'statusCode': 200, + 'body': {'events_extracted': 0, 'message': 'SFN trigger not implemented'} + } + + else: + raise ValueError("Invalid event payload. Expected S3 or SFN trigger.") + + return { + 'statusCode': 200, + 'body': json.dumps({ + 'message': f'Processed {len(processing_results)} match files', + 'results': processing_results + }) + } + + except Exception as e: + print(f"Error processing timeline: {str(e)}") + import traceback + traceback.print_exc() + + return { + 'statusCode': 500, + 'body': json.dumps({'error': str(e)}) + } \ No newline at end of file diff --git a/front-end/components/classroom/question.jsx b/front-end/components/classroom/question.jsx deleted file mode 100644 index 4f2e7b2..0000000 --- a/front-end/components/classroom/question.jsx +++ /dev/null @@ -1,16 +0,0 @@ -import { motion } from "motion/react"; - -const Question = ({ text }) => { - return ( - - {text} - - ); -}; - -export default Question; diff --git a/front-end/components/classroom/response.jsx b/front-end/components/classroom/response.jsx deleted file mode 100644 index cb89737..0000000 --- a/front-end/components/classroom/response.jsx +++ /dev/null @@ -1,86 +0,0 @@ -import { motion } from "motion/react"; - -const Response = ({ questionType, choices, question }) => { - const selectAll = questionType === "selectAll"; - const multipleChoice = questionType === "multipleChoice"; - const shortAnswer = questionType === "shortAnswer"; - return ( - -
- {multipleChoice && ( -
-

Choose One

- - {choices.map((item, index) => ( -
- {" "} - -
- ))} - -
- )} - {selectAll && ( -
-

Select all that apply

- - {choices.map((item, index) => ( -
- {" "} - -
- ))} - -
- )} - {shortAnswer && ( -
-

type your answer

- -
- -
- -
- )} - {!multipleChoice && !selectAll && !shortAnswer && ( -

invalid question type

- )} -
- - ); -}; - -export default Response; diff --git a/front-end/pages/classroom.jsx b/front-end/pages/classroom.jsx deleted file mode 100644 index 937d31a..0000000 --- a/front-end/pages/classroom.jsx +++ /dev/null @@ -1,43 +0,0 @@ -import classroombackground from "@/public/images/classroom-background.png"; -import Image from "next/image"; -import Question from "@/components/classroom/question"; -import yuumiPlaceholder from "@/public/images/Yuumi_BattlePrincipalSkin.webp"; -import Response from "@/components/classroom/response"; -import { motion } from "motion/react"; - -const Classroom = () => { - return ( -
- background image - - yuumi - - -
- -
-
- -
-
- ); -}; - -export default Classroom;