vtlengine 1.2.1__py3-none-any.whl → 1.2.2__py3-none-any.whl

vtlengine/AST/ASTConstructorModules/Terminals.py

@@ -622,11 +622,7 @@ class Terminals(VtlVisitor):
         erLevel: ERRORLEVEL  constant;
         """
         ctx_list = list(ctx.getChildren())
-
-        try:
-            return int(self.visitConstant(ctx_list[1]).value)
-        except Exception:
-            raise Exception(f"Error level must be an integer, line {ctx_list[1].start.line}")
+        return self.visitConstant(ctx_list[1]).value
 
     def visitSignature(self, ctx: Parser.SignatureContext, kind="ComponentID"):
         """

vtlengine/AST/__init__.py

@@ -443,7 +443,7 @@ class Validation(AST):
     op: str
     validation: str
     error_code: Optional[str]
-    error_level: Optional[int]
+    error_level: Optional[Union[int, str]]
     imbalance: Optional[AST]
     invalid: bool
 
@@ -590,7 +590,7 @@ class HRule(AST):
     name: Optional[str]
     rule: HRBinOp
     erCode: Optional[str]
-    erLevel: Optional[int]
+    erLevel: Optional[Union[int, str]]
 
     __eq__ = AST.ast_equality
 
@@ -604,7 +604,7 @@ class DPRule(AST):
     name: Optional[str]
     rule: HRBinOp
     erCode: Optional[str]
-    erLevel: Optional[int]
+    erLevel: Optional[Union[int, str]]
 
     __eq__ = AST.ast_equality
 

vtlengine/DataTypes/TimeHandling.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, Optional, Union
 
 import pandas as pd
 
+from vtlengine.AST.Grammar.tokens import GT, GTE, LT, LTE
 from vtlengine.Exceptions import SemanticError
 
 PERIOD_IND_MAPPING = {"A": 6, "S": 5, "Q": 4, "M": 3, "W": 2, "D": 1}
@@ -180,7 +181,7 @@ class TimePeriodHandler:
 
     @staticmethod
     def _check_year(year: int) -> None:
-        if year < 1900 or year > 9999:
+        if year < 0 or year > 9999:
             raise SemanticError("2-1-19-10", year=year)
             # raise ValueError(f'Invalid year {year}, must be between 1900 and 9999.')
 
@@ -407,22 +408,22 @@ class TimeIntervalHandler:
         return py_op(self.length, other.length)
 
     def __eq__(self, other: Any) -> Optional[bool]:  # type: ignore[override]
-        return self._meta_comparison(other, operator.eq)
+        return str(self) == str(other) if other is not None else None
 
     def __ne__(self, other: Any) -> Optional[bool]:  # type: ignore[override]
-        return self._meta_comparison(other, operator.ne)
+        return str(self) != str(other) if other is not None else None
 
     def __lt__(self, other: Any) -> Optional[bool]:
-        return self._meta_comparison(other, operator.lt)
+        raise SemanticError("2-1-19-17", op=LT, type="Time")
 
     def __le__(self, other: Any) -> Optional[bool]:
-        return self._meta_comparison(other, operator.le)
+        raise SemanticError("2-1-19-17", op=LTE, type="Time")
 
     def __gt__(self, other: Any) -> Optional[bool]:
-        return self._meta_comparison(other, operator.gt)
+        raise SemanticError("2-1-19-17", op=GT, type="Time")
 
     def __ge__(self, other: Any) -> Optional[bool]:
-        return self._meta_comparison(other, operator.ge)
+        raise SemanticError("2-1-19-17", op=GTE, type="Time")
 
     @classmethod
     def from_time_period(cls, value: TimePeriodHandler) -> "TimeIntervalHandler":

vtlengine/Exceptions/messages.py

