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

py_dpm/{AST/ModuleDependencies.py → dpm_xl/ast/module_dependencies.py}

@@ -1,39 +1,51 @@
 from abc import ABC
 
-from py_dpm.AST.ASTObjects import *
-from py_dpm.AST.ASTTemplate import ASTTemplate
-from py_dpm.AST.WhereClauseChecker import WhereClauseChecker
-from py_dpm.Exceptions import exceptions
-from py_dpm.models import TableVersion, VariableVersion, ViewDatapoints, ViewModules, ItemCategory
-
-operand_elements = ['table', 'rows', 'cols', 'sheets', 'default', 'interval']
-
-def filter_datapoints_df(df, table, table_info:dict, release_id:int=None):
-    """
-    """
-    mapping_dictionary = {'rows': 'row_code', 'cols': 'column_code', 'sheets': 'sheet_code'}
-    df = df[df['table_code'] == table]
+from py_dpm.dpm_xl.ast.nodes import *
+from py_dpm.dpm_xl.ast.template import ASTTemplate
+from py_dpm.dpm_xl.ast.where_clause import WhereClauseChecker
+from py_dpm.exceptions import exceptions
+from py_dpm.dpm.models import (
+    TableVersion,
+    VariableVersion,
+    ViewDatapoints,
+    ViewModules,
+    ItemCategory,
+)
+
+operand_elements = ["table", "rows", "cols", "sheets", "default", "interval"]
+
+
+def filter_datapoints_df(df, table, table_info: dict, release_id: int = None):
+    """ """
+    mapping_dictionary = {
+        "rows": "row_code",
+        "cols": "column_code",
+        "sheets": "sheet_code",
+    }
+    df = df[df["table_code"] == table]
     for k, v in table_info.items():
         if v is not None:
-            if '-' in v[0]:
-                low_limit, high_limit = v[0].split('-')
+            if "-" in v[0]:
+                low_limit, high_limit = v[0].split("-")
                 df = df[(df[mapping_dictionary[k]].between(low_limit, high_limit))]
-            elif v[0] == '*':
+            elif v[0] == "*":
                 continue
             else:
                 df = df[(df[mapping_dictionary[k]].isin(v))]
 
     if release_id:
-        df = df[df['release_id'] == release_id]
+        df = df[df["release_id"] == release_id]
     return df
 
+
 def filter_module_by_table_df(df, table):
     """
     Returns a list of modules that contain the table
     """
-    module_list = df[df['table_code'] == table]['module_code'].tolist()
+    module_list = df[df["table_code"] == table]["module_code"].tolist()
     return module_list
 
+
 class ModuleDependencies(ASTTemplate, ABC):
     def __init__(self, session, ast, release_id, date, module_ref, is_scripting=False):
         self.release_id = release_id
@@ -55,7 +67,7 @@ class ModuleDependencies(ASTTemplate, ABC):
         self.is_scripting = is_scripting
 
         self.session = session
-        self.time_period = 't'  # TODO
+        self.time_period = "t"  # TODO
         self.date = date
         self.modules = {}
         self.from_time_shift = False
@@ -63,7 +75,6 @@ class ModuleDependencies(ASTTemplate, ABC):
         super().__init__()
         self.visit(self.AST)
 
-
     # Start of visiting nodes
     def visit_WithExpression(self, node: WithExpression):
         if node.partial_selection.is_table_group:
@@ -78,17 +89,16 @@ class ModuleDependencies(ASTTemplate, ABC):
 
         if self.partial_selection:
             for attribute in operand_elements:
-                if getattr(node, attribute, None) is None and not getattr(self.partial_selection, attribute, None) is None:
+                if (
+                    getattr(node, attribute, None) is None
+                    and not getattr(self.partial_selection, attribute, None) is None
+                ):
                     setattr(node, attribute, getattr(self.partial_selection, attribute))
 
         if not node.table:
             raise exceptions.SemanticError("1-4", table=node.table)
 
