Update app.py

app.py

@@ -3,47 +3,42 @@ import requests
 import spacy
 import re
 import time
-from IPython.display import display, HTML
+import os  # Import the 'os' module
+import base64  # Import base64
+
+# Try to load the spaCy model, download if it's not available
+try:
+    nlp = spacy.load("en_core_web_sm")
+except OSError:
+    print("Downloading en_core_web_sm model...")
+    import spacy.cli
+    spacy.cli.download("en_core_web_sm")
+    nlp = spacy.load("en_core_web_sm")
 
-# Load the English NLP model
-nlp = spacy.load("en_core_web_sm")
 
-# Function to parse the input and generate a Mermaid.js diagram
 def text_to_diagram(text_description):
-    """
-    Convert any process description into a Mermaid.js flowchart by parsing steps, conditions, loops, and flows.
-    """
-    # Process the text with spaCy
+    """Convert process description into Mermaid.js flowchart."""
     doc = nlp(text_description.lower())
-
-    # Initialize variables to store diagram components
-    steps = []  # List of sequential steps
-    conditions = []  # List of (condition, true_action, false_action)
-    loops = []  # List of (action, condition)
-    complex_flow = []  # List of steps in the complex flow
-
-    # Split the text into sentences for easier parsing
+    steps = []
+    conditions = []
+    loops = []
+    complex_flow = []
     sentences = [sent.text.strip() for sent in doc.sents]
 
-    # Parse each sentence to identify components
     for sentence in sentences:
-        # Clean up the sentence
         sentence = sentence.replace("2, conditional branch", "").replace("3 loop start", "").replace("4 complex flow", "").strip()
 
-        # Detect sequential steps (e.g., "Developer writes code, then tests code")
         if "then" in sentence:
             tokens = sentence.split("then")
             for token in tokens:
                 token = token.strip()
                 if token:
-                    # Extract the full action (e.g., "developer writes code" instead of just "code")
                     step = token.strip().replace(",", "").replace(".", "")
                     if step and step not in ["conditional branch", "loop start", "complex flow"]:
                         if "flowchart that shows" in step:
                             continue
                         steps.append(step)
 
-        # Detect conditional branches (e.g., "If tests pass, proceed to deploy; otherwise, debug code")
         cond_match = re.search(r"if ([a-z\s]+), (?:go to|proceed to) ([a-z\s]+); otherwise, (?:go to|proceed to) ([a-z\s]+)", sentence)
         if not cond_match:
             cond_match = re.search(r"if ([a-z\s]+), ([a-z\s]+); otherwise, ([a-z\s]+)", sentence)
@@ -51,7 +46,6 @@ def text_to_diagram(text_description):
             condition, true_action, false_action = cond_match.groups()
             conditions.append((condition.strip(), true_action.strip(), false_action.strip()))
 
-        # Detect loops (e.g., "Loop: Perform action X, repeat X until Y is true")
         loop_match = re.search(r"(?:do|perform) (?:action )?([a-z]), repeat ([a-z]) until ([a-z]) is true", sentence)
         if not loop_match:
             loop_match = re.search(r"loop: ([a-z\s]+), repeat ([a-z\s]+) until ([a-z\s]+)", sentence)
@@ -59,7 +53,6 @@ def text_to_diagram(text_description):
             action, repeat_action, condition = loop_match.groups()
             loops.append((action.strip(), condition.strip()))
 
-        # Detect complex flow (e.g., "A flowchart that shows a customer replacing an order, then fulfilled, then ship, then delivered")
         if "flowchart that shows" in sentence:
             flow_part = sentence.split("flowchart that shows")[1]
             flow_steps = flow_part.split("then")
@@ -67,7 +60,7 @@ def text_to_diagram(text_description):
                 step = step.replace("and finally", "").replace(".", "").replace(",", "").strip()
                 if step:
                     complex_flow.append(step)
-        elif "then" in sentence and not steps:  # If no "flowchart that shows", treat remaining "then" as complex flow
+        elif "then" in sentence and not steps:
             tokens = sentence.split("then")
             for token in tokens:
                 token = token.strip()
@@ -76,39 +69,33 @@ def text_to_diagram(text_description):
                     if step:
                         complex_flow.append(step)
 
-    # Combine steps and complex flow if necessary
     if not complex_flow:
         complex_flow = steps[1:] if steps else []
         steps = steps[:1] if steps else []
 
-    # Build the Mermaid.js diagram
     diagram_code = "graph TD\n"
     node_counter = 0
-    node_map = {}  # Map labels to node IDs (e.g., "developer writes code" -> "A")
+    node_map = {}
 
-    # Helper function to get or create a node ID
     def get_node_id(label):
         nonlocal node_counter
         if label not in node_map:
-            node_map[label] = chr(65 + node_counter)  # A, B, C, ...
+            node_map[label] = chr(65 + node_counter)
             node_counter += 1
         return node_map[label]
 
-    # Add initial steps
     if steps:
         for i in range(len(steps)):
             step = steps[i]
             node_id = get_node_id(step)
             diagram_code += f"{node_id}[{step.capitalize()}]\n"
             if i > 0:
-                prev_node_id = get_node_id(steps[i-1])
+                prev_node_id = get_node_id(steps[i - 1])
                 diagram_code += f"{prev_node_id} --> {node_id}\n"
     else:
-        # Default start node if no initial steps
         start_node = get_node_id("start")
         diagram_code += f"{start_node}[Start]\n"
 
-    # Add conditional branches
     last_node = steps[-1] if steps else "start"
     last_node_id = get_node_id(last_node)
     for condition, true_action, false_action in conditions:
