pysdmx 1.3.0__py3-none-any.whl → 1.4.0rc1__py3-none-any.whl

pysdmx/io/xml/{sdmx21/__tokens.py → __tokens.py}

@@ -12,6 +12,7 @@ REQUIRED = "required"
 POSITION = "position"
 CLASS = "class"
 PACKAGE = "package"
+LINK = "Link"
 
 # Structure Specific
 STR_SPE = "StructureSpecificData"
@@ -28,6 +29,7 @@ STR_REF = "structureRef"
 STRUCTURE = "Structure"
 STR_USAGE = "StructureUsage"
 PROV_AGREMENT = "ProvisionAgrement"
+PROV_AGREEMENT = "ProvisionAgreement"
 STR_ID = "structureID"
 STR_TYPE = "structure_type"
 DIM_OBS = "dimensionAtObservation"
@@ -43,6 +45,7 @@ SOURCE = "Source"
 HEADER_ID = "ID"
 NAMESPACE = "namespace"
 NAMES = "names"
+REGISTRY_LOW = "registry"
 
 
 # SDMX Error handling
@@ -80,9 +83,11 @@ ANNOTATIONS = "Annotations"
 ANNOTATIONS_LOW = "annotations"
 STRUCTURES = "Structures"
 ORGS = "OrganisationSchemes"
-AGENCIES = "AgencyScheme"
+AGENCIES = "AgencySchemes"
+AGENCY_SCHEME = "AgencyScheme"
 CODELISTS = "Codelists"
 CONCEPTS = "Concepts"
+CON_SCHEMES = "ConceptSchemes"
 DSDS = "DataStructures"
 DATAFLOWS = "Dataflows"
 CONSTRAINTS = "Constraints"
@@ -99,6 +104,7 @@ CS_LOW = "concept_scheme"
 CON = "Concept"
 CON_LOW = "concept"
 DSD = "DataStructure"
+DSD_LOW = "datastructure"
 
 # DSD components
 DSD_COMPS = "DataStructureComponents"
@@ -119,17 +125,24 @@ ATT_LVL = "attachment_level"
 ATT_REL_LOW = "attribute_relationship"
 ATT_REL = "AttributeRelationship"
 AS_STATUS = "assignmentStatus"
+USAGE = "usage"
 MANDATORY = "Mandatory"
+MANDATORY_LOW = "mandatory"
 CONDITIONAL = "Conditional"
+OPTIONAL_LOW = "optional"
+ME_REL = "MeasureRelationship"
+OBSERVATION = "Observation"
 # Measure
 ME_LIST = "MeasureList"
 ME_LIST_LOW = "measure_list"
 MEASURE = "Measure"
 PRIM_MEASURE = "PrimaryMeasure"
+MEASURE_RELATIONSHIP = "MeasureRelationship"
 # Group Dimension
 GROUP = "Group"
 GROUP_DIM_LOW = "group_dimension_descriptor"
 GROUP_DIM = "GroupDimension"
+ATTACH_GROUP = "AttachmentGroup"
 DIM_REF = "DimensionReference"
 
 # Constraints
@@ -200,6 +213,7 @@ PAR_ID = "maintainableParentID"
 PAR_VER = "maintainableParentVersion"
 REL_TO = "relatedTo"
 NO_REL = "NoSpecifiedRelationship"
+METADATA = "Metadata"
 
 # To exclude from attached_attributes
 EXCLUDED_ATTRIBUTES = [STR_REF, "action", "dataScope", "xsi:type", SERIES, OBS]
@@ -238,15 +252,33 @@ DFWS = "Dataflows"
 DFWS_LOW = "dataflows"
 RULESETS = "Rulesets"
 RULE_SCHEME = "RulesetScheme"
+RULE_SCHEMES = "RulesetSchemes"
 RULE = "Ruleset"
 UDOS = "UserDefinedOperators"
 UDO_SCHEME = "UserDefinedOperatorScheme"
+UDO_SCHEMES = "UserDefinedOperatorSchemes"
 UDO = "UserDefinedOperator"
 TRANSFORMATIONS = "Transformations"
 TRANS_SCHEME = "TransformationScheme"
+TRANS_SCHEMES = "TransformationSchemes"
 TRANSFORMATION = "Transformation"
 VTLMAPPINGS = "VtlMappings"
