Update app.py

app.py

@@ -16,41 +16,88 @@ def safe_get(data: Dict, key: str, default: Any = None) -> Any:
 
 
 def normalize_recommendation_data(data: Dict) -> Dict:
-    """Normalize API response to ensure all required fields exist"""
+    """
+    Normalize API response to ensure all required fields exist.
+    Handles both orchestrator format and direct API format.
+    """
     
-    # Extract or compute rewards_earned
-    rewards_earned = safe_get(data, 'rewards_earned')
-    if rewards_earned is None:
-        amount = safe_get(data, 'amount', 0)
-        rewards_rate = safe_get(data, 'rewards_rate', '0x points')
+    # Handle case where recommended_card is a dict (orchestrator format)
+    recommended_card = safe_get(data, 'recommended_card', {})
+    if isinstance(recommended_card, dict):
+        card_name = safe_get(recommended_card, 'card_name', 'Unknown Card')
+        reward_amount = float(safe_get(recommended_card, 'reward_amount', 0))
+        reward_rate = float(safe_get(recommended_card, 'reward_rate', 0))
+        category = safe_get(recommended_card, 'category', 'Unknown')
+        reasoning = safe_get(recommended_card, 'reasoning', 'Optimal choice')
         
-        try:
-            if 'x' in str(rewards_rate):
-                multiplier = float(rewards_rate.split('x')[0])
-                rewards_earned = amount * (multiplier / 100)
-            elif '%' in str(rewards_rate):
-                multiplier = float(rewards_rate.replace('%', '').split()[0])
-                rewards_earned = amount * (multiplier / 100)
+        # Format reward rate as string
+        if reward_rate > 0:
+            rewards_rate_str = f"{reward_rate}x points"
+        else:
+            rewards_rate_str = "N/A"
+    else:
+        # Handle case where it's already a string
+        card_name = str(recommended_card) if recommended_card else 'Unknown Card'
+        reward_amount = float(safe_get(data, 'rewards_earned', 0))
+        reward_rate = 0
+        rewards_rate_str = safe_get(data, 'rewards_rate', 'N/A')
+        category = safe_get(data, 'category', 'Unknown')
+        reasoning = safe_get(data, 'reasoning', 'Optimal choice')
+    
+    # Get merchant and amount from top level
+    merchant = safe_get(data, 'merchant', 'Unknown Merchant')
+    amount = float(safe_get(data, 'amount_usd', safe_get(data, 'amount', 0)))
+    
+    # Calculate annual potential
+    annual_potential = reward_amount * 12 if reward_amount > 0 else 0
+    
+    # Process alternative cards
+    alternatives = []
+    alt_cards = safe_get(data, 'alternative_cards', safe_get(data, 'alternatives', []))
+    
+    for alt in alt_cards[:3]:  # Limit to top 3
+        if isinstance(alt, dict):
+            alt_name = safe_get(alt, 'card_name', safe_get(alt, 'card', 'Unknown'))
+            alt_reward = float(safe_get(alt, 'reward_amount', safe_get(alt, 'rewards', 0)))
+            alt_rate = safe_get(alt, 'reward_rate', safe_get(alt, 'rate', 0))
+            
+            if isinstance(alt_rate, (int, float)) and alt_rate > 0:
+                alt_rate_str = f"{alt_rate}x points"
             else:
-                rewards_earned = 0
-        except:
-            rewards_earned = 0
+                alt_rate_str = str(alt_rate) if alt_rate else "N/A"
+            
+            alternatives.append({
+                'card': alt_name,
+                'rewards': alt_reward,
+                'rate': alt_rate_str
+            })
     
