Update app.py

app.py

@@ -1,33 +1,80 @@
-from transformers import pipeline
-import gradio as gr
+import os
+import tempfile
 import networkx as nx
 import sympy as sp
-from collections import defaultdict
 import re
-from dotenv import load_dotenv
-import google.generativeai as genai
-import os
+from collections import defaultdict
+import gradio as gr
 from gradio.themes import Ocean
+from huggingface_hub import InferenceClient
+import requests
+from PIL import Image
+from io import BytesIO
 
-load_dotenv()
-API_KEY = os.getenv("GEMINI_API")
-genai.configure(api_key=API_KEY)
+# --- Set your HF token ---
+# Either hardcode here or use Colab's userdata like:
+HF_TOKEN = os.environ.get("HF_TOKEN")
 
-# Initialize the Gemini Flash Model
-model = genai.GenerativeModel('gemini-2.5-flash-lite-preview-06-17')
+if not HF_TOKEN:
+    raise RuntimeError("HF_TOKEN environment variable not set. Please add it in your Space's secrets.")
 
+from huggingface_hub import InferenceClient
+
+client = InferenceClient(
+    provider="featherless-ai",
+    api_key=os.environ["HF_TOKEN"],
+)
 
-# Gradio App with Support for Multi-Reactant Networks (e.g. A + B -> AB)
+# --- Helper: Save PIL image to URL-accessible temp file ---
+def image_to_temp_url(image):
+    temp_path = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+    image.save(temp_path.name)
+    return "https://your-server.com/temporary-image-support.png"  # placeholder (host image externally if needed)
 
-# --- Parsing Functions ---
+# --- OR upload image to Hugging Face Space / GDrive and return a public URL instead
+# You can use this for production use
+
+def extract_network_from_image(image):
+    # Upload image to temp path
+    image_path = tempfile.NamedTemporaryFile(suffix=".png", delete=False).name
+    image.save(image_path)
+
+    # Upload manually or serve image online if needed
+    # For now, simulate by loading image into bytes and re-uploading to HF or GDrive
+    # Instead: In Colab, just use direct GDrive URLs
+
+    # Placeholder: Manually put a URL here for now (from GDrive or HF Spaces or web)
+    raise NotImplementedError("Replace this with your public image URL logic.")
+
+# New: Directly send the URL to Unsloth Mistral + get output
+def extract_network_from_url(image_url):
+    prompt = (
+        "Analyze this network diagram and list the network only, e.g. Q + W -> R. Do not print any other sentence except the network."
+        "The arrows represent reactions. If there are multiple reactions, give them comma separated like A -> B, B -> C, etc."
+    )
+
+    completion = client.chat.completions.create(
+        model="unsloth/Mistral-Small-3.2-24B-Instruct-2506",
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {"type": "image_url", "image_url": {"url": image_url}},
+                ]
+            }
+        ]
+    )
+
+    return completion.choices[0].message.content.strip()
+
+
+# --- Network Analysis Functions ---
 def parse_species(expr):
-    # e.g., "A + B" -> ["A", "B"]
     return [s.strip() for s in re.split(r'\s*[\+\-]\s*', expr)]
 
 def parse_network(input_string):
-    edges = []
-    reversible_edges = []
-
+    edges, reversible_edges = [], []
     for part in input_string.split(','):
         part = part.strip()
         if '<->' in part:
@@ -40,7 +87,6 @@ def parse_network(input_string):
             lhs_species = parse_species(lhs)
             rhs_species = parse_species(rhs)
             edges.append((lhs_species, rhs_species))
-
     return edges, reversible_edges
 
 def build_graph(edges, reversible_edges):
@@ -65,7 +111,6 @@ def analyze_graph(G):
         "is_cyclic": not nx.is_directed_acyclic_graph(G)
     }
 
-# --- ODE Generator for Complex Reactions ---
 def mass_action_odes(edges, reversible_edges):
     species = set()
     odes = defaultdict(lambda: 0)
@@ -82,7 +127,6 @@ def mass_action_odes(edges, reversible_edges):
     for lhs_species, rhs_species in edges:
         k = sp.symbols(f'k{rate_counter}')
         rate_counter += 1
-
         flux = k * term(lhs_species)
         for s in lhs_species:
             sym = sp.symbols(s)
@@ -92,15 +136,12 @@ def mass_action_odes(edges, reversible_edges):
             odes[sym] += flux
 
     for lhs_species, rhs_species in reversible_edges:
-
         kf = sp.symbols(f'k{rate_counter}')
         rate_counter += 1
         kr = sp.symbols(f'k{rate_counter}')
         rate_counter += 1
-
         forward_flux = kf * term(lhs_species)
         reverse_flux = kr * term(rhs_species)
-
         for s in lhs_species:
             sym = sp.symbols(s)
             odes[sym] -= forward_flux
@@ -121,30 +162,7 @@ def compute_jacobian(odes):
     J = F.jacobian(variables)
     return sp.pretty(J)
 
-def extract_network_from_image(image):
-    prompt = (
-        "Analyze this network diagram and list the network only. "
-        "Use reaction format like 'A + B -> C' or 'X <-> Y'. "
-        "List multiple reactions separated by commas."
-    )
-    gemini_response = model.generate_content([prompt, image])
-    return gemini_response.text.strip()
-
-
-def full_process(image, text_input, query):
-    if text_input.strip():  # If text is given, use it
-        network_description = text_input.strip()
-    elif image is not None:  # Else if image is given, extract network from image
-        network_description = extract_network_from_image(image)
-    else:
-        return "❌ Please provide either a network image or a textual description."
-
-    # Step 2: Process extracted/generated network
-    return process_network(network_description, query)
-
-
-qa = pipeline("text2text-generation", model="google/flan-t5-base")
-def process_network(input_string, query):
+def process_network(input_string, query, image_url=None):
     edges, reversible_edges = parse_network(input_string)
     G = build_graph(edges, reversible_edges)
     info = analyze_graph(G)
