Update parser.py

parser.py

@@ -13,29 +13,29 @@ def get_category_id(category):
 
 def create_vector(category, level, location, total_lines, parent_path):
     """
-    Creates a 6D normalized vector:
-    [Category, Depth, RelativeCenter, Density, ParentDepth, AncestryWeight]
+    Creates a 6D normalized vector with rounded values to reduce JSON size.
     """
     cat_id = get_category_id(category)
     start, end = location
     total_lines = max(1, total_lines)
     
-    # metrics
+    # Calculate metrics
     span = (end - start + 1) / total_lines
     center = ((start + end) / 2) / total_lines
     parent_depth = len(parent_path)
     
-    # Ancestry weight: Simple hash sum of parent IDs to represent unique path
+    # Ancestry weight
     path_str = "".join(parent_path)
     parent_weight = (int(hashlib.md5(path_str.encode()).hexdigest(), 16) % 100) / 100.0
     
+    # OPTIMIZATION: Round floats to 4 decimals
     return [
         cat_id, 
         level, 
-        float(f"{center:.4f}"), 
-        float(f"{span:.4f}"), 
+        round(center, 4), 
+        round(span, 4), 
         parent_depth, 
-        float(f"{parent_weight:.4f}")
+        round(parent_weight, 4)
     ]
 
 def parse_source_to_graph(code):
@@ -48,16 +48,13 @@ def parse_source_to_graph(code):
     total_lines = len(lines)
     nodes = []
     
-    # Recursive visitor
     def traverse(node, parent_path=[], level=0, parent_id=None):
         category = 'other'
         name = getattr(node, 'name', None)
-        # Unique Node ID based on position to ensure consistency
         node_id = f"{type(node).__name__}_{getattr(node, 'lineno', 0)}_{getattr(node, 'col_offset', 0)}"
         
         # Categorization logic
-        if isinstance(node, (ast.Import, ast.ImportFrom)): category = 'import'; name = "import"
-        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): category = 'function'
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): category = 'function'
         elif isinstance(node, ast.ClassDef): category = 'class'
         elif isinstance(node, ast.If): category = 'if'; name = "if"
         elif isinstance(node, (ast.For, ast.AsyncFor)): category = 'for'; name = "for"
@@ -66,17 +63,13 @@ def parse_source_to_graph(code):
         elif isinstance(node, (ast.Assign, ast.AnnAssign)): category = 'assigned_variable'; name = "assignment"
         elif isinstance(node, ast.Expr): category = 'expression'; name = "expr"
         elif isinstance(node, ast.Try): category = 'try'; name = "try"
-        elif isinstance(node, ast.ExceptHandler): category = 'except'; name = "except"
+        elif isinstance(node, (ast.Import, ast.ImportFrom)): category = 'import'; name = "import"
         
         lineno = getattr(node, 'lineno', 0)
         end_lineno = getattr(node, 'end_lineno', lineno)
         
-        if lineno == 0: return # Skip nodes without line numbers (e.g. Load context)
+        if lineno == 0: return 
 
-        # Create source snippet
-        source_segment = "".join(lines[lineno-1:end_lineno])
-        
-        # Determine Label
         label = name if name else category
         if category == 'assigned_variable':
             targets = getattr(node, 'targets', []) or [getattr(node, 'target', None)]
@@ -85,18 +78,18 @@ def parse_source_to_graph(code):
         
         vector = create_vector(category, level, (lineno, end_lineno), total_lines, parent_path)
         
+        # OPTIMIZATION: Send 'loc' (location) instead of 'source' string.
+        # Shorten keys to reduce payload size.
         node_data = {
             "id": node_id,
-            "label": label,
+            "lbl": label,          # label -> lbl
             "type": category,
-            "source": source_segment.strip(),
-            "vector": vector,
-            "level": level,
-            "lineno": lineno,
-            "parent_id": parent_id
+            "loc": [lineno, end_lineno], # Start/End lines only
+            "vec": vector,         # vector -> vec
+            "lvl": level,          # level -> lvl
+            "pid": parent_id       # parent_id -> pid
         }
         
-        # Filter: Only visualize structural elements (skip raw expressions unless useful)
         if category != 'other':
             nodes.append(node_data)
             current_path = parent_path + [node_id]
@@ -113,10 +106,17 @@ def parse_source_to_graph(code):
     for node in tree.body:
         traverse(node)
     
-    # Sort by line number for linear visual flow
-    nodes.sort(key=lambda x: x['lineno'])
+    nodes.sort(key=lambda x: x['loc'][0])
     
-    return {"nodes": nodes, "connections": generate_connections(nodes)}
+    # Update connections to use shorter keys
+    connections = []
+    node_ids = {n['id'] for n in nodes}
+    for node in nodes:
+        if node['pid'] and node['pid'] in node_ids:
+            connections.append({"f": node['pid'], "t": node['id']}) # from/to -> f/t
+
+    return {"nodes": nodes, "connections": connections}
+
 
 def generate_connections(nodes):
     connections = []