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

vtlengine/Operators/CastOperator.py

@@ -34,43 +34,43 @@ class Cast(Operator.Unary):
     # CASTS VALUES
     # Converts the value from one type to another in a way that is according to the mask
     @classmethod
-    def cast_string_to_number(cls, *args: Any) -> Any:
+    def cast_string_to_number(cls, value: Any, mask: str) -> Any:
         """
         This method casts a string to a number, according to the mask.
 
         """
 
-        raise NotImplementedError("How this cast should be implemented is not yet defined.")
+        raise NotImplementedError("How this mask should be implemented is not yet defined.")
 
     @classmethod
-    def cast_string_to_date(cls, *args: Any) -> Any:
+    def cast_string_to_date(cls, value: Any, mask: str) -> Any:
         """
         This method casts a string to a number, according to the mask.
 
         """
 
-        raise NotImplementedError("How this cast should be implemented is not yet defined.")
+        raise NotImplementedError("How this mask should be implemented is not yet defined.")
 
     @classmethod
-    def cast_string_to_duration(cls, *args: Any) -> Any:
+    def cast_string_to_duration(cls, value: Any, mask: str) -> Any:
         """
         This method casts a string to a duration, according to the mask.
 
         """
 
-        raise NotImplementedError("How this cast should be implemented is not yet defined.")
+        raise NotImplementedError("How this mask should be implemented is not yet defined.")
 
     @classmethod
-    def cast_string_to_time_period(cls, *args: Any) -> Any:
+    def cast_string_to_time_period(cls, value: Any, mask: str) -> Any:
         """
         This method casts a string to a time period, according to the mask.
 
         """
 
-        raise NotImplementedError("How this cast should be implemented is not yet defined.")
+        raise NotImplementedError("How this mask should be implemented is not yet defined.")
 
     @classmethod
-    def cast_string_to_time(cls, *args: Any) -> Any:
+    def cast_string_to_time(cls, value: Any, mask: str) -> Any:
         """
         This method casts a string to a time, according to the mask.
 
@@ -78,20 +78,21 @@ class Cast(Operator.Unary):
 
         raise NotImplementedError("How this cast should be implemented is not yet defined.")
 
-    @classmethod
-    def cast_date_to_string(cls, *args: Any) -> Any:
-        """ """
-        return NotImplementedError("How this cast should be implemented is not yet defined.")
-
-    @classmethod
-    def cast_duration_to_string(cls, *args: Any) -> Any:
-        """ """
-        return NotImplementedError("How this cast should be implemented is not yet defined.")
-
-    @classmethod
-    def cast_time_to_string(cls, *args: Any) -> Any:
-        """ """
-        return NotImplementedError("How this cast should be implemented is not yet defined.")
+    #
+    # @classmethod
+    # def cast_date_to_string(cls, value: Any, mask: str) -> Any:
+    #     """ """
+    #     return NotImplementedError("How this cast should be implemented is not yet defined.")
+    #
+    # @classmethod
+    # def cast_duration_to_string(cls, value: Any, mask: str) -> Any:
+    #     """ """
+    #     return NotImplementedError("How this cast should be implemented is not yet defined.")
+    #
+    # @classmethod
+    # def cast_time_to_string(cls, value: Any, mask: str) -> Any:
+    #     """ """
+    #     return NotImplementedError("How this cast should be implemented is not yet defined.")
 
     @classmethod
     def cast_time_period_to_date(cls, value: Any, mask_value: str) -> Any:
@@ -142,7 +143,6 @@ class Cast(Operator.Unary):
 
     @classmethod
     def check_mask_value_from_time_period_to_date(cls, mask_value: str) -> None:
-
         if mask_value not in ["START", "END"]:
             raise SemanticError("1-1-5-4", op=cls.op, type_1="Time_Period", type_2="Date")
 
@@ -180,9 +180,11 @@ class Cast(Operator.Unary):
 
     @classmethod
     def check_cast(
-        cls, from_type: Type[ScalarType], to_type: Type[ScalarType], mask_value: Optional[str]
+        cls,
+        from_type: Type[ScalarType],
+        to_type: Type[ScalarType],
+        mask_value: Optional[str],
     ) -> None:
-
         if mask_value is not None:
             cls.check_with_mask(from_type, to_type, mask_value)
         else:
@@ -192,7 +194,6 @@ class Cast(Operator.Unary):
     def check_with_mask(
         cls, from_type: Type[ScalarType], to_type: Type[ScalarType], mask_value: str
     ) -> None:
-
         explicit_promotion = EXPLICIT_WITH_MASK_TYPE_PROMOTION_MAPPING[from_type]
         if to_type.is_included(explicit_promotion):
             return cls.check_mask_value(from_type, to_type, mask_value)
@@ -207,7 +208,6 @@ class Cast(Operator.Unary):
 
     @classmethod
     def check_without_mask(cls, from_type: Type[ScalarType], to_type: Type[ScalarType]) -> None:
-
         explicit_promotion = EXPLICIT_WITHOUT_MASK_TYPE_PROMOTION_MAPPING[from_type]
         implicit_promotion = IMPLICIT_TYPE_PROMOTION_MAPPING[from_type]
         if not (to_type.is_included(explicit_promotion) or to_type.is_included(implicit_promotion)):
@@ -231,7 +231,7 @@ class Cast(Operator.Unary):
         cls, data: Any, from_type: Type[ScalarType], to_type: Type[ScalarType]
     ) -> Any:
         """
