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

py_dpm/{semantics/SemanticAnalyzer.py → dpm_xl/semantic_analyzer.py}

@@ -3,25 +3,69 @@ from abc import ABC
 
 import pandas as pd
 
-from py_dpm.AST.ASTObjects import AggregationOp, BinOp, ComplexNumericOp, CondExpr, Constant, \
-    Dimension, FilterOp, GetOp, OperationRef, \
-    ParExpr, PersistentAssignment, PreconditionItem, PropertyReference, RenameOp, \
-    Scalar as ScalarNode, Set, Start, SubOp, TemporaryAssignment, \
-    TimeShiftOp, UnaryOp, VarID, VarRef, WhereClauseOp, WithExpression
-from py_dpm.AST.ASTTemplate import ASTTemplate
-from py_dpm.DataTypes.ScalarTypes import Item, Mixed, Null, ScalarFactory
-from py_dpm.DataTypes.TypePromotion import binary_implicit_type_promotion
-from py_dpm.Exceptions import exceptions
-from py_dpm.Exceptions.exceptions import SemanticError
-from py_dpm.Utils.operands_mapping import set_operand_label
-from py_dpm.Utils.operator_mapping import AGGR_OP_MAPPING, BIN_OP_MAPPING, CLAUSE_OP_MAPPING, \
-    COMPLEX_OP_MAPPING, CONDITIONAL_OP_MAPPING, \
-    TIME_OPERATORS, UNARY_OP_MAPPING
-from py_dpm.Utils.tokens import DPM, FILTER, GET, IF, RENAME, STANDARD, SUB, TIME_SHIFT, WHERE
-from py_dpm.data_handlers import filter_all_data
-from py_dpm.semantics.Symbols import ConstantOperand, FactComponent, KeyComponent, RecordSet, \
-    Scalar, \
-    ScalarSet, Structure
+from py_dpm.dpm_xl.ast.nodes import (
+    AggregationOp,
+    BinOp,
+    ComplexNumericOp,
+    CondExpr,
+    Constant,
+    Dimension,
+    FilterOp,
+    GetOp,
+    OperationRef,
+    ParExpr,
+    PersistentAssignment,
+    PreconditionItem,
+    PropertyReference,
+    RenameOp,
+    Scalar as ScalarNode,
+    Set,
+    Start,
+    SubOp,
+    TemporaryAssignment,
+    TimeShiftOp,
+    UnaryOp,
+    VarID,
+    VarRef,
+    WhereClauseOp,
+    WithExpression,
+)
+from py_dpm.dpm_xl.ast.template import ASTTemplate
+from py_dpm.dpm_xl.types.scalar import Item, Mixed, Null, ScalarFactory
+from py_dpm.dpm_xl.types.promotion import binary_implicit_type_promotion
+from py_dpm.exceptions import exceptions
+from py_dpm.exceptions.exceptions import SemanticError
+from py_dpm.dpm_xl.utils.operands_mapping import set_operand_label
+from py_dpm.dpm_xl.utils.operator_mapping import (
+    AGGR_OP_MAPPING,
+    BIN_OP_MAPPING,
+    CLAUSE_OP_MAPPING,
+    COMPLEX_OP_MAPPING,
+    CONDITIONAL_OP_MAPPING,
+    TIME_OPERATORS,
+    UNARY_OP_MAPPING,
+)
+from py_dpm.dpm_xl.utils.tokens import (
+    DPM,
+    FILTER,
+    GET,
+    IF,
+    RENAME,
+    STANDARD,
+    SUB,
+    TIME_SHIFT,
+    WHERE,
+)
+from py_dpm.dpm_xl.utils.data_handlers import filter_all_data
+from py_dpm.dpm_xl.symbols import (
+    ConstantOperand,
+    FactComponent,
+    KeyComponent,
+    RecordSet,
+    Scalar,
+    ScalarSet,
+    Structure,
+)
 
 
 class InputAnalyzer(ASTTemplate, ABC):
