pydpm_xl 0.1.10__py3-none-any.whl

py_dpm/ValidationsGeneration/auxiliary_functions.py

@@ -0,0 +1,98 @@
+import numpy as np
+import pandas as pd
+
+from py_dpm.Utils.ValidationsGenerationUtils import ValidationsGenerationUtils
+from py_dpm.Utils.tokens import *
+
+
+def generate_context_structure(lst: list, group_df: pd.DataFrame):
+    """
+    Method to generate the structure of the contexts of variables in order to generate the hierarchy validations
+    :param lst: list to store the structure of contexts
+    :param group_df: Dataframe with information about properties and items of variables
+    """
+    group_df.set_index(CONTEXT_PROPERTY, inplace=True)
+    result = group_df.to_dict()[CONTEXT_ITEM]
+    result[VARIABLE_VID] = group_df[VARIABLE_VID].tolist()[0]
+    result[VARIABLE_PROPERTY_ID] = group_df[VARIABLE_PROPERTY_ID].tolist()[0]
+
+    lst.append(result)
+
+
+def generate_subexpression(common_values, data, table, operator:str=None):
+    """
+    Method to generate the subexpression of a hierarchy expression
+    :param common_values: dictionary with information about the common components and their values
+    :param data: variable datapoints
+    :param table: table code
+    """
+    abs_value = True if operator and operator != '=' else False
+    if ROW_CODE in common_values:
+        rows = None
+    else:
+        rows = ROW + data[ROW_CODE].iloc[0] if data[ROW_CODE].iloc[0] else None
+
+    if COLUMN_CODE in common_values:
+        cols = None
+    else:
+        cols = COLUMN + data[COLUMN_CODE].iloc[0] if data[COLUMN_CODE].iloc[0] else None
+
+    if SHEET_CODE in common_values:
+        sheets = None
+    else:
+        sheets = SHEET + data[SHEET_CODE].iloc[0] if data[SHEET_CODE].iloc[0] else None
+    
+    if abs_value:
+        expr = ValidationsGenerationUtils.write_cell(table, rows, cols, sheets)
+        return 'abs(' + expr + ')'
+    
+    return ValidationsGenerationUtils.write_cell(table, rows, cols, sheets)
+
+
+def get_common_components(left_data: pd.DataFrame, right_data: pd.DataFrame):
+    """
+    Method to get the common components of expression operands
+    :param left_data: Dataframe corresponding to the data of the left operand
+    :param right_data: Dataframe corresponding to the data of the right side operands
+    """
+    common_components = {}
+    for component in CELL_COMPONENTS:
+        left = left_data[component].dropna().tolist()
+        right = right_data[component].isnull().values.any()
+        if left and not right:
+            intersection_component = np.intersect1d(left_data[component], right_data[component])
+            if len(intersection_component):
+                if all(right_data[component].isin(intersection_component)):
+                    common_components[component] = intersection_component
+    return common_components
+
+
+def group_hierarchy_right_data(right_data: pd.DataFrame, left_table: str, common_components: list, comparisson_operator:str=None):
+    """
+    Method to group right side operands
+    :param right_data: Dataframe with the datapoints of the right side of expression
+    :param left_table: Table code of left operand
+    :param common_components: List with the common components of right and left operands
+    """
+    right_table = right_data[TABLE_CODE].tolist()[0]
+    is_table_unique = left_table == right_table
+    right_operands_lst = []
+    right_table_cell = right_table if not is_table_unique else None
+    # Here we have to add the order of the items in the expression
+    order_dict = {}
+    for keys, group in right_data.groupby([ARITHMETIC_OPERATOR_SYMBOL, ITEM_ID]):
+        operand = generate_subexpression(common_components, group, right_table_cell,comparisson_operator)
+        operand = keys[0] + operand
+        if ORDER in group:
+            order_dict[group[ORDER].tolist()[0]] = operand
+        else:
+            order_dict[group[ORDER + '_x'].tolist()[0]] = operand
+
+    right_operands_lst = [order_dict[order] for order in sorted(order_dict)]
+
+    right_expression = ' '.join(right_operands_lst)
+    if DUPLICATE_VARIABLES not in right_data:
+        right_data[DUPLICATE_VARIABLES] = False
+    duplicate_variables = right_data[DUPLICATE_VARIABLES].any()
+    right_items = right_data[ITEM_ID].unique().tolist()
+    return [right_expression, right_table, duplicate_variables,right_items]

py_dpm/__init__.py

