removing old endpoints etc

visualizers/report_generator.py

@@ -40,8 +40,8 @@ class ReportGenerator:
         self.jinja_env.filters['format_power'] = self._format_power
         self.jinja_env.filters['format_heart_rate'] = self._format_heart_rate
     
-    def generate_workout_report(self, workout: WorkoutData, analysis: Dict[str, Any], 
-                              format: str = 'html') -> str:
+    def generate_workout_report(self, workout: WorkoutData, analysis: Dict[str, Any],
+                               format: str = 'html') -> str:
         """Generate comprehensive workout report.
         
         Args:
@@ -50,7 +50,7 @@ class ReportGenerator:
             format: Report format ('html', 'pdf', 'markdown')
             
         Returns:
-            Path to generated report
+            Rendered report content as a string (for html/markdown) or path to PDF file.
         """
         # Prepare report data
         report_data = self._prepare_report_data(workout, analysis)
@@ -59,7 +59,7 @@ class ReportGenerator:
         if format == 'html':
             return self._generate_html_report(report_data)
         elif format == 'pdf':
-            return self._generate_pdf_report(report_data)
+            return self._generate_pdf_report(report_data, workout.metadata.activity_name)
         elif format == 'markdown':
             return self._generate_markdown_report(report_data)
         else:
@@ -75,24 +75,57 @@ class ReportGenerator:
         Returns:
             Dictionary with report data
         """
-        return {
-            'workout': {
-                'metadata': workout.metadata,
-                'summary': analysis.get('summary', {}),
-                'power_analysis': analysis.get('power_analysis', {}),
-                'heart_rate_analysis': analysis.get('heart_rate_analysis', {}),
-                'speed_analysis': analysis.get('speed_analysis', {}),
-                'elevation_analysis': analysis.get('elevation_analysis', {}),
-                'intervals': analysis.get('intervals', []),
-                'zones': analysis.get('zones', {}),
-                'efficiency': analysis.get('efficiency', {})
+        # Normalize and alias data for template compatibility
+        summary = analysis.get('summary', {})
+        summary['avg_speed'] = summary.get('avg_speed_kmh')
+        summary['avg_heart_rate'] = summary.get('avg_hr')
+
+        power_analysis = analysis.get('power_analysis', {})
+        if 'avg_power' not in power_analysis and 'avg_power' in summary:
+            power_analysis['avg_power'] = summary['avg_power']
+        if 'max_power' not in power_analysis and 'max_power' in summary:
+            power_analysis['max_power'] = summary['max_power']
+
+        heart_rate_analysis = analysis.get('heart_rate_analysis', {})
+        if 'avg_hr' not in heart_rate_analysis and 'avg_hr' in summary:
+            heart_rate_analysis['avg_hr'] = summary['avg_hr']
+        if 'max_hr' not in heart_rate_analysis and 'max_hr' in summary:
+            heart_rate_analysis['max_hr'] = summary['max_hr']
+        # For templates using avg_heart_rate
+        heart_rate_analysis['avg_heart_rate'] = heart_rate_analysis.get('avg_hr')
+        heart_rate_analysis['max_heart_rate'] = heart_rate_analysis.get('max_hr')
+
+
+        speed_analysis = analysis.get('speed_analysis', {})
+        speed_analysis['avg_speed'] = speed_analysis.get('avg_speed_kmh')
+        speed_analysis['max_speed'] = speed_analysis.get('max_speed_kmh')
+
+
+        report_context = {
+            "workout": {
+                "metadata": workout.metadata,
+                "summary": summary,
+                "power_analysis": power_analysis,
+                "heart_rate_analysis": heart_rate_analysis,
+                "speed_analysis": speed_analysis,
+                "elevation_analysis": analysis.get("elevation_analysis", {}),
+                "intervals": analysis.get("intervals", []),
+                "zones": analysis.get("zones", {}),
+                "efficiency": analysis.get("efficiency", {}),
+            },
+            "report": {
+                "generated_at": datetime.now().isoformat(),
+                "version": "1.0.0",
+                "tool": "Garmin Analyser",
             },
-            'report': {
-                'generated_at': datetime.now().isoformat(),
-                'version': '1.0.0',
-                'tool': 'Garmin Analyser'
-            }
         }
+
+        # Add minute-by-minute aggregation if data is available
+        if workout.df is not None and not workout.df.empty:
+            report_context["minute_by_minute"] = self._aggregate_minute_by_minute(
+                workout.df, analysis
+            )
+        return report_context
     
     def _generate_html_report(self, report_data: Dict[str, Any]) -> str:
         """Generate HTML report.