@@ -37,7 +81,9 @@ class InputAnalyzer(ASTTemplate, ABC):
 
         self.calculations_outputs = {}
 
-        self.global_variables = {'refPeriod': ScalarFactory().database_types_mapping('d')()}
+        self.global_variables = {
+            "refPeriod": ScalarFactory().database_types_mapping("d")()
+        }
 
     # Start of visiting nodes.
 
@@ -48,12 +94,18 @@ class InputAnalyzer(ASTTemplate, ABC):
             result_symbol = self.visit(child)
 
             if self.preconditions:
-                if isinstance(result_symbol, Scalar) and not result_symbol.type.strictly_same_class(ScalarFactory().scalar_factory("Boolean")):
+                if isinstance(
+                    result_symbol, Scalar
+                ) and not result_symbol.type.strictly_same_class(
+                    ScalarFactory().scalar_factory("Boolean")
+                ):
                     raise exceptions.SemanticError("2-1")
                 elif isinstance(result_symbol, RecordSet):
                     if (not result_symbol.has_only_global_components) or (
                         not result_symbol.get_fact_component().type.strictly_same_class(
-                            ScalarFactory().scalar_factory("Boolean"))):
+                            ScalarFactory().scalar_factory("Boolean")
+                        )
+                    ):
                         raise exceptions.SemanticError("2-1")
 
             if len(node.children) == 1:
@@ -92,7 +144,9 @@ class InputAnalyzer(ASTTemplate, ABC):
         condition_symbol = self.visit(node.condition)
         then_symbol = self.visit(node.then_expr)
         else_symbol = None if node.else_expr is None else self.visit(node.else_expr)
-        result = CONDITIONAL_OP_MAPPING[IF].validate(condition_symbol, then_symbol, else_symbol)
+        result = CONDITIONAL_OP_MAPPING[IF].validate(
+            condition_symbol, then_symbol, else_symbol
+        )
         return result
 
     def visit_VarRef(self, node: VarRef):
@@ -109,48 +163,63 @@ class InputAnalyzer(ASTTemplate, ABC):
         try:
             binary_implicit_type_promotion(default_type, type_)
         except SemanticError:
-            raise exceptions.SemanticError("3-6", expected_type=type_, default_type=default_type)
-
+            raise exceptions.SemanticError(
+                "3-6", expected_type=type_, default_type=default_type
+            )
 
     def visit_VarID(self, node: VarID):
 
-        self.__check_default_value(node.default, getattr(node, 'type'))
+        self.__check_default_value(node.default, getattr(node, "type"))
 
         # filter by table_code
         df = filter_all_data(self.data, node.table, node.rows, node.cols, node.sheets)
 
         scalar_factory = ScalarFactory()
         interval = getattr(node, "interval", None)
-        data_types = df["data_type"].apply(lambda x: scalar_factory.from_database_to_scalar_types(x, interval))
-        df['data_type'] = data_types
+        data_types = df["data_type"].apply(
+            lambda x: scalar_factory.from_database_to_scalar_types(x, interval)
+        )
+        df["data_type"] = data_types
 
         label = getattr(node, "label", None)
         components = []
         if self.key_components and node.table in self.key_components:
             dpm_keys = self.key_components[node.table]
             if len(dpm_keys) > 0:
-                for key_name, key_type in zip(dpm_keys['property_code'], dpm_keys['data_type']):
+                for key_name, key_type in zip(
+                    dpm_keys["property_code"], dpm_keys["data_type"]
+                ):
                     if not key_type:
                         type_ = Item()
                     else:
                         type_ = ScalarFactory().database_types_mapping(key_type)()
-                    components.append(KeyComponent(name=key_name, type_=type_, subtype=DPM, parent=label))
+                    components.append(
+                        KeyComponent(
+                            name=key_name, type_=type_, subtype=DPM, parent=label
+                        )
+                    )
 
         standard_keys = []
