pydpm_xl 0.1.10__py3-none-any.whl

py_dpm/Operators/AggregateOperators.py

@@ -0,0 +1,138 @@
+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
+
+
+class AggregateOperator(Operator.Unary):
+    """
+    Aggregate operators involve all operators with a Recordset and a Grouping clause.
+
+    The grouping clause components must be present in the operand recordset.
+    """
+    interval_allowed: bool = True
+
+    @staticmethod
+    def check_grouping(grouping_clause, key_components):
+
+        if grouping_clause and not all(item in key_components for item in grouping_clause):
+            not_present = [item for item in grouping_clause if item not in key_components]
+            raise exceptions.SemanticError("4-4-0-2", not_present=not_present)
+
+    @staticmethod
+    def format_structure_with_grouping(operand, grouping_clause):
+        structure = operand.structure
+
+        components_to_delete = []
+
+        for component in structure.components:
+            if component not in grouping_clause and component != 'refPeriod':
+                components_to_delete.append(component)
+
+        for item in components_to_delete:
+            del structure.components[item]
+
+        return structure
+
+    @staticmethod
+    def manage_records(records: pd.DataFrame, grouping_clause: list):
+        if records is None:
+            return records
+        columns_to_preserve = ['data_type']
+        for item in grouping_clause:
+            columns_to_preserve.append(item)
+
+        columns_to_delete = [item for item in records.columns if item not in columns_to_preserve]
+
+        for col in columns_to_delete:
+            del records[col]
+
+        if len(records.columns) == 1 and records.columns[0] == 'data_type':
+            return None
+
+        records = records.loc[records.astype(str).drop_duplicates(keep='first').index].reset_index(drop=True)
+
+        return records
+
+    @classmethod
+    def create_grouped_recordset(cls, operand: RecordSet, grouping_clause, final_type):
+
+        # Creating new structure with only the grouped components
+        rslt_structure = cls.format_structure_with_grouping(operand, grouping_clause)
+        origin = f"{cls.op}({operand.name} group by {', '.join(grouping_clause)})"
+        result_dataframe = cls.manage_records(operand.records, grouping_clause) if operand.records is not None else None
+        recordset = cls._create_labeled_recordset(origin=origin, rslt_type=final_type, rslt_structure=rslt_structure,
+                                                  result_dataframe=result_dataframe)
+        return recordset
+
+    @classmethod
+    def validate(cls, operand, grouping_clause):
+        cls.check_operator_well_defined()
+        return_type = None if not cls.return_type else ScalarFactory().scalar_factory(cls.return_type.__name__)
+        op_type_to_check = None if not cls.type_to_check else ScalarFactory().scalar_factory(cls.type_to_check.__name__)
+
+        error_info ={
+                'operand_name': operand.name,
+                'op': cls.op
+            }
+        fact_component_type = operand.structure.components["f"].type
+
+        final_type = unary_implicit_type_promotion(
+            fact_component_type, op_type_to_check, return_type=return_type, interval_allowed=cls.interval_allowed, error_info=error_info)
+        if operand.records is not None:
+            operand.records['data_type'] = final_type
+
+        if grouping_clause is None:
+            return cls.create_labeled_scalar(operand, final_type)
+
+        key_components = operand.get_key_components_names()
+        cls.check_grouping(grouping_clause, key_components)
+        if len(grouping_clause) == len(key_components):
+            warnings.warn(f"Grouping by all the key components of the Recordset: {','.join(key_components)}")
+
+        return cls.create_grouped_recordset(operand, grouping_clause, final_type)
+
+    @classmethod
+    def generate_origin_expression(cls, operand, group_by=None):
+        operand_name = getattr(operand, 'name', None) or getattr(operand, 'origin', None)
+        if group_by:
+            return f"{cls.op}({operand_name} group by {group_by})"
+        else:
+            return f"{cls.op}({operand_name})"
+
+
+class MaxAggr(AggregateOperator):
+    op = tokens.MAX_AGGR
+
+
+class MinAggr(AggregateOperator):
+    op = tokens.MIN_AGGR
+
+
+class Sum(AggregateOperator):
+    op = tokens.SUM
+    type_to_check = Number
+
+
+class Count(AggregateOperator):
+    op = tokens.COUNT
+    type_to_check = None
+    return_type = Integer
+
+
+class Avg(AggregateOperator):
+    op = tokens.AVG
+    type_to_check = Number
+    return_type = Number
+
+
+class Median(AggregateOperator):
+    op = tokens.MEDIAN
+    type_to_check = Number
+    return_type = Number