@@ -118,11 +105,10 @@ def text_to_diagram(text_description):
         diagram_code += f"{last_node_id} --> {cond_node}{{{condition.capitalize()}?}}\n"
         diagram_code += f"{cond_node} -->|Yes| {true_node}[{true_action.capitalize()}]\n"
         diagram_code += f"{cond_node} -->|No| {false_node}[{false_action.capitalize()}]\n"
-        last_node = true_action  # Continue from the "true" path
+        last_node = true_action
         last_node_id = true_node
-        false_node_id = false_node  # Store the "false" path for later
+        false_node_id = false_node
 
-    # Add loops
     for action, condition in loops:
         loop_node = get_node_id(f"loop_{action}")
         cond_node = get_node_id(f"cond_{condition}")
@@ -133,7 +119,6 @@ def text_to_diagram(text_description):
         diagram_code += f"{cond_node} -->|Yes| {finish_node}[Finish Loop]\n"
         last_node_id = finish_node
 
-    # Add complex flow
     for i in range(len(complex_flow)):
         step = complex_flow[i]
         node_id = get_node_id(f"flow_{i}_{step}")
@@ -141,58 +126,43 @@ def text_to_diagram(text_description):
         if i == 0:
             diagram_code += f"{last_node_id} --> {node_id}\n"
         else:
-            prev_node_id = get_node_id(f"flow_{i-1}_{complex_flow[i-1]}")
+            prev_node_id = get_node_id(f"flow_{i - 1}_{complex_flow[i - 1]}")
             diagram_code += f"{prev_node_id} --> {node_id}\n"
         last_node_id = node_id
 
-    # Add end node
     end_node = get_node_id("end")
     diagram_code += f"{end_node}[End Process]\n"
     diagram_code += f"{last_node_id} --> {end_node}\n"
 
-    # Connect the "false" path of conditions to the end
     if conditions:
         diagram_code += f"{false_node_id} --> {end_node}\n"
 
-    # Render diagram to image using Mermaid.ink API
     try:
         img_url = render_mermaid_to_url(diagram_code)
         response = requests.get(img_url, timeout=10)
-        if response.status_code == 200:
-            image_data = response.content
-            temp_img_path = f"temp_diagram_{int(time.time())}.png"
-            with open(temp_img_path, "wb") as f:
-                f.write(image_data)
-            return diagram_code, temp_img_path
-        else:
-            return diagram_code, None
+        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
+        image_data = response.content
+        temp_img_path = f"temp_diagram_{int(time.time())}.png"
+        with open(temp_img_path, "wb") as f:
+            f.write(image_data)
+        return diagram_code, temp_img_path
+    except requests.exceptions.RequestException as e:
+        print(f"Error rendering diagram (network): {e}")
+        return diagram_code, None
     except Exception as e:
         print(f"Error rendering diagram: {e}")
         return diagram_code, None
 
+
 def render_mermaid_to_url(mermaid_code):
     """Render Mermaid code to an image URL using Mermaid.ink."""
     try:
-        import base64
         encoded_code = base64.urlsafe_b64encode(mermaid_code.encode()).decode()
         return f"https://mermaid.ink/img/{encoded_code}"
     except Exception as e:
         print(f"Error encoding Mermaid code: {e}")
         return None
 
-# Direct rendering for Jupyter/Colab (optional)
-def render_mermaid_in_notebook(mermaid_code):
-    """Render Mermaid diagram in a notebook environment."""
-    html = f"""
-    <div class="mermaid">
-    {mermaid_code}
-    </div>
-    <script src="https://cdn.jsdelivr.net/npm/mermaid@9/dist/mermaid.min.js"></script>
-    <script>mermaid.initialize({{startOnLoad:true}});</script>
-    """
-    return HTML(html)
-
-# Gradio Interface
 def gradio_interface(text_input):
     """Process user input and return diagram output for Gradio."""
     try:
@@ -204,16 +174,15 @@ def gradio_interface(text_input):
         print(f"Error in Gradio interface: {e}")
         return f"Error: {str(e)}", None
 
-# Create Gradio interface
 iface = gr.Interface(
     fn=gradio_interface,
     inputs=gr.Textbox(lines=5, placeholder="Describe your process (e.g., 'User logs in, then enters details...')"),
     outputs=[
         gr.Textbox(label="Generated Mermaid Code"),
-        gr.Image(label="Diagram Visualization", type="filepath")
+        gr.Image(label="Diagram Visualization", type="filepath"),
     ],
     title="Text-to-Diagram Converter (Napkin AI Style)",
-    description="Convert any process description into a structured flowchart like Napkin AI.",
+    description="Convert process descriptions into structured flowcharts like Napkin AI.",
     examples=[
         ["Developer writes code, then tests code. If tests pass, proceed to deploy; otherwise, debug code. Then release software to production."],
         ["Customer browses products, then adds to cart, then proceeds to checkout. If payment is verified, confirm order; otherwise, request payment again. Loop: Validate payment, repeat until successful. Then ship order and notify customer."],
@@ -221,11 +190,10 @@ iface = gr.Interface(
         ["Student registers for exam, then studies material. If prepared, proceed to take exam; otherwise, study more. If exam is passed, receive certificate; otherwise, retake exam. Then celebrate success."],
         ["Customer places order, then kitchen prepares food. Loop: Check food quality, repeat until perfect. Then serve food and collect payment."],
         ["Traveler searches for flights, then selects flight, then books ticket. If booking is confirmed, proceed to payment; otherwise, search again. If payment is successful, receive itinerary; otherwise, cancel booking. Then plan trip."],
-        ["User signs up, then verifies email, then logs in."]
+        ["User signs up, then verifies email, then logs in."],
     ],
-    allow_flagging="never"
+    allow_flagging="never",
 )
 
-# Launch the interface
 if __name__ == "__main__":
     iface.launch(share=True)