-        self._check_standard_key(standard_keys, df['row_code'], 'r', label)
-        self._check_standard_key(standard_keys, df['column_code'], 'c', label)
-        self._check_standard_key(standard_keys, df['sheet_code'], 's', label)
+        self._check_standard_key(standard_keys, df["row_code"], "r", label)
+        self._check_standard_key(standard_keys, df["column_code"], "c", label)
+        self._check_standard_key(standard_keys, df["sheet_code"], "s", label)
 
         if len(self.global_variables):
             for var_name, var_type in self.global_variables.items():
-                var_component = KeyComponent(name=var_name, type_=var_type, subtype=DPM, parent=label, is_global=True)
+                var_component = KeyComponent(
+                    name=var_name,
+                    type_=var_type,
+                    subtype=DPM,
+                    parent=label,
+                    is_global=True,
+                )
                 components.append(var_component)
 
         components.extend(standard_keys)
         if len(components) == 0:
             set_operand_label(label=label, operand=node)
-            return Scalar(type_=getattr(node, 'type'), name=label, origin=label)
-        fact_component = FactComponent(type_=getattr(node, 'type'), parent=label)
+            return Scalar(type_=getattr(node, "type"), name=label, origin=label)
+        fact_component = FactComponent(type_=getattr(node, "type"), parent=label)
 
         components.append(fact_component)
         structure = Structure(components)
@@ -161,16 +230,16 @@ class InputAnalyzer(ASTTemplate, ABC):
         if len(standard_keys) > 0:
             for key in standard_keys:
                 standard_key_names.append(key.name)
-                if key.name == 'r':
-                    records.append(df['row_code'])
-                elif key.name == 'c':
-                    records.append(df['column_code'])
-                elif key.name == 's':
-                    records.append(df['sheet_code'])
+                if key.name == "r":
+                    records.append(df["row_code"])
+                elif key.name == "c":
+                    records.append(df["column_code"])
+                elif key.name == "s":
+                    records.append(df["sheet_code"])
 
             df_records = pd.concat(records, axis=1)
             df_records.columns = standard_key_names
-            df_records['data_type'] = df['data_type']
+            df_records["data_type"] = df["data_type"]
 
             # Check for duplicate keys, but only among non-NULL combinations
             # NULL values can repeat without being considered duplicates
@@ -179,32 +248,47 @@ class InputAnalyzer(ASTTemplate, ABC):
             df_non_null_keys = df_records[~mask_all_null]
 
             if len(df_non_null_keys) > 0:
-                repeated_identifiers = df_non_null_keys[df_non_null_keys[standard_key_names].duplicated(keep=False)]
+                repeated_identifiers = df_non_null_keys[
+                    df_non_null_keys[standard_key_names].duplicated(keep=False)
+                ]
                 # Further filter: only report duplicates where NO key is NULL (fully specified duplicates)
-                mask_has_null = repeated_identifiers[standard_key_names].isnull().any(axis=1)
+                mask_has_null = (
+                    repeated_identifiers[standard_key_names].isnull().any(axis=1)
+                )
                 fully_specified_duplicates = repeated_identifiers[~mask_has_null]
 
                 if len(fully_specified_duplicates) > 0:
                     repeated_values = ""
                     for value in fully_specified_duplicates.values:
-                        repeated_values = ', '.join([repeated_values, str(value)]) if repeated_values else str(value)
-                    raise exceptions.SemanticError("2-6", name=getattr(node, 'label', None), keys=standard_key_names,
-                                                   values=repeated_values)
+                        repeated_values = (
+                            ", ".join([repeated_values, str(value)])
+                            if repeated_values
+                            else str(value)
+                        )
+                    raise exceptions.SemanticError(
+                        "2-6",
+                        name=getattr(node, "label", None),
+                        keys=standard_key_names,
+                        values=repeated_values,
+                    )
 
             recordset.records = df_records
 
