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

vtlengine/Operators/Numeric.py

@@ -8,9 +8,23 @@ import pandas as pd
 from vtlengine.DataTypes import Integer, Number
 from vtlengine.Operators import ALL_MODEL_DATA_TYPES
 
-from vtlengine.AST.Grammar.tokens import ABS, CEIL, DIV, EXP, FLOOR, LN, LOG, MINUS, MOD, MULT, \
-    PLUS, POWER, \
-    ROUND, SQRT, TRUNC
+from vtlengine.AST.Grammar.tokens import (
+    ABS,
+    CEIL,
+    DIV,
+    EXP,
+    FLOOR,
+    LN,
+    LOG,
+    MINUS,
+    MOD,
+    MULT,
+    PLUS,
+    POWER,
+    ROUND,
+    SQRT,
+    TRUNC,
+)
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import DataComponent, Dataset, Scalar
 
@@ -19,6 +33,7 @@ class Unary(Operator.Unary):
     """
     Checks that the unary operation is performed with a number.
     """
+
     type_to_check = Number
 
 
@@ -26,6 +41,7 @@ class Binary(Operator.Binary):
     """
     Checks that the binary operation is performed with numbers.
     """
+
     type_to_check = Number
 
     @classmethod
@@ -52,8 +68,9 @@ class Binary(Operator.Binary):
 
 class UnPlus(Unary):
     """
-    `Plus <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=94&zoom=100,72,142> `_ unary operator
+    `Plus <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=94&zoom=100,72,142> `_ unary operator # noqa E501
     """
+
     op = PLUS
     py_op = operator.pos
 
@@ -64,24 +81,27 @@ class UnPlus(Unary):
 
 class UnMinus(Unary):
     """
-    `Minus <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=95&zoom=100,72,414> `_unary operator
+    `Minus <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=95&zoom=100,72,414> `_unary operator # noqa E501
     """
+
     op = MINUS
     py_op = operator.neg
 
 
 class AbsoluteValue(Unary):
     """
-    `Absolute <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=112&zoom=100,72,801> `_ unary operator
+    `Absolute <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=112&zoom=100,72,801> `_ unary operator # noqa E501
     """
+
     op = ABS
     py_op = operator.abs
 
 
 class Exponential(Unary):
     """
-    `Exponential <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=114&zoom=100,72,94>`_ unary operator
+    `Exponential <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=114&zoom=100,72,94>`_ unary operator # noqa E501
     """
+
     op = EXP
     py_op = math.exp
     return_type = Number
@@ -89,9 +109,10 @@ class Exponential(Unary):
 
 class NaturalLogarithm(Unary):
     """
-    `Natural logarithm <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=115&zoom=100,72,394> `_
+    `Natural logarithm <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=115&zoom=100,72,394> `_ # noqa E501
     unary operator
     """
+
     op = LN
     py_op = math.log
     return_type = Number
@@ -99,9 +120,10 @@ class NaturalLogarithm(Unary):
 
 class SquareRoot(Unary):
     """
-    `Square Root <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=119&zoom=100,72,556> '_
+    `Square Root <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=119&zoom=100,72,556> '_ # noqa E501
     unary operator
     """
+
     op = SQRT
     py_op = math.sqrt
     return_type = Number
@@ -109,8 +131,9 @@ class SquareRoot(Unary):
 
 class Ceil(Unary):
     """
-    `Ceilling <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=110&zoom=100,72,94> `_ unary operator
+    `Ceilling <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=110&zoom=100,72,94> `_ unary operator # noqa E501
     """
+
     op = CEIL
     py_op = math.ceil
     return_type = Integer
@@ -118,8 +141,9 @@ class Ceil(Unary):
 
 class Floor(Unary):
     """
-    `Floor <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=111&zoom=100,72,442> `_ unary operator
+    `Floor <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=111&zoom=100,72,442> `_ unary operator # noqa E501
     """
