vtlengine 1.0.3rc3__py3-none-any.whl → 1.1__py3-none-any.whl

vtlengine/Operators/Conditional.py

@@ -39,7 +39,7 @@ class If(Operator):
         validate: Class method that has two branches so datacomponent and datasets can be validated. With datacomponent,
         the code reviews if it is actually a Measure and if it is a binary operation. Dataset branch reviews if the
         identifiers are the same in 'if', 'then' and 'else'.
-    """ # noqa E501
+    """  # noqa E501
 
     @classmethod
     def evaluate(cls, condition: Any, true_branch: Any, false_branch: Any) -> Any:
@@ -66,7 +66,8 @@ class If(Operator):
             else:
                 false_data = false_branch.data.reindex(condition.data.index)
             result = np.where(condition.data, true_data, false_data)
-        return pd.Series(result, index=condition.data.index)
+
+        return pd.Series(result, index=condition.data.index)  # type: ignore[union-attr]
 
     @classmethod
     def dataset_level_evaluation(
@@ -80,7 +81,11 @@ class If(Operator):
         if isinstance(true_branch, Dataset):
             if len(true_data) > 0 and true_branch.data is not None:
                 true_data = pd.merge(
-                    true_data, true_branch.data, on=ids, how="right", suffixes=("_condition", "")
+                    true_data,
+                    true_branch.data,
+                    on=ids,
+                    how="right",
+                    suffixes=("_condition", ""),
                 )
             else:
                 true_data = pd.DataFrame(columns=true_branch.get_components_names())
@@ -91,7 +96,11 @@ class If(Operator):
         if isinstance(false_branch, Dataset):
             if len(false_data) > 0 and false_branch.data is not None:
                 false_data = pd.merge(
-                    false_data, false_branch.data, on=ids, how="right", suffixes=("_condition", "")
+                    false_data,
+                    false_branch.data,
+                    on=ids,
+                    how="right",
+                    suffixes=("_condition", ""),
                 )
             else:
                 false_data = pd.DataFrame(columns=false_branch.get_components_names())
@@ -141,7 +150,9 @@ class If(Operator):
         if isinstance(condition, DataComponent):
             if not condition.data_type == Boolean:
                 raise SemanticError(
-                    "1-1-9-11", op=cls.op, type=SCALAR_TYPES_CLASS_REVERSE[condition.data_type]
+                    "1-1-9-11",
+                    op=cls.op,
+                    type=SCALAR_TYPES_CLASS_REVERSE[condition.data_type],
                 )
             if not isinstance(left, Scalar) or not isinstance(right, Scalar):
                 nullable = condition.nullable
@@ -191,7 +202,8 @@ class If(Operator):
                 if component.data_type != right.components[component.name].data_type:
                     component.data_type = right.components[component.name].data_type = (
                         binary_implicit_promotion(
-                            component.data_type, right.components[component.name].data_type
+                            component.data_type,
+                            right.components[component.name].data_type,
                         )
                     )
         if isinstance(condition, Dataset):
@@ -219,14 +231,14 @@ class Nvl(Binary):
         Validate: Class method that validates if the operation at scalar,
         datacomponent or dataset level can be performed.
         Evaluate: Evaluates the actual operation, returning the result.
-    """ # noqa E501
+    """  # noqa E501
 
     @classmethod
     def evaluate(cls, left: Any, right: Any) -> Union[Scalar, DataComponent, Dataset]:
         result = cls.validate(left, right)
 
         if isinstance(left, Scalar) and isinstance(result, Scalar):
-            if pd.isnull(left):  # type: ignore[call-overload]
+            if left.data_type is Null:
                 result.value = right.value
             else:
                 result.value = left.value
@@ -290,13 +302,31 @@ class Nvl(Binary):
 
 
 class Case(Operator):
-
     @classmethod
     def evaluate(
         cls, conditions: List[Any], thenOps: List[Any], elseOp: Any
     ) -> Union[Scalar, DataComponent, Dataset]:
-
         result = cls.validate(conditions, thenOps, elseOp)
+        for condition in conditions:
+            if isinstance(condition, Dataset) and condition.data is not None:
+                condition.data.fillna(False, inplace=True)
+                condition_measure = condition.get_measures_names()[0]
+                if condition.data[condition_measure].dtype != bool:
+                    condition.data[condition_measure] = condition.data[condition_measure].astype(
+                        bool
+                    )
+            elif (
+                isinstance(
+                    condition,
+                    DataComponent,
+                )
+                and condition.data is not None
+            ):
+                condition.data.fillna(False, inplace=True)
+                if condition.data.dtype != bool:
+                    condition.data = condition.data.astype(bool)
+            elif isinstance(condition, Scalar) and condition.value is None:
+                condition.value = False
 
         if isinstance(result, Scalar):
             result.value = elseOp.value
@@ -309,8 +339,10 @@ class Case(Operator):
 
             for i, condition in enumerate(conditions):
                 value = thenOps[i].value if isinstance(thenOps[i], Scalar) else thenOps[i].data
-                result.data = np.where(
-                    condition.data, value, result.data  # type: ignore[call-overload]
+                result.data = np.where(  # type: ignore[call-overload]
+                    condition.data.notna(),
+                    np.where(condition.data, value, result.data),  # type: ignore[call-overload]
+                    result.data,
                 )
 
             condition_mask_else = ~np.any([condition.data for condition in conditions], axis=0)
@@ -349,7 +381,7 @@ class Case(Operator):
                 ]
             )
 
