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

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()

vtlengine/Operators/String.py

@@ -31,7 +31,6 @@ class Unary(Operator.Unary):
 
     @classmethod
     def op_func(cls, x: Any) -> Any:
-
         x = "" if pd.isnull(x) else str(x)
         return cls.py_op(x)
 
@@ -116,7 +115,6 @@ class Concatenate(Binary):
 
 
 class Parameterized(Unary):
-
     @classmethod
     def validate(cls, *args: Any) -> Any:
         operand: Operator.ALL_MODEL_DATA_TYPES
@@ -353,7 +351,6 @@ class Instr(Parameterized):
         param2: Optional[Operator.ALL_MODEL_DATA_TYPES] = None,
         param3: Optional[Operator.ALL_MODEL_DATA_TYPES] = None,
     ) -> Any:
-
         if (
             isinstance(param1, Dataset)
             or isinstance(param2, Dataset)
@@ -395,7 +392,10 @@ class Instr(Parameterized):
         else:
             if not check_unary_implicit_promotion(data_type, Integer):
                 raise SemanticError(
-                    "1-1-18-4", op=cls.op, param_type="Occurrence", correct_type="Integer"
+                    "1-1-18-4",
+                    op=cls.op,
+                    param_type="Occurrence",
+                    correct_type="Integer",
                 )
         if isinstance(param, DataComponent):
             if param.data is not None:
@@ -408,9 +408,7 @@ class Instr(Parameterized):
         if position == 2 and not pd.isnull(param) and param < 1:
             raise SemanticError("1-1-18-4", op=cls.op, param_type="Start", correct_type=">= 1")
         elif position == 3 and not pd.isnull(param) and param < 1:
-            raise SemanticError(
-                "1-1-18-4", op=cls.op, param_type="Occurrence", correct_type=">= 1"
-            )
+            raise SemanticError("1-1-18-4", op=cls.op, param_type="Occurrence", correct_type=">= 1")
 
     @classmethod
     def apply_operation_series_scalar(
@@ -529,7 +527,6 @@ class Instr(Parameterized):
         param2: Optional[Any],
         param3: Optional[Any],
     ) -> Any:
-
         if pd.isnull(x):
             return None
         return cls.py_op(x, param1, param2, param3)
@@ -560,7 +557,10 @@ class Instr(Parameterized):
             else:
                 # OPERATORS_STRINGOPERATORS.93
                 raise SemanticError(
-                    "1-1-18-4", op=cls.op, param_type="Occurrence", correct_type="Integer"
+                    "1-1-18-4",
+                    op=cls.op,
+                    param_type="Occurrence",
+                    correct_type="Integer",
                 )
         else:
             occurrence = 0