+
     op = FLOOR
     py_op = math.floor
     return_type = Integer
@@ -127,8 +151,9 @@ class Floor(Unary):
 
 class BinPlus(Binary):
     """
-    `Addition <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=96&zoom=100,72,692> `_ binary operator
+    `Addition <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=96&zoom=100,72,692> `_ binary operator # noqa E501
     """
+
     op = PLUS
     py_op = operator.add
     type_to_check = Number
@@ -136,8 +161,9 @@ class BinPlus(Binary):
 
 class BinMinus(Binary):
     """
-    `Subtraction <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=98&zoom=100,72,448> `_ binary operator
+    `Subtraction <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=98&zoom=100,72,448> `_ binary operator # noqa E501
     """
+
     op = MINUS
     py_op = operator.sub
     type_to_check = Number
@@ -145,18 +171,20 @@ class BinMinus(Binary):
 
 class Mult(Binary):
     """
-    `Multiplication <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=100&zoom=100,72,254>`_
+    `Multiplication <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=100&zoom=100,72,254>`_ # noqa E501
     binary operator
     """
+
     op = MULT
     py_op = operator.mul
 
 
 class Div(Binary):
     """
-    `Division <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=102&zoom=100,72,94>`_
+    `Division <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=102&zoom=100,72,94>`_ # noqa E501
     binary operator
     """
+
     op = DIV
     py_op = operator.truediv
     return_type = Number
@@ -164,8 +192,9 @@ class Div(Binary):
 
 class Logarithm(Binary):
     """
-    `Logarithm <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=118&zoom=100,72,228>`_ operator
+    `Logarithm <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=118&zoom=100,72,228>`_ operator # noqa E501
     """
+
     op = LOG
     return_type = Number
 
@@ -181,16 +210,18 @@ class Logarithm(Binary):
 
 class Modulo(Binary):
     """
-    `Module <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=104&zoom=100,72,94>`_ operator
+    `Module <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=104&zoom=100,72,94>`_ operator # noqa E501
     """
+
     op = MOD
     py_op = operator.mod
 
 
 class Power(Binary):
     """
-    `Power <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=116&zoom=100,72,693>`_ operator
+    `Power <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=116&zoom=100,72,693>`_ operator # noqa E501
     """
+
     op = POWER
     return_type = Number
 
@@ -198,26 +229,30 @@ class Power(Binary):
     def py_op(cls, x: Any, param: Any) -> Any:
         if pd.isnull(param):
             return None
-        return x ** param
+        return x**param
 
 
 class Parameterized(Unary):
     """Parametrized class
-        Inherits from Unary class, to validate the data type and evaluate if it is the correct one to
-        perform the operation. Similar to Unary, but in the end, the param validation is added.
+    Inherits from Unary class, to validate the data type and evaluate if it is the correct one to
+    perform the operation. Similar to Unary, but in the end, the param validation is added.
     """
 
     @classmethod
-    def validate(cls, operand: Operator.ALL_MODEL_DATA_TYPES,
-                 param: Optional[Union[DataComponent, Scalar]] = None):
+    def validate(
+        cls,
+        operand: Operator.ALL_MODEL_DATA_TYPES,
+        param: Optional[Union[DataComponent, Scalar]] = None,
+    ) -> Any:
 
         if param is not None:
             if isinstance(param, Dataset):
                 raise SemanticError("1-1-15-8", op=cls.op, comp_type="Dataset")
             if isinstance(param, DataComponent):
                 if isinstance(operand, Scalar):
-                    raise SemanticError("1-1-15-8", op=cls.op,
-                                        comp_type="DataComponent and an Scalar operand")
+                    raise SemanticError(
+                        "1-1-15-8", op=cls.op, comp_type="DataComponent and an Scalar operand"
+                    )
                 cls.validate_type_compatibility(param.data_type)
             else:
                 cls.validate_scalar_type(param)
