vtlengine 1.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

vtlengine/Operators/General.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Any, Union
 
 import pandas as pd
 import sqlite3
@@ -20,38 +20,47 @@ class Membership(Binary):
     """
 
     @classmethod
-    def validate(cls, left_operand: Dataset, right_operand: str):
+    def validate(cls, left_operand: Any, right_operand: Any) -> Dataset:
         if right_operand not in left_operand.components:
-            raise SemanticError("1-1-1-10", op=cls.op, comp_name=right_operand,
-                                dataset_name=left_operand.name)
+            raise SemanticError(
+                "1-1-1-10", op=cls.op, comp_name=right_operand, dataset_name=left_operand.name
+            )
 
         component = left_operand.components[right_operand]
         if component.role in (Role.IDENTIFIER, Role.ATTRIBUTE):
             right_operand = COMP_NAME_MAPPING[component.data_type]
-            left_operand.components[right_operand] = Component(name=right_operand,
-                                                               data_type=component.data_type,
-                                                               role=Role.MEASURE,
-                                                               nullable=component.nullable)
+            left_operand.components[right_operand] = Component(
+                name=right_operand,
+                data_type=component.data_type,
+                role=Role.MEASURE,
+                nullable=component.nullable,
+            )
             if left_operand.data is not None:
                 left_operand.data[right_operand] = left_operand.data[component.name]
             left_operand.data[right_operand] = left_operand.data[component.name]
-
-        result_components = {name: comp for name, comp in left_operand.components.items()
-                             if comp.role == Role.IDENTIFIER or comp.name == right_operand}
+        result_components = {
+            name: comp
+            for name, comp in left_operand.components.items()
+            if comp.role == Role.IDENTIFIER or comp.name == right_operand
+        }
         result_dataset = Dataset(name="result", components=result_components, data=None)
         return result_dataset
 
     @classmethod
-    def evaluate(cls, left_operand: Dataset, right_operand: str,
-                 is_from_component_assignment=False) -> Dataset:
+    def evaluate(
+        cls, left_operand: Dataset, right_operand: str, is_from_component_assignment: bool = False
+    ) -> Union[DataComponent, Dataset]:
         result_dataset = cls.validate(left_operand, right_operand)
-        if is_from_component_assignment:
-            return DataComponent(name=right_operand,
-                                 data_type=left_operand.components[right_operand].data_type,
-                                 role=Role.MEASURE,
-                                 nullable=left_operand.components[right_operand].nullable,
-                                 data=left_operand.data[right_operand])
-        result_dataset.data = left_operand.data[list(result_dataset.components.keys())]
+        if left_operand.data is not None:
+            if is_from_component_assignment:
+                return DataComponent(
+                    name=right_operand,
+                    data_type=left_operand.components[right_operand].data_type,
+                    role=Role.MEASURE,
+                    nullable=left_operand.components[right_operand].nullable,
+                    data=left_operand.data[right_operand],
+                )
+            result_dataset.data = left_operand.data[list(result_dataset.components.keys())]
         return result_dataset
 
 
@@ -60,19 +69,19 @@ class Alias(Binary):
     It inherits from Binary class, and has the following class methods:
 
     Class methods:
-        Validate: Ensures the name given in the right operand is different from the name of the Dataset.
-        Evaluate: Checks if the data between both operators are the same.
+        Validate: Ensures the name given in the right operand is different from the
+        name of the Dataset. Evaluate: Checks if the data between both operators are the same.
     """
 
     @classmethod
-    def validate(cls, left_operand: Dataset, right_operand: str):
+    def validate(cls, left_operand: Dataset, right_operand: Union[str, Dataset]) -> Dataset:
         new_name = right_operand if isinstance(right_operand, str) else right_operand.name
         if new_name != left_operand.name and new_name in left_operand.get_components_names():
             raise SemanticError("1-3-1", alias=new_name)
         return Dataset(name=new_name, components=left_operand.components, data=None)
 
     @classmethod