py_dpm/Operators/BooleanOperators.py

@@ -0,0 +1,30 @@
+import operator
+
+from py_dpm.DataTypes.ScalarTypes import Boolean
+from py_dpm.Operators import Operator
+from py_dpm.Utils import tokens
+
+
+class Binary(Operator.Binary):
+    type_to_check = Boolean
+
+
+class And(Binary):
+    op = tokens.AND
+    py_op = operator.and_
+
+
+class Or(Binary):
+    op = tokens.OR
+    py_op = operator.or_
+
+
+class Xor(Binary):
+    op = tokens.XOR
+    py_op = operator.xor
+
+
+class Not(Operator.Unary):
+    type_to_check = Boolean
+    op = tokens.NOT
+    py_op = operator.not_

py_dpm/Operators/ClauseOperators.py

@@ -0,0 +1,159 @@
+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
+
+
+class ClauseOperator(Operator):
+    op = None
+    check_new_names = False
+    precondition = False
+    propagate_attributes = True
+
+    @classmethod
+    def validate(cls, operand, key_names, new_names=None, condition=None):
+        if not isinstance(operand, RecordSet):
+            raise exceptions.SemanticError("4-5-0-2", operator=cls.op)
+
+        if condition:
+            cls._validate_condition(operand, condition)
+
+        if any(x in operand.get_standard_components() for x in key_names) or tokens.FACT in key_names:
+            raise exceptions.SemanticError("4-5-0-1", recordset=operand.name)
+
+        dpm_components = {**operand.get_dpm_components(), **operand.get_attributes()}
+
+        not_found = [name for name in key_names if name not in dpm_components]
+        if not_found:
+            raise exceptions.SemanticError("2-8", op=cls.op, dpm_keys=not_found, recordset=operand.name)
+
+        if cls.op == tokens.RENAME:
+            if len(new_names) > len(set(new_names)):
+                seen = set()
+                duplicated = list(set(x for x in new_names if x in seen or seen.add(x)))
+                raise exceptions.SemanticError("4-5-1-2", duplicated=duplicated)
+            existing_components = [name for name in new_names if name in dpm_components]
+            if existing_components:
+                raise exceptions.SemanticError("4-5-1-1", names=existing_components, recordset=operand.name)
+
+            for name, new_name in list(zip(key_names, new_names)):
+                if new_name in (
+                        tokens.ROW, tokens.COLUMN, tokens.SHEET, tokens.FACT, tokens.INDEX_X, tokens.INDEX_Y,
+                        tokens.INDEX_Z):
+                    raise exceptions.SemanticError("4-5-1-3", recordset=operand.name)
+                elif name not in operand.structure.components:
+                    raise exceptions.SemanticError("4-5-1-4", component=name, recordset=operand.name)
+                cls.rename_component(operand=operand, name=name, new_name=new_name)
+
+        if cls.op == tokens.WHERE:
+            origin = cls.generate_origin_expression(operand, condition)
+        elif cls.op == tokens.RENAME:
+            origin = cls.generate_origin_expression(operand, key_names, new_names)
+        else:
+            origin = cls.generate_origin_expression(operand, key_names[0])
+
+        return cls.generate_result_structure(operand, key_names, condition, origin)
+
+    @classmethod
+    def _validate_condition(cls, operand: RecordSet, condition):
+        boolean_type = ScalarFactory().scalar_factory('Boolean')
+        if isinstance(condition, RecordSet):
+            fact_component = condition.get_fact_component()
+            unary_implicit_type_promotion(fact_component.type, boolean_type)
+            cls._check_structures(operand, condition)
+        else:
+            unary_implicit_type_promotion(condition.type, boolean_type)
+
+    @classmethod
+    def _check_structures(cls, operand: RecordSet, condition: RecordSet):
+        operand_structure = operand.structure
+        condition_structure = condition.structure
+        if len(operand_structure.get_key_components()) == len(condition.get_key_components()):
+            origin = f"{operand.origin}[where {condition.origin}]"
+            # For better error management
+            class_check = Binary()
+            class_check.op = cls.op
+            class_check.check_same_components(operand_structure, condition_structure, origin)
+        else:
+            is_subset = ConditionalOperator.check_condition_is_subset(operand, condition)
+            if not is_subset:
+                raise exceptions.SemanticError("4-5-2-2", operand=operand.name, condition=condition.name)
+
+    @classmethod
+    def rename_component(cls, operand: RecordSet, name: str, new_name: str):
+        component = operand.structure.components[name]
+        del operand.structure.components[name]
+        component.name = new_name
+        operand.structure.components[new_name] = component
+
+    @classmethod
+    def generate_result_structure(cls, operand: RecordSet, key_names: List[str], condition, origin):
+
+        new_label = generate_new_label()
+        operand.structure.replace_components_parent(new_label)
+
+        if cls.op == tokens.GET:
+            selected_component = key_names[0]
+            component = operand.structure.components[selected_component]
+            del operand.structure.components[tokens.FACT]
+            fact_component = FactComponent(type_=component.type, parent=component.parent)
+            operand.structure.components[tokens.FACT] = fact_component
+
+        if not cls.propagate_attributes:
+            operand.structure.remove_attributes()
+
+        result = RecordSet(structure=operand.structure, name=new_label, origin=origin)
+        if condition and isinstance(condition, RecordSet):
+            result_dataframe = ConditionalOperator.generate_result_dataframe(operand, condition)
+            result.records = result_dataframe
+        else:
+            result.records = operand.records
+        set_operand_label(result.name, result.origin)
+        return result
+
+    @classmethod
+    def generate_origin_expression(cls, *args) -> str:
+        pass
+
+
+class Where(ClauseOperator):
+    op = tokens.WHERE
+
+    @classmethod
+    def validate_condition_type(cls, condition):
+        boolean_type = ScalarFactory().scalar_factory('Boolean')
+        error_info = {
+            'operand_name': condition.name,
+            'op': cls.op
+        }
+        unary_implicit_type_promotion(condition.type, boolean_type, error_info=error_info)
+
+    @classmethod
+    def generate_origin_expression(cls, operand, condition):
+        operand_name = getattr(operand, 'name', None) or getattr(operand, 'origin', None)
+        condition_name = getattr(condition, 'name', None) or getattr(condition, 'origin', None)
+        return f"{operand_name}[ where {condition_name}]"
+
+
+class Rename(ClauseOperator):
+    op = tokens.RENAME
+
+    @classmethod
+    def generate_origin_expression(cls, operand, old_names, new_names):
+        origin_nodes = [f"{old_names[i]} to {new_names[i]}" for i in range(len(old_names))]
+        return f"{operand.name} [ rename " + ', '.join(origin_nodes) + ']'
+
+
+class Get(ClauseOperator):
+    op = tokens.GET
+    propagate_attributes = False
+
+    @classmethod
+    def generate_origin_expression(cls, operand, component) -> str:
+        return f"{operand.name} [ get {component} ]"

