vtlengine 1.0.4__py3-none-any.whl → 1.1__py3-none-any.whl

vtlengine/Model/__init__.py

@@ -1,3 +1,4 @@
+import inspect
 import json
 from collections import Counter
 from dataclasses import dataclass
@@ -128,10 +129,14 @@ class Component:
         )
 
     def to_dict(self) -> Dict[str, Any]:
+        data_type = self.data_type
+        if not inspect.isclass(self.data_type):
+            data_type = self.data_type.__class__  # type: ignore[assignment]
         return {
             "name": self.name,
-            "data_type": DataTypes.SCALAR_TYPES_CLASS_REVERSE[self.data_type],
-            "role": self.role.value,
+            "data_type": DataTypes.SCALAR_TYPES_CLASS_REVERSE[data_type],
+            # Need to check here for NoneType as UDO argument has it
+            "role": self.role.value if self.role is not None else None,  # type: ignore[redundant-expr]
             "nullable": self.nullable,
         }
 
@@ -229,11 +234,11 @@ class Dataset:
                 self.data[comp.name] = self.data[comp.name].astype(str)
                 other.data[comp.name] = other.data[comp.name].astype(str)
                 self.data[comp.name] = self.data[comp.name].map(
-                    lambda x: str(TimePeriodHandler(x)) if x != "" else "",
+                    lambda x: str(TimePeriodHandler(str(x))) if x != "" else "",
                     na_action="ignore",
                 )
                 other.data[comp.name] = other.data[comp.name].map(
-                    lambda x: str(TimePeriodHandler(x)) if x != "" else "",
+                    lambda x: str(TimePeriodHandler(str(x))) if x != "" else "",
                     na_action="ignore",
                 )
             elif type_name in ["Integer", "Number"]:

vtlengine/Operators/Aggregation.py

@@ -78,7 +78,7 @@ class Aggregation(Operator.Unary):
                     data[measure.name] = (
                         data[measure.name]
                         .astype(object)
-                        .map(lambda x: TimePeriodHandler(x), na_action="ignore")
+                        .map(lambda x: TimePeriodHandler(str(x)), na_action="ignore")
                     )
                 else:
                     data[measure.name] = data[measure.name].map(
@@ -90,7 +90,7 @@ class Aggregation(Operator.Unary):
                         data[measure.name]
                         .astype(object)
                         .map(
-                            lambda x: TimeIntervalHandler.from_iso_format(x),
+                            lambda x: TimeIntervalHandler.from_iso_format(str(x)),
                             na_action="ignore",
                         )
                     )
@@ -103,11 +103,13 @@ class Aggregation(Operator.Unary):
             elif measure.data_type == Duration:
                 if mode == "input":
                     data[measure.name] = data[measure.name].map(
-                        lambda x: PERIOD_IND_MAPPING[x], na_action="ignore"
+                        lambda x: PERIOD_IND_MAPPING[x],  # type: ignore[index]
+                        na_action="ignore",
                     )
                 else:
                     data[measure.name] = data[measure.name].map(
-                        lambda x: PERIOD_IND_MAPPING_REVERSE[x], na_action="ignore"
+                        lambda x: PERIOD_IND_MAPPING_REVERSE[x],  # type: ignore[index]
+                        na_action="ignore",
                     )
             elif measure.data_type == Boolean:
                 if mode == "result":
@@ -208,7 +210,7 @@ class Aggregation(Operator.Unary):
                 e = f'"{e}"'
                 if cls.type_to_check is not None and cls.op != COUNT:
                     functions += (
-                        f"{cls.py_op}(CAST({e} AS REAL)) AS {e}, "  # Count can only be one here
+                        f"{cls.py_op}(CAST({e} AS DOUBLE)) AS {e}, "  # Count can only be one here
                     )
                 elif cls.op == COUNT:
                     functions += f"{cls.py_op}({e}) AS int_var, "

vtlengine/Operators/Analytic.py

@@ -189,21 +189,26 @@ class Analytic(Operator.Unary):
         if window is not None:
             mode = "ROWS" if window.type_ == "data" else "RANGE"
             start_mode = (
-                window.start_mode
-                if window.start_mode != "current" and window.start != "CURRENT ROW"
+                window.start_mode.upper()
+                if (isinstance(window.start, int) and window.start != 0)
+                or (isinstance(window.start, str) and window.start == "unbounded")
                 else ""
             )
             stop_mode = (
-                window.stop_mode
-                if window.stop_mode != "current" and window.stop != "CURRENT ROW"
+                window.stop_mode.upper()
+                if (isinstance(window.stop, int) and window.stop != 0)
+                or (isinstance(window.stop, str) and window.stop == "unbounded")
                 else ""
             )