+VTLMAPPING_SCHEMES = "VtlMappingSchemes"
 VTLMAPPING = "VtlMapping"
 VTL_DFW_MAPP = "VtlDataflowMapping"
+VTL_CL_MAPP = "VtlCodelistMapping"
+VTL_CON_MAPP = "VtlConceptMapping"
 VTL_MAPPING_SCHEME = "VtlMappingScheme"
 DFW_ALIAS_LOW = "dataflow_alias"
+NAME_PER_SCHEME = "NamePersonalisationScheme"
+NAME_PER_SCHEMES = "NamePersonalisationSchemes"
+NAME_PER = "NamePersonalisation"
+NAME_PERS = "NamePersonalisations"
+CUSTOM_TYPE_SCHEME = "CustomTypeScheme"
+CUSTOM_TYPE_SCHEMES = "CustomTypeSchemes"
+CUSTOM_TYPE = "CustomType"
+CUSTOM_TYPES = "CustomTypes"
+VALUE_LISTS = "ValueLists"
+VALUE_LIST = "ValueList"
+VALUE_LIST_LOW = "valuelist"
+VALUE_ITEM = "ValueItem"

pysdmx/io/xml/{sdmx21/writer/__write_aux.py → __write_aux.py}

@@ -8,21 +8,30 @@ from xml.sax.saxutils import escape
 
 from pysdmx.errors import Invalid, NotImplemented
 from pysdmx.io.format import Format