@@ -44,6 +44,8 @@ centralised_messages = {
     "0-1-1-12": "On Dataset {name} loading: not possible to cast column {column} to {type}.",
     "0-1-1-13": "Invalid key on {field} field: {key}{closest_key}.",
     "0-1-1-14": "Empty datasets {dataset1} and {dataset2} shape missmatch.",
+    "0-1-1-15": "On Dataset {name} loading: Duplicated identifiers are not allowed, "
+    "found on row {row_index}",
     "0-1-0-1": " Trying to redefine input datasets {dataset}.",  # Semantic Error
     # ------------Operators-------------
     # General Semantic errors
@@ -51,6 +53,7 @@ centralised_messages = {
     "1-1-1-2": "Invalid implicit cast from {type_1} and {type_2} to {type_check}.",
     "1-1-1-3": "At op {op}: {entity} {name} cannot be promoted to {target_type}.",
     "1-1-1-4": "At op {op}: Operation not allowed for multimeasure datasets.",
+    "1-1-1-5": "At op {op}: Invalid type {type}.",
     "1-1-1-8": "At op {op}: Invalid Dataset {name}, no measures defined.",
     "1-1-1-9": "At op {op}: Invalid Dataset {name}, all measures must have the same type: {type}.",
     "1-1-1-10": "Component {comp_name} not found in Dataset {dataset_name}.",
@@ -240,6 +243,10 @@ centralised_messages = {
     "measure.",
     "2-1-19-15": "{op} can only be applied according to the iso 8601 format mask",
     "2-1-19-16": "{op} can only be positive numbers",
+    "2-1-19-17": "At op {op}: Time operators comparison are only support "
+    "= and <> comparison operations",
+    "2-1-19-18": "At op {op}: Time operators do not support < and > comparison operations, "
+    "so its not possible to use get the max or min between two time operators",
     # ----------- Interpreter Common ------
     "2-3-1": "{comp_type} {comp_name} not found.",
     "2-3-2": "{op_type} cannot be used with {node_op} operators.",

vtlengine/Interpreter/__init__.py

@@ -151,6 +151,8 @@ class InterpreterAnalyzer(ASTTemplate):
     dprs: Optional[Dict[str, Optional[Dict[str, Any]]]] = None
     udos: Optional[Dict[str, Optional[Dict[str, Any]]]] = None
     hrs: Optional[Dict[str, Optional[Dict[str, Any]]]] = None
+    is_from_case_then: bool = False
+    signature_values: Optional[Dict[str, Any]] = None
 
     # **********************************
     # *                                *
@@ -1078,15 +1080,43 @@ class InterpreterAnalyzer(ASTTemplate):
 
         if self.condition_stack is None:
             self.condition_stack = []
+        if self.then_condition_dataset is None:
+            self.then_condition_dataset = []
+        if self.else_condition_dataset is None:
+            self.else_condition_dataset = []
 
-        while node.cases:
-            case = node.cases.pop(0)
+        for case in node.cases:
             self.is_from_condition = True
-            conditions.append(self.visit(case.condition))
+            cond = self.visit(case.condition)
             self.is_from_condition = False
-            thenOps.append(self.visit(case.thenOp))
 
-        return Case.analyze(conditions, thenOps, self.visit(node.elseOp))
+            conditions.append(cond)
+            if isinstance(cond, Scalar):
+                then_result = self.visit(case.thenOp)
+                thenOps.append(then_result)
+                continue
+
+            self.generate_then_else_datasets(copy(cond))
+
+            self.condition_stack.append(THEN_ELSE["then"])
+            self.is_from_if = True
+            self.is_from_case_then = True
+
+            then_result = self.visit(case.thenOp)
+            thenOps.append(then_result)
+
+            self.is_from_case_then = False
+            self.is_from_if = False
+            if len(self.condition_stack) > 0:
+                self.condition_stack.pop()
+            if len(self.then_condition_dataset) > 0:
+                self.then_condition_dataset.pop()
+            if len(self.else_condition_dataset) > 0:
+                self.else_condition_dataset.pop()
+
+        elseOp = self.visit(node.elseOp)
+
+        return Case.analyze(conditions, thenOps, elseOp)
 
     def visit_RenameNode(self, node: AST.RenameNode) -> Any:
         if self.udo_params is not None:
@@ -1575,11 +1605,10 @@ class InterpreterAnalyzer(ASTTemplate):
         if self.else_condition_dataset is None:
             self.else_condition_dataset = []
         if isinstance(condition, Dataset):
-            if (
-                len(condition.get_measures()) != 1
-                or condition.get_measures()[0].data_type != BASIC_TYPES[bool]
-            ):
-                raise ValueError("Only one boolean measure is allowed on condition dataset")
+            if len(condition.get_measures()) != 1:
+                raise SemanticError("1-1-1-4", op="condition")
+            if condition.get_measures()[0].data_type != BASIC_TYPES[bool]:
+                raise SemanticError("2-1-9-5", op="condition", name=condition.name)
             name = condition.get_measures_names()[0]
             if condition.data is None or condition.data.empty:
                 data = None
@@ -1589,7 +1618,7 @@ class InterpreterAnalyzer(ASTTemplate):
 
         else:
             if condition.data_type != BASIC_TYPES[bool]:
-                raise ValueError("Only boolean scalars are allowed on data component condition")
+                raise SemanticError("2-1-9-4", op="condition", name=condition.name)
             name = condition.name
             data = None if condition.data is None else condition.data
 
@@ -1667,11 +1696,18 @@ class InterpreterAnalyzer(ASTTemplate):
         ):
             return left_operand, right_operand
 
-        merge_dataset = (
-            self.then_condition_dataset.pop()
-            if self.condition_stack.pop() == THEN_ELSE["then"]
-            else (self.else_condition_dataset.pop())
-        )
+        if self.is_from_case_then:
+            merge_dataset = (
+                self.then_condition_dataset[-1]
+                if self.condition_stack[-1] == THEN_ELSE["then"]
+                else self.else_condition_dataset[-1]
+            )
+        else:
+            merge_dataset = (
+                self.then_condition_dataset.pop()
+                if self.condition_stack.pop() == THEN_ELSE["then"]
+                else (self.else_condition_dataset.pop())
+            )
 
         merge_index = merge_dataset.data[merge_dataset.get_measures_names()[0]].to_list()
         ids = merge_dataset.get_identifiers_names()
@@ -1826,6 +1862,8 @@ class InterpreterAnalyzer(ASTTemplate):
             raise SemanticError("2-3-10", comp_type="User Defined Operators")
         elif node.op not in self.udos:
             raise SemanticError("1-3-5", node_op=node.op, op_type="User Defined Operator")
+        if self.signature_values is None:
+            self.signature_values = {}
 
         operator = self.udos[node.op]
         signature_values = {}
@@ -1919,6 +1957,12 @@ class InterpreterAnalyzer(ASTTemplate):
             self.udo_params = []
 
         # Adding parameters to the stack
+        for k, v in signature_values.items():
+            if hasattr(v, "name"):
+                v = v.name  # type: ignore[assignment]
+            if v in self.signature_values:
+                signature_values[k] = self.signature_values[v]  # type: ignore[index]
+        self.signature_values.update(signature_values)
         self.udo_params.append(signature_values)
 
         # Calling the UDO AST, we use deepcopy to avoid changing the original UDO AST

vtlengine/Operators/Aggregation.py

@@ -259,6 +259,10 @@ class Aggregation(Operator.Unary):
         result_df = result_df[grouping_keys + measure_names]
         if cls.op == COUNT:
             result_df = result_df.dropna(subset=measure_names, how="any")
+        if cls.op in [MAX, MIN]:
+            for measure in operand.get_measures():
+                if measure.data_type == TimeInterval:
+                    raise SemanticError("2-1-19-18", op=cls.op)
         cls._handle_data_types(result_df, operand.get_measures(), "input")
         result_df = cls._agg_func(result_df, grouping_keys, measure_names, having_expr)
 

vtlengine/Operators/Conditional.py

@@ -316,6 +316,7 @@ class Case(Operator):
         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, Dataset) and condition.data is not None:
                 condition.data.fillna(False, inplace=True)
@@ -344,57 +345,73 @@ class Case(Operator):
                     result.value = thenOps[i].value
 
         if isinstance(result, DataComponent):
-            result.data = pd.Series(None, index=conditions[0].data.index)
+            full_index = conditions[0].data.index
+            result.data = pd.Series(None, index=full_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.notna(),
-                    np.where(condition.data, value, result.data),
-                    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(thenOps[i], Scalar):
+                    value_series = pd.Series(thenOps[i].value, index=full_index)
+                else:
+                    value_series = thenOps[i].data.reindex(full_index)
+                cond_series = condition.data.reindex(full_index)
+                cond_mask = cond_series.notna() & cond_series == True
+                result_data = result.data.copy()
+                result_data[cond_mask] = value_series[cond_mask]
+                result.data = result_data
+
+            conditions_stack = [c.data.reindex(full_index).fillna(False) for c in conditions]
+            else_cond_mask = (
+                ~np.logical_or.reduce(conditions_stack)
+                if conditions_stack
+                else pd.Series(True, index=full_index)
             )
+            if isinstance(elseOp, Scalar):
+                else_series = pd.Series(elseOp.value, index=full_index)
+            else:
+                else_series = elseOp.data.reindex(full_index)
+            result.data[else_cond_mask] = else_series[else_cond_mask]
 
-        if isinstance(result, Dataset):
+        elif 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)
-            )
+            ).copy()
 