@@ -0,0 +1,61 @@
+"""
+PyDPM - Python Data Processing and Migration
+============================================
+
+A Python library for DPM-XL data processing, migration, and analysis.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+Main Features:
+- Database migration from Access to SQLite
+- DPM-XL syntax validation and parsing
+- DPM-XL semantic analysis
+
+Quick Start:
+    >>> import pydpm
+    >>>
+    >>> # Migration
+    >>> migration = pydpm.api.MigrationAPI()
+    >>> engine = migration.migrate_access_to_sqlite("data.mdb", "output.db")
+    >>>
+    >>> # Syntax validation
+    >>> syntax = pydpm.api.SyntaxAPI()
+    >>> result = syntax.validate_expression("{tC_01.00, r0100, c0010}")
+    >>>
+    >>> # Semantic analysis
+    >>> semantic = pydpm.api.SemanticAPI()
+    >>> result = semantic.validate_expression("{tC_01.00, r0100, c0010}")
+
+Available packages:
+- pydpm.api: Main APIs for migration, syntax, and semantic analysis
+"""
+
+__version__ = "0.1.10"
+__author__ = "MeaningfulData S.L."
+__email__ = "info@meaningfuldata.eu"
+__license__ = "GPL-3.0-or-later"
+
+# Import main API modules for convenient access
+from py_dpm import api
+
+# Import main classes for direct usage
+from py_dpm.api import MigrationAPI, SyntaxAPI, SemanticAPI
+
+__all__ = [
+    'api',
+    'MigrationAPI',
+    'SyntaxAPI',
+    'SemanticAPI',
+    '__version__'
+]

py_dpm/api/__init__.py

@@ -0,0 +1,140 @@
+from py_dpm.api.migration import MigrationAPI
+from py_dpm.api.syntax import SyntaxAPI
+from py_dpm.api.semantic import SemanticAPI
+from py_dpm.api.ast_generator import ASTGenerator, parse_expression, validate_expression, parse_batch
+from py_dpm.api.complete_ast import generate_complete_ast, generate_complete_batch
+
+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.ASTObjects import TemporaryAssignment
+from py_dpm.AST.MLGeneration import MLGeneration
+from py_dpm.AST.ModuleAnalyzer import ModuleAnalyzer
+from py_dpm.AST.ModuleDependencies import ModuleDependencies
+from py_dpm.AST.check_operands import OperandsChecking
+from py_dpm.semantics import SemanticAnalyzer
+
+from py_dpm.ValidationsGeneration.VariantsProcessor import (
+    VariantsProcessor,
+    VariantsProcessorChecker,
+)
+from py_dpm.ValidationsGeneration.PropertiesConstraintsProcessor import (
+    PropertiesConstraintsChecker,
+    PropertiesConstraintsProcessor,
+)
+
+from py_dpm.db_utils import get_session, get_engine
+
+# Export the main API classes
+__all__ = [
+    # Complete AST API (recommended - includes data fields)
+    'generate_complete_ast',
+    'generate_complete_batch',
+
+    # Simple AST API
+    'ASTGenerator',
+    'parse_expression',
+    'validate_expression',
+    'parse_batch',
+
+    # Advanced APIs
+    'MigrationAPI',
+    'SyntaxAPI',
+    'SemanticAPI',
+    'API'  # Keep for backward compatibility
+]
+
+
+class API:
+    error_listener = DPMErrorListener()
+    visitor = ASTVisitor()
+
+    def __init__(self):
+        get_engine()
+        self.session = get_session()
+
+    @classmethod
+    def lexer(cls, text: str):
+        """
+        Extracts the tokens from the input expression
+        :param text: Expression to be analyzed
+        """
+        lexer = dpm_xlLexer(InputStream(text))
+        lexer._listeners = [cls.error_listener]
+        cls.stream = CommonTokenStream(lexer)
+
+    @classmethod
+    def parser(cls):
+        """
+        Parses the token from the lexer stream
+        """
+        parser = dpm_xlParser(cls.stream)
+        parser._listeners = [cls.error_listener]
+        cls.CST = parser.start()
+
+        if parser._syntaxErrors == 0:
+            return True
+
+    @classmethod
+    def syntax_validation(cls, expression):
+        """
+        Validates that the input expression is syntactically correct by applying the ANTLR lexer and parser
+        :param expression: Expression to be analyzed
+        """
+        cls.lexer(expression)
+        cls.parser()
+
+    @classmethod
+    def create_ast(cls, expression):
+        """
+        Generates the AST from the expression
+        :param expression: Expression to be analyzed
+        """
+        cls.lexer(expression)
+        if cls.parser():
+            cls.visitor = ASTVisitor()
+            cls.AST = cls.visitor.visit(cls.CST)
+
+    def semantic_validation(self, expression):
+        self.create_ast(expression=expression)
+
+        oc = OperandsChecking(session=self.session, expression=expression, ast=self.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(self.AST)
+        return results
+
+    def _check_property_constraints(self, ast):
+        """
+        Method to check property constraints
+        :return: Boolean value indicating if the ast has property constraints
+        """
+        pcc = PropertiesConstraintsChecker(ast=ast, session=self.session)
+        return pcc.is_property_constraint
+
+    def _check_property_constraints_from_expression(self, expression):
+        """
+        Method to check property constraints
+        :return: Boolean value indicating if the ast has property constraints
+        """
+        self.create_ast(expression=expression)
+        pcc = PropertiesConstraintsChecker(ast=self.AST, session=self.session)
+        return pcc.is_property_constraint
+
+    def _check_variants(self, expression):
+        """
+        Method to check table groups
+        :return: Boolean value indicating if the ast has table groups
+        """
+        self.create_ast(expression=expression)
+        tgc = VariantsProcessorChecker(ast=self.AST)
+        return tgc.is_variant