pydpm_xl 0.1.39rc29__py3-none-any.whl → 0.1.39rc31__py3-none-any.whl

py_dpm/Utils/ast_serialization.py

@@ -360,13 +360,26 @@ class ASTToJSONVisitor(NodeVisitor):
             'class_name': 'AggregationOp',
             'op': node.op,
             'operand': self.visit(node.operand),
-            'grouping_clause': None
         }
-        # Add grouping_clause if present
+        # Add grouping_clause if present and has actual components
         if hasattr(node, 'grouping_clause') and node.grouping_clause is not None:
-            result['grouping_clause'] = self.visit(node.grouping_clause)
+            gc = self.visit(node.grouping_clause)
+            # Only include grouping_clause if it has components
+            if gc and gc.get('components'):
+                result['grouping_clause'] = gc
         return result
 
+    def visit_GroupingClause(self, node):
+        """Visit GroupingClause nodes."""
+        components = getattr(node, 'components', None)
+        if components:
+            return {
+                'class_name': 'GroupingClause',
+                'components': components
+            }
+        # Return None for empty grouping clauses (will be filtered out)
+        return None
+
     def visit_ComplexNumericOp(self, node):
         """Visit ComplexNumericOp nodes (max, min)."""
         return {

py_dpm/__init__.py

@@ -41,7 +41,7 @@ Available packages:
 - pydpm.api: Main APIs for migration, syntax, and semantic analysis
 """
 
-__version__ = "0.1.39rc29"
+__version__ = "0.1.39rc31"
 __author__ = "MeaningfulData S.L."
 __email__ = "info@meaningfuldata.eu"
 __license__ = "GPL-3.0-or-later"

py_dpm/api/complete_ast.py

@@ -14,7 +14,12 @@ from typing import Dict, Any, Optional
 from py_dpm.Utils.ast_serialization import ASTToJSONVisitor
 
 
-def generate_complete_ast(expression: str, database_path: str = None, connection_url: str = None):
+def generate_complete_ast(
+    expression: str,
+    database_path: str = None,
+    connection_url: str = None,
+    release_id: Optional[int] = None
+):
     """
     Generate complete AST with all data fields, exactly like json_scripts examples.
 
@@ -25,6 +30,8 @@ def generate_complete_ast(expression: str, database_path: str = None, connection
         expression: DPM-XL expression string
         database_path: Path to SQLite database file (e.g., "./database.db")
         connection_url: SQLAlchemy connection URL for PostgreSQL (optional)
+        release_id: Optional release ID to filter database lookups by specific release.
+            If None, uses all available data (release-agnostic).
 
     Returns:
         dict: {
@@ -87,7 +94,7 @@ def generate_complete_ast(expression: str, database_path: str = None, connection
                     session=session,
                     expression=expression,
                     ast=inner_ast,
-                    release_id=None
+                    release_id=release_id
                 )
 
                 # Apply the data from operand checker to VarID nodes
@@ -246,7 +253,12 @@ def _check_data_fields_populated(ast_dict):
     return False
 
 
-def generate_complete_batch(expressions: list, database_path: str = None, connection_url: str = None):
+def generate_complete_batch(
+    expressions: list,
+    database_path: str = None,
+    connection_url: str = None,
+    release_id: Optional[int] = None
+):
     """
     Generate complete ASTs for multiple expressions.
 
@@ -254,20 +266,29 @@ def generate_complete_batch(expressions: list, database_path: str = None, connec
         expressions: List of DPM-XL expression strings
         database_path: Path to SQLite database file
         connection_url: SQLAlchemy connection URL for PostgreSQL (optional)
+        release_id: Optional release ID to filter database lookups by specific release.
+            If None, uses all available data (release-agnostic).
 
     Returns:
         list: List of result dictionaries
     """
     results = []
     for i, expr in enumerate(expressions):
-        result = generate_complete_ast(expr, database_path, connection_url)
+        result = generate_complete_ast(
+            expr, database_path, connection_url, release_id=release_id
+        )
         result['batch_index'] = i
         results.append(result)
     return results
 
 
 # Convenience function with cleaner interface
-def parse_with_data_fields(expression: str, database_path: str = None, connection_url: str = None):
+def parse_with_data_fields(
+    expression: str,
+    database_path: str = None,
+    connection_url: str = None,
+    release_id: Optional[int] = None
+):
     """
     Simple function to parse expression and get AST with data fields.
 
@@ -275,11 +296,15 @@ def parse_with_data_fields(expression: str, database_path: str = None, connectio
         expression: DPM-XL expression string
         database_path: Path to SQLite database file
         connection_url: SQLAlchemy connection URL for PostgreSQL (optional)
+        release_id: Optional release ID to filter database lookups by specific release.
+            If None, uses all available data (release-agnostic).
 
     Returns:
         dict: AST dictionary with data fields, or None if failed
     """
-    result = generate_complete_ast(expression, database_path, connection_url)
+    result = generate_complete_ast(
+        expression, database_path, connection_url, release_id=release_id
+    )
     return result['ast'] if result['success'] else None
 
 
@@ -296,6 +321,7 @@ def generate_enriched_ast(
     operation_code: Optional[str] = None,
     table_context: Optional[Dict[str, Any]] = None,
     precondition: Optional[str] = None,
+    release_id: Optional[int] = None,
 ) -> Dict[str, Any]:
     """
     Generate enriched, engine-ready AST from DPM-XL expression.
@@ -311,6 +337,8 @@ def generate_enriched_ast(
         operation_code: Optional operation code (defaults to "default_code")
         table_context: Optional table context dict with keys: 'table', 'columns', 'rows', 'sheets', 'default', 'interval'
         precondition: Optional precondition variable reference (e.g., {v_F_44_04})
+        release_id: Optional release ID to filter database lookups by specific release.
+            If None, uses all available data (release-agnostic).
 
     Returns:
         dict: {
@@ -321,7 +349,9 @@ def generate_enriched_ast(
     """
     try:
         # Generate complete AST first
-        complete_result = generate_complete_ast(expression, database_path, connection_url)
+        complete_result = generate_complete_ast(
+            expression, database_path, connection_url, release_id=release_id
+        )
 
         if not complete_result['success']:
             return {

py_dpm/client.py

@@ -6,26 +6,38 @@ import os
 import sys
 import pandas as pd
 
-from py_dpm.api import API
+from py_dpm.api import API, SemanticAPI
+from py_dpm.api.semantic import SemanticValidationResult
 from py_dpm.api.operation_scopes import OperationScopesAPI
 from py_dpm.migration import run_migration
-from py_dpm.Utils.tokens import CODE, ERROR, ERROR_CODE, EXPRESSION, OP_VERSION_ID, STATUS, \
-    STATUS_CORRECT, STATUS_UNKNOWN, VALIDATIONS, \
-    VALIDATION_TYPE, \
-    VARIABLES
+from py_dpm.Utils.tokens import (
+    CODE,
+    ERROR,
+    ERROR_CODE,
+    EXPRESSION,
+    OP_VERSION_ID,
+    STATUS,
+    STATUS_CORRECT,
+    STATUS_UNKNOWN,
+    VALIDATIONS,
+    VALIDATION_TYPE,
+    VARIABLES,
+)
 from py_dpm.Exceptions.exceptions import SemanticError
 
 
 console = Console()
 
+
 @click.group()
 @click.version_option()
 def main():
     """pyDPM CLI - A command line interface for pyDPM"""
     pass
 
+
 @main.command()
-@click.argument('access_file', type=click.Path(exists=True))
+@click.argument("access_file", type=click.Path(exists=True))
 def migrate_access(access_file: str):
     """
     Migrates data from an Access database to a SQLite database.
@@ -44,45 +56,93 @@ def migrate_access(access_file: str):
 
 
 @main.command()
-@click.argument('expression', type=str)
-def semantic(expression: str):
+@click.argument("expression", type=str)
+@click.option(
+    "--release-id", type=int, help="Release ID to use for validation", default=None
+)
+@click.option(
+    "--dpm-version",
+    type=str,
+    help="DPM Version (e.g. 4.2) to use for validation",
+    default=None,
+)
+def semantic(expression: str, release_id: int, dpm_version: str):
     """
     Semantically analyses the input expression by applying the syntax validation, the operands checking, the data type
     validation and the structure validation
     :param expression: Expression to be analysed
     :param release_id: ID of the release used. If None, gathers the live release
+    :param dpm_version: Version code of the release used.
     Used only in DPM-ML generation
     :return if Return_data is False, any Symbol, else data extracted from DB based on operands cell references
     """
 
+    if release_id is not None and dpm_version is not None:
+        raise click.UsageError("Cannot provide both --release-id and --dpm-version")
+
     error_code = ""
     validation_type = STATUS_UNKNOWN
 
-    api = API()
+    semantic_api = SemanticAPI()
+
+    if dpm_version:
+        from py_dpm.models import Release
+
+        release_id = (
+            semantic_api.session.query(Release.releaseid)
+            .filter(Release.code == dpm_version)
+            .scalar()
+        )
+        if release_id is None:
+            console.print(
+                f"Error: DPM version '{dpm_version}' not found.", style="bold red"
+            )
+            sys.exit(1)
+
     try:
         validation_type = "OTHER"
-        api.semantic_validation(expression)
-        status = 200
-        message_error = ''
+        # Validate using the semantic API with release_id support
+        result: SemanticValidationResult = semantic_api.validate_expression(
+            expression, release_id=release_id
+        )
+
+        if result.is_valid:
+            status = 200
+            message_error = ""
+        else:
+            status = 500
+            message_error = result.error_message
+            error_code = result.error_code or 1
+
     except Exception as error:
         status = 500
         message_error = str(error)
         error_code = 1
+
+    # Clean up resources
+    # semantic_api destructor handles this, but we can be explicit if needed
+
     message_response = {
         ERROR: message_error,
         ERROR_CODE: error_code,
         VALIDATION_TYPE: validation_type,
     }
-    api.session.close()
+
     if error_code and status == 500:
-        console.print(f"Semantic validation failed for expression: {expression}.", style="bold red")
+        console.print(
+            f"Semantic validation failed for expression: {expression}.",
+            style="bold red",
+        )
+        if message_error:
+            console.print(f"Error: {message_error}", style="red")
     else:
         console.log(f"Semantic validation completed for expression: {expression}.")
         console.print(f"Status: {status}", style="bold green")
     return status
 
+
 @main.command()
-@click.argument('expression', type=str)
+@click.argument("expression", type=str)
 def syntax(expression: str):
     """Perform syntactic analysis on a DPM expression."""
 
@@ -106,11 +166,21 @@ def syntax(expression: str):
 
 
 @main.command()
-@click.argument('expression', type=str, required=False)
-@click.option('--operation-vid', type=int, help='Operation version ID to associate scopes with')
-@click.option('--tables', type=str, help='Comma-separated table VIDs (for low-level mode)')
-@click.option('--preconditions', type=str, help='Comma-separated precondition item codes')
-@click.option('--release-id', type=int, help='Release ID to filter modules (defaults to last release)')
+@click.argument("expression", type=str, required=False)
+@click.option(
+    "--operation-vid", type=int, help="Operation version ID to associate scopes with"
+)
+@click.option(
+    "--tables", type=str, help="Comma-separated table VIDs (for low-level mode)"
+)
+@click.option(
+    "--preconditions", type=str, help="Comma-separated precondition item codes"
+)
+@click.option(
+    "--release-id",
+    type=int,
+    help="Release ID to filter modules (defaults to last release)",
+)
 def calculate_scopes(expression, operation_vid, tables, preconditions, release_id):
     """
     Calculate operation scopes from a DPM-XL expression or table VIDs.
@@ -133,12 +203,14 @@ def calculate_scopes(expression, operation_vid, tables, preconditions, release_i
                 expression=expression,
                 operation_version_id=operation_vid,
                 release_id=release_id,
-                read_only=True
+                read_only=True,
             )
         elif tables:
             # Low-level mode with table VIDs
-            table_vids = [int(t.strip()) for t in tables.split(',')]
-            precondition_items = [p.strip() for p in preconditions.split(',')] if preconditions else []
+            table_vids = [int(t.strip()) for t in tables.split(",")]
+            precondition_items = (
+                [p.strip() for p in preconditions.split(",")] if preconditions else []
+            )
 
             # Always use read_only=True for CLI to prevent accidental database modifications
             result = api.calculate_scopes(
@@ -146,15 +218,20 @@ def calculate_scopes(expression, operation_vid, tables, preconditions, release_i
                 tables_vids=table_vids,
                 precondition_items=precondition_items,
                 release_id=release_id,
-                read_only=True
+                read_only=True,
             )
         else:
-            console.print("Error: Either EXPRESSION or --tables must be provided", style="bold red")
+            console.print(
+                "Error: Either EXPRESSION or --tables must be provided",
+                style="bold red",
+            )
             sys.exit(1)
 
         # Check for errors
         if result.has_error:
-            console.print(f"Error calculating scopes: {result.error_message}", style="bold red")
+            console.print(
+                f"Error calculating scopes: {result.error_message}", style="bold red"
+            )
             sys.exit(1)
 
         # Display summary
@@ -168,9 +245,16 @@ def calculate_scopes(expression, operation_vid, tables, preconditions, release_i
         summary_table.add_row("Total Scopes:", str(result.total_scopes))
         summary_table.add_row("Existing Scopes:", str(len(result.existing_scopes)))
         summary_table.add_row("New Scopes:", str(len(result.new_scopes)))
-        summary_table.add_row("Cross-Module:", "Yes" if result.is_cross_module else "No")
-        summary_table.add_row("Module Versions:", ', '.join(map(str, result.module_versions)))
-        summary_table.add_row("Release ID:", str(result.release_id) if result.release_id else "Default (Last)")
+        summary_table.add_row(
+            "Cross-Module:", "Yes" if result.is_cross_module else "No"
+        )
+        summary_table.add_row(
+            "Module Versions:", ", ".join(map(str, result.module_versions))
+        )
+        summary_table.add_row(
+            "Release ID:",
+            str(result.release_id) if result.release_id else "Default (Last)",
+        )
 
         if result.expression:
             summary_table.add_row("Expression:", result.expression)
@@ -189,29 +273,37 @@ def calculate_scopes(expression, operation_vid, tables, preconditions, release_i
             scopes_table.add_column("From Date", justify="center")
 
             for scope in result.existing_scopes:
-                module_vids = [str(comp.modulevid) for comp in scope.operation_scope_compositions]
+                module_vids = [
+                    str(comp.modulevid) for comp in scope.operation_scope_compositions
+                ]
                 scope_type = "Cross-Module" if len(module_vids) > 1 else "Intra-Module"
-                from_date = str(scope.fromsubmissiondate) if scope.fromsubmissiondate else "N/A"
+                from_date = (
+                    str(scope.fromsubmissiondate) if scope.fromsubmissiondate else "N/A"
+                )
 
                 scopes_table.add_row(
                     str(scope.operationscopeid),
                     "[yellow]Existing[/yellow]",
                     ", ".join(module_vids),
                     scope_type,
-                    from_date
+                    from_date,
                 )
 
             for scope in result.new_scopes:
-                module_vids = [str(comp.modulevid) for comp in scope.operation_scope_compositions]
+                module_vids = [
+                    str(comp.modulevid) for comp in scope.operation_scope_compositions
+                ]
                 scope_type = "Cross-Module" if len(module_vids) > 1 else "Intra-Module"
-                from_date = str(scope.fromsubmissiondate) if scope.fromsubmissiondate else "N/A"
+                from_date = (
+                    str(scope.fromsubmissiondate) if scope.fromsubmissiondate else "N/A"
+                )
 
                 scopes_table.add_row(
                     "[dim]New (not committed)[/dim]",
                     "[green]New[/green]",
                     ", ".join(module_vids),
                     scope_type,
-                    from_date
+                    from_date,
                 )
 
             console.print(scopes_table)
@@ -230,20 +322,28 @@ def calculate_scopes(expression, operation_vid, tables, preconditions, release_i
                 from py_dpm.models import ModuleVersion
 
                 for module_vid in result.module_versions:
-                    module_df = ModuleVersion.get_module_version_by_vid(api.session, module_vid)
+                    module_df = ModuleVersion.get_module_version_by_vid(
+                        api.session, module_vid
+                    )
                     if not module_df.empty:
                         module = module_df.iloc[0]
                         modules_table.add_row(
-                            str(module['ModuleVID']),
-                            str(module['Code']),
-                            str(module['Name']),
-                            str(module['FromReferenceDate']),
-                            str(module['ToReferenceDate']) if module['ToReferenceDate'] is not pd.NaT else "Open"
+                            str(module["ModuleVID"]),
+                            str(module["Code"]),
+                            str(module["Name"]),
+                            str(module["FromReferenceDate"]),
+                            (
+                                str(module["ToReferenceDate"])
+                                if module["ToReferenceDate"] is not pd.NaT
+                                else "Open"
+                            ),
                         )
 
                 console.print(modules_table)
 
-        console.print("\n[bold green]✓ Scope calculation completed successfully[/bold green]\n")
+        console.print(
+            "\n[bold green]✓ Scope calculation completed successfully[/bold green]\n"
+        )
 
     except SemanticError as e:
         console.print(f"Semantic error: {str(e)}", style="bold red")
@@ -256,9 +356,13 @@ def calculate_scopes(expression, operation_vid, tables, preconditions, release_i
 
 
 @main.command()
-@click.argument('expression', type=str, required=False)
-@click.option('--operation-vid', type=int, help='Operation version ID')
-@click.option('--release-id', type=int, help='Release ID to filter modules (defaults to last release)')
+@click.argument("expression", type=str, required=False)
+@click.option("--operation-vid", type=int, help="Operation version ID")
+@click.option(
+    "--release-id",
+    type=int,
+    help="Release ID to filter modules (defaults to last release)",
+)
 def get_scopes_metadata(expression, operation_vid, release_id):
     """
     Get operation scopes with detailed module metadata.
@@ -276,15 +380,17 @@ def get_scopes_metadata(expression, operation_vid, release_id):
         # Determine mode: expression-based or operation-vid-based
         if expression:
             scopes = api.get_scopes_with_metadata_from_expression(
-                expression=expression,
-                release_id=release_id
+                expression=expression, release_id=release_id
             )
             mode = "expression"
         elif operation_vid:
             scopes = api.get_scopes_with_metadata(operation_version_id=operation_vid)
             mode = "operation_vid"
         else:
-            console.print("Error: Either EXPRESSION or --operation-vid must be provided", style="bold red")
+            console.print(
+                "Error: Either EXPRESSION or --operation-vid must be provided",
+                style="bold red",
+            )
             sys.exit(1)
 
         # Display results
@@ -292,7 +398,9 @@ def get_scopes_metadata(expression, operation_vid, release_id):
             console.print("\n[yellow]No scopes found[/yellow]\n")
             return
 
-        console.print(f"\n[bold cyan]Operation Scopes with Metadata[/bold cyan] (Total: {len(scopes)})")
+        console.print(
+            f"\n[bold cyan]Operation Scopes with Metadata[/bold cyan] (Total: {len(scopes)})"
+        )
         console.print("=" * 80)
 
         for idx, scope in enumerate(scopes, 1):
@@ -314,7 +422,9 @@ def get_scopes_metadata(expression, operation_vid, release_id):
 
             # Module versions
             if scope.module_versions:
-                console.print(f"\n  [bold]Modules ({len(scope.module_versions)}):[/bold]")
+                console.print(
+                    f"\n  [bold]Modules ({len(scope.module_versions)}):[/bold]"
+                )
 
                 modules_table = Table(show_header=True, header_style="bold magenta")
                 modules_table.add_column("Module VID", justify="right")
@@ -328,15 +438,29 @@ def get_scopes_metadata(expression, operation_vid, release_id):
                     modules_table.add_row(
                         str(module.module_vid),
                         module.code,
-                        module.name[:40] + "..." if len(module.name) > 40 else module.name,
+                        (
+                            module.name[:40] + "..."
+                            if len(module.name) > 40
+                            else module.name
+                        ),
                         module.version_number,
-                        str(module.from_reference_date) if module.from_reference_date else "N/A",
-                        str(module.to_reference_date) if module.to_reference_date else "Open"
+                        (
+                            str(module.from_reference_date)
+                            if module.from_reference_date
+                            else "N/A"
+                        ),
+                        (
+                            str(module.to_reference_date)
+                            if module.to_reference_date
+                            else "Open"
+                        ),
                     )
 
                 console.print(modules_table)
 
-        console.print("\n[bold green]✓ Scopes metadata retrieved successfully[/bold green]\n")
+        console.print(
+            "\n[bold green]✓ Scopes metadata retrieved successfully[/bold green]\n"
+        )
 
     except Exception as e:
         console.print(f"Error: {str(e)}", style="bold red")
@@ -346,9 +470,13 @@ def get_scopes_metadata(expression, operation_vid, release_id):
 
 
 @main.command()
-@click.argument('expression', type=str, required=False)
-@click.option('--operation-vid', type=int, help='Operation version ID')
-@click.option('--release-id', type=int, help='Release ID to filter modules (defaults to last release)')
+@click.argument("expression", type=str, required=False)
+@click.option("--operation-vid", type=int, help="Operation version ID")
+@click.option(
+    "--release-id",
+    type=int,
+    help="Release ID to filter modules (defaults to last release)",
+)
 def get_tables_metadata(expression, operation_vid, release_id):
     """
     Get tables from operation scopes with metadata.
@@ -366,13 +494,15 @@ def get_tables_metadata(expression, operation_vid, release_id):
         # Determine mode: expression-based or operation-vid-based
         if expression:
             tables = api.get_tables_with_metadata_from_expression(
-                expression=expression,
-                release_id=release_id
+                expression=expression, release_id=release_id
             )
         elif operation_vid:
             tables = api.get_tables_with_metadata(operation_version_id=operation_vid)
         else:
-            console.print("Error: Either EXPRESSION or --operation-vid must be provided", style="bold red")
+            console.print(
+                "Error: Either EXPRESSION or --operation-vid must be provided",
+                style="bold red",
+            )
             sys.exit(1)
 
         # Display results
@@ -380,7 +510,9 @@ def get_tables_metadata(expression, operation_vid, release_id):
             console.print("\n[yellow]No tables found[/yellow]\n")
             return
 
-        console.print(f"\n[bold cyan]Tables with Metadata[/bold cyan] (Total: {len(tables)})")
+        console.print(
+            f"\n[bold cyan]Tables with Metadata[/bold cyan] (Total: {len(tables)})"
+        )
         console.print("=" * 80)
 
         tables_table = Table(show_header=True, header_style="bold magenta")
@@ -391,17 +523,23 @@ def get_tables_metadata(expression, operation_vid, release_id):
 
         for table in tables:
             # Truncate long descriptions
-            description = table.description[:60] + "..." if len(table.description) > 60 else table.description
+            description = (
+                table.description[:60] + "..."
+                if len(table.description) > 60
+                else table.description
+            )
 
             tables_table.add_row(
                 str(table.table_vid),
                 table.code,
                 table.name[:40] + "..." if len(table.name) > 40 else table.name,
-                description
+                description,
             )
 
         console.print(tables_table)
-        console.print("\n[bold green]✓ Tables metadata retrieved successfully[/bold green]\n")
+        console.print(
+            "\n[bold green]✓ Tables metadata retrieved successfully[/bold green]\n"
+        )
 
     except Exception as e:
         console.print(f"Error: {str(e)}", style="bold red")
@@ -411,10 +549,14 @@ def get_tables_metadata(expression, operation_vid, release_id):
 
 
 @main.command()
-@click.argument('expression', type=str, required=False)
-@click.option('--operation-vid', type=int, help='Operation version ID')
-@click.option('--table-vid', type=int, help='Filter by specific table VID')
-@click.option('--release-id', type=int, help='Release ID to filter modules (defaults to last release)')
+@click.argument("expression", type=str, required=False)
+@click.option("--operation-vid", type=int, help="Operation version ID")
+@click.option("--table-vid", type=int, help="Filter by specific table VID")
+@click.option(
+    "--release-id",
+    type=int,
+    help="Release ID to filter modules (defaults to last release)",
+)
 def get_headers_metadata(expression, operation_vid, table_vid, release_id):
     """
     Get headers from operation scopes with metadata.
@@ -433,17 +575,17 @@ def get_headers_metadata(expression, operation_vid, table_vid, release_id):
         # Determine mode: expression-based or operation-vid-based
         if expression:
             headers = api.get_headers_with_metadata_from_expression(
-                expression=expression,
-                table_vid=table_vid,
-                release_id=release_id
+                expression=expression, table_vid=table_vid, release_id=release_id
             )
         elif operation_vid:
             headers = api.get_headers_with_metadata(
-                operation_version_id=operation_vid,
-                table_vid=table_vid
+                operation_version_id=operation_vid, table_vid=table_vid
             )
         else:
-            console.print("Error: Either EXPRESSION or --operation-vid must be provided", style="bold red")
+            console.print(
+                "Error: Either EXPRESSION or --operation-vid must be provided",
+                style="bold red",
+            )
             sys.exit(1)
 
         # Display results
@@ -451,7 +593,9 @@ def get_headers_metadata(expression, operation_vid, table_vid, release_id):
             console.print("\n[yellow]No headers found[/yellow]\n")
             return
 
-        console.print(f"\n[bold cyan]Headers with Metadata[/bold cyan] (Total: {len(headers)})")
+        console.print(
+            f"\n[bold cyan]Headers with Metadata[/bold cyan] (Total: {len(headers)})"
+        )
         if table_vid:
             console.print(f"[dim]Filtered by Table VID: {table_vid}[/dim]")
         console.print("=" * 80)
@@ -469,11 +613,13 @@ def get_headers_metadata(expression, operation_vid, table_vid, release_id):
                 str(header.table_vid) if header.table_vid else "N/A",
                 header.code,
                 header.label[:50] + "..." if len(header.label) > 50 else header.label,
-                header.header_type
+                header.header_type,
             )
 
         console.print(headers_table)
-        console.print("\n[bold green]✓ Headers metadata retrieved successfully[/bold green]\n")
+        console.print(
+            "\n[bold green]✓ Headers metadata retrieved successfully[/bold green]\n"
+        )
 
     except Exception as e:
         console.print(f"Error: {str(e)}", style="bold red")
@@ -482,5 +628,5 @@ def get_headers_metadata(expression, operation_vid, table_vid, release_id):
         api.session.close()
 
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    main()

{pydpm_xl-0.1.39rc29.dist-info → pydpm_xl-0.1.39rc31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydpm_xl
-Version: 0.1.39rc29
+Version: 0.1.39rc31
 Summary: Python library for DPM-XL data processing and analysis
 Author-email: "MeaningfulData S.L." <info@meaningfuldata.eu>
 License: GPL-3.0-or-later
@@ -25,7 +25,7 @@ Requires-Dist: antlr4-python3-runtime<4.9.3,>=4.9.2
 Requires-Dist: pyodbc<5.2.0,>=5.1.0
 Requires-Dist: click<8.2.0,>=8.1.6
 Requires-Dist: python-dotenv<1.1.0,>=1.0.1
-Requires-Dist: psycopg2<3.0.0,>=2.9.0
+Requires-Dist: psycopg2-binary<3.0.0,>=2.9.0
 Provides-Extra: test
 Requires-Dist: pytest<8.0.0,>=7.4.0; extra == "test"
 Requires-Dist: pytest-cov<5.0.0,>=4.1.0; extra == "test"

{pydpm_xl-0.1.39rc29.dist-info → pydpm_xl-0.1.39rc31.dist-info}/RECORD

@@ -1,5 +1,5 @@
-py_dpm/__init__.py,sha256=mHCg5ux9mRv69Wp72Tulb994Kb5PQhpr_TS_pl8WMwU,1863
-py_dpm/client.py,sha256=DspAS6lVLh62nLlyOy4UEBy00GLR0bb9Wbd6hOZ6bHY,19491
+py_dpm/__init__.py,sha256=Ka4t1a-16Iht1Iqn-XfNPTJuUt9FbyFX_3SCDdabdZQ,1863
+py_dpm/client.py,sha256=f-D3-5-tNpBM2fr5H8ImdwZM5hyuqfCXJRJd66euHU8,22279
 py_dpm/data_handlers.py,sha256=_aJqkyflJr1oNsOQ24nB9yzfrpxu28NPrpoil2aAm58,4395
 py_dpm/db_utils.py,sha256=f0da6FT7HusGpLfGen4fceSvcojW4bzrp5sucgt6XVQ,7822
 py_dpm/migration.py,sha256=ivO_ObvKzVomTns6qfo-o5FuciWxkXbMd_gJ4_tu7Xc,14110
@@ -35,7 +35,7 @@ py_dpm/Operators/TimeOperators.py,sha256=klcFIYFonGVRNhr66Ipu1lwOr9CxzDGIbA3QQLm
 py_dpm/Operators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 py_dpm/Utils/ValidationsGenerationUtils.py,sha256=1yINJ_ANqr9BbIDdPm4WxRG2EQu0yaRICikYG1nIhzs,22652
 py_dpm/Utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-py_dpm/Utils/ast_serialization.py,sha256=ldCTenu-BMIccOzhSYtKupmEVzjWdXSAr-XUWfwNT9A,31961
+py_dpm/Utils/ast_serialization.py,sha256=c23qwwGtjDJgOxoOo41g4p7CYdbkVPz3q_Q6KssMSIU,32462
 py_dpm/Utils/operands_mapping.py,sha256=CDWvoKxh-nBcEKMxrUmMnaCveE8dExjeuFUa-lgK8Rg,2239
 py_dpm/Utils/operator_mapping.py,sha256=SK8utWaUaQJybSmErkF_2blzUIgiVOUNGFozIk7dBg8,1926
 py_dpm/Utils/tokens.py,sha256=VRIrPDi5ttwgH-on5Qt4-l4ho4bLA755-nfTalponcA,3496
@@ -47,7 +47,7 @@ py_dpm/ValidationsGeneration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 py_dpm/ValidationsGeneration/auxiliary_functions.py,sha256=4msDLINbwNb4gTc05x_351eb_VIra1H0lWE1hPijlVI,4187
 py_dpm/api/__init__.py,sha256=41ILMv8oQ9mmw_zkIhRHVBnfYi1OQYEAFWqyqc3O8_U,6986
 py_dpm/api/ast_generator.py,sha256=HjosdS1CkguPJDjp2JUqzO7WaRCS2GjXKuFgQXQkkPg,16143
-py_dpm/api/complete_ast.py,sha256=_PMwIGwUqSzw8kPo0mgHQPrl5V9oTMIJlTY6Nq2jkx8,28953
+py_dpm/api/complete_ast.py,sha256=8hMPoVyVOHXIR5Qm8TGUuva8rONntN-TJoFQHU0ElW8,29892
 py_dpm/api/data_dictionary.py,sha256=0k-tz0DNP1gZXlCA4EX9BoWHq2RB7nDnlsxRfbxNwow,33083
 py_dpm/api/data_dictionary_validation.py,sha256=OtvErzLtDMryoxdO5ktACjvGWeDEqG6SXuvuJyzKdys,23495
 py_dpm/api/migration.py,sha256=LW8V-sq9iBAuXUHWPGqWl-tvxz2vAGUvIYyZLtgfjKA,2512
@@ -88,9 +88,9 @@ py_dpm/views/precondition_info.sql,sha256=l24U8c6NtwFcUDFwb2FqH9h0xgpoi9WbvsKUgJ
 py_dpm/views/report_type_operand_reference_info.sql,sha256=_lBK9HQILk9yLD7cW9Ieud-vfTc-KQiU3WGAnN6LuNY,977
 py_dpm/views/subcategory_info.sql,sha256=V8UZiGjicmOWfBEHX2v6ktSMR4r_f1YiGD_LeN9Gn6o,812
 py_dpm/views/table_info.sql,sha256=htRXIVJya44CZAqjO5sVaJJwiQBQ30oiLFFu5DiBpR4,793
-pydpm_xl-0.1.39rc29.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pydpm_xl-0.1.39rc29.dist-info/METADATA,sha256=_KHZGTtkz50qVANC29LNEe63THXegD9lnUkfCWYkZWE,1592
-pydpm_xl-0.1.39rc29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pydpm_xl-0.1.39rc29.dist-info/entry_points.txt,sha256=W9j5xCzgvdfzOKSfEpkk2jSRhEcpmXZUVMwHrsEFAbY,45
-pydpm_xl-0.1.39rc29.dist-info/top_level.txt,sha256=495PvWZRoKl2NvbQU25W7dqWIBHqY-mFMPt83uxPpcM,7
-pydpm_xl-0.1.39rc29.dist-info/RECORD,,
+pydpm_xl-0.1.39rc31.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pydpm_xl-0.1.39rc31.dist-info/METADATA,sha256=TLfn-srr0mIT5UNqwsL_46ewXN9GsuO4M_RgaiueiF0,1599
+pydpm_xl-0.1.39rc31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pydpm_xl-0.1.39rc31.dist-info/entry_points.txt,sha256=W9j5xCzgvdfzOKSfEpkk2jSRhEcpmXZUVMwHrsEFAbY,45
+pydpm_xl-0.1.39rc31.dist-info/top_level.txt,sha256=495PvWZRoKl2NvbQU25W7dqWIBHqY-mFMPt83uxPpcM,7
+pydpm_xl-0.1.39rc31.dist-info/RECORD,,