+            full_index = result.data.index
             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]
+                cond_mask = condition.data[bool_col].reindex(full_index).astype(bool)
 
-                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
-                ]
+                if isinstance(thenOps[i], Scalar):
+                    for col in columns:
+                        result.data.loc[cond_mask, col] = thenOps[i].value
+                else:
+                    cond_df = thenOps[i].data.reindex(full_index)
+                    result.data.loc[cond_mask, columns] = cond_df.loc[cond_mask, columns]
+
+            then_cond_masks = [
+                c.data[next(x.name for x in c.get_measures() if x.data_type == Boolean)]
+                .reindex(full_index)
+                .fillna(False)
+                .astype(bool)
+                for c in conditions
+            ]
+            else_cond_mask = (
+                ~np.logical_or.reduce(then_cond_masks)
+                if then_cond_masks
+                else pd.Series(True, index=full_index)
             )
 
-            result.data.loc[condition_mask_else, columns] = (  # type: ignore[index, unused-ignore]
-                elseOp.value
-                if isinstance(elseOp, Scalar)
-                else elseOp.data.loc[condition_mask_else, columns]
-            )
+            if isinstance(elseOp, Scalar):
+                for col in columns:
+                    result.data.loc[else_cond_mask, col] = elseOp.value
+            else:
+                else_df = elseOp.data.reindex(full_index)
+                result.data.loc[else_cond_mask, columns] = else_df.loc[else_cond_mask, columns]
 
         return result
 

