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

vtlengine/Operators/Numeric.py

@@ -1,16 +1,33 @@
+import _random
 import math
 import operator
+import warnings
 from decimal import getcontext, Decimal
 from typing import Any, Optional, Union
 
 import vtlengine.Operators as Operator
 import pandas as pd
-from vtlengine.DataTypes import Integer, Number
+from vtlengine.DataTypes import Integer, Number, binary_implicit_promotion
 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,
+    RANDOM,
+)
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import DataComponent, Dataset, Scalar
 
@@ -19,6 +36,7 @@ class Unary(Operator.Unary):
     """
     Checks that the unary operation is performed with a number.
     """
+
     type_to_check = Number
 
 
@@ -26,6 +44,7 @@ class Binary(Operator.Binary):
     """
     Checks that the binary operation is performed with numbers.
     """
+
     type_to_check = Number
 
     @classmethod
@@ -35,7 +54,8 @@ class Binary(Operator.Binary):
         if isinstance(x, int) and isinstance(y, int):
             if cls.op == DIV and y == 0:
                 raise SemanticError("2-1-15-6", op=cls.op, value=y)
-            return cls.py_op(x, y)
+            if cls.op == RANDOM:
+                return cls.py_op(x, y)
         x = float(x)
         y = float(y)
         # Handles precision to avoid floating point errors
@@ -52,8 +72,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 +85,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 +113,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 +124,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 +135,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 +145,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 +155,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 +165,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 +175,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 +196,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 +214,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 +233,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 +272,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 +292,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 +349,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 +364,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
 
@@ -332,3 +381,37 @@ class Trunc(Parameterized):
             return truncated_value
 
         return int(truncated_value)
+
+
+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
+
+    @classmethod
+    def validate(cls, seed: Any, index: Any = None) -> Any:
+        if index.data_type != Integer:
+            index.data_type = binary_implicit_promotion(index.data_type, Integer)
+        if index.value < 0:
+            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.", UserWarning)
+        return super().validate(seed, index)
+
+    @classmethod
+    def py_op(cls,
+              seed: Union[int, float],
+              index: int
+              ) -> float:
+        instance: PseudoRandom = PseudoRandom(seed)
+        for _ in range(index):
+            instance.random()
+        return instance.random().__round__(6)

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