vtlengine 1.2.1rc1__py3-none-any.whl → 1.3.0rc1__py3-none-any.whl

vtlengine/Operators/Conditional.py

@@ -66,6 +66,7 @@ class If(Operator):
                 false_data = pd.Series(false_branch.value, index=condition.data.index)
             else:
                 false_data = false_branch.data.reindex(condition.data.index)
+            condition.data = condition.data.fillna(False)
             result = np.where(condition.data, true_data, false_data)
 
         return pd.Series(result, index=condition.data.index)  # type: ignore[union-attr]
@@ -316,6 +317,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 +346,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/General.py

@@ -154,7 +154,7 @@ class Eval(Unary):
         for comp_name in component_names:
             if comp_name not in output.components:
                 raise SemanticError(
-                    "1-1-1-10", op=cls.op, comp_name=comp_name, dataset_name=df.name
+                    "1-1-1-10", op=cls.op, comp_name=comp_name, dataset_name=output.name
                 )
 
         for comp_name in output.components:

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/Operators/__init__.py

@@ -84,6 +84,8 @@ class Operator:
     def cast_time_types_scalar(cls, data_type: Any, value: str) -> Any:
         if cls.op not in BINARY_COMPARISON_OPERATORS:
             return value
+        if value is None:
+            return None
         if data_type.__name__ == "TimeInterval":
             return TimeIntervalHandler.from_iso_format(value)
         elif data_type.__name__ == "TimePeriod":
@@ -614,8 +616,10 @@ class Binary(Operator):
 
         for measure in dataset.get_measures():
             measure_data = cls.cast_time_types(measure.data_type, result_data[measure.name].copy())
