vtlengine 1.1rc1__py3-none-any.whl → 1.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
 
@@ -324,9 +339,9 @@ class Case(Operator):
 
             for i, condition in enumerate(conditions):
                 value = thenOps[i].value if isinstance(thenOps[i], Scalar) else thenOps[i].data
-                result.data = np.where(  # type: ignore[call-overload]
+                result.data = np.where(
                     condition.data.notna(),
-                    np.where(condition.data, value, result.data),  # type: ignore[call-overload]
+                    np.where(condition.data, value, result.data),
                     result.data,
                 )
 
@@ -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
 
@@ -378,7 +381,7 @@ class Fill_time_series(Binary):
                         )
 
         filled_data = pd.concat(filled_data, ignore_index=True)
-        combined_data = pd.concat([filled_data, data], ignore_index=True)  # type: ignore[list-item]
+        combined_data = pd.concat([filled_data, data], ignore_index=True)
         if len(cls.periods) == 1 and cls.periods[0] == "A":
             combined_data[cls.time_id] = combined_data[cls.time_id].astype(int)
         else:
@@ -456,7 +459,7 @@ class Fill_time_series(Binary):
 
         filled_data = pd.concat(filled_data, ignore_index=True)
         filled_data[cls.time_id] = filled_data[cls.time_id].dt.strftime(date_format)
-        combined_data = pd.concat([filled_data, data], ignore_index=True)  # type: ignore[list-item]
+        combined_data = pd.concat([filled_data, data], ignore_index=True)
         combined_data[cls.time_id] = combined_data[cls.time_id].astype(str)
         return combined_data.sort_values(by=cls.other_ids + [cls.time_id])
 
@@ -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/__init__.py

