pydpm_xl 0.1.39rc31__py3-none-any.whl → 0.2.0__py3-none-any.whl

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

@@ -11,14 +11,14 @@ 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 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.
@@ -45,19 +45,21 @@ def generate_complete_ast(
     try:
         # Import here to avoid circular imports
         from py_dpm.api import API
-        from py_dpm.db_utils import get_engine
+        from py_dpm.dpm.utils import get_engine
 
         # Initialize database connection if provided
         if connection_url or database_path:
             try:
-                engine = get_engine(database_path=database_path, connection_url=connection_url)
+                engine = 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
@@ -66,22 +68,21 @@ def generate_complete_ast(
 
         # Perform complete semantic validation with operand checking
         # This should populate all data fields on VarID nodes
-        semantic_result = api.semantic_validation(expression)
-
+        semantic_result = api.semantic_validation(expression, release_id=release_id)
 
         # Force data population if semantic validation completed successfully
-        if hasattr(api, 'AST') and api.AST and semantic_result:
+        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
+                from py_dpm.dpm_xl.ast.operands import OperandsChecking
+                from py_dpm.dpm.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:
+                    if hasattr(ast_obj, "children") and len(ast_obj.children) > 0:
                         child = ast_obj.children[0]
-                        if hasattr(child, 'expression'):
+                        if hasattr(child, "expression"):
                             return child.expression
                         else:
                             return child
@@ -94,33 +95,40 @@ def generate_complete_ast(
                     session=session,
                     expression=expression,
                     ast=inner_ast,
-                    release_id=release_id
+                    release_id=release_id,
                 )
 
                 # Apply the data from operand checker to VarID nodes
-                if hasattr(oc, 'data') and oc.data is not None:
+                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 (
+                            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)
+                                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))
+                                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))
+                                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]
 
@@ -132,22 +140,32 @@ def generate_complete_ast(
                                     # 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()]
+                                    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()]
+                                    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()]
+                                    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'
+                                        subset=[
+                                            "row_code",
+                                            "column_code",
+                                            "sheet_code",
+                                        ],
+                                        keep="first",
                                     )
 
                                     # Set the data attribute on the VarID node
@@ -155,14 +173,24 @@ def generate_complete_ast(
                                         node.data = filtered_data
 
                         # Recursively apply to child nodes
-                        for attr_name in ['children', 'left', 'right', 'operand', 'operands', 'expression', 'condition', 'then_expr', 'else_expr']:
+                        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__'):
+                                        if hasattr(item, "__class__"):
                                             apply_data_to_varids(item)
-                                elif attr_value and hasattr(attr_value, '__class__'):
+                                elif attr_value and hasattr(attr_value, "__class__"):
                                     apply_data_to_varids(attr_value)
 
                     # Apply data to all VarID nodes in the AST
@@ -172,12 +200,12 @@ def generate_complete_ast(
                 # Silently continue if data population fails
                 pass
 
-        if hasattr(api, 'AST') and api.AST is not None:
+        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:
+                if hasattr(ast_obj, "children") and len(ast_obj.children) > 0:
                     child = ast_obj.children[0]
-                    if hasattr(child, 'expression'):
+                    if hasattr(child, "expression"):
                         return child.expression, child.partial_selection
                     else:
                         return child, None
@@ -196,39 +224,39 @@ def generate_complete_ast(
             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)
+                    "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
+                "success": True,
+                "ast": ast_dict,
+                "context": context_dict,
+                "error": None,
+                "data_populated": data_populated,
+                "semantic_result": semantic_result,
             }
 
         else:
             return {
-                'success': False,
-                'ast': None,
-                'context': None,
-                'error': 'Semantic validation did not generate AST',
-                'data_populated': False
+                "success": False,
+                "ast": None,
+                "context": None,
+                "error": "Semantic validation did not generate AST",
+                "data_populated": False,
             }
 
     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 +265,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 +285,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 +305,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 +315,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 +333,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 +381,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 +400,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 +441,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 +464,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 +482,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 +494,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 +529,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 +545,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 +555,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 +608,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 +617,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 +661,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 +685,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 +732,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 +758,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 +776,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 +794,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 +802,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 +829,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