-            result.data.loc[condition_mask_else, columns] = (
+            result.data.loc[condition_mask_else, columns] = (  # type: ignore[index, unused-ignore]
                 elseOp.value
                 if isinstance(elseOp, Scalar)
                 else elseOp.data.loc[condition_mask_else, columns]
@@ -361,7 +393,6 @@ class Case(Operator):
     def validate(
         cls, conditions: List[Any], thenOps: List[Any], elseOp: Any
     ) -> Union[Scalar, DataComponent, Dataset]:
-
         if len(set(map(type, conditions))) > 1:
             raise SemanticError("2-1-9-1", op=cls.op)
 
@@ -395,9 +426,10 @@ class Case(Operator):
                     raise SemanticError("2-1-9-4", op=cls.op, name=condition.name)
 
             nullable = any(
-                thenOp.nullable if isinstance(thenOp, DataComponent) else thenOp.data_type == Null
+                (thenOp.nullable if isinstance(thenOp, DataComponent) else thenOp.data_type == Null)
                 for thenOp in ops
             )
+            nullable |= any(condition.nullable for condition in conditions)
 
             data_type = ops[0].data_type
             for op in ops[1:]:

vtlengine/Operators/General.py

@@ -23,7 +23,10 @@ class Membership(Binary):
     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
+                "1-1-1-10",
+                op=cls.op,
+                comp_name=right_operand,
+                dataset_name=left_operand.name,
             )
 
         component = left_operand.components[right_operand]
@@ -48,7 +51,10 @@ class Membership(Binary):
 
     @classmethod
     def evaluate(
-        cls, left_operand: Dataset, right_operand: str, is_from_component_assignment: bool = False
+        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 left_operand.data is not None:
@@ -128,12 +134,11 @@ class Eval(Unary):
         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"
+                    f"External Routine dataset {ds_name} is not present in Eval operands"
                 )
             empty_data = pd.DataFrame(
                 columns=[comp.name for comp in operands[ds_name].components.values()]

vtlengine/Operators/HROperators.py

@@ -24,12 +24,9 @@ def get_measure_from_dataset(dataset: Dataset, code_item: str) -> DataComponent:
 
 
 class HRComparison(Operators.Binary):
-
     @classmethod
     def imbalance_func(cls, x: Any, y: Any) -> Any:
-        if pd.isnull(x) or pd.isnull(y):
-            return None
-        return x - y
+        return None if pd.isnull(x) or pd.isnull(y) else x - y
 
     @staticmethod
     def hr_func(left_series: Any, right_series: Any, hr_mode: str) -> Any:
@@ -44,8 +41,8 @@ class HRComparison(Operators.Binary):
             result[mask_remove] = "REMOVE_VALUE"
             result[mask_null] = None
         elif hr_mode == "non_null":
-                mask_remove = left_series.isnull() | right_series.isnull()
-                result[mask_remove] = "REMOVE_VALUE"
+            mask_remove = left_series.isnull() | right_series.isnull()
+            result[mask_remove] = "REMOVE_VALUE"
         elif hr_mode == "non_zero":
             mask_remove = (left_series == 0) & (right_series == 0)
             result[mask_remove] = "REMOVE_VALUE"
@@ -66,11 +63,7 @@ class HRComparison(Operators.Binary):
         return result
 
     @classmethod
-    def validate(cls,
-                 left_operand: Dataset,
-                 right_operand: DataComponent,
-                 hr_mode: str
-                 ) -> Dataset:
+    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()
@@ -136,7 +129,6 @@ class HRLessEqual(HRComparison):
 
 
 class HRBinNumeric(Operators.Binary):
-
     @classmethod
     def op_func(cls, x: Any, y: Any) -> Any:
         if not pd.isnull(x) and x == "REMOVE_VALUE":
@@ -166,7 +158,6 @@ class HRBinMinus(HRBinNumeric):
 
 
 class HRUnNumeric(Operators.Unary):
-
     @classmethod
     def evaluate(cls, operand: DataComponent) -> DataComponent:  # type: ignore[override]
         result_data = cls.apply_operation_component(operand.data)
@@ -190,7 +181,6 @@ class HRUnMinus(HRUnNumeric):
 
 
 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()}

vtlengine/Operators/Join.py

@@ -70,7 +70,9 @@ class Join(Operator):
                     comp.role = (
                         Role.IDENTIFIER
                         if is_identifier
-                        else Role.MEASURE if comp.role == Role.IDENTIFIER else comp.role
+                        else Role.MEASURE
+                        if comp.role == Role.IDENTIFIER
+                        else comp.role
                     )
                 if comp.name not in nullability:
                     nullability[comp.name] = copy(comp.nullable)
@@ -107,7 +109,8 @@ class Join(Operator):
                 else:
                     if component_name in using and component_name in merged_components:
                         data_type = binary_implicit_promotion(
-                            merged_components[component_name].data_type, component.data_type
+                            merged_components[component_name].data_type,
+                            component.data_type,
                         )
                         component.data_type = data_type
                     merged_components[component_name] = component
@@ -216,7 +219,6 @@ class Join(Operator):
 
     @classmethod
     def identifiers_validation(cls, operands: List[Dataset], using: Optional[List[str]]) -> None:
-
         # (Case A)
         info = {op.name: op.get_identifiers_names() for op in operands}
         for op_name, identifiers in info.items():
@@ -224,11 +226,12 @@ class Join(Operator):
                 raise SemanticError("1-1-13-14", op=cls.op, name=op_name)
 
         for op_name, identifiers in info.items():
-            if (using is None and op_name != cls.reference_dataset.name and not
-            set(identifiers).issubset(set(info[cls.reference_dataset.name]))):
-                missing_components = list(
-                    set(identifiers) - set(info[cls.reference_dataset.name])
-                )
+            if (
+                using is None
+                and op_name != cls.reference_dataset.name
+                and not set(identifiers).issubset(set(info[cls.reference_dataset.name]))
+            ):
+                missing_components = list(set(identifiers) - set(info[cls.reference_dataset.name]))
                 raise SemanticError(
                     "1-1-13-11",
                     op=cls.op,
@@ -277,7 +280,6 @@ class InnerJoin(Join):
     def generate_result_components(
         cls, operands: List[Dataset], using: Optional[List[str]] = None
     ) -> Dict[str, Component]:
-
         if using is None:
             return super().generate_result_components(operands, using)
 
@@ -334,7 +336,9 @@ class CrossJoin(Join):
             else:
                 if result.data is not None:
                     result.data = pd.merge(
-                        result.data, op.data, how=cls.how  # type: ignore[arg-type]
+                        result.data,
+                        op.data,
+                        how=cls.how,  # type: ignore[arg-type]
                     )
             if result.data is not None:
                 result.data = result.data.rename(
@@ -357,7 +361,6 @@ class CrossJoin(Join):
 
 
 class Apply(Operator):
-
     @classmethod
     def evaluate(cls, dataset: Dataset, expression: Any, op_map: Dict[str, Any]) -> Dataset:
         for child in expression:
@@ -424,9 +427,7 @@ class Apply(Operator):
         return Dataset(name=name, components=components, data=data)
 
     @classmethod
-    def get_common_components(
-        cls, left: Dataset, right: Dataset
-    ) -> (Dataset, Dataset):  # type: ignore[syntax]
+    def get_common_components(cls, left: Dataset, right: Dataset) -> (Dataset, Dataset):  # type: ignore[syntax]
         common = set(left.get_components_names()) & set(right.get_components_names())
         left.components = {
             comp.name: comp for comp in left.components.values() if comp.name in common

vtlengine/Operators/Numeric.py

@@ -73,7 +73,7 @@ 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
-    """ # noqa E501
+    """  # noqa E501
 
     op = PLUS
     py_op = operator.pos
@@ -86,7 +86,7 @@ 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
-    """ # noqa E501
+    """  # noqa E501
 
     op = MINUS
     py_op = operator.neg
@@ -95,7 +95,7 @@ class UnMinus(Unary):
 class AbsoluteValue(Unary):
     """
     `Absolute <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=112&zoom=100,72,801> `_ unary operator
-    """ # noqa E501
+    """  # noqa E501
 
     op = ABS
     py_op = operator.abs
@@ -104,7 +104,7 @@ class AbsoluteValue(Unary):
 class Exponential(Unary):
     """
     `Exponential <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=114&zoom=100,72,94>`_ unary operator
-    """ # noqa E501
+    """  # noqa E501
 
     op = EXP
     py_op = math.exp
@@ -115,7 +115,7 @@ class NaturalLogarithm(Unary):
     """
     `Natural logarithm <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=115&zoom=100,72,394> `_
     unary operator
-    """ # noqa E501
+    """  # noqa E501
 
     op = LN
     py_op = math.log
@@ -126,7 +126,7 @@ class SquareRoot(Unary):
     """
     `Square Root <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=119&zoom=100,72,556> '_
     unary operator
-    """ # noqa E501
+    """  # noqa E501
 
     op = SQRT
     py_op = math.sqrt
@@ -136,7 +136,7 @@ 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
-    """ # noqa E501
+    """  # noqa E501
 
     op = CEIL
     py_op = math.ceil
@@ -146,7 +146,7 @@ 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
-    """ # noqa E501
+    """  # noqa E501
 
     op = FLOOR
     py_op = math.floor
@@ -156,7 +156,7 @@ 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
-    """ # noqa E501
+    """  # noqa E501
 
     op = PLUS
     py_op = operator.add
@@ -166,7 +166,7 @@ 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
-    """ # noqa E501
+    """  # noqa E501
 
     op = MINUS
     py_op = operator.sub
@@ -177,7 +177,7 @@ class Mult(Binary):
     """
     `Multiplication <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=100&zoom=100,72,254>`_
     binary operator
-    """ # noqa E501
+    """  # noqa E501
 
     op = MULT
     py_op = operator.mul
@@ -187,7 +187,7 @@ class Div(Binary):
     """
     `Division <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=102&zoom=100,72,94>`_
     binary operator
-    """ # noqa E501
+    """  # noqa E501
 
     op = DIV
     py_op = operator.truediv
@@ -197,7 +197,7 @@ 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
-    """ # noqa E501
+    """  # noqa E501
 
     op = LOG
     return_type = Number
@@ -215,7 +215,7 @@ 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
-    """ # noqa E501
+    """  # noqa E501
 
     op = MOD
     py_op = operator.mod
@@ -224,7 +224,7 @@ class Modulo(Binary):
 class Power(Binary):
     """
     `Power <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=116&zoom=100,72,693>`_ operator
-    """ # noqa E501
+    """  # noqa E501
 
     op = POWER
     return_type = Number
@@ -248,14 +248,15 @@ class Parameterized(Unary):
         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"
+                        "1-1-15-8",
+                        op=cls.op,
+                        comp_type="DataComponent and an Scalar operand",
                     )
                 cls.validate_type_compatibility(param.data_type)
             else:
@@ -298,14 +299,19 @@ class Parameterized(Unary):
                     )
             except ValueError:
                 raise SemanticError(
-                    "2-1-15-1", op=cls.op, comp_name=measure_name, dataset_name=operand.name
+                    "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: Optional[Union[DataComponent, Scalar]] = None
+        cls,
+        operand: DataComponent,
+        param: Optional[Union[DataComponent, Scalar]] = None,
     ) -> DataComponent:
         result = cls.validate(operand, param)
         if operand.data is None:
@@ -327,7 +333,9 @@ class Parameterized(Unary):
 
     @classmethod
     def evaluate(
-        cls, operand: ALL_MODEL_DATA_TYPES, param: Optional[Union[DataComponent, Scalar]] = None
+        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)
@@ -340,7 +348,7 @@ class Parameterized(Unary):
 class Round(Parameterized):
     """
     `Round <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=106&zoom=100,72,94>`_ operator
-    """ # noqa E501
+    """  # noqa E501
 
     op = ROUND
     return_type = Integer
@@ -365,14 +373,14 @@ 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.
-    """ # noqa E501
+    """  # noqa E501
 
     op = TRUNC
 
     @classmethod
     def py_op(cls, x: float, param: Optional[float]) -> Any:
         multiplier = 1.0
-        if not pd.isnull(param):
+        if not pd.isnull(param) and param is not None:
             multiplier = 10**param
 
         truncated_value = int(x * multiplier) / multiplier
@@ -384,14 +392,12 @@ class Trunc(Parameterized):
 
 
 class PseudoRandom(_random.Random):
-
     def __init__(self, seed: Union[int, float]) -> None:
         super().__init__()
         self.seed(seed)
 
 
 class Random(Parameterized):
-
     op = RANDOM
     return_type = Number
 
@@ -403,7 +409,7 @@ class Random(Parameterized):
             raise SemanticError("2-1-15-2", op=cls.op, value=index)
         if index.value > 10000:
             warnings.warn(
-                "Random: The value of 'index' is very big. This can affect " "performance.",
+                "Random: The value of 'index' is very big. This can affect performance.",
                 UserWarning,
             )
         return super().validate(seed, index)

vtlengine/Operators/RoleSetter.py

@@ -35,8 +35,12 @@ class RoleSetter(Unary):
 
     @classmethod
     def evaluate(cls, operand: Any, data_size: int = 0) -> DataComponent:
-        if (isinstance(operand, DataComponent) and operand.data is not None and
-                not operand.nullable and any(operand.data.isnull())):
+        if (
+            isinstance(operand, DataComponent)
+            and operand.data is not None
+            and not operand.nullable
+            and any(operand.data.isnull())
+        ):
             raise SemanticError("1-1-1-16")
         result = cls.validate(operand, data_size)
         if isinstance(operand, Scalar):

vtlengine/Operators/Set.py

@@ -13,12 +13,14 @@ from vtlengine.Operators import Operator
 
 
 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
+                "1-1-17-1",
+                op=cls.op,
+                dataset_1=dataset_1.name,
+                dataset_2=dataset_2.name,
             )
 
         for comp in dataset_1.components.values():
@@ -26,7 +28,10 @@ class Set(Operator):
                 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
+                comp.data_type,
+                second_comp.data_type,
+                cls.type_to_check,
+                cls.return_type,
             )
             if comp.role != second_comp.role:
                 raise Exception(
@@ -36,7 +41,6 @@ class Set(Operator):
 
     @classmethod
     def validate(cls, operands: List[Dataset]) -> Dataset:
-
         base_operand = operands[0]
         for operand in operands[1:]:
             cls.check_same_structure(base_operand, operand)
@@ -70,7 +74,6 @@ class Union(Set):
 
 
 class Intersection(Set):
-
     @classmethod
     def evaluate(cls, operands: List[Dataset]) -> Dataset:
         result = cls.validate(operands)
@@ -97,7 +100,6 @@ class Intersection(Set):
 
 
 class Symdiff(Set):
-
     @classmethod
     def evaluate(cls, operands: List[Dataset]) -> Dataset:
         result = cls.validate(operands)
@@ -110,7 +112,10 @@ class Symdiff(Set):
             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")
+                    data,
+                    how="outer",
+                    on=result.get_identifiers_names(),
+                    suffixes=("_x", "_y"),
                 )
 
                 for measure in result.get_measures_names():
@@ -140,7 +145,6 @@ class Symdiff(Set):
 
 
 class Setdiff(Set):
-
     @staticmethod
     def has_null(row: Any) -> bool:
         return row.isnull().any()