vtlengine/Operators/Validation.py

@@ -1,5 +1,5 @@
 from copy import copy
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 
 import pandas as pd
 
@@ -27,7 +27,7 @@ class Check(Operator):
         validation_element: Dataset,
         imbalance_element: Optional[Dataset],
         error_code: Optional[str],
-        error_level: Optional[int],
+        error_level: Optional[Union[int, str]],
         invalid: bool,
     ) -> Dataset:
         dataset_name = VirtualCounter._new_ds_name()
@@ -36,6 +36,13 @@ class Check(Operator):
         measure = validation_element.get_measures()[0]
         if measure.data_type != Boolean:
             raise SemanticError("1-1-10-1", op=cls.op, op_type="validation", me_type="Boolean")
+        error_level_type = None
+        if error_level is None or isinstance(error_level, int):
+            error_level_type = Integer
+        elif isinstance(error_level, str):
+            error_level_type = String  # type: ignore[assignment]
+        else:
+            error_level_type = String
 
         imbalance_measure = None
         if imbalance_element is not None:
@@ -69,8 +76,12 @@ class Check(Operator):
         result_components["errorcode"] = Component(
             name="errorcode", data_type=String, role=Role.MEASURE, nullable=True
         )
+
         result_components["errorlevel"] = Component(
-            name="errorlevel", data_type=Integer, role=Role.MEASURE, nullable=True
+            name="errorlevel",
+            data_type=error_level_type,  # type: ignore[arg-type]
+            role=Role.MEASURE,
+            nullable=True,
         )
 
         return Dataset(name=dataset_name, components=result_components, data=None)