-
         return recordset
 
     @staticmethod
     def _check_standard_key(key_components, elements, name, parent):
         if len(elements) > 1 and len(elements.unique()) > 1:
-            key_component = KeyComponent(name=name, type_=Null(), subtype=STANDARD, parent=parent)
+            key_component = KeyComponent(
+                name=name, type_=Null(), subtype=STANDARD, parent=parent
+            )
             key_components.append(key_component)
 
     def visit_Constant(self, node: Constant):
         constant_type = ScalarFactory().scalar_factory(code=node.type)
-        return ConstantOperand(type_=constant_type, name=None, origin=node.value, value=node.value)
+        return ConstantOperand(
+            type_=constant_type, name=None, origin=node.value, value=node.value
+        )
 
     def visit_AggregationOp(self, node: AggregationOp):
         operand = self.visit(node.operand)
@@ -213,27 +297,31 @@ class InputAnalyzer(ASTTemplate, ABC):
 
         if operand.has_only_global_components:
             warnings.warn(
-                f"Performing an aggregation on recordset: {operand.name} which has only global key components")
+                f"Performing an aggregation on recordset: {operand.name} which has only global key components"
+            )
 
         grouping_clause = None
         if node.grouping_clause:
             grouping_clause = node.grouping_clause.components
 
         if isinstance(operand.get_fact_component().type, Mixed):
-            origin_expression =AGGR_OP_MAPPING[node.op].generate_origin_expression(operand, grouping_clause)
+            origin_expression = AGGR_OP_MAPPING[node.op].generate_origin_expression(
+                operand, grouping_clause
+            )
             raise exceptions.SemanticError("4-4-0-3", origin=origin_expression)
 
         result = AGGR_OP_MAPPING[node.op].validate(operand, grouping_clause)
         return result
 
     def visit_Dimension(self, node: Dimension):
-        dimension_data = self.open_keys[self.open_keys['property_code'] == node.dimension_code].reset_index(
-            drop=True)
-        if dimension_data['data_type'][0] is not None:
-            type_code = dimension_data['data_type'][0]
+        dimension_data = self.open_keys[
+            self.open_keys["property_code"] == node.dimension_code
+        ].reset_index(drop=True)
+        if dimension_data["data_type"][0] is not None:
+            type_code = dimension_data["data_type"][0]
             type_ = ScalarFactory().database_types_mapping(code=type_code)()
         else:
-            type_ = ScalarFactory().scalar_factory(code='Item')
+            type_ = ScalarFactory().scalar_factory(code="Item")
         return Scalar(type_=type_, name=None, origin=node.dimension_code)
 
     def visit_Set(self, node: Set):
@@ -241,15 +329,15 @@ class InputAnalyzer(ASTTemplate, ABC):
         if isinstance(node.children[0], Constant):
             types = {child.type for child in node.children}
             if len(types) > 1:
-                raise exceptions.SemanticError('11', types=', '.join(types))
+                raise exceptions.SemanticError("11", types=", ".join(types))
             common_type_code = types.pop()
             origin_elements = [str(child.value) for child in node.children]
         else:
-            common_type_code = 'Item'
+            common_type_code = "Item"
             origin_elements = ["[" + child.item + "]" for child in node.children]
         common_type = ScalarFactory().scalar_factory(common_type_code)
-        origin = ', '.join(origin_elements)
-        origin = "{" + origin + '}'
+        origin = ", ".join(origin_elements)
+        origin = "{" + origin + "}"
 
         return ScalarSet(type_=common_type, name=None, origin=origin)
 
@@ -276,8 +364,12 @@ class InputAnalyzer(ASTTemplate, ABC):
         operand = self.visit(node.operand)
         if not isinstance(operand, (RecordSet, Scalar, ConstantOperand)):
             raise exceptions.SemanticError("4-7-1", op=TIME_SHIFT)
