Update app.py

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 import networkx as nx
 import random
 import logging
+import ast
 
 # Configure logging
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -22,16 +23,38 @@ def triplextract(text: str, entity_types: list[str], predicates: list[str]) -> s
         A string representation of the extracted triples, or an error message if extraction fails.
     """
     logging.debug(f"triplextract called with text: {text}, entity_types: {entity_types}, predicates: {predicates}")
+    print(f"triplextract input:\ntext: {text}\nentity_types: {entity_types}\npredicates: {predicates}")
     try:
         #  Replace this with your actual NLP pipeline logic
         #  This is a placeholder for demonstration purposes
         #  Example: "Alice knows Bob" -> ("Alice", "knows", "Bob")
-        if "Alice knows Bob" in text:
-            return "[('Alice', 'knows', 'Bob')]"  # Example triple
-        elif "The cat sat on the mat" in text:
-            return "[('cat', 'sat on', 'mat')]"
+
+        # TEMPORARY - Hardcoded triple for testing
+        # if "Global warming" in text:
+        #     prediction = "[('Global warming', 'causes', 'climate changes')]" #hardcoded string
+        #     print(f"triplextract output: {prediction}")
+        #     return prediction
+        # else:
+        #     prediction = "[]"
+        #     print(f"triplextract output: {prediction}")
+        #     return "[]"
+
+        if "Global warming" in text:
+            triples = [
+                ('Global warming', 'causes', 'climate changes'),
+                ('temperature', 'increased by', '1C'),
+                ('warming', 'caused by', 'human activities'),
+                ('Paris Agreement', 'aims to limit', 'temperature increase')
+            ]
+            prediction = str(triples)
+            print(f"triplextract output: {prediction}")
+            return prediction
         else:
-            return "[]"  # No triples found (important to return an empty list as a string)
+            prediction = "[]"
+            print(f"triplextract output: {prediction}")
+            return "[]"
+
+        # ... (Remove this hardcoding once the rest works)
     except Exception as e:
         error_message = f"Error in triplextract: {str(e)}"
         logging.exception(error_message)  # Log the full exception with traceback
@@ -50,26 +73,40 @@ def parse_triples(triples_str: str) -> tuple[list[str], list[tuple[str, str, str
             - A list of relationships (tuples of (subject, predicate, object)).
     """
     logging.debug(f"parse_triples called with triples_str: {triples_str}")
+    print(f"parse_triples input: {triples_str}")
     try:
         #  Replace this with your actual parsing logic based on triplextract's output
         #  This is a placeholder for demonstration purposes
-        import ast
-        triples_list = ast.literal_eval(triples_str)  # Safely evaluate the string as a list
+        # Properly handle error cases where ast.literal_eval fails
+
+        try:
+            triples_list = ast.literal_eval(triples_str)  # Safely evaluate the string as a list
+        except (SyntaxError, ValueError) as e:
+            error_message = f"Error in parse_triples: Invalid triples string format: {str(e)}"
+            logging.error(error_message)
+            return [], [] # Return empty lists to prevent further errors
+        except Exception as e:
+            error_message = f"Unexpected error in parse_triples during literal_eval: {str(e)}"
+            logging.exception(error_message)
+            return [], []
+
 
         entities = set()
         relationships = []
-        for triple in triples_list:
-            subject, predicate, object_ = triple  # Unpack the triple
-            entities.add(subject)
-            entities.add(object_)
-            relationships.append((subject, predicate, object_))
+        if isinstance(triples_list, list):
+            for triple in triples_list:
+                if isinstance(triple, tuple) and len(triple) == 3:
+                    subject, predicate, object_ = triple  # Unpack the triple
+                    entities.add(subject)
+                    entities.add(object_)
+                    relationships.append((subject, predicate, object_))
+                else:
+                     logging.warning(f"Invalid triple format: {triple}.  Skipping.")
+        else:
+            logging.warning(f"Triples list is not a list, but {type(triples_list)}. Returning empty lists.")
+            return [], []
 
         return list(entities), relationships
-    except (SyntaxError, ValueError) as e:
-        error_message = f"Error in parse_triples: Invalid triples string format: {str(e)}"
-        logging.error(error_message)
-        return [], []  # Return empty lists to prevent further errors
-
     except Exception as e:
         error_message = f"Error in parse_triples: {str(e)}"
         logging.exception(error_message)
@@ -269,6 +306,16 @@ snippets = {
         text_input="The cat sat on the mat.",
         entity_types="Animal, Object",
         predicates="sat on"
+    ),
+    "Sample 3": Sample(
+        text_input="Global warming is causing significant changes to Earth's climate. The average global \
+        temperature has increased by approximately 1C since the pre-industrial era. This warming is \
+        primarily caused by human activities, particularly the emission of greenhouse gases like carbon dioxide. \
+        The Paris Agreement, signed in 2015, aims to limit global temperature increase to well below 2°C above \
+        pre-industrial levels. To achieve this goal, many countries are implementing policies to reduce carbon \
+        emissions and transition to renewable energy sources.",
+        entity_types="Event, Measure, Activity, Agreement",
+        predicates="causes, increased by, aims to limit"
     )
 }
 
@@ -277,6 +324,7 @@ snippets = {
 WORD_LIMIT = 300
 
 def process_text(text: str, entity_types: str, predicates: str, layout_type: str, visualization_type: str):
+    print(f"process_text input:\ntext: {text}\nentity_types: {entity_types}\npredicates: {predicates}")
     if not text:
         return None, None, "Please enter some text."