vtlengine 1.4.0rc2__py3-none-any.whl

vtlengine/files/parser/__init__.py

@@ -0,0 +1,240 @@
+import warnings
+from csv import DictReader
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Type, Union
+
+import numpy as np
+import pandas as pd
+
+from vtlengine.DataTypes import (
+    SCALAR_TYPES_CLASS_REVERSE,
+    Boolean,
+    Date,
+    Duration,
+    Integer,
+    Number,
+    ScalarType,
+    TimeInterval,
+    TimePeriod,
+)
+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 DataLoadError, InputValidationException
+from vtlengine.files.parser._rfc_dialect import register_rfc
+from vtlengine.Model import Component, Dataset, Role
+
+TIME_CHECKS_MAPPING: Dict[Type[ScalarType], Any] = {
+    Date: check_date,
+    TimePeriod: check_time_period,
+    TimeInterval: check_time,
+}
+
+
+def _validate_csv_path(components: Dict[str, Component], csv_path: Path) -> None:
+    # GE1 check if the file is empty
+    if not csv_path.exists():
+        raise DataLoadError(code="0-3-1-1", file=csv_path)
+    if not csv_path.is_file():
+        raise DataLoadError(code="0-3-1-1", file=csv_path)
+    register_rfc()
+    try:
+        with open(csv_path, "r", errors="replace", encoding="utf-8") as f:
+            reader = DictReader(f, dialect="rfc")
+            csv_columns = reader.fieldnames
+    except InputValidationException as ie:
+        raise InputValidationException("{}".format(str(ie))) from None
+    except Exception as e:
+        raise InputValidationException(
+            f"ERROR: {str(e)}, review file {str(csv_path.as_posix())}"
+        ) from None
+
+    if not csv_columns:
+        raise InputValidationException(code="0-1-1-6", file=csv_path)
+
+    if len(list(set(csv_columns))) != len(csv_columns):
+        duplicates = list(set([item for item in csv_columns if csv_columns.count(item) > 1]))
+        raise InputValidationException(
+            code="0-1-2-3", element_type="Columns", element=f"{', '.join(duplicates)}"
+        )
+
+    comp_names = set([c.name for c in components.values() if c.role == Role.IDENTIFIER])
+    comps_missing: Union[str, List[str]] = (
+        [id_m for id_m in comp_names if id_m not in reader.fieldnames] if reader.fieldnames else []
+    )
+    if comps_missing:
+        comps_missing = ", ".join(comps_missing)
+        raise InputValidationException(code="0-1-1-8", ids=comps_missing, file=str(csv_path.name))
+
+
+def _sanitize_pandas_columns(
+    components: Dict[str, Component], csv_path: Union[str, Path], data: pd.DataFrame
+) -> pd.DataFrame:
+    # Fast loading from SDMX-CSV
+    if (
+        "DATAFLOW" in data.columns
+        and data.columns[0] == "DATAFLOW"
+        and "DATAFLOW" not in components
+    ):
+        data.drop(columns=["DATAFLOW"], inplace=True)
+    if "STRUCTURE" in data.columns and data.columns[0] == "STRUCTURE":
+        if "STRUCTURE" not in components:
+            data.drop(columns=["STRUCTURE"], inplace=True)
+        if "STRUCTURE_ID" in data.columns:
+            data.drop(columns=["STRUCTURE_ID"], inplace=True)
+        if "ACTION" in data.columns:
+            data = data[data["ACTION"] != "D"]
+            data.drop(columns=["ACTION"], inplace=True)
+
+    # Validate identifiers
+    comp_names = set([c.name for c in components.values() if c.role == Role.IDENTIFIER])
+    comps_missing: Union[str, List[str]] = [id_m for id_m in comp_names if id_m not in data.columns]
+    if comps_missing:
+        comps_missing = ", ".join(comps_missing)
+        file = csv_path if isinstance(csv_path, str) else csv_path.name
+        raise InputValidationException(code="0-1-1-7", ids=comps_missing, file=file)
+
+    # Fill rest of components with null values
+    for comp_name, comp in components.items():
+        if comp_name not in data:
+            if not comp.nullable:
+                raise InputValidationException(f"Component {comp_name} is missing in the file.")
+            data[comp_name] = None
+    return 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,  # type: ignore[call-overload, unused-ignore]
+        dtype=obj_dtypes,
+        engine="c",
+        keep_default_na=False,
+        na_values=[""],
+        encoding_errors="replace",
+    )
+
+    return _sanitize_pandas_columns(components, csv_path, data)
+
+
+def _parse_boolean(value: str) -> bool:
+    if isinstance(value, bool):
+        return value
+    result = value.lower() == "true" or value == "1"
+    return result
+
+
+def _validate_pandas(
+    components: Dict[str, Component], data: pd.DataFrame, dataset_name: str
+) -> pd.DataFrame:
+    warnings.filterwarnings("ignore", category=FutureWarning)
+    # Identifier checking
+
+    id_names = [comp_name for comp_name, comp in components.items() if comp.role == Role.IDENTIFIER]
+
+    missing_columns = [name for name in components if name not in data.columns.tolist()]
+    if missing_columns:
+        for name in missing_columns:
+            if components[name].nullable is False:
+                raise DataLoadError("0-3-1-5", name=dataset_name, comp_name=name)
+            data[name] = None
+
+    for id_name in id_names:
+        if data[id_name].isnull().any():
+            raise DataLoadError("0-3-1-3", null_identifier=id_name, name=dataset_name)
+
+    if len(id_names) == 0 and len(data) > 1:
+        raise DataLoadError("0-3-1-4", name=dataset_name)
+
+    data = data.fillna(np.nan).replace([np.nan], None)
+    # Checking data types on all data types
+    comp_name = ""
+    comp = None
+    try:
+        for comp_name, comp in components.items():
+            if comp.data_type in (Date, TimePeriod, TimeInterval):
+                data[comp_name] = data[comp_name].map(
+                    TIME_CHECKS_MAPPING[comp.data_type], na_action="ignore"
+                )
+            elif comp.data_type == Integer:
+                data[comp_name] = data[comp_name].map(
+                    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((str(x))), na_action="ignore")
+            elif comp.data_type == Boolean:
+                data[comp_name] = data[comp_name].map(
+                    lambda x: _parse_boolean(str(x)), na_action="ignore"
+                )
+            elif comp.data_type == Duration:
+                values_correct = (
+                    data[comp_name]
+                    .map(
+                        lambda x: Duration.validate_duration(x),
+                        na_action="ignore",
+                    )
+                    .all()
+                )
+                if not values_correct:
+                    try:
+                        values_correct = (
+                            data[comp_name]
+                            .map(
+                                lambda x: x.replace(" ", "") in PERIOD_IND_MAPPING,  # type: ignore[union-attr, unused-ignore]
+                                na_action="ignore",
+                            )
+                            .all()
+                        )
+                        if not values_correct:
+                            raise ValueError(
+                                f"Duration values are not correct in column {comp_name}"
+                            )
+                    except ValueError:
+                        raise ValueError(f"Duration values are not correct in column {comp_name}")
+            else:
+                data[comp_name] = data[comp_name].map(
+                    lambda x: str(x).replace('"', ""), na_action="ignore"
+                )
+            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"
+        raise DataLoadError("0-3-1-6", 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 DataLoadError("0-3-1-7", name=name, row_index=row_index)
+
+
+def load_datapoints(
+    components: Dict[str, Component],
+    dataset_name: str,
+    csv_path: Optional[Union[Path, str]] = None,
+) -> 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, Path)):
+        if isinstance(csv_path, Path):
+            _validate_csv_path(components, csv_path)
+        data = _pandas_load_csv(components, csv_path)
+    else:
+        raise InputValidationException(code="0-1-1-2", input=csv_path)
+    data = _validate_pandas(components, data, dataset_name)
+
+    return data
+
+
+def _fill_dataset_empty_data(dataset: Dataset) -> None:
+    dataset.data = pd.DataFrame(columns=list(dataset.components.keys()))