py_dpm/Operators/ComparisonOperators.py

@@ -0,0 +1,69 @@
+import operator
+import re
+
+from py_dpm.DataTypes.ScalarTypes import Boolean, String
+from py_dpm.Operators import Operator
+from py_dpm.Utils import tokens
+
+
+class IsNull(Operator.Unary):
+    op = tokens.ISNULL
+    py_op = operator.truth
+    do_not_check_with_return_type = True
+    return_type = Boolean
+
+
+class Binary(Operator.Binary):
+    do_not_check_with_return_type = True
+    return_type = Boolean
+
+
+class Equal(Binary):
+    op = tokens.EQ
+    py_op = operator.eq
+
+
+class NotEqual(Binary):
+    op = tokens.NEQ
+    py_op = operator.ne
+
+
+class Greater(Binary):
+    op = tokens.GT
+    py_op = operator.gt
+
+
+class GreaterEqual(Binary):
+    op = tokens.GTE
+    py_op = operator.ge
+
+
+class Less(Binary):
+    op = tokens.LT
+    py_op = operator.lt
+
+
+class LessEqual(Binary):
+    op = tokens.LTE
+    py_op = operator.le
+
+
+class In(Binary):
+    op = tokens.IN
+
+    @classmethod
+    def py_op(cls, x, y):
+        return operator.contains(y, x)
+
+    py_op = py_op
+
+
+class Match(Binary):
+    op = tokens.MATCH
+    type_to_check = String
+
+    @classmethod
+    def py_op(cls, x, y):
+        return bool(re.fullmatch(y, x))
+
+    py_op = py_op