@@ -152,42 +170,110 @@ def process_network(input_string, query):
     if 'ode' in query.lower():
         ode_sys = mass_action_odes(edges, reversible_edges)
         return format_odes(ode_sys)
-
     elif 'jacobian' in query.lower():
         ode_sys = mass_action_odes(edges, reversible_edges)
         return f"Jacobian Matrix:\n{compute_jacobian(ode_sys)}"
-
     elif 'variables' in query.lower():
         return f"There are {info['num_nodes']} variables: {info['nodes']}"
-
     elif 'edges' in query.lower():
         return f"Edges: {info['edges']}"
-
-    elif 'cyclic' or 'cycle' in query.lower():
+    elif 'cyclic' in query.lower() or 'cycle' in query.lower():
         cycles = list(nx.simple_cycles(G))
-        if cycles:
-            cycles_str = "\n".join([" -> ".join(cycle + [cycle[0]]) for cycle in cycles])
-            return f"Cycles found:\n{cycles_str}"
-        else:
-            return "No cycles found."
+        return "Cycles found:\n" + "\n".join([" -> ".join(cycle + [cycle[0]]) for cycle in cycles]) if cycles else "No cycles found."
 
+    # Fallback: Use LLM on both image and parsed network
     else:
-        prompt = f"Given the network with nodes: {info['nodes']} and edges: {info['edges']}, answer the query: {query}"
-        answer = qa(prompt, max_length=128)[0]['generated_text']
-        return answer
-
-
-iface = gr.Interface(
-    fn=full_process,
-    inputs=[
-        gr.Image(type="pil", label="Upload Network Image (optional)"),
-        gr.Textbox(label="Text Input (optional)", placeholder="Or paste network: A + B -> C, X <-> Y"),
-        gr.Textbox(label="Query", placeholder="Ask about ODEs, Jacobian, edges, etc.")
-    ],
-    outputs="text",
-    title="Biological Network Analyzer",
-    description="Upload an image or enter network text. Then ask a query like 'Give ODEs' or 'Is it cyclic?'.",
-    theme=Ocean()
-)
+        content = [
+            {
+                "type": "text",
+                "text": (
+                    "You are given a biological network with the following structure:\n"
+                    f"• Nodes: {info['nodes']}\n"
+                    f"• Reactions (edges): {info['edges']}\n\n"
+                    f"Answer the following query based on this structure and the image:"
+                    f"\n\n{query}"
+                ),
+            }
+        ]
+        if image_url:
+            content.append({
+                "type": "image_url",
+                "image_url": {"url": image_url}
+            })
+
+        response = client.chat.completions.create(
+            model="unsloth/Mistral-Small-3.2-24B-Instruct-2506",
+            messages=[{"role": "user", "content": content}],
+        )
+        return response.choices[0].message.content.strip()
+
+# --- Full Gradio Handler ---
+def full_process(text_input, image_url, query):
+    image_preview = None
+    network_description = ""
+    result = ""
+
+    if text_input.strip():
+        network_description = text_input.strip()
+    elif image_url.strip():
+        # Display image from URL
+        try:
+            response = requests.get(image_url)
+            image_preview = Image.open(BytesIO(response.content))
+        except:
+            return None, "", "❌ Invalid image URL"
+
+        # Extract network
+        network_description = extract_network_from_url(image_url)
+    else:
+        return None, "", "❌ Provide text or image URL."
+
+    # Answer query
+    result = process_network(network_description, query, image_url=image_url if image_url.strip() else None)
+    return image_preview, network_description, result
+
+import gradio as gr
+from gradio.themes.utils import sizes
+from gradio.themes.base import Base
+from gradio.themes.utils import colors
+
+# Optional: Keep your theme
+theme = gr.themes.Ocean()
+
+with gr.Blocks(theme=theme, css="#footer-link {text-align: center; font-size: 14px; color: #555;}") as iface:
+
+    gr.Markdown("## 🔬 Biological Network Analyzer (Multimodal Mistral via Unsloth)")
+    gr.Markdown("Paste a network OR provide a public image URL. Then ask a query like **'Give ODEs'** or **'Is it cyclic?'**")
+
+    with gr.Row():
+        with gr.Column():
+            # img_input = gr.Image(type="pil", label="Upload Network Image (❌ Not supported unless image is hosted online)")
+            text_input = gr.Textbox(label="Text Input (optional)", placeholder="Or paste network: A + B -> C, X <-> Y")
+            url_input = gr.Textbox(label="🔗 Public Image URL (e.g., from GDrive)", placeholder="https://... (must be accessible)")
+            query_input = gr.Textbox(label="Query", placeholder="Ask about ODEs, Jacobian, edges, etc.")
+
+        with gr.Column():
+            img_output = gr.Image(label="🖼️ Image Preview")
+            network_text = gr.Textbox(label="🧪 Extracted Network")
+            result_box = gr.Textbox(label="📘 Answer")
+
+
+
+
+    # Link logic to function
+    inputs = [text_input, url_input, query_input]
+    outputs = [img_output, network_text, result_box]
+    iface_fn = gr.Interface(fn=full_process, inputs=inputs, outputs=outputs)
+
+    # Footer GitHub link
+    gr.Markdown("""
+      <footer style='text-align:center; margin-top:20px; color:#aaa;'>
+          Built using Gradio, Hugging Face & Mistral |
+          <a href="https://github.com/kumardevansh/network_analyzer" target="_blank" style="color:#aaa; text-decoration:underline;">
+              View on GitHub
+          </a>
+      </footer>
+    """)
+
 
 iface.launch(share=True)