Create app.py

app.py

@@ -0,0 +1,232 @@
+import os
+import pickle
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+from datetime import datetime, timedelta
+import gradio as gr
+
+# SCOPES for Google Calendar API
+SCOPES = ['https://www.googleapis.com/auth/calendar.readonly', 'https://www.googleapis.com/auth/calendar']
+
+def authenticate_google():
+    """Authenticate and return Google Calendar service."""
+    creds = None
+    try:
+        if os.path.exists('token.pickle'):
+            try:
+                with open('token.pickle', 'rb') as token:
+                    creds = pickle.load(token)
+                
+                if not creds or not creds.valid:
+                    if creds and creds.expired and creds.refresh_token:
+                        try:
+                            creds.refresh(Request())
+                        except Exception:
+                            os.remove('token.pickle')
+                            creds = None
+                    else:
+                        os.remove('token.pickle')
+                        creds = None
+            except Exception:
+                os.remove('token.pickle')
+                creds = None
+
+        if not creds:
+            if not os.path.exists('credentials.json'):
+                raise FileNotFoundError(
+                    "credentials.json file not found. Please download it from Google Cloud Console."
+                )
+            
+            flow = InstalledAppFlow.from_client_secrets_file('credentials.json', SCOPES)
+            creds = flow.run_local_server(port=0)
+            
+            with open('token.pickle', 'wb') as token:
+                pickle.dump(creds, token)
+
+        return build('calendar', 'v3', credentials=creds)
+
+    except Exception as e:
+        raise Exception(f"Authentication failed: {str(e)}")
+
+def create_event(service, event_name, start_time, end_time, time_zone='Asia/Kolkata'):
+    """Create an event in Google Calendar."""
+    try:
+        event = {
+            'summary': event_name,
+            'start': {
+                'dateTime': start_time.isoformat(),
+                'timeZone': time_zone,
+            },
+            'end': {
+                'dateTime': end_time.isoformat(),
+                'timeZone': time_zone,
+            },
+        }
+
+        created_event = service.events().insert(calendarId='primary', body=event).execute()
+        return f'Event "{event_name}" created successfully!'
+    except Exception as e:
+        error_msg = f"Failed to create event: {str(e)}"
+        if "invalid_grant" in str(e):
+            if os.path.exists('token.pickle'):
+                os.remove('token.pickle')
+            error_msg += "\nPlease restart the application to re-authenticate."
+        raise Exception(error_msg)
+
+def parse_date_time(date_str, time_str):
+    """Parse date and time strings."""
+    try:
+        date_parts = date_str.split('-')
+        if len(date_parts) != 3:
+            raise ValueError("Date must be in DD-MM-YYYY format")
+        
+        day, month, year = map(int, date_parts)
+        
+        try:
+            time_obj = datetime.strptime(time_str.strip().upper(), '%I:%M %p')
+        except ValueError:
+            raise ValueError("Time must be in HH:MM AM/PM format")
+
+        start_time = datetime(year, month, day,
+                            time_obj.hour, time_obj.minute)
+        
+        return start_time
+    except ValueError as e:
+        raise ValueError(str(e))
+
+def get_conversation_stage(history):
+    """Determine the current stage of the conversation."""
+    user_messages = [msg for role, msg in history if role == "User"]
+    if not user_messages:
+        return 0
+    return len(user_messages)
+
+def conversational_flow(history, user_input):
+    """Handle the conversation flow with improved input processing."""
+    if not user_input:
+        return history
+
+    # Check for restart command at any point
+    if user_input.lower() in ['restart', 'start over', 'reset']:
+        history.clear()
+        history.append(("Bot", "Conversation restarted. Hi! How may I assist you?"))
+        return history
+
+    # Add user input to history
+    history.append(("User", user_input))
+    stage = get_conversation_stage(history)
+
+    # Process based on conversation stage
+    if stage == 1:  # After first input (Book an appointment)
+        if "appointment" in user_input.lower() or "book" in user_input.lower():
+            history.append(("Bot", "What is the purpose of the appointment?"))
+        else:
+            history.pop()  # Remove invalid input
+            history.append(("Bot", "I can help you book an appointment. Please say 'Book an appointment' to start."))
+    
+    elif stage == 2:  # After purpose
+        event_name = user_input
+        history.append(("Bot", f"Great! You want to create an event for '{event_name}'. What is the date? (DD-MM-YYYY)"))
+    
+    elif stage == 3:  # After date
+        date_str = user_input
+        try:
+            # Validate date format
+            date_parts = date_str.split('-')
+            if len(date_parts) != 3 or not all(part.isdigit() for part in date_parts):
+                raise ValueError("Date must be in DD-MM-YYYY format")
+            history.append(("Bot", "What is the start time? (HH:MM AM/PM)"))
+        except ValueError as e:
+            history.pop()  # Remove invalid date
+            history.append(("Bot", f"Invalid date format: {str(e)}. Please enter the date in DD-MM-YYYY format."))
+    
+    elif stage == 4:  # After start time
+        start_time_str = user_input
+        try:
+            datetime.strptime(start_time_str.strip().upper(), '%I:%M %p')
+            history.append(("Bot", "What is the end time? (HH:MM AM/PM)"))
+        except ValueError:
+            history.pop()
+            history.append(("Bot", "Invalid time format. Please enter the time in HH:MM AM/PM format (e.g., 02:30 PM)."))
+    
+    elif stage == 5:  # After end time
+        end_time_str = user_input
+        try:
+            # Extract event details from history
+            event_name = [msg for role, msg in history if role == "User"][1]
+            date_str = [msg for role, msg in history if role == "User"][2]
+            start_time_str = [msg for role, msg in history if role == "User"][3]
+            
+            # Parse start and end times
+            start_time = parse_date_time(date_str, start_time_str)
+            end_time = parse_date_time(date_str, end_time_str)
+            
+            # Validate end time is after start time
+            if end_time <= start_time:
+                raise ValueError("End time must be after start time")
+
+            # Create event
+            try:
+                service = authenticate_google()
+                result = create_event(service, event_name, start_time, end_time)
+                history.append(("Bot", result))
+                history.append(("Bot", "Do you need to book any other appointments? (yes/no)"))
+            except Exception as e:
+                history.append(("Bot", f"Error: {str(e)}"))
+        except ValueError as e:
+            history.pop()
+            history.append(("Bot", f"Invalid time: {str(e)}. Please enter a valid end time in HH:MM AM/PM format."))
+    
+    elif stage == 6:  # After yes/no
+        if user_input.lower() == "yes":
+            history.clear()
+            history.append(("Bot", "Hi! How may I assist you?"))
+        elif user_input.lower() == "no":
+            history.append(("Bot", "Thank you! Have a nice day."))
+        else:
+            history.pop()
+            history.append(("Bot", "Please answer with 'yes' or 'no'."))
+
+    return history
+
+def display_chat(history):
+    """Display chat messages."""
+    chat_display = []
+    for role, message in history:
+        if role == "User":
+            chat_display.append([message, None])
+        else:
+            chat_display.append([None, message])
+    return chat_display
+
+# Create Gradio interface
+with gr.Blocks() as iface:
+    gr.Markdown("""
+    <h1>Google Calendar Appointment Bot</h1>
+    <p>Type 'restart' at any time to start over.</p>
+    """)
+    chatbot = gr.Chatbot()
+    user_input = gr.Textbox(placeholder="Type your response here...")
+    send_button = gr.Button("Send")
+    restart_button = gr.Button("Restart Conversation")
+
+    def reset_conversation():
+        history = [("Bot", "Hi! How may I assist you?")]
+        return display_chat(history), history
+
+    def handle_input(user_input, history):
+        if not user_input.strip():
+            return display_chat(history), history, ""
+        history = conversational_flow(history, user_input)
+        return display_chat(history), history, ""
+
+    history_state = gr.State([])
+    send_button.click(handle_input, inputs=[user_input, history_state], outputs=[chatbot, history_state, user_input])
+    user_input.submit(handle_input, inputs=[user_input, history_state], outputs=[chatbot, history_state, user_input])
+    restart_button.click(reset_conversation, outputs=[chatbot, history_state])
+    iface.load(reset_conversation, outputs=[chatbot, history_state])
+
+if __name__ == "__main__":
+    iface.launch()