Update app.py

app.py

@@ -2,15 +2,12 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Optional, Dict, Any
 from composio_llamaindex import ComposioToolSet, App, Action
-from llama_index.core.agent import FunctionCallingAgentWorker
-from llama_index.core.llms import ChatMessage
-from llama_index.llms.openai import OpenAI
-from llama_index.llms.gemini import Gemini
-from dotenv import load_dotenv
+from datetime import datetime, timedelta
+from collections import defaultdict, Counter
 import gradio as gr
 import os
 import json
-from datetime import datetime
+from dotenv import load_dotenv
 
 # Load environment variables
 load_dotenv()
@@ -37,8 +34,85 @@ class APIResponse:
 class CalendarService:
     def __init__(self):
         self.toolset = ComposioToolSet(api_key=os.getenv('COMPOSIO_API_KEY'))
-        self.llm = OpenAI(model="gpt-4o", api_key=os.getenv('OPENAI_API_KEY'))
         self.connections: Dict[str, Dict[str, Any]] = {}
+
+    def analyze_calendar_events(self, response_data):
+        """
+        Analyze calendar events and return statistics about meetings.
+        """
+        current_year = datetime.now().year
+        meetings = []
+        participants = []
+        meeting_times = []
+        total_duration = timedelta()
+        monthly_meetings = defaultdict(int)
+        daily_meetings = defaultdict(int)
+        
+        events = response_data.get('data', {}).get('event_data', {}).get('event_data', [])
+        
+        for event in events:
+            start_data = event.get('start', {})
+            end_data = event.get('end', {})
+            
+            try:
+                start = datetime.fromisoformat(start_data.get('dateTime').replace('Z', '+00:00'))
+                end = datetime.fromisoformat(end_data.get('dateTime').replace('Z', '+00:00'))
+                
+                if start.year == current_year:
+                    duration = end - start
+                    total_duration += duration
+                    
+                    monthly_meetings[start.strftime('%B')] += 1
+                    daily_meetings[start.strftime('%A')] += 1
+                    meeting_times.append(start.strftime('%H:%M'))
+                    
+                    if 'attendees' in event:
+                        for attendee in event['attendees']:
+                            if attendee.get('responseStatus') != 'declined':
+                                participants.append(attendee.get('email'))
+                    
+                    organizer_email = event.get('organizer', {}).get('email')
+                    if organizer_email:
+                        participants.append(organizer_email)
+                    
+                    meetings.append({
+                        'start': start,
+                        'duration': duration,
+                        'summary': event.get('summary', 'No Title')
+                    })
+            except (ValueError, TypeError, AttributeError) as e:
+                print(f"Error processing event: {e}")
+                continue
+        
+        total_meetings = len(meetings)
+        stats = {
+            "total_meetings_this_year": total_meetings
+        }
+        
+        if total_meetings > 0:
+            stats.update({
+                "total_time_spent": str(total_duration),
+                "busiest_month": max(monthly_meetings.items(), key=lambda x: x[1])[0] if monthly_meetings else "N/A",
+                "busiest_day": max(daily_meetings.items(), key=lambda x: x[1])[0] if daily_meetings else "N/A",
+                "most_frequent_participant": Counter(participants).most_common(1)[0][0] if participants else "N/A",
+                "average_meeting_duration": str(total_duration / total_meetings),
+                "most_common_meeting_time": Counter(meeting_times).most_common(1)[0][0] if meeting_times else "N/A",
+                "monthly_breakdown": dict(monthly_meetings),
+                "daily_breakdown": dict(daily_meetings)
+            })
+        else:
+            stats.update({
+                "total_time_spent": "0:00:00",
+                "busiest_month": "N/A",
+                "busiest_day": "N/A",
+                "most_frequent_participant": "N/A",
+                "average_meeting_duration": "0:00:00",
+                "most_common_meeting_time": "N/A",
+                "monthly_breakdown": {},
+                "daily_breakdown": {}
+            })
+        
+        return stats
         
     def initiate_connection(self, entity_id: str, redirect_url: Optional[str] = None) -> APIResponse:
         try:
@@ -80,8 +154,6 @@ class CalendarService:
                     error="No connection found for this entity ID"
                 )
             
-            # In a real implementation, you would check the actual status
-            # For now, we'll simulate the status check
             connection = self.connections[entity_id]
             
             return APIResponse(
@@ -100,52 +172,37 @@ class CalendarService:
     
     def generate_wrapped(self, entity_id: str) -> APIResponse:
         try:
-            tools = self.toolset.get_tools([
-                Action.GOOGLECALENDAR_GET_CALENDAR,
-                Action.GOOGLECALENDAR_FIND_EVENT,
-            ])
+            # Get current year's start and end dates
+            current_year = datetime.now().year
+            time_min = f"{current_year},1,1,0,0,0"
+            time_max = f"{current_year},12,31,23,59,59"
             
-            agent = FunctionCallingAgentWorker(
-                tools=tools,
-                llm=self.llm,
-                prefix_messages=[
-                    ChatMessage(
-                        role="system",
-                        content="""
-                        Use all the tools including get calendar and more available to you get factual data then
-                        Generate a creative Google Calendar Wrapped summary including:
-                        1. Total meetings this year
-                        2. Overall time spent in meetings
-                        3. Busiest month
-                        4. Busiest day
-                        5. Most frequent meeting participant
-                        6. Average meeting duration
-                        7. Most common meeting time
-                        
-                        Be entertaining and witty with the analysis. Conclude by assigning 
-                        a Greek god persona based on their meeting patterns.
-                        Search data from last 6 months instead of a year
-                        """
-                    )
-                ],
-                max_function_calls=10,
-                allow_parallel_tool_calls=False,
-                verbose=True
-            ).as_agent()
+            request_params = {
+                "calendar_id": "primary",
+                "timeMin": time_min,
+                "timeMax": time_max,
+                "single_events": True,
+                "max_results": 2500,
+                "order_by": "startTime"
+            }
             
-            response = agent.chat(
-                f"Create a Calendar Wrapped summary for user with entity_id: {entity_id}. "
-                f"Today's date is {datetime.now().isoformat()}"
-                "Use the available Google Calendar actions to gather real data about the user's calendar usage."
-                "calendar id is primary"
+            events_response = self.toolset.execute_action(
+                action=Action.GOOGLECALENDAR_FIND_EVENT,
+                params=request_params,
+                entity_id=entity_id
             )
             
-            return APIResponse(
-                success=True,
-                data={
-                    'wrapped_summary': str(response)
-                }
-            )
+            if events_response["successfull"]:
+                stats = self.analyze_calendar_events(events_response)
+                return APIResponse(
+                    success=True,
+                    data=stats
+                )
+            else:
+                return APIResponse(
+                    success=False,
+                    error=events_response["error"] or "Failed to fetch calendar events"
+                )
             
         except Exception as e:
             return APIResponse(