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

vtlengine/Operators/HROperators.py

@@ -1,22 +1,19 @@
 import operator
 from copy import copy
-from typing import Dict, Any
+from typing import Any, Dict
 
-import vtlengine.Operators as Operators
 import pandas as pd
-from vtlengine.DataTypes import Boolean, Number
 from pandas import DataFrame
 
+import vtlengine.Operators as Operators
 from vtlengine.AST.Grammar.tokens import HIERARCHY
-from vtlengine.Model import DataComponent, Dataset, Role, Component
+from vtlengine.DataTypes import Boolean, Number
+from vtlengine.Model import Component, DataComponent, Dataset, Role
 
 
 def get_measure_from_dataset(dataset: Dataset, code_item: str) -> DataComponent:
     measure_name = dataset.get_measures_names()[0]
-    if dataset.data is None:
-        data = None
-    else:
-        data = dataset.data[measure_name]
+    data = None if dataset.data is None else dataset.data[measure_name]
     return DataComponent(
         name=code_item,
         data=data,
@@ -35,33 +32,45 @@ class HRComparison(Operators.Binary):
         return x - y
 
     @staticmethod
-    def hr_func(x: Any, y: Any, hr_mode: str, func: Any) -> Any:
-        # In comments, it is specified the condition for evaluating the rule,
-        # so we delete the cases that does not satisfy the condition
-        # (line 6509 of the reference manual)
-        if hr_mode in ("partial_null", "partial_zero") and not pd.isnull(y) and y == "REMOVE_VALUE":
-            if hr_mode == "partial_null" and pd.isnull(x):
-                return "REMOVE_VALUE"
-            elif hr_mode == "partial_zero" and not pd.isnull(x) and x == 0:
-                return "REMOVE_VALUE"
-            return None
-        if hr_mode == "non_null":
-            # If all the involved Data Points are not NULL
-            if pd.isnull(x) or pd.isnull(y):
-                return "REMOVE_VALUE"
+    def hr_func(left_series: Any, right_series: Any, hr_mode: str) -> Any:
+        result = pd.Series(True, index=left_series.index)
+
+        if hr_mode in ("partial_null", "partial_zero"):
+            mask_remove = (right_series == "REMOVE_VALUE") & (right_series.notnull())
+            if hr_mode == "partial_null":
+                mask_null = mask_remove & left_series.notnull()
+            else:
+                mask_null = mask_remove & (left_series != 0)
+            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"
         elif hr_mode == "non_zero":
-            # If at least one of the involved Data Points is <> zero
-            if not (pd.isnull(x) and pd.isnull(y)) and (x == 0 and y == 0):
-                return "REMOVE_VALUE"
+            mask_remove = (left_series == 0) & (right_series == 0)
+            result[mask_remove] = "REMOVE_VALUE"
 
-        return func(x, y)
+        return result
 
     @classmethod
     def apply_hr_func(cls, left_series: Any, right_series: Any, hr_mode: str, func: Any) -> Any:
-        return left_series.combine(right_series, lambda x, y: cls.hr_func(x, y, hr_mode, func))
+        # In order not to apply the function to the whole series, we align the series
+        # and apply the function only to the valid values based on a validation mask.
+        # The function is applied to the aligned series and the result is combined with the
+        # original series.
+        left_series, right_series = left_series.align(right_series)
+        remove_result = cls.hr_func(left_series, right_series, hr_mode)
+        mask_valid = remove_result == True
+        result = pd.Series(remove_result, index=left_series.index)
+        result.loc[mask_valid] = left_series[mask_valid].combine(right_series[mask_valid], func)
+        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()
@@ -80,12 +89,11 @@ class HRComparison(Operators.Binary):
         )
 
     @classmethod
-    def evaluate(  # type: ignore[override]
-        cls, left: Dataset, right: DataComponent, hr_mode: str
-    ) -> Dataset:
+    def evaluate(cls, left: Dataset, right: DataComponent, hr_mode: str) -> Dataset:  # type: ignore[override]
         result = cls.validate(left, right, hr_mode)
         result.data = left.data.copy() if left.data is not None else pd.DataFrame()
         measure_name = left.get_measures_names()[0]
