Update app.py

app.py

@@ -3,69 +3,30 @@ import base64
 from datetime import datetime
 import json
 import os
-from openai import OpenAI
-import requests
+from anthropic import Anthropic
 from PIL import Image
 import io
 import yaml
 
-def load_openai_key():
-    """Load OpenAI API key from HuggingFace secrets"""
+def load_anthropic_key():
+    """Load Anthropic API key from environment variables"""
     try:
-        # Try to get from HuggingFace secrets via environment variable
-        api_key = os.getenv('OPENAI_API_KEY')
-        
+        api_key = os.getenv('ANTHROPIC_API_KEY')
         if not api_key:
-            st.error("OpenAI API key not found in HuggingFace secrets. Please ensure the secret is set as OPENAI_API_KEY_HF in your HuggingFace space.")
+            st.error("Anthropic API key not found. Please set ANTHROPIC_API_KEY in your environment variables.")
             return None
-            
         return api_key
     except Exception as e:
-        st.error(f"Error loading OpenAI API key from HuggingFace secrets: {str(e)}")
+        st.error(f"Error loading Anthropic API key: {str(e)}")
         return None
 
-def initialize_openai_client():
-    """Initialize OpenAI client with API key"""
-    api_key = load_openai_key()
+def initialize_anthropic_client():
+    """Initialize Anthropic client with API key"""
+    api_key = load_anthropic_key()
     if api_key:
-        return OpenAI(api_key=api_key)
+        return Anthropic(api_key=api_key)
     return None
 
-def detect_chart_type(client, image_data):
-    """Detect chart type using OpenAI's GPT-4 vision model"""
-    try:
-        encoded_image = base64.b64encode(image_data).decode('utf-8')
-        
-        messages = [
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": "What type of financial chart is this? Choose from: Candlestick, Line, OHLC, Area, or Other. Just respond with one word."
-                    },
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": f"data:image/jpeg;base64,{encoded_image}"
-                        }
-                    }
-                ]
-            }
-        ]
-        
-        response = client.chat.completions.create(
-            model="gpt-4",
-            messages=messages,
-            max_tokens=50
-        )
-        
-        chart_type = response.choices[0].message.content.strip()
-        return chart_type
-    except Exception as e:
-        st.error(f"Error in chart type detection: {str(e)}")
-        return "Other"
-
 def create_prompt_template(patterns, indicators):
     """Creates a structured prompt for the LLM based on the chart and analysis needs"""
     prompt = """You are an expert financial analyst. Please analyze this financial chart (chart type will be detected automatically) and provide insights in the following structured format:
@@ -106,8 +67,41 @@ def create_prompt_template(patterns, indicators):
         indicators=', '.join(indicators) if indicators else 'visible indicators'
     )
 
-def analyze_chart_with_openai(client, image_data, prompt, chart_type=None):
-    """Analyze chart using OpenAI's GPT-4 model"""
+def detect_chart_type(client, image_data):
+    """Detect chart type using Claude Vision"""
+    try:
+        encoded_image = base64.b64encode(image_data).decode('utf-8')
+        
+        message = client.messages.create(
+            model="claude-3-opus-20240229",
+            max_tokens=50,
+            messages=[{
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": "What type of financial chart is this? Choose from: Candlestick, Line, OHLC, Area, or Other. Just respond with one word."
+                    },
+                    {
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": "image/jpeg",
+                            "data": encoded_image
+                        }
+                    }
+                ]
+            }]
+        )
+        
+        chart_type = message.content[0].text.strip()
+        return chart_type
+    except Exception as e:
+        st.error(f"Error in chart type detection: {str(e)}")
+        return "Other"
+
+def analyze_chart_with_claude(client, image_data, prompt, chart_type=None):
+    """Analyze chart using Claude Vision"""
     try:
         encoded_image = base64.b64encode(image_data).decode('utf-8')
         
@@ -116,8 +110,10 @@ def analyze_chart_with_openai(client, image_data, prompt, chart_type=None):
             chart_type = detect_chart_type(client, image_data)
             st.info(f"Detected chart type: {chart_type}")
         
-        messages = [
-            {
+        message = client.messages.create(
+            model="claude-3-opus-20240229",
+            max_tokens=1000,
+            messages=[{
                 "role": "user",
                 "content": [
                     {
@@ -125,24 +121,20 @@ def analyze_chart_with_openai(client, image_data, prompt, chart_type=None):
                         "text": prompt.format(chart_type=chart_type)
                     },
                     {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": f"data:image/jpeg;base64,{encoded_image}"
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": "image/jpeg",
+                            "data": encoded_image
                         }
                     }
                 ]
-            }
-        ]
-        
-        response = client.chat.completions.create(
-            model="gpt-4o",
-            messages=messages,
-            max_tokens=1000
+            }]
         )
         
-        return response.choices[0].message.content, chart_type
+        return message.content[0].text, chart_type
     except Exception as e:
-        st.error(f"Error in OpenAI analysis: {str(e)}")
+        st.error(f"Error in Claude analysis: {str(e)}")
         return None, None
 
 def save_chat_history(chat_history, filename=None):
@@ -172,10 +164,10 @@ def main():
         initial_sidebar_state="expanded"
     )
     
-    # Initialize OpenAI client
-    client = initialize_openai_client()
+    # Initialize Anthropic client
+    client = initialize_anthropic_client()
     if not client:
-        st.error("Failed to initialize OpenAI client. Please check your API key configuration.")
+        st.error("Failed to initialize Anthropic client. Please check your API key configuration.")
         return
     
     # Initialize session state for chat history
@@ -200,7 +192,6 @@ def main():
         elif upload_option == "Take Screenshot":
             if st.button("Take Screenshot", key="screenshot"):
                 st.info("Feature coming soon! For now, please use the Upload Image option.")
-                # Future screenshot implementation will go here
                 screenshot_taken = False
         
         # Analysis Options
@@ -217,10 +208,6 @@ def main():
              "Volume", "Stochastic", "ADX"]
         )
 
-        # Initialize or get chart type from session state
-        if 'detected_chart_type' not in st.session_state:
-            st.session_state.detected_chart_type = None
-
     # Main content area
     st.title("📈 Stock Chart Analysis Assistant")
     
@@ -237,7 +224,6 @@ def main():
         
         if st.button("Analyze"):
             if upload_option == "Ask Question" and user_question:
-                # Handle question-based analysis here
                 st.info("Question-based analysis feature coming soon!")
             elif uploaded_file is None and not screenshot_taken:
                 st.warning("Please upload an image or take a screenshot first.")
@@ -248,20 +234,17 @@ def main():
                     
                     if uploaded_file:
                         # Process image and get analysis
-                        analysis_result, detected_chart_type = analyze_chart_with_openai(
+                        analysis_result, chart_type = analyze_chart_with_claude(
                             client,
                             uploaded_file.getvalue(),
                             prompt
                         )
                         
-                        # Store the detected chart type in session state
-                        st.session_state.detected_chart_type = detected_chart_type
-                        
                         if analysis_result:
                             # Add to chat history
                             st.session_state.chat_history.append({
                                 'timestamp': datetime.now().isoformat(),
-                                'chart_type': detected_chart_type,
+                                'chart_type': chart_type,
                                 'analysis': analysis_result
                             })