Update app.py

app.py

@@ -1,21 +1,30 @@
 import gradio as gr
 import openai
 import os
-import cv2
-import numpy as np
 import base64
-import re
-from typing import Tuple, Dict, Any
-from datetime import datetime
+from typing import Tuple
 
 # OpenAI API Configuration
 openai.api_key = os.getenv("OPENAI_API_KEY")
 ANALYSIS_MODEL = "gpt-4o"
 MAX_TOKENS = 4096
 
+# System Prompt Configuration
+SYSTEM_PROMPT = """Professional Crypto Technical Analyst:
+1. Identify all technical patterns in the chart
+2. Determine key support/resistance levels
+3. Analyze volume and momentum indicators
+4. Calculate risk/reward ratios
+5. Provide clear trading recommendations
+6. Include specific price targets
+7. Assess market sentiment
+8. Evaluate trend strength
+9. Identify potential breakout/breakdown levels
+10. Provide time-based projections"""
+
 class ChartAnalyzer:
     def __init__(self):
-        self.last_analysis = {}
+        self.last_analysis = ""
 
     def encode_image(self, image_path: str) -> str:
         """Encode image to base64 with validation"""
@@ -23,147 +32,31 @@ class ChartAnalyzer:
             raise FileNotFoundError("File not found")
         if not image_path.lower().endswith(('.png', '.jpg', '.jpeg')):
             raise ValueError("Unsupported file format")
+        if os.path.getsize(image_path) > 5 * 1024 * 1024:
+            raise ValueError("Maximum file size is 5MB")
             
         with open(image_path, "rb") as image_file:
             return base64.b64encode(image_file.read()).decode('utf-8')
 
-    def extract_financial_data(self, analysis_text: str) -> Dict[str, Any]:
-        """Extract structured data from analysis text"""
-        data = {
-            'current_price': None,
-            'support_levels': [],
-            'resistance_levels': [],
-            'patterns': [],
-            'timeframe': None
-        }
-        
-        # Improved price extraction with currency symbols
-        price_match = re.search(r'(?:\$|€|£)?(\d+\.?\d*)', analysis_text)
-        if price_match:
-            try:
-                data['current_price'] = float(price_match.group(1))
-            except ValueError:
-                pass
-            
-        # Enhanced timeframe detection
-        timeframe_pattern = r'(?:timeframe|period|chart)\s*(?:is|shows|of)\s*([1-9][0-9]*[mhDWMY])'
-        timeframe_match = re.search(timeframe_pattern, analysis_text, re.IGNORECASE)
-        if timeframe_match:
-            data['timeframe'] = timeframe_match.group(1)
-            
-        # Pattern detection with variations
-        patterns = {
-            'triangle': r'triangle|symmetrical|ascending|descending',
-            'wedge': r'wedge|rising wedge|falling wedge',
-            'head and shoulders': r'head\s*and\s*shoulders|H&S',
-            'flag': r'flag|bull flag|bear flag',
-            'double top': r'double top|M pattern',
-            'double bottom': r'double bottom|W pattern'
-        }
-        
-        for pattern_name, pattern_regex in patterns.items():
-            if re.search(pattern_regex, analysis_text, re.IGNORECASE):
-                data['patterns'].append(pattern_name)
-        
-        # Level extraction with multiple formats
-        level_pattern = r'(support|resistance)\s*(?:at|level:?)\s*\$?(\d+\.?\d*)'
-        levels = re.findall(level_pattern, analysis_text, re.IGNORECASE)
-        for level_type, value in levels:
-            try:
-                numeric_value = float(value)
-                if level_type.lower() == 'support':
-                    data['support_levels'].append(numeric_value)
-                else:
-                    data['resistance_levels'].append(numeric_value)
-            except ValueError:
-                pass
-                
-        return data
-
-    def calculate_confidence(self, analysis_text: str) -> float:
-        """Dynamic confidence calculation"""
-        confidence_signals = {
-            r'\bclear pattern\b': 0.3,
-            r'\bstrong volume\b': 0.2,
-            r'\bkey level (break|test)\b': 0.25,
-            r'\bmultiple indicators\b': 0.15,
-            r'\balignment with\b': 0.1
-        }
-        
-        confidence = 0.0
-        for pattern, value in confidence_signals.items():
-            if re.search(pattern, analysis_text, re.IGNORECASE):
-                confidence += value
-                
-        return min(max(confidence, 0.0), 1.0)
-
-    def generate_annotations(self, img: np.ndarray, analysis: Dict) -> np.ndarray:
-        """Advanced chart annotations"""
-        h, w = img.shape[:2]
-        overlay = img.copy()
-        
-        # Dynamic trend lines based on patterns
-        if any(p in analysis['patterns'] for p in ['triangle', 'wedge']):
-            cv2.line(overlay, (w//4, h//4), (3*w//4, 3*h//4), (0,255,255), 2)
-            
-        # Support/resistance zones with labels
-        for i, level in enumerate(analysis['support_levels']):
-            y_pos = int(h * 0.85 - i*20)
-            cv2.line(overlay, (0, y_pos), (w, y_pos), (0,255,0), 2)
-            cv2.putText(overlay, f"S: {level}", (10, y_pos-5), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,0), 1)
-            
-        for i, level in enumerate(analysis['resistance_levels']):
-            y_pos = int(h * 0.15 + i*20)
-            cv2.line(overlay, (0, y_pos), (w, y_pos), (0,0,255), 2)
-            cv2.putText(overlay, f"R: {level}", (10, y_pos+15), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,255), 1)
-        
-        # Confidence meter with percentage
-        confidence = self.calculate_confidence(analysis['raw_text'])
-        cv2.rectangle(overlay, (w-150, 20), (w-50, 40), (50,50,50), -1)
-        cv2.rectangle(overlay, (w-150, 20), 
-                     (w-150 + int(100*confidence), 40), 
-                     (0,255,0), -1)
-        cv2.putText(overlay, f"{confidence*100:.0f}%", (w-140, 35), 
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255,255,255), 1)
-                     
-        return cv2.addWeighted(overlay, 0.3, img, 0.7, 0)
-
-    def analyze_chart(self, image_path: str) -> Tuple[str, str]:
-        """Complete analysis pipeline"""
+    def analyze_chart(self, image_path: str) -> str:
+        """Core analysis function"""
         try:
-            # Validate image first
-            if not os.path.exists(image_path):
-                raise ValueError("Image file not found")
-                
-            if os.path.getsize(image_path) > 5*1024*1024:  # 5MB limit
-                raise ValueError("Image size exceeds 5MB limit")
-
-            # Image processing
             base64_image = self.encode_image(image_path)
-            image_url = f"data:image/jpeg;base64,{base64_image}"
             
-            # AI Analysis
             response = openai.ChatCompletion.create(
                 model=ANALYSIS_MODEL,
                 messages=[
                     {
                         "role": "system",
-                        "content": """Expert Crypto Chart Analysis Protocol:
-1. Identify exact numerical price levels (e.g., $32,500.75)
-2. Detect chart timeframe from axis/price action
-3. List all technical patterns with confidence
-4. Analyze volume and momentum indicators
-5. Provide specific trade entry/exit levels"""
+                        "content": SYSTEM_PROMPT
                     },
                     {
                         "role": "user",
                         "content": [
-                            {"type": "text", "text": "Perform full technical analysis:"},
+                            {"type": "text", "text": "Perform detailed technical analysis of this chart:"},
                             {
                                 "type": "image_url",
-                                "image_url": {"url": image_url}
+                                "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}
                             }
                         ]
                     }
@@ -171,65 +64,19 @@ class ChartAnalyzer:
                 max_tokens=MAX_TOKENS
             )
             
-            raw_text = response.choices[0].message.content
-            analysis = self.extract_financial_data(raw_text)
-            analysis['raw_text'] = raw_text
-            
-            # Image annotation
-            img = cv2.imread(image_path)
-            if img is not None:
-                img = cv2.resize(img, (1024, 512))
-                annotated_img = self.generate_annotations(img, analysis)
-                output_path = f"analyzed_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
-                cv2.imwrite(output_path, annotated_img)
-            else:
-                output_path = None
-                
-            # Safe formatting
-            current_price_str = (
-                f"{analysis['current_price']:.2f}" 
-                if analysis['current_price'] is not None 
-                else "N/A"
-            )
+            self.last_analysis = response.choices[0].message.content
+            return self.last_analysis
             
-            support_levels = (
-                ', '.join(map(lambda x: f"{x:.2f}", analysis['support_levels'])) 
-                or "None"
-            )
-            
-            resistance_levels = (
-                ', '.join(map(lambda x: f"{x:.2f}", analysis['resistance_levels'])) 
-                or "None"
-            )
-            
-            formatted_output = f"""
-            ## 📊 Comprehensive Analysis
-            **Current Price:** ${current_price_str}
-            **Timeframe:** {analysis['timeframe'] or 'Auto-detected'}
-            
-            ### 🔑 Key Levels
-            - Support: {support_levels}
-            - Resistance: {resistance_levels}
-            
-            ### 🌀 Detected Patterns
-            {', '.join(analysis['patterns']).title() or 'No clear patterns detected'}
-            
-            ### 📝 Detailed Analysis
-            {raw_text}
-            """
-            
-            return formatted_output, output_path
-            
-        except openai.error.InvalidRequestError as e:
-            return f"API Error: {str(e)}", None
+        except openai.error.APIError as e:
+            return f"OpenAI API Error: {str(e)}"
         except Exception as e:
-            return f"Analysis Error: {str(e)}", None
+            return f"Analysis Error: {str(e)}"
 
 # Gradio Interface
 analyzer = ChartAnalyzer()
 
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="emerald")) as demo:
-    gr.Markdown("# 🔥 Pro Crypto Chart Analyzer")
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as demo:
+    gr.Markdown("# 🚀 Advanced Crypto Analysis System")
     
     with gr.Row():
         with gr.Column(scale=1):
@@ -237,24 +84,20 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="emerald")) as demo:
                 type="filepath",
                 label="Upload Chart (PNG/JPG)",
                 sources=["upload"],
-                height=300
+                height=200
             )
-            analyze_btn = gr.Button("Analyze Now", variant="primary")
+            analyze_btn = gr.Button("Start Analysis", variant="primary")
             
         with gr.Column(scale=2):
-            with gr.Tabs():
-                with gr.TabItem("Technical Report"):
-                    analysis_output = gr.Markdown()
-                with gr.TabItem("Annotated Chart"):
-                    chart_output = gr.Image(
-                        label="Pattern Recognition",
-                        interactive=False
-                    )
+            analysis_output = gr.Markdown(
+                label="Professional Analysis Report",
+                elem_classes=["analysis-box"]
+            )
 
     analyze_btn.click(
         fn=analyzer.analyze_chart,
         inputs=chart_input,
-        outputs=[analysis_output, chart_output]
+        outputs=analysis_output
     )
 
 if __name__ == "__main__":