feat: implement P1 UX improvements - export, validation, and accessibility

- Add PDF and CSV export functionality with formatted reports
- Implement real-time form validation (email format, password match)
- Add password strength meter with NIST 2024 compliance indicators
- Fix correlation matrix to include all portfolio assets
- Improve WCAG AA colour contrast for accessibility
- Add focus indicators for keyboard navigation
- Update dependencies: reportlab, pypdf, matplotlib, plotly

Phase 7: Export functionality
- New module: backend/export.py with PDF/CSV generation
- Export buttons in results page header
- Temporary file handling for downloads

Phase 8: Form validation
- Real-time email validation with regex
- Password match confirmation
- Visual feedback with checkmarks

Phase 9: Bug fixes and accessibility
- Correlation matrix length alignment fix
- Enhanced colour contrast (demo subtitle, disclaimers, placeholders)
- 3px focus outline for keyboard users

Phase 13: Password strength meter
- 4-tier strength indicator (weak to strong)
- Contextual feedback and improvement suggestions
- Emphasises 15+ character NIST requirement

app.py

@@ -57,6 +57,7 @@ from backend.rate_limiting import (
 )
 from backend.rate_limiting.fixed_window import TieredFixedWindowLimiter
 from backend.auth import auth, UserSession
+from backend.export import export_analysis_to_csv, export_analysis_to_pdf
 
 def check_authentication(session_state: Dict) -> bool:
     """Check if user is authenticated or in demo mode."""
@@ -1569,6 +1570,35 @@ def create_interface() -> gr.Blocks:
             max-height: 400px;
         }
     }