@@ -233,17 +268,19 @@ class Parameterized(Unary):
         return None if pd.isnull(x) else cls.py_op(x, param)
 
     @classmethod
-    def apply_operation_two_series(cls, left_series: pd.Series, right_series: pd.Series) -> Any:
+    def apply_operation_two_series(cls, left_series: Any, right_series: Any) -> Any:
         return left_series.combine(right_series, cls.op_func)
 
     @classmethod
-    def apply_operation_series_scalar(cls, series: pd.Series, param: Any) -> Any:
+    def apply_operation_series_scalar(cls, series: Any, param: Any) -> Any:
         return series.map(lambda x: cls.op_func(x, param))
 
     @classmethod
-    def dataset_evaluation(cls, operand: Dataset, param: Union[DataComponent, Scalar]):
+    def dataset_evaluation(
+        cls, operand: Dataset, param: Optional[Union[DataComponent, Scalar]] = None
+    ) -> Dataset:
         result = cls.validate(operand, param)
-        result.data = operand.data.copy()
+        result.data = operand.data.copy() if operand.data is not None else pd.DataFrame()
         for measure_name in result.get_measures_names():
             try:
                 if isinstance(param, DataComponent):
@@ -251,49 +288,56 @@ class Parameterized(Unary):
                         result.data[measure_name], param.data
                     )
                 else:
-                    param_value = None if param is None else param.value
+                    param_value = param.value if param is not None else None
                     result.data[measure_name] = cls.apply_operation_series_scalar(
                         result.data[measure_name], param_value
                     )
             except ValueError:
-                raise SemanticError("2-1-15-1", op=cls.op, comp_name=measure_name,
-                                    dataset_name=operand.name) from None
+                raise SemanticError(
+                    "2-1-15-1", op=cls.op, comp_name=measure_name, dataset_name=operand.name
+                ) from None
         result.data = result.data[result.get_components_names()]
         return result
 
     @classmethod
-    def component_evaluation(cls, operand: DataComponent, param: Union[DataComponent, Scalar]):
+    def component_evaluation(
+        cls, operand: DataComponent, param: Optional[Union[DataComponent, Scalar]] = None
+    ) -> DataComponent:
         result = cls.validate(operand, param)
+        if operand.data is None:
+            operand.data = pd.Series()
         result.data = operand.data.copy()
         if isinstance(param, DataComponent):
             result.data = cls.apply_operation_two_series(operand.data, param.data)
         else:
-            param_value = None if param is None else param.value
+            param_value = param.value if param is not None else None
             result.data = cls.apply_operation_series_scalar(operand.data, param_value)
         return result
 
     @classmethod
-    def scalar_evaluation(cls, operand: Scalar, param: Scalar):
+    def scalar_evaluation(cls, operand: Scalar, param: Optional[Any] = None) -> Scalar:
         result = cls.validate(operand, param)
-        param_value = None if param is None else param.value
+        param_value = param.value if param is not None else None
         result.value = cls.op_func(operand.value, param_value)
         return result
 
     @classmethod
-    def evaluate(cls, operand: ALL_MODEL_DATA_TYPES,
-                 param: Optional[Union[DataComponent, Scalar]] = None) -> ALL_MODEL_DATA_TYPES:
+    def evaluate(
+        cls, operand: ALL_MODEL_DATA_TYPES, param: Optional[Union[DataComponent, Scalar]] = None
+    ) -> Union[DataComponent, Dataset, Scalar]:
         if isinstance(operand, Dataset):
             return cls.dataset_evaluation(operand, param)
-        if isinstance(operand, DataComponent):
+        elif isinstance(operand, DataComponent):
             return cls.component_evaluation(operand, param)
-        if isinstance(operand, Scalar):
+        else:
             return cls.scalar_evaluation(operand, param)
 
 
 class Round(Parameterized):
     """
-    `Round <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=106&zoom=100,72,94>`_ operator
+    `Round <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=106&zoom=100,72,94>`_ operator # noqa E501
     """