+
         if left.data is not None and right.data is not None:
             result.data["bool_var"] = cls.apply_hr_func(
                 left.data[measure_name], right.data, hr_mode, cls.op_func
@@ -93,6 +101,7 @@ class HRComparison(Operators.Binary):
             result.data["imbalance"] = cls.apply_hr_func(
                 left.data[measure_name], right.data, hr_mode, cls.imbalance_func
             )
+
         # Removing datapoints that should not be returned
         # (we do it below imbalance calculation
         # to avoid errors on different shape)
@@ -203,9 +212,7 @@ class HAAssignment(Operators.Binary):
     def handle_mode(cls, x: Any, hr_mode: str) -> Any:
         if not pd.isnull(x) and x == "REMOVE_VALUE":
             return "REMOVE_VALUE"
-        if hr_mode == "non_null" and pd.isnull(x):
-            return "REMOVE_VALUE"
-        elif hr_mode == "non_zero" and x == 0:
+        if hr_mode == "non_null" and pd.isnull(x) or hr_mode == "non_zero" and x == 0:
             return "REMOVE_VALUE"
         return x
 

vtlengine/Operators/Join.py

@@ -1,11 +1,6 @@
 from copy import copy
 from functools import reduce
-from typing import List, Dict, Any, Optional
-
-from vtlengine.DataTypes import binary_implicit_promotion
-
-from vtlengine.AST import BinOp
-from vtlengine.Exceptions import SemanticError
+from typing import Any, Dict, List, Optional
 
 # if os.environ.get("SPARK"):
 #     import pyspark.pandas as pd
@@ -13,7 +8,10 @@ from vtlengine.Exceptions import SemanticError
 #     import pandas as pd
 import pandas as pd
 
-from vtlengine.Model import Dataset, Component, Role
+from vtlengine.AST import BinOp
+from vtlengine.DataTypes import binary_implicit_promotion
+from vtlengine.Exceptions import SemanticError
+from vtlengine.Model import Component, Dataset, Role
 from vtlengine.Operators import Operator, _id_type_promotion_join_keys
 
 
@@ -197,7 +195,7 @@ class Join(Operator):
     def validate(cls, operands: List[Dataset], using: Optional[List[str]]) -> Dataset:
         if len(operands) < 1 or sum([isinstance(op, Dataset) for op in operands]) < 1:
             raise Exception("Join operator requires at least 1 dataset")
-        if not all([isinstance(op, Dataset) for op in operands]):
+        if not all(isinstance(op, Dataset) for op in operands):
             raise SemanticError("1-1-13-10")
         if len(operands) == 1 and isinstance(operands[0], Dataset):
             return Dataset(name="result", components=operands[0].components, data=None)
@@ -226,19 +224,17 @@ class Join(Operator):
                 raise SemanticError("1-1-13-14", op=cls.op, name=op_name)
 
         for op_name, identifiers in info.items():
-            if op_name != cls.reference_dataset.name and not set(identifiers).issubset(
-                set(info[cls.reference_dataset.name])
-            ):
-                if using is None:
-                    missing_components = list(
-                        set(identifiers) - set(info[cls.reference_dataset.name])
-                    )
-                    raise SemanticError(
-                        "1-1-13-11",
-                        op=cls.op,
-                        dataset_reference=cls.reference_dataset.name,
-                        component=missing_components[0],
-                    )
+            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,
+                    dataset_reference=cls.reference_dataset.name,
+                    component=missing_components[0],
+                )
         if using is None:
             return
 
@@ -256,7 +252,7 @@ class Join(Operator):
                     reference=cls.reference_dataset.name,
                 )
 
-            for op_name, identifiers in info.items():
+            for _, identifiers in info.items():
                 if not set(using).issubset(identifiers):
                     # (Case B2)
                     if not set(using).issubset(reference_components):

vtlengine/Operators/Numeric.py

@@ -1,13 +1,13 @@
+import _random
 import math
 import operator
-from decimal import getcontext, Decimal
+import warnings
+from decimal import Decimal, getcontext
 from typing import Any, Optional, Union
 
-import vtlengine.Operators as Operator
 import pandas as pd
