Update parser.py

parser.py

@@ -40,11 +40,8 @@ def create_vector(category, level, location, total_lines, parent_path):
     span = (end_line - start_line + 1) / total_lines
     center_pos = ((start_line + end_line) / 2) / total_lines
     parent_depth = len(parent_path)
-    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))
-    parent_weight = parent_weight / max(1, len(category_map))
+    parent_weight = sum(category_map.get(parent.split('[')[0].lower(), 0) * (1 / (i + 1)) 
+                        for i, parent in enumerate(parent_path)) / max(1, len(category_map))
     return [category_id, level, center_pos, span, parent_depth, parent_weight]
 
 def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=None, counters=None):
@@ -63,90 +60,101 @@ def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=Non
     counters[category] += 1
     node_id = f"{category.capitalize()}[{counters[category]}]"
 
+    # Spacer before node
     if start_line > prev_end + 1:
         spacer_lines = lines[prev_end:start_line - 1]
         counters['spacer'] += 1
         spacer_node_id = f"Spacer[{counters['spacer']}]"
-        spacer_vector = create_vector('spacer', level, (prev_end + 1, start_line - 1), total_lines, parent_path)
         parts.append({
             'category': 'spacer',
             'source': ''.join(spacer_lines),
             'location': (prev_end + 1, start_line - 1),
             'level': level,
-            'vector': spacer_vector,
+            'vector': create_vector('spacer', level, (prev_end + 1, start_line - 1), total_lines, parent_path),
             'parent_path': ' -> '.join(parent_path) if parent_path else 'Top-Level',
             'node_id': spacer_node_id
         })
 
-    stmt_lines = lines[start_line - 1:end_line]
+    # Current node's header (e.g., 'def', 'if')
     current_path = parent_path + [node_id]
-    node_vector = create_vector(category, level, (start_line, end_line), total_lines, current_path)
+    node_lines = lines[start_line - 1:end_line]
     parts.append({
         'category': category,
-        'source': ''.join(stmt_lines),
-        'location': (start_line, end_line),
+        'source': node_lines[0],  # Only the header line
+        'location': (start_line, start_line),
         'level': level,
-        'vector': node_vector,
+        'vector': create_vector(category, level, (start_line, start_line), total_lines, current_path),
         'parent_path': ' -> '.join(parent_path) if parent_path else 'Top-Level',
         'node_id': node_id
     })
 
-    nested_prev_end = end_line - 1
+    # Process nested bodies
+    nested_prev_end = start_line
     for attr in ('body', 'orelse', 'handlers', 'finalbody'):
         if hasattr(node, attr) and getattr(node, attr):
-            sub_parts = []
             for child in getattr(node, attr):
                 if attr == 'orelse' and isinstance(node, ast.If) and child.lineno != start_line:
-                    sub_category = 'elif' if child.lineno != end_line else 'else'
+                    sub_category = 'elif' if 'elif' in lines[child.lineno - 1] else 'else'
                     counters[sub_category] += 1
                     sub_node_id = f"{sub_category.capitalize()}[{counters[sub_category]}]"
