Update parser.py

parser.py

@@ -24,25 +24,35 @@ def get_category(node):
     elif isinstance(node, ast.Expr):
         return 'expression'
     else:
-        return 'other'  # Fallback for uncategorized nodes (e.g., 'pass')
+        return 'other'
 
 def create_vector(category, level, location, total_lines, parent_path):
-    """Create a vector representation including hierarchy info."""
+    """Create an optimized vector representation for a code part."""
     category_map = {
         'import': 1, 'assignment': 2, 'function': 3, 'async_function': 4, 'class': 5,
-        'if': 6, 'while': 7, 'for': 8, 'try': 9, 'expression': 10, 'spacer': 11, 'other': 12
+        'if': 6, 'while': 7, 'for': 8, 'try': 9, 'expression': 10, 'spacer': 11,
+        'other': 12, 'elif': 13, 'else': 14, 'except': 15, 'finally': 16
     }
     category_id = category_map.get(category, 0)
     start_line, end_line = location
+    span = (end_line - start_line + 1) / total_lines  # Normalized size of the part
+    center_pos = ((start_line + end_line) / 2) / total_lines  # Center position normalized
     parent_depth = len(parent_path)
-    parent_hash = hash(' -> '.join(parent_path)) % 1000
+    
+    # Weighted sum of parent categories (simple weighting by position)
+    parent_weight = 0
+    for i, parent in enumerate(parent_path):
+        parent_category = parent.split('[')[0].lower()
+        parent_weight += category_map.get(parent_category, 0) * (1 / (i + 1))  # Decay with depth
+    parent_weight = parent_weight / max(1, len(category_map))  # Normalize by max category ID
+
     return [
-        category_id,
-        level,
-        start_line / total_lines,
-        end_line / total_lines,
-        parent_depth,
-        parent_hash / 1000
+        category_id,       # Type of the part
+        level,             # Nesting depth
+        center_pos,        # Center position in file (0.0 to 1.0)
+        span,              # Relative size in file (0.0 to 1.0)
+        parent_depth,      # Number of ancestors
+        parent_weight      # Semantic connection to parents (0.0 to 1.0-ish)
     ]
 
 def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=None, counters=None):
@@ -59,13 +69,11 @@ def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=Non
     end_line = getattr(node, 'end_lineno', start_line)
     category = get_category(node)
 
-    # Assign a node ID for relevant categories
     node_id = ''
     if category in counters:
         counters[category] += 1
         node_id = f"{category.capitalize()}[{counters[category]}]"
 
-    # Handle spacers before the node
     if start_line > prev_end + 1:
         spacer_lines = lines[prev_end:start_line - 1]
         spacer_vector = create_vector('spacer', level, (prev_end + 1, start_line - 1), total_lines, parent_path)
@@ -79,7 +87,6 @@ def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=Non
             'node_id': ''
         })
 
-    # Capture the node's source
     stmt_lines = lines[start_line - 1:end_line]
     current_path = parent_path + ([node_id] if node_id else [])
     node_vector = create_vector(category, level, (start_line, end_line), total_lines, current_path)
@@ -93,13 +100,11 @@ def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=Non
         'node_id': node_id
     })
 
-    # Process nested bodies (body, orelse, handlers, finalbody)
     nested_prev_end = end_line - 1
     for attr in ('body', 'orelse', 'handlers', 'finalbody'):
         if hasattr(node, attr) and getattr(node, attr):
             sub_parts = []
             for child in getattr(node, attr):
-                # Special case for elif: treat as part of the if's orelse but same level
                 if attr == 'orelse' and isinstance(node, ast.If) and child.lineno != start_line:
                     sub_category = 'elif' if child.lineno != end_line else 'else'
                     sub_vector = create_vector(sub_category, level, (child.lineno, getattr(child, 'end_lineno', child.lineno)), total_lines, current_path)
@@ -110,11 +115,10 @@ def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=Non
                         'level': level,
                         'vector': sub_vector,
                         'parent_path': ' -> '.join(parent_path) if parent_path else 'Top-Level',
-                        'node_id': node_id  # Inherits the If's node_id
+                        'node_id': node_id
                     })
                     child_parts = parse_node(child, lines, child.lineno - 1, level + 1, total_lines, current_path, counters)
                     sub_parts.extend(child_parts)
-                # Special case for except: treat as part of try
                 elif attr == 'handlers' and isinstance(child, ast.ExceptHandler):
                     sub_vector = create_vector('except', level, (child.lineno, getattr(child, 'end_lineno', child.lineno)), total_lines, current_path)
                     sub_parts.append({
@@ -124,11 +128,10 @@ def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=Non
                         'level': level,
                         'vector': sub_vector,
                         'parent_path': ' -> '.join(parent_path) if parent_path else 'Top-Level',
-                        'node_id': node_id  # Inherits the Try's node_id
+                        'node_id': node_id
                     })
                     child_parts = parse_node(child, lines, child.lineno - 1, level + 1, total_lines, current_path, counters)
                     sub_parts.extend(child_parts)
-                # Special case for finally
                 elif attr == 'finalbody':
                     sub_vector = create_vector('finally', level, (child.lineno, getattr(child, 'end_lineno', child.lineno)), total_lines, current_path)
                     sub_parts.append({
@@ -138,7 +141,7 @@ def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=Non
                         'level': level,
                         'vector': sub_vector,
                         'parent_path': ' -> '.join(parent_path) if parent_path else 'Top-Level',
-                        'node_id': node_id  # Inherits the Try's node_id
+                        'node_id': node_id
                     })
                     child_parts = parse_node(child, lines, child.lineno - 1, level + 1, total_lines, current_path, counters)
                     sub_parts.extend(child_parts)
@@ -157,7 +160,7 @@ def parse_python_code(code):
     try:
         tree = ast.parse(code)
     except SyntaxError:
-        return [{'category': 'error', 'source': 'Invalid Python code', 'location': (1, 1), 'level': 0, 'vector': [0, 0, 1.0, 1.0, 0, 0], 'parent_path': 'Top-Level', 'node_id': ''}]
+        return [{'category': 'error', 'source': 'Invalid Python code', 'location': (1, 1), 'level': 0, 'vector': [0, 0, 1.0, 0.0, 0, 0], 'parent_path': 'Top-Level', 'node_id': ''}]
 
     parts = []
     prev_end = 0