Update app.py

app.py

@@ -129,36 +129,39 @@ class EventAnalyzer:
                 
         return entities
 
-    async def extract_temporal(self, text):
+    def extract_temporal(self, text):
         return self.ontology.validate_pattern(text, 'temporal')
 
     async def extract_locations(self, text):
-        ml_locations = [loc for loc in await self.extract_entities(text).get('locations', [])]
+        # First await the entities result
+        entities = await self.extract_entities(text)
+        ml_locations = entities.get('locations', [])
+        # Get pattern-based locations
         pattern_locations = self.ontology.validate_pattern(text, 'location')
         return list(set(ml_locations + pattern_locations))
 
     async def analyze_event(self, text):
         try:
             # Parallel extraction
-            entities_task = self.extract_entities(text)
-            temporal_task = self.extract_temporal(text)
-            locations_task = self.extract_locations(text)
+            entities_future = self.extract_entities(text)
+            temporal_data = self.extract_temporal(text)  # This is synchronous now
+            locations_future = self.extract_locations(text)
             
-            # Gather results
-            entities, temporal, locations = await asyncio.gather(
-                entities_task, temporal_task, locations_task
+            # Gather async results
+            entities, locations = await asyncio.gather(
+                entities_future, locations_future
             )
             
-            # Merge location results
+            # Add temporal and locations to entities
             entities['locations'] = locations
-            entities['temporal'] = temporal
+            entities['temporal'] = temporal_data
             
             # Calculate initial confidence
             confidence = min(1.0, (
                 0.2 * bool(entities["people"]) +
                 0.2 * bool(entities["organizations"]) +
                 0.3 * bool(entities["locations"]) +
-                0.3 * bool(temporal)
+                0.3 * bool(temporal_data)
             ))
             
             # Find related events
@@ -172,7 +175,7 @@ class EventAnalyzer:
                 relationship_confidence = max(
                     self.relationship_engine.calculate_relationship_confidence(
                         {'entities': entities}, 
-                        {'text': event[1]} # event[1] is the text field
+                        {'text': event[1]}
                     )
                     for event in related_events
                 )
@@ -285,6 +288,7 @@ def format_results(analysis_result):
     """
     return html
 
+# Modified to properly handle async
 async def process_input(text):
     result = await analyzer.analyze_event(text)
     return format_results(result)
@@ -299,7 +303,7 @@ demo = gr.Interface(
         )
     ],
     outputs=gr.HTML(),
-    title="DoD Event Analysis System",
+    title="ToY Event Analysis System",
     description="Analyze text to extract entities, assess confidence, and identify key event information with relationship tracking.",
     css=css,
     theme=gr.themes.Soft(),