pysdmx 1.10.1__py3-none-any.whl → 1.12.0__py3-none-any.whl

pysdmx/io/xml/__structure_aux_reader.py

@@ -1,9 +1,10 @@
 """Parsers for reading metadata."""
 
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, Sequence, Union
+from typing import Any, Callable, Dict, List, Optional, Sequence, Type, Union
 
 from msgspec import Struct
+from msgspec.structs import asdict
 
 from pysdmx.io.xml.__tokens import (
     AGENCIES,
@@ -29,6 +30,8 @@ from pysdmx.io.xml.__tokens import (
     CLS,
     CODE,
     CODES_LOW,
+    COMPONENT_MAP,
+    COMPONENT_MAPS,
     COMPS,
     CON,
     CON_ID,
@@ -44,6 +47,7 @@ from pysdmx.io.xml.__tokens import (
     CUSTOM_TYPE_SCHEMES,
     CUSTOM_TYPES,
     DATA_PROV,
+    DATE_PATTERN_MAP,
     DEPARTMENT,
     DESC,
     DFW,
@@ -64,6 +68,8 @@ from pysdmx.io.xml.__tokens import (
     FACETS,
     FAX,
     FAXES,
+    FIXED_VALUE_MAP,
+    FIXED_VALUE_MAPS,
     GROUP,
     GROUP_DIM,
     GROUPS_LOW,
@@ -98,6 +104,8 @@ from pysdmx.io.xml.__tokens import (
     PROV_AGREEMENT,
     PROV_AGREEMENTS,
     REF,
+    REPRESENTATION_MAP,
+    REPRESENTATION_MAPS,
     REQUIRED,
     ROLE,
     RULE,
@@ -110,6 +118,8 @@ from pysdmx.io.xml.__tokens import (
     STR_URL_LOW,
     STR_USAGE,
     STRUCTURE,
+    STRUCTURE_MAP,
+    STRUCTURE_MAPS,
     TELEPHONE,
     TELEPHONES,
     TEXT,
@@ -152,10 +162,19 @@ from pysdmx.model import (
     AgencyScheme,
     Code,
     Codelist,
+    ComponentMap,
     Concept,
     ConceptScheme,
     DataType,
+    DatePatternMap,
     Facets,
+    FixedValueMap,
+    ImplicitComponentMap,
+    MultiComponentMap,
+    MultiValueMap,
+    RepresentationMap,
+    StructureMap,
+    ValueMap,
     VtlCodelistMapping,
     VtlConceptMapping,
 )
@@ -207,6 +226,11 @@ STRUCTURES_MAPPING = {
     UDO_SCHEME: UserDefinedOperatorScheme,
     TRANS_SCHEME: TransformationScheme,
     VTL_MAPPING_SCHEME: VtlMappingScheme,
+    STRUCTURE_MAP: StructureMap,
+    COMPONENT_MAP: ComponentMap,
+    FIXED_VALUE_MAP: FixedValueMap,
+    DATE_PATTERN_MAP: DatePatternMap,
+    REPRESENTATION_MAP: RepresentationMap,
     NAME_PER_SCHEME: NamePersonalisationScheme,
     CUSTOM_TYPE_SCHEME: CustomTypeScheme,
     PROV_AGREEMENTS: ProvisionAgreement,
@@ -308,6 +332,10 @@ class StructureParser(Struct):
     rulesets: Dict[str, RulesetScheme] = {}
     udos: Dict[str, UserDefinedOperatorScheme] = {}
     vtl_mappings: Dict[str, VtlMappingScheme] = {}
+    structure_maps: Dict[str, StructureMap] = {}
+    component_maps: Dict[str, ComponentMap] = {}
+    fixed_value_maps: Dict[str, FixedValueMap] = {}
+    representation_maps: Dict[str, RepresentationMap] = {}
     name_personalisations: Dict[str, NamePersonalisationScheme] = {}
     custom_types: Dict[str, CustomTypeScheme] = {}
     transformations: Dict[str, TransformationScheme] = {}
@@ -529,16 +557,11 @@ class StructureParser(Struct):
         if FACETS.lower() in rep:
             representation_info[LOCAL_FACETS_LOW] = rep.pop(FACETS.lower())
 
-    def __format_con_id(self, concept_ref: Dict[str, Any]) -> Dict[str, Any]:
-        rep = {}
+    def __format_con_id(
+        self, concept_ref: Union[str, Dict[str, Any]]
+    ) -> Dict[str, Any]:
         if isinstance(concept_ref, str):
             item_reference = parse_urn(concept_ref)
-            scheme_reference = Reference(
-                sdmx_type=CS,
-                agency=item_reference.agency,
-                id=item_reference.id,
-                version=item_reference.version,
-            )
         else:
             item_reference = ItemReference(
                 sdmx_type=concept_ref[CLASS],
@@ -547,27 +570,44 @@ class StructureParser(Struct):
                 version=concept_ref[PAR_VER],
                 item_id=concept_ref[ID],
             )
-            scheme_reference = Reference(
-                sdmx_type=CS,
-                agency=concept_ref[AGENCY_ID],
-                id=concept_ref[PAR_ID],
-                version=concept_ref[PAR_VER],
-            )
+        scheme_reference = Reference(
+            sdmx_type=CS,
+            agency=item_reference.agency,
+            id=item_reference.id,
+            version=item_reference.version,
+        )
 
         concept_scheme = self.concepts.get(str(scheme_reference))
+
         if concept_scheme is None:
             return {CON: item_reference}
+
+        short_urn = str(item_reference)
         for con in concept_scheme.concepts:
-            if isinstance(concept_ref, str):
-                if con.id == item_reference.item_id:
-                    rep[CON] = parse_urn(concept_ref)
-                    break
-            elif con.id == concept_ref[ID]:
-                rep[CON] = con
-                break
-        if CON not in rep:
-            return {CON: item_reference}
-        return rep
+            con_short = str(
+                ItemReference(
+                    sdmx_type=item_reference.sdmx_type,
+                    agency=item_reference.agency,
+                    id=item_reference.id,
+                    version=item_reference.version,
+                    item_id=con.id,
+                )
+            )
+
+            if con_short == short_urn:
+                if con.urn is None:
+                    con = Concept(
+                        **{
+                            **asdict(con),
+                            "urn": (
+                                "urn:sdmx:org.sdmx.infomodel.conceptscheme."
+                                f"{short_urn}"
+                            ),
+                        }
+                    )
+                return {CON: con}
+
+        return {CON: item_reference}
 
     @staticmethod
     def __get_attachment_level(  # noqa: C901
@@ -751,6 +791,11 @@ class StructureParser(Struct):
             del comp[ATT_REL]
 
         if ME_REL in comp:
+            measures = add_list(comp[ME_REL][MSR])
+            if len(measures) == 1 and measures[0] == "OBS_VALUE":
+                comp[ATT_LVL] = "O"
+            else:
+                comp[ATT_LVL] = ",".join(measures)
             del comp[ME_REL]
 
         if AS_STATUS in comp or USAGE in comp:
@@ -762,14 +807,10 @@ class StructureParser(Struct):
                 comp[REQUIRED] = False
             del comp[status_key]
 
-        if "position" in comp:
-            del comp["position"]
-
-        if ANNOTATIONS in comp:
-            del comp[ANNOTATIONS]
-
-        if CON_ROLE in comp:
-            del comp[CON_ROLE]
+        unwanted_keys = ["position", ANNOTATIONS, CON_ROLE]
+        for key in unwanted_keys:
+            if key in comp:
+                del comp[key]
 
         return Component(**comp)
 
@@ -1035,6 +1076,124 @@ class StructureParser(Struct):
             )
         return json_elem
 
+    def __build_component_map(
+        self, child_dict: Dict[str, Any]
+    ) -> Union[ComponentMap, MultiComponentMap, ImplicitComponentMap]:
+        if "values" not in child_dict:
+            return ImplicitComponentMap(
+                source=child_dict["source"],
+                target=child_dict["target"],
+            )
+
+        src_list = add_list(child_dict.get("source"))
+        tgt_list = add_list(child_dict.get("target"))
+
+        if len(src_list) != 1 or len(tgt_list) != 1:
+            return MultiComponentMap(
+                source=src_list,
+                target=tgt_list,
+                values=child_dict["values"],
+            )
+
+        return ComponentMap(
+            source=src_list[0],
+            target=tgt_list[0],
+            values=child_dict["values"],
+        )
+
+    def __build_representation_mapping(
+        self, child_dict: Dict[str, Any]
+    ) -> Union[ValueMap, MultiValueMap]:
+        src = child_dict.get("source")
+        tgt = child_dict.get("target")
+
+        src_list = add_list(src) if src is not None else []
+        tgt_list = add_list(tgt) if tgt is not None else []
+
+        if len(src_list) != 1 or len(tgt_list) != 1:
+            return MultiValueMap(
+                source=src_list,
+                target=tgt_list,
+                valid_from=child_dict.get("valid_from"),
+                valid_to=child_dict.get("valid_to"),
+            )
+
+        return ValueMap(
+            source=src_list[0],
+            target=tgt_list[0],
+            valid_from=child_dict.get("valid_from"),
+            valid_to=child_dict.get("valid_to"),
+        )
+
+    def __format_maps(self, element: Dict[str, Any]) -> Dict[str, Any]:
+        if "sourcePattern" in element:
+            element["pattern_type"] = (
+                # DatePatternMap.pattern_type defaults value is fixed
+                "variable" if "FrequencyDimension" in element else "fixed"
+            )
+
+        renames = {
+            "Source": "source",
+            "Target": "target",
+            "Value": "value",
+            "SourceCodelist": "source",
+            "TargetCodelist": "target",
+            "SourceValue": "source",
+            "TargetValue": "target",
+            "RepresentationMap": "values",
+            "sourcePattern": "pattern",
+            "resolvePeriod": "resolve_period",
+            "TargetFrequencyID": "frequency",
+            "FrequencyDimension": "frequency",
+            "validFrom": "valid_from",
+            "validTo": "valid_to",
+        }
+
+        for xml_key, py_key in renames.items():
+            if xml_key in element:
+                element[py_key] = element.pop(xml_key)
+
+        child_class_mapping: Dict[str, Type[Any]] = {
+            "ComponentMap": ComponentMap,
+            "FixedValueMap": FixedValueMap,
+            "DatePatternMap": DatePatternMap,
+            "RepresentationMapping": ValueMap,
+        }
+
+        MapChild = Union[
+            ComponentMap,
+            MultiComponentMap,
+            ImplicitComponentMap,
+            FixedValueMap,
+            DatePatternMap,
+            ValueMap,
+            MultiValueMap,
+        ]
+        consolidated_children: List[MapChild] = []
+
+        for xml_tag, target_class in child_class_mapping.items():
+            if xml_tag not in element:
+                continue
+
+            for child_dict in add_list(element.pop(xml_tag)):
+                self.__format_maps(child_dict)
+
+                if xml_tag == "ComponentMap":
+                    consolidated_children.append(
+                        self.__build_component_map(child_dict)
+                    )
+                elif xml_tag == "RepresentationMapping":
+                    consolidated_children.append(
+                        self.__build_representation_mapping(child_dict)
+                    )
+                else:
+                    consolidated_children.append(target_class(**child_dict))
+
+        if consolidated_children:
+            element["maps"] = consolidated_children
+
+        return element
+
     def __format_scheme(
         self, json_elem: Dict[str, Any], scheme: str, item: str
     ) -> Dict[str, ItemScheme]:
@@ -1116,6 +1275,7 @@ class StructureParser(Struct):
             element = self.__format_validity(element)
             element = self.__format_groups(element)
             element = self.__format_components(element)
+            element = self.__format_maps(element)
             if item == PROV_AGREEMENT:
                 element = self.__format_prov_agreement(element)
 
@@ -1300,6 +1460,34 @@ class StructureParser(Struct):
                 ),
                 "transformations",
             ),
+            STRUCTURE_MAPS: process_structure(
+                STRUCTURE_MAPS,
+                lambda data: self.__format_schema(
+                    data, STRUCTURE_MAP, STRUCTURE_MAP
+                ),
+                "structure_maps",
+            ),
+            COMPONENT_MAPS: process_structure(
+                COMPONENT_MAPS,
+                lambda data: self.__format_schema(
+                    data, COMPONENT_MAP, COMPONENT_MAP
+                ),
+                "component_maps",
+            ),
+            FIXED_VALUE_MAPS: process_structure(
+                FIXED_VALUE_MAPS,
+                lambda data: self.__format_schema(
+                    data, FIXED_VALUE_MAP, FIXED_VALUE_MAP
+                ),
+                "fixed_value_maps",
+            ),
+            REPRESENTATION_MAPS: process_structure(
+                REPRESENTATION_MAPS,
+                lambda data: self.__format_schema(
+                    data, REPRESENTATION_MAP, REPRESENTATION_MAP
+                ),
+                "representation_maps",
+            ),
             TRANS_SCHEMES: process_structure(
                 TRANS_SCHEMES,
                 lambda data: self.__format_scheme(