vtlengine 1.2.2__py3-none-any.whl → 1.3.0rc1__py3-none-any.whl

vtlengine/DataTypes/TimeHandling.py

@@ -255,6 +255,10 @@ class TimePeriodHandler:
         if isinstance(other, str):
             other = TimePeriodHandler(other)
 
+        if self.period_indicator != other.period_indicator:
+            tokens = {operator.lt: "<", operator.le: "<=", operator.gt: ">", operator.ge: ">="}
+            raise SemanticError("2-1-19-19", op=tokens[py_op], value1=self, value2=other)
+
         self_lapse, other_lapse = self.period_dates, other.period_dates
         is_lt_or_le = py_op in [operator.lt, operator.le]
         is_gt_or_ge = py_op in [operator.gt, operator.ge]

vtlengine/DataTypes/__init__.py

@@ -3,6 +3,11 @@ from typing import Any, Dict, Optional, Set, Type, Union
 
 import pandas as pd
 
+from vtlengine.DataTypes._time_checking import (
+    check_date,
+    check_time,
+    check_time_period,
+)
 from vtlengine.DataTypes.TimeHandling import (
     check_max_date,
     date_to_period_str,
@@ -102,6 +107,14 @@ class ScalarType:
         class_name: str = cls.__name__.__str__()
         return DTYPE_MAPPING[class_name]
 
+    @classmethod
+    def check(cls, value: Any) -> bool:
+        try:
+            cls.cast(value)
+            return True
+        except Exception:
+            return False
+
 
 class String(ScalarType):
     """ """
@@ -143,6 +156,10 @@ class String(ScalarType):
             type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
         )
 
+    @classmethod
+    def check(cls, value: Any) -> bool:
+        return True
+
 
 class Number(ScalarType):
     """ """
@@ -201,6 +218,19 @@ class Number(ScalarType):
                 return 0.0
         return float(value)
 
+    @classmethod
+    def check(cls, value: Any) -> bool:
+        if pd.isnull(value):
+            return True
+        if isinstance(value, (int, float, bool)):
+            return True
+        if isinstance(value, str):
+            v = value.strip()
+            if v.lower() in {"true", "false"}:
+                return True
+            return bool(re.match(r"^\d+(\.\d*)?$|^\.\d+$", v))
+        return False
+
 
 class Integer(Number):
     """ """
@@ -286,6 +316,16 @@ class Integer(Number):
                 return 0
         return int(value)
 
+    @classmethod
+    def check(cls, value: Any) -> bool:
+        if pd.isnull(value):
+            return True
+        if isinstance(value, str):
+            return value.isdigit() or value.lower() in {"true", "false"}
+        if isinstance(value, float):
+            return value.is_integer()
+        return isinstance(value, (int, bool))
+
 
 class TimeInterval(ScalarType):
     """ """
@@ -325,6 +365,16 @@ class TimeInterval(ScalarType):
             type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
         )
 
+    @classmethod
+    def check(cls, value: Any) -> bool:
+        if pd.isnull(value):
+            return True
+        try:
+            check_time(value)
+        except Exception:
+            return False
+        return True
+
 
 class Date(TimeInterval):
     """ """
@@ -357,6 +407,16 @@ class Date(TimeInterval):
             type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
         )
 
+    @classmethod
+    def check(cls, value: Any) -> bool:
+        if pd.isnull(value):
+            return True
+        try:
+            check_date(value)
+        except Exception:
+            return False
+        return True
+
 
 class TimePeriod(TimeInterval):
     """ """
@@ -400,6 +460,16 @@ class TimePeriod(TimeInterval):
             type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
         )
 
+    @classmethod
+    def check(cls, value: Any) -> bool:
+        if pd.isnull(value):
+            return True
+        try:
+            check_time_period(value)
+        except Exception:
+            return False
+        return True
+
 
 class Duration(ScalarType):
     iso8601_duration_pattern = r"^P((\d+Y)?(\d+M)?(\d+D)?)$"
@@ -461,6 +531,16 @@ class Duration(ScalarType):
         total_days = years * 365 + months * 30 + days
         return int(total_days)
 
+    @classmethod
+    def check(cls, value: Any) -> bool:
+        if pd.isnull(value):
+            return True
+
+        if isinstance(value, str):
+            match = re.match(cls.iso8601_duration_pattern, value)
+            return bool(match)
+        return False
+
 
 class Boolean(ScalarType):
     """ """
@@ -514,6 +594,14 @@ class Boolean(ScalarType):
             type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
         )
 
+    @classmethod
+    def check(cls, value: Any) -> bool:
+        if pd.isnull(value):
+            return True
+        if isinstance(value, str):
+            return value.lower() in {"true", "false", "1", "0"}
+        return isinstance(value, (int, float, bool))
+
 
 class Null(ScalarType):
     """ """
