Add exercise progress forecasting

utils.py

@@ -15,12 +15,131 @@ def convert_str_to_date(date_str, format='%Y-%m-%d'):
     except TypeError:
         return None
 
-def get_exercise_graph_model(title, estimated_1rm, repetitions, weight, start_dates, messages, epoch, person_id, exercise_id, min_date=None, max_date=None, degree=1):
-    # Precompute ranges
-    min_date, max_date = min(start_dates), max(start_dates)
-    total_span = (max_date - min_date).days or 1
-
-    min_e1rm, max_e1rm = min(estimated_1rm), max(estimated_1rm)
+def build_forecast(values, dates, horizon_weeks=8, metric='E1RM'):
+    """Build a conservative linear forecast from dated exercise observations."""
+    try:
+        horizon_weeks = max(4, min(int(horizon_weeks), 26))
+    except (TypeError, ValueError):
+        horizon_weeks = 8
+
+    observations = []
+    for value, point_date in zip(values, dates):
+        if value is None or point_date is None:
+            continue
+        try:
+            numeric_value = float(value)
+        except (TypeError, ValueError):
+            continue
+        if isinstance(point_date, datetime):
+            point_date = point_date.date()
+        observations.append((point_date, numeric_value))
+
+    # Multiple sets on one date should not make the forecast look more certain.
+    # Use the best observed value for that date, which matches the E1RM use case.
+    best_by_date = {}
+    for point_date, numeric_value in observations:
+        best_by_date[point_date] = max(best_by_date.get(point_date, numeric_value), numeric_value)
+    observations = sorted(best_by_date.items())
+
+    if len(observations) < 4:
+        return {
+            'available': False,
+            'reason': 'Add at least 4 sessions to generate a forecast.',
+            'metric': metric,
+            'horizon_weeks': horizon_weeks,
+            'observed_points': len(observations)
+        }
+
+    observed_dates = [point_date for point_date, _ in observations]
+    observed_values = np.array([value for _, value in observations], dtype=float)
+    first_date = observed_dates[0]
+    last_date = observed_dates[-1]
+    x = np.array([(point_date - first_date).days for point_date in observed_dates], dtype=float)
+    if len(np.unique(x)) < 3 or x[-1] <= 0:
+        return {
+            'available': False,
+            'reason': 'Use at least 3 different workout dates to generate a forecast.',
+            'metric': metric,
+            'horizon_weeks': horizon_weeks,
+            'observed_points': len(observations)
+        }
+
+    try:
+        slope, intercept = np.polyfit(x, observed_values, 1)
+    except (np.linalg.LinAlgError, ValueError, TypeError):
+        return {
+            'available': False,
+            'reason': 'There is not enough consistent data to generate a forecast.',
+            'metric': metric,
+            'horizon_weeks': horizon_weeks,
+            'observed_points': len(observations)
+        }
+
+    fitted = intercept + slope * x
+    residuals = observed_values - fitted
+    degrees_of_freedom = max(len(observed_values) - 2, 1)
+    residual_std = float(np.sqrt(np.sum(residuals ** 2) / degrees_of_freedom))
+    mean_x = float(np.mean(x))
+    sum_squared_x = float(np.sum((x - mean_x) ** 2)) or 1.0
+    horizon_days = horizon_weeks * 7
+    future_x = np.arange(0, horizon_days + 1, 7, dtype=float) + x[-1]
+    future_dates = [last_date + timedelta(days=int(day - x[-1])) for day in future_x]
+    future_values = intercept + slope * future_x
+
+    # A 95% prediction band, widened for points further from the observations.
+    prediction_error = 1.96 * residual_std * np.sqrt(
+        1 + (1 / len(observed_values)) + ((future_x - mean_x) ** 2 / sum_squared_x)
+    )
+    lower_values = np.maximum(future_values - prediction_error, 0)
+    upper_values = future_values + prediction_error
+
+    total_variation = float(np.sum((observed_values - np.mean(observed_values)) ** 2))
+    residual_variation = float(np.sum(residuals ** 2))
+    r_squared = None if total_variation == 0 else max(0.0, 1 - residual_variation / total_variation)
+    weekly_change = float(slope * 7)
+    confidence = 'High' if len(observed_values) >= 8 and (r_squared is None or r_squared >= 0.6) else 'Moderate'
+    if len(observed_values) < 6 or (r_squared is not None and r_squared < 0.25):
+        confidence = 'Low'
+
+    points = []
+    for point_date, predicted, lower, upper in zip(future_dates, future_values, lower_values, upper_values):
+        points.append({
+            'date': point_date,
+            'value': round(float(predicted), 1),
+            'lower': round(float(lower), 1),
+            'upper': round(float(upper), 1)
+        })
+
+    return {
+        'available': True,
+        'metric': metric,
+        'horizon_weeks': horizon_weeks,
+        'observed_points': len(observations),
+        'last_date': last_date,
+        'last_value': round(float(observed_values[-1]), 1),
+        'projected_value': round(float(future_values[-1]), 1),
+        'weekly_change': round(weekly_change, 1),
+        'r_squared': None if r_squared is None else round(r_squared, 2),
+        'confidence': confidence,
+        'end_date': future_dates[-1],
+        'points': points
+    }
+
+
+def get_exercise_graph_model(title, estimated_1rm, repetitions, weight, start_dates, messages, epoch, person_id, exercise_id, min_date=None, max_date=None, degree=1, forecast_enabled=False, forecast_weeks=8):
+    # Precompute ranges. Forecast values are included so the projected line and
+    # confidence band have room inside the same SVG coordinate system.
+    observed_min_date, observed_max_date = min(start_dates), max(start_dates)
+    forecast = build_forecast(estimated_1rm, start_dates, forecast_weeks, metric='E1RM') if forecast_enabled else {'available': False}
+    chart_max_date = forecast.get('end_date', observed_max_date) if forecast.get('available') else observed_max_date
+    total_span = (chart_max_date - observed_min_date).days or 1
+
+    e1rm_values_for_scale = list(estimated_1rm)
+    if forecast.get('available'):
+        e1rm_values_for_scale.extend([point['lower'] for point in forecast['points']])
+        e1rm_values_for_scale.extend([point['upper'] for point in forecast['points']])
+
+    min_e1rm, max_e1rm = min(e1rm_values_for_scale), max(e1rm_values_for_scale)
     min_reps, max_reps = min(repetitions), max(repetitions)
     min_weight, max_weight = min(weight), max(weight)
 
