API

app.py

@@ -43,6 +43,10 @@ try:
     excel_content.seek(0)  # Reset buffer position
     customer_profiles = pd.read_excel(excel_content, sheet_name='Customer Profile (Individual)')
 
+    # Read Social Media Sentiment
+    excel_content.seek(0)  # Reset buffer position
+    customer_Media = pd.read_excel(excel_content, sheet_name='Social Media Sentiment',parse_dates=['Timestamp'])
+
     logger.info("Successfully downloaded and loaded Excel file")
     
     # Process the data
@@ -59,6 +63,13 @@ try:
     numerical_features = ['Age', 'Income per year (in dollars)']  # Add or modify based on your actual columns
     scaler = StandardScaler()
     customer_profiles[numerical_features] = scaler.fit_transform(customer_profiles[numerical_features])
+
+      # Process the data media
+    customer_Media['Customer_Id'] = customer_Media['Customer_Id'].astype(str)
+    tweet_categories = customer_Media[['Post_Id', 'Platform']].drop_duplicates().set_index('Post_Id')['Platform'].to_dict()
+    tweet_counts = customer_Media.groupby(['Customer_Id', 'Post_Id']).size().unstack(fill_value=0)
+    sparse_tweet_counts = sparse.csr_matrix(tweet_counts)
+    cosine_similarities_tweet = cosine_similarity(sparse_tweet_counts.T)
     
     logger.info("Data processing completed successfully")
     
@@ -353,4 +364,163 @@ async def get_customer_content_recommendations(customer_id: str, n: int = 5):
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=f"Error processing request: {str(e)}"
-        )
+        )
+    
+@app.get("/social-sentiment/{customer_id}")
+async def get_social_sentiment(customer_id: str):
+    """
+    Get social media sentiment analysis for a customer
+    
+    Parameters:
+    - customer_id: The ID of the customer
+    
+    Returns:
+    - JSON object containing sentiment analysis and insights
+    """
+    try:
+        # Validate customer
+        if customer_id not in customer_Media['Customer_Id'].unique():
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="No social media data found for this customer"
+            )
+        
+        # Get customer's social media data
+        customer_posts = customer_Media[customer_Media['Customer_Id'] == customer_id]
+        
+        # Calculate sentiment metrics
+        avg_sentiment = customer_posts['Sentiment_Score'].mean()
+        recent_sentiment = customer_posts.sort_values('Timestamp', ascending=False)['Sentiment_Score'].iloc[0]
+        
+        # Calculate sentiment trend
+        customer_posts['Timestamp'] = pd.to_datetime(customer_posts['Timestamp'])
+        sentiment_trend = customer_posts.sort_values('Timestamp')
+        
+        # Platform breakdown
+        platform_stats = customer_posts.groupby('Platform').agg({
+            'Post_Id': 'count',
+            'Sentiment_Score': 'mean'
+        }).round(2)
+        
+        platform_breakdown = [
+            {
+                "platform": platform,
+                "post_count": int(stats['Post_Id']),
+                "avg_sentiment": float(stats['Sentiment_Score'])
+            }
+            for platform, stats in platform_stats.iterrows()
+        ]
+        
+        # Intent analysis
+        intent_distribution = customer_posts['Intent'].value_counts().to_dict()
+        
+        # Get most recent posts with sentiments
+        recent_posts = customer_posts.sort_values('Timestamp', ascending=False).head(5)
+        recent_activities = [
+            {
+                "timestamp": post['Timestamp'].strftime('%Y-%m-%d %H:%M:%S'),
+                "platform": post['Platform'],
+                "content": post['Content'],
+                "sentiment_score": float(post['Sentiment_Score']),
+                "intent": post['Intent']
+            }
+            for _, post in recent_posts.iterrows()
+        ]
+        
+        # Calculate sentiment categories
+        sentiment_categories = {
+            "positive": len(customer_posts[customer_posts['Sentiment_Score'] > 0.5]),
+            "neutral": len(customer_posts[(customer_posts['Sentiment_Score'] >= -0.5) & 
+                                       (customer_posts['Sentiment_Score'] <= 0.5)]),
+            "negative": len(customer_posts[customer_posts['Sentiment_Score'] < -0.5])
+        }
+        
+        # Determine overall mood
+        if avg_sentiment > 0.5:
+            overall_mood = "Positive"
+        elif avg_sentiment < -0.5:
+            overall_mood = "Negative"
+        else:
+            overall_mood = "Neutral"
+            
+        # Generate insights
+        insights = []
+        
+        # Trend insight
+        sentiment_change = recent_sentiment - customer_posts['Sentiment_Score'].iloc[0]
+        if abs(sentiment_change) > 0.3:
+            trend_direction = "improved" if sentiment_change > 0 else "declined"
+            insights.append(f"Customer sentiment has {trend_direction} over time")
+            
+        # Platform insight
+        if len(platform_stats) > 1:
+            best_platform = platform_stats['Sentiment_Score'].idxmax()
+            insights.append(f"Customer shows most positive engagement on {best_platform}")
+            
+        # Engagement insight
+        if len(recent_activities) > 0:
+            recent_avg = sum(post['sentiment_score'] for post in recent_activities) / len(recent_activities)
+            if abs(recent_avg - avg_sentiment) > 0.3:
+                trend = "improving" if recent_avg > avg_sentiment else "declining"
+                insights.append(f"Recent sentiment is {trend} compared to overall average")
+        
+        return {
+            "customer_id": customer_id,
+            "overall_sentiment": {
+                "average_score": float(avg_sentiment),
+                "recent_score": float(recent_sentiment),
+                "overall_mood": overall_mood
+            },
+            "sentiment_distribution": sentiment_categories,
+            "platform_analysis": platform_breakdown,
+            "intent_analysis": intent_distribution,
+            "recent_activities": recent_activities,
+            "insights": insights,
+            "analysis_timestamp": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error processing social sentiment for customer {customer_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error processing request: {str(e)}"
+        )
+
+# Add a combined endpoint for full customer analysis
+@app.get("/customer-analysis/{customer_id}")
+async def get_customer_analysis(customer_id: str):
+    """
+    Get comprehensive customer analysis including recommendations and sentiment
+    
+    Parameters:
+    - customer_id: The ID of the customer
+    
+    Returns:
+    - JSON object containing full customer analysis
+    """
+    try:
+        # Get content recommendations
+        content_recs = await get_customer_content_recommendations(customer_id)
+        
+        # Get social sentiment
+        sentiment_analysis = await get_social_sentiment(customer_id)
+        
+        # Get purchase recommendations
+        purchase_recs = await get_recommendations(customer_id)
+        
+        return {
+            "customer_id": customer_id,
+            "sentiment_analysis": sentiment_analysis,
+            "content_recommendations": content_recs,
+            "purchase_recommendations": purchase_recs,
+            "analysis_timestamp": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        }
+        
+    except Exception as e:
+        logger.error(f"Error processing customer analysis for {customer_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error processing request: {str(e)}"
+        )