-        result = TIME_OPERATORS[TIME_SHIFT].validate(operand=operand, component_name=node.component,
-                                                     period=node.period_indicator, shift_number=node.shift_number)
+        result = TIME_OPERATORS[TIME_SHIFT].validate(
+            operand=operand,
+            component_name=node.component,
+            period=node.period_indicator,
+            shift_number=node.shift_number,
+        )
         return result
 
     def visit_WhereClauseOp(self, node: WhereClauseOp):
@@ -288,8 +380,12 @@ class InputAnalyzer(ASTTemplate, ABC):
             raise exceptions.SemanticError("4-5-2-1", recordset=operand.name)
 
         condition = self.visit(node.condition)
-        result = CLAUSE_OP_MAPPING[WHERE].validate(operand=operand, key_names=node.key_components, new_names=None,
-                                                   condition=condition)
+        result = CLAUSE_OP_MAPPING[WHERE].validate(
+            operand=operand,
+            key_names=node.key_components,
+            new_names=None,
+            condition=condition,
+        )
         return result
 
     def visit_RenameOp(self, node: RenameOp):
@@ -299,7 +395,9 @@ class InputAnalyzer(ASTTemplate, ABC):
         for rename_node in node.rename_nodes:
             names.append(rename_node.old_name)
             new_names.append(rename_node.new_name)
-        result = CLAUSE_OP_MAPPING[RENAME].validate(operand=operand, key_names=names, new_names=new_names)
+        result = CLAUSE_OP_MAPPING[RENAME].validate(
+            operand=operand, key_names=names, new_names=new_names
+        )
         return result
 
     def visit_GetOp(self, node: GetOp):
@@ -311,7 +409,9 @@ class InputAnalyzer(ASTTemplate, ABC):
     def visit_SubOp(self, node: SubOp):
         operand = self.visit(node.operand)
         value = self.visit(node.value)
-        result = CLAUSE_OP_MAPPING[SUB].validate(operand=operand, property_code=node.property_code, value=value)
+        result = CLAUSE_OP_MAPPING[SUB].validate(
+            operand=operand, property_code=node.property_code, value=value
+        )
         return result
 
     def visit_PreconditionItem(self, node: PreconditionItem) -> Scalar:

py_dpm/{semantics/Symbols.py → dpm_xl/symbols.py}

@@ -1,8 +1,8 @@
 from typing import List, Union
 
-from py_dpm.DataTypes.ScalarTypes import ScalarFactory
-from py_dpm.Exceptions.exceptions import SemanticError
-from py_dpm.Utils.tokens import DPM, STANDARD
+from py_dpm.dpm_xl.types.scalar import ScalarFactory
+from py_dpm.exceptions.exceptions import SemanticError
+from py_dpm.dpm_xl.utils.tokens import DPM, STANDARD
 
 
 class Operand:

py_dpm/dpm_xl/types/__init__.py

@@ -0,0 +1,13 @@
+"""
+DPM-XL Type System
+
+Type definitions, type checking, and type promotion rules for DPM-XL expressions.
+"""
+
+from py_dpm.dpm_xl.types.scalar import *
+from py_dpm.dpm_xl.types.time import *
+from py_dpm.dpm_xl.types.promotion import *
+
+__all__ = [
+    # Re-export will be handled by import *
+]

py_dpm/{DataTypes/TypePromotion.py → dpm_xl/types/promotion.py}

@@ -1,8 +1,8 @@
 import warnings
 
-from py_dpm.DataTypes.ScalarTypes import Boolean, Date, Duration, Integer, Item, Mixed, Null, Number, \
+from py_dpm.dpm_xl.types.scalar import Boolean, Date, Duration, Integer, Item, Mixed, Null, Number, \
     ScalarType, String, Subcategory, TimeInterval, TimePeriod