+
     op = ROUND
     return_type = Integer
 
@@ -301,7 +345,7 @@ class Round(Parameterized):
     def py_op(cls, x: Any, param: Any) -> Any:
         multiplier = 1.0
         if not pd.isnull(param):
-            multiplier = 10 ** param
+            multiplier = 10**param
 
         if x >= 0.0:
             rounded_value = math.floor(x * multiplier + 0.5) / multiplier
@@ -316,15 +360,16 @@ class Round(Parameterized):
 
 class Trunc(Parameterized):
     """
-    `Trunc <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=108&zoom=100,72,94>`_ operator.
+    `Trunc <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=108&zoom=100,72,94>`_ operator. # noqa E501
     """
+
     op = TRUNC
 
     @classmethod
     def py_op(cls, x: float, param: Optional[float]) -> Any:
         multiplier = 1.0
         if not pd.isnull(param):
-            multiplier = 10 ** param
+            multiplier = 10**param
 
         truncated_value = int(x * multiplier) / multiplier
 

vtlengine/Operators/RoleSetter.py

@@ -1,43 +1,42 @@
-import os
 from copy import copy
+from typing import Any, Union
 
 from vtlengine.Exceptions import SemanticError
 
-if os.environ.get("SPARK", False):
-    import pyspark.pandas as pd
-else:
-    import pandas as pd
+# if os.environ.get("SPARK", False):
+#     import pyspark.pandas as pd
+# else:
+#     import pandas as pd
+import pandas as pd
 
 from vtlengine.Model import DataComponent, Role, Scalar
 from vtlengine.Operators import Unary
 
-ALLOWED_MODEL_TYPES = [DataComponent, Scalar]
+ALLOWED_MODEL_TYPES = Union[DataComponent, Scalar]
 
 
 class RoleSetter(Unary):
-    role = None
+    role: Role
 
     @classmethod
-    def validate(cls, operand: ALLOWED_MODEL_TYPES, data_size: int = 0):
+    def validate(cls, operand: ALLOWED_MODEL_TYPES, data_size: int = 0) -> DataComponent:
         if isinstance(operand, Scalar):
-
             nullable = True
             if cls.role == Role.IDENTIFIER or operand.value is not None:
                 nullable = False
-
             return DataComponent(
                 name=operand.name,
                 data_type=operand.data_type,
                 role=cls.role,
                 nullable=nullable,
-                data=None
+                data=None,
             )
         operand.role = cls.role
         return copy(operand)
 
     @classmethod
-    def evaluate(cls, operand: ALLOWED_MODEL_TYPES, data_size: int = 0):
-        if isinstance(operand, DataComponent):
+    def evaluate(cls, operand: Any, data_size: int = 0) -> DataComponent:
+        if isinstance(operand, DataComponent) and operand.data is not None:
             if not operand.nullable and any(operand.data.isnull()):
                 raise SemanticError("1-1-1-16")
         result = cls.validate(operand, data_size)
@@ -52,14 +51,16 @@ class Identifier(RoleSetter):
     role = Role.IDENTIFIER
 
     @classmethod
-    def validate(cls, operand: ALLOWED_MODEL_TYPES, data_size: int = 0):
+    def validate(cls, operand: ALLOWED_MODEL_TYPES, data_size: int = 0) -> DataComponent:
         result = super().validate(operand)
         if result.nullable:
             raise SemanticError("1-1-1-16")
         return result
 
     @classmethod
-    def evaluate(cls, operand: ALLOWED_MODEL_TYPES, data_size: int = 0):
+    def evaluate(  # type: ignore[override]
+        cls, operand: ALLOWED_MODEL_TYPES, data_size: int = 0
+    ) -> DataComponent:
         if isinstance(operand, Scalar):
             if operand.value is None:
                 raise SemanticError("1-1-1-16")

vtlengine/Operators/Set.py

