Support new analytics payload

api.py

@@ -750,11 +750,139 @@ def safe_float(value):
         return None
 
 
+def frame_number(value):
+    try:
+        if value is None:
+            return None
+        return int(float(value))
+    except Exception:
+        return None
+
+
+def relative_frame(value, start_frame=0, fallback=0):
+    frame = frame_number(value)
+    if frame is None:
+        return fallback
+    start = frame_number(start_frame) or 0
+    return frame - start if frame >= start else frame
+
+
+def safe_metric_value(value):
+    if value is None:
+        return None
+    number = safe_float(value)
+    if number is not None:
+        return round(number, 3)
+    if isinstance(value, (str, bool)):
+        return value
+    if isinstance(value, (dict, list, tuple)):
+        return None
+    return str(value)
+
+
+def point_to_float_list(point):
+    if point is None:
+        return None
+    if hasattr(point, "tolist"):
+        point = point.tolist()
+    try:
+        values = list(point)
+    except Exception:
+        return None
+    if len(values) < 3:
+        return None
+    xyz = []
+    for component in values[:3]:
+        number = safe_float(component)
+        if number is None:
+            return None
+        xyz.append(float(number))
+    return xyz
+
+
+def map_value(mapping, key):
+    if not isinstance(mapping, dict):
+        return None
+    if key in mapping:
+        return mapping[key]
+    str_key = str(key)
+    if str_key in mapping:
+        return mapping[str_key]
+    target = frame_number(key)
+    for current_key, value in mapping.items():
+        if frame_number(current_key) == target:
+            return value
+    return None
+
+
+def skeleton_joint(raw_skel, joint_index):
+    if raw_skel is None:
+        return None
+    if hasattr(raw_skel, "tolist") and not isinstance(raw_skel, dict):
+        raw_skel = raw_skel.tolist()
+    if isinstance(raw_skel, dict):
+        if joint_index in raw_skel:
+            return raw_skel[joint_index]
+        return raw_skel.get(str(joint_index))
+    if isinstance(raw_skel, (list, tuple)) and joint_index < len(raw_skel):
+        return raw_skel[joint_index]
+    return None
+
+
+def max_joint_index(raw_skel):
+    if raw_skel is None:
+        return 32
+    if hasattr(raw_skel, "tolist") and not isinstance(raw_skel, dict):
+        raw_skel = raw_skel.tolist()
+    if isinstance(raw_skel, dict):
+        keys = [frame_number(key) for key in raw_skel.keys()]
+        keys = [key for key in keys if key is not None]
+        return max(keys, default=32)
+    if isinstance(raw_skel, (list, tuple)):
+        return max(32, len(raw_skel) - 1)
+    return 32
+
+
+def build_skeleton_frames(rep, analytics, start_frame, end_frame):
+    tracking_data = analytics.get("tracking_data", {}) if isinstance(analytics, dict) else {}
+    player_skeletons = tracking_data.get("player_skeletons") if isinstance(tracking_data, dict) else None
+    ball_positions = tracking_data.get("ball_positions") if isinstance(tracking_data, dict) else None
+
+    if not isinstance(player_skeletons, dict):
+        player_skeletons = rep.get("skel_history", {})
+    if not isinstance(ball_positions, dict):
+        ball_positions = rep.get("ball_history", {})
+
+    skeleton_frames = []
+    for f_idx in range(start_frame, end_frame + 1):
+        raw_skel = map_value(player_skeletons, f_idx)
+        raw_ball = map_value(ball_positions, f_idx)
+        n_joints = max(33, max_joint_index(raw_skel) + 1)
+        joints = []
+        for joint_index in range(n_joints):
+            point = point_to_float_list(skeleton_joint(raw_skel, joint_index))
+            joints.append(point if point is not None else [0.0, 0.0, 0.0])
+        frame_payload = {"frame": f_idx - start_frame, "joints": joints}
+        ball_point = point_to_float_list(raw_ball)
+        if ball_point is not None:
+            frame_payload["ball"] = ball_point
+        skeleton_frames.append(frame_payload)
+    return skeleton_frames
+
+
 def metric_name(key: str) -> str:
     return key.replace("_", " ").title()
 
 
 FULL_INTERVAL_KEYS = [
+    "head_angle",
+    "left_knee_angle",
+    "right_knee_angle",
+    "trunk_pitch_angle",
+    "active_foot_ball_distance",
+    "stationary_foot_ball_distance_pctw_shoulder",
+    "foot_anteroposterior_offset",
+    "foot_inclination_angle",
     "left_knee_angles",
     "right_knee_angles",
     "torso_pitch_angles",
@@ -767,6 +895,13 @@ ACTION_METRIC_LAYOUTS = {
     "Pass": {
         "pre": ["body_to_ball_angle"],
         "in": [
+            "foot_region",
+            "ball_contact_zone",
+            "head_angle",
+            "left_knee_angle",
+            "right_knee_angle",
+            "trunk_pitch_angle",
+            "stationary_foot_ball_distance_pctw_shoulder",
             "body_to_ball_angle",
             "l_r_foot_distance",
             "trunc_pitch_angle",
@@ -786,8 +921,16 @@ ACTION_METRIC_LAYOUTS = {
         "top_level_scalars": ["backward_weighted_angle", "forward_weighted_angle"],
     },
     "Shot": {
-        "pre": ["body_to_ball_angle"],
+        "pre": ["max_backward_swing_distance", "max_backward_swing_angle", "body_to_ball_angle"],
         "in": [
+            "foot_region",
+            "ball_contact_zone",
+            "head_angle",
+            "left_knee_angle",
+            "right_knee_angle",
+            "trunk_pitch_angle",
+            "stationary_foot_ball_distance_pctw_shoulder",
+            "foot_inclination_angle",
             "body_to_ball_angle",
             "l_r_foot_distance",
             "trunc_pitch_angle",
@@ -805,13 +948,20 @@ ACTION_METRIC_LAYOUTS = {
             "r_elbow_shoulder_hip_angle",
             "active_ankle_angle",
         ],
-        "post": ["head_angle", "body_to_ball_angle"],
+        "post": ["max_forward_swing_distance", "max_forward_swing_angle", "head_angle", "body_to_ball_angle"],
         "top_level_scalars": ["backward_weighted_angle", "forward_weighted_angle"],
     },
     "Receive": {
         "pre": ["body_orientation_vs_ball", "head_angle"],
         "in": [
+            "foot_region",
+            "ball_contact_zone",
             "head_angle",
+            "left_knee_angle",
+            "right_knee_angle",
+            "trunk_pitch_angle",
+            "stationary_foot_ball_distance_pctw_shoulder",
+            "foot_anteroposterior_offset",
             "l_knee_angle",
             "r_knee_angle",
             "trunc_pitch_angle",
@@ -829,15 +979,22 @@ ACTION_METRIC_LAYOUTS = {
     },
     "Dribble": {
         "frames": [
+            "head_angle",
+            "left_knee_angle",
+            "right_knee_angle",
+            "trunk_pitch_angle",
+            "left_heel_height",
+            "right_heel_height",
+            "active_foot_ball_distance",
             "ball_feet_distance",
             "trunk_pitch",
             "trunk_roll",
-            "head_angle",
             "ball_possession_score",
         ],
         "top_level_scalars": [],
     },
 }
+ACTION_METRIC_LAYOUTS["Shoot"] = ACTION_METRIC_LAYOUTS["Shot"]
 
 
 def ordered_metric_keys(observed_keys, preferred_keys=None):
@@ -846,38 +1003,98 @@ def ordered_metric_keys(observed_keys, preferred_keys=None):
     return preferred + extras
 
 
+def is_frame_metric_payload(payload):
+    if isinstance(payload, list):
+        return True
+    if not isinstance(payload, dict) or not payload:
+        return False
+    keys_are_frames = all(frame_number(key) is not None for key in payload.keys())
+    has_metric_dict = any(isinstance(value, dict) for value in payload.values())
+    return keys_are_frames and has_metric_dict
+
+
+def entries_from_frame_payload(payload, start_frame=0):
+    entries = []
+    if isinstance(payload, list):
+        for index, item in enumerate(payload):
+            if not isinstance(item, dict):
+                continue
+            entry = dict(item)
+            entry["frame"] = relative_frame(entry.get("frame", index), start_frame, index)
+            entries.append(entry)
+        return entries
+
+    if not isinstance(payload, dict):
+        return entries
+
+    def sort_key(item):
+        frame = frame_number(item[0])
+        return (frame is None, frame if frame is not None else 0)
+
+    for index, (frame_key, frame_payload) in enumerate(sorted(payload.items(), key=sort_key)):
+        if not isinstance(frame_payload, dict):
+            continue
+        entry = dict(frame_payload)
+        entry["frame"] = relative_frame(frame_key, start_frame, index)
+        entries.append(entry)
+    return entries
+
+
 def build_series_from_entries(entries, unit_for, skip_keys=None, preferred_keys=None):
     skip = {"frame"}
     if skip_keys:
         skip.update(skip_keys)
 
-    metric_keys = set(preferred_keys or [])
+    metric_keys = set()
     for entry in entries:
         metric_keys.update(
             key for key in entry.keys()
-            if key not in skip
+            if key not in skip and safe_float(entry.get(key)) is not None
         )
 
-    series = [
-        format_metric_series(metric_name(key), unit_for(key), [entry.get(key) for entry in entries])
-        for key in ordered_metric_keys(metric_keys, preferred_keys)
-    ]
+    series = []
+    for key in ordered_metric_keys(metric_keys, preferred_keys):
+        series.append({
+            "name": metric_name(key),
+            "unit": unit_for(key),
+            "values": [
+                {
+                    "frame": relative_frame(entry.get("frame"), 0, index),
+                    "value": safe_float(entry.get(key)),
+                }
+                for index, entry in enumerate(entries)
+            ],
+        })
     return series
 
 
+def build_series_from_frame_payload(payload, unit_for, start_frame=0, skip_keys=None, preferred_keys=None):
+    return build_series_from_entries(
+        entries_from_frame_payload(payload, start_frame),
+        unit_for,
+        skip_keys=skip_keys,
+        preferred_keys=preferred_keys,
+    )
+
+
 def build_scalar_metrics(payload, unit_for, skip_keys=None, preferred_keys=None):
+    if not isinstance(payload, dict):
+        return []
     skip = set(skip_keys or [])
+    skip.add("frame")
     metrics = []
-    observed_keys = set(key for key in payload.keys() if key not in skip)
-    observed_keys.update(key for key in (preferred_keys or []) if key not in skip)
+    observed_keys = {
+        key for key, value in payload.items()
+        if key not in skip and not isinstance(value, (dict, list, tuple))
+    }
     for key in ordered_metric_keys(observed_keys, preferred_keys):
         if key in skip:
             continue
-        value = safe_float(payload.get(key))
+        value = safe_metric_value(payload.get(key))
         metrics.append({
             "name": metric_name(key),
-            "value": round(value, 3) if value is not None else None,
-            "unit": unit_for(key),
+            "value": value,
+            "unit": unit_for(key) if isinstance(value, (int, float)) else "",
         })
     return metrics
 
@@ -891,12 +1108,20 @@ def build_top_level_interval_metrics(analytics, unit_for, skip_keys=None, prefer
         "action_frame",
         "post_action",
         "frames",
+        "in_action_data",
+        "pre_action_data",
+        "post_action_data",
+        "full_interval_data",
+        "per_frame",
+        "tracking_data",
     }
     if skip_keys:
         skip.update(skip_keys)
 
-    observed_keys = set(preferred_keys or [])
-    observed_keys.update(analytics.keys())
+    observed_keys = {
+        key for key, value in analytics.items()
+        if key not in skip and isinstance(value, list)
+    }
 
     series = []
     for key in ordered_metric_keys(observed_keys, preferred_keys):
@@ -1028,39 +1253,21 @@ async def analyze_endpoint(
                 })
                 continue
 
-            an = rep["analytics"]
-            sf = rep["start_frame"]
-            ef = rep["end_frame"]
+            an = rep.get("analytics", {})
+            if not isinstance(an, dict):
+                an = {}
+            action_name = rep.get("action", raw.get("label", an.get("action", "Unknown")))
+            sf = int(rep.get("start_frame", 0))
+            ef = int(rep.get("end_frame", sf))
             fps = float(rep.get("fps", 30))
-            is_dribble = (an.get("action") == "Dribble")
-            
-            if is_dribble:
-                tf = (sf + ef) // 2
-            else:
-                tf = an.get("touch_frame", (sf + ef) // 2)
+            is_dribble = action_name.lower() == "dribble" or "per_frame" in an
+            tf = relative_frame(an.get("touch_frame"), sf, (ef - sf) // 2)
             
             # --- Skeleton: support full COCO-25/WB joint range (0–32) ---
-            skeleton_frames = []
-            raw_ball_history = rep.get("ball_history", {})
-            for f_idx in range(sf, ef + 1):
-                raw_skel = rep["skel_history"].get(f_idx, {})
-                raw_ball = raw_ball_history.get(f_idx)
-                # Find the max joint index present so we don't truncate
-                max_joint = max(raw_skel.keys()) if raw_skel else 32
-                n_joints = max(33, max_joint + 1)
-                joints = []
-                for j in range(n_joints):
-                    pt = raw_skel.get(j)
-                    if pt is not None:
-                        joints.append([float(pt[0]), float(pt[1]), float(pt[2])])
-                    else:
-                        joints.append([0.0, 0.0, 0.0])
-                frame_payload = {"frame": f_idx - sf, "joints": joints}
-                if raw_ball is not None:
-                    frame_payload["ball"] = [float(raw_ball[0]), float(raw_ball[1]), float(raw_ball[2])]
-                skeleton_frames.append(frame_payload)
+            skeleton_frames = build_skeleton_frames(rep, an, sf, ef)
             
             # --- Unit dictionary for known metric names ---
+            DEG = "\u00b0"
             UNITS = {
                 "head_angle": "°", "l_knee_angle": "°", "r_knee_angle": "°",
                 "trunc_pitch_angle": "°", "trunc_roll_angle": "°",
@@ -1077,85 +1284,122 @@ async def analyze_endpoint(
                 "active_foot_height_pct": "%", "ball_height_pct_body": "%",
                 "ball_possession_score": "%", "ball_feet_distance": "cm",
             }
+            UNITS.update({
+                "left_knee_angle": DEG,
+                "right_knee_angle": DEG,
+                "trunk_pitch_angle": DEG,
+                "max_backward_swing_angle": DEG,
+                "max_forward_swing_angle": DEG,
+                "foot_inclination_angle": DEG,
+                "active_foot_ball_distance": "cm",
+                "stationary_foot_ball_distance_pctw_shoulder": "%",
+                "left_heel_height": "cm",
+                "right_heel_height": "cm",
+                "foot_anteroposterior_offset": "cm",
+                "max_backward_swing_distance": "cm",
+                "max_forward_swing_distance": "cm",
+            })
             
             def unit_for(key):
                 return UNITS.get(key, "")
             
-            action_layout = ACTION_METRIC_LAYOUTS.get(rep["action"], {})
+            action_layout = ACTION_METRIC_LAYOUTS.get(action_name, {})
+            active_foot = an.get("active_foot")
+            pre_action_metrics = []
+            post_action_metrics = []
 
             if is_dribble:
-                dribble_frames = an.get("frames", [])
-                pre_metrics = build_series_from_entries(
-                    dribble_frames,
-                    unit_for,
-                    preferred_keys=action_layout.get("frames"),
-                )
+                dribble_payload = an.get("per_frame", an.get("frames", []))
+                pre_metrics = []
                 in_action_metrics = []
-                frame_metric_keys = ordered_metric_keys(
-                    {k for frame in dribble_frames for k in frame.keys() if k != "frame"},
-                    action_layout.get("frames"),
-                )
-                for key in frame_metric_keys:
-                    numeric_values = [safe_float(frame.get(key)) for frame in dribble_frames]
-                    numeric_values = [value for value in numeric_values if value is not None]
-                    in_action_metrics.append({
-                        "name": f"Avg {metric_name(key)}",
-                        "value": round(float(np.mean(numeric_values)), 3) if numeric_values else None,
-                        "unit": unit_for(key),
-                    })
                 post_metrics = []
-            else:
-                pre_entries = an.get("pre_action", [])
-                post_entries = an.get("post_action", [])
-                action_frame_data = an.get("action_frame", {})
-                pre_metrics = build_series_from_entries(
-                    pre_entries,
+                full_interval_metrics = build_series_from_frame_payload(
+                    dribble_payload,
                     unit_for,
-                    preferred_keys=action_layout.get("pre"),
+                    start_frame=sf,
+                    preferred_keys=action_layout.get("frames"),
                 )
+            else:
+                pre_payload = an.get("pre_action_data", an.get("pre_action", []))
+                post_payload = an.get("post_action_data", an.get("post_action", []))
+                action_frame_data = an.get("in_action_data", an.get("action_frame", {}))
+                if is_frame_metric_payload(pre_payload):
+                    pre_metrics = build_series_from_frame_payload(
+                        pre_payload,
+                        unit_for,
+                        start_frame=sf,
+                        preferred_keys=action_layout.get("pre"),
+                    )
+                else:
+                    pre_metrics = []
+                    pre_action_metrics = build_scalar_metrics(
+                        pre_payload,
+                        unit_for,
+                        preferred_keys=action_layout.get("pre"),
+                    )
                 in_action_metrics = build_scalar_metrics(
                     action_frame_data,
                     unit_for,
                     skip_keys={"active_foot"},
                     preferred_keys=action_layout.get("in"),
                 )
-                in_action_metrics.extend(
-                    build_scalar_metrics(
-                        an,
+                if "in_action_data" not in an:
+                    in_action_metrics.extend(
+                        build_scalar_metrics(
+                            an,
+                            unit_for,
+                            skip_keys={
+                                "action",
+                                "active_foot",
+                                "touch_frame",
+                                "pre_action",
+                                "action_frame",
+                                "post_action",
+                                "frames",
+                                "left_knee_angles",
+                                "right_knee_angles",
+                                "torso_pitch_angles",
+                                "head_angles",
+                                "mid_foot_ball_distances",
+                                "left_right_foot_distances",
+                            },
+                            preferred_keys=action_layout.get("top_level_scalars"),
+                        )
+                    )
+                if is_frame_metric_payload(post_payload):
+                    post_metrics = build_series_from_frame_payload(
+                        post_payload,
                         unit_for,
-                        skip_keys={
-                            "action",
-                            "active_foot",
-                            "touch_frame",
-                            "pre_action",
-                            "action_frame",
-                            "post_action",
-                            "frames",
-                            "left_knee_angles",
-                            "right_knee_angles",
-                            "torso_pitch_angles",
-                            "head_angles",
-                            "mid_foot_ball_distances",
-                            "left_right_foot_distances",
-                        },
-                        preferred_keys=action_layout.get("top_level_scalars"),
+                        start_frame=sf,
+                        preferred_keys=action_layout.get("post"),
+                    )
+                else:
+                    post_metrics = []
+                    post_action_metrics = build_scalar_metrics(
+                        post_payload,
+                        unit_for,
+                        preferred_keys=action_layout.get("post"),
                     )
-                )
-                post_metrics = build_series_from_entries(
-                    post_entries,
-                    unit_for,
-                    preferred_keys=action_layout.get("post"),
-                )
 
-            full_interval_metrics = build_top_level_interval_metrics(
-                an,
-                unit_for,
-                preferred_keys=FULL_INTERVAL_KEYS,
-            )
+                full_payload = an.get("full_interval_data")
+                if full_payload is not None:
+                    full_interval_metrics = build_series_from_frame_payload(
+                        full_payload,
+                        unit_for,
+                        start_frame=sf,
+                        preferred_keys=FULL_INTERVAL_KEYS,
+                    )
+                else:
+                    full_interval_metrics = build_top_level_interval_metrics(
+                        an,
+                        unit_for,
+                        preferred_keys=FULL_INTERVAL_KEYS,
+                    )
 
             formatted_actions.append({
-                "id": f"{rep['action'].lower()}-{uuid.uuid4().hex[:6]}",
-                "label": rep["action"],
+                "id": f"{action_name.lower()}-{uuid.uuid4().hex[:6]}",
+                "label": action_name,
+                "activeFoot": active_foot,
                 "start": raw.get("start", "00:00:00:00"),
                 "end": raw.get("end", "00:00:00:00"),
                 "fps": fps,
@@ -1164,14 +1408,16 @@ async def analyze_endpoint(
                 "startSeconds": max(0.0, sf / max(1.0, fps)),
                 "endSeconds": max(0.0, (ef + 1) / max(1.0, fps)),
                 "totalFrames": ef - sf + 1,
-                "preFrames": tf - sf,
-                "inFrame": tf - sf,
-                "postFrames": ef - tf,
+                "preFrames": max(0, tf),
+                "inFrame": max(0, tf),
+                "postFrames": max(0, (ef - sf) - tf),
                 "cameraClips": camera_videos,
                 "sourceCameraClips": source_camera_videos,
                 "preMetrics": pre_metrics,
+                "preActionMetrics": pre_action_metrics,
                 "inActionMetrics": in_action_metrics,
                 "postMetrics": post_metrics,
+                "postActionMetrics": post_action_metrics,
                 "fullIntervalMetrics": full_interval_metrics,
                 "skeleton": skeleton_frames,
                 "rawAnalytics": an,