vtlengine/files/parser/_rfc_dialect.py

@@ -0,0 +1,22 @@
+import csv
+
+
+class RFCDialect(csv.Dialect):
+    """
+    https://docs.python.org/3/library/csv.html#csv.Dialect
+    https://tools.ietf.org/html/rfc4180
+    """
+
+    delimiter = ","
+    doublequote = True
+    lineterminator = "\r\n"
+    quotechar = '"'
+    quoting = csv.QUOTE_MINIMAL
+    strict = True
+    escapechar = None
+    skipinitialspace = False
+
+
+def register_rfc() -> None:
+    """Register the RFC dialect."""
+    csv.register_dialect("rfc", RFCDialect)

vtlengine-1.4.0rc2.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: vtlengine
+Version: 1.4.0rc2
+Summary: Run and Validate VTL Scripts
+License-Expression: AGPL-3.0
+License-File: LICENSE.md
+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,<4.10)
+Requires-Dist: duckdb (>=1.4,<1.5)
+Requires-Dist: jsonschema (>=3.2.0,<5.0)
+Requires-Dist: networkx (>=2.8,<3.0)
+Requires-Dist: pandas (>=2.1.4,<3.0)
+Requires-Dist: pysdmx[xml] (>=1.5.2,<2.0)
+Requires-Dist: s3fs (>=2022.11.0) ; extra == "all"
+Requires-Dist: s3fs (>=2022.11.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)](https://github.com/SNStatComp/awesome-official-statistics-software)                                               |
+
+## 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.4.0rc2.dist-info/RECORD

@@ -0,0 +1,66 @@
+vtlengine/API/_InternalApi.py,sha256=qkrEPwrOCWDeL4TeAw0IKNeLb30UfsTgqRRQnUDLhKY,29571
+vtlengine/API/__init__.py,sha256=JZ_SoLp34xC9rglN8CCgExo9GTSg_bJVU_yUu3vhJJs,22992
+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=rn9lVIafpjoBc4fjCs0o3ytglf8URg2whsUzLhCE19w,1723
+vtlengine/AST/ASTConstructor.py,sha256=Ypi4iLW-2LXbtd4jsEjvICpll79cBIuSD0REYjfDJAE,21488
+vtlengine/AST/ASTConstructorModules/Expr.py,sha256=Wjl6Eb_tF-ncF3Frgp2UAZXBUSwxR6ZuegWUR9Y3MyI,70556
+vtlengine/AST/ASTConstructorModules/ExprComponents.py,sha256=_HdsvJ2JiDWI19EwgjDkLtVf9YkSaFnZJLf1R5KndoA,38553
+vtlengine/AST/ASTConstructorModules/Terminals.py,sha256=mWvjEoeF2hA1GVzm5pD33al3oNDzXjNydGq_4wdMdfo,26891
+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
+vtlengine/AST/ASTString.py,sha256=HBvDW0te1ZNIkPgmqW4D4D20Wca1JWdr475u64tqWSg,27901
+vtlengine/AST/ASTTemplate.py,sha256=UN9T6BBgd964dF4I9DpdnvU0n0qV1R5RKGdr_Jtm5pw,13099
+vtlengine/AST/ASTVisitor.py,sha256=3QQTudBpbR4pPQdH7y07EgwuzhoGzNQ59qox8R-E3fM,500
+vtlengine/AST/DAG/__init__.py,sha256=2xAQpKJrH01jlKXgKHuBeB7eDXVO5CSUC4OWpmuXqc4,17120
+vtlengine/AST/DAG/_words.py,sha256=LyRL9j-vZUNHdLDJZJrq2nKUmVlpbxdzd9ovW6CnNoU,200
+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=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=ypsyviCe1AxpJmJkI2z9MbB0WtJk0IEK4rXhLhu6z1w,11736
+vtlengine/DataTypes/TimeHandling.py,sha256=6kP5CWrrmP1DdRq_mViG5G2-48J7eNW3_FCqHAhoXNM,20497
+vtlengine/DataTypes/__init__.py,sha256=j1ijUT7OiK1WltI9CRL0dc868Emcj1Y-WhiCGT51bfQ,25486
+vtlengine/DataTypes/_time_checking.py,sha256=YAbjO8IEc8fJz3mSstCV3Qma2S5Sk5PRZzQjI48RElY,4822
+vtlengine/Exceptions/__exception_file_generator.py,sha256=E-MEXfdL2eivdoUXDQZ3Tq8XT77ZH3e8WkWr600xLS0,3782
+vtlengine/Exceptions/__init__.py,sha256=5eVyH9gNJpE9VfUh2Te9ZXOiLX0gJtKqqIZ0n4rOnPg,4445
+vtlengine/Exceptions/messages.py,sha256=PXsHe3xG5oXeisZUq6sAO03FeDZvoYntMO5CkRDjRxw,46407
+vtlengine/Interpreter/__init__.py,sha256=5zL2oXjNGCAVj3yB64VTt0hkQR6q0B0m_Jd9rDrbtew,89128
+vtlengine/Model/__init__.py,sha256=rcgrYbQmP8bOvnUO6tLcg6kMZp4I9EveqyQJ4KZAeqY,17576
+vtlengine/Operators/Aggregation.py,sha256=rD9LYZHVbfrZ7DWc1m8vb4BcoP_nBF7UAnp_Qnlz5cE,12510
+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=IzyCehwPp5lG6Txd3mH352hEV9f5fQ6wRTfYikljHlE,17213
+vtlengine/Operators/Clause.py,sha256=ctD0pQX3qrxcQGoBztbMQKhhBkXOZ3w6ensWCuAN7OY,15505
+vtlengine/Operators/Comparison.py,sha256=paSX24S0iW-KYi_11cjIkRGwxToCfeUsbCXzLqvxMHw,17457
+vtlengine/Operators/Conditional.py,sha256=Pu42sRwIqhYOCFO40aShVw9YYWgm6PUoUU6ialI8yRs,21476
+vtlengine/Operators/General.py,sha256=BVvBYYWGWFq-eaYoD1pgYMJjILATrX4zpUtqBbxgTw8,7548
+vtlengine/Operators/HROperators.py,sha256=a_oh6H7E6Ex6t7FX78e--rkXcFcegqxEotzw3LvUuQc,9153
+vtlengine/Operators/Join.py,sha256=ZtgL_aL9PLjL8V5zM7ZSGQ5bJOQ94TZqAuROvGH82bo,18393
+vtlengine/Operators/Numeric.py,sha256=icYTWzEsw6VQFLYc5Wucgr8961d8ZwTFx_wfZ8Wp9Co,12083
+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=wjYAp_4hvqgyK0lvweIZOhzUqI0TLmjcns3iLnN4erQ,43332
+vtlengine/Operators/Validation.py,sha256=BWHwCOajDnYJVWOkkDsTcjrDqmpKCJ3jykj-rMxfTSU,11259
+vtlengine/Operators/__init__.py,sha256=ECSr7YL5WUs1ab-KlYwz7nDlnXc2S4eBgiQMPaj-Y68,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=36roYHxGbmUgbIN4d5zODv-MznsPss-iRKrit7qqcNo,533
+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=8or2JoWSDwUwvOEQH6sO4HxD_rrIMwLAAVAeT4kQzm0,9155
+vtlengine/files/parser/_rfc_dialect.py,sha256=Y8kAYBxH_t9AieN_tYg7QRh5A4DgvabKarx9Ko3QeCQ,462
+vtlengine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vtlengine-1.4.0rc2.dist-info/METADATA,sha256=CKSQjSQu5KYK03wZAd4CEYoczggM_P3oVwKcP6Uo3Ts,3909
+vtlengine-1.4.0rc2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+vtlengine-1.4.0rc2.dist-info/licenses/LICENSE.md,sha256=2xqHuoHohba7gpcZZKtOICRjzeKsQANXG8WoV9V35KM,33893
+vtlengine-1.4.0rc2.dist-info/RECORD,,

vtlengine-1.4.0rc2.dist-info/WHEEL

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