@@ -1,12 +1,12 @@
-import os
-from typing import List
+from typing import List, Any, Dict
 
 from vtlengine.Exceptions import SemanticError
 
-if os.environ.get("SPARK"):
-    import pyspark.pandas as pd
-else:
-    import pandas as pd
+# if os.environ.get("SPARK"):
+#     import pyspark.pandas as pd
+# else:
+#     import pandas as pd
+import pandas as pd
 
 from vtlengine.Model import Dataset
 from vtlengine.Operators import Operator
@@ -18,18 +18,22 @@ class Set(Operator):
     @classmethod
     def check_same_structure(cls, dataset_1: Dataset, dataset_2: Dataset) -> None:
         if len(dataset_1.components) != len(dataset_2.components):
-            raise SemanticError("1-1-17-1", op=cls.op, dataset_1=dataset_1.name,
-                                dataset_2=dataset_2.name)
+            raise SemanticError(
+                "1-1-17-1", op=cls.op, dataset_1=dataset_1.name, dataset_2=dataset_2.name
+            )
 
         for comp in dataset_1.components.values():
             if comp.name not in dataset_2.components:
                 raise Exception(f"Component {comp.name} not found in dataset {dataset_2.name}")
             second_comp = dataset_2.components[comp.name]
-            binary_implicit_promotion(comp.data_type, second_comp.data_type, cls.type_to_check,
-                                      cls.return_type)
+            binary_implicit_promotion(
+                comp.data_type, second_comp.data_type, cls.type_to_check, cls.return_type
+            )
             if comp.role != second_comp.role:
-                raise Exception(f"Component {comp.name} has different roles "
-                                f"in datasets {dataset_1.name} and {dataset_2.name}")
+                raise Exception(
+                    f"Component {comp.name} has different roles "
+                    f"in datasets {dataset_1.name} and {dataset_2.name}"
+                )
 
     @classmethod
     def validate(cls, operands: List[Dataset]) -> Dataset:
@@ -38,7 +42,7 @@ class Set(Operator):
         for operand in operands[1:]:
             cls.check_same_structure(base_operand, operand)
 
-        result_components = {}
+        result_components: Dict[str, Any] = {}
         for operand in operands:
             if len(result_components) == 0:
                 result_components = operand.components
@@ -46,7 +50,8 @@ class Set(Operator):
                 for comp_name, comp in operand.components.items():
                     current_comp = result_components[comp_name]
                     result_components[comp_name].data_type = binary_implicit_promotion(
-                        current_comp.data_type, comp.data_type)
+                        current_comp.data_type, comp.data_type
+                    )
                     result_components[comp_name].nullable = current_comp.nullable or comp.nullable
 
         result = Dataset(name="result", components=result_components, data=None)
@@ -58,10 +63,9 @@ class Union(Set):
     def evaluate(cls, operands: List[Dataset]) -> Dataset:
         result = cls.validate(operands)
         all_datapoints = [ds.data for ds in operands]
-        result.data = pd.concat(all_datapoints, sort=True,
-                                ignore_index=True)
+        result.data = pd.concat(all_datapoints, sort=True, ignore_index=True)
         identifiers_names = result.get_identifiers_names()
-        result.data = result.data.drop_duplicates(subset=identifiers_names, keep='first')
+        result.data = result.data.drop_duplicates(subset=identifiers_names, keep="first")
         result.data.reset_index(drop=True, inplace=True)
         return result
 
@@ -76,16 +80,22 @@ class Intersection(Set):
             if result.data is None:
                 result.data = data
             else:
-                result.data = result.data.merge(data, how='inner',
-                                                on=result.get_identifiers_names())
+                if data is None:
+                    result.data = pd.DataFrame(columns=result.get_identifiers_names())
+                    break
+                result.data = result.data.merge(
+                    data, how="inner", on=result.get_identifiers_names()
+                )
 