-        cast the component to the type to_type without mask
+        Cast the component to the type to_type without mask
         """
 
         if to_type.is_included(IMPLICIT_TYPE_PROMOTION_MAPPING[from_type]):
@@ -242,15 +242,17 @@ class Cast(Operator.Unary):
 
     @classmethod
     def cast_mask_component(cls, data: Any, from_type: Any, to_type: Any, mask: str) -> Any:
-
         result = data.map(lambda x: cls.cast_value(x, from_type, to_type, mask), na_action="ignore")
         return result
 
     @classmethod
     def cast_value(
-        cls, value: Any, provided_type: Type[ScalarType], to_type: Type[ScalarType], mask_value: str
+        cls,
+        value: Any,
+        provided_type: Type[ScalarType],
+        to_type: Type[ScalarType],
+        mask_value: str,
     ) -> Any:
-
         if provided_type == String and to_type == Number:
             return cls.cast_string_to_number(value, mask_value)
         if provided_type == String and to_type == Date:
@@ -261,12 +263,12 @@ class Cast(Operator.Unary):
             return cls.cast_string_to_time_period(value, mask_value)
         if provided_type == String and to_type == TimeInterval:
             return cls.cast_string_to_time(value, mask_value)
-        if provided_type == Date and to_type == String:
-            return cls.cast_date_to_string(value, mask_value)
-        if provided_type == Duration and to_type == String:
-            return cls.cast_duration_to_string(value, mask_value)
-        if provided_type == TimeInterval and to_type == String:
-            return cls.cast_time_to_string(value, mask_value)
+        # if provided_type == Date and to_type == String:
+        #     return cls.cast_date_to_string(value, mask_value)
+        # if provided_type == Duration and to_type == String:
+        #     return cls.cast_duration_to_string(value, mask_value)
+        # if provided_type == TimeInterval and to_type == String:
+        #     return cls.cast_time_to_string(value, mask_value)
         if provided_type == TimePeriod and to_type == Date:
             return cls.cast_time_period_to_date(value, mask_value)
 
@@ -285,7 +287,6 @@ class Cast(Operator.Unary):
         scalarType: Type[ScalarType],
         mask: Optional[str] = None,
     ) -> Any:
-
         if mask is not None and not isinstance(mask, str):
             raise Exception(f"{cls.op} mask must be a string")
 
@@ -325,7 +326,10 @@ class Cast(Operator.Unary):
         else:
             measure_name = measure.name
         result_components[measure_name] = Component(
-            name=measure_name, data_type=to_type, role=Role.MEASURE, nullable=measure.nullable
+            name=measure_name,
+            data_type=to_type,
+            role=Role.MEASURE,
+            nullable=measure.nullable,
         )
         return Dataset(name="result", components=result_components, data=None)
 
@@ -366,7 +370,6 @@ class Cast(Operator.Unary):
         scalarType: Type[ScalarType],
         mask: Optional[str] = None,
     ) -> Any:
-
         if isinstance(operand, Dataset):
             return cls.dataset_evaluation(operand, scalarType, mask)
         if isinstance(operand, Scalar):
@@ -381,7 +384,6 @@ class Cast(Operator.Unary):
         to_type: Type[ScalarType],
         mask: Optional[str] = None,
     ) -> Dataset:
-
         from_type = operand.get_measures()[0].data_type
         original_measure = operand.get_measures()[0]
         result_dataset = cls.dataset_validation(operand, to_type, mask)
@@ -410,7 +412,6 @@ class Cast(Operator.Unary):
         to_type: Type[ScalarType],
         mask: Optional[str] = None,
     ) -> Scalar:
-
         from_type = operand.data_type
         result_scalar = cls.scalar_validation(operand, to_type, mask)
         if pd.isna(operand.value):
@@ -431,7 +432,6 @@ class Cast(Operator.Unary):
         to_type: Type[ScalarType],
         mask: Optional[str] = None,
     ) -> DataComponent:
-
         from_type = operand.data_type
         result_component = cls.component_validation(operand, to_type, mask)
         if mask:

vtlengine/Operators/Clause.py

@@ -22,12 +22,10 @@ class Calc(Operator):
 
     @classmethod
     def validate(cls, operands: List[Union[DataComponent, Scalar]], dataset: Dataset) -> Dataset:
-
         result_components = {name: copy(comp) for name, comp in dataset.components.items()}
         result_dataset = Dataset(name=dataset.name, components=result_components, data=None)
 
         for operand in operands:
-
             if operand.name in result_dataset.components:
                 if result_dataset.components[operand.name].role == Role.IDENTIFIER:
                     raise SemanticError("1-1-6-13", op=cls.op, comp_name=operand.name)
@@ -72,7 +70,6 @@ class Aggregate(Operator):
 
     @classmethod
     def validate(cls, operands: List[Union[DataComponent, Scalar]], dataset: Dataset) -> Dataset:
-
         result_dataset = Dataset(name=dataset.name, components=dataset.components, data=None)
 
         for operand in operands:
@@ -121,7 +118,6 @@ class Aggregate(Operator):
 
 
 class Filter(Operator):
-
     @classmethod
     def validate(cls, condition: DataComponent, dataset: Dataset) -> Dataset:
         if condition.data_type != Boolean:
@@ -212,11 +208,17 @@ class Rename(Operator):
         for operand in operands:
             if operand.old_name not in dataset.components:
                 raise SemanticError(
-                    "1-1-1-10", op=cls.op, comp_name=operand.old_name, dataset_name=dataset.name
+                    "1-1-1-10",
+                    op=cls.op,
+                    comp_name=operand.old_name,
+                    dataset_name=dataset.name,
                 )
             if operand.new_name in dataset.components:
                 raise SemanticError(
-                    "1-1-6-8", op=cls.op, comp_name=operand.new_name, dataset_name=dataset.name
+                    "1-1-6-8",
+                    op=cls.op,
+                    comp_name=operand.new_name,
+                    dataset_name=dataset.name,
                 )
 
         result_components = {comp.name: comp for comp in dataset.components.values()}
@@ -242,7 +244,6 @@ class Rename(Operator):
 
 
 class Pivot(Operator):
-
     @classmethod
     def validate(cls, operands: List[str], dataset: Dataset) -> Dataset:
         raise NotImplementedError
@@ -253,7 +254,6 @@ class Pivot(Operator):
 
 
 class Unpivot(Operator):
-
     @classmethod
     def validate(cls, operands: List[str], dataset: Dataset) -> Dataset:
         if len(operands) != 2:
@@ -311,11 +311,17 @@ class Sub(Operator):
         for operand in operands:
             if operand.name not in dataset.components:
                 raise SemanticError(
-                    "1-1-1-10", op=cls.op, comp_name=operand.name, dataset_name=dataset.name
+                    "1-1-1-10",
+                    op=cls.op,
+                    comp_name=operand.name,
+                    dataset_name=dataset.name,
                 )
             if operand.role != Role.IDENTIFIER:
                 raise SemanticError(
-                    "1-1-6-10", op=cls.op, operand=operand.name, dataset_name=dataset.name
+                    "1-1-6-10",
+                    op=cls.op,
+                    operand=operand.name,
+                    dataset_name=dataset.name,
                 )
             if isinstance(operand, Scalar):
                 raise SemanticError("1-1-6-5", op=cls.op, name=operand.name)

vtlengine/Operators/Comparison.py

@@ -74,10 +74,11 @@ class Binary(Operator.Binary):
     return_type = Boolean
 
     @classmethod
-    def _cast_values(cls,
-                     x: Optional[Union[int, float, str, bool]],
-                     y: Optional[Union[int, float, str, bool]]
-                     ) -> Any:
+    def _cast_values(
+        cls,
+        x: Optional[Union[int, float, str, bool]],
+        y: Optional[Union[int, float, str, bool]],
+    ) -> Any:
         # Cast values to compatible types for comparison
         try:
             if isinstance(x, str) and isinstance(y, bool):
@@ -247,9 +248,7 @@ class Between(Operator.Operator):
         z: Optional[Union[int, float, bool, str]],
     ) -> Optional[bool]:
         return (
-            None
-            if (pd.isnull(x) or pd.isnull(y) or pd.isnull(z))
-            else y <= x <= z  # type: ignore[operator]
+            None if (pd.isnull(x) or pd.isnull(y) or pd.isnull(z)) else y <= x <= z  # type: ignore[operator]
         )
 
     @classmethod
@@ -264,7 +263,8 @@ class Between(Operator.Operator):
                 to_data = pd.Series(to_data, index=series.index)
             df = pd.DataFrame({"operand": series, "from_data": from_data, "to_data": to_data})
             return df.apply(
-                lambda x: cls.op_func(x["operand"], x["from_data"], x["to_data"]), axis=1
+                lambda x: cls.op_func(x["operand"], x["from_data"], x["to_data"]),
+                axis=1,
             )
 
         return series.map(lambda x: cls.op_func(x, from_data, to_data))
@@ -310,13 +310,19 @@ class Between(Operator.Operator):
             result = Dataset(name=operand.name, components=result_components, data=None)
         elif isinstance(operand, DataComponent):
             result = DataComponent(
-                name=operand.name, data=None, data_type=cls.return_type, role=operand.role
+                name=operand.name,
+                data=None,
+                data_type=cls.return_type,
+                role=operand.role,
             )
         elif isinstance(from_, Scalar) and isinstance(to, Scalar):
             result = Scalar(name=operand.name, value=None, data_type=cls.return_type)
         else:  # From or To is a DataComponent, or both
             result = DataComponent(
-                name=operand.name, data=None, data_type=cls.return_type, role=Role.MEASURE
+                name=operand.name,
+                data=None,
+                data_type=cls.return_type,
+                role=Role.MEASURE,
             )
 
         if isinstance(operand, Dataset):
@@ -369,14 +375,16 @@ class Between(Operator.Operator):
         elif isinstance(operand, Scalar) and (
             isinstance(from_data, pd.Series) or isinstance(to_data, pd.Series)
         ):  # From or To is a DataComponent, or both
-
             if isinstance(from_data, pd.Series):
                 series = pd.Series(operand.value, index=from_data.index, dtype=object)
             elif isinstance(to_data, pd.Series):
                 series = pd.Series(operand.value, index=to_data.index, dtype=object)
             result_series = cls.apply_operation_component(series, from_data, to_data)
             result = DataComponent(
-                name=operand.name, data=result_series, data_type=cls.return_type, role=Role.MEASURE
+                name=operand.name,
+                data=result_series,
+                data_type=cls.return_type,
+                role=Role.MEASURE,
             )
         return result
 

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,7 +231,7 @@ 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]:
@@ -290,13 +302,16 @@ 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, (DataComponent, Dataset)) and condition.data is not None:
+                condition.data.fillna(False, inplace=True)
+            elif isinstance(condition, Scalar) and condition.value is None:
+                condition.value = False
 
         if isinstance(result, Scalar):
             result.value = elseOp.value
@@ -309,8 +324,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)
@@ -361,7 +378,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 +411,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()}