-            if isinstance(window.start, int) and window.start == -1:
-                window.start = "UNBOUNDED"
-
-            if stop_mode == "" and window.stop == 0:
-                window.stop = "CURRENT ROW"
-            window_str = f"{mode} BETWEEN {window.start} {start_mode} AND {window.stop} {stop_mode}"
+            start = (
+                "UNBOUNDED"
+                if window.start == "unbounded" or window.start == -1
+                else str(window.start)
+            )
+            stop = (
+                "CURRENT ROW" if window.stop == "current" or window.stop == 0 else str(window.stop)
+            )
+            window_str = f"{mode} BETWEEN {start} {start_mode} AND {stop} {stop_mode}"
 
         # Partitioning
         partition = "PARTITION BY " + ", ".join(partitioning) if len(partitioning) > 0 else ""
@@ -224,7 +229,7 @@ class Analytic(Operator.Unary):
             if cls.op == RANK:
                 measure_query = f"{cls.sql_op}()"
             elif cls.op == RATIO_TO_REPORT:
-                measure_query = f"CAST({measure} AS REAL) / SUM(CAST({measure} AS REAL))"
+                measure_query = f"CAST({measure} AS DOUBLE) / SUM(CAST({measure} AS DOUBLE))"
             elif cls.op in [LAG, LEAD]:
                 measure_query = f"{cls.sql_op}({measure}, {','.join(map(str, params or []))})"
             else:

vtlengine/Operators/Conditional.py

@@ -238,7 +238,7 @@ class Nvl(Binary):
         result = cls.validate(left, right)
 
         if isinstance(left, Scalar) and isinstance(result, Scalar):
-            if pd.isnull(left):  # type: ignore[call-overload]
+            if left.data_type is Null:
                 result.value = right.value
             else:
                 result.value = left.value
@@ -308,8 +308,23 @@ class Case(Operator):
     ) -> Union[Scalar, DataComponent, Dataset]:
         result = cls.validate(conditions, thenOps, elseOp)
         for condition in conditions:
-            if isinstance(condition, (DataComponent, Dataset)) and condition.data is not None:
+            if isinstance(condition, Dataset) and condition.data is not None:
                 condition.data.fillna(False, inplace=True)
+                condition_measure = condition.get_measures_names()[0]
+                if condition.data[condition_measure].dtype != bool:
+                    condition.data[condition_measure] = condition.data[condition_measure].astype(
+                        bool
+                    )
+            elif (
+                isinstance(
+                    condition,
+                    DataComponent,
+                )
+                and condition.data is not None
+            ):
+                condition.data.fillna(False, inplace=True)
+                if condition.data.dtype != bool:
+                    condition.data = condition.data.astype(bool)
             elif isinstance(condition, Scalar) and condition.value is None:
                 condition.value = False
 
@@ -366,7 +381,7 @@ class Case(Operator):
                 ]
             )
 
-            result.data.loc[condition_mask_else, columns] = (
+            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]

vtlengine/Operators/Time.py

@@ -57,14 +57,17 @@ class Time(Operators.Operator):
     op = FLOW_TO_STOCK
 
     @classmethod
-    def _get_time_id(cls, operand: Dataset) -> Optional[str]:
+    def _get_time_id(cls, operand: Dataset) -> str:
         reference_id = None
+        identifiers = operand.get_identifiers()
+        if len(identifiers) == 0:
+            raise SemanticError("1-1-19-8", op=cls.op, comp_type="time dataset")
         for id in operand.get_identifiers():
             if id.data_type in cls.TIME_DATA_TYPES:
                 if reference_id is not None:
                     raise SemanticError("1-1-19-8", op=cls.op, comp_type="time dataset")
                 reference_id = id.name
-        return reference_id
+        return str(reference_id)
 
     @classmethod
     def sort_by_time(cls, operand: Dataset) -> Optional[pd.DataFrame]:
@@ -182,7 +185,7 @@ class Period_indicator(Unary):
     def validate(cls, operand: Any) -> Any:
         if isinstance(operand, Dataset):
             time_id = cls._get_time_id(operand)