@@ -534,6 +622,10 @@ class Null(ScalarType):
     def dtype(cls) -> str:
         return "string"
 
+    @classmethod
+    def check(cls, value: Any) -> bool:
+        return True
+
 
 SCALAR_TYPES: Dict[str, Type[ScalarType]] = {
     "String": String,

vtlengine/{files/parser → DataTypes}/_time_checking.py

@@ -11,7 +11,7 @@ def check_date(value: str) -> str:
     Check if the date is in the correct format.
     """
     # Remove all whitespaces
-    value = value.replace(" ", "")
+    value = value.strip()
     try:
         if len(value) == 9 and value[7] == "-":
             value = value[:-1] + "0" + value[-1]
@@ -49,7 +49,7 @@ time_pattern = r"^" + date_pattern + r"/" + date_pattern + r"$"
 
 
 def check_time(value: str) -> str:
-    value = value.replace(" ", "")
+    value = value.strip()
     year_result = re.fullmatch(year_pattern, value)
     if year_result is not None:
         date1_time = datetime.strptime(value, "%Y")
@@ -94,7 +94,7 @@ further_options_period_pattern = (
 def check_time_period(value: str) -> str:
     if isinstance(value, int):
         value = str(value)
-    value = value.replace(" ", "")
+    value = value.strip()
 
     match = re.fullmatch(r"^(\d{4})-(\d{2})$", value)
     if match:

vtlengine/Exceptions/messages.py

@@ -17,6 +17,8 @@ centralised_messages = {
     "0-1-2-3": "Component {component} is duplicated.",
     "0-1-2-4": "Invalid json structure because {err} on file {filename}.",
     "0-1-2-5": "File {file} must be encoded in utf-8 (without BOM).",
+    "0-1-2-6": "Not found scalar {name} in datastructures",
+    "0-1-2-7": "Invalid value '{value}' for type {type_} {op_type} {name}.",
     # Run SDMX errors
     "0-1-3-1": "Expected exactly one input dataset in the whole script, found: {number_datasets}",
     "0-1-3-2": "SDMX Dataset {schema} requires to have a Schema object defined as structure",
@@ -247,6 +249,10 @@ centralised_messages = {
     "= 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",
+    "2-1-19-19": "Time Period comparison (>, <, >=, <=) with different period indicator is not "
+    "supported, found {value1} {op} {value2}",
+    "2-1-19-20": "Time Period operands with different period indicators do not support < and > "
+    "comparison operations, unable to get the {op}",
     # ----------- Interpreter Common ------
     "2-3-1": "{comp_type} {comp_name} not found.",
     "2-3-2": "{op_type} cannot be used with {node_op} operators.",

vtlengine/Model/__init__.py

@@ -14,7 +14,7 @@ from pandas._testing import assert_frame_equal
 import vtlengine.DataTypes as DataTypes
 from vtlengine.DataTypes import SCALAR_TYPES, ScalarType
 from vtlengine.DataTypes.TimeHandling import TimePeriodHandler
-from vtlengine.Exceptions import SemanticError
+from vtlengine.Exceptions import InputValidationException, SemanticError
 
 # from pyspark.pandas import DataFrame as SparkDataFrame, Series as SparkSeries
 
@@ -27,7 +27,28 @@ class Scalar:
 
     name: str
     data_type: Type[ScalarType]
-    value: Any
+    _value: Any
+
+    def __init__(self, name: str, data_type: Type[ScalarType], value: Any) -> None:
+        self.name = name
+        self.data_type = data_type
+        self.value = value
+
+    @property
+    def value(self) -> Any:
+        return self._value
+
+    @value.setter
+    def value(self, new_value: Any) -> None:
+        if self.data_type and not self.data_type.check(new_value):
+            raise InputValidationException(
+                code="0-1-2-7",
+                value=new_value,
+                type_=self.data_type.__name__,
+                op_type=self.__class__.__name__,
+                name=self.name,
+            )
+        self._value = new_value
 
     @classmethod
     def from_json(cls, json_str: str) -> "Scalar":
@@ -368,7 +389,30 @@ class ScalarSet:
     """
 
     data_type: Type[ScalarType]
-    values: List[Union[int, float, str, bool]]
+    _values: List[Union[int, float, str, bool]]
+
+    def __init__(
+        self, data_type: Type[ScalarType], values: List[Union[int, float, str, bool]]
+    ) -> None:
+        self.data_type = data_type
+        self.values = values
+
+    @property
+    def values(self) -> List[Union[int, float, str, bool]]:
+        return self._values
+
+    @values.setter
+    def values(self, new_values: List[Union[int, float, str, bool]]) -> None:
+        for value in new_values:
+            if self.data_type and not self.data_type.check(value):
+                raise InputValidationException(
+                    code="0-1-2-7",
+                    value=value,
+                    type_=self.data_type.__name__,
+                    op_type=self.__class__.__name__,
+                    name="",
+                )
+        self._values = new_values
 
     def __contains__(self, item: str) -> Optional[bool]:
         if isinstance(item, float) and item.is_integer():

vtlengine/Operators/Aggregation.py

@@ -72,7 +72,7 @@ class Aggregation(Operator.Unary):
                         new_value = ["9999-99-99"]
                     else:
                         to_replace = ["9999-99-99"]
-                data[measure.name] = data[measure.name].replace(to_replace, new_value)
+                data[measure.name] = data[measure.name].replace(to_replace, new_value)  # type: ignore[arg-type, unused-ignore]
             elif measure.data_type == TimePeriod:
                 if mode == "input":
                     data[measure.name] = (
@@ -80,6 +80,10 @@ class Aggregation(Operator.Unary):
                         .astype(object)
                         .map(lambda x: TimePeriodHandler(str(x)), na_action="ignore")
                     )
+                    if cls.op in [MAX, MIN]:
+                        indicators = {v.period_indicator for v in data[measure.name].dropna()}
+                        if len(indicators) > 1:
+                            raise SemanticError("2-1-19-20", op=cls.op)
                 else:
                     data[measure.name] = data[measure.name].map(
                         lambda x: str(x), na_action="ignore"
@@ -99,7 +103,7 @@ class Aggregation(Operator.Unary):
                         lambda x: str(x), na_action="ignore"
                     )
             elif measure.data_type == String:
-                data[measure.name] = data[measure.name].replace(to_replace, new_value)
+                data[measure.name] = data[measure.name].replace(to_replace, new_value)  # type: ignore[arg-type, unused-ignore]
             elif measure.data_type == Duration:
                 if mode == "input":
                     data[measure.name] = data[measure.name].map(

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]

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/__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.2"
+__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()

{vtlengine-1.2.2.dist-info → vtlengine-1.3.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtlengine
-Version: 1.2.2
+Version: 1.3.0rc1
 Summary: Run and Validate VTL Scripts
 License-Expression: AGPL-3.0
 License-File: LICENSE.md
@@ -17,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)

{vtlengine-1.2.2.dist-info → vtlengine-1.3.0rc1.dist-info}/RECORD

@@ -1,6 +1,8 @@
-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
@@ -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=zTrSDHd3AFaHvvqdPYT8ZthqN2anHfI9Ul1QomA4rNo,11708
-vtlengine/DataTypes/TimeHandling.py,sha256=K8769_b3Q4kPXGC2XVQ4oN7VsGnhxmJtgdhC_ryXjho,20250
-vtlengine/DataTypes/__init__.py,sha256=LYXrde68bYm7MLeMLmr4haeOTSE4Fnpq9G2Ewy7DiaU,23084
+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=V68Al8_TGvb_kY9PHEtSRp26rF_PjhjHdDMRtB-IuTI,20113
+vtlengine/Exceptions/messages.py,sha256=DMeQt9cNE1hutDo0BAq0KoVLhnPWJS9suDud51C68QU,20544
 vtlengine/Interpreter/__init__.py,sha256=6Ffl5bJRL1KSF335xSxfA8a5y_pV8ZNQUYM9BmYN6hg,87256
-vtlengine/Model/__init__.py,sha256=xWrwhdUOj8Y-5x38zP5XnmFPw8IkBVBBG2bPsUBGLA8,15869
-vtlengine/Operators/Aggregation.py,sha256=K9u0PE77ZAqEwKTCRyRx9G9uvpyVVZQBB_E4648B4V8,12158
+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=Py4QwCgCi4t4-FG75-RMe7M5sDRgUZlRGyuFt4RwwJ4,21182
-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
@@ -45,19 +48,18 @@ vtlengine/Operators/Set.py,sha256=f1uLeY4XZF0cWEwpXRB_CczgbXr6s33DYPuFt39HlEg,70
 vtlengine/Operators/String.py,sha256=ghWtYl6oUEAAzynY1a9Hg4yqRA9Sa7uk2B6iF9uuSqQ,20230
 vtlengine/Operators/Time.py,sha256=ESn6ldPg73bdZxOXZYJuIwCLDQnXDGTqR1y7ckQmV1M,43025
 vtlengine/Operators/Validation.py,sha256=ot-og75Ce690DddQM-xILrY3PoRf8Z0M3aIovFK-wMY,11245
-vtlengine/Operators/__init__.py,sha256=N1zi9RFC_l0qggRm5IPLOkPFtFS4CGAg-r1taHOrbTI,37667
+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=2ylv7tLHXE_OKN9-zlvcdqenn_WPaMklmkjAt-EJ16A,188
+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=WdvToMTIeWgkkuUWSDvtACQlguEZN3plz5LPvyCvdt0,9030
+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=-MsfAJdIHpVwPulaiklxvyPfWAVocwvf43WSqgusryc,4849
 vtlengine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-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.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,,