@@ -81,7 +92,7 @@ class Check(Operator):
         validation_element: Dataset,
         imbalance_element: Optional[Dataset],
         error_code: Optional[str],
-        error_level: Optional[int],
+        error_level: Optional[Union[int, str]],
         invalid: bool,
     ) -> Dataset:
         result = cls.validate(
@@ -128,6 +139,20 @@ class Validation(Operator):
 
     @classmethod
     def validate(cls, dataset_element: Dataset, rule_info: Dict[str, Any], output: str) -> Dataset:
+        error_level_type = None
+        error_levels = [
+            rule_data.get("errorlevel")
+            for rule_data in rule_info.values()
+            if "errorlevel" in rule_data
+        ]
+        non_null_levels = [el for el in error_levels if el is not None]
+
+        if len(non_null_levels) == 0 or all(isinstance(el, int) for el in non_null_levels):
+            error_level_type = Number
+        elif all(isinstance(el, str) for el in non_null_levels):
+            error_level_type = String  # type: ignore[assignment]
+        else:
+            error_level_type = String  # type: ignore[assignment]
         dataset_name = VirtualCounter._new_ds_name()
         result_components = {comp.name: comp for comp in dataset_element.get_identifiers()}
         result_components["ruleid"] = Component(
@@ -154,7 +179,10 @@ class Validation(Operator):
             name="errorcode", data_type=String, role=Role.MEASURE, nullable=True
         )
         result_components["errorlevel"] = Component(
-            name="errorlevel", data_type=Number, role=Role.MEASURE, nullable=True
+            name="errorlevel",
+            data_type=error_level_type,  # type: ignore[arg-type]
+            role=Role.MEASURE,
+            nullable=True,
         )
 
         return Dataset(name=dataset_name, components=result_components, data=None)

vtlengine/__init__.py

@@ -2,4 +2,4 @@ from vtlengine.API import generate_sdmx, prettify, run, run_sdmx, semantic_analy
 
 __all__ = ["semantic_analysis", "run", "generate_sdmx", "run_sdmx", "prettify"]
 
-__version__ = "1.2.1"
+__version__ = "1.2.2"

vtlengine/files/parser/__init__.py

@@ -203,9 +203,19 @@ def _validate_pandas(
         str_comp = SCALAR_TYPES_CLASS_REVERSE[comp.data_type] if comp else "Null"
         raise SemanticError("0-1-1-12", name=dataset_name, column=comp_name, type=str_comp)
 
+    if id_names:
+        check_identifiers_duplicity(data, id_names, dataset_name)
+
     return data
 
 
+def check_identifiers_duplicity(data: pd.DataFrame, identifiers: List[str], name: str) -> None:
+    dup_id_row = data.duplicated(subset=identifiers, keep=False)
+    if dup_id_row.any():
+        row_index = int(dup_id_row.idxmax()) + 1
+        raise SemanticError("0-1-1-15", name=name, row_index=row_index)
+
+
 def load_datapoints(
     components: Dict[str, Component],
     dataset_name: str,

vtlengine/files/parser/_time_checking.py

@@ -95,6 +95,11 @@ def check_time_period(value: str) -> str:
     if isinstance(value, int):
         value = str(value)
     value = value.replace(" ", "")
+
+    match = re.fullmatch(r"^(\d{4})-(\d{2})$", value)
+    if match:
+        value = f"{match.group(1)}-M{match.group(2)}"
+
     period_result = re.fullmatch(period_pattern, value)
     if period_result is not None:
         result = TimePeriodHandler(value)

{vtlengine-1.2.1.dist-info → vtlengine-1.2.2.dist-info}/METADATA

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: vtlengine
-Version: 1.2.1
+Version: 1.2.2
 Summary: Run and Validate VTL Scripts
-License: AGPL-3.0
+License-Expression: AGPL-3.0
+License-File: LICENSE.md
 Keywords: vtl,sdmx,vtlengine,Validation and Transformation Language
 Author: MeaningfulData
 Author-email: info@meaningfuldata.eu
@@ -25,7 +26,7 @@ Requires-Dist: networkx (>=2.8,<3.0)
 Requires-Dist: numpy (>=1.23.2,<2) ; python_version < "3.13"
 Requires-Dist: numpy (>=2.1.0) ; python_version >= "3.13"
 Requires-Dist: pandas (>=2.1.4,<3.0)
-Requires-Dist: pysdmx[xml] (>=1.4.0rc1,<2.0)
+Requires-Dist: pysdmx[xml] (>=1.5.2,<2.0)
 Requires-Dist: s3fs (>=2022.11.0,<2023.0) ; extra == "all"
 Requires-Dist: s3fs (>=2022.11.0,<2023.0) ; extra == "s3"
 Requires-Dist: sqlglot (>=22.2.0,<23.0)

{vtlengine-1.2.1.dist-info → vtlengine-1.2.2.dist-info}/RECORD

@@ -5,7 +5,7 @@ vtlengine/AST/ASTComment.py,sha256=bAJW7aaqBXU2LqMtRvL_XOttdl1AFZufa15vmQdvNlY,1
 vtlengine/AST/ASTConstructor.py,sha256=X55I98BKG1ItyGIDObF9ALVfCcWnU-0wwCWJsiPILkg,21488
 vtlengine/AST/ASTConstructorModules/Expr.py,sha256=PdI66D3dwA4ymxgqqcChkctsWMRgBSfuyUtgH-KOkss,70207
 vtlengine/AST/ASTConstructorModules/ExprComponents.py,sha256=2Ft4e5w2NtbfaqSNW8I9qSpG9iUaPIfdug7yYWo2gqE,38553
-vtlengine/AST/ASTConstructorModules/Terminals.py,sha256=7zWDx_SFcbnL35G7Y0qZwl-lLEsfqReyzBX0UxwTCOk,27054
+vtlengine/AST/ASTConstructorModules/Terminals.py,sha256=0-5XZbGTXSQxAAWeF-xBBszyaGEb02lD1Ar82ljxk28,26911
 vtlengine/AST/ASTConstructorModules/__init__.py,sha256=J6g6NhJD8j0Ek1YmpethxRiFdjhLxUTM0mc3NHRFLlM,1879
 vtlengine/AST/ASTDataExchange.py,sha256=kPSz21DGbEv-2bZowObseqf2d2_iQj1VnrqWuD9ZwtA,140
 vtlengine/AST/ASTEncoders.py,sha256=-Ar6a0GqMdJZK4CtZ1pUpIeGv57oSdN5qy3-aF0Zt9c,948
@@ -21,21 +21,21 @@ vtlengine/AST/Grammar/lexer.py,sha256=66cH0cJi83Sxd8XPrPRYkBwdz4NGhPaadUnq5p0GYU
 vtlengine/AST/Grammar/parser.py,sha256=fWJaGcXvUCwN2pvjJBU4l5apoQnkhQbUv_mSlKKiDXc,712465
 vtlengine/AST/Grammar/tokens.py,sha256=YF7tO0nF2zYC-VaBAJLyc6VitM72CvYfFQpoPDGCMzo,3139
 vtlengine/AST/VtlVisitor.py,sha256=NJfXJVP6wNmasJmPLlojFqm9R5VSamOAKg_w7BMrhac,35332
-vtlengine/AST/__init__.py,sha256=JnPilognG2rT2gtpjD4OwKFX0O3ZqvV-ic8gJxRu7Xo,11672
-vtlengine/DataTypes/TimeHandling.py,sha256=CYnC0sb1qbRjTnCSsA3wgez7QftOzrXHxbuZXlY3O3Q,20151
+vtlengine/AST/__init__.py,sha256=zTrSDHd3AFaHvvqdPYT8ZthqN2anHfI9Ul1QomA4rNo,11708
+vtlengine/DataTypes/TimeHandling.py,sha256=K8769_b3Q4kPXGC2XVQ4oN7VsGnhxmJtgdhC_ryXjho,20250
 vtlengine/DataTypes/__init__.py,sha256=LYXrde68bYm7MLeMLmr4haeOTSE4Fnpq9G2Ewy7DiaU,23084
 vtlengine/Exceptions/__init__.py,sha256=rSSskV_qCBFzg_W67Q1QBAL7Lnq88D7yi2BDYo1hytw,4727
-vtlengine/Exceptions/messages.py,sha256=h2RHfgolbNsYXO39FXT3NTe2RwG-1AK5NL9k6utPtCA,19658
-vtlengine/Interpreter/__init__.py,sha256=aO7CGEzFgg0W6kkXFYHzogVxsiVI0l9pJ3wH8m1WuPE,85502
+vtlengine/Exceptions/messages.py,sha256=V68Al8_TGvb_kY9PHEtSRp26rF_PjhjHdDMRtB-IuTI,20113
+vtlengine/Interpreter/__init__.py,sha256=6Ffl5bJRL1KSF335xSxfA8a5y_pV8ZNQUYM9BmYN6hg,87256
 vtlengine/Model/__init__.py,sha256=xWrwhdUOj8Y-5x38zP5XnmFPw8IkBVBBG2bPsUBGLA8,15869
-vtlengine/Operators/Aggregation.py,sha256=BI4cHzdWWtxEHisg1cr87twg8gvc1MHfR05JsiXpo6M,11956
+vtlengine/Operators/Aggregation.py,sha256=K9u0PE77ZAqEwKTCRyRx9G9uvpyVVZQBB_E4648B4V8,12158
 vtlengine/Operators/Analytic.py,sha256=adm8y4mTeen4iVMsQvcvxM9U5f6Xj9UNjdCQI2OBINE,12934
 vtlengine/Operators/Assignment.py,sha256=xyJgGPoFYbq6mzX06gz7Q7L8jXJxpUkgzdY3Lrne2hw,793
 vtlengine/Operators/Boolean.py,sha256=3U5lHkxW5d7QQdGDNxXeXqejlPfFrXKG8_TqknrC8Ls,2856
 vtlengine/Operators/CastOperator.py,sha256=pXTSs0UYBeR5hS3J2HWUyaHmoZoifl2EFch6ol_Taok,17115
 vtlengine/Operators/Clause.py,sha256=Lu6zjcUBkShN6kQmjEZu_7ytaFGwfH-yB4ROoCSkLGI,15505
 vtlengine/Operators/Comparison.py,sha256=CRMvs9qXVXUW32pxAnCua8b7ZHpJy0-Egvs691ekOCk,17403
-vtlengine/Operators/Conditional.py,sha256=lu0S06GtBzVR_pbq9_QyAGeUC0Xcawag-3wBh5W93Xc,20340
+vtlengine/Operators/Conditional.py,sha256=Py4QwCgCi4t4-FG75-RMe7M5sDRgUZlRGyuFt4RwwJ4,21182
 vtlengine/Operators/General.py,sha256=ltRK8Sw686sb4rC5ji2OX-GYVxaK_PpL0Lev8P5OFHI,6828
 vtlengine/Operators/HROperators.py,sha256=YybwD70906AA00c0k4IP6sjeta0pg7hqb2EUVsFqdmA,8979
 vtlengine/Operators/Join.py,sha256=lYmC_jGlJ4RRmn2vplB13Ysrxgv6O8sNFEHQYZzun5s,18393
@@ -44,20 +44,20 @@ vtlengine/Operators/RoleSetter.py,sha256=mHZIdcHC3wflj81ekLbioDG1f8yHZXYDQFymV-K
 vtlengine/Operators/Set.py,sha256=f1uLeY4XZF0cWEwpXRB_CczgbXr6s33DYPuFt39HlEg,7084
 vtlengine/Operators/String.py,sha256=ghWtYl6oUEAAzynY1a9Hg4yqRA9Sa7uk2B6iF9uuSqQ,20230
 vtlengine/Operators/Time.py,sha256=ESn6ldPg73bdZxOXZYJuIwCLDQnXDGTqR1y7ckQmV1M,43025
-vtlengine/Operators/Validation.py,sha256=tnHRZ7o0Z_AE1Bb2DtRVP6pGGUtSs5KVwNSEJxzzGnk,10162
+vtlengine/Operators/Validation.py,sha256=ot-og75Ce690DddQM-xILrY3PoRf8Z0M3aIovFK-wMY,11245
 vtlengine/Operators/__init__.py,sha256=N1zi9RFC_l0qggRm5IPLOkPFtFS4CGAg-r1taHOrbTI,37667
 vtlengine/Utils/__Virtual_Assets.py,sha256=0jPXysZrBr0hYVzqFoyg9La8ZcZoZ01Ql245X5vrth4,862
 vtlengine/Utils/__init__.py,sha256=zhGPJA8MjHmtEEwMS4CxEFYL0tk2L5F0YPn7bitdRzM,8954
 vtlengine/__extras_check.py,sha256=Wr-lxGZhXJZEacVV5cUkvKt7XM-mry0kYAe3VxNrVcY,614
-vtlengine/__init__.py,sha256=KCcWyZAye_AlBe85RhqEnKonr2ARI8SgoznT_MMl8cs,188
+vtlengine/__init__.py,sha256=2ylv7tLHXE_OKN9-zlvcdqenn_WPaMklmkjAt-EJ16A,188
 vtlengine/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vtlengine/files/output/__init__.py,sha256=4tmf-p1Y1u5Ohrwt3clQA-FMGaijKI3HC_iwn3H9J8c,1250
 vtlengine/files/output/_time_period_representation.py,sha256=D5XCSXyEuX_aBzTvBV3sZxACcgwXz2Uu_YH3loMP8q0,1610
-vtlengine/files/parser/__init__.py,sha256=JamEIWI0pFZxT0sKYE6Fii8H2JQcsFn4Nf3T0OLSm9g,8637
+vtlengine/files/parser/__init__.py,sha256=WdvToMTIeWgkkuUWSDvtACQlguEZN3plz5LPvyCvdt0,9030
 vtlengine/files/parser/_rfc_dialect.py,sha256=Y8kAYBxH_t9AieN_tYg7QRh5A4DgvabKarx9Ko3QeCQ,462
-vtlengine/files/parser/_time_checking.py,sha256=UAC_Pv-eQJKrhgTguWb--xfqMMs6quyMeiAkGBt_vgI,4725
+vtlengine/files/parser/_time_checking.py,sha256=-MsfAJdIHpVwPulaiklxvyPfWAVocwvf43WSqgusryc,4849
 vtlengine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vtlengine-1.2.1.dist-info/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
-vtlengine-1.2.1.dist-info/METADATA,sha256=wN1W64ZHTH74x_lcVf9EjBTzaWWjZE7UeY2-ZiKVICw,4132
-vtlengine-1.2.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-vtlengine-1.2.1.dist-info/RECORD,,
+vtlengine-1.2.2.dist-info/METADATA,sha256=BzikHNHbu6YDewYFLYeYD5tAkwoEg2sfI2ySJBBcnR8,4165
+vtlengine-1.2.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+vtlengine-1.2.2.dist-info/licenses/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
+vtlengine-1.2.2.dist-info/RECORD,,

{vtlengine-1.2.1.dist-info → vtlengine-1.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any