Update app.py

app.py

@@ -1,124 +1,175 @@
-import os
-import re
-from datetime import datetime, timedelta
-import openai
 import gradio as gr
-from ics import Calendar, Event
-
-# Set your OpenAI API key
-openai.api_key = ("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")
-
-# Define a custom calendar class
-class CustomCalendar:
-    def __init__(self, file_path):
-        self.file_path = file_path
-        self.calendar = Calendar()
-
-    def create_event(self, title, start_time, end_time):
-        event = Event()
-        event.name = title
-        event.begin = start_time
-        event.end = end_time
-        self.calendar.events.add(event)
-        self.save_to_file()
-
-    def update_event(self, old_title, new_start_time, new_end_time):
-        for event in self.calendar.events:
-            if event.name == old_title:
-                event.begin = new_start_time
-                event.end = new_end_time
-                self.save_to_file()
-                break
-
-    def get_events(self):
-        return list(self.calendar.events)
-
-    def save_to_file(self):
-        with open(self.file_path, "w") as file:
-            file.writelines(self.calendar)
-
-# Helper function to extract event details from the chatbot's response
-def extract_event_details(response):
-    time_pattern = r"(\d{1,2})\s*([ap]m)"
-    title_pattern = r"(for|about)\s+(.+)"
-
-    time_match = re.search(time_pattern, response, re.IGNORECASE)
-    title_match = re.search(title_pattern, response, re.IGNORECASE)
-
-    if time_match:
-        hour = int(time_match.group(1))
-        meridiem = time_match.group(2).lower()
-        if meridiem == "pm" and hour < 12:
-            hour += 12
-        elif meridiem == "am" and hour == 12:
-            hour = 0
-
-    if title_match:
-        title = title_match.group(2)
-
-    if time_match and title_match:
-        start_time = datetime.now().replace(hour=hour, minute=0, second=0, microsecond=0)
-        end_time = start_time + timedelta(hours=1)
-        return title, start_time, end_time
-
-    return None, None, None
-
-# Function to handle user messages
-def handle_message(texts):
-    global calendar
-    responses = []
-
-    for text in texts:
-        response = openai.ChatCompletion.create(
-            model="gpt-3.5-turbo",
-            messages=[{"role": "user", "content": text}],
-            temperature=0.7,
-        )
-        response_text = response.choices[0].message.content
-
-        # Check for event creation or adjustment
-        title, start_time, end_time = extract_event_details(response_text)
-        if title and start_time and end_time:
-            if "create" in text or "set" in text or "make" in text:
-                calendar.create_event(title, start_time, end_time)
-                responses.append(f"Appointment created: {title} at {start_time.strftime('%I:%M %p')}")
-            elif "change" in text or "adjust" in text or "modify" in text:
-                old_title = None
-                for event in calendar.get_events():
-                    if event.name.lower() in response_text.lower():
-                        old_title = event.name
-                        break
-                if old_title:
-                    calendar.update_event(old_title, start_time, end_time)
-                    responses.append(f"Appointment updated: {old_title} to {start_time.strftime('%I:%M %p')}")
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+import torch
+import datetime
+import re
+import os
+import pytz
+import dateutil.parser
+
+# Load the DistilBERT model and tokenizer
+model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
+tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
+
+# Initialize an empty list to store events
+events = []
+
+# Load events from file if it exists
+if os.path.isfile("events.txt"):
+    with open("events.txt", "r") as f:
+        for line in f:
+            event_data = line.strip().split("|")
+            if len(event_data) == 4:
+                name, start_str, end_str, recurring = event_data
+                start = dateutil.parser.parse(start_str)
+                end = dateutil.parser.parse(end_str)
+                is_recurring = (recurring.lower() == "true")
+                events.append({"name": name, "start": start, "end": end, "recurring": is_recurring})
+                print(f"Loaded event: {name} ({start} - {end})")
+
+def generate_response(prompt):
+    """
+    Generate a response using the DistilBERT model.
+    """
+    inputs = tokenizer(prompt, return_tensors="pt")
+    output = model(**inputs)[0]  # get the logits
+    return tokenizer.decode(torch.argmax(output, dim=-1)[0], skip_special_tokens=True)
+
+def list_events(start, end):
+    """
+    List events for the day between start and end times.
+    """
+    event_summaries = []
+    for event in events:
+        event_start = event["start"]
+        event_end = event["end"]
+        if event_start.tzinfo is None:
+            event_start = pytz.utc.localize(event_start)
+        if event_end.tzinfo is None:
+            event_end = pytz.utc.localize(event_end)
+        if start <= event_start < end:
+            event_summaries.append(f"{event['name']} ({event_start.strftime('%I:%M %p')} - {event_end.strftime('%I:%M %p')})")
+    if not event_summaries:
+        return "There are no events presently."
+    return ", ".join(event_summaries)
+
+def create_event(summary, start, end, recurring=False):
+    """
+    Create a new event.
+    """
+    event = {"name": summary, "start": start, "end": end, "recurring": recurring}
+    events.append(event)
+    save_events()
+    return f"Event '{summary}' has been scheduled from {start.strftime('%I:%M %p')} to {end.strftime('%I:%M %p')}."
+
+def save_events():
+    """
+    Save events to a text file.
+    """
+    with open("events.txt", "w") as f:
+        for event in events:
+            start_str = event["start"].strftime("%Y-%m-%d %H:%M:%S")
+            end_str = event["end"].strftime("%Y-%m-%d %H:%M:%S")
+            recurring_str = "True" if event["recurring"] else "False"
+            f.write(f"{event['name']}|{start_str}|{end_str}|{recurring_str}\n")
+
+def process_input(user_input):
+    """
+    Process the user input and perform the corresponding action.
+    """
+    if any(keyword in user_input.lower() for keyword in ["schedule", "create"]):
+        summary, start, end, recurring = extract_event_details(user_input)
+        if summary and start and end:
+            response = create_event(summary, start, end, recurring)
+            return response
+        else:
+            return "I'm sorry, I couldn't understand the event details. Please try again."
+
+    elif any(keyword in user_input.lower() for keyword in ["list", "show"]):
+        start = datetime.datetime.now(pytz.utc).replace(hour=0, minute=0, second=0, microsecond=0, tzinfo=pytz.utc)
+        end = start + datetime.timedelta(days=1, seconds=-1, microseconds=-1)
+        existing_events = list_events(start, end)
+        return existing_events
+
+    else:
+        return "I'm sorry, I didn't understand your request. Please try again."
+
+def extract_event_details(user_input):
+    """
+    Extract the event summary, start time, end time, and recurrence from the user input.
+    """
+    patterns = [
+        r"(schedule|create)(.*?)from\s*(\d+:\d+\s*[aApP][mM])\s*to\s*(\d+:\d+\s*[aApP][mM])\s*tomorrow",
+        r"(schedule|create)(.*?)from\s*(\d+:\d+\s*[aApP][mM])\s*to\s*(\d+:\d+\s*[aApP][mM])\s*on\s*(\w+)",
+        r"(schedule|create)(.*?)from\s*(\d+:\d+\s*[aApP][mM])\s*to\s*(\d+:\d+\s*[aApP][mM])\s*every\s*(\w+)",
+        r"(schedule|create)(.*?)from\s*(\d+:\d+\s*[aApP][mM])\s*to\s*(\d+:\d+\s*[aApP][mM])\s*on\s*the\s*(\w+)\s*of\s*every\s*(\w+)",
+        r"(schedule|create)(.*?)from\s*(\d+:\d+\s*[aApP][mM])\s*to\s*(\d+:\d+\s*[aApP][mM])\s*on\s*the\s*(last|first|second|third|fourth)\s*(\w+)\s*of\s*every\s*(\w+)",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, user_input, re.IGNORECASE)
+        if match:
+            summary = match.group(2).strip()
+            start_str = match.group(3).strip()
+            end_str = match.group(4).strip()
+            if match.group(5) is None:
+                tomorrow = datetime.date.today() + datetime.timedelta(days=1)
+                start = datetime.datetime.combine(tomorrow, datetime.datetime.strptime(start_str, "%I:%M %p").time())
+                end = datetime.datetime.combine(tomorrow, datetime.datetime.strptime(end_str, "%I:%M %p").time())
+                recurring = False
+            elif match.group(6):
+                day_of_week = match.group(6).lower()
+                start = datetime.datetime.combine(datetime.date.today(), datetime.datetime.strptime(start_str, "%I:%M %p").time())
+                while start.strftime("%A").lower() != day_of_week:
+                    start += datetime.timedelta(days=1)
+                end = start + datetime.timedelta(hours=int(end_str.split(":")[0]) - int(start_str.split(":")[0]), minutes=int(end_str.split(":")[1]) - int(start_str.split(":")[1]))
+                recurring = (match.group(7) == "every")
+            elif match.group(8):
+                ordinal = match.group(8).lower()
+                weekday = match.group(9).lower()
+                month = match.group(10).lower()
+                start = datetime.datetime.combine(datetime.date.today(), datetime.datetime.strptime(start_str, "%I:%M %p").time())
+                next_month = start.replace(day=1) + datetime.timedelta(days=32)
+                while start.strftime("%B").lower() != month:
+                    start = next_month
+                    next_month = start.replace(day=1) + datetime.timedelta(days=32)
+                while start.strftime("%A").lower() != weekday:
+                    start += datetime.timedelta(days=1)
+                if ordinal == "last":
+                    while start.replace(day=1) + datetime.timedelta(days=32) > start.replace(month=start.month + 1, day=1):
+                        start -= datetime.timedelta(days=7)
                 else:
-                    responses.append("Sorry, I couldn't find the appointment you wanted to adjust.")
-        elif "show" in response_text or "list" in response_text or "view" in response_text:
-            events = calendar.get_events()
-            if events:
-                event_list = "\n".join([f"{event.name}: {event.begin.strftime('%I:%M %p')} - {event.end.strftime('%I:%M %p')}" for event in events])
-                responses.append(f"Your appointments:\n{event_list}")
-            else:
-                responses.append("You don't have any appointments scheduled.")
+                    count = 1
+                    while count < int(ordinal):
+                        start += datetime.timedelta(days=7)
+                        if start.strftime("%B").lower() != month:
+                            break
+                        count += 1
+                end = start + datetime.timedelta(hours=int(end_str.split(":")[0]) - int(start_str.split(":")[0]), minutes=int(end_str.split(":")[1]) - int(start_str.split(":")[1]))
+                recurring = (match.group(11) == "every")
+            start = pytz.utc.localize(start)
+            end = pytz.utc.localize(end)
+            return summary, start, end, recurring
+
+    # If the input doesn't match any pattern, try to parse it using dateutil
+    try:
+        date_strings = dateutil.parser.parse(user_input, fuzzy=True)
+        if isinstance(date_strings, list):
+            start, end = date_strings
         else:
-            responses.append(response_text)
-
-    return responses
-
-# Define calendar file path
-calendar_file_path = "calendar.ics"
-
-# Create a custom calendar instance
-calendar = CustomCalendar(calendar_file_path)
-
-# Define Gradio interface
-iface = gr.Interface(
-    fn=handle_message,
-    inputs=gr.Textbox(lines=3, label="Enter your messages (one per line)"),
-    outputs="text",
-    title="Calendar Chatbot",
-    description="Interact with the chatbot to manage your calendar events.",
-)
-
-# Run the Gradio interface
-iface.launch(debug=True, share=True)
+            start = end = date_strings
+        summary = "Event"
+        start = pytz.utc.localize(start)
+        end = pytz.utc.localize(end)
+        return summary, start, end, False
+    except (ValueError, OverflowError):
+        pass
+
+    return None, None, None, False
+
+# Gradio interface
+def chat(user_input):
+    response = process_input(user_input)
+    return response
+
+iface = gr.Interface(chat, inputs="text", outputs="text", title="AI Scheduling Assistant")
+iface.launch()