-    def evaluate(cls, left_operand: Dataset, right_operand: str) -> Dataset:
+    def evaluate(cls, left_operand: Dataset, right_operand: Union[str, Dataset]) -> Dataset:
         result = cls.validate(left_operand, right_operand)
         result.data = left_operand.data
         return result
@@ -83,14 +92,16 @@ class Eval(Unary):
     It inherits from Unary class and has the following class methods
 
     Class methods:
-        Validate: checks if the external routine name is the same as the operand name, which must be a Dataset.
+        Validate: checks if the external routine name is the same as the operand name,
+        which must be a Dataset.
         Evaluate: Checks if the operand and the output is actually a Dataset.
 
     """
 
     @staticmethod
-    def _execute_query(query: str, dataset_names: List[str],
-                       data: Dict[str, pd.DataFrame]) -> pd.DataFrame:
+    def _execute_query(
+        query: str, dataset_names: List[str], data: Dict[str, pd.DataFrame]
+    ) -> pd.DataFrame:
         try:
             conn = sqlite3.connect(":memory:")
             try:
@@ -111,25 +122,33 @@ class Eval(Unary):
         return df_result
 
     @classmethod
-    def validate(cls, operands: Dict[str, Dataset], external_routine: ExternalRoutine,
-                 output: Dataset) -> Dataset:
+    def validate(  # type: ignore[override]
+        cls,
+        operands: Dict[str, Dataset],
+        external_routine: ExternalRoutine,
+        output: Dataset,
+    ) -> Dataset:
 
         empty_data_dict = {}
         for ds_name in external_routine.dataset_names:
             if ds_name not in operands:
-                raise ValueError(f"External Routine dataset {ds_name} "
-                                 f"is not present in Eval operands")
+                raise ValueError(
+                    f"External Routine dataset {ds_name} " f"is not present in Eval operands"
+                )
             empty_data = pd.DataFrame(
-                columns=[comp.name for comp in operands[ds_name].components.values()])
+                columns=[comp.name for comp in operands[ds_name].components.values()]
+            )
             empty_data_dict[ds_name] = empty_data
 
-        df = cls._execute_query(external_routine.query, external_routine.dataset_names,
-                                empty_data_dict)
+        df = cls._execute_query(
+            external_routine.query, external_routine.dataset_names, empty_data_dict
+        )
         component_names = [name for name in df.columns]
         for comp_name in component_names:
             if comp_name not in output.components:
-                raise SemanticError("1-1-1-10", op=cls.op, comp_name=comp_name,
-                                    dataset_name=df.name)
+                raise SemanticError(
+                    "1-1-1-10", op=cls.op, comp_name=comp_name, dataset_name=df.name
+                )
 
         for comp_name in output.components:
             if comp_name not in component_names:
@@ -140,15 +159,17 @@ class Eval(Unary):
         return output
 
     @classmethod
-    def evaluate(cls, operands: Dict[str, Dataset], external_routine: ExternalRoutine,
-                 output: Dataset) -> Dataset:
-        result = cls.validate(operands, external_routine, output)
-
-        operands_data_dict = {ds_name: operands[ds_name].data
-                              for ds_name in operands}
-
-        result.data = cls._execute_query(external_routine.query,
-                                         external_routine.dataset_names,
-                                         operands_data_dict)
-
+    def evaluate(  # type: ignore[override]
+        cls,
+        operands: Dict[str, Dataset],
+        external_routine: ExternalRoutine,
+        output: Dataset,
+    ) -> Dataset:
+        result: Dataset = cls.validate(operands, external_routine, output)
+        operands_data_dict = {ds_name: operands[ds_name].data for ds_name in operands}
+        result.data = cls._execute_query(
+            external_routine.query,
+            external_routine.dataset_names,
+            operands_data_dict,  # type: ignore[arg-type]
+        )
         return result

vtlengine/Operators/HROperators.py

@@ -17,38 +17,39 @@ def get_measure_from_dataset(dataset: Dataset, code_item: str) -> DataComponent:
         data = None
     else:
         data = dataset.data[measure_name]
-    return DataComponent(name=code_item, data=data,
-                         data_type=dataset.components[measure_name].data_type,
-                         role=dataset.components[measure_name].role,
-                         nullable=dataset.components[measure_name].nullable)
+    return DataComponent(
+        name=code_item,
+        data=data,
+        data_type=dataset.components[measure_name].data_type,
+        role=dataset.components[measure_name].role,
+        nullable=dataset.components[measure_name].nullable,
+    )
 
 
 class HRComparison(Operators.Binary):
 
     @classmethod
-    def imbalance_func(cls, x, y):
+    def imbalance_func(cls, x: Any, y: Any) -> Any:
         if pd.isnull(x) or pd.isnull(y):
             return None
         return x - y
 
     @staticmethod
-    def hr_func(x, y, hr_mode, func):
+    def hr_func(x: Any, y: Any, hr_mode: str, func: Any) -> Any:
         # In comments, it is specified the condition for evaluating the rule,
         # so we delete the cases that does not satisfy the condition
         # (line 6509 of the reference manual)
-        if (hr_mode in ('partial_null', 'partial_zero') and
-                not pd.isnull(y) and
-                y == "REMOVE_VALUE"):
-            if hr_mode == 'partial_null' and pd.isnull(x):
+        if hr_mode in ("partial_null", "partial_zero") and not pd.isnull(y) and y == "REMOVE_VALUE":
+            if hr_mode == "partial_null" and pd.isnull(x):
                 return "REMOVE_VALUE"
-            elif hr_mode == 'partial_zero' and not pd.isnull(x) and x == 0:
+            elif hr_mode == "partial_zero" and not pd.isnull(x) and x == 0:
                 return "REMOVE_VALUE"
             return None
-        if hr_mode == 'non_null':
+        if hr_mode == "non_null":
             # If all the involved Data Points are not NULL
             if pd.isnull(x) or pd.isnull(y):
                 return "REMOVE_VALUE"
-        elif hr_mode == 'non_zero':
+        elif hr_mode == "non_zero":
             # If at least one of the involved Data Points is <> zero
             if not (pd.isnull(x) and pd.isnull(y)) and (x == 0 and y == 0):
                 return "REMOVE_VALUE"
@@ -56,64 +57,72 @@ class HRComparison(Operators.Binary):
         return func(x, y)
 
     @classmethod
-    def apply_hr_func(cls, left_series, right_series, hr_mode, func):
+    def apply_hr_func(cls, left_series: Any, right_series: Any, hr_mode: str, func: Any) -> Any:
         return left_series.combine(right_series, lambda x, y: cls.hr_func(x, y, hr_mode, func))
 
     @classmethod
     def validate(cls, left_operand: Dataset, right_operand: DataComponent, hr_mode: str) -> Dataset:
-        result_components = {comp_name: copy(comp) for comp_name, comp in
-                             left_operand.components.items() if comp.role == Role.IDENTIFIER}
-        result_components['bool_var'] = Component(name='bool_var',
-                                                  data_type=Boolean,
-                                                  role=Role.MEASURE,
-                                                  nullable=True)
-        result_components['imbalance'] = Component(name='imbalance',
-                                                   data_type=Number,
-                                                   role=Role.MEASURE,
-                                                   nullable=True)
-        return Dataset(name=f"{left_operand.name}{cls.op}{right_operand.name}",
-                       components=result_components,
-                       data=None)
+        result_components = {
+            comp_name: copy(comp)
+            for comp_name, comp in left_operand.components.items()
+            if comp.role == Role.IDENTIFIER
+        }
+        result_components["bool_var"] = Component(
+            name="bool_var", data_type=Boolean, role=Role.MEASURE, nullable=True
+        )
+        result_components["imbalance"] = Component(
+            name="imbalance", data_type=Number, role=Role.MEASURE, nullable=True
+        )
+        return Dataset(
+            name=f"{left_operand.name}{cls.op}{right_operand.name}",
+            components=result_components,
+            data=None,
+        )
 
     @classmethod
-    def evaluate(cls, left: Dataset, right: DataComponent, hr_mode: str) -> Dataset:
+    def evaluate(  # type: ignore[override]
+        cls, left: Dataset, right: DataComponent, hr_mode: str
+    ) -> Dataset:
         result = cls.validate(left, right, hr_mode)
-        result.data = left.data.copy()
+        result.data = left.data.copy() if left.data is not None else pd.DataFrame()
         measure_name = left.get_measures_names()[0]
-        result.data['bool_var'] = cls.apply_hr_func(left.data[measure_name], right.data,
-                                                    hr_mode, cls.op_func)
-        result.data['imbalance'] = cls.apply_hr_func(left.data[measure_name], right.data,
-                                                     hr_mode, cls.imbalance_func)
+        if left.data is not None and right.data is not None:
+            result.data["bool_var"] = cls.apply_hr_func(
+                left.data[measure_name], right.data, hr_mode, cls.op_func
+            )
+            result.data["imbalance"] = cls.apply_hr_func(
+                left.data[measure_name], right.data, hr_mode, cls.imbalance_func
+            )
         # Removing datapoints that should not be returned
         # (we do it below imbalance calculation
         # to avoid errors on different shape)
-        result.data = result.data[result.data['bool_var'] != "REMOVE_VALUE"]
+        result.data = result.data[result.data["bool_var"] != "REMOVE_VALUE"]
         result.data.drop(measure_name, axis=1, inplace=True)
         return result
 
 
 class HREqual(HRComparison):
-    op = '='
+    op = "="
     py_op = operator.eq
 
 
 class HRGreater(HRComparison):
-    op = '>'
+    op = ">"
     py_op = operator.gt
 
 
 class HRGreaterEqual(HRComparison):
-    op = '>='
+    op = ">="
     py_op = operator.ge
 
 
 class HRLess(HRComparison):
-    op = '<'
+    op = "<"
     py_op = operator.lt
 
 
 class HRLessEqual(HRComparison):
-    op = '<='
+    op = "<="
     py_op = operator.le
 
 
@@ -128,38 +137,46 @@ class HRBinNumeric(Operators.Binary):
     @classmethod
     def evaluate(cls, left: DataComponent, right: DataComponent) -> DataComponent:
         result_data = cls.apply_operation_two_series(left.data, right.data)
-        return DataComponent(name=f"{left.name}{cls.op}{right.name}", data=result_data,
-                             data_type=left.data_type,
-                             role=left.role, nullable=left.nullable)
+        return DataComponent(
+            name=f"{left.name}{cls.op}{right.name}",
+            data=result_data,
+            data_type=left.data_type,
+            role=left.role,
+            nullable=left.nullable,
+        )
 
 
 class HRBinPlus(HRBinNumeric):
-    op = '+'
+    op = "+"
     py_op = operator.add
 
 
 class HRBinMinus(HRBinNumeric):
-    op = '-'
+    op = "-"
     py_op = operator.sub
 
 
 class HRUnNumeric(Operators.Unary):
 
     @classmethod
-    def evaluate(cls, operand: DataComponent):
+    def evaluate(cls, operand: DataComponent) -> DataComponent:  # type: ignore[override]
         result_data = cls.apply_operation_component(operand.data)
-        return DataComponent(name=f"{cls.op}({operand.name})", data=result_data,
-                             data_type=operand.data_type,
-                             role=operand.role, nullable=operand.nullable)
+        return DataComponent(
+            name=f"{cls.op}({operand.name})",
+            data=result_data,
+            data_type=operand.data_type,
+            role=operand.role,
+            nullable=operand.nullable,
+        )
 
 
 class HRUnPlus(HRUnNumeric):
-    op = '+'
+    op = "+"
     py_op = operator.pos
 
 
 class HRUnMinus(HRUnNumeric):
-    op = '-'
+    op = "-"
     py_op = operator.neg
 
 
@@ -167,28 +184,28 @@ class HAAssignment(Operators.Binary):
 
     @classmethod
     def validate(cls, left: Dataset, right: DataComponent, hr_mode: str) -> Dataset:
-        result_components = {comp_name: copy(comp) for comp_name, comp in
-                             left.components.items()}
-        return Dataset(name=f"{left.name}",
-                       components=result_components,
-                       data=None)
+        result_components = {comp_name: copy(comp) for comp_name, comp in left.components.items()}
+        return Dataset(name=f"{left.name}", components=result_components, data=None)
 
     @classmethod
-    def evaluate(cls, left: Dataset, right: DataComponent, hr_mode: str) -> Dataset:
+    def evaluate(  # type: ignore[override]
+        cls, left: Dataset, right: DataComponent, hr_mode: str
+    ) -> Dataset:
         result = cls.validate(left, right, hr_mode)
         measure_name = left.get_measures_names()[0]
-        result.data = left.data.copy()
-        result.data[measure_name] = right.data.map(lambda x: cls.handle_mode(x, hr_mode))
+        result.data = left.data.copy() if left.data is not None else pd.DataFrame()
+        if right.data is not None:
+            result.data[measure_name] = right.data.map(lambda x: cls.handle_mode(x, hr_mode))
         result.data = result.data[result.data[measure_name] != "REMOVE_VALUE"]
         return result
 
     @classmethod
-    def handle_mode(cls, x, hr_mode):
+    def handle_mode(cls, x: Any, hr_mode: str) -> Any:
         if not pd.isnull(x) and x == "REMOVE_VALUE":
             return "REMOVE_VALUE"
-        if hr_mode == 'non_null' and pd.isnull(x):
+        if hr_mode == "non_null" and pd.isnull(x):
             return "REMOVE_VALUE"
-        elif hr_mode == 'non_zero' and x == 0:
+        elif hr_mode == "non_zero" and x == 0:
             return "REMOVE_VALUE"
         return x
 
@@ -204,17 +221,18 @@ class Hierarchy(Operators.Operator):
         return df
 
     @classmethod
-    def validate(cls, dataset: Dataset, computed_dict: Dict[str, DataFrame],
-                 output: str) -> Dataset:
-        result_components = {comp_name: copy(comp) for comp_name, comp in
-                             dataset.components.items()}
-        return Dataset(name=dataset.name,
-                       components=result_components,
-                       data=None)
+    def validate(
+        cls, dataset: Dataset, computed_dict: Dict[str, DataFrame], output: str
+    ) -> Dataset:
+        result_components = {
+            comp_name: copy(comp) for comp_name, comp in dataset.components.items()
+        }
+        return Dataset(name=dataset.name, components=result_components, data=None)
 
     @classmethod
-    def evaluate(cls, dataset: Dataset, computed_dict: Dict[str, DataFrame],
-                 output: str) -> Dataset:
+    def evaluate(
+        cls, dataset: Dataset, computed_dict: Dict[str, DataFrame], output: str
+    ) -> Dataset:
         result = cls.validate(dataset, computed_dict, output)
         if len(computed_dict) == 0:
             computed_data = pd.DataFrame(columns=dataset.get_components_names())
@@ -227,7 +245,8 @@ class Hierarchy(Operators.Operator):
         # union(setdiff(op, R), R) where R is the computed data.
         # It is the same as union(op, R) and drop duplicates, selecting the last one available
         result.data = pd.concat([dataset.data, computed_data], axis=0, ignore_index=True)
-        result.data.drop_duplicates(subset=dataset.get_identifiers_names(), keep='last',
-                                    inplace=True)
+        result.data.drop_duplicates(
+            subset=dataset.get_identifiers_names(), keep="last", inplace=True
+        )
         result.data.reset_index(drop=True, inplace=True)
         return result