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

vtlengine/Operators/Conditional.py

@@ -1,5 +1,5 @@
 from copy import copy
-from typing import Union, Any
+from typing import Union, Any, List
 
 import numpy as np
 
@@ -287,4 +287,145 @@ class Nvl(Binary):
             }
             for comp in result_components.values():
                 comp.nullable = False
-        return Dataset(name="result", components=result_components, data=None)
+        return Dataset(
+            name="result",
+            components=result_components,
+            data=None
+        )
+
+
+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)
+
+        if isinstance(result, Scalar):
+            result.value = elseOp.value
+            for i in range(len(conditions)):
+                if conditions[i].value:
+                    result.value = thenOps[i].value
+
+        if isinstance(result, DataComponent):
+            result.data = pd.Series(None, index=conditions[0].data.index)
+
+            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,  # type: ignore[call-overload]
+                                       result.data)
+
+            condition_mask_else = ~np.any([condition.data for condition in conditions], axis=0)
+            else_value = elseOp.value if isinstance(elseOp, Scalar) else elseOp.data
+            result.data = pd.Series(np.where(condition_mask_else, else_value, result.data),
+                                    index=conditions[0].data.index)
+
+        if isinstance(result, Dataset):
+            identifiers = result.get_identifiers_names()
+            columns = [col for col in result.get_components_names() if col not in identifiers]
+            result.data = (conditions[0].data[identifiers] if conditions[0].data is not None
+                           else pd.DataFrame(columns=identifiers))
+
+            for i in range(len(conditions)):
+                condition = conditions[i]
+                bool_col = next(x.name for x in condition.get_measures() if x.data_type == Boolean)
+                condition_mask = condition.data[bool_col]
+
+                result.data.loc[condition_mask, columns] = (
+                    thenOps[i].value if isinstance(thenOps[i], Scalar)
+                    else thenOps[i].data.loc[condition_mask, columns]
+                )
+
+            condition_mask_else = ~np.logical_or.reduce([
+                condition.data[next(x.name for x in condition.get_measures() if
+                                    x.data_type == Boolean)].astype(bool) for
+                condition in conditions])
+
+            result.data.loc[condition_mask_else, columns] = (
+                elseOp.value if isinstance(elseOp, Scalar)
+                else elseOp.data.loc[condition_mask_else, columns]
+            )
+
+        return result
+
+    @classmethod
+    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)
+
+        ops = thenOps + [elseOp]
+        then_else_types = set(map(type, ops))
+        condition_type = type(conditions[0])
+
+        if condition_type is Scalar:
+            for condition in conditions:
+                if condition.data_type != Boolean:
+                    raise SemanticError("2-1-9-2", op=cls.op, name=condition.name)
+            if list(then_else_types) != [Scalar]:
+                raise SemanticError("2-1-9-3", op=cls.op)
+
+            # The output data type is the data type of the last then operation that has a true
+            # condition, defaulting to the data type of the else operation if no condition is true
+            output_data_type = elseOp.data_type
+            for i in range(len(conditions)):
+                if conditions[i].value:
+                    output_data_type = thenOps[i].data_type
+
+            return Scalar(
+                name="result",
+                value=None,
+                data_type=output_data_type,
+            )
+
+        elif condition_type is DataComponent:
+            for condition in conditions:
+                if not condition.data_type == Boolean:
+                    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
+                for thenOp in ops
+            )
+
+            data_type = ops[0].data_type
+            for op in ops[1:]:
+                data_type = binary_implicit_promotion(data_type, op.data_type)
+
+            return DataComponent(
+                name="result",
+                data=None,
+                data_type=data_type,
+                role=Role.MEASURE,
+                nullable=nullable,
+            )
+
+        # Dataset
+        for condition in conditions:
+            if len(condition.get_measures_names()) != 1:
+                raise SemanticError("1-1-1-4", op=cls.op)
+            if condition.get_measures()[0].data_type != Boolean:
+                raise SemanticError("2-1-9-5", op=cls.op, name=condition.name)
+
+        if Dataset not in then_else_types:
+            raise SemanticError("2-1-9-6", op=cls.op)
+
+        components = next(op for op in ops if isinstance(op, Dataset)).components
+        comp_names = [comp.name for comp in components.values()]
+        for op in ops:
+            if isinstance(op, Dataset) and op.get_components_names() != comp_names:
+                raise SemanticError("2-1-9-7", op=cls.op)
+
+        return Dataset(
+            name="result",
+            components=components,
+            data=None
+        )