-                    sub_vector = create_vector(sub_category, level, (child.lineno, getattr(child, 'end_lineno', child.lineno)), total_lines, current_path)
-                    sub_parts.append({
+                    sub_start = child.lineno
+                    sub_end = getattr(child, 'end_lineno', sub_start)
+                    parts.append({
                         'category': sub_category,
-                        'source': ''.join(lines[child.lineno - 1:getattr(child, 'end_lineno', child.lineno)]),
-                        'location': (child.lineno, getattr(child, 'end_lineno', child.lineno)),
+                        'source': lines[sub_start - 1],
+                        'location': (sub_start, sub_start),
                         'level': level,
-                        'vector': sub_vector,
+                        'vector': create_vector(sub_category, level, (sub_start, sub_start), total_lines, current_path),
                         'parent_path': ' -> '.join(parent_path) if parent_path else 'Top-Level',
-                        'node_id': node_id
+                        'node_id': sub_node_id
                     })
-                    child_parts = parse_node(child, lines, child.lineno - 1, level + 1, total_lines, current_path, counters)
-                    sub_parts.extend(child_parts)
+                    child_parts = parse_node(child, lines, sub_start, level + 1, total_lines, current_path, counters)
+                    parts.extend(child_parts)
+                    nested_prev_end = max(nested_prev_end, child_parts[-1]['location'][1] if child_parts else sub_start)
                 elif attr == 'handlers' and isinstance(child, ast.ExceptHandler):
                     counters['except'] += 1
                     sub_node_id = f"Except[{counters['except']}]"
-                    sub_vector = create_vector('except', level, (child.lineno, getattr(child, 'end_lineno', child.lineno)), total_lines, current_path)
-                    sub_parts.append({
+                    sub_start = child.lineno
+                    sub_end = getattr(child, 'end_lineno', sub_start)
+                    parts.append({
                         'category': 'except',
-                        'source': ''.join(lines[child.lineno - 1:getattr(child, 'end_lineno', child.lineno)]),
-                        'location': (child.lineno, getattr(child, 'end_lineno', child.lineno)),
+                        'source': lines[sub_start - 1],
+                        'location': (sub_start, sub_start),
                         'level': level,
-                        'vector': sub_vector,
+                        'vector': create_vector('except', level, (sub_start, sub_start), total_lines, current_path),
                         'parent_path': ' -> '.join(parent_path) if parent_path else 'Top-Level',
-                        'node_id': node_id
+                        'node_id': sub_node_id
                     })
-                    child_parts = parse_node(child, lines, child.lineno - 1, level + 1, total_lines, current_path, counters)
-                    sub_parts.extend(child_parts)
+                    child_parts = parse_node(child, lines, sub_start, level + 1, total_lines, current_path, counters)
+                    parts.extend(child_parts)
+                    nested_prev_end = max(nested_prev_end, child_parts[-1]['location'][1] if child_parts else sub_start)
                 elif attr == 'finalbody':
                     counters['finally'] += 1
                     sub_node_id = f"Finally[{counters['finally']}]"
-                    sub_vector = create_vector('finally', level, (child.lineno, getattr(child, 'end_lineno', child.lineno)), total_lines, current_path)
-                    sub_parts.append({
+                    sub_start = child.lineno
+                    sub_end = getattr(child, 'end_lineno', sub_start)
+                    parts.append({
                         'category': 'finally',
-                        'source': ''.join(lines[child.lineno - 1:getattr(child, 'end_lineno', child.lineno)]),
-                        'location': (child.lineno, getattr(child, 'end_lineno', child.lineno)),
+                        'source': lines[sub_start - 1],
+                        'location': (sub_start, sub_start),
                         'level': level,
-                        'vector': sub_vector,
+                        'vector': create_vector('finally', level, (sub_start, sub_start), total_lines, current_path),
                         'parent_path': ' -> '.join(parent_path) if parent_path else 'Top-Level',
-                        'node_id': node_id
+                        'node_id': sub_node_id
                     })
-                    child_parts = parse_node(child, lines, child.lineno - 1, level + 1, total_lines, current_path, counters)
-                    sub_parts.extend(child_parts)
+                    child_parts = parse_node(child, lines, sub_start, level + 1, total_lines, current_path, counters)
+                    parts.extend(child_parts)
+                    nested_prev_end = max(nested_prev_end, child_parts[-1]['location'][1] if child_parts else sub_start)
                 else:
                     child_parts = parse_node(child, lines, nested_prev_end, level + 1, total_lines, current_path, counters)
-                    sub_parts.extend(child_parts)
-                nested_prev_end = sub_parts[-1]['location'][1] if sub_parts else nested_prev_end
-            parts.extend(sub_parts)
+                    parts.extend(child_parts)
+                    nested_prev_end = child_parts[-1]['location'][1] if child_parts else nested_prev_end
+
+    # Update end_line of the parent node to reflect its full scope
+    if nested_prev_end > start_line:
+        parts[-1]['location'] = (start_line, nested_prev_end)
+        parts[-1]['source'] = ''.join(lines[start_line - 1:nested_prev_end])
+        parts[-1]['vector'] = create_vector(category, level, (start_line, nested_prev_end), total_lines, current_path)
 
     return parts
 
@@ -171,13 +179,12 @@ def parse_python_code(code):
         counters = {'spacer': 0}
         counters['spacer'] += 1
         spacer_node_id = f"Spacer[{counters['spacer']}]"
-        spacer_vector = create_vector('spacer', 0, (prev_end + 1, total_lines + 1), total_lines, [])
         parts.append({
             'category': 'spacer',
             'source': ''.join(remaining_lines),
             'location': (prev_end + 1, total_lines + 1),
             'level': 0,
-            'vector': spacer_vector,
+            'vector': create_vector('spacer', 0, (prev_end + 1, total_lines + 1), total_lines, []),
             'parent_path': 'Top-Level',
             'node_id': spacer_node_id
         })