-from pysdmx.io.xml.sdmx21.__tokens import (
+from pysdmx.io.xml.__tokens import (
     ANNOTATIONS_LOW,
     CONTACTS_LOW,
+    CUSTOM_TYPE_SCHEMES,
+    CUSTOM_TYPES,
     DESC_LOW,
     DFW,
     DFWS_LOW,
     DSD,
+    NAME_PER_SCHEMES,
+    NAME_PERS,
+    PROV_AGREEMENT,
     PROV_AGREMENT,
+    RULE_SCHEMES,
     RULESETS,
     STR_USAGE,
     STRUCTURE,
+    TRANS_SCHEMES,
     TRANSFORMATIONS,
+    UDO_SCHEMES,
     UDOS,
     URI_LOW,
     URN_LOW,
+    VTLMAPPING_SCHEMES,
     VTLMAPPINGS,
 )
 from pysdmx.model import Organisation
@@ -36,6 +45,8 @@ MESSAGE_TYPE_MAPPING = {
     Format.STRUCTURE_SDMX_ML_2_1: "Structure",
     Format.ERROR_SDMX_ML_2_1: "Error",
     Format.REGISTRY_SDMX_ML_2_1: "RegistryInterface",
+    Format.DATA_SDMX_ML_3_0: "StructureSpecificData",
+    Format.STRUCTURE_SDMX_ML_3_0: "Structure",
 }
 
 ABBR_MSG = "mes"
@@ -47,26 +58,40 @@ ABBR_SPE = "ss"
 ANNOTATIONS = "Annotations"
 STRUCTURES = "Structures"
 ORGS = "OrganisationSchemes"
+AGC = "AgencySchemes"
 AGENCIES = "AgencyScheme"
 CODELISTS = "Codelists"
 CONCEPTS = "Concepts"
+CONCEPTS_SCHEMES = "ConceptSchemes"
 DSDS = "DataStructures"
 DATAFLOWS = "Dataflows"
 CONSTRAINTS = "Constraints"
 ALL_DIM = "AllDimensions"
 
-BASE_URL = "http://www.sdmx.org/resources/sdmxml/schemas/v2_1"
+BASE_URL_21 = "http://www.sdmx.org/resources/sdmxml/schemas/v2_1"
 
-NAMESPACES = {
+NAMESPACES_21 = {
     "xsi": "http://www.w3.org/2001/XMLSchema-instance",
-    ABBR_MSG: f"{BASE_URL}/message",
-    ABBR_GEN: f"{BASE_URL}/data/generic",
-    ABBR_COM: f"{BASE_URL}/common",
-    ABBR_STR: f"{BASE_URL}/structure",
-    ABBR_SPE: f"{BASE_URL}/data/structurespecific",
+    ABBR_MSG: f"{BASE_URL_21}/message",
+    ABBR_GEN: f"{BASE_URL_21}/data/generic",
+    ABBR_COM: f"{BASE_URL_21}/common",
+    ABBR_STR: f"{BASE_URL_21}/structure",
+    ABBR_SPE: f"{BASE_URL_21}/data/structurespecific",
+}
+
+BASE_URL_30 = "http://www.sdmx.org/resources/sdmxml/schemas/v3_0"
+
+NAMESPACES_30 = {
+    "xsi": "http://www.w3.org/2001/XMLSchema-instance",
+    ABBR_MSG: f"{BASE_URL_30}/message",
+    ABBR_COM: f"{BASE_URL_30}/common",
+    ABBR_STR: f"{BASE_URL_30}/structure",
+    ABBR_SPE: f"{BASE_URL_30}/data/structurespecific",
 }
 
 URN_DS_BASE = "urn:sdmx:org.sdmx.infomodel.datastructure.DataStructure="
+URN_PROVISION = "urn:sdmx:org.sdmx.infomodel.registry.ProvisionAgreement="
+URN_DFW = "urn:sdmx:org.sdmx.infomodel.datastructure.Dataflow="
 
 
 def __namespaces_from_type(type_: Format) -> str:
@@ -82,11 +107,15 @@ def __namespaces_from_type(type_: Format) -> str:
         NotImplemented: If the MessageType is not implemented
     """
     if type_ == Format.STRUCTURE_SDMX_ML_2_1:
-        return f"xmlns:{ABBR_STR}={NAMESPACES[ABBR_STR]!r} "
+        return f"xmlns:{ABBR_STR}={NAMESPACES_21[ABBR_STR]!r} "
     elif type_ == Format.DATA_SDMX_ML_2_1_STR:
-        return f"xmlns:{ABBR_SPE}={NAMESPACES[ABBR_SPE]!r} "
+        return f"xmlns:{ABBR_SPE}={NAMESPACES_21[ABBR_SPE]!r} "
     elif type_ == Format.DATA_SDMX_ML_2_1_GEN:
-        return f"xmlns:{ABBR_GEN}={NAMESPACES[ABBR_GEN]!r} "
+        return f"xmlns:{ABBR_GEN}={NAMESPACES_21[ABBR_GEN]!r} "
+    elif type_ == Format.DATA_SDMX_ML_3_0:
+        return f"xmlns:{ABBR_SPE}={NAMESPACES_30[ABBR_SPE]!r} "
+    elif type_ == Format.STRUCTURE_SDMX_ML_3_0:
+        return f"xmlns:{ABBR_STR}={NAMESPACES_30[ABBR_STR]!r} "
     else:
         raise NotImplemented(f"{type_} not implemented")
 
@@ -109,20 +138,34 @@ def create_namespaces(
     outfile = f'<?xml version="1.0" encoding="UTF-8"?>{nl}'
 
     outfile += f"<{ABBR_MSG}:{MESSAGE_TYPE_MAPPING[type_]} "
-    outfile += f'xmlns:xsi={NAMESPACES["xsi"]!r} '
-    outfile += f"xmlns:{ABBR_MSG}={NAMESPACES[ABBR_MSG]!r} "
-    outfile += __namespaces_from_type(type_)
-    outfile += (
-        f"xmlns:{ABBR_COM}={NAMESPACES[ABBR_COM]!r} "
-        f"{ss_namespaces}"
-        f'xsi:schemaLocation="{NAMESPACES[ABBR_MSG]} '
-        f'https://registry.sdmx.org/schemas/v2_1/SDMXMessage.xsd">'
-    )
+    if (
+        type_ == Format.DATA_SDMX_ML_3_0
+        or type_ == Format.STRUCTURE_SDMX_ML_3_0
+    ):
+        outfile += f"xmlns:xsi={NAMESPACES_30['xsi']!r} "
+        outfile += f"xmlns:{ABBR_MSG}={NAMESPACES_30[ABBR_MSG]!r} "
+        outfile += __namespaces_from_type(type_)
+        outfile += (
+            f"xmlns:{ABBR_COM}={NAMESPACES_30[ABBR_COM]!r} "
+            f"{ss_namespaces}"
+            f'xsi:schemaLocation="{NAMESPACES_30[ABBR_MSG]} '
+            f'https://registry.sdmx.org/schemas/v3_0/SDMXMessage.xsd">'
+        )
+    else:
+        outfile += f"xmlns:xsi={NAMESPACES_21['xsi']!r} "
+        outfile += f"xmlns:{ABBR_MSG}={NAMESPACES_21[ABBR_MSG]!r} "
+        outfile += __namespaces_from_type(type_)
+        outfile += (
+            f"xmlns:{ABBR_COM}={NAMESPACES_21[ABBR_COM]!r} "
+            f"{ss_namespaces}"
+            f'xsi:schemaLocation="{NAMESPACES_21[ABBR_MSG]} '
+            f'https://registry.sdmx.org/schemas/v2_1/SDMXMessage.xsd">'
+        )
 
     return outfile.replace("'", '"')
 
 
-MSG_CONTENT_PKG = OrderedDict(
+MSG_CONTENT_PKG_21 = OrderedDict(
     [
         (ORGS, "OrganisationSchemes"),
         (DATAFLOWS, "Dataflows"),
@@ -130,10 +173,30 @@ MSG_CONTENT_PKG = OrderedDict(
         (CONCEPTS, "Concepts"),
         (DSDS, "DataStructures"),
         (CONSTRAINTS, "ContentConstraints"),
+        (CUSTOM_TYPES, "CustomTypes"),
+        (VTLMAPPINGS, "VtlMappings"),
+        (NAME_PERS, "NamePersonalisations"),
         (RULESETS, "Rulesets"),
         (TRANSFORMATIONS, "Transformations"),
         (UDOS, "UserDefinedOperators"),
-        (VTLMAPPINGS, "VtlMappings"),
+    ]
+)
+
+
+MSG_CONTENT_PKG_30 = OrderedDict(
+    [
+        (AGC, "AgencySchemes"),
+        (DATAFLOWS, "Dataflows"),
+        (CODELISTS, "Codelists"),
+        (CONCEPTS_SCHEMES, "ConceptSchemes"),
+        (DSDS, "DataStructures"),
+        (CONSTRAINTS, "ContentConstraints"),
+        (CUSTOM_TYPE_SCHEMES, "CustomTypeSchemes"),
+        (VTLMAPPING_SCHEMES, "VtlMappingSchemes"),
+        (NAME_PER_SCHEMES, "NamePersonalisationSchemes"),
+        (RULE_SCHEMES, "RulesetSchemes"),
+        (TRANS_SCHEMES, "TransformationSchemes"),
+        (UDO_SCHEMES, "UserDefinedOperatorSchemes"),
     ]
 )
 
@@ -236,6 +299,7 @@ def __reference(
     nl: str,
     prettyprint: bool,
     add_namespace_structure: bool,
+    references_30: bool = False,
 ) -> str:
     child2 = "\t\t" if prettyprint else ""
     child3 = "\t\t\t" if prettyprint else ""
@@ -244,16 +308,49 @@ def __reference(
     reference = parse_short_urn(urn_structure)
     if reference.sdmx_type == DSD:
         structure_type = STRUCTURE
+        urn_type = URN_DS_BASE
     elif reference.sdmx_type == DFW:
         structure_type = STR_USAGE
+        urn_type = URN_DFW
     else:
-        structure_type = PROV_AGREMENT
+        structure_type = PROV_AGREEMENT if references_30 else PROV_AGREMENT
+        urn_type = URN_PROVISION
     if add_namespace_structure:
-        namespace = (
-            f"{URN_DS_BASE}={reference.agency}:{reference.id}"
-            f"({reference.version})"
-        )
+        if references_30:
+            namespace = (
+                f"{urn_type}{reference.agency}:{reference.id}"
+                f"({reference.version})"
+            )
+        else:
+            namespace = (
+                f"{URN_DS_BASE}{reference.agency}:{reference.id}"
+                f"({reference.version})"
+            )
+
         namespace = f"namespace={namespace!r} "
+    if references_30:
+        reference_str = (
+            f"{urn_type}{reference.agency}:{reference.id}({reference.version})"
+        )
+    else:
+        # Then the reference
+        reference_str = (
+            f"{nl}{child4}<Ref agencyID={reference.agency!r} "
+            f"id={reference.id!r} version={reference.version!r} "
+            f"class={reference.sdmx_type!r}/>"
+        )
+    if references_30:
+        common_structure = (
+            f"{nl}{child3}<{ABBR_COM}:{structure_type}>"
+            f"{reference_str}"
+            f"</{ABBR_COM}:{structure_type}>"
+        )
+    else:
+        common_structure = (
+            f"{nl}{child3}<{ABBR_COM}:{structure_type}>"
+            f"{reference_str}"
+            f"{nl}{child3}</{ABBR_COM}:{structure_type}>"
+        )
 
     return (
         # First the message structure
@@ -262,13 +359,7 @@ def __reference(
         f"{namespace}"
         f"dimensionAtObservation={dimension!r}>"
         # Then the common structure
-        f"{nl}{child3}<{ABBR_COM}:{structure_type}>"
-        # Then the reference
-        f"{nl}{child4}<Ref agencyID={reference.agency!r} "
-        f"id={reference.id!r} version={reference.version!r} "
-        f"class={reference.sdmx_type!r}/>"
-        # Close the common structure
-        f"{nl}{child3}</{ABBR_COM}:{structure_type}>"
+        f"{common_structure}"
         # Close the message structure
         f"{nl}{child2}</{ABBR_MSG}:Structure>"
     )
@@ -279,6 +370,7 @@ def __write_header(
     prettyprint: bool,
     add_namespace_structure: bool = False,
     data_message: bool = True,
+    references_30: bool = False,
 ) -> str:
     """Writes the Header part of the message.
 
@@ -287,6 +379,7 @@ def __write_header(
         prettyprint: Prettyprint or not
         add_namespace_structure: Add the namespace for the structure
         data_message: If the message is a data message
+        references_30: If the references are for SDMX 3.0
 
     Returns:
         The XML string
@@ -308,9 +401,7 @@ def __write_header(
             return ""
         child2 = "\t\t" if prettyprint else ""
         return (
-            f"{nl}{child2}<{ABBR_MSG}:{element}>"
-            f"{value}"
-            f"</{ABBR_MSG}:{element}>"
+            f"{nl}{child2}<{ABBR_MSG}:{element}>{value}</{ABBR_MSG}:{element}>"
         )
 
     nl = "\n" if prettyprint else ""
@@ -331,6 +422,7 @@ def __write_header(
                 nl,
                 prettyprint,
                 add_namespace_structure,
+                references_30,
             )
     if not data_message and (
         header.dataset_id or header.dataset_action or header.structure

pysdmx/io/xml/{sdmx21/writer/__write_data_aux.py → __write_data_aux.py}

@@ -4,7 +4,7 @@ import pandas as pd
 
 from pysdmx.errors import Invalid
 from pysdmx.io.pd import PandasDataset
-from pysdmx.io.xml.sdmx21.writer.__write_aux import ALL_DIM
+from pysdmx.io.xml.__write_aux import ALL_DIM
 from pysdmx.model import Role, Schema
 
 

pysdmx/io/xml/__write_structure_specific_aux.py

@@ -0,0 +1,254 @@
+# mypy: disable-error-code="union-attr"
+"""Module for writing SDMX-ML 3.0 Structure Specific auxiliary functions."""
+
+from typing import Any, Dict, List
+
+import pandas as pd
+
+from pysdmx.io.pd import PandasDataset
+from pysdmx.io.xml.__write_aux import (
+    ABBR_MSG,
+    ALL_DIM,
+    __escape_xml,
+    get_structure,
+)
+from pysdmx.io.xml.__write_data_aux import (
+    get_codes,
+    writing_validation,
+)
+from pysdmx.io.xml.config import CHUNKSIZE
+from pysdmx.util import parse_short_urn
+
+
+def __memory_optimization_writing(
+    dataset: PandasDataset, prettyprint: bool
+) -> str:
+    """Memory optimization for writing data."""
+    outfile = ""
+    length_ = len(dataset.data)
+    if len(dataset.data) > CHUNKSIZE:
+        previous = 0
+        next_ = CHUNKSIZE
+        while previous <= length_:
+            # Sliding a window for efficient access to the data
+            # and avoid memory issues
+            outfile += __obs_processing(
+                dataset.data.iloc[previous:next_], prettyprint
+            )
+            previous = next_
+            next_ += CHUNKSIZE
+
+            if next_ >= length_:
+                outfile += __obs_processing(
+                    dataset.data.iloc[previous:], prettyprint
+                )
+                previous = next_
+    else:
+        outfile += __obs_processing(dataset.data, prettyprint)
+
+    return outfile
+
+
+def __write_data_structure_specific(
+    datasets: Dict[str, PandasDataset],
+    dim_mapping: Dict[str, str],
+    prettyprint: bool = True,
+    references_30: bool = False,
+) -> str:
+    """Write data to SDMX-ML Structure-Specific format.
+
+    Args:
+        datasets: dict. Datasets to be written.
+        dim_mapping: dict. URN-DimensionAtObservation mapping.
+        prettyprint: bool. Prettyprint or not.
+        references_30: bool. Whether to use SDMX 3.0 references.
+
+    Returns:
+        The data in SDMX-ML Structure-Specific format, as string.
+    """
+    outfile = ""
+
+    for i, (short_urn, dataset) in enumerate(datasets.items()):
+        dataset.data = dataset.data.astype(str).replace(
+            {"nan": "", "<NA>": ""}
+        )
+        outfile += __write_data_single_dataset(
+            dataset=dataset,
+            prettyprint=prettyprint,
+            count=i + 1,
+            dim=dim_mapping[short_urn],
+            references_30=references_30,
+        )
+
+    return outfile
+
+
+def __write_data_single_dataset(
+    dataset: PandasDataset,
+    prettyprint: bool = True,
+    count: int = 1,
+    dim: str = ALL_DIM,
+    references_30: bool = False,
+) -> str:
+    """Write data to SDMX-ML Structure-Specific format.
+
+    Args:
+        dataset: PandasDataset. Dataset to be written.
+        prettyprint: bool. Prettyprint or not.
+        count: int. Count for namespace.
+        dim: str. Dimension to be written.
+        references_30: bool. Whether to use SDMX 3.0 references.
+
+    Returns:
+        The data in SDMX-ML Structure-Specific format, as string.
+    """
+
+    def __remove_optional_attributes_empty_data(str_to_check: str) -> str:
+        """This function removes data when optional attributes are found."""
+        for att in dataset.structure.components.attributes:
+            if not att.required:
+                str_to_check = str_to_check.replace(f"{att.id}='' ", "")
+                str_to_check = str_to_check.replace(f'{att.id}="" ', "")
+        return str_to_check
+
+    outfile = ""
+    structure_urn = get_structure(dataset)
+    id_structure = parse_short_urn(structure_urn).id
+    sdmx_type = parse_short_urn(structure_urn).id
+    # Remove nan values from DataFrame
+    dataset.data = dataset.data.fillna("").astype(str).replace("nan", "")
+
+    nl = "\n" if prettyprint else ""
+    child1 = "\t" if prettyprint else ""
+
+    attached_attributes_str = ""
+    for k, v in dataset.attributes.items():
+        attached_attributes_str += f"{k}={str(v)!r} "
+    datascope = ""
+    if not references_30:
+        datascope = f'ss:dataScope="{sdmx_type}" '
+    # Datasets
+    outfile += (
+        f"{nl}{child1}<{ABBR_MSG}:DataSet {attached_attributes_str}"
+        f"ss:structureRef={id_structure!r} "
+        f'xsi:type="ns{count}:DataSetType" '
+        f"{datascope}"
+        f'action="{dataset.action.value}">{nl}'
+    )
+    data = ""
+    if dim == ALL_DIM:
+        data += __memory_optimization_writing(dataset, prettyprint)
+    else:
+        writing_validation(dataset)
+        series_codes, obs_codes = get_codes(
+            dimension_code=dim,
+            structure=dataset.structure,  # type: ignore[arg-type]
+            data=dataset.data,
+        )
+
+        data += __series_processing(
+            data=dataset.data,
+            series_codes=series_codes,
+            obs_codes=obs_codes,
+            prettyprint=prettyprint,
+        )
+
+        # Remove optional attributes empty data
+        data = __remove_optional_attributes_empty_data(data)
+
+    # Adding to outfile
+    outfile += data
+
+    outfile += f"{child1}</{ABBR_MSG}:DataSet>"
+
+    return outfile.replace("'", '"')
+
+
+def __obs_processing(data: pd.DataFrame, prettyprint: bool = True) -> str:
+    def __format_obs_str(element: Dict[str, Any]) -> str:
+        """Formats the observation as key=value pairs."""
+        nl = "\n" if prettyprint else ""
+        child2 = "\t\t" if prettyprint else ""
+
+        out = f"{child2}<Obs "
+
+        for k, v in element.items():
+            out += f"{k}={__escape_xml(str(v))!r} "
+
+        out += f"/>{nl}"
+
+        return out
+
+    parser = lambda x: __format_obs_str(x)  # noqa: E731
+
+    iterator = map(parser, data.to_dict(orient="records"))
+
+    return "".join(iterator)
+
+
+def __series_processing(
+    data: pd.DataFrame,
+    series_codes: List[str],
+    obs_codes: List[str],
+    prettyprint: bool = True,
+) -> str:
+    def __generate_series_str() -> str:
+        """Generates the series item with its observations."""
+        out_list: List[str] = []
+        data.groupby(by=series_codes)[obs_codes].apply(
+            lambda x: __format_dict_ser(out_list, x)
+        )
+
+        return "".join(out_list)
+
+    def __format_dict_ser(
+        output_list: List[str],
+        obs: Any,
+    ) -> Any:
+        """Formats the series as key=value pairs."""
+        # Creating the observation dict,
+        # we always get the first element on Series
+        # as we are grouping by it
+        data_dict["Series"][0]["Obs"] = obs.to_dict(orient="records")
+        output_list.append(__format_ser_str(data_dict["Series"][0]))
+        # We remove the data for series as it is no longer necessary
+        del data_dict["Series"][0]
+
+    def __format_ser_str(data_info: Dict[Any, Any]) -> str:
+        """Formats the series as key=value pairs."""
+        child2 = "\t\t" if prettyprint else ""
+        child3 = "\t\t\t" if prettyprint else ""
+        nl = "\n" if prettyprint else ""
+
+        out_element = f"{child2}<Series "
+
+        for k, v in data_info.items():
+            if k != "Obs":
+                out_element += f"{k}={__escape_xml(str(v))!r} "
+
+        out_element += f">{nl}"
+
+        for obs in data_info["Obs"]:
+            out_element += f"{child3}<Obs "
+
+            for k, v in obs.items():
+                out_element += f"{k}={__escape_xml(str(v))!r} "
+
+            out_element += f"/>{nl}"
+
+        out_element += f"{child2}</Series>{nl}"
+
+        return out_element
+
+    # Getting each datapoint from data and creating dict
+    data = data.sort_values(series_codes, axis=0)
+    data_dict = {
+        "Series": data[series_codes]
+        .drop_duplicates()
+        .reset_index(drop=True)
+        .to_dict(orient="records")
+    }
+
+    out = __generate_series_str()
+
+    return out

pysdmx/io/xml/{sdmx21/reader/doc_validation.py → doc_validation.py}

@@ -3,11 +3,14 @@
 from io import BytesIO
 
 from lxml import etree
-from sdmxschemas import SDMX_ML_21_MESSAGE_PATH as SCHEMA_PATH
+from sdmxschemas import SDMX_ML_21_MESSAGE_PATH as SCHEMA_PATH_21
+from sdmxschemas import SDMX_ML_30_MESSAGE_PATH as SCHEMA_PATH_30
 
 from pysdmx.errors import Invalid
 from pysdmx.io.xml.__allowed_lxml_errors import ALLOWED_ERRORS_CONTENT
 
+SCHEMA_ROOT_30 = "http://www.sdmx.org/resources/sdmxml/schemas/v3_0/"
+
 
 def validate_doc(input_str: str) -> None:
     """Validates the SDMX-ML data against the XSD schema for SDMX-ML 2.1.
@@ -19,7 +22,12 @@ def validate_doc(input_str: str) -> None:
         Invalid: If the SDMX-ML data does not validate against the schema.
     """
     parser = etree.ETCompatXMLParser()
-    xmlschema_doc = etree.parse(SCHEMA_PATH)
+    check = input_str[:1000].lower()
+    if SCHEMA_ROOT_30 in check:
+        xmlschema_doc = etree.parse(SCHEMA_PATH_30)
+    else:
+        xmlschema_doc = etree.parse(SCHEMA_PATH_21)
+
     xmlschema = etree.XMLSchema(xmlschema_doc)
 
     bytes_infile = BytesIO(bytes(input_str, "UTF_8"))