Update app.py

app.py

@@ -3,10 +3,10 @@ Blockchain Wallet Analyzer - A tool for analyzing Ethereum wallet contents and N
 
 This module provides a complete implementation of a blockchain wallet analysis tool
 with a Gradio web interface. It includes wallet analysis, NFT tracking, and 
-interactive chat capabilities using the OpenAI API.
+interactive chat capabilities using the Groq API.
 
 Author: Claude
-Date: January 2025
+Date: March 2025
 """
 
 from __future__ import annotations
@@ -25,15 +25,19 @@ from enum import Enum
 from pathlib import Path
 
 import aiohttp
-import openai
 import gradio as gr
 from tenacity import retry, stop_after_attempt, wait_exponential
+import groq
 
 # Type variables
 T = TypeVar('T')
 WalletData = Dict[str, Any]
 ChatHistory = List[Tuple[str, str]]
 
+# API Keys - Define as constants in the script
+GROQ_API_KEY = "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"
+ETHERSCAN_API_KEY = "V562U3P76KKEUJ2DV9Q3U2EPDK89T5CKNH"
+
 # Configure logging
 logging.basicConfig(
     level=logging.INFO,
@@ -77,7 +81,7 @@ class Config:
     ETHEREUM_ADDRESS_REGEX: str = r"0x[a-fA-F0-9]{40}"
     RATE_LIMIT_DELAY: float = 0.2  # 5 requests per second max for free tier
     MAX_RETRIES: int = 3
-    OPENAI_MODEL: str = "gpt-4o-mini"  # Updated to correct model name
+    GROQ_MODEL: str = "llama3-70b-8192"  # Groq's high-performance model
     MAX_TOKENS: int = 4000
     TEMPERATURE: float = 0.7
     HISTORY_LIMIT: int = 5
@@ -96,9 +100,9 @@ class Config:
 class WalletAnalyzer:
     """Analyzes Ethereum wallet contents using Etherscan API."""
     
-    def __init__(self, api_key: str):
+    def __init__(self):
         """Initialize the analyzer with API key."""
-        self.api_key = api_key
+        self.api_key = ETHERSCAN_API_KEY
         self.base_url = Config.ETHERSCAN_BASE_URL
         self.last_request_time = 0
         self.session: Optional[aiohttp.ClientSession] = None
@@ -276,38 +280,12 @@ class WalletAnalyzer:
 
 
 class ChatInterface:
-    """Handles chat interaction using OpenAI API."""
+    """Handles chat interaction using Groq API."""
     
-    def __init__(self, openai_key: str, etherscan_key: str):
-        """Initialize chat interface with API keys."""
-        self.openai_key = openai_key
-        self.etherscan_key = etherscan_key
+    def __init__(self):
+        """Initialize chat interface with Groq client."""
+        self.groq_client = groq.Client(api_key=GROQ_API_KEY)
         self.context: Dict[str, Any] = {}
-        openai.api_key = openai_key
-
-    @staticmethod
-    def _validate_api_keys(openai_key: str, etherscan_key: str) -> Tuple[bool, str]:
-        """Validate both API keys."""
-        try:
-            # Validate OpenAI key
-            client = openai.OpenAI(api_key=openai_key)
-            client.chat.completions.create(
-                model=Config.OPENAI_MODEL,
-                messages=[{"role": "user", "content": "test"}],
-                max_tokens=1
-            )
-            
-            # Validate Etherscan key
-            async def validate_etherscan():
-                async with WalletAnalyzer(etherscan_key) as analyzer:
-                    params = {"module": "stats", "action": "ethsupply"}
-                    await analyzer._fetch_data(params)
-            
-            asyncio.run(validate_etherscan())
-            return True, "Both API keys are valid! 🎉"
-            
-        except Exception as e:
-            return False, f"API key validation failed: {str(e)}"
 
     def _format_context_message(self) -> str:
         """Format wallet data as context message."""
@@ -356,7 +334,7 @@ class ChatInterface:
         if match:
             try:
                 address = match.group(0)
-                async with WalletAnalyzer(self.etherscan_key) as analyzer:
+                async with WalletAnalyzer() as analyzer:
                     wallet_data = await analyzer.get_portfolio_data(address)
                     self.context[address] = wallet_data
                     
@@ -383,12 +361,12 @@ class ChatInterface:
                 history.append((message, error_message))
                 return history, self.context, ""
 
-        # Generate response using OpenAI
+        # Generate response using Groq
         try:
             # Format context message
             context_msg = self._format_context_message()
             
-            # Convert history to OpenAI format
+            # Convert history to Groq format
             chat_history = []
             for user_msg, assistant_msg in history[-Config.HISTORY_LIMIT:]:
                 chat_history.extend([
@@ -396,10 +374,9 @@ class ChatInterface:
                     {"role": "assistant", "content": assistant_msg}
                 ])
 
-            # Create OpenAI client and generate response
-            client = openai.OpenAI(api_key=self.openai_key)
-            response = client.chat.completions.create(
-                model=Config.OPENAI_MODEL,
+            # Generate response using Groq
+            response = self.groq_client.chat.completions.create(
+                model=Config.GROQ_MODEL,
                 messages=[
                     {"role": "system", "content": Config.SYSTEM_PROMPT},
                     {"role": "system", "content": context_msg},
@@ -431,7 +408,7 @@ class GradioInterface:
     
     def __init__(self):
         """Initialize Gradio interface."""
-        self.chat_interface: Optional[ChatInterface] = None
+        self.chat_interface = ChatInterface()
         self.demo = self._create_interface()
 
     def _create_interface(self) -> gr.Blocks:
@@ -441,32 +418,10 @@ class GradioInterface:
             # 🐕 LOSS DOG: Blockchain Wallet Analyzer
             
             Welcome to LOSS DOG - Your friendly blockchain analysis companion!
-            - Enter your API keys below to get started
             - Input an Ethereum wallet address to analyze
             - Chat about your wallet contents with context!
             """)
 
