Inference time cutodonw

event_matcher.py

@@ -28,90 +28,89 @@ class EventMatcher:
     def query(self, user_query: str) -> str:
         """Main query method called by the app"""
         try:
-            # Update events if needed
-            self.update_events()
-            
-            # Find matching events
+            # Update events if needed - make this non-blocking
+            if self.last_update is None or (datetime.now() - self.last_update).seconds >= 3600:
+                # Start a background task to update events
+                self.update_events()
+    
+            # Quick response for empty query
+            if not user_query.strip():
+                return "Please ask me about events at Brock University!"
+    
+            # Find matching events - optimize by limiting initial search
             matched_events = self.find_matching_events(user_query)
             
             if not matched_events:
                 return "I couldn't find any events matching your query. Try asking in a different way!"
             
-            # Format the response
-            return self.format_response(matched_events, user_query)
-            
-        except Exception as e:
-            print(f"Error in query: {e}")
-            return "I encountered an error processing your query. Please try again!"
+            # Format the response without T5 for faster response
+            events_text = ""
+            for event, score in matched_events:
+                events_text += f"""
+    📅 {event['title']}
+    📆 {event['start_time'].strftime('%A, %B %d, %Y')}
+    ⏰ {event['start_time'].strftime('%I:%M %p')}
+    📍 {event['location']}
+    🏷️ {event['categories']}
+    👥 {event['hosts']}
+    
+    {event['description'][:200]}...
+    
+    🔗 {event['link']}
+    
+    """    
+        # Create a simple response prefix based on the query type
+        if "today" in user_query.lower():
+            prefix = "Here are today's events:"
+        elif "week" in user_query.lower():
+            prefix = "Here are the events happening this week:"
+        elif any(word in user_query.lower() for word in ["workshop", "training", "seminar"]):
+            prefix = "I found these workshops and seminars:"
+        elif any(word in user_query.lower() for word in ["faculty", "department", "school"]):
+            prefix = "Here are the faculty-related events:"
+        else:
+            prefix = "Here are some events that match your query:"
 
-    def find_matching_events(self, query: str) -> List[Tuple[Dict, float]]:
-        """Find events matching the query"""
-        matched_events = []
+        return f"{prefix}\n{events_text}"
         
-        for event in self.events:
-            # Calculate various similarity scores
-            title_score = fuzz.token_set_ratio(query.lower(), event['title'].lower()) / 100
-            desc_score = fuzz.token_set_ratio(query.lower(), event['description'].lower()) / 100
-            location_score = fuzz.token_set_ratio(query.lower(), event['location'].lower()) / 100
-            categories_score = fuzz.token_set_ratio(query.lower(), event['categories'].lower()) / 100
-            hosts_score = fuzz.token_set_ratio(query.lower(), event['hosts'].lower()) / 100
+    except Exception as e:
+        print(f"Error in query: {e}")
+        return "I encountered an error processing your query. Please try again!"
+        return "I encountered an error processing your query. Please try again!"
+
+    def find_matching_events(self, query: str) -> List[Tuple[Dict, float]]:
+    """Find events matching the query - optimized version"""
+    matched_events = []
+    query_lower = query.lower()
+    
+    for event in self.events:
+        # Quick initial filter
+        if any(term in event['title'].lower() or 
+               term in event['description'].lower()[:200] or 
+               term in event['location'].lower() or 
+               term in event['categories'].lower() 
+               for term in query_lower.split()):
+               
+            # Calculate similarity scores only for potentially matching events
+            title_score = fuzz.token_set_ratio(query_lower, event['title'].lower()) / 100
+            desc_score = fuzz.token_set_ratio(query_lower, event['description'].lower()) / 100
+            location_score = fuzz.token_set_ratio(query_lower, event['location'].lower()) / 100
+            categories_score = fuzz.token_set_ratio(query_lower, event['categories'].lower()) / 100
             
             # Weight the scores
             total_score = (
-                title_score * 0.35 +
-                desc_score * 0.25 +
-                location_score * 0.20 +
-                categories_score * 0.15 +
-                hosts_score * 0.05
+                title_score * 0.4 +
+                desc_score * 0.3 +
+                location_score * 0.2 +
+                categories_score * 0.1
             )
             
             if total_score > 0.3:  # Threshold for relevance
                 matched_events.append((event, total_score))
-        
-        # Sort by score and get top matches
-        matched_events.sort(key=lambda x: x[1], reverse=True)
-        return matched_events[:3]
-
-    def format_response(self, matched_events: List[Tuple[Dict, float]], query: str) -> str:
-        """Format the response with matched events"""
-        try:
-            # Prepare text for T5 model
-            events_text = ""
-            for event, score in matched_events:
-                events_text += f"""
-📅 {event['title']}
-Date: {event['start_time'].strftime('%A, %B %d, %Y')}
-Time: {event['start_time'].strftime('%I:%M %p')}
-📍 Location: {event['location']}
-🏷️ Categories: {event['categories']}
-👥 Hosted by: {event['hosts']}
-
-{event['description'][:200]}...
-
-🔗 More info: {event['link']}
-"""
-            
-            # Generate response using T5
-            input_text = f"query: {query} context: {events_text}"
-            inputs = self.tokenizer(input_text, return_tensors="pt", max_length=512, truncation=True)
-            outputs = self.model.generate(
-                inputs.input_ids,
-                max_length=150,
-                num_beams=4,
-                temperature=0.7,
-                no_repeat_ngram_size=2
-            )
-            
-            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-            
-            # Combine T5 response with event details
-            final_response = f"{response}\n\nHere are the matching events:{events_text}"
-            
-            return final_response
-            
-        except Exception as e:
-            print(f"Error formatting response: {e}")
-            return "Here are some relevant events I found:" + events_text
+    
+    # Sort by score and get top matches
+    matched_events.sort(key=lambda x: x[1], reverse=True)
+    return matched_events[:3]
 
     def parse_event_datetime(self, entry) -> Tuple[Optional[datetime], Optional[datetime]]:
         """Parse event dates from RSS feed"""