Update main.py

main.py

@@ -1,23 +1,19 @@
 import asyncio
-import time  # <-- Add this line to import the time module
+import time
+import re
+import json
 from crewai import Crew, Process
 from textwrap import dedent
-import json
 from crypto_analysis_agents import CryptoAnalysisAgents
-from crypto__analysis_tasks import CryptoAnalysisTasks # <-- Corrected the import name based on previous feedback
+from crypto__analysis_tasks import CryptoAnalysisTasks
 
 class CryptoCrew:
     def __init__(self, crypto):
         self.crypto = crypto
-        # Initialize agents once for reuse
         self.agents_instance = CryptoAnalysisAgents()
         self.tasks_instance = CryptoAnalysisTasks()
 
     def run(self):
-        # Using asyncio.run() is fine for a standalone script,
-        # but can cause issues in environments that already have an event loop (like Streamlit).
-        # It's better to manage the loop explicitly when integrating.
-        # However, for now, we'll keep it as is since your app.py calls it simply.
         return asyncio.run(self.run_async())
 
     async def run_async(self):
@@ -37,65 +33,255 @@ class CryptoCrew:
                 self.tasks_instance.recommend(advisor, self.crypto)
             ]
 
-            # Optimized crew configuration
+            # Enhanced crew configuration
             crew = Crew(
                 agents=[market_analyst, technical_analyst, advisor],
                 tasks=tasks,
-                verbose=False,
+                verbose=True,  # Enable for better debugging
                 process=Process.sequential,
-                max_iterations=5,
-                task_timeout=60
+                max_iterations=8,
+                task_timeout=90
             )
 
             # Run crew
             result = await asyncio.to_thread(crew.kickoff)
-
             end_time = time.time()
-            print(f"Analysis completed in {end_time - start_time:.2f} seconds")
 
-            return self.parse_result(result)
+            return self.parse_result(result, end_time - start_time)
+            
         except Exception as e:
-            # When an exception occurs, calculate duration up to the point of failure
             execution_time = time.time() - start_time
             return {
                 "summary": f"Analysis failed: {str(e)}",
-                "sentiment": {"overall": "Neutral", "confidence": "Low"},
-                "recommendation": "HOLD",
-                "execution_time": execution_time
+                "market_data": self._get_fallback_market_data(),
+                "technical_data": self._get_fallback_technical_data(),
+                "sentiment": self._get_fallback_sentiment(),
+                "recommendation": {"action": "HOLD", "confidence": "Low", "reasoning": "Analysis incomplete"},
+                "execution_time": execution_time,
+                "risk_assessment": "High - Analysis failed"
             }
 
-    def parse_result(self, result):
-        # Enhanced parsing logic
+    def parse_result(self, result, execution_time):
+        """Enhanced parsing to extract structured data from LLM responses"""
         result_str = str(result)
+        
+        # Extract market data
+        market_data = self._extract_market_data(result_str)
+        
+        # Extract technical analysis
+        technical_data = self._extract_technical_data(result_str)
+        
+        # Extract detailed sentiment analysis
+        sentiment_analysis = self._extract_sentiment_analysis(result_str)
+        
+        # Extract recommendation
+        recommendation = self._extract_recommendation(result_str)
+        
+        # Extract risk assessment
+        risk_assessment = self._extract_risk_assessment(result_str)
+        
+        return {
+            "summary": self._clean_summary(result_str),
+            "market_data": market_data,
+            "technical_data": technical_data,
+            "sentiment": sentiment_analysis,
+            "recommendation": recommendation,
+            "risk_assessment": risk_assessment,
+            "execution_time": execution_time,
+            "last_updated": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime())
+        }
 
