pysdmx 1.9.0__py3-none-any.whl → 1.10.0rc1__py3-none-any.whl

pysdmx/__extras_check.py

@@ -46,7 +46,7 @@ def __check_xml_extra() -> None:
 
 def __check_vtl_extra() -> None:
     try:
-        import vtlengine  # type: ignore[import-untyped]  # noqa: F401
+        import vtlengine  # noqa: F401
     except ImportError:
         raise ImportError(
             ERROR_MESSAGE.format(

pysdmx/__init__.py

@@ -1,3 +1,3 @@
 """Your opinionated Python SDMX library."""
 
-__version__ = "1.9.0"
+__version__ = "1.10.0rc1"

pysdmx/io/input_processor.py

@@ -29,16 +29,19 @@ def __check_xml(input_str: str) -> bool:
 
 def __check_csv(input_str: str) -> bool:
     try:
-        max_length = min(2048, len(input_str))
-        dialect = csv.Sniffer().sniff(input_str[:max_length])
+        lines = input_str.splitlines()
+
+        # Use the first N complete lines
+        # (1 should be enough)
+        max_lines = 1
+        sample = "\n".join(lines[:max_lines])
+
+        dialect = csv.Sniffer().sniff(sample)
         control_csv_format = (
             dialect.delimiter == "," and dialect.quotechar == '"'
         )
         # Check we can access the data and it is not empty
-        if (
-            len(input_str.splitlines()) > 1
-            or input_str.splitlines()[0].count(",") > 1
-        ) and control_csv_format:
+        if (len(lines) > 1 or lines[0].count(",") > 1) and control_csv_format:
             return True
     except Exception:
         return False

pysdmx/io/xml/header.py

@@ -31,6 +31,7 @@ from pysdmx.io.xml.__tokens import (
     URN,
     VERSION,
 )
+from pysdmx.io.xml.utils import add_list
 from pysdmx.model import Organisation, Reference
 from pysdmx.model.dataset import ActionType
 from pysdmx.model.message import Header
@@ -87,43 +88,49 @@ def __parse_sender_receiver(
 def __parse_structure(
     structure: Union[Dict[str, Any], None],
 ) -> Union[Dict[str, str], None]:
-    """Parses the structure of the SDMX header."""
+    """Parses the structure/s of the SDMX header."""
     if structure is None:
         return None
 
-    dim_at_obs = structure.get(DIM_OBS, "AllDimensions")
-
-    if STRUCTURE in structure:
-        structure_info = structure[STRUCTURE]
-        sdmx_type = DSD
-    elif STR_USAGE in structure:
-        structure_info = structure[STR_USAGE]
-        sdmx_type = DFW
-    elif PROV_AGREEMENT in structure:
-        structure_info = structure[PROV_AGREEMENT]
-        sdmx_type = PROV_AGREEMENT
-    else:
-        # Provision Agrement is a typo in the SDMX 2.1 schema,
-        # and it is later solved in SDMX 3.0
-        structure_info = structure[PROV_AGREMENT]
-        sdmx_type = PROV_AGREMENT
-
-    if REF in structure_info:
-        reference = structure_info[REF]
-        agency_id = reference[AGENCY_ID]
-        structure_id = reference[ID]
-        version = reference[VERSION]
-        ref_obj = Reference(
-            sdmx_type=sdmx_type,
-            agency=agency_id,
-            id=structure_id,
-            version=version,
-        )
-    elif URN in structure_info:
-        ref_obj = parse_maintainable_urn(structure_info[URN])
-    else:
-        ref_obj = parse_maintainable_urn(structure_info)
-    return {str(ref_obj): dim_at_obs}
+    result = {}
+
+    for struct in add_list(structure):
+        dim_at_obs = struct.get(DIM_OBS, "AllDimensions")
+
+        if STRUCTURE in struct:
+            structure_info = struct[STRUCTURE]
+            sdmx_type = DSD
+        elif STR_USAGE in struct:
+            structure_info = struct[STR_USAGE]
+            sdmx_type = DFW
+        elif PROV_AGREEMENT in struct:
+            structure_info = struct[PROV_AGREEMENT]
+            sdmx_type = PROV_AGREEMENT
+        else:
+            # Provision Agrement is a typo in the SDMX 2.1 schema,
+            # and it is later solved in SDMX 3.0
+            structure_info = struct[PROV_AGREMENT]
+            sdmx_type = PROV_AGREMENT
+
+        if REF in structure_info:
+            reference = structure_info[REF]
+            agency_id = reference[AGENCY_ID]
+            structure_id = reference[ID]
+            version = reference[VERSION]
+            ref_obj = Reference(
+                sdmx_type=sdmx_type,
+                agency=agency_id,
+                id=structure_id,
+                version=version,
+            )
+        elif URN in structure_info:
+            ref_obj = parse_maintainable_urn(structure_info[URN])
+        else:
+            ref_obj = parse_maintainable_urn(structure_info)
+
+        result[str(ref_obj)] = dim_at_obs
+
+    return result
 
 
 def __parse_source(source: Optional[Dict[str, Any]]) -> Optional[str]:

pysdmx/toolkit/vtl/__init__.py

@@ -1,6 +1,15 @@
 """VTL toolkit for PySDMX."""
 
+from pysdmx.toolkit.vtl.convert import (
+    convert_dataset_to_sdmx,
+    convert_dataset_to_vtl,
+)
 from pysdmx.toolkit.vtl.script_generation import generate_vtl_script
 from pysdmx.toolkit.vtl.validation import model_validations
 
-__all__ = ["model_validations", "generate_vtl_script"]
+__all__ = [
+    "model_validations",
+    "generate_vtl_script",
+    "convert_dataset_to_vtl",
+    "convert_dataset_to_sdmx",
+]

pysdmx/toolkit/vtl/_validations.py

@@ -1,13 +1,9 @@
 """Private module for VTL validation functions."""
 
-from vtlengine.API import create_ast  # type: ignore[import-untyped]
-from vtlengine.AST import (  # type: ignore[import-untyped]
-    DPRuleset as ASTDPRuleset,
-)
+from vtlengine.API import create_ast
+from vtlengine.AST import DPRuleset as ASTDPRuleset
 from vtlengine.AST import HRuleset as ASTHRuleset
-from vtlengine.AST import (
-    Operator as ASTOperator,
-)
+from vtlengine.AST import Operator as ASTOperator
 
 from pysdmx.errors import Invalid
 from pysdmx.model import Reference
@@ -37,14 +33,14 @@ def _ruleset_validation(ruleset: Ruleset) -> None:
         ast.children[0], ASTDPRuleset
     ):
         raise Invalid("Ruleset type does not match the definition")
-    if (
-        ruleset.ruleset_scope == "variable"
-        and ast.children[0].signature_type != "variable"
-    ):
+
+    child = ast.children[0]
+    signature_type = getattr(child, "signature_type", None)
+    if ruleset.ruleset_scope == "variable" and signature_type != "variable":
         raise Invalid("Ruleset scope does not match the definition")
     if (
         ruleset.ruleset_scope == "valuedomain"
-        and ast.children[0].signature_type != "valuedomain"
+        and signature_type != "valuedomain"
     ):
         raise Invalid("Ruleset scope does not match the definition")
 

pysdmx/toolkit/vtl/convert.py

@@ -0,0 +1,333 @@
+"""Conversions between pysdmx PandasDataset and vtlengine Dataset."""
+
+from typing import Dict, Optional, Type, Union
+
+from vtlengine.API import load_datasets  # type: ignore[attr-defined]
+from vtlengine.API._InternalApi import to_vtl_json
+from vtlengine.DataTypes import (
+    Boolean,
+    Date,
+    Duration,
+    Integer,
+    Number,
+    ScalarType,
+    String,
+    TimeInterval,
+    TimePeriod,
+)
+from vtlengine.Model import Dataset as VTLengineDataset
+from vtlengine.Model import Role as VTLRole
+
+from pysdmx.errors import Invalid
+from pysdmx.io.pd import PandasDataset
+from pysdmx.model import Component, Components, Concept, Reference
+from pysdmx.model.concept import DataType
+from pysdmx.model.dataflow import Role, Schema
+
+# VTL to SDMX type mapping
+VTL_TO_SDMX_TYPE_MAP: Dict[Type[ScalarType], DataType] = {
+    String: DataType.STRING,
+    Integer: DataType.INTEGER,
+    Number: DataType.DOUBLE,
+    Boolean: DataType.BOOLEAN,
+    Date: DataType.DATE,
+    TimePeriod: DataType.PERIOD,
+    TimeInterval: DataType.TIME,
+    Duration: DataType.DURATION,
+}
+
+# Role mapping
+# ViralAttribute is not yet supported as a separate role in VTL 1.2.2,
+# so it is mapped to Attribute following vtlengine's behavior
+VTL_TO_SDMX_ROLE_MAP: Dict[VTLRole, Role] = {
+    VTLRole.IDENTIFIER: Role.DIMENSION,
+    VTLRole.MEASURE: Role.MEASURE,
+    VTLRole.ATTRIBUTE: Role.ATTRIBUTE,
+    "ViralAttribute": Role.ATTRIBUTE,  # type: ignore[dict-item]
+}
+
+VALID_SDMX_TYPES = {"DataStructure", "Dataflow", "ProvisionAgreement"}
+
+
+def convert_dataset_to_vtl(
+    dataset: PandasDataset, vtl_dataset_name: str
+) -> VTLengineDataset:
+    """Convert a PandasDataset to a vtlengine Dataset.
+
+    This function converts a PandasDataset, which contains both data and
+    structure (Schema), into a vtlengine Dataset. It uses vtlengine's
+    conversion functions to handle the Schema to VTL structure mapping.
+
+    It raises an Invalid exception if the dataset structure is not a
+    Schema object.
+
+    Args:
+        dataset: The PandasDataset to convert.
+        vtl_dataset_name: The name for the vtlengine Dataset.
+
+    Returns:
+        A vtlengine Dataset with the data and structure from the
+        PandasDataset.
+
+    Raises:
+        Invalid: If the dataset structure is not a Schema object or if
+            component types cannot be mapped.
+    """
+    if not isinstance(dataset.structure, Schema):
+        raise Invalid(
+            "Validation Error",
+            "Dataset structure must be a Schema object for conversion to VTL",
+        )
+
+    schema = dataset.structure
+    pd_dataset = dataset.data
+
+    # Use vtlengine's built-in conversion function to convert Schema to VTL
+    vtl_json = to_vtl_json(schema, vtl_dataset_name)
+
+    # Load the dataset structure using vtlengine's API
+    datasets, scalars = load_datasets(vtl_json)
+    vtl_dataset = datasets[vtl_dataset_name]
+
+    # Assign the pandas DataFrame to the VTL dataset
+    vtl_dataset.data = pd_dataset
+
+    return vtl_dataset
+
+
+def convert_dataset_to_sdmx(
+    dataset: VTLengineDataset,
+    reference: Optional[Reference] = None,
+    schema: Optional[Schema] = None,
+) -> PandasDataset:
+    """Convert a VTLengine Dataset to a PandasDataset.
+
+    This function converts a `vtlengine.Model.Dataset` into
+    a `PandasDataset` by:
+
+    * Using a provided `Schema` for direct validation and conversion.
+    * Generating a new SDMX-compatible `Schema` from the dataset components,
+      using metadata from a provided `Reference`.
+
+    When a `schema` is supplied, the dataset is first validated against it and,
+    if validation passes, the data is wrapped in a `PandasDataset` with that
+    schema. If no `schema` is provided, a `reference` must be given so a new
+    SDMX structure (with components, roles, and data types mapped from the
+    VTL dataset) can be created.
+
+    Invalid is raised in the following cases:
+        * If neither `schema` nor `reference` is provided.
+        * If the `reference` has an unsupported `sdmx_type`.
+        * If the `dataset` contains no data.
+        * If component types or roles cannot be mapped to SDMX equivalents.
+        * If validation fails when a `schema` is provided.
+
+    Args:
+        dataset: The VTLengine dataset to convert.
+            Must include components and associated data.
+        reference: Optional reference to the SDMX structure
+            (DataStructure, Dataflow, or ProvisionAgreement).
+            Required only when no `schema` is provided.
+            Used to build a schema and supply contextual identifiers.
+        schema: Optional schema describing the SDMX structure.
+            If provided, the dataset is validated against it
+            and the same schema is used directly in the output.
+
+    Returns:
+        A `PandasDataset` containing the converted data and the associated SDMX
+        structure (either the provided schema or a generated one).
+
+    Raises:
+        Invalid: If the reference sdmx_type is not valid, if component types
+            cannot be mapped, or if validation fails when schema is provided.
+    """
+    # If schema is provided
+    if schema is not None:
+        _validate_vtl_dataset_against_schema(dataset, schema)
+
+        data = dataset.data
+        if data is None:
+            raise Invalid(
+                "Validation Error",
+                "VTL dataset has no data for conversion to SDMX",
+            )
+
+        pandas_dataset = PandasDataset(
+            structure=schema,
+            data=data,
+        )
+        return pandas_dataset
+
+    # If schema is not provided, reference must be provided
+    if reference is None:
+        raise Invalid(
+            "Validation Error",
+            "Either schema or reference must be provided",
+        )
+
+    # Validate reference.sdmx_type
+    if reference.sdmx_type not in VALID_SDMX_TYPES:
+        raise Invalid(
+            "Validation Error",
+            f"Reference sdmx_type must be one of {VALID_SDMX_TYPES}, "
+            f"but got '{reference.sdmx_type}'",
+        )
+
+    data = dataset.data
+    if data is None:
+        raise Invalid(
+            "Validation Error",
+            "VTL dataset has no data for conversion to SDMX",
+        )
+
+    # Generate a new Schema from VTL Dataset components
+    sdmx_components = []
+
+    for comp_name, vtl_comp in dataset.components.items():
+        # Map VTL data type to SDMX data type
+        sdmx_dtype = _map_vtl_dtype_to_sdmx(vtl_comp.data_type)
+
+        # Map VTL role to SDMX role
+        sdmx_role = _map_vtl_role_to_sdmx(vtl_comp.role)
+
+        # Determine attachment_level for attributes
+        attachment_level = "O" if sdmx_role == Role.ATTRIBUTE else None
+
+        # Create SDMX Component
+        sdmx_comp = Component(
+            id=comp_name,
+            required=not vtl_comp.nullable,
+            role=sdmx_role,
+            concept=Concept(comp_name, dtype=sdmx_dtype),
+            attachment_level=attachment_level,
+        )
+        sdmx_components.append(sdmx_comp)
+
+    # Create Schema using reference information
+    generated_schema = Schema(
+        context=reference.sdmx_type.lower(),  # type: ignore[arg-type]
+        agency=reference.agency,
+        id=reference.id,
+        version=reference.version,
+        components=Components(sdmx_components),
+    )
+
+    pandas_dataset = PandasDataset(
+        structure=generated_schema,
+        data=data,
+    )
+    return pandas_dataset
+
+
+def _map_vtl_dtype_to_sdmx(
+    vtl_dtype_value: Union[ScalarType, Type[ScalarType]],
+) -> DataType:
+    """Return the SDMX DataType for a given VTL scalar.
+
+    Args:
+        vtl_dtype_value: The VTL scalar type or instance to map.
+
+    Returns:
+        The corresponding SDMX DataType.
+
+    Raises:
+        Invalid: If the VTL DataType cannot be mapped to an SDMX DataType.
+    """
+    if isinstance(vtl_dtype_value, type):
+        vtl_dtype_class: type[ScalarType] = vtl_dtype_value
+    else:
+        vtl_dtype_class = type(vtl_dtype_value)
+
+    if vtl_dtype_class not in VTL_TO_SDMX_TYPE_MAP:
+        supported = ", ".join(str(t.__name__) for t in VTL_TO_SDMX_TYPE_MAP)
+        raise Invalid(
+            "Validation Error",
+            f"VTL DataType '{vtl_dtype_class.__name__}' cannot be "
+            f"mapped to an SDMX type. Supported types are: {supported}",
+        )
+
+    return VTL_TO_SDMX_TYPE_MAP[vtl_dtype_class]
+
+
+def _map_vtl_role_to_sdmx(vtl_role: VTLRole) -> Role:
+    """Return the SDMX Role for a given VTL Role.
+
+    Args:
+        vtl_role: The VTLRole to map.
+
+    Returns:
+        The corresponding SDMX Role.
+
+    Raises:
+        Invalid: If the VTL Role cannot be mapped to an SDMX Role.
+    """
+    if vtl_role not in VTL_TO_SDMX_ROLE_MAP:
+        raise Invalid(
+            "Validation Error",
+            f"VTL Role '{vtl_role}' cannot be mapped to an SDMX Role",
+        )
+    return VTL_TO_SDMX_ROLE_MAP[vtl_role]
+
+
+def _validate_vtl_dataset_against_schema(
+    dataset: VTLengineDataset,
+    schema: Schema,
+) -> None:
+    """Validate VTLengine Dataset against SDMX Schema.
+
+    Args:
+        dataset: The VTLengineDataset instance whose components, roles, and
+            data types will be validated.
+        schema: The SDMX Schema that defines the expected components,
+            SDMX data types, and SDMX roles for validation.
+
+    Raises:
+        Invalid: If component names differ, if types or roles cannot be mapped,
+                 or if any mismatch is detected between the Dataset and Schema.
+    """
+    # Validate that schema components match VTL dataset components
+    vtl_component_names = set(dataset.components.keys())
+    schema_component_names = {comp.id for comp in schema.components}
+
+    if vtl_component_names != schema_component_names:
+        missing_in_schema = vtl_component_names - schema_component_names
+        missing_in_vtl = schema_component_names - vtl_component_names
+        error_parts = []
+        if missing_in_schema:
+            error_parts.append(
+                f"VTL components not in Schema: {missing_in_schema}"
+            )
+        if missing_in_vtl:
+            error_parts.append(
+                f"Schema components not in VTL: {missing_in_vtl}"
+            )
+        raise Invalid(
+            "Validation Error",
+            "Component mismatch between VTL Dataset and Schema. "
+            f"{'; '.join(error_parts)}",
+        )
+
+    # Validate that component types and roles match
+    for component in schema.components:
+        comp_id = str(component.id)
+        vtl_comp = dataset.components[comp_id]
+
+        # Validate data type using helper
+        expected_sdmx_dtype = _map_vtl_dtype_to_sdmx(vtl_comp.data_type)
+        if component.dtype != expected_sdmx_dtype:
+            raise Invalid(
+                "Validation Error",
+                "Component mismatch between VTL Dataset and Schema. "
+                f"Component '{comp_id}' has type {expected_sdmx_dtype} "
+                f"in VTL but {component.dtype} in Schema",
+            )
+
+        # Validate role using helper
+        expected_sdmx_role = _map_vtl_role_to_sdmx(vtl_comp.role)
+        if component.role != expected_sdmx_role:
+            raise Invalid(
+                "Validation Error",
+                "Component mismatch between VTL Dataset and Schema. "
+                f"Component '{comp_id}' has role {expected_sdmx_role} "
+                f"in VTL but {component.role} in Schema",
+            )

pysdmx/toolkit/vtl/script_generation.py

@@ -97,7 +97,7 @@ def generate_vtl_script(
 
     if prettyprint:
         __check_vtl_extra()
-        from vtlengine import prettify  # type: ignore[import-untyped]
+        from vtlengine import prettify
 
         return prettify(vtl_script)
 

{pysdmx-1.9.0.dist-info → pysdmx-1.10.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdmx
-Version: 1.9.0
+Version: 1.10.0rc1
 Summary: Your opinionated Python SDMX library
 License: Apache-2.0
 License-File: LICENSE
@@ -32,8 +32,8 @@ Requires-Dist: python-dateutil (>=2.8.2) ; extra == "dc"
 Requires-Dist: sdmxschemas (>=1.0.0) ; extra == "all"
 Requires-Dist: sdmxschemas (>=1.0.0) ; extra == "json"
 Requires-Dist: sdmxschemas (>=1.0.0) ; extra == "xml"
-Requires-Dist: vtlengine (>=1.1,<2.0) ; extra == "all"
-Requires-Dist: vtlengine (>=1.1,<2.0) ; extra == "vtl"
+Requires-Dist: vtlengine (>=1.2,<2.0) ; extra == "all"
+Requires-Dist: vtlengine (>=1.2,<2.0) ; extra == "vtl"
 Requires-Dist: xmltodict (>=0.13) ; extra == "all"
 Requires-Dist: xmltodict (>=0.13) ; extra == "xml"
 Project-URL: Bug Tracker, https://bis-med-it.github.io/pysdmx/issues

{pysdmx-1.9.0.dist-info → pysdmx-1.10.0rc1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pysdmx/__extras_check.py,sha256=A_w1dogaXAgEV96YqmWTCSCiPenlwFN5RuZaxHSUVzQ,2091
-pysdmx/__init__.py,sha256=imDBU5mrhY96OrWBHs0tqBGc2zWunlIkrd_szXtg4Lc,67
+pysdmx/__extras_check.py,sha256=Tmluui2OuJVyJB6a1Jl0PlrRjpsswhtCjAqtRLOSero,2059
+pysdmx/__init__.py,sha256=00h-DwPfv9b8RnK5FXzBTiZQOciFTXqXk7axxd3VD28,71
 pysdmx/api/__init__.py,sha256=8lRaF6kEO51ehl0fmW_pHLvkN_34TtEhqhr3oKo6E6g,26
 pysdmx/api/dc/__init__.py,sha256=oPU32X8CRZy4T1to9mO5KMqMwxQsVI424dPqai-I8zI,121
 pysdmx/api/dc/_api.py,sha256=poy1FYFXnF6maBGy5lpOodf32-7QQjH8PCBNDkuOXxQ,7747
@@ -38,7 +38,7 @@ pysdmx/io/csv/sdmx21/__init__.py,sha256=I3_dwi4A4if62_mwEjqbOa-F7mhoIMf0D6szpDf3
 pysdmx/io/csv/sdmx21/reader/__init__.py,sha256=J1cCkZh3klgZZWjdQ_U1zkfzT_DVzQmdreGZhN33SLs,2866
 pysdmx/io/csv/sdmx21/writer/__init__.py,sha256=CH8Nm7hqvXyN6XM_D2nJRmbKj6CJV-X1QzSF0WJrs0E,2484
 pysdmx/io/format.py,sha256=EO-PyYpiU0WswvEGA5UHokladxPezcwBUo1AJTqxp1Q,5250
-pysdmx/io/input_processor.py,sha256=rj2GzDs3xVQRzikzWonPWJGEa4_mxUPgCqHQ50JI5xY,6917
+pysdmx/io/input_processor.py,sha256=P1_jKegrOyV7EaZLjLrq8fX2u1EI7gPBJoKvlBCNkP0,6967
 pysdmx/io/json/fusion/messages/__init__.py,sha256=ac2jWfjGGBcfoSutiKy68LzqwNp_clt2RzmJOaYCxL0,2142
 pysdmx/io/json/fusion/messages/category.py,sha256=2NnYTptQ6nAdeYBIkAysyriTFF6dW8fjb9AvRWtTOao,5606
 pysdmx/io/json/fusion/messages/code.py,sha256=YayxSKiHa124WTr_lK8HTfXHomh_e0oDZvuydd29XKg,8300
@@ -107,7 +107,7 @@ pysdmx/io/xml/__write_data_aux.py,sha256=Kfwxi8XHXj4W94D41cTdPig6GYw_3wTUzfDucNW
 pysdmx/io/xml/__write_structure_specific_aux.py,sha256=reRDVw4Xwag0ODyMzm9uOk9WJ_e1ELxAPYHSMUUDJBQ,8919
 pysdmx/io/xml/config.py,sha256=R24cczVkzkhjVLXpv-qfEm88W3_QTqVt2Qofi8IvJ5Y,93
 pysdmx/io/xml/doc_validation.py,sha256=WXDhte96VEAeZMMHJ0Y68WW8HEoOhEiOYEnbGP5Zwjw,1795
-pysdmx/io/xml/header.py,sha256=L-stf7C2F6GWMlXUCWyI_2rBPjhKrHbICsHZ0vn_pZU,5752
+pysdmx/io/xml/header.py,sha256=My03uhWD3AkfTwfUqiblmLIZuqd7uvIEYsOial6TClg,5971
 pysdmx/io/xml/sdmx21/__init__.py,sha256=_rh_dz1d-LmUw4iVbsZQkTXANTJeR8ov8z_4jNRGhtg,38
 pysdmx/io/xml/sdmx21/reader/__init__.py,sha256=2jMsySFbbq-So3ymqzKVi5gOPRwO0qasBBwntD03rTw,34
 pysdmx/io/xml/sdmx21/reader/error.py,sha256=ySY3dBPcOaF_lm8yX1Khc92R5XgyD1u-djjiOrgZJP8,885
@@ -153,15 +153,16 @@ pysdmx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pysdmx/toolkit/__init__.py,sha256=yBRw4FXQH_RUJgF6vwZscNwCVBt-FMwslJEfDKa7eXo,26
 pysdmx/toolkit/pd/__init__.py,sha256=3JoCZHamJR4mZfLt9GmaznLlG_YilmY0hAhuW5COQC8,3138
 pysdmx/toolkit/pd/_data_utils.py,sha256=fzXl_a1M8NI7HHI23tRmLlS4PBZ9N4Tgtqh-zxg19qk,3265
-pysdmx/toolkit/vtl/__init__.py,sha256=nVwtISeFiT4tr2gNjb2A-P_IRAdqv6Mn7EOgFkaRleg,216
-pysdmx/toolkit/vtl/_validations.py,sha256=Djc5hHpj79SksvnAA0vL5EnpsDCdQ_BmB6zsr7Ze9Eg,5639
-pysdmx/toolkit/vtl/script_generation.py,sha256=YOP_-MMcIdDIHYa8HIMuVCN9N-S9CQD8bH5xpF1kc2E,3235
+pysdmx/toolkit/vtl/__init__.py,sha256=jYWScnAomHlkvTtl07ur82UEqALCveiAEmMbqdWhT1A,388
+pysdmx/toolkit/vtl/_validations.py,sha256=k0le8fDUOGNl97P-QbNglrNyr5fCh5dLPMiTk1yu1jw,5590
+pysdmx/toolkit/vtl/convert.py,sha256=FNToVTG4Zu9n7h_Fre-LEGihx8RMGSJb7G6-FFyPg8Y,11355
+pysdmx/toolkit/vtl/script_generation.py,sha256=pIDKd12uQrmbiU21DbDm8UbYMW2PYldFV_OXCzyqU_8,3203
 pysdmx/toolkit/vtl/validation.py,sha256=UieJUYwxkw9McHZwixKFQdgYKFsgFwFo5XCLIIDcr7Q,3594
 pysdmx/util/__init__.py,sha256=m_XWRAmVJ7F6ai4Ckrj_YuPbhg3cJZAXeZrEThrL88k,3997
 pysdmx/util/_date_pattern_map.py,sha256=IS1qONwVHbTBNIFCT0Rqbijj2a9mYvs7onXSK6GeQAQ,1620
 pysdmx/util/_model_utils.py,sha256=nQ1yWBt-tZYDios9xvRvJ7tHq6A8_RoGdY1wi7WGz2w,3793
 pysdmx/util/_net_utils.py,sha256=nOTz_x3FgFrwKh42_J70IqYXz9duQkMFJWtejZXcLHs,1326
-pysdmx-1.9.0.dist-info/METADATA,sha256=XVEmYwvV0I0_sXF_IE9NlkAehLn5VZwK39N2rg47DW8,4848
-pysdmx-1.9.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-pysdmx-1.9.0.dist-info/licenses/LICENSE,sha256=3XTNDPtv2RxDUNkQzn9MIWit2u7_Ob5daMLEq-4pBJs,649
-pysdmx-1.9.0.dist-info/RECORD,,
+pysdmx-1.10.0rc1.dist-info/METADATA,sha256=kPs3kQG4EX60hnWKin3iojI-3tHGysb93P5Xc7uy56k,4852
+pysdmx-1.10.0rc1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+pysdmx-1.10.0rc1.dist-info/licenses/LICENSE,sha256=3XTNDPtv2RxDUNkQzn9MIWit2u7_Ob5daMLEq-4pBJs,649
+pysdmx-1.10.0rc1.dist-info/RECORD,,