-    return {
-        'recommended_card': safe_get(data, 'recommended_card', 'Unknown Card'),
-        'rewards_earned': round(float(rewards_earned), 2),
-        'rewards_rate': safe_get(data, 'rewards_rate', 'N/A'),
-        'merchant': safe_get(data, 'merchant', 'Unknown Merchant'),
-        'category': safe_get(data, 'category', 'Unknown'),
-        'amount': float(safe_get(data, 'amount', 0)),
-        'annual_potential': float(safe_get(data, 'annual_potential', rewards_earned * 12)),
+    # Extract warnings
+    warnings = safe_get(data, 'warnings', [])
+    forecast_warning = safe_get(data, 'forecast_warning')
+    if forecast_warning and isinstance(forecast_warning, dict):
+        warning_msg = safe_get(forecast_warning, 'warning_message')
+        if warning_msg:
+            warnings.append(warning_msg)
+    
+    # Build normalized response
+    normalized = {
+        'recommended_card': card_name,
+        'rewards_earned': round(reward_amount, 2),
+        'rewards_rate': rewards_rate_str,
+        'merchant': merchant,
+        'category': category,
+        'amount': amount,
+        'annual_potential': round(annual_potential, 2),
         'optimization_score': int(safe_get(data, 'optimization_score', 75)),
-        'reasoning': safe_get(data, 'reasoning', 'Optimal choice for this category'),
-        'warnings': safe_get(data, 'warnings', []),
-        'alternatives': safe_get(data, 'alternatives', []),
+        'reasoning': reasoning,
+        'warnings': warnings,
+        'alternatives': alternatives,
         'mock_data': safe_get(data, 'mock_data', False)
     }
     
+    return normalized
+    
 from datetime import date
 from typing import Optional, Tuple, List, Dict, Any
 import gradio as gr
@@ -158,20 +205,24 @@ def get_recommendation_with_ai(user_id, merchant, category, amount):
         return "❌ Please enter a valid amount greater than $0.", None
     
     try:
+        # Map category to MCC
+        mcc = MCC_CATEGORIES.get(category, "5999")
+        
         # Get base recommendation from orchestrator
-        result = client.get_recommendation(
+        result = client.get_recommendation_sync(
             user_id=user_id,
             merchant=merchant,
-            category=category,
-            amount=float(amount)
+            mcc=mcc,
+            amount_usd=float(amount)
         )
         
-        if not result.get('success'):
+        # Check for errors
+        if result.get('error'):
             error_msg = result.get('error', 'Unknown error')
             return f"❌ Error: {error_msg}", None
         
         # Normalize the data to ensure all fields exist
-        data = normalize_recommendation_data(result.get('data', {}))
+        data = normalize_recommendation_data(result)
         
         # Generate LLM explanation if enabled
         ai_explanation = ""
@@ -226,6 +277,7 @@ def get_recommendation_with_ai(user_id, merchant, category, amount):
 
 - **Category:** {data['category']}
 - **Merchant:** {data['merchant']}
+- **Reasoning:** {data['reasoning']}
 - **Annual Potential:** ${data['annual_potential']:.2f}
 - **Optimization Score:** {data['optimization_score']}/100
 """
@@ -239,11 +291,8 @@ def get_recommendation_with_ai(user_id, merchant, category, amount):
         # Add alternatives
         if data['alternatives']:
             output += "\n\n### 🔄 Alternative Options\n\n"
-            for alt in data['alternatives'][:3]:
-                alt_rewards = safe_get(alt, 'rewards', 0)
-                alt_rate = safe_get(alt, 'rate', 'N/A')
-                alt_card = safe_get(alt, 'card', 'Unknown')
-                output += f"- **{alt_card}:** ${alt_rewards:.2f} ({alt_rate})\n"
+            for alt in data['alternatives']:
+                output += f"- **{alt['card']}:** ${alt['rewards']:.2f} ({alt['rate']})\n"
         
         # Create visualization
         chart = create_rewards_comparison_chart(data)
@@ -256,18 +305,36 @@ def get_recommendation_with_ai(user_id, merchant, category, amount):
         print(f"Recommendation error: {error_details}")
         return f"❌ Error: {str(e)}\n\nPlease check your API connection or try again.", None
 
+        
 def create_rewards_comparison_chart(data: Dict) -> go.Figure:
-    """Create rewards comparison chart"""
+    """Create rewards comparison chart with proper error handling"""
     
     try:
         # Prepare data for chart
         cards = [data['recommended_card']]
         rewards = [data['rewards_earned']]
+        colors = ['#667eea']  # Primary color for recommended card
         
         # Add alternatives
         for alt in data.get('alternatives', [])[:3]:
-            cards.append(safe_get(alt, 'card', 'Unknown'))
-            rewards.append(float(safe_get(alt, 'rewards', 0)))
+            cards.append(alt['card'])
+            rewards.append(float(alt['rewards']))
+            colors.append('#a0aec0')  # Gray for alternatives
+        
+        # Only create chart if we have valid data
+        if not cards or all(r == 0 for r in rewards):
+            fig = go.Figure()
+            fig.add_annotation(
+                text="No rewards data available for comparison",
+                xref="paper", yref="paper",
+                x=0.5, y=0.5, showarrow=False,
+                font=dict(size=14, color="#666")
+            )
+            fig.update_layout(
+                height=400,
+                template='plotly_white'
+            )
+            return fig
         
         # Create bar chart
         fig = go.Figure(data=[
@@ -275,36 +342,46 @@ def create_rewards_comparison_chart(data: Dict) -> go.Figure:
                 x=cards,
                 y=rewards,
                 marker=dict(
-                    color=['#667eea'] + ['#a0aec0'] * (len(cards) - 1),
+                    color=colors,
                     line=dict(color='white', width=2)
                 ),
                 text=[f'${r:.2f}' for r in rewards],
                 textposition='outside',
+                hovertemplate='<b>%{x}</b><br>Rewards: $%{y:.2f}<extra></extra>'
             )
         ])
         
         fig.update_layout(
-            title='Rewards Comparison',
+            title={
+                'text': 'Rewards Comparison',
+                'x': 0.5,
+                'xanchor': 'center'
+            },
             xaxis_title='Credit Card',
             yaxis_title='Rewards Earned ($)',
             template='plotly_white',
             height=400,
             showlegend=False,
-            margin=dict(t=50, b=50, l=50, r=50)
+            margin=dict(t=60, b=50, l=50, r=50),
+            hovermode='x'
         )
         
         return fig
         
     except Exception as e:
         print(f"Chart creation error: {e}")
+        import traceback
+        print(traceback.format_exc())
+        
         # Return empty chart with error message
         fig = go.Figure()
         fig.add_annotation(
-            text=f"Error creating chart: {str(e)}",
+            text=f"Error creating chart",
             xref="paper", yref="paper",
             x=0.5, y=0.5, showarrow=False,
             font=dict(size=14, color="red")
         )
+        fig.update_layout(height=400, template='plotly_white')
         return fig
         
 def get_analytics_with_insights(user_id):