@@ -34,17 +153,22 @@ def get_exercise_graph_model(title, estimated_1rm, repetitions, weight, start_da
     vb_height *= 75 / vb_height  # Scale to 75px height
 
     # Use NumPy arrays for efficient scaling
-    relative_positions = np.round(np.array([(date - min_date).days / total_span for date in start_dates]), 1)
+    relative_positions = np.round(np.array([(date - observed_min_date).days / total_span for date in start_dates]), 3)
     estimated_1rm_scaled = np.round(((np.array(estimated_1rm) - min_e1rm) / e1rm_range) * vb_height, 1)
     repetitions_scaled = np.round(((np.array(repetitions) - min_reps) / reps_range) * vb_height, 1)
     weight_scaled = np.round(((np.array(weight) - min_weight) / weight_range) * vb_height, 1)
 
     # Calculate slope and line of best fit
     slope_kg_per_day = e1rm_range / total_span
-    best_fit_formula = {
-        'kg_per_week': round(slope_kg_per_day * 7, 1),
-        'kg_per_month': round(slope_kg_per_day * 30, 1)
-    }
+    best_fit_formula = {
+        'kg_per_week': round(slope_kg_per_day * 7, 1),
+        'kg_per_month': round(slope_kg_per_day * 30, 1)
+    }
+    if forecast.get('available'):
+        best_fit_formula = {
+            'kg_per_week': forecast['weekly_change'],
+            'kg_per_month': round(forecast['weekly_change'] * 4.345, 1)
+        }
 
     best_fit_points = []
     try:
@@ -83,7 +207,19 @@ def get_exercise_graph_model(title, estimated_1rm, repetitions, weight, start_da
     }
 
     # Prepare plot labels
-    plot_labels = list(zip(relative_positions.tolist(), messages))
+    plot_labels = list(zip(relative_positions.tolist(), messages))
+
+    forecast_points = []
+    forecast_band_lower = []
+    forecast_band_upper = []
+    forecast_start_position = None
+    if forecast.get('available'):
+        forecast_start_position = round((observed_max_date - observed_min_date).days / total_span, 3)
+        for point in forecast['points']:
+            position = round((point['date'] - observed_min_date).days / total_span, 3)
+            forecast_points.append((round(((point['value'] - min_e1rm) / e1rm_range) * vb_height, 1), position))
+            forecast_band_lower.append((round(((point['lower'] - min_e1rm) / e1rm_range) * vb_height, 1), position))
+            forecast_band_upper.append((round(((point['upper'] - min_e1rm) / e1rm_range) * vb_height, 1), position))
 
     # Return exercise data with SVG dimensions and data points
     return {
@@ -98,10 +234,17 @@ def get_exercise_graph_model(title, estimated_1rm, repetitions, weight, start_da
         'selected_epoch': epoch,
         'person_id': person_id,
         'exercise_id': exercise_id,
-        'min_date': min_date,
-        'max_date': max_date,
-        'degree': degree
-    }
+        'min_date': observed_min_date,
+        'max_date': observed_max_date,
+        'degree': degree,
+        'forecast': forecast,
+        'forecast_enabled': forecast_enabled,
+        'forecast_weeks': forecast_weeks,
+        'forecast_points': forecast_points,
+        'forecast_band_lower': forecast_band_lower,
+        'forecast_band_upper': forecast_band_upper,
+        'forecast_start_position': forecast_start_position
+    }
 
 def get_distinct_colors(n):
     colors = []