New features / batch processing and PDF reporting

batch_utils.py

@@ -0,0 +1,355 @@
+"""
+Batch processing and PDF generation utilities for Smartwatch Normative Z-Score Calculator.
+
+Author: Lars Masanneck 2026
+"""
+import pandas as pd
+import numpy as np
+from io import BytesIO
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4
+from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.graphics.shapes import Drawing, Rect, Line, String
+
+# Import from the main normalizer model
+import normalizer_model
+
+# Friendly biomarker labels (matching the main app)
+BIOMARKER_LABELS = {
+    "nb_steps": "Number of Steps",
+    "max_steps": "Maximum Steps",
+    "mean_active_time": "Mean Active Time",
+    "sbp": "Systolic Blood Pressure",
+    "dbp": "Diastolic Blood Pressure",
+    "sleep_duration": "Sleep Duration",
+    "avg_night_hr": "Average Night Heart Rate",
+    "nb_moderate_active_minutes": "Moderate Active Minutes",
+    "nb_vigorous_active_minutes": "Vigorous Active Minutes",
+    "weight": "Weight",
+    "pwv": "Pulse Wave Velocity",
+}
+
+# Biomarkers available for batch processing (excluding disabled ones)
+AVAILABLE_BIOMARKERS = [
+    "nb_steps",
+    "max_steps", 
+    "mean_active_time",
+    "sleep_duration",
+    "avg_night_hr",
+    "nb_moderate_active_minutes",
+]
+
+
+def get_batch_template_df():
+    """Return a template DataFrame for batch upload."""
+    return pd.DataFrame({
+        "patient_id": ["P001", "P002", "P003"],
+        "age": [45, 62, 38],
+        "gender": ["Man", "Woman", "Man"],
+        "region": ["Western Europe", "Western Europe", "North America"],
+        "bmi": [24.5, 28.1, 22.3],
+        "nb_steps": [7500, 4200, 9800],
+        "sleep_duration": [7.2, 6.5, 8.1],
+        "avg_night_hr": [62, 68, 58],
+    })
+
+
+def process_batch_data(df: pd.DataFrame, normative_df: pd.DataFrame, 
+                       biomarkers_to_process: list = None) -> pd.DataFrame:
+    """
+    Process batch data and add z-score and percentile columns for selected biomarkers.
+    
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Input data with patient demographics and biomarker values
+    normative_df : pd.DataFrame
+        Normative reference table
+    biomarkers_to_process : list, optional
+        List of biomarker columns to process. If None, auto-detect from data.
+    
+    Returns
+    -------
+    pd.DataFrame
+        Results with z-scores and percentiles added
+    """
+    results = []
+    
+    # Auto-detect biomarkers if not specified
+    if biomarkers_to_process is None:
+        biomarkers_to_process = [col for col in df.columns if col in AVAILABLE_BIOMARKERS]
+    
+    for _, row in df.iterrows():
+        result = row.to_dict()
+        
+        # Process each biomarker
+        for biomarker in biomarkers_to_process:
+            if pd.notna(row.get(biomarker)):
+                try:
+                    res = normalizer_model.compute_normative_position(
+                        value=float(row[biomarker]),
+                        biomarker=biomarker,
+                        age_group=int(row['age']) if pd.notna(row.get('age')) else 45,
+                        region=row.get('region', 'Western Europe'),
+                        gender=row.get('gender', 'Man'),
+                        bmi=float(row.get('bmi', 24.0)) if pd.notna(row.get('bmi')) else 24.0,
+                        normative_df=normative_df,
+                    )
+                    result[f'{biomarker}_z'] = round(res['z_score'], 2)
+                    result[f'{biomarker}_percentile'] = round(res['percentile'], 1)
+                    
+                    # Add interpretation
+                    z = res['z_score']
+                    if z < -2:
+                        result[f'{biomarker}_interpretation'] = 'Very Low'
+                    elif z < -1:
+                        result[f'{biomarker}_interpretation'] = 'Below Average'
+                    elif z < 1:
+                        result[f'{biomarker}_interpretation'] = 'Average'
+                    elif z < 2:
+                        result[f'{biomarker}_interpretation'] = 'Above Average'
+                    else:
+                        result[f'{biomarker}_interpretation'] = 'Very High'
+                        
+                except Exception as e:
+                    result[f'{biomarker}_z'] = 'N/A'
+                    result[f'{biomarker}_percentile'] = 'N/A'
+                    result[f'{biomarker}_interpretation'] = f'Error: {str(e)[:30]}'
+            else:
+                result[f'{biomarker}_z'] = 'N/A'
+                result[f'{biomarker}_percentile'] = 'N/A'
+                result[f'{biomarker}_interpretation'] = 'No data'
+        
+        results.append(result)
+    
+    return pd.DataFrame(results)
+
+
+def create_z_score_gauge(z_score: float, label: str, width: float = 350, height: float = 100) -> Drawing:
+    """Create a horizontal gauge showing z-score position with orange theme."""
+    d = Drawing(width, height)
+    
+    gauge_y = 35
+    gauge_height = 25
+    gauge_left = 50
+    gauge_width = width - 100
+    
+    # Color zones - orange themed
+    zone_colors = [
+        (colors.HexColor('#2ecc71'), -2),   # Green - very low (good for some metrics)
+        (colors.HexColor('#27ae60'), -1),   # Darker green
+        (colors.HexColor('#f39c12'), 0),    # Orange - average
+        (colors.HexColor('#e67e22'), 1),    # Darker orange
+        (colors.HexColor('#d35400'), 2),    # Deep orange
+        (colors.HexColor('#c0392b'), 3),    # Red - extreme
+    ]
+    
+    zone_width = gauge_width / 6
+    for i, (color, _) in enumerate(zone_colors):
+        d.add(Rect(gauge_left + i * zone_width, gauge_y, zone_width, gauge_height, 
+                   fillColor=color, strokeColor=None))
+    
+    # Border
+    d.add(Rect(gauge_left, gauge_y, gauge_width, gauge_height, 
+               fillColor=None, strokeColor=colors.black, strokeWidth=1))
+    
+    # Marker position (clamp z to -3, 3)
+    clamped_z = max(-3, min(3, z_score))
+    marker_x = gauge_left + ((clamped_z + 3) / 6) * gauge_width
+    
+    # Marker line
+    d.add(Line(marker_x, gauge_y - 8, marker_x, gauge_y + gauge_height + 8, 
+               strokeColor=colors.black, strokeWidth=3))
+    
+    # Scale labels
+    for i, val in enumerate([-3, -2, -1, 0, 1, 2, 3]):
+        x = gauge_left + (i / 6) * gauge_width
+        d.add(String(x, gauge_y - 15, str(val), fontSize=9, textAnchor='middle'))
+    
+    # Title
+    d.add(String(width / 2, height - 8, label, fontSize=11, textAnchor='middle', fontName='Helvetica-Bold'))
+    
+    # Z-score value
+    d.add(String(width / 2, gauge_y + gauge_height + 18, f"Z = {z_score:.2f}", 
+                 fontSize=10, textAnchor='middle', fontName='Helvetica-Bold'))
+    
+    return d
+
+
+def generate_pdf_report(patient_info: dict, measurements: dict, z_scores: dict = None) -> BytesIO:
+    """
+    Generate a PDF report for a patient with Z-scores and graphs.
+    
+    Parameters
+    ----------
+    patient_info : dict
+        Patient demographics (age, gender, region, bmi)
+    measurements : dict
+        Biomarker measurements (biomarker_code: value)
+    z_scores : dict
+        Z-score results for each biomarker
+    
+    Returns
+    -------
+    BytesIO
+        PDF buffer ready for download
+    """
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=A4, topMargin=0.5*inch, bottomMargin=0.5*inch)
+    
+    styles = getSampleStyleSheet()
+    
+    # Orange-themed styles
+    title_style = ParagraphStyle(
+        'Title', 
+        parent=styles['Heading1'], 
+        fontSize=18, 
+        spaceAfter=12, 
+        alignment=1,
+        textColor=colors.HexColor('#d35400')
+    )
+    heading_style = ParagraphStyle(
+        'Heading', 
+        parent=styles['Heading2'], 
+        fontSize=14, 
+        spaceAfter=8, 
+        spaceBefore=12,
+        textColor=colors.HexColor('#e67e22')
+    )
+    normal_style = styles['Normal']
+    
+    elements = []
+    
+    # Title
+    elements.append(Paragraph("Smartwatch Normative Z-Score Report", title_style))
+    elements.append(Spacer(1, 0.2*inch))
+    
+    # Patient Information
+    elements.append(Paragraph("Demographics", heading_style))
+    patient_data = [
+        ["Age:", f"{patient_info.get('age', 'N/A')} years"],
+        ["Gender:", patient_info.get('gender', 'N/A')],
+        ["Region:", patient_info.get('region', 'N/A')],
+        ["BMI:", f"{patient_info.get('bmi', 'N/A')}"],
+    ]
+    patient_table = Table(patient_data, colWidths=[2*inch, 4*inch])
+    patient_table.setStyle(TableStyle([
+        ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+        ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+    ]))
+    elements.append(patient_table)
+    elements.append(Spacer(1, 0.2*inch))
+    
+    # Measurements
+    if measurements:
+        elements.append(Paragraph("Measurements", heading_style))
+        measurements_data = []
+        for biomarker, value in measurements.items():
+            label = BIOMARKER_LABELS.get(biomarker, biomarker.replace('_', ' ').title())
+            measurements_data.append([f"{label}:", f"{value}"])
+        
+        if measurements_data:
+            meas_table = Table(measurements_data, colWidths=[2.5*inch, 3.5*inch])
+            meas_table.setStyle(TableStyle([
+                ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+                ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+                ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+            ]))
+            elements.append(meas_table)
+        elements.append(Spacer(1, 0.2*inch))
+    
+    # Z-Score Analysis
+    if z_scores:
+        elements.append(Paragraph("Z-Score Analysis", heading_style))
+        elements.append(Paragraph(
+            "Z-scores indicate how many standard deviations a measurement is from the population mean. "
+            "Values between -2 and +2 are typically considered within normal range.",
+            ParagraphStyle('ZInfo', parent=normal_style, fontSize=9, textColor=colors.grey, spaceAfter=8)
+        ))
+        
+        # Z-score table
+        z_data = [["Biomarker", "Value", "Z-Score", "Percentile", "Interpretation"]]
+        
+        for biomarker, data in z_scores.items():
+            if isinstance(data, dict) and 'z_score' in data:
+                z = data['z_score']
+                pct = data['percentile']
+                value = measurements.get(biomarker, 'N/A')
+                label = BIOMARKER_LABELS.get(biomarker, biomarker.replace('_', ' ').title())
+                
+                # Interpretation
+                if z < -2:
+                    interp = "Very Low"
+                elif z < -1:
+                    interp = "Below Average"
+                elif z < 1:
+                    interp = "Average"
+                elif z < 2:
+                    interp = "Above Average"
+                else:
+                    interp = "Very High"
+                
+                z_data.append([label, str(value), f"{z:.2f}", f"{pct:.1f}%", interp])
+        
+        if len(z_data) > 1:
+            z_table = Table(z_data, colWidths=[1.5*inch, 1*inch, 0.8*inch, 1*inch, 1.2*inch])
+            z_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#e67e22')),
+                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, -1), 9),
+                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+                ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+                ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
+                ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+                ('TOPPADDING', (0, 0), (-1, -1), 6),
+            ]))
+            elements.append(z_table)
+            elements.append(Spacer(1, 0.15*inch))
+            
+            # Add Z-score gauges
+            for biomarker, data in z_scores.items():
+                if isinstance(data, dict) and 'z_score' in data:
+                    label = BIOMARKER_LABELS.get(biomarker, biomarker.replace('_', ' ').title())
+                    gauge = create_z_score_gauge(data['z_score'], label)
+                    elements.append(gauge)
+                    elements.append(Spacer(1, 0.1*inch))
+        
+        elements.append(Spacer(1, 0.2*inch))
+    
+    # Cohort Information
+    elements.append(Paragraph("Reference Population", heading_style))
+    cohort_text = (
+        f"Z-scores calculated using normative data from Withings users in "
+        f"{patient_info.get('region', 'Western Europe')}, filtered by gender "
+        f"({patient_info.get('gender', 'N/A')}), age group, and BMI category."
+    )
+    elements.append(Paragraph(cohort_text, normal_style))
+    elements.append(Spacer(1, 0.3*inch))
+    
+    # Disclaimer
+    disclaimer = Paragraph(
+        "<i>This report is for educational and research purposes only. Z-scores are based on "
+        "Withings population data and may not reflect clinical reference ranges. For detailed "
+        "questions regarding personal health data, contact your healthcare professionals.</i>",
+        ParagraphStyle('Disclaimer', parent=normal_style, fontSize=8, textColor=colors.grey)
+    )
+    elements.append(disclaimer)
+    
+    # Footer
+    elements.append(Spacer(1, 0.2*inch))
+    footer = Paragraph(
+        "Built with ❤️ in Düsseldorf. © Lars Masanneck 2026.",
+        ParagraphStyle('Footer', parent=normal_style, fontSize=8, textColor=colors.grey, alignment=1)
+    )
+    elements.append(footer)
+    
+    doc.build(elements)
+    buffer.seek(0)
+    return buffer
+