-            # API Keys Section
-            with gr.Row():
-                with gr.Column():
-                    openai_key = gr.Textbox(
-                        label="OpenAI API Key",
-                        type="password",
-                        placeholder="Enter your OpenAI API key..."
-                    )
-                with gr.Column():
-                    etherscan_key = gr.Textbox(
-                        label="Etherscan API Key",
-                        type="password",
-                        placeholder="Enter your Etherscan API key..."
-                    )
-
-            validation_status = gr.Textbox(
-                label="Validation Status",
-                interactive=False
-            )
-            validate_btn = gr.Button("Validate API Keys", variant="primary")
-
             # Main Interface
             with gr.Row():
                 # Chat Area (Left Side)
@@ -493,37 +448,12 @@ class GradioInterface:
                     )
                     clear_btn = gr.Button("Clear Context", variant="secondary")
 
-            # Initial States
-            msg_input.interactive = False
-            send_btn.interactive = False
-
-            # Event Handlers
-            def validate_keys(openai_k: str, etherscan_k: str) -> Tuple[str, gr.update, gr.update]:
-                """Validate API keys and initialize chat interface."""
-                is_valid, message = ChatInterface._validate_api_keys(openai_k, etherscan_k)
-                
-                if is_valid:
-                    self.chat_interface = ChatInterface(openai_k, etherscan_k)
-                    return (
-                        "✅ API keys validated! You can start chatting now.",
-                        gr.update(interactive=True),
-                        gr.update(interactive=True)
-                    )
-                return (
-                    f"❌ Validation failed: {message}",
-                    gr.update(interactive=False),
-                    gr.update(interactive=False)
-                )
-
             async def handle_message(
                 message: str,
                 chat_history: List[Tuple[str, str]],
                 context: Dict[str, Any]
             ) -> Tuple[List[Tuple[str, str]], Dict[str, Any]]:
                 """Handle incoming messages."""
-                if not self.chat_interface:
-                    return [], {}
-                    
                 try:
                     history, new_context, _ = await self.chat_interface.process_message(
                         message,
@@ -539,19 +469,12 @@ class GradioInterface:
                     return chat_history, context
 
             # Connect Event Handlers
-            validate_btn.click(
-                fn=validate_keys,
-                inputs=[openai_key, etherscan_key],
-                outputs=[validation_status, msg_input, send_btn]
+            clear_btn.click(
+                fn=self.chat_interface.clear_context,
+                inputs=[],
+                outputs=[wallet_context, chatbot]
             )
 
-            if self.chat_interface:
-                clear_btn.click(
-                    fn=self.chat_interface.clear_context,
-                    inputs=[],
-                    outputs=[wallet_context, chatbot]
-                )
-
             # Message Handling
             msg_input.submit(
                 fn=handle_message,