-            if time_id is None or operand.components[time_id].data_type != TimePeriod:
+            if operand.components[time_id].data_type != TimePeriod:
                 raise SemanticError("1-1-19-8", op=cls.op, comp_type="time period dataset")
             result_components = {
                 comp.name: comp
@@ -223,7 +226,7 @@ class Period_indicator(Unary):
             if (operand.data is not None)
             else pd.Series()
         )
-        period_series: Any = result.data[cls.time_id].map(cls._get_period)  # type: ignore[index]
+        period_series: Any = result.data[cls.time_id].map(cls._get_period)
         result.data["duration_var"] = period_series
         return result
 
@@ -544,9 +547,7 @@ class Time_Shift(Binary):
         shift_value = int(shift_value.value)
         cls.time_id = cls._get_time_id(result)
 
-        data_type: Any = (
-            result.components[cls.time_id].data_type if isinstance(cls.time_id, str) else None
-        )
+        data_type: Any = result.components[cls.time_id].data_type
 
         if data_type == Date:
             freq = cls.find_min_frequency(
@@ -966,7 +967,7 @@ class Date_Add(Parametrized):
             for measure in operand.get_measures():
                 if measure.data_type in [Date, TimePeriod]:
                     result.data[measure.name] = result.data[measure.name].map(
-                        lambda x: cls.py_op(x, shift, period, measure.data_type == TimePeriod),
+                        lambda x: cls.py_op(str(x), shift, period, measure.data_type == TimePeriod),
                         na_action="ignore",
                     )
                     measure.data_type = Date

vtlengine/Utils/__init__.py

@@ -1,5 +1,7 @@
 from typing import Any, Dict
 
+from pysdmx.model.dataflow import Role
+
 from vtlengine.AST.Grammar.tokens import (
     ABS,
     AGGREGATE,
@@ -428,3 +430,50 @@ HA_UNARY_MAPPING = {
     PLUS: HRUnPlus,
     MINUS: HRUnMinus,
 }
+VTL_DTYPES_MAPPING = {
+    "String": "String",
+    "Alpha": "String",
+    "AlphaNumeric": "String",
+    "Numeric": "String",
+    "BigInteger": "Integer",
+    "Integer": "Integer",
+    "Long": "Integer",
+    "Short": "Integer",
+    "Decimal": "Number",
+    "Float": "Number",
+    "Double": "Number",
+    "Boolean": "Boolean",
+    "URI": "String",
+    "Count": "Integer",
+    "InclusiveValueRange": "Number",
+    "ExclusiveValueRange": "Number",
+    "Incremental": "Number",
+    "ObservationalTimePeriod": "Time_Period",
+    "StandardTimePeriod": "Time_Period",
+    "BasicTimePeriod": "Date",
+    "GregorianTimePeriod": "Date",
+    "GregorianYear": "Date",
+    "GregorianYearMonth": "Date",
+    "GregorianMonth": "Date",
+    "GregorianDay": "Date",
+    "ReportingTimePeriod": "Time_Period",
+    "ReportingYear": "Time_Period",
+    "ReportingSemester": "Time_Period",
+    "ReportingTrimester": "Time_Period",
+    "ReportingQuarter": "Time_Period",
+    "ReportingMonth": "Time_Period",
+    "ReportingWeek": "Time_Period",
+    "ReportingDay": "Time_Period",
+    "DateTime": "Date",
+    "TimeRange": "Time",
+    "Month": "String",
+    "MonthDay": "String",
+    "Day": "String",
+    "Time": "String",
+    "Duration": "Duration",
+}
+VTL_ROLE_MAPPING = {
+    Role.DIMENSION: "Identifier",
+    Role.MEASURE: "Measure",
+    Role.ATTRIBUTE: "Attribute",
+}

vtlengine/__extras_check.py

@@ -0,0 +1,17 @@
+import importlib.util
+
+EXTRAS_DOCS = "https://docs.vtlengine.meaningfuldata.eu/#installation"
+ERROR_MESSAGE = (
+    "The '{extra_name}' extra is required to run {extra_desc}. "
+    "Please install it using 'pip install vtlengine[{extra_name}]' or "
+    "install all extras with 'pip install vtlengine[all]'. "
+    f"Check the documentation at: {EXTRAS_DOCS}"
+)
+
+
+def __check_s3_extra() -> None:
+    package_loc = importlib.util.find_spec("s3fs")
+    if package_loc is None:
+        raise ImportError(
+            ERROR_MESSAGE.format(extra_name="s3", extra_desc="over csv files using S3 URIs")
+        ) from None

vtlengine/__init__.py

@@ -1,3 +1,3 @@
-from vtlengine.API import run, semantic_analysis
+from vtlengine.API import generate_sdmx, prettify, run, run_sdmx, semantic_analysis
 
-__all__ = ["semantic_analysis", "run"]
+__all__ = ["semantic_analysis", "run", "generate_sdmx", "run_sdmx", "prettify"]

vtlengine/files/output/__init__.py

@@ -3,6 +3,7 @@ from typing import Optional, Union
 
 import pandas as pd
 
+from vtlengine.__extras_check import __check_s3_extra
 from vtlengine.files.output._time_period_representation import (
     TimePeriodRepresentation,
     format_time_period_external_representation,
@@ -20,6 +21,7 @@ def save_datapoints(
     if time_period_representation is not None:
         format_time_period_external_representation(dataset, time_period_representation)
     if isinstance(output_path, str):
+        __check_s3_extra()
         if output_path.endswith("/"):
             s3_file_output = output_path + f"{dataset.name}.csv"
         else:

vtlengine/files/parser/__init__.py

@@ -42,14 +42,9 @@ def _validate_csv_path(components: Dict[str, Component], csv_path: Path) -> None
         raise Exception(f"Path {csv_path} is not a file.")
     register_rfc()
     try:
-        with open(csv_path, "r") as f:
+        with open(csv_path, "r", errors="replace", encoding="utf-8") as f:
             reader = DictReader(f, dialect="rfc")
             csv_columns = reader.fieldnames
-
-    except UnicodeDecodeError as error:
-        # https://coderwall.com/p/stzy9w/raising-unicodeencodeerror-and-unicodedecodeerror-
-        # manually-for-testing-purposes
-        raise InputValidationException("0-1-2-5", file=csv_path.name) from error
     except InputValidationException as ie:
         raise InputValidationException("{}".format(str(ie))) from None
     except Exception as e:
@@ -109,40 +104,18 @@ def _sanitize_pandas_columns(
     return data
 
 
-def _pandas_load_csv(components: Dict[str, Component], csv_path: Path) -> pd.DataFrame:
-    obj_dtypes = {comp_name: np.object_ for comp_name, comp in components.items()}
-
-    try:
-        data = pd.read_csv(
-            csv_path,
-            dtype=obj_dtypes,
-            engine="c",
-            keep_default_na=False,
-            na_values=[""],
-        )
-    except UnicodeDecodeError:
-        raise InputValidationException(code="0-1-2-5", file=csv_path.name)
-
-    return _sanitize_pandas_columns(components, csv_path, data)
+def _pandas_load_csv(components: Dict[str, Component], csv_path: Union[str, Path]) -> pd.DataFrame:
+    obj_dtypes = {comp_name: object for comp_name, comp in components.items()}
 
+    data = pd.read_csv(
+        csv_path,
+        dtype=obj_dtypes,
+        engine="c",
+        keep_default_na=False,
+        na_values=[""],
+        encoding_errors="replace",
+    )
 
-def _pandas_load_s3_csv(components: Dict[str, Component], csv_path: str) -> pd.DataFrame:
-    obj_dtypes = {comp_name: np.object_ for comp_name, comp in components.items()}
-
-    # start = time()
-    try:
-        data = pd.read_csv(
-            csv_path,
-            dtype=obj_dtypes,
-            engine="c",
-            keep_default_na=False,
-            na_values=[""],
-        )
-
-    except UnicodeDecodeError:
-        raise InputValidationException(code="0-1-2-5", file=csv_path)
-    except Exception as e:
-        raise InputValidationException(f"ERROR: {str(e)}, review file {str(csv_path)}")
     return _sanitize_pandas_columns(components, csv_path, data)
 
 
@@ -187,13 +160,13 @@ def _validate_pandas(
                 )
             elif comp.data_type == Integer:
                 data[comp_name] = data[comp_name].map(
-                    lambda x: Integer.cast(float(x)), na_action="ignore"
+                    lambda x: Integer.cast(float(str(x))), na_action="ignore"
                 )
             elif comp.data_type == Number:
-                data[comp_name] = data[comp_name].map(lambda x: float(x), na_action="ignore")
+                data[comp_name] = data[comp_name].map(lambda x: float((str(x))), na_action="ignore")
             elif comp.data_type == Boolean:
                 data[comp_name] = data[comp_name].map(
-                    lambda x: _parse_boolean(x), na_action="ignore"
+                    lambda x: _parse_boolean(str(x)), na_action="ignore"
                 )
             elif comp.data_type == Duration:
                 values_correct = (
@@ -209,7 +182,7 @@ def _validate_pandas(
                         values_correct = (
                             data[comp_name]
                             .map(
-                                lambda x: x.replace(" ", "") in PERIOD_IND_MAPPING,
+                                lambda x: x.replace(" ", "") in PERIOD_IND_MAPPING,  # type: ignore[union-attr]
                                 na_action="ignore",
                             )
                             .all()
@@ -224,7 +197,7 @@ def _validate_pandas(
                 data[comp_name] = data[comp_name].map(
                     lambda x: str(x).replace('"', ""), na_action="ignore"
                 )
-            data[comp_name] = data[comp_name].astype(np.object_, errors="raise")
+            data[comp_name] = data[comp_name].astype(object, errors="raise")
 
     except ValueError:
         str_comp = SCALAR_TYPES_CLASS_REVERSE[comp.data_type] if comp else "Null"
@@ -240,10 +213,9 @@ def load_datapoints(
 ) -> pd.DataFrame:
     if csv_path is None or (isinstance(csv_path, Path) and not csv_path.exists()):
         return pd.DataFrame(columns=list(components.keys()))
-    elif isinstance(csv_path, str):
-        data = _pandas_load_s3_csv(components, csv_path)
-    elif isinstance(csv_path, Path):
-        _validate_csv_path(components, csv_path)
+    elif isinstance(csv_path, (str, Path)):
+        if isinstance(csv_path, Path):
+            _validate_csv_path(components, csv_path)
         data = _pandas_load_csv(components, csv_path)
     else:
         raise Exception("Invalid csv_path type")

vtlengine/files/parser/_rfc_dialect.py

@@ -19,4 +19,4 @@ class RFCDialect(csv.Dialect):
 
 def register_rfc() -> None:
     """Register the RFC dialect."""
-    csv.register_dialect("rfc", RFCDialect)  # type: ignore[arg-type]
+    csv.register_dialect("rfc", RFCDialect)

{vtlengine-1.0.4.dist-info → vtlengine-1.1.dist-info}/METADATA

@@ -1,32 +1,35 @@
 Metadata-Version: 2.3
 Name: vtlengine
-Version: 1.0.4
+Version: 1.1
 Summary: Run and Validate VTL Scripts
 License: AGPL-3.0
 Keywords: vtl,sdmx,vtlengine,Validation and Transformation Language
 Author: MeaningfulData
 Author-email: info@meaningfuldata.eu
-Requires-Python: >=3.9,<4.0
+Maintainer: Francisco Javier Hernandez del Caño
+Maintainer-email: javier.hernandez@meaningfuldata.eu
+Requires-Python: >=3.9
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: GNU Affero General Public License v3
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-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: duckdb (>=1.1,<2.0)
-Requires-Dist: jsonschema (>=4.23.0,<5.0.0)
-Requires-Dist: networkx (>=2.8.8,<3.0.0)
-Requires-Dist: numexpr (>=2.9.0,<3.0.0)
-Requires-Dist: pandas (>=2.1.4,<3.0.0)
-Requires-Dist: s3fs (>=2025.2.0,<2026.0.0)
-Requires-Dist: sqlglot (>=22.2.0,<23.0.0)
+Provides-Extra: all
+Provides-Extra: s3
+Requires-Dist: antlr4-python3-runtime (>=4.9.2,<4.10)
+Requires-Dist: duckdb (>=1.1,<1.2)
+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)
+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,<2.2) ; python_version < "3.13"
+Requires-Dist: pandas (>=2.2,<3.0) ; python_version >= "3.13"
+Requires-Dist: pysdmx[xml] (>=1.3.0,<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)
 Project-URL: Authors, https://github.com/Meaningful-Data/vtlengine/graphs/contributors
 Project-URL: Documentation, https://docs.vtlengine.meaningfuldata.eu
 Project-URL: IssueTracker, https://github.com/Meaningful-Data/vtlengine/issues

{vtlengine-1.0.4.dist-info → vtlengine-1.1.dist-info}/RECORD

@@ -1,16 +1,18 @@
-vtlengine/API/_InternalApi.py,sha256=E3WbH-AfFAp0Dgk7TAx6T5FZb0EzHgVEwtVxTjcfTlA,16058
-vtlengine/API/__init__.py,sha256=2IDUvvSJdbkL5It8JulhmPCgkEnNbw52_VbbWm_aRp0,11061
+vtlengine/API/_InternalApi.py,sha256=uSPW-Lny_zSVrhHfkz6FbBEaxQXNySTGPI2LF8wKTHY,22761
+vtlengine/API/__init__.py,sha256=IiJZWSlHpUWq73Qv1_V-Tirim-ZnpF3xexFtW1Psyx8,17866
 vtlengine/API/data/schema/json_schema_2.1.json,sha256=v3-C0Xnq8qScJSPAtLgb3rjKMrd3nz-bIxgZdTSEUiU,4336
-vtlengine/AST/ASTConstructor.py,sha256=DdE0B6CyPt1RYb3he6L0tL-KhZ1UyHRxQisGC1GuKx8,19692
-vtlengine/AST/ASTConstructorModules/Expr.py,sha256=C4-toJm3bDt53_YSooeCJiqyUhK1ykgpiQTZjyZYsLE,65344
-vtlengine/AST/ASTConstructorModules/ExprComponents.py,sha256=6zUFY5a9KxzdOoSvC8TMyziYmfVW2bMbwYBI9r779Yg,36461
-vtlengine/AST/ASTConstructorModules/Terminals.py,sha256=141hfXUm5Xh53KD_W5VK5LwRMf8FYWLZ0PFR4Io2Dyo,25272
-vtlengine/AST/ASTConstructorModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vtlengine/AST/ASTComment.py,sha256=bAJW7aaqBXU2LqMtRvL_XOttdl1AFZufa15vmQdvNlY,1667
+vtlengine/AST/ASTConstructor.py,sha256=X55I98BKG1ItyGIDObF9ALVfCcWnU-0wwCWJsiPILkg,21488
+vtlengine/AST/ASTConstructorModules/Expr.py,sha256=aCL3uuQF0BJIels6rTckL8FAAykzImYb3AESs7umFcY,70066
+vtlengine/AST/ASTConstructorModules/ExprComponents.py,sha256=2Ft4e5w2NtbfaqSNW8I9qSpG9iUaPIfdug7yYWo2gqE,38553
+vtlengine/AST/ASTConstructorModules/Terminals.py,sha256=7zWDx_SFcbnL35G7Y0qZwl-lLEsfqReyzBX0UxwTCOk,27054
+vtlengine/AST/ASTConstructorModules/__init__.py,sha256=J6g6NhJD8j0Ek1YmpethxRiFdjhLxUTM0mc3NHRFLlM,1879
 vtlengine/AST/ASTDataExchange.py,sha256=kPSz21DGbEv-2bZowObseqf2d2_iQj1VnrqWuD9ZwtA,140
-vtlengine/AST/ASTEncoders.py,sha256=HZfG-Oo2u2l16tloEsHLAyNoLbkBC30X3H7drLq44rA,773
-vtlengine/AST/ASTTemplate.py,sha256=3dd9fkWNJywDn279tUuZGcOCPbyMiGiqnBwqAB1FWrU,12357
+vtlengine/AST/ASTEncoders.py,sha256=-Ar6a0GqMdJZK4CtZ1pUpIeGv57oSdN5qy3-aF0Zt9c,948
+vtlengine/AST/ASTString.py,sha256=y_xWVm2OHgsFs9As1-0PjEnmftjaoRsZJHZNtsFcKXc,25297
+vtlengine/AST/ASTTemplate.py,sha256=qUkz0AE1ay3gFrCidzhJAqxRnZR8nj98DOKAW2rXoso,12961
 vtlengine/AST/ASTVisitor.py,sha256=3QQTudBpbR4pPQdH7y07EgwuzhoGzNQ59qox8R-E3fM,500
-vtlengine/AST/DAG/__init__.py,sha256=DyFF3ZQW3f8RvtQ3X1I52BGk3CY8j51fCE5eEEwx6Dc,14618
+vtlengine/AST/DAG/__init__.py,sha256=ViL1vfLOCU28Yx8cOMt8aIvguSrzYYTb9qPhAwoExwY,15074
 vtlengine/AST/DAG/_words.py,sha256=lEuBQ_w-KoKGna-x3gFGfbX1KP4Ez5EgdomH2LOeodk,170
 vtlengine/AST/Grammar/Vtl.g4,sha256=86bBWjQLCHZSuB5iLIk0JZRgMyMg0n7xbU8qzot2cIE,26313
 vtlengine/AST/Grammar/VtlTokens.g4,sha256=SwDR_59U25APqslczFcvTUiPoH7bC6kGaH2GkJ3kYzA,9972
@@ -19,21 +21,21 @@ vtlengine/AST/Grammar/lexer.py,sha256=ncoPevKkUpGyYx5mVKcKjocVhFoKSdu-5NSQDPY2V3
 vtlengine/AST/Grammar/parser.py,sha256=ISi5OWmPbLitMp-8fg-wa1-475TfKZWK98jXjyOLi-8,634355
 vtlengine/AST/Grammar/tokens.py,sha256=YF7tO0nF2zYC-VaBAJLyc6VitM72CvYfFQpoPDGCMzo,3139
 vtlengine/AST/VtlVisitor.py,sha256=NJfXJVP6wNmasJmPLlojFqm9R5VSamOAKg_w7BMrhac,35332
-vtlengine/AST/__init__.py,sha256=_-NLJ-GCX5mMmAUGPnY3NzErnFEgjg8LdoGfpdRQjrU,9809
+vtlengine/AST/__init__.py,sha256=JnPilognG2rT2gtpjD4OwKFX0O3ZqvV-ic8gJxRu7Xo,11672
 vtlengine/DataTypes/TimeHandling.py,sha256=CYnC0sb1qbRjTnCSsA3wgez7QftOzrXHxbuZXlY3O3Q,20151
 vtlengine/DataTypes/__init__.py,sha256=LYXrde68bYm7MLeMLmr4haeOTSE4Fnpq9G2Ewy7DiaU,23084
 vtlengine/Exceptions/__init__.py,sha256=rSSskV_qCBFzg_W67Q1QBAL7Lnq88D7yi2BDYo1hytw,4727
-vtlengine/Exceptions/messages.py,sha256=Flczp7SrsLfMHjXaSPhM3mx9ScsWiUvEvcdKR53teeA,18811
-vtlengine/Interpreter/__init__.py,sha256=MBI5ApmgHljAjmdSkFi-2II_ELGQ4xWNkYI2dPMzaSg,81375
-vtlengine/Model/__init__.py,sha256=DOxJA_MlFVq2s0Yqx8S4TwXulMP8v3MpIh1CgW19vYg,15553
-vtlengine/Operators/Aggregation.py,sha256=yS8_ZwMbQuIt-FJ_O_KQp-dYxF5bj2CktERuaGoMuAY,11798
-vtlengine/Operators/Analytic.py,sha256=x-koqCS4z6BeD89Q2fDzU-LnQyTuynp_aayFbvmXkpQ,12573
+vtlengine/Exceptions/messages.py,sha256=9Tzkm-Q4ZI7UFFmWfsiy2xI7hFKMrnPB-EmUfVgxuBo,19428
+vtlengine/Interpreter/__init__.py,sha256=yFXLi3Mr7EnOmdynf-BvFwDHOBsWVjRXSkNgdmhfJVc,83533
+vtlengine/Model/__init__.py,sha256=xWrwhdUOj8Y-5x38zP5XnmFPw8IkBVBBG2bPsUBGLA8,15869
+vtlengine/Operators/Aggregation.py,sha256=43bqjaMqGG9zzFkcs6JLfShb1ISupmyQnXOQQ-HQo9E,11906
+vtlengine/Operators/Analytic.py,sha256=GiVNwa02JNRaVcHEkqKlat9WSIgQ32OhpgOdYc9PlJo,12818
 vtlengine/Operators/Assignment.py,sha256=xyJgGPoFYbq6mzX06gz7Q7L8jXJxpUkgzdY3Lrne2hw,793
 vtlengine/Operators/Boolean.py,sha256=3U5lHkxW5d7QQdGDNxXeXqejlPfFrXKG8_TqknrC8Ls,2856
 vtlengine/Operators/CastOperator.py,sha256=mvWfNhJ1pEEk_ZQp-3unLoYJvJShUjUu_BOYQ6ByySI,16951
 vtlengine/Operators/Clause.py,sha256=_Sdt3qQUpphNRs4IQW5pSj9kagzwLluV9BRHMGNxqsI,15022
 vtlengine/Operators/Comparison.py,sha256=7G2UK1BDCDJR4jTXa-txJlAJEvzXEeYaDSA_2oxjgKY,17286
-vtlengine/Operators/Conditional.py,sha256=kjFQ90DS3lVIeYdsDlhxne_dOCtzTdvnWY8AOnR7ceM,19294
+vtlengine/Operators/Conditional.py,sha256=nxatC0tr8UvsOVcCMcBjK_U6hzjbd2uf3VG3YiCMUOo,19944
 vtlengine/Operators/General.py,sha256=q1fpqP4IYEwURXi8Eo-_j5AUktK0dvNosL9SgSe7a8w,6711
 vtlengine/Operators/HROperators.py,sha256=VVp5FcdbDXhU_VCfUA6t75bs51qx9fKJT4n15WM2vyM,8866
 vtlengine/Operators/Join.py,sha256=df2XG2tKmha_WUhHEYhgZIVc_2L8Wr45o0ISm-HOReA,18108
@@ -41,18 +43,19 @@ vtlengine/Operators/Numeric.py,sha256=icYTWzEsw6VQFLYc5Wucgr8961d8ZwTFx_wfZ8Wp9C
 vtlengine/Operators/RoleSetter.py,sha256=mHZIdcHC3wflj81ekLbioDG1f8yHZXYDQFymV-KnyXA,2274
 vtlengine/Operators/Set.py,sha256=f1uLeY4XZF0cWEwpXRB_CczgbXr6s33DYPuFt39HlEg,7084
 vtlengine/Operators/String.py,sha256=ghWtYl6oUEAAzynY1a9Hg4yqRA9Sa7uk2B6iF9uuSqQ,20230
-vtlengine/Operators/Time.py,sha256=9f2kQ6iAoA4YPvlfphJ_uQjM-ZuqjSnOs312ttWMhgg,42679
+vtlengine/Operators/Time.py,sha256=tpBZkuDldlcVnNWUNvrc8yhnG1knalZVFklGppbzw4k,42734
 vtlengine/Operators/Validation.py,sha256=ev3HyU7e1XbeAtUQ1y6zY3fzBwMqetDPhG3NNveAGOE,9988
 vtlengine/Operators/__init__.py,sha256=GN5eaAwmzfYKD7JJRIaRqdIJzflGc3UMvrOC9mlYNVo,37227
-vtlengine/Utils/__init__.py,sha256=ZobqGLc4rpMrsmniexTD4J-VokQt3qLrBGdFEDHHT1M,7571
-vtlengine/__init__.py,sha256=L9tGzRGQ8HMDS23sVWIbBvj41sXR89pf0ZMzEidIEMM,89
+vtlengine/Utils/__init__.py,sha256=zhGPJA8MjHmtEEwMS4CxEFYL0tk2L5F0YPn7bitdRzM,8954
+vtlengine/__extras_check.py,sha256=Wr-lxGZhXJZEacVV5cUkvKt7XM-mry0kYAe3VxNrVcY,614
+vtlengine/__init__.py,sha256=E31A6eDHTZsPNI5Cq-zv9-O87D5n8du-oZtVB6u3dVk,165
 vtlengine/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vtlengine/files/output/__init__.py,sha256=W0P5E4Gnikp2cVIVtxPZ4BQazfUW7MTlMNjq7ltg5I8,1169
+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=5emul7mwgAEq3A4_y6gyIl-PxoUV_oMxEtKlmkzNux4,9621
-vtlengine/files/parser/_rfc_dialect.py,sha256=0T8GshGA5z9ZgYStH7zz2ZwtdiGkj7B8jXcxsPkXfjs,488
+vtlengine/files/parser/__init__.py,sha256=JamEIWI0pFZxT0sKYE6Fii8H2JQcsFn4Nf3T0OLSm9g,8637
+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-1.0.4.dist-info/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
-vtlengine-1.0.4.dist-info/METADATA,sha256=6Mbusz1Tl8IKHID-GiuA0NEDg2uMu1ZXNf_X1lzhbHo,8816
-vtlengine-1.0.4.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-vtlengine-1.0.4.dist-info/RECORD,,
+vtlengine-1.1.dist-info/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
+vtlengine-1.1.dist-info/METADATA,sha256=0F0SO41WyyQfA4zhfkYmIaM0-6eSlShGKoDE7i2uebI,8971
+vtlengine-1.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+vtlengine-1.1.dist-info/RECORD,,

{vtlengine-1.0.4.dist-info → vtlengine-1.1.dist-info}/WHEEL

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