@@ -101,36 +134,40 @@ class ReportGenerator:
             report_data: Report data
             
         Returns:
-            Path to generated HTML report
+            Rendered HTML content as a string.
         """
         template = self.jinja_env.get_template('workout_report.html')
         html_content = template.render(**report_data)
         
-        output_path = Path('reports') / f"workout_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html"
-        output_path.parent.mkdir(exist_ok=True)
-        
-        with open(output_path, 'w', encoding='utf-8') as f:
-            f.write(html_content)
-        
-        return str(output_path)
+        # In a real application, you might save this to a file or return it directly
+        # For testing, we return the content directly
+        return html_content
     
-    def _generate_pdf_report(self, report_data: Dict[str, Any]) -> str:
+    def _generate_pdf_report(self, report_data: Dict[str, Any], activity_name: str) -> str:
         """Generate PDF report.
         
         Args:
             report_data: Report data
+            activity_name: Name of the activity for the filename.
             
         Returns:
-            Path to generated PDF report
+            Path to generated PDF report.
         """
-        # First generate HTML
-        html_path = self._generate_html_report(report_data)
+        html_content = self._generate_html_report(report_data)
         
-        # Convert to PDF
-        pdf_path = html_path.replace('.html', '.pdf')
-        HTML(html_path).write_pdf(pdf_path)
+        output_dir = Path('reports')
+        output_dir.mkdir(exist_ok=True)
         
-        return pdf_path
+        # Sanitize activity_name for filename
+        sanitized_activity_name = "".join(
+            [c if c.isalnum() or c in (' ', '-', '_') else '_' for c in activity_name]
+        ).replace(' ', '_')
+        
+        pdf_path = output_dir / f"{sanitized_activity_name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+        
+        HTML(string=html_content).write_pdf(str(pdf_path))
+        
+        return str(pdf_path)
     
     def _generate_markdown_report(self, report_data: Dict[str, Any]) -> str:
         """Generate Markdown report.
@@ -139,44 +176,52 @@ class ReportGenerator:
             report_data: Report data
             
         Returns:
-            Path to generated Markdown report
+            Rendered Markdown content as a string.
         """
         template = self.jinja_env.get_template('workout_report.md')
         markdown_content = template.render(**report_data)
         
-        output_path = Path('reports') / f"workout_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
-        output_path.parent.mkdir(exist_ok=True)
-        
-        with open(output_path, 'w', encoding='utf-8') as f:
-            f.write(markdown_content)
-        
-        return str(output_path)
+        # In a real application, you might save this to a file or return it directly
+        # For testing, we return the content directly
+        return markdown_content
     
-    def generate_summary_report(self, workouts: List[WorkoutData], 
-                              analyses: List[Dict[str, Any]]) -> str:
+    def generate_summary_report(self, workouts: List[WorkoutData],
+                               analyses: List[Dict[str, Any]],
+                               format: str = 'html') -> str:
         """Generate summary report for multiple workouts.
         
         Args:
             workouts: List of WorkoutData objects
             analyses: List of analysis results
+            format: Report format ('html', 'pdf', 'markdown')
             
         Returns:
-            Path to generated summary report
+            Rendered summary report content as a string (for html/markdown) or path to PDF file.
         """
         # Aggregate data
         summary_data = self._aggregate_workout_data(workouts, analyses)
         
-        # Generate summary report
+        # Generate report based on format
+        if format == 'html':
+            template = self.jinja_env.get_template("summary_report.html")
+            return template.render(**summary_data)
+        elif format == 'pdf':
+            html_content = self._generate_summary_html_report(summary_data)
+            output_dir = Path('reports')
+            output_dir.mkdir(exist_ok=True)
+            pdf_path = output_dir / f"summary_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+            HTML(string=html_content).write_pdf(str(pdf_path))
+            return str(pdf_path)
+        elif format == 'markdown':
+            template = self.jinja_env.get_template('summary_report.md')
+            return template.render(**summary_data)
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+
+    def _generate_summary_html_report(self, report_data: Dict[str, Any]) -> str:
+        """Helper to generate HTML for summary report, used by PDF generation."""
         template = self.jinja_env.get_template('summary_report.html')
-        html_content = template.render(**summary_data)
-        
-        output_path = Path('reports') / f"summary_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html"
-        output_path.parent.mkdir(exist_ok=True)
-        
-        with open(output_path, 'w', encoding='utf-8') as f:
-            f.write(html_content)
-        
-        return str(output_path)
+        return template.render(**report_data)
     
     def _aggregate_workout_data(self, workouts: List[WorkoutData], 
                               analyses: List[Dict[str, Any]]) -> Dict[str, Any]:
@@ -195,11 +240,11 @@ class ReportGenerator:
         for workout, analysis in zip(workouts, analyses):
             data = {
                 'date': workout.metadata.start_time,
-                'activity_type': workout.metadata.activity_type,
+                'activity_type': workout.metadata.sport or workout.metadata.activity_type,
                 'duration_minutes': analysis.get('summary', {}).get('duration_minutes', 0),
                 'distance_km': analysis.get('summary', {}).get('distance_km', 0),
                 'avg_power': analysis.get('summary', {}).get('avg_power', 0),
-                'avg_heart_rate': analysis.get('summary', {}).get('avg_heart_rate', 0),
+                'avg_heart_rate': analysis.get('summary', {}).get('avg_hr', 0),
                 'avg_speed': analysis.get('summary', {}).get('avg_speed_kmh', 0),
                 'elevation_gain': analysis.get('summary', {}).get('elevation_gain_m', 0),
                 'calories': analysis.get('summary', {}).get('calories', 0),
@@ -237,6 +282,74 @@ class ReportGenerator:
             }
         }
     
+    def _aggregate_minute_by_minute(
+        self, df: pd.DataFrame, analysis: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """Aggregate workout data into minute-by-minute summaries.
+
+        Args:
+            df: Workout DataFrame.
+            analysis: Analysis results.
+
+        Returns:
+            A list of dictionaries, each representing one minute of the workout.
+        """
+        if "timestamp" not in df.columns:
+            return []
+
+        df = df.copy()
+        df["elapsed_time"] = (
+            df["timestamp"] - df["timestamp"].iloc[0]
+        ).dt.total_seconds()
+        df["minute_index"] = (df["elapsed_time"] // 60).astype(int)
+
+        agg_rules = {}
+        if "speed" in df.columns:
+            agg_rules["avg_speed_kmh"] = ("speed", "mean")
+        if "cadence" in df.columns:
+            agg_rules["avg_cadence"] = ("cadence", "mean")
+        if "heart_rate" in df.columns:
+            agg_rules["avg_hr"] = ("heart_rate", "mean")
+            agg_rules["max_hr"] = ("heart_rate", "max")
+        if "power" in df.columns:
+            agg_rules["avg_real_power"] = ("power", "mean")
+        elif "estimated_power" in df.columns:
+            agg_rules["avg_power_estimate"] = ("estimated_power", "mean")
+
+        if not agg_rules:
+            return []
+
+        minute_stats = df.groupby("minute_index").agg(**agg_rules).reset_index()
+
+        # Distance and elevation require special handling
+        if "distance" in df.columns:
+            minute_stats["distance_km"] = (
+                df.groupby("minute_index")["distance"]
+                .apply(lambda x: (x.max() - x.min()) / 1000.0)
+                .values
+            )
+        if "altitude" in df.columns:
+            minute_stats["elevation_change"] = (
+                df.groupby("minute_index")["altitude"]
+                .apply(lambda x: x.iloc[-1] - x.iloc[0] if not x.empty else 0)
+                .values
+            )
+        if "gradient" in df.columns:
+            minute_stats["avg_gradient"] = (
+                df.groupby("minute_index")["gradient"].mean().values
+            )
+
+        # Convert to km/h if speed is in m/s
+        if "avg_speed_kmh" in minute_stats.columns:
+            minute_stats["avg_speed_kmh"] *= 3.6
+
+        # Round and format
+        for col in minute_stats.columns:
+            if minute_stats[col].dtype == "float64":
+                minute_stats[col] = minute_stats[col].round(2)
+
+        return minute_stats.to_dict("records")
+
     def _format_duration(self, seconds: float) -> str:
         """Format duration in seconds to human-readable format.
         
