pydpm_xl 0.1.10__py3-none-any.whl

py_dpm/api/semantic.py

@@ -0,0 +1,224 @@
+from typing import Dict, Any, Optional
+from dataclasses import dataclass
+
+# Import directly to avoid circular imports
+from antlr4 import CommonTokenStream, InputStream
+from py_dpm.grammar.dist.dpm_xlLexer import dpm_xlLexer
+from py_dpm.grammar.dist.dpm_xlParser import dpm_xlParser
+from py_dpm.grammar.dist.listeners import DPMErrorListener
+from py_dpm.AST.ASTConstructor import ASTVisitor
+from py_dpm.AST.check_operands import OperandsChecking
+from py_dpm.semantics import SemanticAnalyzer
+from py_dpm.db_utils import get_session, get_engine
+from py_dpm.Exceptions.exceptions import SemanticError
+
+
+@dataclass
+class SemanticValidationResult:
+    """
+    Result of semantic validation.
+    
+    Attributes:
+        is_valid (bool): Whether the semantic validation passed
+        error_message (Optional[str]): Error message if validation failed
+        error_code (Optional[str]): Error code if validation failed
+        expression (str): The original expression that was validated
+        validation_type (str): Type of validation performed
+        results (Optional[Any]): Additional results from semantic analysis
+    """
+    is_valid: bool
+    error_message: Optional[str]
+    error_code: Optional[str]
+    expression: str
+    validation_type: str
+    results: Optional[Any] = None
+
+
+class SemanticAPI:
+    """
+    API for DPM-XL semantic validation and analysis.
+    
+    This class provides methods to perform semantic analysis on DPM-XL expressions,
+    including operand checking, data type validation, and structure validation.
+    """
+    
+    def __init__(self):
+        """Initialize the Semantic API."""
+        get_engine()
+        self.session = get_session()
+        self.error_listener = DPMErrorListener()
+        self.visitor = ASTVisitor()
+    
+    def validate_expression(self, expression: str) -> SemanticValidationResult:
+        """
+        Perform semantic validation on a DPM-XL expression.
+        
+        This includes syntax validation, operands checking, data type validation,
+        and structure validation.
+        
+        Args:
+            expression (str): The DPM-XL expression to validate
+            
+        Returns:
+            SemanticValidationResult: Result containing validation status and details
+            
+        Example:
+            >>> from pydpm.api import SemanticAPI
+            >>> semantic = SemanticAPI()
+            >>> result = semantic.validate_expression("{tC_01.00, r0100, c0010} + {tC_01.00, r0200, c0010}")
+            >>> print(result.is_valid)
+            True
+        """
+        try:
+            # Parse expression to AST
+            input_stream = InputStream(expression)
+            lexer = dpm_xlLexer(input_stream)
+            lexer._listeners = [self.error_listener]
+            token_stream = CommonTokenStream(lexer)
+            
+            parser = dpm_xlParser(token_stream)
+            parser._listeners = [self.error_listener]
+            parse_tree = parser.start()
+            
+            if parser._syntaxErrors > 0:
+                return SemanticValidationResult(
+                    is_valid=False,
+                    error_message="Syntax errors detected",
+                    error_code="SYNTAX_ERROR",
+                    expression=expression,
+                    validation_type="SEMANTIC"
+                )
+            
+            # Generate AST
+            ast = self.visitor.visit(parse_tree)
+            
+            # Perform semantic analysis
+            oc = OperandsChecking(session=self.session, expression=expression, ast=ast, release_id=None)
+            semanticAnalysis = SemanticAnalyzer.InputAnalyzer(expression)
+            
+            semanticAnalysis.data = oc.data
+            semanticAnalysis.key_components = oc.key_components
+            semanticAnalysis.open_keys = oc.open_keys
+            semanticAnalysis.preconditions = oc.preconditions
+            
+            results = semanticAnalysis.visit(ast)
+            
+            return SemanticValidationResult(
+                is_valid=True,
+                error_message=None,
+                error_code=None,
+                expression=expression,
+                validation_type="SEMANTIC",
+                results=results
+            )
+            
+        except SemanticError as e:
+            return SemanticValidationResult(
+                is_valid=False,
+                error_message=str(e),
+                error_code=getattr(e, 'code', None),
+                expression=expression,
+                validation_type="SEMANTIC"
+            )
+        except Exception as e:
+            return SemanticValidationResult(
+                is_valid=False,
+                error_message=str(e),
+                error_code="UNKNOWN",
+                expression=expression,
+                validation_type="SEMANTIC"
+            )
+    
+    def analyze_expression(self, expression: str) -> Dict[str, Any]:
+        """
+        Perform detailed semantic analysis on a DPM-XL expression.
+        
+        Args:
+            expression (str): The DPM-XL expression to analyze
+            
+        Returns:
+            Dict[str, Any]: Detailed analysis results
+            
+        Raises:
+            Exception: If analysis fails
+            
+        Example:
+            >>> from pydpm.api import SemanticAPI
+            >>> semantic = SemanticAPI()
+            >>> analysis = semantic.analyze_expression("{tC_01.00, r0100, c0010}")
+        """
+        result = self.validate_expression(expression)
+        
+        if not result.is_valid:
+            raise Exception(f"Semantic analysis failed: {result.error_message}")
+        
+        # Extract additional analysis information
+        analysis = {
+            'expression': expression,
+            'is_valid': True,
+            'results': result.results,
+            'data_types': getattr(result.results, 'type', None) if result.results else None,
+            'components': getattr(result.results, 'components', None) if result.results else None
+        }
+        
+        return analysis
+    
+    def is_valid_semantics(self, expression: str) -> bool:
+        """
+        Quick check if expression has valid semantics.
+        
+        Args:
+            expression (str): The DPM-XL expression to check
+            
+        Returns:
+            bool: True if semantics are valid, False otherwise
+            
+        Example:
+            >>> from pydpm.api import SemanticAPI
+            >>> semantic = SemanticAPI()
+            >>> is_valid = semantic.is_valid_semantics("{tC_01.00, r0100, c0010}")
+        """
+        result = self.validate_expression(expression)
+        return result.is_valid
+    
+    def __del__(self):
+        """Clean up resources."""
+        if hasattr(self, 'session'):
+            self.session.close()
+
+
+# Convenience functions for direct usage
+def validate_expression(expression: str) -> SemanticValidationResult:
+    """
+    Convenience function to validate DPM-XL expression semantics.
+    
+    Args:
+        expression (str): The DPM-XL expression to validate
+        
+    Returns:
+        SemanticValidationResult: Result containing validation status and details
+        
+    Example:
+        >>> from pydpm.api.semantic import validate_expression
+        >>> result = validate_expression("{tC_01.00, r0100, c0010}")
+    """
+    api = SemanticAPI()
+    return api.validate_expression(expression)
+
+
+def is_valid_semantics(expression: str) -> bool:
+    """
+    Convenience function to check if expression has valid semantics.
+    
+    Args:
+        expression (str): The DPM-XL expression to check
+        
+    Returns:
+        bool: True if semantics are valid, False otherwise
+        
+    Example:
+        >>> from pydpm.api.semantic import is_valid_semantics
+        >>> is_valid = is_valid_semantics("{tC_01.00, r0100, c0010}")
+    """
+    api = SemanticAPI()
+    return api.is_valid_semantics(expression)