-            if measure.data_type.__name__.__str__() == "Duration" and not isinstance(
-                scalar_value, int
+            if (
+                measure.data_type.__name__.__str__() == "Duration"
+                and not isinstance(scalar_value, int)
+                and scalar_value is not None
             ):
                 scalar_value = PERIOD_IND_MAPPING[scalar_value]
             result_dataset.data[measure.name] = cls.apply_operation_series_scalar(
@@ -654,8 +658,10 @@ class Binary(Operator):
             component.data.copy() if component.data is not None else pd.Series(),
         )
         scalar_value = cls.cast_time_types_scalar(scalar.data_type, scalar.value)
-        if component.data_type.__name__.__str__() == "Duration" and not isinstance(
-            scalar_value, int
+        if (
+            component.data_type.__name__.__str__() == "Duration"
+            and not isinstance(scalar_value, int)
+            and scalar_value is not None
         ):
             scalar_value = PERIOD_IND_MAPPING[scalar_value]
         result_component.data = cls.apply_operation_series_scalar(

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.1rc1"
+__version__ = "1.3.0rc1"

vtlengine/files/parser/__init__.py

@@ -17,14 +17,14 @@ from vtlengine.DataTypes import (
     TimeInterval,
     TimePeriod,
 )
-from vtlengine.DataTypes.TimeHandling import PERIOD_IND_MAPPING
-from vtlengine.Exceptions import InputValidationException, SemanticError
-from vtlengine.files.parser._rfc_dialect import register_rfc
-from vtlengine.files.parser._time_checking import (
+from vtlengine.DataTypes._time_checking import (
     check_date,
     check_time,
     check_time_period,
 )
+from vtlengine.DataTypes.TimeHandling import PERIOD_IND_MAPPING
+from vtlengine.Exceptions import InputValidationException, SemanticError
+from vtlengine.files.parser._rfc_dialect import register_rfc
 from vtlengine.Model import Component, Dataset, Role
 
 TIME_CHECKS_MAPPING: Dict[Type[ScalarType], Any] = {
@@ -108,7 +108,7 @@ def _pandas_load_csv(components: Dict[str, Component], csv_path: Union[str, Path
     obj_dtypes = {comp_name: object for comp_name, comp in components.items()}
 
     data = pd.read_csv(
-        csv_path,
+        csv_path,  # type: ignore[call-overload, unused-ignore]
         dtype=obj_dtypes,
         engine="c",
         keep_default_na=False,
@@ -148,7 +148,7 @@ def _validate_pandas(
     if len(id_names) == 0 and len(data) > 1:
         raise SemanticError("0-1-1-5", name=dataset_name)
 
-    data = data.fillna(np.nan).replace([np.nan], [None])
+    data = data.fillna(np.nan).replace([np.nan], None)
     # Checking data types on all data types
     comp_name = ""
     comp = None
@@ -182,7 +182,7 @@ def _validate_pandas(
                         values_correct = (
                             data[comp_name]
                             .map(
-                                lambda x: x.replace(" ", "") in PERIOD_IND_MAPPING,  # type: ignore[union-attr]
+                                lambda x: x.replace(" ", "") in PERIOD_IND_MAPPING,  # type: ignore[union-attr, unused-ignore]
                                 na_action="ignore",
                             )
                             .all()
@@ -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-1.2.1rc1.dist-info → vtlengine-1.3.0rc1.dist-info}/METADATA

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: vtlengine
-Version: 1.2.1rc1
+Version: 1.3.0rc1
 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
@@ -16,8 +17,8 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Typing :: Typed
 Provides-Extra: all
 Provides-Extra: s3
-Requires-Dist: antlr4-python3-runtime (>=4.13.2,<4.14)
-Requires-Dist: duckdb (>=1.1,<1.2)
+Requires-Dist: antlr4-python3-runtime (>=4.9,<4.10)
+Requires-Dist: duckdb (>=1.4,<1.5)
 Requires-Dist: fsspec (>=2022.11.0,<2023.0) ; extra == "all"
 Requires-Dist: fsspec (>=2022.11.0,<2023.0) ; extra == "s3"
 Requires-Dist: jsonschema (>=3.2.0,<5.0)
@@ -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.1rc1.dist-info → vtlengine-1.3.0rc1.dist-info}/RECORD

@@ -1,11 +1,13 @@
-vtlengine/API/_InternalApi.py,sha256=ptmL3F07ThTN2G2yLAo7p6Az_njScJYfBbasYUaLEF0,24167
-vtlengine/API/__init__.py,sha256=XyL_7ZNaEfL5Xbler7iHI7MtsbHsQRvopSa25h14R3A,18598
+vtlengine/API/_InternalApi.py,sha256=6nZPc8jARsa7rVw09YOhvgPHkVOJtOta5sPyEc9U2T0,25165
+vtlengine/API/__init__.py,sha256=-dy9QfT79knEjcAPZ55ck0U-d1XxTu6htYtfUDmy1Es,21034
+vtlengine/API/data/schema/external_routines_schema.json,sha256=--egdFkK1-vB-WkJ10bNko2qZ9ZP24bgpZv_D_qquQI,696
 vtlengine/API/data/schema/json_schema_2.1.json,sha256=v3-C0Xnq8qScJSPAtLgb3rjKMrd3nz-bIxgZdTSEUiU,4336
+vtlengine/API/data/schema/value_domain_schema.json,sha256=Qr7AOnPsfLAWv1XZk-pm8d0vVU79Qw3P1tBs7g4lthg,2229
 vtlengine/AST/ASTComment.py,sha256=bAJW7aaqBXU2LqMtRvL_XOttdl1AFZufa15vmQdvNlY,1667
 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
@@ -17,26 +19,27 @@ vtlengine/AST/DAG/_words.py,sha256=LyRL9j-vZUNHdLDJZJrq2nKUmVlpbxdzd9ovW6CnNoU,2
 vtlengine/AST/Grammar/Vtl.g4,sha256=g4a76A04qH-SaR9a9LfrG4rt3GPZ7UpqZLISkY1BkmI,26323
 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=66cH0cJi83Sxd8XPrPRYkBwdz4NGhPaadUnq5p0GYUI,256579
-vtlengine/AST/Grammar/parser.py,sha256=fWJaGcXvUCwN2pvjJBU4l5apoQnkhQbUv_mSlKKiDXc,712465
+vtlengine/AST/Grammar/lexer.py,sha256=zg3HdNvuoKNkijt-jWhavmWfTPmU4Dx6Jb0sf_1xvEg,105722
+vtlengine/AST/Grammar/parser.py,sha256=NIcPZPjwke4Ik5ksm96BHL0WaVEs_FXWu61waehVHVk,638343
 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/DataTypes/__init__.py,sha256=LYXrde68bYm7MLeMLmr4haeOTSE4Fnpq9G2Ewy7DiaU,23084
+vtlengine/AST/__init__.py,sha256=zTrSDHd3AFaHvvqdPYT8ZthqN2anHfI9Ul1QomA4rNo,11708
+vtlengine/DataTypes/TimeHandling.py,sha256=6kP5CWrrmP1DdRq_mViG5G2-48J7eNW3_FCqHAhoXNM,20497
+vtlengine/DataTypes/__init__.py,sha256=60iB8m6izBDrY1FkI5woIo2oEJZ2dqCTGiH-3UmFXQs,25479
+vtlengine/DataTypes/_time_checking.py,sha256=YAbjO8IEc8fJz3mSstCV3Qma2S5Sk5PRZzQjI48RElY,4822
 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/Model/__init__.py,sha256=xWrwhdUOj8Y-5x38zP5XnmFPw8IkBVBBG2bPsUBGLA8,15869
-vtlengine/Operators/Aggregation.py,sha256=BI4cHzdWWtxEHisg1cr87twg8gvc1MHfR05JsiXpo6M,11956
+vtlengine/Exceptions/messages.py,sha256=DMeQt9cNE1hutDo0BAq0KoVLhnPWJS9suDud51C68QU,20544
+vtlengine/Interpreter/__init__.py,sha256=6Ffl5bJRL1KSF335xSxfA8a5y_pV8ZNQUYM9BmYN6hg,87256
+vtlengine/Model/__init__.py,sha256=9FCxBuGotA1_L6x0l8uk9emVguE4PFIaA3cPAjN_D3E,17340
+vtlengine/Operators/Aggregation.py,sha256=bweme6bum3QA5LFR6uvNm7JQkFUpNAkyD2kIqAGeQiQ,12500
 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/General.py,sha256=ltRK8Sw686sb4rC5ji2OX-GYVxaK_PpL0Lev8P5OFHI,6828
+vtlengine/Operators/Conditional.py,sha256=wtpfhMw8Pnw61SGb1CX2iOu1ELPqObJXcmodYXVE9ZY,21240
+vtlengine/Operators/General.py,sha256=uu-n9FvXzEvgqDTUMy5LhqdsOgqDd3rGaYRXwXl77OQ,6832
 vtlengine/Operators/HROperators.py,sha256=YybwD70906AA00c0k4IP6sjeta0pg7hqb2EUVsFqdmA,8979
 vtlengine/Operators/Join.py,sha256=lYmC_jGlJ4RRmn2vplB13Ysrxgv6O8sNFEHQYZzun5s,18393
 vtlengine/Operators/Numeric.py,sha256=icYTWzEsw6VQFLYc5Wucgr8961d8ZwTFx_wfZ8Wp9Co,12083
@@ -44,20 +47,19 @@ 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/__init__.py,sha256=N1zi9RFC_l0qggRm5IPLOkPFtFS4CGAg-r1taHOrbTI,37667
+vtlengine/Operators/Validation.py,sha256=ot-og75Ce690DddQM-xILrY3PoRf8Z0M3aIovFK-wMY,11245
+vtlengine/Operators/__init__.py,sha256=iwYUO00ce_J6jRHmFScIJZB3WTLuhS_bNOQkN5BfeCw,37835
 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=l8c8MEFiqOOnoRwhFkch3oZAxLsyNg2vIj0c96LYZmU,191
+vtlengine/__init__.py,sha256=zTOiIdhnN9M97pRWFDTsvCYQ4n2wrpF7QdXjD5FKkRQ,191
 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=RWtQSKFk64Ag4gzIuRw1nHzWvO91_zvAATEbMPR2Urc,9086
 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/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vtlengine-1.2.1rc1.dist-info/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
-vtlengine-1.2.1rc1.dist-info/METADATA,sha256=OgvVzj7n35H2Z9qPn3vzXcUXAPiFcYUzzACX7PA053A,4135
-vtlengine-1.2.1rc1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-vtlengine-1.2.1rc1.dist-info/RECORD,,
+vtlengine-1.3.0rc1.dist-info/METADATA,sha256=YWAp6Hql-chdGgKnlIKELuaL3ZaR0C4amn_sEpcZe-s,4165
+vtlengine-1.3.0rc1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+vtlengine-1.3.0rc1.dist-info/licenses/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
+vtlengine-1.3.0rc1.dist-info/RECORD,,

{vtlengine-1.2.1rc1.dist-info → vtlengine-1.3.0rc1.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