Update app.py

app.py

@@ -7,7 +7,6 @@ app = Flask(__name__)
 UPLOAD_FOLDER = 'uploads'
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 
-# Ensure upload folder exists
 if not os.path.exists(UPLOAD_FOLDER):
     os.makedirs(UPLOAD_FOLDER)
 
@@ -25,7 +24,7 @@ def parse_code():
         file.save(file_path)
         with open(file_path, 'r') as f:
             code = f.read()
-        os.remove(file_path)  # Clean up
+        os.remove(file_path)
     elif 'code' in request.form:
         code = request.form['code']
 
@@ -34,16 +33,17 @@ def parse_code():
 
     parts, _ = parse_python_code(code)
     
-    # Extract nodes and connections
     nodes = []
     connections = []
-    node_id_map = {}  # Maps parser node_id to canvas node index
-    y_offset = 50  # For vertical layout
+    node_id_map = {}
+    scope_positions = defaultdict(lambda: {'x': 50, 'y': 50})  # Track positions per scope
 
     for part in parts:
         category = part['category']
         node_id = part['node_id']
         source = part['source'].strip()
+        scope = part['parent_path'].split(' -> ')[0] if ' -> ' in part['parent_path'] else 'global'
+        level = part['level']
 
         if category in ['function', 'assigned_variable', 'input_variable', 'returned_variable', 'import']:
             node_data = {
@@ -51,14 +51,14 @@ def parse_code():
                 'type': category,
                 'label': node_id,
                 'source': source,
-                'x': 50,
-                'y': y_offset,
+                'x': scope_positions[scope]['x'] + level * 150,  # Indent based on level
+                'y': scope_positions[scope]['y'],
                 'inputs': [],
-                'outputs': []
+                'outputs': [],
+                'value': part.get('value', None)
             }
 
             if category == 'function':
-                # Function: inputs are parameters, output is return
                 if 'def ' in source:
                     func_name = source.split('def ')[1].split('(')[0]
                     node_data['label'] = func_name
@@ -67,55 +67,59 @@ def parse_code():
                     node_data['inputs'] = params
                     node_data['outputs'] = ['return']
             elif category == 'input_variable':
-                # Input variable: output to parent function
                 var_name = source.strip().rstrip(',')
                 node_data['label'] = var_name
                 node_data['outputs'] = [var_name]
             elif category == 'assigned_variable':
-                # Assigned variable: input is value, output is variable
                 var_name = source.split('=')[0].strip()
                 node_data['label'] = var_name
                 node_data['inputs'] = ['value']
                 node_data['outputs'] = [var_name]
+                if node_data['value'] and node_data['value'].isdigit():
+                    node_data['type'] = 'number_box'
             elif category == 'returned_variable':
-                # Returned variable: input from function
                 var_name = source.split('return ')[1].strip() if 'return ' in source else node_id
                 node_data['label'] = var_name
                 node_data['inputs'] = [var_name]
             elif category == 'import':
-                # Import: no inputs/outputs, just a node
                 import_name = source.split('import ')[1].split()[0] if 'import ' in source else node_id
                 node_data['label'] = import_name
 
             nodes.append(node_data)
             node_id_map[node_id] = node_data['id']
-            y_offset += 100
+            scope_positions[scope]['y'] += 100
 
-    # Create connections based on parent_path and variable usage
+    # Create connections based on variable usage
     for part in parts:
         category = part['category']
-        if category in ['input_variable', 'returned_variable', 'assigned_variable']:
-            parent_path = part['parent_path']
-            if 'Function' in parent_path:
-                parent_node_id = parent_path.split(' -> ')[0]
-                if parent_node_id in node_id_map:
-                    from_id = node_id_map[part['node_id']]
-                    to_id = node_id_map[parent_node_id]
-                    if category == 'input_variable':
-                        connections.append({'from': from_id, 'to': to_id})
-                    elif category == 'returned_variable':
-                        connections.append({'from': to_id, 'to': from_id})
-                    elif category == 'assigned_variable':
-                        # Connect assigned variables to parent function (e.g., local variables)
-                        connections.append({'from': from_id, 'to': to_id})
-        elif category == 'import':
-            # Connect imports to functions that might use them (simplified: connect to all functions)
-            for other_part in parts:
-                if other_part['category'] == 'function' and other_part['node_id'] in node_id_map:
-                    connections.append({
-                        'from': node_id_map[part['node_id']],
-                        'to': node_id_map[other_part['node_id']]
-                    })
+        node_id = part['node_id']
+        if node_id in node_id_map:
+            scope = part['parent_path'].split(' -> ')[0] if ' -> ' in part['parent_path'] else 'global'
+            var_defs = part.get('var_defs', {})
+            var_uses = part.get('var_uses', {})
+            if category == 'assigned_variable':
+                var_name = part['source'].split('=')[0].strip()
+                # Connect to nodes where this variable is used
+                for use_node_id, use_scope in var_uses.get(var_name, []):
+                    if use_node_id in node_id_map and use_scope == scope:
+                        connections.append({
+                            'from': node_id_map[node_id],
+                            'to': node_id_map[use_node_id]
+                        })
+            elif category == 'function':
+                # Connect function to its input and returned variables
+                for input_part in parts:
+                    if input_part['category'] == 'input_variable' and input_part['parent_path'].startswith(node_id):
+                        connections.append({
+                            'from': node_id_map[input_part['node_id']],
+                            'to': node_id_map[node_id]
+                        })
+                for return_part in parts:
+                    if return_part['category'] == 'returned_variable' and return_part['parent_path'].startswith(node_id):
+                        connections.append({
+                            'from': node_id_map[node_id],
+                            'to': node_id_map[return_part['node_id']]
+                        })
 
     return jsonify({'nodes': nodes, 'connections': connections})