-        table_info = {
-            'rows': node.rows,
-            'cols': node.cols,
-            'sheets': node.sheets
-        }
+        table_info = {"rows": node.rows, "cols": node.cols, "sheets": node.sheets}
 
         if node.table not in self.tables:
             self.tables[node.table] = table_info
@@ -100,17 +110,16 @@ class ModuleDependencies(ASTTemplate, ABC):
                 # self.operands[node.table].append(node)
 
         # Variables full
-        variables_full = ViewDatapoints.get_filtered_datapoints(self.session,
-                                                                node.table,
-                                                                table_info,
-                                                                release_id=self.release_id)
+        variables_full = ViewDatapoints.get_filtered_datapoints(
+            self.session, node.table, table_info, release_id=self.release_id
+        )
         # variables_full = ViewDatapoints.get_table_data(self.session, node.table, table_info['rows'], table_info['cols'], table_info['sheets'],
         #                                              self.release_id)
 
         if variables_full.empty:
             raise exceptions.SemanticError("1-5", open_keys=table_info)
 
-        final_list = variables_full['variable_id'].to_list()
+        final_list = variables_full["variable_id"].to_list()
         # Here change table for module or modules
         modules = ViewModules().get_all_modules(self.session)  # TODO
         modules = filter_module_by_table_df(modules, node.table)
@@ -137,35 +146,41 @@ class ModuleDependencies(ASTTemplate, ABC):
             full_name = f"{node.table}:{self.time_period}"
             self.full_operands[full_name] = final_list
 
-
     def visit_Dimension(self, node: Dimension):
         if node.dimension_code not in self.dimension_codes:
             self.dimension_codes.append(node.dimension_code)
-            if not ItemCategory.get_property_from_code(node.dimension_code, self.session):
+            if not ItemCategory.get_property_from_code(
+                node.dimension_code, self.session
+            ):
                 raise exceptions.SemanticError("1-5", open_keys=node.dimension_code)
 
     def visit_VarRef(self, node: VarRef):
-        if not VariableVersion.check_variable_exists(self.session, node.variable, self.release_id):
-            raise exceptions.SemanticError('1-3', variable=node.variable)
+        if not VariableVersion.check_variable_exists(
+            self.session, node.variable, self.release_id
+        ):
+            raise exceptions.SemanticError("1-3", variable=node.variable)
 
     def visit_PreconditionItem(self, node: PreconditionItem):
 
         if self.is_scripting:
-            raise exceptions.SemanticError('6-3', precondition=node.variable_id)
+            raise exceptions.SemanticError("6-3", precondition=node.variable_id)
 
-        if not TableVersion.check_table_exists(self.session, node.variable_id, self.release_id):
+        if not TableVersion.check_table_exists(
+            self.session, node.variable_id, self.release_id
+        ):
             raise exceptions.SemanticError("1-3", variable=node.variable_id)
 
         self.preconditions = True
 
     def visit_Scalar(self, node: Scalar):
-        if node.item and node.scalar_type == 'Item':
+        if node.item and node.scalar_type == "Item":
             if node.item not in self.items:
                 self.items.append(node.item)
-                if not ItemCategory.get_item_category_id_from_signature(node.item, self.session):
+                if not ItemCategory.get_item_category_id_from_signature(
+                    node.item, self.session
+                ):
                     raise exceptions.SemanticError("1-1", items=node.item)
 
-
     def visit_WhereClauseOp(self, node: WhereClauseOp):
         self.visit(node.operand)
         checker = WhereClauseChecker()
@@ -178,7 +193,7 @@ class ModuleDependencies(ASTTemplate, ABC):
         period_indicator = node.period_indicator
         shift_number = node.shift_number
         # compute new time period
-        if period_indicator not in ('A', 'Q', 'M', 'W', 'D'):
+        if period_indicator not in ("A", "Q", "M", "W", "D"):
             raise ValueError("Period indicator is not valid")
         if "-" in shift_number:
             new_time_period = f"t+{period_indicator}{shift_number}"

py_dpm/{AST/ASTObjects.py → dpm_xl/ast/nodes.py}

@@ -255,7 +255,7 @@ class VarID(AST):
 
             # First check if type attribute is set (from semantic validation)
             if hasattr(self, 'type') and self.type is not None:
-                from py_dpm.DataTypes.ScalarTypes import Number
+                from py_dpm.dpm_xl.types.scalar import Number
                 if isinstance(self.type, Number):
                     interval_value = self.interval if self.interval is not None else False
                 else:

py_dpm/{AST/check_operands.py → dpm_xl/ast/operands.py}

@@ -6,7 +6,7 @@ import warnings
 # Suppress pandas UserWarning about SQLAlchemy connection types
 warnings.filterwarnings("ignore", message=".*pandas only supports SQLAlchemy.*")
 
-from py_dpm.AST.ASTObjects import (
+from py_dpm.dpm_xl.ast.nodes import (
     Dimension,
     GetOp,
     OperationRef,
@@ -19,12 +19,12 @@ from py_dpm.AST.ASTObjects import (
     WhereClauseOp,
     WithExpression,
 )
-from py_dpm.AST.ASTTemplate import ASTTemplate
-from py_dpm.AST.WhereClauseChecker import WhereClauseChecker
-from py_dpm.DataTypes.ScalarTypes import Integer, Mixed, Number, ScalarFactory
-from py_dpm.Exceptions import exceptions
-from py_dpm.Exceptions.exceptions import SemanticError
-from py_dpm.models import (
+from py_dpm.dpm_xl.ast.template import ASTTemplate
+from py_dpm.dpm_xl.ast.where_clause import WhereClauseChecker
+from py_dpm.dpm_xl.types.scalar import Integer, Mixed, Number, ScalarFactory
+from py_dpm.exceptions import exceptions
+from py_dpm.exceptions.exceptions import SemanticError
+from py_dpm.dpm.models import (
     ItemCategory,
     Operation,
     VariableVersion,
@@ -35,10 +35,10 @@ from py_dpm.models import (
     TableVersion,
     TableVersionHeader,
     Header,
-    filter_by_release,
 )
-from py_dpm.Utils.operands_mapping import generate_new_label, set_operand_label
-from py_dpm.data_handlers import filter_all_data
+from py_dpm.dpm.queries.filters import filter_by_release
+from py_dpm.dpm_xl.utils.operands_mapping import generate_new_label, set_operand_label
+from py_dpm.dpm_xl.utils.data_handlers import filter_all_data
 
 operand_elements = ["table", "rows", "cols", "sheets", "default", "interval"]
 
@@ -208,16 +208,19 @@ class OperandsChecking(ASTTemplate, ABC):
         # Apply release filter
         query = filter_by_release(
             query,
+            self.release_id,
             TableVersion.startreleaseid,
             TableVersion.endreleaseid,
-            self.release_id,
         )
 
         # Execute query and convert to DataFrame
-        from py_dpm.models import _compile_query_for_pandas
+        from py_dpm.dpm.models import (
+            _compile_query_for_pandas,
+            _read_sql_with_connection,
+        )
 
         compiled_query = _compile_query_for_pandas(query.statement, self.session)
-        df_headers = pd.read_sql(compiled_query, self.session.connection().connection)
+        df_headers = _read_sql_with_connection(compiled_query, self.session)
 
         for table in table_codes:
             table_headers = df_headers[df_headers["Code"] == table]

py_dpm/{AST/ASTTemplate.py → dpm_xl/ast/template.py}

@@ -1,7 +1,7 @@
-from py_dpm.AST.ASTObjects import AggregationOp, BinOp, ComplexNumericOp, CondExpr, Constant, Dimension, FilterOp, GetOp, GroupingClause, \
+from py_dpm.dpm_xl.ast.nodes import AggregationOp, BinOp, ComplexNumericOp, CondExpr, Constant, Dimension, FilterOp, GetOp, GroupingClause, \
     OperationRef, ParExpr, PersistentAssignment, PreconditionItem, PropertyReference, RenameOp, Scalar, Set, Start, SubOp, TemporaryAssignment, \
     TimeShiftOp, UnaryOp, VarID, VarRef, WhereClauseOp, WithExpression
-from py_dpm.AST.ASTVisitor import NodeVisitor
+from py_dpm.dpm_xl.ast.visitor import NodeVisitor
 
 
 class ASTTemplate(NodeVisitor):

py_dpm/{AST/WhereClauseChecker.py → dpm_xl/ast/where_clause.py}

@@ -1,5 +1,5 @@
-from py_dpm.AST.ASTObjects import Dimension
-from py_dpm.AST.ASTTemplate import ASTTemplate
+from py_dpm.dpm_xl.ast.nodes import Dimension
+from py_dpm.dpm_xl.ast.template import ASTTemplate
 
 
 class WhereClauseChecker(ASTTemplate):

py_dpm/dpm_xl/grammar/__init__.py

@@ -0,0 +1,18 @@
+"""
+DPM-XL Grammar
+
+ANTLR4 grammar definitions and generated parsers for DPM-XL expressions.
+"""
+
+# Import generated parser and lexer
+from py_dpm.dpm_xl.grammar.generated.dpm_xlLexer import dpm_xlLexer
+from py_dpm.dpm_xl.grammar.generated.dpm_xlParser import dpm_xlParser
+from py_dpm.dpm_xl.grammar.generated.dpm_xlParserVisitor import dpm_xlParserVisitor
+from py_dpm.dpm_xl.grammar.generated.dpm_xlParserListener import dpm_xlParserListener
+
+__all__ = [
+    "dpm_xlLexer",
+    "dpm_xlParser",
+    "dpm_xlParserVisitor",
+    "dpm_xlParserListener",
+]

py_dpm/dpm_xl/operators/__init__.py

@@ -0,0 +1,19 @@
+"""
+DPM-XL Operators
+
+Operator implementations for DPM-XL expressions.
+"""
+
+from py_dpm.dpm_xl.operators.base import *
+from py_dpm.dpm_xl.operators.arithmetic import *
+from py_dpm.dpm_xl.operators.boolean import *
+from py_dpm.dpm_xl.operators.comparison import *
+from py_dpm.dpm_xl.operators.conditional import *
+from py_dpm.dpm_xl.operators.aggregate import *
+from py_dpm.dpm_xl.operators.string import *
+from py_dpm.dpm_xl.operators.time import *
+from py_dpm.dpm_xl.operators.clause import *
+
+__all__ = [
+    # Re-export will be handled by import *
+]

py_dpm/{Operators/AggregateOperators.py → dpm_xl/operators/aggregate.py}

@@ -2,15 +2,15 @@ import warnings
 
 import pandas as pd
 
-from py_dpm.DataTypes.ScalarTypes import Integer, Number, ScalarFactory
-from py_dpm.DataTypes.TypePromotion import unary_implicit_type_promotion
-from py_dpm.Exceptions import exceptions
-from py_dpm.Operators import Operator
-from py_dpm.Utils import tokens
-from py_dpm.semantics.Symbols import RecordSet
+from py_dpm.dpm_xl.types.scalar import Integer, Number, ScalarFactory
+from py_dpm.dpm_xl.types.promotion import unary_implicit_type_promotion
+from py_dpm.exceptions import exceptions
+from py_dpm.dpm_xl.operators.base import Operator, Binary, Unary, Complex
+from py_dpm.dpm_xl.utils import tokens
+from py_dpm.dpm_xl.symbols import RecordSet
 
 
-class AggregateOperator(Operator.Unary):
+class AggregateOperator(Unary):
     """
     Aggregate operators involve all operators with a Recordset and a Grouping clause.
 

py_dpm/{Operators/NumericOperators.py → dpm_xl/operators/arithmetic.py}

@@ -1,12 +1,12 @@
 import math
 import operator
 
-from py_dpm.DataTypes.ScalarTypes import Number
-from py_dpm.Operators import Operator
-from py_dpm.Utils import tokens
+from py_dpm.dpm_xl.types.scalar import Number
+from py_dpm.dpm_xl.operators.base import Operator, Binary, Unary, Complex
+from py_dpm.dpm_xl.utils import tokens
 
 
-class Unary(Operator.Unary):
+class Unary(Unary):
     op = None
     type_to_check = Number
     return_type = None
@@ -49,7 +49,7 @@ class SquareRoot(Unary):
     interval_allowed: bool = False
 
 
-class NumericBinary(Operator.Binary):
+class NumericBinary(Binary):
     type_to_check = Number
     interval_allowed:bool = True
 
@@ -88,7 +88,7 @@ class Logarithm(NumericBinary):
     interval_allowed:bool = False
 
 
-class NumericComplex(Operator.Complex):
+class NumericComplex(Complex):
     type_to_check = Number
     interval_allowed:bool = True
 

py_dpm/{Operators/Operator.py → dpm_xl/operators/base.py}

@@ -3,13 +3,13 @@ from typing import Union
 
 import pandas as pd
 
-from py_dpm.DataTypes.ScalarTypes import Mixed, Number, ScalarFactory
-from py_dpm.DataTypes.TypePromotion import binary_implicit_type_promotion, binary_implicit_type_promotion_with_mixed_types, \
+from py_dpm.dpm_xl.types.scalar import Mixed, Number, ScalarFactory
+from py_dpm.dpm_xl.types.promotion import binary_implicit_type_promotion, binary_implicit_type_promotion_with_mixed_types, \
     check_operator, \
     unary_implicit_type_promotion, unary_implicit_type_promotion_with_mixed_types
-from py_dpm.Exceptions.exceptions import SemanticError
-from py_dpm.Utils.operands_mapping import generate_new_label, set_operand_label
-from py_dpm.semantics.Symbols import ConstantOperand, FactComponent, RecordSet, Scalar, ScalarSet, Structure
+from py_dpm.exceptions.exceptions import SemanticError
+from py_dpm.dpm_xl.utils.operands_mapping import generate_new_label, set_operand_label
+from py_dpm.dpm_xl.symbols import ConstantOperand, FactComponent, RecordSet, Scalar, ScalarSet, Structure
 
 
 class Operator:

py_dpm/{Operators/BooleanOperators.py → dpm_xl/operators/boolean.py}

@@ -1,11 +1,11 @@
 import operator
 
-from py_dpm.DataTypes.ScalarTypes import Boolean
-from py_dpm.Operators import Operator
-from py_dpm.Utils import tokens
+from py_dpm.dpm_xl.types.scalar import Boolean
+from py_dpm.dpm_xl.operators.base import Operator, Binary, Unary, Complex
+from py_dpm.dpm_xl.utils import tokens
 
 
-class Binary(Operator.Binary):
+class Binary(Binary):
     type_to_check = Boolean
 
 
@@ -24,7 +24,7 @@ class Xor(Binary):
     py_op = operator.xor
 
 
-class Not(Operator.Unary):
+class Not(Unary):
     type_to_check = Boolean
     op = tokens.NOT
     py_op = operator.not_

py_dpm/{Operators/ClauseOperators.py → dpm_xl/operators/clause.py}

@@ -1,13 +1,13 @@
 from typing import List
 
-from py_dpm.DataTypes.ScalarTypes import ScalarFactory
-from py_dpm.DataTypes.TypePromotion import unary_implicit_type_promotion
-from py_dpm.Exceptions import exceptions
-from py_dpm.Operators.ConditionalOperators import ConditionalOperator
-from py_dpm.Operators.Operator import Binary, Operator
-from py_dpm.Utils import tokens
-from py_dpm.Utils.operands_mapping import generate_new_label, set_operand_label
-from py_dpm.semantics.Symbols import FactComponent, RecordSet
+from py_dpm.dpm_xl.types.scalar import ScalarFactory
+from py_dpm.dpm_xl.types.promotion import unary_implicit_type_promotion
+from py_dpm.exceptions import exceptions
+from py_dpm.dpm_xl.operators.conditional import ConditionalOperator
+from py_dpm.dpm_xl.operators.base import Binary, Operator
+from py_dpm.dpm_xl.utils import tokens
+from py_dpm.dpm_xl.utils.operands_mapping import generate_new_label, set_operand_label
+from py_dpm.dpm_xl.symbols import FactComponent, RecordSet
 
 
 class ClauseOperator(Operator):

py_dpm/{Operators/ComparisonOperators.py → dpm_xl/operators/comparison.py}

@@ -1,19 +1,19 @@
 import operator
 import re
 
-from py_dpm.DataTypes.ScalarTypes import Boolean, String
-from py_dpm.Operators import Operator
-from py_dpm.Utils import tokens
+from py_dpm.dpm_xl.types.scalar import Boolean, String
+from py_dpm.dpm_xl.operators.base import Operator, Binary, Unary, Complex
+from py_dpm.dpm_xl.utils import tokens
 
 
-class IsNull(Operator.Unary):
+class IsNull(Unary):
     op = tokens.ISNULL
     py_op = operator.truth
     do_not_check_with_return_type = True
     return_type = Boolean
 
 
-class Binary(Operator.Binary):
+class Binary(Binary):
     do_not_check_with_return_type = True
     return_type = Boolean
 

py_dpm/{Operators/ConditionalOperators.py → dpm_xl/operators/conditional.py}

@@ -3,14 +3,14 @@ from typing import Union
 
 import pandas as pd
 
-from py_dpm.DataTypes.ScalarTypes import Mixed, ScalarFactory
-from py_dpm.DataTypes.TypePromotion import binary_implicit_type_promotion, binary_implicit_type_promotion_with_mixed_types, \
+from py_dpm.dpm_xl.types.scalar import Mixed, ScalarFactory
+from py_dpm.dpm_xl.types.promotion import binary_implicit_type_promotion, binary_implicit_type_promotion_with_mixed_types, \
     unary_implicit_type_promotion
-from py_dpm.Exceptions import exceptions
-from py_dpm.Exceptions.exceptions import SemanticError
-from py_dpm.Operators.Operator import Binary, Operator
-from py_dpm.Utils import tokens
-from py_dpm.semantics.Symbols import ConstantOperand, RecordSet, Scalar, Structure
+from py_dpm.exceptions import exceptions
+from py_dpm.exceptions.exceptions import SemanticError
+from py_dpm.dpm_xl.operators.base import Binary, Operator
+from py_dpm.dpm_xl.utils import tokens
+from py_dpm.dpm_xl.symbols import ConstantOperand, RecordSet, Scalar, Structure
 
 
 class ConditionalOperator(Operator):

py_dpm/{Operators/StringOperators.py → dpm_xl/operators/string.py}

@@ -1,16 +1,16 @@
 import operator
 
-from py_dpm.DataTypes.ScalarTypes import Integer, String
-from py_dpm.Operators import Operator
-from py_dpm.Utils import tokens
+from py_dpm.dpm_xl.types.scalar import Integer, String
+from py_dpm.dpm_xl.operators.base import Operator, Binary, Unary, Complex
+from py_dpm.dpm_xl.utils import tokens
 
 
-class Unary(Operator.Unary):
+class Unary(Unary):
     op = None
     type_to_check = String
 
 
-class Binary(Operator.Binary):
+class Binary(Binary):
     op = None
     type_to_check = String
 

py_dpm/{Operators/TimeOperators.py → dpm_xl/operators/time.py}

@@ -1,11 +1,11 @@
 from typing import Union
 
-from py_dpm.DataTypes.ScalarTypes import ScalarFactory, TimeInterval
-from py_dpm.DataTypes.TypePromotion import unary_implicit_type_promotion
-from py_dpm.Exceptions import exceptions
-from py_dpm.Operators.Operator import Operator
-from py_dpm.Utils import tokens
-from py_dpm.semantics.Symbols import ConstantOperand, RecordSet, Scalar
+from py_dpm.dpm_xl.types.scalar import ScalarFactory, TimeInterval
+from py_dpm.dpm_xl.types.promotion import unary_implicit_type_promotion
+from py_dpm.exceptions import exceptions
+from py_dpm.dpm_xl.operators.base import Operator
+from py_dpm.dpm_xl.utils import tokens
+from py_dpm.dpm_xl.symbols import ConstantOperand, RecordSet, Scalar
 
 
 class TimeShift(Operator):