Update parser.py

parser.py

@@ -19,29 +19,30 @@ def get_category(node):
         return 'while'
     elif isinstance(node, ast.For):
         return 'for'
+    elif isinstance(node, ast.Try):
+        return 'try'
     elif isinstance(node, ast.Expr):
         return 'expression'
     else:
-        return 'other'
+        return 'other'  # Fallback for uncategorized nodes (e.g., 'pass')
 
 def create_vector(category, level, location, total_lines, parent_path):
     """Create a vector representation including hierarchy info."""
     category_map = {
         'import': 1, 'assignment': 2, 'function': 3, 'async_function': 4, 'class': 5,
-        'if': 6, 'while': 7, 'for': 8, 'expression': 9, 'spacer': 10, 'other': 11
+        'if': 6, 'while': 7, 'for': 8, 'try': 9, 'expression': 10, 'spacer': 11, 'other': 12
     }
     category_id = category_map.get(category, 0)
     start_line, end_line = location
-    # Extend vector with parent path length and a hash of the path for uniqueness
     parent_depth = len(parent_path)
-    parent_hash = hash(' -> '.join(parent_path)) % 1000  # Simple hash for vector
+    parent_hash = hash(' -> '.join(parent_path)) % 1000
     return [
         category_id,
         level,
         start_line / total_lines,
         end_line / total_lines,
         parent_depth,
-        parent_hash / 1000  # Normalized hash (0.0 to 1.0)
+        parent_hash / 1000
     ]
 
 def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=None, counters=None):
@@ -51,7 +52,7 @@ def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=Non
     if parent_path is None:
         parent_path = []
     if counters is None:
-        counters = {'if': 0, 'while': 0, 'for': 0, 'function': 0, 'class': 0}  # Track counts per type
+        counters = {'if': 0, 'while': 0, 'for': 0, 'function': 0, 'class': 0, 'try': 0}
 
     parts = []
     start_line = getattr(node, 'lineno', prev_end + 1)
@@ -92,14 +93,60 @@ def parse_node(node, lines, prev_end, level=0, total_lines=None, parent_path=Non
         'node_id': node_id
     })
 
-    # Process nested nodes (body and orelse)
+    # Process nested bodies (body, orelse, handlers, finalbody)
     nested_prev_end = end_line - 1
-    for attr in ('body', 'orelse'):
+    for attr in ('body', 'orelse', 'handlers', 'finalbody'):
         if hasattr(node, attr) and getattr(node, attr):
+            sub_parts = []
             for child in getattr(node, attr):
-                child_parts = parse_node(child, lines, nested_prev_end, level + 1, total_lines, current_path, counters)
-                parts.extend(child_parts)
-                nested_prev_end = child_parts[-1]['location'][1]
+                # 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)
+                    sub_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)),
+                        '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
+                    })
+                    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({
+                        'category': 'except',
+                        'source': ''.join(lines[child.lineno - 1:getattr(child, 'end_lineno', child.lineno)]),
+                        'location': (child.lineno, getattr(child, 'end_lineno', child.lineno)),
+                        '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
+                    })
+                    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({
+                        'category': 'finally',
+                        'source': ''.join(lines[child.lineno - 1:getattr(child, 'end_lineno', child.lineno)]),
+                        'location': (child.lineno, getattr(child, 'end_lineno', child.lineno)),
+                        '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
+                    })
+                    child_parts = parse_node(child, lines, child.lineno - 1, level + 1, total_lines, current_path, counters)
+                    sub_parts.extend(child_parts)
+                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)
 
     return parts