-        # Extract key information using simple parsing
-        sentiment = "Neutral"
-        recommendation = "HOLD"
+    def _extract_market_data(self, text):
+        """Extract market metrics from analysis"""
+        market_data = {
+            "current_price": "N/A",
+            "market_cap": "N/A", 
+            "price_change_24h": "N/A",
+            "price_change_7d": "N/A",
+            "volume_24h": "N/A",
+            "market_dominance": "N/A"
+        }
+        
+        # Extract price
+        price_match = re.search(r'\$([0-9,]+\.?[0-9]*)', text)
+        if price_match:
+            market_data["current_price"] = f"${price_match.group(1)}"
+            
+        # Extract market cap
+        mcap_match = re.search(r'market cap[:\s]+\$([0-9,]+\.?[0-9]*[BMK]?)', text, re.IGNORECASE)
+        if mcap_match:
+            market_data["market_cap"] = f"${mcap_match.group(1)}"
+            
+        # Extract percentage changes
+        change_24h = re.search(r'24h?[:\s]*([+-]?[0-9]+\.?[0-9]*%)', text, re.IGNORECASE)
+        if change_24h:
+            market_data["price_change_24h"] = change_24h.group(1)
+            
+        change_7d = re.search(r'7d?[:\s]*([+-]?[0-9]+\.?[0-9]*%)', text, re.IGNORECASE)
+        if change_7d:
+            market_data["price_change_7d"] = change_7d.group(1)
+            
+        return market_data
+
+    def _extract_technical_data(self, text):
+        """Extract technical indicators"""
+        technical_data = {
+            "rsi": "N/A",
+            "rsi_signal": "Neutral",
+            "moving_average_7d": "N/A", 
+            "moving_average_50d": "N/A",
+            "trend": "Neutral",
+            "support_level": "N/A",
+            "resistance_level": "N/A"
+        }
+        
+        # Extract RSI
+        rsi_match = re.search(r'RSI[:\s]*([0-9]+\.?[0-9]*)', text, re.IGNORECASE)
+        if rsi_match:
+            rsi_value = float(rsi_match.group(1))
+            technical_data["rsi"] = str(rsi_value)
+            if rsi_value > 70:
+                technical_data["rsi_signal"] = "Overbought"
+            elif rsi_value < 30:
+                technical_data["rsi_signal"] = "Oversold" 
+            else:
+                technical_data["rsi_signal"] = "Neutral"
+                
+        # Extract moving averages
+        ma_match = re.search(r'(?:7-day )?MA[:\s]*\$([0-9,]+\.?[0-9]*)', text, re.IGNORECASE)
+        if ma_match:
+            technical_data["moving_average_7d"] = f"${ma_match.group(1)}"
+            
+        # Determine trend
+        if "bullish" in text.lower() or "uptrend" in text.lower():
+            technical_data["trend"] = "Bullish"
+        elif "bearish" in text.lower() or "downtrend" in text.lower():
+            technical_data["trend"] = "Bearish"
+            
+        return technical_data
 
-        if "Positive" in result_str or "bullish" in result_str.lower():
-            sentiment = "Positive"
-        elif "Negative" in result_str or "bearish" in result_str.lower():
-            sentiment = "Negative"
+    def _extract_sentiment_analysis(self, text):
+        """Extract differentiated sentiment analysis"""
+        # Default to varied sentiments for demonstration
+        sentiment_data = {
+            "overall": "Neutral",
+            "social_media": "Neutral", 
+            "news": "Neutral",
+            "community": "Neutral"
+        }
+        
+        # Extract overall sentiment
+        if re.search(r'overall.*positive|positive.*overall', text, re.IGNORECASE):
+            sentiment_data["overall"] = "Positive"
+        elif re.search(r'overall.*negative|negative.*overall', text, re.IGNORECASE):
+            sentiment_data["overall"] = "Negative"
+        elif "bullish" in text.lower():
+            sentiment_data["overall"] = "Positive"
+        elif "bearish" in text.lower():
+            sentiment_data["overall"] = "Negative"
+            
+        # Extract social media sentiment
+        if re.search(r'social.*positive|twitter.*positive|reddit.*positive', text, re.IGNORECASE):
+            sentiment_data["social_media"] = "Positive"
+        elif re.search(r'social.*negative|twitter.*negative|reddit.*negative', text, re.IGNORECASE):
+            sentiment_data["social_media"] = "Negative"
+        elif re.search(r'social.*bullish|community.*optimistic', text, re.IGNORECASE):
+            sentiment_data["social_media"] = "Positive"
+            
+        # Extract news sentiment
+        if re.search(r'news.*positive|headlines.*positive|media.*positive', text, re.IGNORECASE):
+            sentiment_data["news"] = "Positive"
+        elif re.search(r'news.*negative|headlines.*negative|regulatory.*concern', text, re.IGNORECASE):
+            sentiment_data["news"] = "Negative"
+            
+        # Extract community sentiment
+        if re.search(r'community.*positive|development.*active|adoption.*growing', text, re.IGNORECASE):
+            sentiment_data["community"] = "Positive"
+        elif re.search(r'community.*negative|development.*slow|adoption.*declining', text, re.IGNORECASE):
+            sentiment_data["community"] = "Negative"
+        elif re.search(r'institutional.*adoption|enterprise.*adoption', text, re.IGNORECASE):
+            sentiment_data["community"] = "Positive"
+            
+        return sentiment_data
 