-                not_identifiers = [col for col in result.get_measures_names() +
-                                   result.get_attributes_names()]
+                not_identifiers = [
+                    col for col in result.get_measures_names() + result.get_attributes_names()
+                ]
 
                 for col in not_identifiers:
                     result.data[col] = result.data[col + "_x"]
                 result.data = result.data[result.get_identifiers_names() + not_identifiers]
-        result.data.reset_index(drop=True, inplace=True)
+        if result.data is not None:
+            result.data.reset_index(drop=True, inplace=True)
         return result
 
 
@@ -96,35 +106,46 @@ class Symdiff(Set):
         result = cls.validate(operands)
         all_datapoints = [ds.data for ds in operands]
         for data in all_datapoints:
+            if data is None:
+                data = pd.DataFrame(columns=result.get_identifiers_names())
             if result.data is None:
                 result.data = data
             else:
                 # Realiza la operación equivalente en pyspark.pandas
-                result.data = result.data.merge(data, how='outer',
-                                                on=result.get_identifiers_names(),
-                                                suffixes=('_x', '_y'))
+                result.data = result.data.merge(
+                    data, how="outer", on=result.get_identifiers_names(), suffixes=("_x", "_y")
+                )
 
                 for measure in result.get_measures_names():
-                    result.data['_merge'] = result.data.apply(
-                        lambda row: 'left_only' if pd.isnull(row[measure + '_y']) else (
-                            'right_only' if pd.isnull(row[measure + '_x']) else 'both'),
-                        axis=1
+                    result.data["_merge"] = result.data.apply(
+                        lambda row: (
+                            "left_only"
+                            if pd.isnull(row[measure + "_y"])
+                            else ("right_only" if pd.isnull(row[measure + "_x"]) else "both")
+                        ),
+                        axis=1,
                     )
 
                 not_identifiers = result.get_measures_names() + result.get_attributes_names()
                 for col in not_identifiers:
                     result.data[col] = result.data.apply(
-                        lambda x, c=col: x[c + '_x'] if x['_merge'] == 'left_only' else (
-                            x[c + '_y'] if x['_merge'] == 'right_only' else None), axis=1)
+                        lambda x, c=col: (
+                            x[c + "_x"]
+                            if x["_merge"] == "left_only"
+                            else (x[c + "_y"] if x["_merge"] == "right_only" else None)
+                        ),
+                        axis=1,
+                    )
                 result.data = result.data[result.get_identifiers_names() + not_identifiers].dropna()
-        result.data = result.data.reset_index(drop=True)
+        if result.data is not None:
+            result.data = result.data.reset_index(drop=True)
         return result
 
 
 class Setdiff(Set):
 
     @staticmethod
-    def has_null(row):
+    def has_null(row: Any) -> bool:
         return row.isnull().any()
 
     @classmethod
@@ -135,12 +156,15 @@ class Setdiff(Set):
             if result.data is None:
                 result.data = data
             else:
+                if data is None:
+                    data = pd.DataFrame(columns=result.get_identifiers_names())
                 result.data = result.data.merge(data, how="left", on=result.get_identifiers_names())
                 if len(result.data) > 0:
                     result.data = result.data[result.data.apply(cls.has_null, axis=1)]
 
-                not_identifiers = [col for col in result.get_measures_names() +
-                                   result.get_attributes_names()]
+                not_identifiers = [
+                    col for col in result.get_measures_names() + result.get_attributes_names()
+                ]
                 for col in not_identifiers:
                     if col + "_x" in result.data:
                         result.data[col] = result.data[col + "_x"]
@@ -148,5 +172,6 @@ class Setdiff(Set):
                     if col + "_y" in result.data:
                         del result.data[col + "_y"]
                 result.data = result.data[result.get_identifiers_names() + not_identifiers]
-        result.data.reset_index(drop=True, inplace=True)
+        if result.data is not None:
+            result.data.reset_index(drop=True, inplace=True)
         return result