@@ -1,3 +1,5 @@
-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"]
+
+__version__ = "1.1.1"

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:
@@ -110,21 +105,16 @@ def _sanitize_pandas_columns(
 
 
 def _pandas_load_csv(components: Dict[str, Component], csv_path: Union[str, 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:
-        if isinstance(csv_path, Path):
-            raise InputValidationException(code="0-1-2-5", file=csv_path.name)
-        else:
-            raise InputValidationException(code="0-1-2-5", file=csv_path)
+    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",
+    )
 
     return _sanitize_pandas_columns(components, csv_path, data)
 
@@ -170,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 = (
@@ -192,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()
@@ -207,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"

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.1.1.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.3
+Name: vtlengine
+Version: 1.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
+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: Typing :: Typed
+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,<3.0)
+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
+Project-URL: MeaningfulData, https://www.meaningfuldata.eu/
+Project-URL: Repository, https://github.com/Meaningful-Data/vtlengine
+Description-Content-Type: text/markdown
+
+# VTL Engine
+
+|              |                                                                                                                                                                                |
+|--------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Testing      | [![Testing](https://github.com/Meaningful-Data/vtlengine/actions/workflows/testing.yml/badge.svg)](https://github.com/Meaningful-Data/vtlengine/actions/workflows/testing.yml) |
+| Package      | [![PyPI Latest Release](https://img.shields.io/pypi/v/vtlengine.svg)](https://pypi.org/project/vtlengine/)                                                                     |
+| License      | [![License - AGPL 3.0](https://img.shields.io/pypi/l/vtlengine.svg)](https://github.com/Meaningful-Data/vtlengine/blob/main/LICENSE.md)                                        |
+| Mentioned in | [![Mentioned in Awesome Official Statistics ](https://awesome.re/mentioned-badge.svg)](http://www.awesomeofficialstatistics.org)                                               |
+
+## Introduction
+
+The VTL Engine is a Python library that allows you to validate, format and execute VTL scripts.
+
+It is a Python-based library around
+the [VTL Language 2.1](https://sdmx-twg.github.io/vtl/2.1/html/index.html).
+
+## Useful Links
+
+- [MeaningfulData: who we are](https://www.meaningfuldata.eu)
+- [Documentation](https://docs.vtlengine.meaningfuldata.eu)
+- [Source Code](https://github.com/Meaningful-Data/vtlengine)
+- [Bug Tracker](https://github.com/Meaningful-Data/vtlengine/issues?q=is%3Aopen+is%3Aissue+label%3Abug)
+- [New features Tracker](https://github.com/Meaningful-Data/vtlengine/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement)
+
+## Installation
+
+### Requirements
+
+The VTL Engine requires Python 3.9 or higher.
+
+### Install with pip
+
+To install the VTL Engine on any Operating System, you can use pip:
+
+```bash
+
+pip install vtlengine
+
+```
+
+*Note: it is recommended to install the VTL Engine in a virtual environment.*
+
+### S3 extra
+
+If you want to use the S3 functionality, you can install the VTL Engine with the `s3` extra:
+
+```bash
+pip install vtlengine[s3]
+```
+
+## Documentation
+
+The documentation for the VTL Engine is available
+at [docs.vtlengine.meaningfuldata.eu](https://docs.vtlengine.meaningfuldata.eu).

{vtlengine-1.1rc1.dist-info → vtlengine-1.1.1.dist-info}/RECORD

@@ -1,16 +1,18 @@
-vtlengine/API/_InternalApi.py,sha256=fz_JSIrLdXd29Tbg7FI6uZQE1wdOTlJPSZ27tPXHjeM,14825
-vtlengine/API/__init__.py,sha256=2IDUvvSJdbkL5It8JulhmPCgkEnNbw52_VbbWm_aRp0,11061
+vtlengine/API/_InternalApi.py,sha256=I4Y11qx66ru9P77TySHtN9ZfJiOiRRcNhzdJVLdSOok,22938
+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=mFZzkT5XO2p21ptt7nv3iBefJOcNsvuoWqwqaxfxMOc,25936
+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=N-HRmSJ_m_mdHgNPk2JV5uqHPMdz2pXSoJE036mRqtg,19882
 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,19 +43,20 @@ 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=4oVoRnGiOCQjBU9oBTe8LozTNr6A1xNigQJui7J4EL0,42680
 vtlengine/Operators/Validation.py,sha256=ev3HyU7e1XbeAtUQ1y6zY3fzBwMqetDPhG3NNveAGOE,9988
 vtlengine/Operators/__init__.py,sha256=GN5eaAwmzfYKD7JJRIaRqdIJzflGc3UMvrOC9mlYNVo,37227
-vtlengine/Utils/__init__.py,sha256=ZobqGLc4rpMrsmniexTD4J-VokQt3qLrBGdFEDHHT1M,7571
+vtlengine/Utils/__init__.py,sha256=zhGPJA8MjHmtEEwMS4CxEFYL0tk2L5F0YPn7bitdRzM,8954
 vtlengine/__extras_check.py,sha256=Wr-lxGZhXJZEacVV5cUkvKt7XM-mry0kYAe3VxNrVcY,614
-vtlengine/__init__.py,sha256=L9tGzRGQ8HMDS23sVWIbBvj41sXR89pf0ZMzEidIEMM,89
+vtlengine/__init__.py,sha256=St9OIn1YjTLffx957I4gjwWlf8W5b4xj0oGCad6Stk8,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=Kt1hFk6El0B2Fpi3sSC34x4r9BfG6V2pwDv67D0Z3xg,9057
-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.1rc1.dist-info/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
-vtlengine-1.1rc1.dist-info/METADATA,sha256=M6qsKt4xzOOOiQ7TdfDnqcSxLeqgqGouytXDAdRR3o0,8726
-vtlengine-1.1rc1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-vtlengine-1.1rc1.dist-info/RECORD,,
+vtlengine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vtlengine-1.1.1.dist-info/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
+vtlengine-1.1.1.dist-info/METADATA,sha256=Csw4dEroIdEu00IUA5thIjqB_1mkDaXTETM7tvN7GjA,4102
+vtlengine-1.1.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+vtlengine-1.1.1.dist-info/RECORD,,

{vtlengine-1.1rc1.dist-info → vtlengine-1.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