+
+    /* Accessibility - WCAG AA Colour Contrast Improvements */
+    .demo-subtitle {
+        color: rgba(255, 255, 255, 0.95) !important;  /* Increased from 0.7 for better contrast */
+        font-size: 14px;
+    }
+
+    .disclaimer-text {
+        color: rgba(255, 255, 255, 0.95) !important;  /* Increased contrast */
+        font-size: 13px;
+    }
+
+    /* Update all placeholder text for better visibility */
+    input::placeholder, textarea::placeholder {
+        color: rgba(255, 255, 255, 0.7) !important;  /* Increased from 0.5 */
+    }
+
+    /* Add focus indicators for keyboard navigation */
+    input:focus, textarea:focus, button:focus, select:focus {
+        outline: 3px solid #4A9EFF !important;
+        outline-offset: 2px;
+    }
+
+    /* Validation message colours with better contrast */
+    #signup-email-validation, #password-match-validation {
+        font-size: 0.85rem;
+        margin-top: 0.25rem;
+        font-weight: 500;
+    }
     """
 
     with gr.Blocks(
@@ -1639,14 +1669,16 @@ def create_interface() -> gr.Blocks:
                 # Login Tab
                 with gr.Tab("Sign In"):
                     login_email = gr.Textbox(
-                        label="Email",
+                        label="Email Address",
                         placeholder="[email protected]",
-                        type="email"
+                        type="email",
+                        elem_id="login-email"
                     )
                     login_password = gr.Textbox(
                         label="Password",
                         placeholder="Enter your password",
-                        type="password"
+                        type="password",
+                        elem_id="login-password"
                     )
                     forgot_password_btn = gr.Button(
                         "Forgot password?",
@@ -1661,23 +1693,33 @@ def create_interface() -> gr.Blocks:
                 with gr.Tab("Create Account"):
                     signup_username = gr.Textbox(
                         label="Username (optional)",
-                        placeholder="Choose a username"
+                        placeholder="Choose a username",
+                        elem_id="signup-username"
                     )
                     signup_email = gr.Textbox(
-                        label="Email",
+                        label="Email Address",
                         placeholder="[email protected]",
-                        type="email"
+                        type="email",
+                        elem_id="signup-email"
                     )
+                    signup_email_validation = gr.Markdown("", elem_id="signup-email-validation")
+
                     signup_password = gr.Textbox(
                         label="Password",
-                        placeholder="At least 6 characters",
-                        type="password"
+                        placeholder="At least 15 characters (NIST 2024 requirement)",
+                        type="password",
+                        elem_id="signup-password"
                     )
+                    signup_password_strength = gr.Markdown("", elem_id="password-strength")
+
                     signup_confirm = gr.Textbox(
                         label="Confirm Password",
                         placeholder="Re-enter your password",
-                        type="password"
+                        type="password",
+                        elem_id="signup-confirm-password"
                     )
+                    signup_password_match = gr.Markdown("", elem_id="password-match-validation")
+
                     gr.Markdown(
                         "*By signing up, you agree this is for educational purposes only and not financial advice.*",
                         elem_classes="disclaimer-text"
@@ -1702,9 +1744,10 @@ def create_interface() -> gr.Blocks:
             gr.Markdown("Enter your email address and we'll send you a password reset link.")
 
             reset_email = gr.Textbox(
-                label="Email",
+                label="Email Address",
                 placeholder="[email protected]",
-                type="email"
+                type="email",
+                elem_id="reset-email"
             )
             with gr.Row():
                 reset_submit_btn = gr.Button("Send Reset Link", variant="primary", size="lg")
@@ -1719,21 +1762,24 @@ def create_interface() -> gr.Blocks:
             # Hidden fields to store recovery token_hash and email (populated by JavaScript)
             recovery_token_hash = gr.Textbox(visible=False, elem_id="recovery-token-hash")
             recovery_email = gr.Textbox(
-                label="Email",
+                label="Email Address",
                 placeholder="[email protected]",
                 type="email",
-                info="Enter the email address you used to request the password reset"
+                info="Enter the email address you used to request the password reset",
+                elem_id="recovery-email"
             )
 
             new_password = gr.Textbox(
                 label="New Password",
-                placeholder="At least 6 characters",
-                type="password"
+                placeholder="At least 15 characters (NIST 2024 requirement)",
+                type="password",
+                elem_id="new-password"
             )
             confirm_new_password = gr.Textbox(
                 label="Confirm New Password",
                 placeholder="Re-enter your new password",
-                type="password"
+                type="password",
+                elem_id="confirm-new-password"
             )
             with gr.Row():
                 update_password_btn = gr.Button("Update Password", variant="primary", size="lg")
@@ -1924,6 +1970,15 @@ def create_interface() -> gr.Blocks:
 
         # Results Page (tabbed interface)
         with gr.Group(visible=False) as results_page:
+            # Header with actions (always visible)
+            with gr.Row(elem_id="results-header"):
+                with gr.Column(scale=3):
+                    gr.Markdown("# Portfolio Analysis Results", elem_classes="page-title")
+                with gr.Column(scale=1):
+                    with gr.Row():
+                        export_pdf_btn = gr.Button("📄 Export PDF", size="sm")
+                        export_csv_btn = gr.Button("📊 Export CSV", size="sm")
+
             # Main tabbed interface
             with gr.Tabs() as results_tabs:
                 # Tab 1: Analysis Results
@@ -2242,6 +2297,144 @@ def create_interface() -> gr.Blocks:
                 logger.error(f"Failed to view historical analysis: {e}")
                 return f"**Error**: Failed to load analysis details: {str(e)}"
 
+        def export_current_analysis_csv():
+            """Export current analysis to CSV.
+
+            Returns:
+                Path to temporary CSV file, or None if no analysis available
+            """
+            global LAST_ANALYSIS_STATE
+
+            if not LAST_ANALYSIS_STATE:
+                logger.warning("No analysis state available for CSV export")
+                return None
+
+            try:
+                csv_content = export_analysis_to_csv(LAST_ANALYSIS_STATE)
+
+                # Create temporary file
+                import tempfile
+                with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv', prefix='portfolio_analysis_') as f:
+                    f.write(csv_content)
+                    logger.info(f"CSV export created: {f.name}")
+                    return f.name
+            except Exception as e:
+                logger.error(f"Failed to export CSV: {e}")
+                return None
+
+        def export_current_analysis_pdf():
+            """Export current analysis to PDF.
+
+            Returns:
+                Path to temporary PDF file, or None if no analysis available
+            """
+            global LAST_ANALYSIS_STATE
+
+            if not LAST_ANALYSIS_STATE:
+                logger.warning("No analysis state available for PDF export")
+                return None
+
+            try:
+                pdf_bytes = export_analysis_to_pdf(LAST_ANALYSIS_STATE)
+
+                # Create temporary file
+                import tempfile
+                with tempfile.NamedTemporaryFile(mode='wb', delete=False, suffix='.pdf', prefix='portfolio_analysis_') as f:
+                    f.write(pdf_bytes)
+                    logger.info(f"PDF export created: {f.name}")
+                    return f.name
+            except Exception as e:
+                logger.error(f"Failed to export PDF: {e}")
+                return None
+
+        def validate_email_format(email: str) -> str:
+            """Validate email format in real-time.
+
+            Args:
+                email: Email address to validate
+
+            Returns:
+                Validation message
+            """
+            import re
+
+            if not email:
+                return ""
+
+            email_regex = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+
+            if re.match(email_regex, email):
+                return "✓ Valid email format"
+            else:
+                return "❌ Invalid email format"
+
+        def validate_password_match(password: str, confirm: str) -> str:
+            """Check if passwords match in real-time.
+
+            Args:
+                password: Password field value
+                confirm: Confirmation field value
+
+            Returns:
+                Validation message
+            """
+            if not confirm:
+                return ""
+
+            if password == confirm:
+                return "✓ Passwords match"
+            else:
+                return "❌ Passwords do not match"
+
+        def check_password_strength(password: str) -> str:
+            """Real-time password strength indicator.
+
+            Args:
+                password: Password to evaluate
+
+            Returns:
+                Strength indicator with feedback
+            """
+            import re
+
+            if not password:
+                return ""
+
+            score = 0
+            feedback = []
+
+            # Length check (main NIST requirement)
+            if len(password) >= 15:
+                score += 3  # Length is most important
+            elif len(password) >= 12:
+                score += 2
+                feedback.append("15+ characters")
+            elif len(password) >= 8:
+                score += 1
+                feedback.append("15+ characters")
+            else:
+                feedback.append("15+ characters")
+
+            # Optional complexity (not required by NIST)
+            if re.search(r'[A-Z]', password):
+                score += 1
+            if re.search(r'[a-z]', password):
+                score += 1
+            if re.search(r'\d', password):
+                score += 1
+            if re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
+                score += 1
+
+            # Generate feedback message
+            if score <= 2:
+                return "🔴 **Weak** - Add: " + ", ".join(feedback) if feedback else "🔴 **Weak**"
+            elif score <= 4:
+                return "🟠 **Moderate** - " + (("Add: " + ", ".join(feedback)) if feedback else "Consider 15+ characters")
+            elif score <= 6:
+                return "🟡 **Good** - " + (("Add: " + ", ".join(feedback)) if feedback else "Meets requirements")
+            else:
+                return "🟢 **Strong** - Exceeds requirements"
+
         def show_history_page():
             """Navigate to history page."""
             return {
@@ -2402,6 +2595,17 @@ Please try again with different parameters.
             show_progress="full"
         )
 
+        # Export buttons
+        export_pdf_btn.click(
+            export_current_analysis_pdf,
+            outputs=gr.File(label="Download PDF", visible=True)
+        )
+
+        export_csv_btn.click(
+            export_current_analysis_csv,
+            outputs=gr.File(label="Download CSV", visible=True)
+        )
+
         # Auto-load history when History tab is selected
         def load_history_if_selected(evt: gr.SelectData, session):
             """Load history only when History tab is selected."""
@@ -2481,8 +2685,10 @@ Please try again with different parameters.
             if password != confirm_password:
                 return current_session, "❌ Passwords do not match"
 
-            if len(password) < 6:
-                return current_session, "❌ Password must be at least 6 characters"
+            # NIST SP 800-63B-4: Minimum 15 characters for single-factor auth
+            # No composition rules (uppercase, numbers, symbols) required
+            if len(password) < 15:
+                return current_session, "❌ Password must be at least 15 characters (NIST 2024 requirement)"
 
             success, message, session = await auth.signup(email, password, username)
 
@@ -2556,9 +2762,9 @@ Please try again with different parameters.
             """Synchronous wrapper for login."""
             return asyncio.run(handle_login(email, password, current_session))
 
-        def sync_signup(email: str, password: str, confirm_password: str, username: str, terms_accepted: bool, current_session: Dict):
+        def sync_signup(email: str, password: str, confirm_password: str, username: str, current_session: Dict):
             """Synchronous wrapper for signup."""
-            return asyncio.run(handle_signup(email, password, confirm_password, username, terms_accepted, current_session))
+            return asyncio.run(handle_signup(email, password, confirm_password, username, current_session))
 
         def sync_logout(current_session: Dict):
             """Synchronous wrapper for logout."""
@@ -2592,8 +2798,9 @@ Please try again with different parameters.
             if password != confirm:
                 return "❌ Passwords do not match"
 
-            if len(password) < 6:
-                return "❌ Password must be at least 6 characters"
+            # NIST SP 800-63B-4: Minimum 15 characters for single-factor auth
+            if len(password) < 15:
+                return "❌ Password must be at least 15 characters (NIST 2024 requirement)"
 
             success, message = await auth.update_password(password, email, token_hash)
             return message
@@ -2618,6 +2825,27 @@ Please try again with different parameters.
             outputs=[session_state, signup_message]
         )
 
+        # Real-time email validation
+        signup_email.change(
+            validate_email_format,
+            inputs=[signup_email],
+            outputs=[signup_email_validation]
+        )
+
+        # Real-time password strength meter
+        signup_password.change(
+            check_password_strength,
+            inputs=[signup_password],
+            outputs=[signup_password_strength]
+        )
+
+        # Real-time password match validation
+        signup_confirm.change(
+            validate_password_match,
+            inputs=[signup_password, signup_confirm],
+            outputs=[signup_password_match]
+        )
+
         # Password reset handlers
         forgot_password_btn.click(
             lambda: (gr.update(visible=False), gr.update(visible=True)),

backend/export.py

@@ -0,0 +1,223 @@
+"""Export functionality for portfolio analyses.
+
+Provides PDF and CSV export capabilities for analysis results.
+"""
+
+import io
+from typing import Dict, Any, List, Optional
+from decimal import Decimal
+from datetime import datetime
+import csv
+import logging
+
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, PageBreak
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+
+logger = logging.getLogger(__name__)
+
+
+def export_analysis_to_csv(analysis_results: Dict[str, Any]) -> str:
+    """Export analysis results to CSV format.
+
+    Args:
+        analysis_results: Complete analysis results dictionary
+
+    Returns:
+        CSV string ready for download
+    """
+    output = io.StringIO()
+    writer = csv.writer(output)
+
+    # Headers
+    writer.writerow(["Portfolio Analysis Export"])
+    writer.writerow(["Generated:", datetime.now().isoformat()])
+    writer.writerow([])
+
+    # Holdings
+    writer.writerow(["Portfolio Holdings"])
+    writer.writerow(["Ticker", "Quantity", "Market Value", "Weight %"])
+
+    holdings = analysis_results.get('holdings', [])
+    for holding in holdings:
+        ticker = holding.get('ticker', '')
+        quantity = holding.get('quantity', 0)
+        market_value = holding.get('market_value', 0)
+        weight = holding.get('weight', 0) * 100
+
+        writer.writerow([ticker, quantity, f"£{market_value:,.2f}", f"{weight:.2f}%"])
+
+    writer.writerow([])
+
+    # Key Metrics
+    writer.writerow(["Key Metrics"])
+    risk_analysis = analysis_results.get('risk_analysis', {})
+    risk_metrics = risk_analysis.get('risk_metrics', {})
+
+    writer.writerow(["Metric", "Value"])
+    writer.writerow(["Sharpe Ratio", risk_metrics.get('sharpe_ratio', 'N/A')])
+
+    volatility = risk_metrics.get('volatility_annual', 0)
+    if isinstance(volatility, (int, float)):
+        writer.writerow(["Volatility", f"{volatility*100:.2f}%"])
+    else:
+        writer.writerow(["Volatility", str(volatility)])
+
+    var_95 = risk_analysis.get('var_95', {})
+    var_value = var_95.get('var_percentage', 'N/A') if isinstance(var_95, dict) else var_95
+    writer.writerow(["VaR (95%)", f"{var_value}%"])
+
+    cvar_95 = risk_analysis.get('cvar_95', {})
+    cvar_value = cvar_95.get('cvar_percentage', 'N/A') if isinstance(cvar_95, dict) else cvar_95
+    writer.writerow(["CVaR (95%)", f"{cvar_value}%"])
+
+    writer.writerow([])
+
+    # AI Synthesis
+    writer.writerow(["AI Analysis"])
+    ai_synthesis = analysis_results.get('ai_synthesis', '')
+    if ai_synthesis:
+        # Split into lines for better CSV formatting
+        for line in ai_synthesis.split('\n'):
+            if line.strip():
+                writer.writerow([line.strip()])
+
+    writer.writerow([])
+
+    # Recommendations
+    writer.writerow(["Recommendations"])
+    recommendations = analysis_results.get('recommendations', [])
+    for i, rec in enumerate(recommendations, 1):
+        writer.writerow([f"{i}.", rec])
+
+    return output.getvalue()
+
+
+def export_analysis_to_pdf(analysis_results: Dict[str, Any]) -> bytes:
+    """Export analysis results to PDF format.
+
+    Args:
+        analysis_results: Complete analysis results dictionary
+
+    Returns:
+        PDF bytes ready for download
+    """
+    buffer = io.BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=letter)
+    story = []
+    styles = getSampleStyleSheet()
+
+    # Title
+    title_style = ParagraphStyle(
+        'CustomTitle',
+        parent=styles['Heading1'],
+        fontSize=24,
+        textColor=colors.HexColor('#05478A'),
+        spaceAfter=30,
+    )
+    story.append(Paragraph("Portfolio Analysis Report", title_style))
+    story.append(Paragraph(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}", styles['Normal']))
+    story.append(Spacer(1, 0.5*inch))
+
+    # Holdings Table
+    story.append(Paragraph("Portfolio Holdings", styles['Heading2']))
+
+    holdings = analysis_results.get('holdings', [])
+    holdings_data = [["Ticker", "Quantity", "Market Value", "Weight %"]]
+
+    for holding in holdings:
+        ticker = holding.get('ticker', '')
+        quantity = holding.get('quantity', 0)
+        market_value = holding.get('market_value', 0)
+        weight = holding.get('weight', 0) * 100
+
+        holdings_data.append([
+            ticker,
+            f"{quantity:.2f}",
+            f"£{market_value:,.2f}",
+            f"{weight:.2f}%"
+        ])
+
+    holdings_table = Table(holdings_data)
+    holdings_table.setStyle(TableStyle([
+        ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#05478A')),
+        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+        ('FONTSIZE', (0, 0), (-1, 0), 12),
+        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+        ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+        ('GRID', (0, 0), (-1, -1), 1, colors.black)
+    ]))
+
+    story.append(holdings_table)
+    story.append(Spacer(1, 0.5*inch))
+
+    # Key Metrics
+    story.append(Paragraph("Key Metrics", styles['Heading2']))
+
+    risk_analysis = analysis_results.get('risk_analysis', {})
+    risk_metrics = risk_analysis.get('risk_metrics', {})
+
+    metrics_data = [["Metric", "Value"]]
+    metrics_data.append(["Sharpe Ratio", f"{risk_metrics.get('sharpe_ratio', 0):.3f}"])
+
+    volatility = risk_metrics.get('volatility_annual', 0)
+    if isinstance(volatility, (int, float)):
+        metrics_data.append(["Volatility", f"{volatility*100:.2f}%"])
+    else:
+        metrics_data.append(["Volatility", str(volatility)])
+
+    var_95 = risk_analysis.get('var_95', {})
+    var_value = var_95.get('var_percentage', 0) if isinstance(var_95, dict) else var_95
+    metrics_data.append(["VaR (95%)", f"{var_value:.2f}%"])
+
+    cvar_95 = risk_analysis.get('cvar_95', {})
+    cvar_value = cvar_95.get('cvar_percentage', 0) if isinstance(cvar_95, dict) else cvar_95
+    metrics_data.append(["CVaR (95%)", f"{cvar_value:.2f}%"])
+
+    metrics_table = Table(metrics_data)
+    metrics_table.setStyle(TableStyle([
+        ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#048CFC')),
+        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+        ('FONTSIZE', (0, 0), (-1, 0), 12),
+        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+        ('BACKGROUND', (0, 1), (-1, -1), colors.lightblue),
+        ('GRID', (0, 0), (-1, -1), 1, colors.black)
+    ]))
+
+    story.append(metrics_table)
+    story.append(Spacer(1, 0.5*inch))
+
+    # AI Synthesis
+    story.append(Paragraph("AI Analysis", styles['Heading2']))
+    ai_synthesis = analysis_results.get('ai_synthesis', '')
+    if ai_synthesis:
+        # Clean and format the text
+        paragraphs = ai_synthesis.split('\n\n')
+        for para in paragraphs:
+            if para.strip():
+                story.append(Paragraph(para.strip(), styles['Normal']))
+                story.append(Spacer(1, 0.1*inch))
+
+    # Recommendations
+    story.append(Spacer(1, 0.3*inch))
+    story.append(Paragraph("Recommendations", styles['Heading2']))
+    recommendations = analysis_results.get('recommendations', [])
+    for i, rec in enumerate(recommendations, 1):
+        story.append(Paragraph(f"{i}. {rec}", styles['Normal']))
+        story.append(Spacer(1, 0.1*inch))
+
+    # Build PDF
+    try:
+        doc.build(story)
+    except Exception as e:
+        logger.error(f"Failed to build PDF: {e}")
+        raise
+
+    buffer.seek(0)
+    return buffer.getvalue()

backend/visualizations/plotly_charts.py

@@ -343,19 +343,33 @@ def create_correlation_heatmap(
     if not historical_data or len(historical_data) < 2:
         return None
 
-    # Build returns dataframe
+    # Build returns dataframe - ENSURE ALL ASSETS ARE INCLUDED
     returns_data = {}
+    min_length = float('inf')
+
+    # First pass: calculate all returns and find minimum length
     for ticker, hist in historical_data.items():
         prices = hist.get('close_prices', [])
         if len(prices) > 1:
             returns = pd.Series(prices).pct_change().dropna()
             returns_data[ticker] = returns
+            min_length = min(min_length, len(returns))
 
     if len(returns_data) < 2:
+        logger.warning("Insufficient returns data for correlation matrix")
         return None
 
+    # Second pass: align all series to same length
+    aligned_returns = {}
+    for ticker, returns in returns_data.items():
+        aligned_returns[ticker] = returns.iloc[-min_length:]
+
     # Create DataFrame and calculate correlation
-    df = pd.DataFrame(returns_data)
+    df = pd.DataFrame(aligned_returns)
+
+    # VERIFY: Check that df contains all expected tickers
+    logger.info(f"Correlation matrix includes {len(df.columns)} assets: {list(df.columns)}")
+
     corr_matrix = df.corr()
 
     fig = go.Figure(data=go.Heatmap(

pyproject.toml

@@ -38,6 +38,11 @@ dependencies = [
     "numpy>=2.0.0",
     "yfinance>=0.2.40",
     "scipy>=1.11.0",
+    "matplotlib>=3.8.0",
+    "plotly>=5.18.0",
+    # Export & Reporting
+    "reportlab>=4.0.0",
+    "pypdf>=3.17.0",
     # ML Models (P1 - Optional)
     "torch>=2.0.0",
     "xgboost>=3.1.0",