Update app.py

app.py

@@ -1,150 +1,147 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
 import gradio as gr
 from transformers import pipeline
 from graphviz import Digraph
-import sqlite3
+import json
 import os
 
-# Initialize AI model
+# File-based persistence
+DB_FILE = "fractal_tree.json"
+
+# AI Model Initialization
 ai_model = pipeline("text-classification", model="distilbert-base-uncased-finetuned-sst-2-english")
 
-# Database setup
-DB_PATH = "fractal_tree.db"
-
-def init_db():
-    """Initialize the SQLite database."""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("""
-    CREATE TABLE IF NOT EXISTS nodes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        data TEXT,
-        module TEXT,
-        parent_id INTEGER,
-        FOREIGN KEY(parent_id) REFERENCES nodes(id)
-    )
-    """)
-    conn.commit()
-    conn.close()
-
-def save_node(data, module, parent_id=None):
-    """Save a node to the database."""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("INSERT INTO nodes (data, module, parent_id) VALUES (?, ?, ?)", (data, module, parent_id))
-    conn.commit()
-    node_id = cursor.lastrowid
-    conn.close()
-    return node_id
-
-def get_node(node_id):
-    """Retrieve a node by ID."""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("SELECT * FROM nodes WHERE id = ?", (node_id,))
-    node = cursor.fetchone()
-    conn.close()
-    return node
-
-def get_children(parent_id):
-    """Retrieve children of a node."""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("SELECT * FROM nodes WHERE parent_id = ?", (parent_id,))
-    children = cursor.fetchall()
-    conn.close()
-    return children
-
-def build_graph():
-    """Build a graphical representation of the tree."""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("SELECT * FROM nodes")
-    nodes = cursor.fetchall()
-    conn.close()
-
-    graph = Digraph()
-    for node in nodes:
-        graph.node(str(node[0]), f"{node[1]} ({node[2]})")
-        if node[3]:  # If parent_id exists
-            graph.edge(str(node[3]), str(node[0]))
-    return graph
-
-# Initialize database
-init_db()
-
-# Fractal Tree Manager
+
+class Node:
+    def __init__(self, node_id, data, module, parent_id=None):
+        self.node_id = node_id
+        self.data = data
+        self.module = module
+        self.parent_id = parent_id
+        self.children = []
+
+    def to_dict(self):
+        """Convert Node to dictionary for JSON storage."""
+        return {
+            "node_id": self.node_id,
+            "data": self.data,
+            "module": self.module,
+            "parent_id": self.parent_id,
+            "children": [child.to_dict() for child in self.children],
+        }
+
+    @staticmethod
+    def from_dict(node_dict):
+        """Create Node from dictionary."""
+        node = Node(
+            node_dict["node_id"],
+            node_dict["data"],
+            node_dict["module"],
+            node_dict.get("parent_id"),
+        )
+        node.children = [Node.from_dict(child) for child in node_dict["children"]]
+        return node
+
+
 class FractalTree:
     def __init__(self):
+        self.tree = None
         self.current_node = None
-        self.ensure_root_exists()
-
-    def ensure_root_exists(self):
-        """Ensure the root node exists."""
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        cursor.execute("SELECT * FROM nodes WHERE parent_id IS NULL")
-        root = cursor.fetchone()
-        if not root:
-            self.current_node = save_node("Root", "Root Module")
+        self.load_tree()
+
+    def save_tree(self):
+        """Save the tree to a JSON file."""
+        with open(DB_FILE, "w") as f:
+            json.dump(self.tree.to_dict(), f, indent=4)
+
+    def load_tree(self):
+        """Load the tree from a JSON file."""
+        if os.path.exists(DB_FILE):
+            with open(DB_FILE, "r") as f:
+                self.tree = Node.from_dict(json.load(f))
+                self.current_node = self.tree
         else:
-            self.current_node = root[0]
-        conn.close()
+            self.tree = Node("0", "Root", "Root Module")
+            self.current_node = self.tree
+            self.save_tree()
 
     def add_node(self, data):
-        """Add a new node as a child of the current node."""
-        suggestion = ai_model(data)[0]['label']  # AI suggests a module
-        node_id = save_node(data, suggestion, self.current_node)
-        return f"Added node: '{data}' with module: '{suggestion}'"
+        """Add a node as a child of the current node."""
+        suggestion = ai_model(data)[0]["label"]
+        new_node = Node(
+            node_id=str(len(self.tree.to_dict())),  # Generate unique ID
+            data=data,
+            module=suggestion,
+            parent_id=self.current_node.node_id,
+        )
+        self.current_node.children.append(new_node)
+        self.save_tree()
+        return f"Added node with data: '{data}' and module: '{suggestion}'"
 
     def go_to_child(self, index):
         """Navigate to a child node by index."""
-        children = get_children(self.current_node)
-        if 0 <= index < len(children):
-            self.current_node = children[index][0]
-            return f"Moved to child node: {children[index][1]}"
+        if 0 <= index < len(self.current_node.children):
+            self.current_node = self.current_node.children[index]
+            self.save_tree()
+            return f"Moved to child node: {self.current_node.data}"
         return "Invalid child index."
 
     def go_to_parent(self):
         """Navigate to the parent node."""
-        node = get_node(self.current_node)
-        if node and node[3]:
-            self.current_node = node[3]
-            return f"Moved to parent node: {get_node(self.current_node)[1]}"
+        if self.current_node.parent_id:
+            parent_node = self.find_node(self.tree, self.current_node.parent_id)
+            if parent_node:
+                self.current_node = parent_node
+                self.save_tree()
+                return f"Moved to parent node: {self.current_node.data}"
         return "Already at the root node."
 
-    def view_tree(self):
-        """Generate a visual representation of the tree."""
-        graph = build_graph()
-        graph_path = "/tmp/fractal_tree"
-        graph.render(graph_path, format="png", cleanup=True)
-        return graph_path + ".png"
-
-# Initialize fractal tree
+    def find_node(self, node, node_id):
+        """Recursively find a node by ID."""
+        if node.node_id == node_id:
+            return node
+        for child in node.children:
+            result = self.find_node(child, node_id)
+            if result:
+                return result
+        return None
+
+    def build_graph(self):
+        """Build a graph visualization of the tree."""
+        def traverse(node, graph, node_id="0"):
+            graph.node(node_id, f"{node.data} ({node.module})")
+            for idx, child in enumerate(node.children):
+                child_id = f"{node_id}-{idx}"
+                graph.edge(node_id, child_id)
+                traverse(child, graph, child_id)
+
+        graph = Digraph()
+        traverse(self.tree, graph)
+        return graph
+
+
+# Initialize Fractal Tree
 fractal_tree = FractalTree()
 
 # Gradio Functions
 def add_node(data):
-    """Add a new node."""
     return fractal_tree.add_node(data)
 
 def go_to_child(index):
-    """Navigate to a child node."""
     return fractal_tree.go_to_child(int(index))
 
 def go_to_parent():
-    """Navigate to the parent node."""
     return fractal_tree.go_to_parent()
 
 def view_tree():
-    """Display the tree structure."""
-    return fractal_tree.view_tree()
+    graph = fractal_tree.build_graph()
+    graph_path = "/tmp/fractal_tree"
+    graph.render(graph_path, format="png", cleanup=True)
+    return graph_path + ".png"
+
 
 # Gradio Interface
 with gr.Blocks() as app:
-    gr.Markdown("# Emergent Fractal App")
+    gr.Markdown("# Emergent Fractal App with JSON Persistence")
 
     # Add Node Section
     with gr.Row():