py_dpm/api/syntax.py

@@ -0,0 +1,182 @@
+from typing import Dict, Any, Optional
+from dataclasses import dataclass
+
+# Import directly to avoid circular imports
+from antlr4 import CommonTokenStream, InputStream
+from py_dpm.grammar.dist.dpm_xlLexer import dpm_xlLexer
+from py_dpm.grammar.dist.dpm_xlParser import dpm_xlParser
+from py_dpm.grammar.dist.listeners import DPMErrorListener
+from py_dpm.AST.ASTConstructor import ASTVisitor
+
+
+@dataclass
+class SyntaxValidationResult:
+    """
+    Result of syntax validation.
+    
+    Attributes:
+        is_valid (bool): Whether the syntax is valid
+        error_message (Optional[str]): Error message if validation failed
+        expression (str): The original expression that was validated
+    """
+    is_valid: bool
+    error_message: Optional[str]
+    expression: str
+
+
+class SyntaxAPI:
+    """
+    API for DPM-XL syntax validation and analysis.
+    
+    This class provides methods to validate DPM-XL expression syntax.
+    """
+    
+    def __init__(self):
+        """Initialize the Syntax API."""
+        self.error_listener = DPMErrorListener()
+        self.visitor = ASTVisitor()
+    
+    def validate_expression(self, expression: str) -> SyntaxValidationResult:
+        """
+        Validate the syntax of a DPM-XL expression.
+        
+        Args:
+            expression (str): The DPM-XL expression to validate
+            
+        Returns:
+            SyntaxValidationResult: Result containing validation status and details
+            
+        Example:
+            >>> from pydpm.api import SyntaxAPI
+            >>> syntax = SyntaxAPI()
+            >>> result = syntax.validate_expression("{tC_01.00, r0100, c0010}")
+            >>> print(result.is_valid)
+            True
+        """
+        try:
+            # Use direct ANTLR validation
+            input_stream = InputStream(expression)
+            lexer = dpm_xlLexer(input_stream)
+            lexer._listeners = [self.error_listener]
+            token_stream = CommonTokenStream(lexer)
+            
+            parser = dpm_xlParser(token_stream)
+            parser._listeners = [self.error_listener]
+            parse_tree = parser.start()
+            
+            if parser._syntaxErrors == 0:
+                return SyntaxValidationResult(
+                    is_valid=True,
+                    error_message=None,
+                    expression=expression
+                )
+            else:
+                return SyntaxValidationResult(
+                    is_valid=False,
+                    error_message="Syntax errors detected",
+                    expression=expression
+                )
+        except SyntaxError as e:
+            return SyntaxValidationResult(
+                is_valid=False,
+                error_message=str(e),
+                expression=expression
+            )
+        except Exception as e:
+            return SyntaxValidationResult(
+                is_valid=False,
+                error_message=f"Unexpected error: {str(e)}",
+                expression=expression
+            )
+    
+    def parse_expression(self, expression: str):
+        """
+        Parse a DPM-XL expression and return the AST.
+        
+        Args:
+            expression (str): The DPM-XL expression to parse
+            
+        Returns:
+            AST: The Abstract Syntax Tree for the expression
+            
+        Raises:
+            Exception: If parsing fails
+            
+        Example:
+            >>> from pydpm.api import SyntaxAPI
+            >>> syntax = SyntaxAPI()
+            >>> ast = syntax.parse_expression("{tC_01.00, r0100, c0010}")
+        """
+        # Parse directly using ANTLR and AST visitor
+        try:
+            input_stream = InputStream(expression)
+            lexer = dpm_xlLexer(input_stream)
+            token_stream = CommonTokenStream(lexer)
+            parser = dpm_xlParser(token_stream)
+            parse_tree = parser.start()
+            
+            # Create AST visitor and visit the parse tree
+            ast = self.visitor.visit(parse_tree)
+            return ast
+        except Exception as e:
+            raise Exception(f"Failed to parse DPM-XL expression '{expression}': {str(e)}")
+    
+    def is_valid_syntax(self, expression: str) -> bool:
+        """
+        Quick check if expression has valid syntax.
+        
+        Args:
+            expression (str): The DPM-XL expression to check
+            
+        Returns:
+            bool: True if syntax is valid, False otherwise
+            
+        Example:
+            >>> from pydpm.api import SyntaxAPI
+            >>> syntax = SyntaxAPI()
+            >>> is_valid = syntax.is_valid_syntax("{tC_01.00, r0100, c0010}")
+        """
+        # Use existing validate_expression method
+        result = self.validate_expression(expression)
+        return result.is_valid
+    
+    def __del__(self):
+        """Clean up resources."""
+        pass
+
+
+# Convenience functions for direct usage
+def validate_expression(expression: str) -> SyntaxValidationResult:
+    """
+    Convenience function to validate DPM-XL expression syntax.
+    
+    Args:
+        expression (str): The DPM-XL expression to validate
+        
+    Returns:
+        SyntaxValidationResult: Result containing validation status and details
+        
+    Example:
+        >>> from pydpm.api.syntax import validate_expression
+        >>> result = validate_expression("{tC_01.00, r0100, c0010}")
+    """
+    api = SyntaxAPI()
+    return api.validate_expression(expression)
+
+
+def is_valid_syntax(expression: str) -> bool:
+    """
+    Convenience function to check if expression has valid syntax.
+    
+    Args:
+        expression (str): The DPM-XL expression to check
+        
+    Returns:
+        bool: True if syntax is valid, False otherwise
+        
+    Example:
+        >>> from pydpm.api.syntax import is_valid_syntax
+        >>> is_valid = is_valid_syntax("{tC_01.00, r0100, c0010}")
+    """
+    api = SyntaxAPI()
+    return api.is_valid_syntax(expression)