@@ -246,6 +359,8 @@ class ReportGenerator:
         Returns:
             Formatted duration string
         """
+        if pd.isna(seconds):
+            return ""
         hours = int(seconds // 3600)
         minutes = int((seconds % 3600) // 60)
         seconds = int(seconds % 60)
@@ -470,6 +585,40 @@ class ReportGenerator:
             </tr>
         </table>
         
+        {% if minute_by_minute %}
+        <h2>Minute-by-Minute Analysis</h2>
+        <table>
+            <thead>
+                <tr>
+                    <th>Minute</th>
+                    <th>Distance (km)</th>
+                    <th>Avg Speed (km/h)</th>
+                    <th>Avg Cadence</th>
+                    <th>Avg HR</th>
+                    <th>Max HR</th>
+                    <th>Avg Gradient (%)</th>
+                    <th>Elevation Change (m)</th>
+                    <th>Avg Power (W)</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for row in minute_by_minute %}
+                <tr>
+                    <td>{{ row.minute_index }}</td>
+                    <td>{{ "%.2f"|format(row.distance_km) if row.distance_km is not none }}</td>
+                    <td>{{ "%.1f"|format(row.avg_speed_kmh) if row.avg_speed_kmh is not none }}</td>
+                    <td>{{ "%.0f"|format(row.avg_cadence) if row.avg_cadence is not none }}</td>
+                    <td>{{ "%.0f"|format(row.avg_hr) if row.avg_hr is not none }}</td>
+                    <td>{{ "%.0f"|format(row.max_hr) if row.max_hr is not none }}</td>
+                    <td>{{ "%.1f"|format(row.avg_gradient) if row.avg_gradient is not none }}</td>
+                    <td>{{ "%.1f"|format(row.elevation_change) if row.elevation_change is not none }}</td>
+                    <td>{{ "%.0f"|format(row.avg_real_power or row.avg_power_estimate) if (row.avg_real_power or row.avg_power_estimate) is not none }}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+        {% endif %}
+
         <div class="footer">
             <p>Report generated on {{ report.generated_at }} using {{ report.tool }} v{{ report.version }}</p>
         </div>
@@ -516,6 +665,16 @@ class ReportGenerator:
 - **Average Speed:** {{ workout.speed_analysis.avg_speed|format_speed }}
 - **Maximum Speed:** {{ workout.speed_analysis.max_speed|format_speed }}
 
+{% if minute_by_minute %}
+### Minute-by-Minute Analysis
+
+| Minute | Dist (km) | Speed (km/h) | Cadence | HR | Max HR | Grad (%) | Elev (m) | Power (W) |
+|--------|-----------|--------------|---------|----|--------|----------|----------|-----------|
+{% for row in minute_by_minute -%}
+| {{ row.minute_index }} | {{ "%.2f"|format(row.distance_km) if row.distance_km is not none }} | {{ "%.1f"|format(row.avg_speed_kmh) if row.avg_speed_kmh is not none }} | {{ "%.0f"|format(row.avg_cadence) if row.avg_cadence is not none }} | {{ "%.0f"|format(row.avg_hr) if row.avg_hr is not none }} | {{ "%.0f"|format(row.max_hr) if row.max_hr is not none }} | {{ "%.1f"|format(row.avg_gradient) if row.avg_gradient is not none }} | {{ "%.1f"|format(row.elevation_change) if row.elevation_change is not none }} | {{ "%.0f"|format(row.avg_real_power or row.avg_power_estimate) if (row.avg_real_power or row.avg_power_estimate) is not none }} |
+{% endfor %}
+{% endif %}
+
 ---
 
 *Report generated on {{ report.generated_at }} using {{ report.tool }} v{{ report.version }}*"""