vtlengine/Operators/Numeric.py

@@ -1,11 +1,13 @@
+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 (
@@ -24,6 +26,7 @@ from vtlengine.AST.Grammar.tokens import (
     ROUND,
     SQRT,
     TRUNC,
+    RANDOM,
 )
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import DataComponent, Dataset, Scalar
@@ -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
@@ -377,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/Time.py

@@ -148,6 +148,10 @@ class Binary(Time):
     pass
 
 
+class Parameterized(Time):
+    pass
+
+
 class Period_indicator(Unary):
     op = PERIOD_INDICATOR
 
@@ -198,6 +202,17 @@ class Period_indicator(Unary):
         return result
 
 
+class Parametrized(Time):
+
+    @classmethod
+    def validate(cls, operand: Any, param: Any) -> Any:
+        pass
+
+    @classmethod
+    def evaluate(cls, operand: Any, param: Any) -> Any:
+        pass
+
+
 class Flow_to_stock(Unary):
 
     @classmethod
@@ -784,3 +799,122 @@ class Current_Date(Time):
         result = cls.validate()
         result.value = date.today().isoformat()
         return result
+
+
+class Date_Diff(Binary):
+
+    @classmethod
+    def evaluate(cls, Date1: Any, Date2: Any) -> Any:
+        # TODO: Implement this method (or adapt Binary's validate method to work with this operator)
+        pass
+
+    @classmethod
+    def validate(cls, Date1: Any, Date2: Any) -> Any:
+        pass
+
+
+class Date_Add(Parametrized):
+    @classmethod
+    def evaluate(cls, operand: Any, param_list: List[Any]) -> Any:
+        # TODO: Implement this method (or adapt Binary's validate method to work with this operator)
+        pass
+
+    @classmethod
+    def validate(cls, operand: Any, param_list: List[Any]) -> Any:
+        pass
+
+
+class Year(Unary):
+
+    @classmethod
+    def validate(cls, operand: Any) -> Any:
+        # TODO: Implement this method (or adapt Unary's validate method to work with this operator)
+        pass
+
+    @classmethod
+    def py_op(cls, x: Any) -> Any:
+        pass
+
+
+class Month(Unary):
+
+    @classmethod
+    def validate(cls, operand: Any) -> Any:
+        # TODO: Implement this method (or adapt Unary's validate method to work with this operator)
+        pass
+
+    @classmethod
+    def py_op(cls, x: Any) -> Any:
+        pass
+
+
+class Day_of_Month(Unary):
+
+    @classmethod
+    def validate(cls, operand: Any) -> Any:
+        # TODO: Implement this method (or adapt Unary's validate method to work with this operator)
+        pass
+
+    @classmethod
+    def py_op(cls, x: Any) -> Any:
+        pass
+
+
+class Day_of_Year(Unary):
+
+    @classmethod
+    def validate(cls, operand: Any) -> Any:
+        # TODO: Implement this method (or adapt Unary's validate method to work with this operator)
+        pass
+
+    @classmethod
+    def py_op(cls, x: Any) -> Any:
+        pass
+
+
+class Day_to_Year(Unary):
+
+    @classmethod
+    def validate(cls, operand: Any) -> Any:
+        # TODO: Implement this method (or adapt Unary's validate method to work with this operator)
+        pass
+
+    @classmethod
+    def py_op(cls, x: Any) -> Any:
+        pass
+
+
+class Day_to_Month(Unary):
+
+    @classmethod
+    def validate(cls, operand: Any) -> Any:
+        # TODO: Implement this method (or adapt Unary's validate method to work with this operator)
+        pass
+
+    @classmethod
+    def py_op(cls, x: Any) -> Any:
+        pass
+
+
+class Year_to_Day(Unary):
+
+    @classmethod
+    def validate(cls, operand: Any) -> Any:
+        # TODO: Implement this method (or adapt Unary's validate method to work with this operator)
+        pass
+
+    @classmethod
+    def py_op(cls, x: Any) -> Any:
+        pass
+
+
+class Month_to_Day(Unary):
+
+    @classmethod
+    def validate(cls, operand: Any) -> Any:
+        # TODO: Implement this method (or adapt Unary's validate method to work with this operator)
+        pass
+
+    @classmethod
+    def py_op(cls, x: Any) -> Any:
+        pass

vtlengine/Utils/__init__.py

@@ -1,3 +1,5 @@
+from typing import Any, Dict
+
 from vtlengine.Operators.Aggregation import (
     Avg,
     Count,
@@ -84,6 +86,7 @@ from vtlengine.Operators.Numeric import (
     Trunc,
     UnMinus,
     UnPlus,
+    Random,
 )
 from vtlengine.Operators.RoleSetter import Attribute, Identifier, Measure
 from vtlengine.Operators.Set import Intersection, Setdiff, Symdiff, Union
@@ -104,6 +107,16 @@ from vtlengine.Operators.Time import (
     Stock_to_flow,
     Fill_time_series,
     Time_Shift,
+    Year,
+    Month,
+    Day_of_Month,
+    Day_of_Year,
+    Day_to_Year,
+    Day_to_Month,
+    Year_to_Day,
+    Month_to_Day,
+    Date_Diff,
+    Date_Add,
 )
 
 from vtlengine.AST.Grammar.tokens import (
@@ -190,9 +203,20 @@ from vtlengine.AST.Grammar.tokens import (
     LEFT_JOIN,
     FULL_JOIN,
     CROSS_JOIN,
+    RANDOM,
+    DAYOFYEAR,
+    DAYOFMONTH,
+    MONTH,
+    YEAR,
+    DAYTOYEAR,
+    DAYTOMONTH,
+    YEARTODAY,
+    MONTHTODAY,
+    DATE_DIFF,
+    DATE_ADD,
 )
 
-BINARY_MAPPING = {
+BINARY_MAPPING: Dict[Any, Any] = {
     # General
     MEMBERSHIP: Membership,
     # Boolean
@@ -218,6 +242,7 @@ BINARY_MAPPING = {
     MOD: Modulo,
     POWER: Power,
     DIV: Div,
+    RANDOM: Random,
     # General
     AS: Alias,
     # String
@@ -225,6 +250,7 @@ BINARY_MAPPING = {
     # Time
     TIMESHIFT: Time_Shift,
     CHARSET_MATCH: Match,
+    DATE_DIFF: Date_Diff,
 }
 
 UNARY_MAPPING = {
@@ -253,6 +279,14 @@ UNARY_MAPPING = {
     PERIOD_INDICATOR: Period_indicator,
     FLOW_TO_STOCK: Flow_to_stock,
     STOCK_TO_FLOW: Stock_to_flow,
+    YEAR: Year,
+    MONTH: Month,
+    DAYOFMONTH: Day_of_Month,
+    DAYOFYEAR: Day_of_Year,
+    DAYTOYEAR: Day_to_Year,
+    DAYTOMONTH: Day_to_Month,
+    YEARTODAY: Year_to_Day,
+    MONTHTODAY: Month_to_Day,
 }
 
 PARAMETRIC_MAPPING = {
@@ -264,6 +298,7 @@ PARAMETRIC_MAPPING = {
     REPLACE: Replace,
     # Time
     FILL_TIME_SERIES: Fill_time_series,
+    DATE_ADD: Date_Add,
 }
 
 ROLE_SETTER_MAPPING = {
@@ -320,6 +355,7 @@ ANALYTIC_MAPPING = {
 }
 
 THEN_ELSE = {"then": "T", "else": "E"}
+
 JOIN_MAPPING = {
     INNER_JOIN: InnerJoin,
     LEFT_JOIN: LeftJoin,

vtlengine/files/parser/__init__.py

@@ -133,6 +133,8 @@ def _pandas_load_s3_csv(components: Dict[str, Component], csv_path: str) -> pd.D
 
 
 def _parse_boolean(value: str) -> bool:
+    if isinstance(value, bool):
+        return value
     if value.lower() == "true" or value == "1":
         return True
     return False

vtlengine/files/parser/_time_checking.py

@@ -93,6 +93,8 @@ further_options_period_pattern = (
 
 
 def check_time_period(value: str) -> str:
+    if isinstance(value, int):
+        value = str(value)
     value = value.replace(" ", "")
     period_result = re.fullmatch(period_pattern, value)
     if period_result is not None:

{vtlengine-1.0.1.dist-info → vtlengine-1.0.2.dist-info}/METADATA

@@ -1,12 +1,14 @@
 Metadata-Version: 2.1
 Name: vtlengine
-Version: 1.0.1
+Version: 1.0.2
 Summary: Run and Validate VTL Scripts
+Home-page: https://github.com/Meaningful-Data/vtlengine
 License: AGPL-3.0
+Keywords: vtl,sdmx,vtlengine,Validation and Transformation Language
 Author: MeaningfulData
 Author-email: info@meaningfuldata.eu
 Requires-Python: >=3.10,<4.0
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
@@ -16,20 +18,26 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
 Requires-Dist: antlr4-python3-runtime (==4.9.2)
 Requires-Dist: bottleneck (>=1.3.4,<2.0.0)
 Requires-Dist: duckdb (>=1.1.1,<2.0.0)
 Requires-Dist: networkx (>=2.8.8,<3.0.0)
-Requires-Dist: numba (>=0.60.0,<0.61.0)
 Requires-Dist: numexpr (>=2.9.0,<3.0.0)
 Requires-Dist: pandas (>=2.1.4,<3.0.0)
-Requires-Dist: pyarrow (>=17.0.0,<18.0.0)
 Requires-Dist: s3fs (>=2024.9.0,<2025.0.0)
 Requires-Dist: sqlglot (>=22.2.0,<23.0.0)
+Project-URL: Repository, https://github.com/Meaningful-Data/vtlengine
 Description-Content-Type: text/markdown
 
 # VTL Engine
 
+|         |                                                                                                                                                                                |
+|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Testing | [![Testing](https://github.com/Meaningful-Data/vtlengine/actions/workflows/testing.yml/badge.svg)](https://github.com/Meaningful-Data/vtlengine/actions/workflows/testing.yml) |
+| Package | [![PyPI Latest Release](https://img.shields.io/pypi/v/vtlengine.svg)](https://pypi.org/project/vtlengine/)                                                                     |
+| License | [![License - AGPL 3.0](https://img.shields.io/pypi/l/vtlengine.svg)](https://github.com/Meaningful-Data/vtlengine/blob/main/LICENSE.md)                                        |
+
 ## Introduction
 
 The VTL Engine is a Python library for validating and running VTL scripts.
@@ -67,7 +75,8 @@ Any action with VTL requires the following elements as input:
 * **VTL Script**: Is the VTL to be executed, which includes the transformation scheme, as well as de
   User Defined Operators, Hierarchical Rulesets and Datapoint Rulesets. It is provided as a string
   or as a Path object to a vtl file.
-* **Data structures** : Provides the structure of the input artifacts of the VTL script, according to
+* **Data structures** : Provides the structure of the input artifacts of the VTL script, according
+  to
   the VTL Information model. Given that the current version doesn't prescribe a standard format for
   providing the information, the VTL Engine is implementing a JSON format that can be found here.
   Data Structures can be provided as Dictionaries or as Paths to JSON files. It is possible to have

{vtlengine-1.0.1.dist-info → vtlengine-1.0.2.dist-info}/RECORD

@@ -1,58 +1,58 @@
-vtlengine/API/_InternalApi.py,sha256=emAbB-cOtThxcgYgFUmgQB_oxiBWSrAgSGOiqFKwlEo,14177
-vtlengine/API/__init__.py,sha256=gR3ZUmBJDOzPSO21b213u0xAR_OID7rzY0qs7oT04nc,10982
+vtlengine/API/_InternalApi.py,sha256=YO6FrDlIF-OJDjhj5n2Ds7afNvA3x9JwM9J9BJexsmU,14403
+vtlengine/API/__init__.py,sha256=shttqk4kmDbeQasawMuw_qqPN9uS2mzlzKy6QqZfp6o,10987
 vtlengine/AST/ASTConstructor.py,sha256=qmHkfiVmGGAYD7NeNJz_zyGxU3t0hY-kDdkzWjCyuVw,19976
-vtlengine/AST/ASTConstructorModules/Expr.py,sha256=hjPvuldphvIFM5wPTGHGRJESET24KwQGVuKHrnR6DPU,63190
-vtlengine/AST/ASTConstructorModules/ExprComponents.py,sha256=tH3GESt1UJ7zfGqHSzlkbtzNDUYQKeUL6E1rMhXE_cY,33779
+vtlengine/AST/ASTConstructorModules/Expr.py,sha256=6JQ3QynbIqRFrGg8MIJ54VB9Tf2OfxuM2BPwE8xODo0,66589
+vtlengine/AST/ASTConstructorModules/ExprComponents.py,sha256=Ud9s-ff2TUUWqvLbAU8Djj7ApXh9mNUsE-fNhphnZQ4,36903
 vtlengine/AST/ASTConstructorModules/Terminals.py,sha256=hcvgMzhWEAT1AsBZNrx80UYMf0nhcA4mbXDrcXAKQvc,25387
 vtlengine/AST/ASTConstructorModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vtlengine/AST/ASTDataExchange.py,sha256=kPSz21DGbEv-2bZowObseqf2d2_iQj1VnrqWuD9ZwtA,140
 vtlengine/AST/ASTEncoders.py,sha256=0RxSQ-4SFTOhFtQFntNeo8VT_gq4qCi92ZK7EWWqOCM,758
-vtlengine/AST/ASTTemplate.py,sha256=_tpxlRoVTWK4YIODRUbxpZBzvYzLtt9Je47YsVmcyWQ,11923
+vtlengine/AST/ASTTemplate.py,sha256=uL1wSwSqDwwBFhQEfhIOb8r9xG9uMwUOGBcVKD27bds,12358
 vtlengine/AST/ASTVisitor.py,sha256=3QQTudBpbR4pPQdH7y07EgwuzhoGzNQ59qox8R-E3fM,500
 vtlengine/AST/DAG/__init__.py,sha256=KAE0yz-kB6cBTJVBvOGcVT-fVStofDdCutjMsbITqNw,14714
 vtlengine/AST/DAG/_words.py,sha256=lEuBQ_w-KoKGna-x3gFGfbX1KP4Ez5EgdomH2LOeodk,170
-vtlengine/AST/Grammar/Vtl.g4,sha256=uxDPfJ14lMfxB5PyLf0f8Vb07T2z3JboU2FB22WMVz4,23776
-vtlengine/AST/Grammar/VtlTokens.g4,sha256=s4NtuaC9FcXNzUEAhy-HPQozfqSkoIaluHbzk9RKYkk,9570
+vtlengine/AST/Grammar/Vtl.g4,sha256=86bBWjQLCHZSuB5iLIk0JZRgMyMg0n7xbU8qzot2cIE,26313
+vtlengine/AST/Grammar/VtlTokens.g4,sha256=SwDR_59U25APqslczFcvTUiPoH7bC6kGaH2GkJ3kYzA,9972
 vtlengine/AST/Grammar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vtlengine/AST/Grammar/lexer.py,sha256=MzmwQbpxXPb6AlVPIZrBxKVW7YuPGTbofM3aYN_AHbo,99945
-vtlengine/AST/Grammar/parser.py,sha256=3_3zhVGh7Pigt48efV_kv0fme3zifx8-6RW051u2DhY,562035
-vtlengine/AST/Grammar/tokens.py,sha256=BHXadghMsT3S8mSQANtaRXDdrlFk8988Qmu-dxlTERU,2884
-vtlengine/AST/VtlVisitor.py,sha256=BJMULkRXVxFEpyT3M6_t6vemVQIHeBIQlW-UuVkKbJE,35015
-vtlengine/AST/__init__.py,sha256=h-66EkZH5C08sBxYBa_n7BWLfQsTKgIkm6FQTbb54cY,9528
+vtlengine/AST/Grammar/lexer.py,sha256=an_9C6ASQ2PN_0tAn41plIYt3gTx2cMrcbtBDXQyI-c,105743
+vtlengine/AST/Grammar/parser.py,sha256=4AA9tdgPuAyXELW5Cr6hZaHq3pdNKp0NeDpp8sPaVb0,635423
+vtlengine/AST/Grammar/tokens.py,sha256=VnNBAtm89AgKIDFPTQL0Jxunv5kUJ_n9D3Aj6Tfs2Do,3142
+vtlengine/AST/VtlVisitor.py,sha256=G9bpyPEvx8hUMzzn1V2RE4O3c59nPUEYrm5bEq8d6kc,35334
+vtlengine/AST/__init__.py,sha256=X5WIN476KnPeFFzHunldVCD1RtaHHUIcxtZONY0jaWk,9824
 vtlengine/DataTypes/NumericTypesHandling.py,sha256=eeSUhnRkAlcYjwbLZcuuUuJUNFWR3tVWQj8DfEHythk,1230
-vtlengine/DataTypes/TimeHandling.py,sha256=BE1axi7YkR0FRa6RyXxhMjTFFPaltYrdxA3eNGBkqNY,18783
+vtlengine/DataTypes/TimeHandling.py,sha256=HHktFbZTA90bNnLLXc39CrbMsU_5qZW4CQJd44k1IC4,18852
 vtlengine/DataTypes/__init__.py,sha256=tAm7U383MWckZCCqoh2327XaU44qap_l8nGkmmQlh_o,21607
-vtlengine/Exceptions/__init__.py,sha256=pBn8yKbZfMtawJcso5Q0B-3vgFILxuLwB91tuYrTXwE,3507
-vtlengine/Exceptions/messages.py,sha256=pYS4s9ytHz0yMk6vtYEjgAs7r80c4NRIr5FMuQrN8A8,19850
-vtlengine/Interpreter/__init__.py,sha256=isF1NBPdhbjzyMx9cWF_WE2C7-TrKrUNMhLDwu8Cwcs,79725
-vtlengine/Model/__init__.py,sha256=4CT_kMfJOLdcRxQvvdzUxVxN1-J2LW1IIPjnewImL68,15486
+vtlengine/Exceptions/__init__.py,sha256=yEWbYbWZVSyZU4n5fhAbl3bxKo5y88yNHag967zrM7k,4832
+vtlengine/Exceptions/messages.py,sha256=vW03MjerI77YR_RpYg9gK1SXQMisV0jAcq_GYYee-6g,20456
+vtlengine/Interpreter/__init__.py,sha256=IUpPSIWoCln7gWW4c8XL8O52P7yELKKNemnLrHXhfvY,80854
+vtlengine/Model/__init__.py,sha256=_v7Sp5XBu5_qgTFdVSfBfmlGSEQlEj5mh_t_cZC5klY,15554
 vtlengine/Operators/Aggregation.py,sha256=PyJqyOHfZ6o12w5FS-y9-5zfOdNmVjq1cXtn41rtD-E,11629
-vtlengine/Operators/Analytic.py,sha256=k0r1SPgSRH1tdJvG0X0suDdAxT2Wo23ZnnImpptXEO0,9993
+vtlengine/Operators/Analytic.py,sha256=uU0GrKsipuiOGZxhzb5_AVT5BEPKtJEby1c3c4Lpocs,11429
 vtlengine/Operators/Assignment.py,sha256=xCL9OocHqXvfwMLm33aM8moRoZtgwNxd6OnmVVwbP0Q,795
-vtlengine/Operators/Boolean.py,sha256=9FFdmSlQLlR7cSXswQUlkD_WyFcQWqfGY5VtYwqpKb4,2890
+vtlengine/Operators/Boolean.py,sha256=ZIT60qUNkbcRn7idHVLrViZdx_PxWg2hUNVGuFA7Tf0,2878
 vtlengine/Operators/CastOperator.py,sha256=yPadG3PJ6h3G0TMvt1EOZWjEFilMmkvQsnKZLorzpys,16743
 vtlengine/Operators/Clause.py,sha256=GoE1CgXStq59MxbnIiMJfhPNsWtWZP7R4MTQaVzCPfA,14815
 vtlengine/Operators/Comparison.py,sha256=5Efnl4fCt0hWRn1iukkSOG7s6NWB9u3I5fEsGCVvkYw,16513
-vtlengine/Operators/Conditional.py,sha256=jCWXRJltdx6Tl4CWyK9HYZkcUeXeLEJHk-UX7y2vKoA,13067
+vtlengine/Operators/Conditional.py,sha256=SeLWo7cT_Y4RZjKoWOovASGi4DJqHIvBc0ShE4SEXks,18594
 vtlengine/Operators/General.py,sha256=K6fxp-IbFTDGiZrm0A194bnQo7j0IcPyu5Y4Jq-91Hk,6652
 vtlengine/Operators/HROperators.py,sha256=jr6Wz-c9szhZ9luKAj3Bg1CwWbzauwlPOChzknvaBi0,8553
 vtlengine/Operators/Join.py,sha256=VwYCtzqlPT75iVctomp8NPAaKi3HiCQ1Pc_K7IPhZCU,18065
-vtlengine/Operators/Numeric.py,sha256=0dR_0HZymPk86jl0uD12HdFilS4xlMOlN9ffGELVElo,10801
+vtlengine/Operators/Numeric.py,sha256=Sc7zPt4HjRH0l8pVnnBF9vkBoQK6zCFBF1Y0kpHiMRM,11928
 vtlengine/Operators/RoleSetter.py,sha256=vjFmZnKPONmR2ztBbi4om7DQZkK6t2joDxMg9v_JPBA,2247
 vtlengine/Operators/Set.py,sha256=7KnHUZaswz3TRcIeE1FwnI_TYR4LP4ZqbMN-bgPQU_g,7041
 vtlengine/Operators/String.py,sha256=hd9bVHqCAQVrXtBNN-oJlWZRONSfeVWRpIL654GvMr8,20315
-vtlengine/Operators/Time.py,sha256=5srrGi_QBSopJm2bfZAwokw94pnGjZngkMTJfBVNRUM,31815
+vtlengine/Operators/Time.py,sha256=Ng7w8TtFOemmDdDQfms6sUoAz1kUODbI2IybioC4f_0,34823
 vtlengine/Operators/Validation.py,sha256=C7w1bvc8j-dYshPNvtpN_oCGMkbsoGoyv4WBCh9o2pg,10000
 vtlengine/Operators/__init__.py,sha256=CJEwWUlz827yp4lyuXPSsMCMd4IWqCOw0yYvqpB76CI,36993
-vtlengine/Utils/__init__.py,sha256=Plrr6nCPPUJ2PApbqsj0GAYF4Q7GBjLufv3-vCsJB6k,6458
+vtlengine/Utils/__init__.py,sha256=pWnyAi5WmoBGiaG00jCBBYHJ1IeSF6k7HpJI-aWbOY4,7105
 vtlengine/__init__.py,sha256=qmLklaVsS-yHG4QeSzGDYln49PLhFaIjBatYNwAm2Ug,89
 vtlengine/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vtlengine/files/output/__init__.py,sha256=X1gmR7Hwp1wKuVTEYPxJRg1cCH-9rYdJk5Ma4_iQc8o,1170
 vtlengine/files/output/_time_period_representation.py,sha256=3uSMK_tHXigsKNFt5-U75ZI9pIRVi6WERFwAG6jEBz0,1580
-vtlengine/files/parser/__init__.py,sha256=TT8MTquqppKxNXq0mgj0nA4jSN8ibufxaqxnofnUeqQ,8754
+vtlengine/files/parser/__init__.py,sha256=Dk7BP4f2H-1EIgx8-VyFTqcP_VyfdDj9XzRvAqmr95Q,8807
 vtlengine/files/parser/_rfc_dialect.py,sha256=Y8kAYBxH_t9AieN_tYg7QRh5A4DgvabKarx9Ko3QeCQ,462
-vtlengine/files/parser/_time_checking.py,sha256=SW89OWAnlTfzBYQDXk0GplImxZlN8XmvvGapJqQQ9Xs,4683
-vtlengine-1.0.1.dist-info/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
-vtlengine-1.0.1.dist-info/METADATA,sha256=aCPKAQRRY0okW85Lkw4Sx9MO1EAu_1pYJsg-dRVWVN0,7430
-vtlengine-1.0.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-vtlengine-1.0.1.dist-info/RECORD,,
+vtlengine/files/parser/_time_checking.py,sha256=IJLZ6dxCTf6DWPT6TKJ-Hc5nUyRmTgpTq_qfWgeZJ_o,4741
+vtlengine-1.0.2.dist-info/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
+vtlengine-1.0.2.dist-info/METADATA,sha256=vU4vjEPjnJ15tJC0dboeBP0ZF5IZQne_KrF8GdcDURY,8531
+vtlengine-1.0.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+vtlengine-1.0.2.dist-info/RECORD,,