pydpm_xl 0.1.39rc32__py3-none-any.whl → 0.2.1__py3-none-any.whl

py_dpm/api/{complete_ast.py → dpm_xl/complete_ast.py}

@@ -10,21 +10,21 @@ Also provides enrichment functionality to create engine-ready ASTs with framewor
 """
 
 from datetime import datetime
-from typing import Dict, Any, Optional
-from py_dpm.Utils.ast_serialization import ASTToJSONVisitor
+from typing import Dict, Any, Any, Optional
+from py_dpm.dpm_xl.utils.serialization import ASTToJSONVisitor
 
 
 def generate_complete_ast(
     expression: str,
     database_path: str = None,
     connection_url: str = None,
-    release_id: Optional[int] = None
+    release_id: Optional[int] = None,
 ):
     """
     Generate complete AST with all data fields, exactly like json_scripts examples.
 
-    This function replicates the exact same process used to generate the reference
-    JSON files in json_scripts/, ensuring complete data field population.
+    This function replicates the process used to generate the reference JSON files,
+    using the new SemanticAPI to perform full semantic validation and operand checking.
 
     Args:
         expression: DPM-XL expression string
@@ -34,201 +34,107 @@ def generate_complete_ast(
             If None, uses all available data (release-agnostic).
 
     Returns:
-        dict: {
-            'success': bool,
-            'ast': dict,        # Complete AST with data fields
-            'context': dict,    # Context from WITH clause
-            'error': str,       # Error if failed
-            'data_populated': bool  # Whether data fields were populated
-        }
+        dict with keys:
+            success, ast, context, error, data_populated, semantic_result
     """
     try:
         # Import here to avoid circular imports
-        from py_dpm.api import API
-        from py_dpm.db_utils import get_engine
+        from py_dpm.api.dpm_xl.semantic import SemanticAPI
+        from py_dpm.dpm.utils import get_engine
 
-        # Initialize database connection if provided
+        # Initialize database connection if explicitly provided, to surface connection errors early
         if connection_url or database_path:
             try:
-                engine = get_engine(database_path=database_path, connection_url=connection_url)
+                get_engine(database_path=database_path, connection_url=connection_url)
             except Exception as e:
                 return {
-                    'success': False,
-                    'ast': None,
-                    'context': None,
-                    'error': f'Database connection failed: {e}',
-                    'data_populated': False
+                    "success": False,
+                    "ast": None,
+                    "context": None,
+                    "error": f"Database connection failed: {e}",
+                    "data_populated": False,
                 }
 
-        # Use the legacy API which does complete semantic validation
-        # This is the same API used to generate the original JSON files
-        api = API(database_path=database_path, connection_url=connection_url)
-
-        # Perform complete semantic validation with operand checking
-        # This should populate all data fields on VarID nodes
-        semantic_result = api.semantic_validation(expression, release_id=release_id)
-
+        # Use the modern SemanticAPI which performs full semantic validation and operand checking
+        semantic_api = SemanticAPI(
+            database_path=database_path, connection_url=connection_url
+        )
 
-        # Force data population if semantic validation completed successfully
-        if hasattr(api, 'AST') and api.AST and semantic_result:
-            try:
-                from py_dpm.AST.check_operands import OperandsChecking
-                from py_dpm.db_utils import get_session
-
-                session = get_session()
-
-                # Extract the expression AST
-                def get_inner_ast(ast_obj):
-                    if hasattr(ast_obj, 'children') and len(ast_obj.children) > 0:
-                        child = ast_obj.children[0]
-                        if hasattr(child, 'expression'):
-                            return child.expression
-                        else:
-                            return child
-                    return ast_obj
-
-                inner_ast = get_inner_ast(api.AST)
-
-                # Run operand checking to populate data fields
-                oc = OperandsChecking(
-                    session=session,
-                    expression=expression,
-                    ast=inner_ast,
-                    release_id=release_id
-                )
+        semantic_result = semantic_api.validate_expression(
+            expression, release_id=release_id
+        )
 
-                # Apply the data from operand checker to VarID nodes
-                if hasattr(oc, 'data') and oc.data is not None:
-
-                    # Apply data to VarID nodes in the AST
-                    def apply_data_to_varids(node):
-                        if hasattr(node, '__class__') and node.__class__.__name__ == 'VarID':
-                            table = getattr(node, 'table', None)
-                            rows = getattr(node, 'rows', None)
-                            cols = getattr(node, 'cols', None)
-
-                            if table and table in oc.operands:
-                                # Filter data for this specific VarID
-                                # Start with table filter
-                                filter_mask = (oc.data['table_code'] == table)
-
-                                # Add row filter only if rows is not None and doesn't contain wildcards
-                                # IMPORTANT: If rows contains '*', include all rows (don't filter)
-                                if rows is not None and '*' not in rows:
-                                    filter_mask = filter_mask & (oc.data['row_code'].isin(rows))
-
-                                # Add column filter only if cols is not None and doesn't contain wildcards
-                                # IMPORTANT: If cols contains '*', include all columns (don't filter)
-                                if cols is not None and '*' not in cols:
-                                    filter_mask = filter_mask & (oc.data['column_code'].isin(cols))
-
-                                filtered_data = oc.data[filter_mask]
-
-                                if not filtered_data.empty:
-                                    # IMPORTANT: Remove wildcard entries (NULL column/row/sheet codes)
-                                    # when specific entries exist for the same dimension
-                                    # The database contains both wildcard entries (column_code=NULL for c*)
-                                    # and specific entries (column_code='0010'). When we query with wildcards,
-                                    # we want only the specific entries.
-
-                                    # Remove rows where column_code is NULL if there are non-NULL column_code entries
-                                    if filtered_data['column_code'].notna().any():
-                                        filtered_data = filtered_data[filtered_data['column_code'].notna()]
-
-                                    # Remove rows where row_code is NULL if there are non-NULL row_code entries
-                                    if filtered_data['row_code'].notna().any():
-                                        filtered_data = filtered_data[filtered_data['row_code'].notna()]
-
-                                    # Remove rows where sheet_code is NULL if there are non-NULL sheet_code entries
-                                    if filtered_data['sheet_code'].notna().any():
-                                        filtered_data = filtered_data[filtered_data['sheet_code'].notna()]
-
-                                    # IMPORTANT: After filtering, remove any remaining duplicates
-                                    # based on (row_code, column_code, sheet_code) combination
-                                    filtered_data = filtered_data.drop_duplicates(
-                                        subset=['row_code', 'column_code', 'sheet_code'],
-                                        keep='first'
-                                    )
-
-                                    # Set the data attribute on the VarID node
-                                    if not filtered_data.empty:
-                                        node.data = filtered_data
-
-                        # Recursively apply to child nodes
-                        for attr_name in ['children', 'left', 'right', 'operand', 'operands', 'expression', 'condition', 'then_expr', 'else_expr']:
-                            if hasattr(node, attr_name):
-                                attr_value = getattr(node, attr_name)
-                                if isinstance(attr_value, list):
-                                    for item in attr_value:
-                                        if hasattr(item, '__class__'):
-                                            apply_data_to_varids(item)
-                                elif attr_value and hasattr(attr_value, '__class__'):
-                                    apply_data_to_varids(attr_value)
-
-                    # Apply data to all VarID nodes in the AST
-                    apply_data_to_varids(inner_ast)
+        # If semantic validation failed, return structured error
+        if not semantic_result.is_valid:
+            return {
+                "success": False,
+                "ast": None,
+                "context": None,
+                "error": semantic_result.error_message,
+                "data_populated": False,
+                "semantic_result": semantic_result,
+            }
 
-            except Exception as e:
-                # Silently continue if data population fails
-                pass
-
-        if hasattr(api, 'AST') and api.AST is not None:
-            # Extract components exactly like batch_validator does
-            def extract_components(ast_obj):
-                if hasattr(ast_obj, 'children') and len(ast_obj.children) > 0:
-                    child = ast_obj.children[0]
-                    if hasattr(child, 'expression'):
-                        return child.expression, child.partial_selection
-                    else:
-                        return child, None
-                return ast_obj, None
-
-            actual_ast, context = extract_components(api.AST)
-
-            # Convert to JSON exactly like batch_validator does
-            visitor = ASTToJSONVisitor(context)
-            ast_dict = visitor.visit(actual_ast)
-
-            # Check if data fields were populated
-            data_populated = _check_data_fields_populated(ast_dict)
-
-            # Serialize context
-            context_dict = None
-            if context:
-                context_dict = {
-                    'table': getattr(context, 'table', None),
-                    'rows': getattr(context, 'rows', None),
-                    'columns': getattr(context, 'cols', None),
-                    'sheets': getattr(context, 'sheets', None),
-                    'default': getattr(context, 'default', None),
-                    'interval': getattr(context, 'interval', None)
-                }
+        ast_root = getattr(semantic_api, "ast", None)
 
+        if ast_root is None:
             return {
-                'success': True,
-                'ast': ast_dict,
-                'context': context_dict,
-                'error': None,
-                'data_populated': data_populated,
-                'semantic_result': semantic_result
+                "success": False,
+                "ast": None,
+                "context": None,
+                "error": "Semantic validation did not generate AST",
+                "data_populated": False,
+                "semantic_result": semantic_result,
             }
 
-        else:
-            return {
-                'success': False,
-                'ast': None,
-                'context': None,
-                'error': 'Semantic validation did not generate AST',
-                'data_populated': False
+        # Extract components exactly like batch_validator does
+        def extract_components(ast_obj):
+            if hasattr(ast_obj, "children") and len(ast_obj.children) > 0:
+                child = ast_obj.children[0]
+                if hasattr(child, "expression"):
+                    return child.expression, child.partial_selection
+                else:
+                    return child, None
+            return ast_obj, None
+
+        actual_ast, context = extract_components(ast_root)
+
+        # Convert to JSON using the ASTToJSONVisitor, which uses VarID.data populated
+        # during semantic validation / operand checking.
+        visitor = ASTToJSONVisitor(context)
+        ast_dict = visitor.visit(actual_ast)
+
+        # Check if data fields were populated
+        data_populated = _check_data_fields_populated(ast_dict)
+
+        # Serialize context
+        context_dict = None
+        if context:
+            context_dict = {
+                "table": getattr(context, "table", None),
+                "rows": getattr(context, "rows", None),
+                "columns": getattr(context, "cols", None),
+                "sheets": getattr(context, "sheets", None),
+                "default": getattr(context, "default", None),
+                "interval": getattr(context, "interval", None),
             }
 
+        return {
+            "success": True,
+            "ast": ast_dict,
+            "context": context_dict,
+            "error": None,
+            "data_populated": data_populated,
+            "semantic_result": semantic_result,
+        }
+
     except Exception as e:
         return {
-            'success': False,
-            'ast': None,
-            'context': None,
-            'error': f'API error: {str(e)}',
-            'data_populated': False
+            "success": False,
+            "ast": None,
+            "context": None,
+            "error": f"API error: {str(e)}",
+            "data_populated": False,
         }
 
 
@@ -237,7 +143,7 @@ def _check_data_fields_populated(ast_dict):
     if not isinstance(ast_dict, dict):
         return False
 
-    if ast_dict.get('class_name') == 'VarID' and 'data' in ast_dict:
+    if ast_dict.get("class_name") == "VarID" and "data" in ast_dict:
         return True
 
     # Recursively check nested structures
@@ -257,7 +163,7 @@ def generate_complete_batch(
     expressions: list,
     database_path: str = None,
     connection_url: str = None,
-    release_id: Optional[int] = None
+    release_id: Optional[int] = None,
 ):
     """
     Generate complete ASTs for multiple expressions.
@@ -277,7 +183,7 @@ def generate_complete_batch(
         result = generate_complete_ast(
             expr, database_path, connection_url, release_id=release_id
         )
-        result['batch_index'] = i
+        result["batch_index"] = i
         results.append(result)
     return results
 
@@ -287,7 +193,7 @@ def parse_with_data_fields(
     expression: str,
     database_path: str = None,
     connection_url: str = None,
-    release_id: Optional[int] = None
+    release_id: Optional[int] = None,
 ):
     """
     Simple function to parse expression and get AST with data fields.
@@ -305,7 +211,7 @@ def parse_with_data_fields(
     result = generate_complete_ast(
         expression, database_path, connection_url, release_id=release_id
     )
-    return result['ast'] if result['success'] else None
+    return result["ast"] if result["success"] else None
 
 
 # ============================================================================
@@ -353,15 +259,15 @@ def generate_enriched_ast(
             expression, database_path, connection_url, release_id=release_id
         )
 
-        if not complete_result['success']:
+        if not complete_result["success"]:
             return {
-                'success': False,
-                'enriched_ast': None,
-                'error': f"Failed to generate complete AST: {complete_result['error']}"
+                "success": False,
+                "enriched_ast": None,
+                "error": f"Failed to generate complete AST: {complete_result['error']}",
             }
 
-        complete_ast = complete_result['ast']
-        context = complete_result.get('context') or table_context
+        complete_ast = complete_result["ast"]
+        context = complete_result.get("context") or table_context
 
         # Enrich with framework structure
         enriched_ast = enrich_ast_with_metadata(
@@ -372,20 +278,16 @@ def generate_enriched_ast(
             connection_url=connection_url,
             dpm_version=dpm_version,
             operation_code=operation_code,
-            precondition=precondition
+            precondition=precondition,
         )
 
-        return {
-            'success': True,
-            'enriched_ast': enriched_ast,
-            'error': None
-        }
+        return {"success": True, "enriched_ast": enriched_ast, "error": None}
 
     except Exception as e:
         return {
-            'success': False,
-            'enriched_ast': None,
-            'error': f'Enrichment error: {str(e)}'
+            "success": False,
+            "enriched_ast": None,
+            "error": f"Enrichment error: {str(e)}",
         }
 
 
@@ -417,8 +319,8 @@ def enrich_ast_with_metadata(
     Returns:
         dict: Engine-ready AST with framework structure
     """
-    from py_dpm.db_utils import get_engine, get_session
-    from py_dpm.models import TableVersion, Release
+    from py_dpm.dpm.utils import get_engine, get_session
+    from py_dpm.dpm.models import TableVersion, Release
     import copy
 
     # Initialize database connection
@@ -440,13 +342,10 @@ def enrich_ast_with_metadata(
         "module_version": "1.0.0",
         "framework_code": "default",
         "dpm_release": {
-            "release": release_info['release'],
-            "publication_date": release_info['publication_date']
+            "release": release_info["release"],
+            "publication_date": release_info["publication_date"],
         },
-        "dates": {
-            "from": "2001-01-01",
-            "to": None
-        }
+        "dates": {"from": "2001-01-01", "to": None},
     }
 
     # Add coordinates to AST data entries
@@ -461,7 +360,7 @@ def enrich_ast_with_metadata(
             "root_operator_id": 24,  # Default for now
             "ast": ast_with_coords,
             "from_submission_date": current_date,
-            "severity": "Error"
+            "severity": "Error",
         }
     }
 
@@ -473,27 +372,24 @@ def enrich_ast_with_metadata(
 
     # Build tables with their specific variables
     for table_code, table_variables in variables_by_table.items():
-        tables[table_code] = {
-            "variables": table_variables,
-            "open_keys": {}
-        }
+        tables[table_code] = {"variables": table_variables, "open_keys": {}}
 
     # Build preconditions
     preconditions = {}
     precondition_variables = {}
 
-    if precondition or (context and 'table' in context):
+    if precondition or (context and "table" in context):
         preconditions, precondition_variables = _build_preconditions(
             precondition=precondition,
             context=context,
             operation_code=operation_code,
-            engine=engine
+            engine=engine,
         )
 
     # Build dependency information
     dependency_info = {
         "intra_instance_validations": [operation_code],
-        "cross_instance_dependencies": []
+        "cross_instance_dependencies": [],
     }
 
     # Build dependency modules
@@ -511,7 +407,7 @@ def enrich_ast_with_metadata(
             "preconditions": preconditions,
             "precondition_variables": precondition_variables,
             "dependency_information": dependency_info,
-            "dependency_modules": dependency_modules
+            "dependency_modules": dependency_modules,
         }
     }
 
@@ -527,7 +423,7 @@ def _get_release_info(dpm_version: Optional[str], engine) -> Dict[str, Any]:
     Returns:
         dict: {'release': str, 'publication_date': str}
     """
-    from py_dpm.models import Release
+    from py_dpm.dpm.models import Release
     from sqlalchemy.orm import sessionmaker
 
     Session = sessionmaker(bind=engine)
@@ -537,39 +433,44 @@ def _get_release_info(dpm_version: Optional[str], engine) -> Dict[str, Any]:
         if dpm_version:
             # Query for specific version
             version_float = float(dpm_version)
-            release = session.query(Release).filter(
-                Release.code == str(version_float)
-            ).first()
+            release = (
+                session.query(Release)
+                .filter(Release.code == str(version_float))
+                .first()
+            )
 
             if release:
                 return {
-                    'release': str(release.code) if release.code else dpm_version,
-                    'publication_date': release.date.strftime("%Y-%m-%d") if release.date else "2001-01-01"
+                    "release": str(release.code) if release.code else dpm_version,
+                    "publication_date": (
+                        release.date.strftime("%Y-%m-%d")
+                        if release.date
+                        else "2001-01-01"
+                    ),
                 }
 
         # Fallback: get latest released version
-        release = session.query(Release).filter(
-            Release.status == 'released'
-        ).order_by(Release.code.desc()).first()
+        release = (
+            session.query(Release)
+            .filter(Release.status == "released")
+            .order_by(Release.code.desc())
+            .first()
+        )
 
         if release:
             return {
-                'release': str(release.code) if release.code else "4.1",
-                'publication_date': release.date.strftime("%Y-%m-%d") if release.date else "2001-01-01"
+                "release": str(release.code) if release.code else "4.1",
+                "publication_date": (
+                    release.date.strftime("%Y-%m-%d") if release.date else "2001-01-01"
+                ),
             }
 
         # Final fallback
-        return {
-            'release': "4.1",
-            'publication_date': "2001-01-01"
-        }
+        return {"release": "4.1", "publication_date": "2001-01-01"}
 
     except Exception:
         # Fallback on any error
-        return {
-            'release': "4.1",
-            'publication_date': "2001-01-01"
-        }
+        return {"release": "4.1", "publication_date": "2001-01-01"}
     finally:
         session.close()
 
@@ -585,7 +486,7 @@ def _get_table_info(table_code: str, engine) -> Optional[Dict[str, Any]]:
     Returns:
         dict: {'table_vid': int, 'code': str} or None if not found
     """
-    from py_dpm.models import TableVersion
+    from py_dpm.dpm.models import TableVersion
     from sqlalchemy.orm import sessionmaker
     import re
 
@@ -594,41 +495,37 @@ def _get_table_info(table_code: str, engine) -> Optional[Dict[str, Any]]:
 
     try:
         # Try exact match first
-        table = session.query(TableVersion).filter(
-            TableVersion.code == table_code
-        ).first()
+        table = (
+            session.query(TableVersion).filter(TableVersion.code == table_code).first()
+        )
 
         if table:
-            return {
-                'table_vid': table.tablevid,
-                'code': table.code
-            }
+            return {"table_vid": table.tablevid, "code": table.code}
 
         # Handle precondition parser format: F_25_01 -> F_25.01
-        if re.match(r'^[A-Z]_\d+_\d+', table_code):
-            parts = table_code.split('_', 2)
+        if re.match(r"^[A-Z]_\d+_\d+", table_code):
+            parts = table_code.split("_", 2)
             if len(parts) >= 3:
                 table_code_with_dot = f"{parts[0]}_{parts[1]}.{parts[2]}"
-                table = session.query(TableVersion).filter(
-                    TableVersion.code == table_code_with_dot
-                ).first()
+                table = (
+                    session.query(TableVersion)
+                    .filter(TableVersion.code == table_code_with_dot)
+                    .first()
+                )
 
                 if table:
-                    return {
-                        'table_vid': table.tablevid,
-                        'code': table.code
-                    }
+                    return {"table_vid": table.tablevid, "code": table.code}
 
         # Try LIKE pattern as last resort (handles sub-tables like F_25.01.a)
-        table = session.query(TableVersion).filter(
-            TableVersion.code.like(f"{table_code}%")
-        ).order_by(TableVersion.code).first()
+        table = (
+            session.query(TableVersion)
+            .filter(TableVersion.code.like(f"{table_code}%"))
+            .order_by(TableVersion.code)
+            .first()
+        )
 
         if table:
-            return {
-                'table_vid': table.tablevid,
-                'code': table.code
-            }
+            return {"table_vid": table.tablevid, "code": table.code}
 
         return None
 
@@ -642,7 +539,7 @@ def _build_preconditions(
     precondition: Optional[str],
     context: Optional[Dict[str, Any]],
     operation_code: str,
-    engine
+    engine,
 ) -> tuple:
     """
     Build preconditions and precondition_variables sections.
@@ -666,30 +563,30 @@ def _build_preconditions(
 
     if precondition:
         # Extract variable code from precondition reference like {v_F_44_04}
-        match = re.match(r'\{v_([^}]+)\}', precondition)
+        match = re.match(r"\{v_([^}]+)\}", precondition)
         if match:
             table_code = match.group(1)
-    elif context and 'table' in context:
-        table_code = context['table']
+    elif context and "table" in context:
+        table_code = context["table"]
 
     if table_code:
         # Query database for actual variable ID and version
         table_info = _get_table_info(table_code, engine)
 
         if table_info:
-            precondition_var_id = table_info['table_vid']
-            version_id = table_info['table_vid']
+            precondition_var_id = table_info["table_vid"]
+            version_id = table_info["table_vid"]
             precondition_code = f"p_{precondition_var_id}"
 
             preconditions[precondition_code] = {
                 "ast": {
                     "class_name": "PreconditionItem",
                     "variable_id": precondition_var_id,
-                    "variable_code": table_code
+                    "variable_code": table_code,
                 },
                 "affected_operations": [operation_code],
                 "version_id": version_id,
-                "code": precondition_code
+                "code": precondition_code,
             }
 
             precondition_variables[str(precondition_var_id)] = "b"
@@ -713,17 +610,17 @@ def _extract_variables_from_ast(ast_dict: Dict[str, Any]) -> tuple:
     def extract_from_node(node):
         if isinstance(node, dict):
             # Check if this is a VarID node with data
-            if node.get('class_name') == 'VarID' and 'data' in node:
-                table = node.get('table')
+            if node.get("class_name") == "VarID" and "data" in node:
+                table = node.get("table")
                 if table:
                     if table not in variables_by_table:
                         variables_by_table[table] = {}
 
                     # Extract variable IDs and data types from AST data array
-                    for data_item in node['data']:
-                        if 'datapoint' in data_item:
-                            var_id = str(int(data_item['datapoint']))
-                            data_type = data_item.get('data_type', 'e')
+                    for data_item in node["data"]:
+                        if "datapoint" in data_item:
+                            var_id = str(int(data_item["datapoint"]))
+                            data_type = data_item.get("data_type", "e")
                             variables_by_table[table][var_id] = data_type
                             all_variables[var_id] = data_type
 
@@ -739,7 +636,9 @@ def _extract_variables_from_ast(ast_dict: Dict[str, Any]) -> tuple:
     return all_variables, variables_by_table
 
 
-def _add_coordinates_to_ast(ast_dict: Dict[str, Any], context: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+def _add_coordinates_to_ast(
+    ast_dict: Dict[str, Any], context: Optional[Dict[str, Any]]
+) -> Dict[str, Any]:
     """
     Add x/y/z coordinates to data entries in AST.
 
@@ -755,16 +654,16 @@ def _add_coordinates_to_ast(ast_dict: Dict[str, Any], context: Optional[Dict[str
     def add_coords_to_node(node):
         if isinstance(node, dict):
             # Handle VarID nodes with data arrays
-            if node.get('class_name') == 'VarID' and 'data' in node:
+            if node.get("class_name") == "VarID" and "data" in node:
                 # Get column information from context
                 cols = []
-                if context and 'columns' in context and context['columns']:
-                    cols = context['columns']
+                if context and "columns" in context and context["columns"]:
+                    cols = context["columns"]
 
                 # Group data entries by row to assign coordinates correctly
                 entries_by_row = {}
-                for data_entry in node['data']:
-                    row_code = data_entry.get('row', '')
+                for data_entry in node["data"]:
+                    row_code = data_entry.get("row", "")
                     if row_code not in entries_by_row:
                         entries_by_row[row_code] = []
                     entries_by_row[row_code].append(data_entry)
@@ -773,7 +672,7 @@ def _add_coordinates_to_ast(ast_dict: Dict[str, Any], context: Optional[Dict[str
                 rows = list(entries_by_row.keys())
                 for x_index, row_code in enumerate(rows, 1):
                     for data_entry in entries_by_row[row_code]:
-                        column_code = data_entry.get('column', '')
+                        column_code = data_entry.get("column", "")
 
                         # Find y coordinate based on column position in context
                         y_index = 1  # default
@@ -781,16 +680,19 @@ def _add_coordinates_to_ast(ast_dict: Dict[str, Any], context: Optional[Dict[str
                             y_index = cols.index(column_code) + 1
                         elif cols:
                             # Fallback to order in data
-                            row_columns = [entry.get('column', '') for entry in entries_by_row[row_code]]
+                            row_columns = [
+                                entry.get("column", "")
+                                for entry in entries_by_row[row_code]
+                            ]
                             if column_code in row_columns:
                                 y_index = row_columns.index(column_code) + 1
 
                         # Always add y coordinate
-                        data_entry['y'] = y_index
+                        data_entry["y"] = y_index
 
                         # Add x coordinate only if there are multiple rows
                         if len(rows) > 1:
-                            data_entry['x'] = x_index
+                            data_entry["x"] = x_index
 
                         # TODO: Add z coordinate for sheets when needed
 
@@ -805,4 +707,4 @@ def _add_coordinates_to_ast(ast_dict: Dict[str, Any], context: Optional[Dict[str
     # Create a deep copy to avoid modifying the original
     result = copy.deepcopy(ast_dict)
     add_coords_to_node(result)
-    return result
+    return result