pages/1_Batch_Analysis.py

@@ -0,0 +1,268 @@
+"""
+Batch Analysis page for Smartwatch Normative Z-Score Calculator.
+
+Upload multiple patient records for bulk z-score analysis.
+"""
+import streamlit as st
+import pandas as pd
+import sys
+import os
+from io import BytesIO
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from batch_utils import get_batch_template_df, process_batch_data, BIOMARKER_LABELS, AVAILABLE_BIOMARKERS
+import normalizer_model
+
+st.set_page_config(
+    page_title="Batch Analysis - Smartwatch Z-Score Calculator",
+    page_icon="📊",
+    layout="wide",
+)
+
+# Load normative data
+DATA_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "Table_1_summary_measure.csv")
+
+@st.cache_data
+def get_normative_data():
+    try:
+        return normalizer_model.load_normative_table(DATA_PATH)
+    except Exception as e:
+        st.error(f"Could not load normative data: {e}")
+        return None
+
+normative_df = get_normative_data()
+
+st.title("📊 Batch Analysis")
+st.markdown("**Upload multiple patient records for bulk smartwatch biomarker analysis**")
+
+st.info(
+    "Upload an Excel or CSV file with patient data. Each row will be analyzed and "
+    "z-scores will be calculated for all available biomarkers."
+)
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("📥 Download Template")
+    st.markdown("Use this template to prepare your data in the correct format.")
+    
+    template_df = get_batch_template_df()
+    
+    # Create downloadable Excel template
+    output = BytesIO()
+    with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+        template_df.to_excel(writer, index=False, sheet_name='Patient Data')
+        workbook = writer.book
+        worksheet = writer.sheets['Patient Data']
+        
+        # Orange-themed header format
+        header_format = workbook.add_format({
+            'bold': True,
+            'bg_color': '#e67e22',
+            'font_color': 'white',
+            'border': 1
+        })
+        for col_num, value in enumerate(template_df.columns.values):
+            worksheet.write(0, col_num, value, header_format)
+            worksheet.set_column(col_num, col_num, 18)
+    
+    st.download_button(
+        label="⬇️ Download Excel Template",
+        data=output.getvalue(),
+        file_name="smartwatch_zscore_template.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    )
+    
+    st.markdown("#### Required Columns:")
+    st.markdown("""
+    | Column | Description | Example |
+    |--------|-------------|---------|
+    | patient_id | Unique identifier | P001 |
+    | age | Age in years | 45 |
+    | gender | Man/Woman | Man |
+    | region | Geographic region | Western Europe |
+    | bmi | Body Mass Index | 24.5 |
+    """)
+    
+    st.markdown("#### Biomarker Columns (optional):")
+    biomarker_table = "| Column | Description |\n|--------|-------------|\n"
+    for code in AVAILABLE_BIOMARKERS:
+        label = BIOMARKER_LABELS.get(code, code)
+        biomarker_table += f"| {code} | {label} |\n"
+    st.markdown(biomarker_table)
+    
+    st.markdown("*Note: Include only the biomarkers you have data for. Leave cells blank if not measured.*")
+
+with col2:
+    st.subheader("📤 Upload Data")
+    
+    uploaded_file = st.file_uploader(
+        "Choose an Excel or CSV file",
+        type=['xlsx', 'xls', 'csv'],
+        help="Upload a file with patient data following the template format"
+    )
+    
+    if uploaded_file is not None:
+        try:
+            if uploaded_file.name.endswith('.csv'):
+                df = pd.read_csv(uploaded_file)
+            else:
+                df = pd.read_excel(uploaded_file)
+            
+            st.success(f"✅ Loaded {len(df)} patient records")
+            
+            # Detect available biomarkers in the uploaded data
+            detected_biomarkers = [col for col in df.columns if col in AVAILABLE_BIOMARKERS]
+            
+            if detected_biomarkers:
+                st.markdown(f"**Detected biomarkers:** {', '.join([BIOMARKER_LABELS.get(b, b) for b in detected_biomarkers])}")
+            else:
+                st.warning("No recognized biomarker columns found. Please check your column names.")
+            
+            with st.expander("Preview uploaded data"):
+                st.dataframe(df, use_container_width=True)
+            
+        except Exception as e:
+            st.error(f"Error reading file: {str(e)}")
+            df = None
+
+st.markdown("---")
+
+# Processing section
+if uploaded_file is not None and 'df' in dir() and df is not None and normative_df is not None:
+    
+    # Biomarker selection
+    st.subheader("Select Biomarkers to Analyze")
+    detected_biomarkers = [col for col in df.columns if col in AVAILABLE_BIOMARKERS]
+    
+    if detected_biomarkers:
+        selected_biomarkers = st.multiselect(
+            "Choose biomarkers to include in analysis",
+            options=detected_biomarkers,
+            default=detected_biomarkers,
+            format_func=lambda x: BIOMARKER_LABELS.get(x, x)
+        )
+        
+        if st.button("🔬 Process Batch Data", type="primary"):
+            if not selected_biomarkers:
+                st.error("Please select at least one biomarker to analyze.")
+            else:
+                with st.spinner("Processing patient data..."):
+                    results_df = process_batch_data(df, normative_df, selected_biomarkers)
+                
+                st.success("✅ Processing complete!")
+                
+                # Results section
+                st.subheader("Results")
+                
+                # Build display columns dynamically
+                base_cols = ['patient_id', 'age', 'gender', 'region', 'bmi']
+                display_cols = [c for c in base_cols if c in results_df.columns]
+                
+                for bm in selected_biomarkers:
+                    if bm in results_df.columns:
+                        display_cols.append(bm)
+                    if f'{bm}_z' in results_df.columns:
+                        display_cols.append(f'{bm}_z')
+                    if f'{bm}_percentile' in results_df.columns:
+                        display_cols.append(f'{bm}_percentile')
+                    if f'{bm}_interpretation' in results_df.columns:
+                        display_cols.append(f'{bm}_interpretation')
+                
+                available_cols = [c for c in display_cols if c in results_df.columns]
+                
+                # Style function for interpretation columns
+                def highlight_interpretation(val):
+                    if pd.isna(val) or val == 'N/A' or val == 'No data':
+                        return ''
+                    val_str = str(val).lower()
+                    if 'average' in val_str and 'below' not in val_str and 'above' not in val_str:
+                        return 'background-color: #90EE90'  # Green
+                    elif 'below' in val_str:
+                        return 'background-color: #87CEEB'  # Light blue
+                    elif 'above' in val_str:
+                        return 'background-color: #FFD700'  # Gold
+                    elif 'very low' in val_str:
+                        return 'background-color: #ADD8E6'  # Light blue
+                    elif 'very high' in val_str:
+                        return 'background-color: #FF6B6B'  # Red
+                    return ''
+                
+                # Apply styling to interpretation columns
+                interp_cols = [c for c in available_cols if 'interpretation' in c]
+                if interp_cols:
+                    styled_df = results_df[available_cols].style.applymap(
+                        highlight_interpretation,
+                        subset=interp_cols
+                    )
+                    st.dataframe(styled_df, use_container_width=True)
+                else:
+                    st.dataframe(results_df[available_cols], use_container_width=True)
+                
+                # Summary Statistics
+                st.subheader("Summary Statistics")
+                
+                # Create columns for each biomarker
+                if len(selected_biomarkers) > 0:
+                    cols = st.columns(min(len(selected_biomarkers), 3))
+                    
+                    for idx, bm in enumerate(selected_biomarkers[:3]):
+                        with cols[idx]:
+                            st.markdown(f"**{BIOMARKER_LABELS.get(bm, bm)}**")
+                            z_col = f'{bm}_z'
+                            if z_col in results_df.columns:
+                                # Filter out non-numeric values
+                                z_values = pd.to_numeric(results_df[z_col], errors='coerce').dropna()
+                                if len(z_values) > 0:
+                                    st.metric("Mean Z-Score", f"{z_values.mean():.2f}")
+                                    st.metric("Patients Analyzed", len(z_values))
+                                    
+                                    # Distribution of interpretations
+                                    interp_col = f'{bm}_interpretation'
+                                    if interp_col in results_df.columns:
+                                        interp_counts = results_df[interp_col].value_counts()
+                                        st.bar_chart(interp_counts)
+                
+                # Export Results
+                st.subheader("📥 Export Results")
+                
+                output = BytesIO()
+                with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+                    results_df.to_excel(writer, index=False, sheet_name='Results')
+                    workbook = writer.book
+                    worksheet = writer.sheets['Results']
+                    
+                    # Orange-themed header
+                    header_format = workbook.add_format({
+                        'bold': True,
+                        'bg_color': '#e67e22',
+                        'font_color': 'white',
+                        'border': 1
+                    })
+                    for col_num, value in enumerate(results_df.columns.values):
+                        worksheet.write(0, col_num, value, header_format)
+                        worksheet.set_column(col_num, col_num, 18)
+                
+                st.download_button(
+                    label="⬇️ Download Results as Excel",
+                    data=output.getvalue(),
+                    file_name="smartwatch_zscore_results.xlsx",
+                    mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                )
+    else:
+        st.warning(
+            "No recognized biomarker columns found in your data. "
+            "Please ensure your columns match the template format."
+        )
+
+# Footer
+st.markdown("---")
+st.markdown(
+    "*Batch analysis calculates z-scores relative to the Withings normative population, "
+    "stratified by region, gender, age group, and BMI category.*"
+)
+st.markdown(
+    "Built with ❤️ in Düsseldorf. © Lars Masanneck 2026."
+)
+

pages/2_PDF_Report.py

@@ -0,0 +1,288 @@
+"""
+PDF Report Generator page for Smartwatch Normative Z-Score Calculator.
+
+Generate downloadable PDF reports for individual patients.
+"""
+import streamlit as st
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from batch_utils import generate_pdf_report, BIOMARKER_LABELS, AVAILABLE_BIOMARKERS
+import normalizer_model
+
+st.set_page_config(
+    page_title="PDF Report - Smartwatch Z-Score Calculator",
+    page_icon="📄",
+    layout="wide",
+)
+
+# Load normative data
+DATA_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "Table_1_summary_measure.csv")
+
+@st.cache_data
+def get_normative_data():
+    try:
+        return normalizer_model.load_normative_table(DATA_PATH)
+    except Exception as e:
+        st.error(f"Could not load normative data: {e}")
+        return None
+
+normative_df = get_normative_data()
+
+st.title("📄 PDF Report Generator")
+st.markdown("**Generate a professional smartwatch biomarker report for download**")
+
+st.info(
+    "Enter patient information and biomarker measurements below to generate a downloadable PDF report "
+    "with z-scores, percentiles, and visual gauges."
+)
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("👤 Patient Information")
+    
+    patient_name = st.text_input(
+        "Patient Name/ID (optional)", 
+        placeholder="e.g., John Doe or P001"
+    )
+    
+    # Region with default Western Europe
+    if normative_df is not None:
+        regions = sorted(normative_df["area"].unique())
+        if "Western Europe" in regions:
+            default_region_idx = regions.index("Western Europe")
+        else:
+            default_region_idx = 0
+    else:
+        regions = ["Western Europe", "Southern Europe", "North America", "Japan"]
+        default_region_idx = 0
+    
+    region = st.selectbox(
+        "Region",
+        regions,
+        index=default_region_idx
+    )
+    
+    # Gender
+    if normative_df is not None:
+        genders = sorted(normative_df["gender"].unique())
+    else:
+        genders = ["Man", "Woman"]
+    
+    gender = st.selectbox("Gender", genders)
+    
+    age = st.number_input(
+        "Age (years)",
+        min_value=0,
+        max_value=120,
+        value=45
+    )
+    
+    bmi = st.number_input(
+        "BMI",
+        min_value=10.0,
+        max_value=60.0,
+        value=24.0,
+        step=0.1,
+        format="%.1f"
+    )
+
+with col2:
+    st.subheader("📊 Biomarker Measurements")
+    st.caption("Select which biomarkers to include in the report")
+    
+    # Biomarker inputs with checkboxes
+    measurements = {}
+    
+    include_steps = st.checkbox("Include Number of Steps", value=True)
+    if include_steps:
+        measurements['nb_steps'] = st.number_input(
+            "Number of Steps",
+            min_value=0.0,
+            max_value=50000.0,
+            value=6500.0,
+            step=100.0
+        )
+    
+    include_sleep = st.checkbox("Include Sleep Duration", value=True)
+    if include_sleep:
+        measurements['sleep_duration'] = st.number_input(
+            "Sleep Duration (hours)",
+            min_value=0.0,
+            max_value=24.0,
+            value=7.5,
+            step=0.1,
+            format="%.1f"
+        )
+    
+    include_hr = st.checkbox("Include Average Night Heart Rate", value=True)
+    if include_hr:
+        measurements['avg_night_hr'] = st.number_input(
+            "Average Night Heart Rate (bpm)",
+            min_value=30.0,
+            max_value=150.0,
+            value=62.0,
+            step=1.0
+        )
+    
+    include_active = st.checkbox("Include Mean Active Time", value=False)
+    if include_active:
+        measurements['mean_active_time'] = st.number_input(
+            "Mean Active Time (minutes)",
+            min_value=0.0,
+            max_value=1440.0,
+            value=45.0,
+            step=1.0
+        )
+    
+    include_moderate = st.checkbox("Include Moderate Active Minutes", value=False)
+    if include_moderate:
+        measurements['nb_moderate_active_minutes'] = st.number_input(
+            "Moderate Active Minutes",
+            min_value=0.0,
+            max_value=1440.0,
+            value=30.0,
+            step=1.0
+        )
+
+st.markdown("---")
+
+# Generate Report Button
+if st.button("📄 Generate PDF Report", type="primary"):
+    if not measurements:
+        st.error("Please include at least one biomarker measurement.")
+    elif normative_df is None:
+        st.error("Normative data not loaded. Cannot generate report.")
+    else:
+        patient_info = {
+            'name': patient_name if patient_name else 'Not specified',
+            'age': age,
+            'gender': gender,
+            'region': region,
+            'bmi': bmi
+        }
+        
+        # Calculate z-scores for each included biomarker
+        z_scores = {}
+        errors = []
+        
+        for biomarker, value in measurements.items():
+            try:
+                result = normalizer_model.compute_normative_position(
+                    value=value,
+                    biomarker=biomarker,
+                    age_group=age,
+                    region=region,
+                    gender=gender,
+                    bmi=bmi,
+                    normative_df=normative_df
+                )
+                z_scores[biomarker] = result
+            except Exception as e:
+                errors.append(f"{BIOMARKER_LABELS.get(biomarker, biomarker)}: {str(e)}")
+        
+        if errors:
+            for err in errors:
+                st.warning(f"Z-score calculation note: {err}")
+        
+        if z_scores:
+            with st.spinner("Generating PDF report..."):
+                pdf_buffer = generate_pdf_report(patient_info, measurements, z_scores)
+            
+            st.success("✅ PDF report generated successfully!")
+            
+            # Report Preview
+            st.subheader("Report Preview")
+            
+            with st.expander("View Report Contents", expanded=True):
+                st.markdown("### Demographics")
+                st.markdown(f"- **Age:** {age} years")
+                st.markdown(f"- **Gender:** {gender}")
+                st.markdown(f"- **Region:** {region}")
+                st.markdown(f"- **BMI:** {bmi}")
+                
+                st.markdown("### Measurements & Z-Scores")
+                
+                # Create columns for z-score display
+                num_scores = len(z_scores)
+                if num_scores > 0:
+                    cols = st.columns(min(num_scores, 3))
+                    
+                    for idx, (biomarker, data) in enumerate(z_scores.items()):
+                        with cols[idx % 3]:
+                            label = BIOMARKER_LABELS.get(biomarker, biomarker)
+                            z = data['z_score']
+                            pct = data['percentile']
+                            value = measurements[biomarker]
+                            
+                            # Determine interpretation
+                            if z < -2:
+                                interp = "Very Low"
+                            elif z < -1:
+                                interp = "Below Average"
+                            elif z < 1:
+                                interp = "Average"
+                            elif z < 2:
+                                interp = "Above Average"
+                            else:
+                                interp = "Very High"
+                            
+                            st.metric(
+                                label,
+                                f"Z = {z:.2f}",
+                                f"{pct:.1f}th percentile"
+                            )
+                            st.caption(f"Value: {value} | {interp}")
+                
+                # Cohort info
+                age_group_str = normalizer_model._categorize_age(age, normative_df)
+                bmi_cat = normalizer_model.categorize_bmi(bmi)
+                st.markdown("### Reference Population")
+                st.markdown(
+                    f"Z-scores calculated from normative data: **{region}**, "
+                    f"**{gender}**, age group **{age_group_str}**, BMI category **{bmi_cat}**."
+                )
+            
+            # Download button
+            filename = f"smartwatch_report_{patient_name.replace(' ', '_') if patient_name else 'patient'}.pdf"
+            
+            st.download_button(
+                label="⬇️ Download PDF Report",
+                data=pdf_buffer,
+                file_name=filename,
+                mime="application/pdf"
+            )
+        else:
+            st.error("Could not calculate z-scores for any biomarkers. Please check your inputs.")
+
+# Information section
+st.markdown("---")
+
+st.markdown("### Report Contents")
+st.markdown("""
+The generated PDF report includes:
+
+1. **Patient Demographics** - Age, gender, region, BMI
+2. **Biomarker Measurements** - All selected smartwatch metrics
+3. **Z-Score Analysis** - Comparison to normative population data
+   - Z-scores and percentiles for each biomarker
+   - Visual gauge charts showing position in distribution
+   - Interpretation (Very Low → Average → Very High)
+4. **Reference Population Info** - Details about the comparison cohort
+
+*All reports include a disclaimer noting educational/research purpose.*
+""")
+
+# Footer
+st.markdown("---")
+st.markdown(
+    "*PDF reports are for educational and research purposes. "
+    "For detailed questions regarding personal health data, contact your healthcare professionals.*"
+)
+st.markdown(
+    "Built with ❤️ in Düsseldorf. © Lars Masanneck 2026."
+)
+

requirements.txt

@@ -7,4 +7,6 @@ matplotlib==3.8.0
 seaborn==0.13.0
 openpyxl==3.1.2
 altair==5.5.0
-plotly==5.21.0
+plotly==5.21.0
+reportlab==4.0.0
+xlsxwriter==3.1.9