-from py_dpm.Exceptions.exceptions import SemanticError
+from py_dpm.exceptions.exceptions import SemanticError
 
 implicit_type_promotion_dict = {
     String: {String},

py_dpm/{DataTypes/ScalarTypes.py → dpm_xl/types/scalar.py}

@@ -1,8 +1,8 @@
 import numpy as np
 import pandas as pd
 
-from py_dpm.DataTypes.TimeClasses import timeParser, timePeriodParser
-from py_dpm.Exceptions.exceptions import DataTypeError, SemanticError
+from py_dpm.dpm_xl.types.time import timeParser, timePeriodParser
+from py_dpm.exceptions.exceptions import DataTypeError, SemanticError
 
 
 class ScalarType:

py_dpm/dpm_xl/utils/__init__.py

@@ -0,0 +1,14 @@
+"""
+DPM-XL Utilities
+
+Utility functions and mappings for DPM-XL processing.
+"""
+
+from py_dpm.dpm_xl.utils.operands_mapping import *
+from py_dpm.dpm_xl.utils.operator_mapping import *
+from py_dpm.dpm_xl.utils.tokens import *
+from py_dpm.dpm_xl.utils.serialization import *
+
+__all__ = [
+    # Re-export will be handled by import *
+]

py_dpm/{data_handlers.py → dpm_xl/utils/data_handlers.py}

@@ -1,7 +1,7 @@
 import pandas as pd
 
-from py_dpm.Exceptions.exceptions import SemanticError
-from py_dpm.Utils.tokens import *
+from py_dpm.exceptions.exceptions import SemanticError
+from py_dpm.dpm_xl.utils.tokens import *
 
 
 def filter_data_by_cell_element(series, cell_elements, element_name, table_code):

py_dpm/{Utils → dpm_xl/utils}/operands_mapping.py

@@ -2,7 +2,7 @@ import itertools
 import string
 from typing import Union
 
-from py_dpm.AST.ASTObjects import PreconditionItem, VarID
+from py_dpm.dpm_xl.ast.nodes import PreconditionItem, VarID
 
 
 class LabelHandler:

py_dpm/{Utils → dpm_xl/utils}/operator_mapping.py

@@ -1,13 +1,13 @@
-from py_dpm.Operators.AggregateOperators import Avg, Count, MaxAggr, Median, MinAggr, Sum
-from py_dpm.Operators.BooleanOperators import And, Not, Or, Xor
-from py_dpm.Operators.ClauseOperators import Get, Rename, Sub, Where
-from py_dpm.Operators.ComparisonOperators import Equal, Greater, GreaterEqual, In, IsNull, Less, LessEqual, Match, NotEqual
-from py_dpm.Operators.ConditionalOperators import Filter, IfOperator, Nvl
-from py_dpm.Operators.NumericOperators import AbsoluteValue, BinMinus, BinPlus, Div, Exponential, Logarithm, \
+from py_dpm.dpm_xl.operators.aggregate import Avg, Count, MaxAggr, Median, MinAggr, Sum
+from py_dpm.dpm_xl.operators.boolean import And, Not, Or, Xor
+from py_dpm.dpm_xl.operators.clause import Get, Rename, Sub, Where
+from py_dpm.dpm_xl.operators.comparison import Equal, Greater, GreaterEqual, In, IsNull, Less, LessEqual, Match, NotEqual
+from py_dpm.dpm_xl.operators.conditional import Filter, IfOperator, Nvl
+from py_dpm.dpm_xl.operators.arithmetic import AbsoluteValue, BinMinus, BinPlus, Div, Exponential, Logarithm, \
     Max, Min, Mult, NaturalLogarithm, \
     Power, SquareRoot, UnMinus, UnPlus
-from py_dpm.Operators.StringOperators import Concatenate, Len
-from py_dpm.Operators.TimeOperators import TimeShift
+from py_dpm.dpm_xl.operators.string import Concatenate, Len
+from py_dpm.dpm_xl.operators.time import TimeShift
 from .tokens import *
 
 BIN_OP_MAPPING = {