Update utils/api_client.py

utils/api_client.py

@@ -1,185 +1,358 @@
-"""API client for RewardPilot Orchestrator"""
+"""
+API Client for RewardPilot Orchestrator Service
+"""
 
-import httpx
-from typing import Dict, Optional
-from config import ORCHESTRATOR_URL
-from typing import Any, Dict, List, Optional, Tuple
+import requests
+from typing import Dict, Optional, List
 import logging
 
-# Create logger
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+
 class RewardPilotClient:
-    """Client for interacting with RewardPilot Orchestrator"""
+    """Client for interacting with RewardPilot microservices"""
     
-    def __init__(self, base_url: str = ORCHESTRATOR_URL):
-        self.base_url = base_url.rstrip('/')
-        self.timeout = 30.0
+    def __init__(self, orchestrator_url: str = "http://localhost:8000"):
+        """
+        Initialize API client
+        
+        Args:
+            orchestrator_url: Base URL for orchestrator service
+        """
+        self.orchestrator_url = orchestrator_url.rstrip('/')
+        self.timeout = 10  # seconds
     
-    async def get_recommendation(
+    def get_recommendation(
         self,
         user_id: str,
         merchant: str,
-        mcc: str,
-        amount_usd: float,
-        transaction_date: Optional[str] = None
+        category: str,
+        amount: float,
+        mcc: Optional[str] = None
     ) -> Dict:
-        """Get card recommendation from orchestrator"""
-        async with httpx.AsyncClient(timeout=self.timeout) as client:
-            try:
-                payload = {
-                    "user_id": user_id,
-                    "merchant": merchant,
-                    "mcc": mcc,
-                    "amount_usd": amount_usd
-                }
-                if transaction_date:
-                    payload["transaction_date"] = transaction_date
-                
-                response = await client.post(
-                    f"{self.base_url}/recommend",
-                    json=payload
-                )
-                response.raise_for_status()
-                return response.json()
-            except httpx.HTTPError as e:
+        """
+        Get card recommendation for a transaction
+        
+        Args:
+            user_id: User identifier
+            merchant: Merchant name
+            category: Transaction category (e.g., "Groceries", "Dining")
+            amount: Transaction amount in USD
+            mcc: Optional Merchant Category Code
+            
+        Returns:
+            Dictionary with recommendation data
+        """
+        
+        # Map category to MCC if not provided
+        if not mcc:
+            mcc = self._category_to_mcc(category)
+        
+        payload = {
+            "user_id": user_id,
+            "merchant": merchant,
+            "category": category,
+            "mcc": mcc,
+            "amount_usd": amount
+        }
+        
+        try:
+            response = requests.post(
+                f"{self.orchestrator_url}/recommend",
+                json=payload,
+                timeout=self.timeout
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                logger.info(f"✅ Got recommendation for {merchant}: {data.get('recommended_card', 'N/A')}")
                 return {
-                    "error": True,
-                    "message": f"API Error: {str(e)}"
+                    "success": True,
+                    "data": data
                 }
-            except Exception as e:
+            else:
+                logger.error(f"❌ API error: {response.status_code}")
                 return {
-                    "error": True,
-                    "message": f"Unexpected error: {str(e)}"
+                    "success": False,
+                    "error": f"API returned status {response.status_code}"
                 }
+                
+        except requests.exceptions.Timeout:
+            logger.error("❌ Request timeout")
+            return {
+                "success": False,
+                "error": "Request timed out. Service may be unavailable."
+            }
+        except requests.exceptions.ConnectionError:
+            logger.error("❌ Connection error")
+            # Return mock data for development/demo
+            return self._get_mock_recommendation(user_id, merchant, category, amount)
+        except Exception as e:
+            logger.error(f"❌ Unexpected error: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
     
-    def get_recommendation_sync(
-        self,
-        user_id: str,
-        merchant: str,
-        mcc: str,
-        amount_usd: float,
-        transaction_date: Optional[str] = None
-    ) -> Dict:
-        """Synchronous version for Gradio"""
-        import asyncio
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-        
-        return loop.run_until_complete(
-            self.get_recommendation(
-                user_id, merchant, mcc, amount_usd, transaction_date
-            )
-        )
-
-    def get_user_analytics(self, user_id: str) -> Dict[str, Any]:
+    def get_user_analytics(self, user_id: str) -> Dict:
         """
-        Fetch user analytics including spending patterns and optimization metrics
+        Get analytics for a user
         
         Args:
             user_id: User identifier
             
         Returns:
-            Dictionary containing analytics data
+            Dictionary with analytics data
         """
+        
         try:
-            # Option 1: If you have a dedicated analytics endpoint
-            response = httpx.get(
+            response = requests.get(
                 f"{self.orchestrator_url}/analytics/{user_id}",
-                timeout=30.0
+                timeout=self.timeout
             )
-            response.raise_for_status()
-            return response.json()
             
-        except Exception as e:
-            logger.error(f"Analytics fetch failed: {e}")
-            # Return mock data as fallback
+            if response.status_code == 200:
+                data = response.json()
+                logger.info(f"✅ Got analytics for {user_id}")
+                return {
+                    "success": True,
+                    "data": data
+                }
+            else:
+                logger.error(f"❌ API error: {response.status_code}")
+                return {
+                    "success": False,
+                    "error": f"API returned status {response.status_code}"
+                }
+                
+        except requests.exceptions.ConnectionError:
+            logger.error("❌ Connection error")
+            # Return mock data for development/demo
             return self._get_mock_analytics(user_id)
+        except Exception as e:
+            logger.error(f"❌ Unexpected error: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
     
-    def _get_mock_analytics(self, user_id: str) -> Dict[str, Any]:
-        """Generate mock analytics data for demo purposes"""
-        import random
-        
-        # Different data per user for variety
-        user_multipliers = {
-            "u_alice": 1.2,
-            "u_bob": 0.9,
-            "u_charlie": 1.5,
+    def compare_cards(self, card_ids: List[str]) -> Dict:
+        """
+        Compare multiple credit cards
+        
+        Args:
+            card_ids: List of card identifiers
+            
+        Returns:
+            Dictionary with comparison data
+        """
+        
+        payload = {
+            "card_ids": card_ids
         }
-        multiplier = user_multipliers.get(user_id, 1.0)
         
-        return {
-            "user_id": user_id,
-            "annual_savings": round(342 * multiplier, 2),
-            "rate_increase": round(23 * multiplier, 1),
-            "optimized_transactions": int(156 * multiplier),
-            "optimization_score": min(100, int(87 * multiplier)),
-            "category_breakdown": [
-                {
-                    "category": "🛒 Groceries",
-                    "monthly_spend": round(450 * multiplier, 2),
-                    "best_card": "Amex Gold",
-                    "rewards": round(27 * multiplier, 2),
-                    "rate": "6%"
-                },
-                {
-                    "category": "🍽️ Restaurants",
-                    "monthly_spend": round(320 * multiplier, 2),
-                    "best_card": "Amex Gold",
-                    "rewards": round(12.8 * multiplier, 2),
-                    "rate": "4%"
-                },
-                {
-                    "category": "⛽ Gas",
-                    "monthly_spend": round(180 * multiplier, 2),
-                    "best_card": "Costco Visa",
-                    "rewards": round(7.2 * multiplier, 2),
-                    "rate": "4%"
-                },
-                {
-                    "category": "✈️ Travel",
-                    "monthly_spend": round(850 * multiplier, 2),
-                    "best_card": "Sapphire Reserve",
-                    "rewards": round(42.5 * multiplier, 2),
-                    "rate": "5%"
-                },
-                {
-                    "category": "🎬 Entertainment",
-                    "monthly_spend": round(125 * multiplier, 2),
-                    "best_card": "Freedom Unlimited",
-                    "rewards": round(1.88 * multiplier, 2),
-                    "rate": "1.5%"
-                },
-                {
-                    "category": "🏪 Online Shopping",
-                    "monthly_spend": round(280 * multiplier, 2),
-                    "best_card": "Amazon Prime",
-                    "rewards": round(16.8 * multiplier, 2),
-                    "rate": "6%"
+        try:
+            response = requests.post(
+                f"{self.orchestrator_url}/compare",
+                json=payload,
+                timeout=self.timeout
+            )
+            
+            if response.status_code == 200:
+                return {
+                    "success": True,
+                    "data": response.json()
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"API returned status {response.status_code}"
                 }
-            ],
-            "total_monthly_spend": round(2205 * multiplier, 2),
-            "total_monthly_rewards": round(108.18 * multiplier, 2),
-            "average_rate": round(4.9, 1),
-            "top_categories": [
-                {"name": "✈️ Travel", "amount": round(850 * multiplier, 2), "change": "+45%"},
-                {"name": "🛒 Groceries", "amount": round(450 * multiplier, 2), "change": "+12%"},
-                {"name": "🍽️ Restaurants", "amount": round(320 * multiplier, 2), "change": "-5%"}
-            ],
-            "ytd_rewards": round(1298.16 * multiplier, 2),
-            "ytd_potential": round(1640 * multiplier, 2),
-            "money_left": round(341.84 * multiplier, 2),
-            "forecast": {
-                "next_month_spend": round(2350 * multiplier, 2),
-                "next_month_rewards": round(115.25 * multiplier, 2),
-                "cards_to_watch": ["Amex Gold (dining cap)", "Freedom (quarterly bonus)"]
+                
+        except Exception as e:
+            logger.error(f"❌ Error comparing cards: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def _category_to_mcc(self, category: str) -> str:
+        """Map category name to MCC code"""
+        
+        category_map = {
+            "Groceries": "5411",
+            "Dining": "5812",
+            "Travel": "4511",
+            "Gas": "5541",
+            "Online Shopping": "5999",
+            "Entertainment": "7832",
+            "Pharmacy": "5912",
+            "Department Store": "5311",
+            "Home Improvement": "5211",
+            "Utilities": "4900"
+        }
+        
+        return category_map.get(category, "0000")
+    
+    def _get_mock_recommendation(
+        self,
+        user_id: str,
+        merchant: str,
+        category: str,
+        amount: float
+    ) -> Dict:
+        """
+        Generate mock recommendation for demo/development
+        
+        This is used when the orchestrator service is unavailable
+        """
+        
+        # Simple rule-based mock logic
+        card_rules = {
+            "Groceries": {
+                "card": "Amex Gold",
+                "rate": "4x points",
+                "multiplier": 4.0
+            },
+            "Dining": {
+                "card": "Capital One Savor",
+                "rate": "4% cashback",
+                "multiplier": 4.0
             },
-            "recommendations": [
-                "💳 Use Chase Freedom for groceries in Q4 (5% back)",
-                "⚠️ Monitor Amex Gold dining spend (cap at $2,000)",
-                "🎯 Book holiday travel with Sapphire Reserve for 5x points"
-            ]
-        }
+            "Travel": {
+                "card": "Chase Sapphire Reserve",
+                "rate": "3x points",
+                "multiplier": 3.0
+            },
+            "Gas": {
+                "card": "Costco Visa",
+                "rate": "4% cashback",
+                "multiplier": 4.0
+            },
+            "Online Shopping": {
+                "card": "Amazon Prime Card",
+                "rate": "5% cashback",
+                "multiplier": 5.0
+            }
+        }
+        
+        rule = card_rules.get(category, {
+            "card": "Citi Double Cash",
+            "rate": "2% cashback",
+            "multiplier": 2.0
+        })
+        
+        rewards_earned = amount * (rule["multiplier"] / 100)
+        annual_potential = rewards_earned * 12  # Rough estimate
+        
+        logger.warning(f"⚠️ Using mock data for {merchant}")
+        
+        return {
+            "success": True,
+            "data": {
+                "recommended_card": rule["card"],
+                "rewards_earned": round(rewards_earned, 2),
+                "rewards_rate": rule["rate"],
+                "merchant": merchant,
+                "category": category,
+                "amount": amount,
+                "annual_potential": round(annual_potential, 2),
+                "optimization_score": 85,
+                "reasoning": f"Best card for {category.lower()} purchases",
+                "warnings": [],
+                "alternatives": [
+                    {
+                        "card": "Citi Double Cash",
+                        "rewards": round(amount * 0.02, 2),
+                        "rate": "2% cashback"
+                    }
+                ],
+                "mock_data": True  # Flag to indicate this is mock data
+            }
+        }
+    
+    def _get_mock_analytics(self, user_id: str) -> Dict:
+        """Generate mock analytics for demo/development"""
+        
+        logger.warning(f"⚠️ Using mock analytics for {user_id}")
+        
+        return {
+            "success": True,
+            "data": {
+                "user_id": user_id,
+                "total_spending": 3450.75,
+                "total_rewards": 142.50,
+                "potential_savings": 425.00,
+                "optimization_score": 87,
+                "optimized_count": 156,
+                "total_transactions": 180,
+                "top_category": "Groceries",
+                "cards": ["Amex Gold", "Chase Sapphire Reserve", "Citi Double Cash"],
+                "category_breakdown": [
+                    {
+                        "category": "Groceries",
+                        "spending": 1250.00,
+                        "rewards": 50.00,
+                        "transactions": 45
+                    },
+                    {
+                        "category": "Dining",
+                        "spending": 890.50,
+                        "rewards": 35.62,
+                        "transactions": 38
+                    },
+                    {
+                        "category": "Travel",
+                        "spending": 750.25,
+                        "rewards": 22.51,
+                        "transactions": 12
+                    },
+                    {
+                        "category": "Gas",
+                        "spending": 350.00,
+                        "rewards": 14.00,
+                        "transactions": 24
+                    },
+                    {
+                        "category": "Online Shopping",
+                        "spending": 210.00,
+                        "rewards": 10.50,
+                        "transactions": 18
+                    }
+                ],
+                "monthly_trends": [
+                    {"month": "Jan", "spending": 2800, "rewards": 115},
+                    {"month": "Feb", "spending": 3100, "rewards": 128},
+                    {"month": "Mar", "spending": 3450, "rewards": 142}
+                ],
+                "card_performance": [
+                    {"card": "Amex Gold", "rewards": 65.00, "usage_pct": 45},
+                    {"card": "Chase Sapphire Reserve", "rewards": 48.50, "usage_pct": 30},
+                    {"card": "Citi Double Cash", "rewards": 29.00, "usage_pct": 25}
+                ],
+                "mock_data": True
+            }
+        }
+    
+    def health_check(self) -> bool:
+        """
+        Check if orchestrator service is available
+        
+        Returns:
+            True if service is healthy, False otherwise
+        """
+        try:
+            response = requests.get(
+                f"{self.orchestrator_url}/health",
+                timeout=5
+            )
+            return response.status_code == 200
+        except:
+            return False
+
+
+# Convenience function
+def create_client(orchestrator_url: str = "http://localhost:8000") -> RewardPilotClient:
+    """Create and return a RewardPilotClient instance"""
+    return RewardPilotClient(orchestrator_url)