-        if "BUY" in result_str:
-            recommendation = "BUY"
-        elif "SELL" in result_str:
-            recommendation = "SELL"
+    def _extract_recommendation(self, text):
+        """Extract investment recommendation with reasoning"""
+        recommendation = {
+            "action": "HOLD",
+            "confidence": "Medium", 
+            "reasoning": "Standard analysis completed",
+            "time_horizon": "Medium-term",
+            "risk_level": "Moderate"
+        }
+        
+        # Extract recommendation
+        if re.search(r'recommendation[:\s]*BUY|BUY.*recommendation', text, re.IGNORECASE):
+            recommendation["action"] = "BUY"
+        elif re.search(r'recommendation[:\s]*SELL|SELL.*recommendation', text, re.IGNORECASE):
+            recommendation["action"] = "SELL"
             
+        # Extract confidence
+        if re.search(r'confidence[:\s]*high|high.*confidence', text, re.IGNORECASE):
+            recommendation["confidence"] = "High"
+        elif re.search(r'confidence[:\s]*low|low.*confidence', text, re.IGNORECASE):
+            recommendation["confidence"] = "Low"
+            
+        # Extract reasoning
+        reason_match = re.search(r'(?:reason|reasoning)[:\s]*([^.]+)', text, re.IGNORECASE)
+        if reason_match:
+            recommendation["reasoning"] = reason_match.group(1).strip()
+            
+        return recommendation
+
+    def _extract_risk_assessment(self, text):
+        """Extract risk assessment"""
+        if re.search(r'high.*risk|risk.*high|volatile|risky', text, re.IGNORECASE):
+            return "High Risk"
+        elif re.search(r'low.*risk|risk.*low|stable|conservative', text, re.IGNORECASE):
+            return "Low Risk"
+        else:
+            return "Moderate Risk"
+
+    def _clean_summary(self, text):
+        """Clean and format the summary"""
+        # Remove excess whitespace and format
+        summary = re.sub(r'\s+', ' ', text).strip()
+        # Truncate if too long
+        if len(summary) > 1000:
+            summary = summary[:1000] + "..."
+        return summary
+
+    def _get_fallback_market_data(self):
         return {
-            "summary": result_str,
-            "sentiment": {
-                "overall": sentiment,
-                "social_media": sentiment,
-                "news": sentiment,
-                "community": sentiment
-            },
-            "recommendation": recommendation,
-            "confidence": "Medium"
+            "current_price": "N/A",
+            "market_cap": "N/A",
+            "price_change_24h": "N/A", 
+            "price_change_7d": "N/A",
+            "volume_24h": "N/A",
+            "market_dominance": "N/A"
+        }
+
+    def _get_fallback_technical_data(self):
+        return {
+            "rsi": "N/A",
+            "rsi_signal": "Neutral",
+            "moving_average_7d": "N/A",
+            "moving_average_50d": "N/A", 
+            "trend": "Neutral",
+            "support_level": "N/A",
+            "resistance_level": "N/A"
+        }
+
+    def _get_fallback_sentiment(self):
+        return {
+            "overall": "Neutral",
+            "social_media": "Neutral",
+            "news": "Neutral", 
+            "community": "Neutral"
         }
 
 if __name__ == "__main__":
-    print("## Welcome to Crypto Analysis Crew")
+    print("## Welcome to Enhanced Crypto Analysis Crew")
     print('-------------------------------')
     crypto = input(dedent("""
     What is the cryptocurrency you want to analyze?
@@ -103,6 +289,6 @@ if __name__ == "__main__":
     crypto_crew = CryptoCrew(crypto)
     result = crypto_crew.run()
     print("\n\n########################")
-    print("## Here is the Report")
+    print("## Here is the Enhanced Report")
     print("########################\n")
-    print(json.dumps(result, indent=2))
+    print(json.dumps(result, indent=2))