py_dpm/client.py

@@ -0,0 +1,106 @@
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+import os
+import sys
+
+from py_dpm.api import API
+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.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))
+def migrate_access(access_file: str):
+    """
+    Migrates data from an Access database to a SQLite database.
+
+    ACCESS_FILE: Path to the Access database file (.mdb or .accdb).
+    """
+
+    sqlite_db = os.getenv("SQLITE_DB_PATH", "database.db")
+    console.print(f"Starting migration from '{access_file}' to '{sqlite_db}'...")
+    try:
+        run_migration(access_file, sqlite_db)
+        console.print("Migration completed successfully.", style="bold green")
+    except Exception as e:
+        console.print(f"An error occurred during migration: {e}", style="bold red")
+        sys.exit(1)
+
+
+@main.command()
+@click.argument('expression', type=str)
+def semantic(expression: 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
+    Used only in DPM-ML generation
+    :return if Return_data is False, any Symbol, else data extracted from DB based on operands cell references
+    """
+
+    error_code = ""
+    validation_type = STATUS_UNKNOWN
+
+    api = API()
+    try:
+        validation_type = "OTHER"
+        api.semantic_validation(expression)
+        status = 200
+        message_error = ''
+    except Exception as error:
+        status = 500
+        message_error = str(error)
+        error_code = 1
+    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")
+    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)
+def syntax(expression: str):
+    """Perform syntactic analysis on a DPM expression."""
+
+    status = 0
+    api = API()
+    try:
+        api.syntax_validation(expression)
+        message_formatted = Text("Syntax OK", style="bold green")
+    except SyntaxError as e:
+        message = str(e)
+        message_formatted = Text(f"Syntax Error: {message}", style="bold red")
+        status = 0
+    except Exception as e:
+        message = str(e)
+        message_formatted = Text(f"Unexpected Error: {message}", style="bold red")
+        status = 1
+
+    console.print(message_formatted)
+
+    return status
+
+if __name__ == '__main__':
+    main()

py_dpm/data_handlers.py

@@ -0,0 +1,99 @@
+import pandas as pd
+
+from py_dpm.Exceptions.exceptions import SemanticError
+from py_dpm.Utils.tokens import *
+
+
+def filter_data_by_cell_element(series, cell_elements, element_name, table_code):
+    """
+    Filter data by cell elements
+    :param series: data to be filtered
+    :param cell_elements: rows, columns or sheets using to filter data
+    :param element_name: name of cell elements using to filter data
+    :return: filtered data
+    """
+    if len(cell_elements) == 1 and '-' not in cell_elements[0]:
+        series = series[series[element_name] == cell_elements[0]]
+    elif len(cell_elements) == 1 and '-' in cell_elements[0]:
+        limits = cell_elements[0].split('-')
+        series = series[series[element_name].between(limits[0], limits[1])]
+    else:
+        range_control = any(['-' in x for x in cell_elements])
+        if range_control:  # Range in cell elements, we must separate them
+            data_range = []
+            data_single = []
+            for x in cell_elements:
+                if '-' in x:
+                    limits = x.split('-')
+                    data_range += list(series[series[element_name].between(limits[0], limits[1])][element_name].unique())
+                else:
+                    data_single.append(x)
+            cell_elements = sorted(list(set(data_range + data_single)))
+        series = series[series[element_name].isin(cell_elements)]
+        cells_not_found = [x for x in cell_elements if x not in list(series[element_name].unique())]
+
+        if cells_not_found:
+            header = "rows" if element_name == ROW_CODE else "columns" if element_name == COLUMN_CODE else "sheets"
+            cell_elements = ", ".join([f"{header[0]}{x}" for x in cells_not_found]) if cells_not_found else None
+            op_pos = [table_code, cell_elements]
+            cell_exp = ", ".join(x for x in op_pos if x is not None)
+            raise SemanticError("1-2", cell_expression=cell_exp)
+    return series
+
+
+def filter_all_data(data, table_code, rows, cols, sheets):
+    df = data[data["table_code"] == table_code].reset_index(drop=True)
+    if rows and rows[0] != '*':
+        df = filter_data_by_cell_element(df, rows, ROW_CODE, table_code)
+    if cols and cols[0] != '*':
+        df = filter_data_by_cell_element(df, cols, COLUMN_CODE, table_code)
+    if sheets and sheets[0] != '*':
+        df = filter_data_by_cell_element(df, sheets, SHEET_CODE, table_code)
+    df = df.reset_index(drop=True)
+    return df
+
+
+def generate_xyz(data: pd.DataFrame):
+
+    for letter in [INDEX_X, INDEX_Y, INDEX_Z]:
+        data[letter] = None
+
+    number_of_rows = len(list(data[ROW_CODE].unique()))
+    number_of_columns = len(list(data[COLUMN_CODE].unique()))
+    number_of_sheets = len(list(data[SHEET_CODE].unique()))
+    group = []
+
+    if number_of_rows > 1:
+        data.sort_values(by=[ROW_CODE], inplace=True)
+        data[INDEX_X] = data[ROW_CODE].rank(method='dense').astype(int)
+        group.append(ROW_CODE)
+
+    if number_of_columns > 1:
+        data.sort_values(by=[COLUMN_CODE], inplace=True)
+        if data[INDEX_X].isnull().all():
+            data[INDEX_Y] = data[COLUMN_CODE].rank(method='dense').astype(int)
+        else:
+            data_groups = list(data.groupby(ROW_CODE))
+            for _, group_data in data_groups:
+                group_data.sort_values(by=[COLUMN_CODE], inplace=True)
+                group_data[INDEX_Y] = group_data[COLUMN_CODE].rank(method='dense').astype(int)
+                # Add to data[INDEX_Y] the values of group_data[INDEX_Y]
+                data.loc[group_data.index, INDEX_Y] = group_data[INDEX_Y]
+        group.append(COLUMN_CODE)
+
+    if number_of_sheets > 1:
+        data.sort_values(by=[SHEET_CODE], inplace=True)
+        if len(group) == 0:
+            data[INDEX_Z] = data[SHEET_CODE].rank(method='dense').astype(int)
+        else:
+            data_groups = list(data.groupby(group))
+            for _, group_data in data_groups:
+                group_data.sort_values(by=[SHEET_CODE], inplace=True)
+                group_data[INDEX_Z] = group_data[SHEET_CODE].rank(method='dense').astype(int)
+                data.loc[group_data.index, INDEX_Z] = group_data[INDEX_Z]
+        group.append(SHEET_CODE)
+    if len(group) > 0:
+        data.sort_values(by=group, inplace=True)
+    data.drop_duplicates(keep="first", inplace=True)
+    list_xyz = data.to_dict(orient='records')
+    return list_xyz