-from vtlengine.DataTypes import Integer, Number
-from vtlengine.Operators import ALL_MODEL_DATA_TYPES
 
+import vtlengine.Operators as Operator
 from vtlengine.AST.Grammar.tokens import (
     ABS,
     CEIL,
@@ -21,12 +21,15 @@ from vtlengine.AST.Grammar.tokens import (
     MULT,
     PLUS,
     POWER,
+    RANDOM,
     ROUND,
     SQRT,
     TRUNC,
 )
+from vtlengine.DataTypes import Integer, Number, binary_implicit_promotion
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import DataComponent, Dataset, Scalar
+from vtlengine.Operators import ALL_MODEL_DATA_TYPES
 
 
 class Unary(Operator.Unary):
@@ -51,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
@@ -68,8 +72,8 @@ 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
-    """
+    `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
@@ -81,8 +85,8 @@ 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
-    """
+    `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
@@ -90,8 +94,8 @@ 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
-    """
+    `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
@@ -99,8 +103,8 @@ 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
-    """
+    `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
@@ -109,9 +113,9 @@ 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> `_ # noqa E501
+    `Natural logarithm <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=115&zoom=100,72,394> `_
     unary operator
-    """
+    """ # noqa E501
 
     op = LN
     py_op = math.log
@@ -120,9 +124,9 @@ 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> '_ # noqa E501
+    `Square Root <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=119&zoom=100,72,556> '_
     unary operator
-    """
+    """ # noqa E501
 
     op = SQRT
     py_op = math.sqrt
@@ -131,8 +135,8 @@ 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
-    """
+    `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
@@ -141,8 +145,8 @@ 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
-    """
+    `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
@@ -151,8 +155,8 @@ 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
-    """
+    `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
@@ -161,8 +165,8 @@ 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
-    """
+    `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
@@ -171,9 +175,9 @@ 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>`_ # noqa E501
+    `Multiplication <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=100&zoom=100,72,254>`_
     binary operator
-    """
+    """ # noqa E501
 
     op = MULT
     py_op = operator.mul
@@ -181,9 +185,9 @@ class Mult(Binary):
 
 class Div(Binary):
     """
-    `Division <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=102&zoom=100,72,94>`_ # noqa E501
+    `Division <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=102&zoom=100,72,94>`_
     binary operator
-    """
+    """ # noqa E501
 
     op = DIV
     py_op = operator.truediv
@@ -192,8 +196,8 @@ 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
-    """
+    `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
@@ -210,8 +214,8 @@ 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
-    """
+    `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
@@ -219,8 +223,8 @@ 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
-    """
+    `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
@@ -335,8 +339,8 @@ 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
-    """
+    `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
@@ -360,8 +364,8 @@ 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
-    """
+    `Trunc <https://sdmx.org/wp-content/uploads/VTL-2.1-Reference-Manual.pdf#page=108&zoom=100,72,94>`_ operator.
+    """ # noqa E501
 
     op = TRUNC
 
@@ -377,3 +381,36 @@ 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,14 +1,13 @@
 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
 import pandas as pd
 
+from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import DataComponent, Role, Scalar
 from vtlengine.Operators import Unary
 
@@ -36,9 +35,9 @@ class RoleSetter(Unary):
 
     @classmethod
     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")
+        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):
             result.data = pd.Series([operand.value] * data_size, dtype=object)
@@ -61,9 +60,8 @@ class Identifier(RoleSetter):
     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")
+        if isinstance(operand, Scalar) and operand.value is None:
+            raise SemanticError("1-1-1-16")
         return super().evaluate(operand, data_size)
 
 

vtlengine/Operators/Set.py

@@ -1,6 +1,4 @@
-from typing import List, Any, Dict
-
-from vtlengine.Exceptions import SemanticError
+from typing import Any, Dict, List
 
 # if os.environ.get("SPARK"):
 #     import pyspark.pandas as pd
@@ -8,9 +6,10 @@ from vtlengine.Exceptions import SemanticError
 #     import pandas as pd
 import pandas as pd
 
+from vtlengine.DataTypes import binary_implicit_promotion
+from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import Dataset
 from vtlengine.Operators import Operator
-from vtlengine.DataTypes import binary_implicit_promotion
 
 
 class Set(Operator):
@@ -87,9 +86,7 @@ class Intersection(Set):
                     data, how="inner", on=result.get_identifiers_names()
                 )
 
-                not_identifiers = [
-                    col for col in result.get_measures_names() + result.get_attributes_names()
-                ]
+                not_identifiers = result.get_measures_names() + result.get_attributes_names()
 
                 for col in not_identifiers:
                     result.data[col] = result.data[col + "_x"]
@@ -120,8 +117,8 @@ class Symdiff(Set):
                     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")
+                            if pd.isnull(row[f"{measure}_y"])
+                            else ("right_only" if pd.isnull(row[f"{measure}_x"]) else "both")
                         ),
                         axis=1,
                     )
@@ -162,9 +159,7 @@ class Setdiff(Set):
                 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 = 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"]

vtlengine/Operators/String.py

@@ -1,7 +1,6 @@
 import operator
 import re
-from vtlengine.Exceptions import SemanticError
-from vtlengine.Model import DataComponent, Dataset, Scalar
+from typing import Any, Optional, Union
 
 # if os.environ.get("SPARK", False):
 #     import pyspark.pandas as pd
@@ -9,21 +8,22 @@ from vtlengine.Model import DataComponent, Dataset, Scalar
 #     import pandas as pd
 import pandas as pd
 
-from typing import Optional, Any, Union
+import vtlengine.Operators as Operator
 from vtlengine.AST.Grammar.tokens import (
-    LEN,
     CONCAT,
-    UCASE,
+    INSTR,
     LCASE,
+    LEN,
+    LTRIM,
+    REPLACE,
     RTRIM,
     SUBSTR,
-    LTRIM,
     TRIM,
-    REPLACE,
-    INSTR,
+    UCASE,
 )
 from vtlengine.DataTypes import Integer, String, check_unary_implicit_promotion
-import vtlengine.Operators as Operator
+from vtlengine.Exceptions import SemanticError
+from vtlengine.Model import DataComponent, Dataset, Scalar
 
 
 class Unary(Operator.Unary):
@@ -280,10 +280,7 @@ class Substr(Parameterized):
             param1 -= 1
         elif param1 > (len(x)):
             return ""
-        if param2 is None or (param1 + param2) > len(x):
-            param2 = len(x)
-        else:
-            param2 = param1 + param2
+        param2 = len(x) if param2 is None or param1 + param2 > len(x) else param1 + param2
         return x[param1:param2]
 
     @classmethod
@@ -408,14 +405,12 @@ class Instr(Parameterized):
 
     @classmethod
     def check_param_value(cls, param: Any, position: int) -> None:
-        if position == 2:
-            if 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:
-            if not pd.isnull(param) and param < 1:
-                raise SemanticError(
-                    "1-1-18-4", op=cls.op, param_type="Occurrence", correct_type=">= 1"
-                )
+        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"
+            )
 
     @classmethod
     def apply_operation_series_scalar(
@@ -549,7 +544,7 @@ class Instr(Parameterized):
     ) -> Any:
         str_value = str(str_value)
         if not pd.isnull(start):
-            if isinstance(start, int) or isinstance(start, float):
+            if isinstance(start, (int, float)):
                 start = int(start - 1)
             else:
                 # OPERATORS_STRINGOPERATORS.92
@@ -560,7 +555,7 @@ class Instr(Parameterized):
             start = 0
 
         if not pd.isnull(occurrence):
-            if isinstance(occurrence, int) or isinstance(occurrence, float):
+            if isinstance(occurrence, (int, float)):
                 occurrence = int(occurrence - 1)
             else:
                 # OPERATORS_STRINGOPERATORS.93
@@ -578,9 +573,6 @@ class Instr(Parameterized):
 
         length = len(occurrences_list)
 
-        if occurrence > length - 1:
-            position = 0
-        else:
-            position = int(start + occurrences_list[occurrence] + 1)
+        position = 0 if occurrence > length - 1 else int(start + occurrences_list[occurrence] + 1)
 
         return position