pysdmx 1.6.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

pysdmx/io/json/sdmxjson2/messages/mpa.py

@@ -0,0 +1,88 @@
+"""Collection of SDMX-JSON schemas for provision agreements."""
+
+from typing import Sequence
+
+from msgspec import Struct
+
+from pysdmx import errors
+from pysdmx.io.json.sdmxjson2.messages.core import (
+    JsonAnnotation,
+    MaintainableType,
+)
+from pysdmx.model import Agency, MetadataProvisionAgreement
+
+
+class JsonMetadataProvisionAgreement(
+    MaintainableType, frozen=True, omit_defaults=True
+):
+    """SDMX-JSON payload for a metadata provision agreement."""
+
+    metadataflow: str = ""
+    metadataProvider: str = ""
+
+    def to_model(self) -> MetadataProvisionAgreement:
+        """Converts a FusionPA to a standard metadata provision agreement."""
+        return MetadataProvisionAgreement(
+            id=self.id,
+            agency=self.agency,
+            name=self.name,
+            description=self.description,
+            version=self.version,
+            valid_from=self.validFrom,
+            valid_to=self.validTo,
+            metadataflow=self.metadataflow,
+            metadata_provider=self.metadataProvider,
+            annotations=tuple([a.to_model() for a in self.annotations]),
+            is_external_reference=self.isExternalReference,
+        )
+
+    @classmethod
+    def from_model(
+        self, mpa: MetadataProvisionAgreement
+    ) -> "JsonMetadataProvisionAgreement":
+        """Converts a pysdmx metadata provision agreement to SDMX-JSON."""
+        if not mpa.name:
+            raise errors.Invalid(
+                "Invalid input",
+                "SDMX-JSON metadata provision agreements must have a name",
+                {"metadata_provision_agreement": mpa.id},
+            )
+        return JsonMetadataProvisionAgreement(
+            agency=(
+                mpa.agency.id if isinstance(mpa.agency, Agency) else mpa.agency
+            ),
+            id=mpa.id,
+            name=mpa.name,
+            version=mpa.version,
+            isExternalReference=mpa.is_external_reference,
+            validFrom=mpa.valid_from,
+            validTo=mpa.valid_to,
+            description=mpa.description,
+            annotations=tuple(
+                [JsonAnnotation.from_model(a) for a in mpa.annotations]
+            ),
+            metadataflow=mpa.metadataflow,
+            metadataProvider=mpa.metadata_provider,
+        )
+
+
+class JsonMetadataProvisionAgreements(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for provision agreements."""
+
+    metadataProvisionAgreements: Sequence[JsonMetadataProvisionAgreement]
+
+    def to_model(self) -> Sequence[MetadataProvisionAgreement]:
+        """Returns the requested metadata provision agreements."""
+        return [pa.to_model() for pa in self.metadataProvisionAgreements]
+
+
+class JsonMetadataProvisionAgreementsMessage(
+    Struct, frozen=True, omit_defaults=True
+):
+    """SDMX-JSON payload for /metadataprovisionagreement queries."""
+
+    data: JsonMetadataProvisionAgreements
+
+    def to_model(self) -> Sequence[MetadataProvisionAgreement]:
+        """Returns the requested metadata provision agreements."""
+        return self.data.to_model()

pysdmx/io/json/sdmxjson2/messages/msd.py

@@ -0,0 +1,241 @@
+"""Collection of SDMX-JSON schemas for SDMX-REST MSD queries."""
+
+from typing import List, Literal, Optional, Sequence, Union
+
+from msgspec import Struct
+
+from pysdmx import errors
+from pysdmx.io.json.sdmxjson2.messages.code import JsonCodelist, JsonValuelist
+from pysdmx.io.json.sdmxjson2.messages.concept import JsonConceptScheme
+from pysdmx.io.json.sdmxjson2.messages.core import (
+    JsonAnnotation,
+    JsonRepresentation,
+    MaintainableType,
+)
+from pysdmx.io.json.sdmxjson2.messages.dsd import (
+    _find_concept,
+    _get_concept_reference,
+    _get_json_representation,
+    _get_representation,
+)
+from pysdmx.model import (
+    Agency,
+    ArrayBoundaries,
+    Codelist,
+    MetadataComponent,
+    MetadataStructure,
+)
+from pysdmx.util import parse_item_urn
+
+
+class JsonMetadataAttribute(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for an attribute."""
+
+    id: str
+    conceptIdentity: str
+    minOccurs: int
+    maxOccurs: Union[int, Literal["unbounded"]]
+    isPresentational: bool
+    localRepresentation: Optional[JsonRepresentation] = None
+
+    def to_model(
+        self, cs: Sequence[JsonConceptScheme], cls: Sequence[Codelist]
+    ) -> MetadataComponent:
+        """Returns a metadata component."""
+        c = (
+            _find_concept(cs, self.conceptIdentity).to_model(cls)
+            if cs
+            else parse_item_urn(self.conceptIdentity)
+        )
+        dt, facets, codes, _ = _get_representation(
+            self.id, self.localRepresentation, cls, {}
+        )
+
+        if self.localRepresentation and self.localRepresentation.enumeration:
+            local_enum_ref = self.localRepresentation.enumeration
+        else:
+            local_enum_ref = None
+
+        if self.maxOccurs == "unbounded":
+            ab = ArrayBoundaries(self.minOccurs)
+        elif self.maxOccurs > 1:
+            ab = ArrayBoundaries(self.minOccurs, self.maxOccurs)
+        else:
+            ab = None
+
+        return MetadataComponent(
+            id=self.id,
+            is_presentational=self.isPresentational,
+            concept=c,
+            local_dtype=dt,
+            local_facets=facets,
+            local_codes=codes,
+            array_def=ab,
+            local_enum_ref=local_enum_ref,
+            components=(),
+        )
+
+    @classmethod
+    def from_model(self, cmp: MetadataComponent) -> "JsonMetadataAttribute":
+        """Converts a pysdmx metadata attribute to an SDMX-JSON one."""
+        concept = _get_concept_reference(cmp)
+        repr = _get_json_representation(cmp)
+
+        min_occurs = cmp.array_def.min_size if cmp.array_def else 0
+        if cmp.array_def is None or cmp.array_def.max_size is None:
+            max_occurs: Union[int, Literal["unbounded"]] = "unbounded"
+        else:
+            max_occurs = cmp.array_def.max_size
+
+        return JsonMetadataAttribute(
+            id=cmp.id,
+            conceptIdentity=concept,
+            localRepresentation=repr,
+            minOccurs=min_occurs,
+            maxOccurs=max_occurs,
+            isPresentational=cmp.is_presentational,
+        )
+
+
+class JsonMetadataAttributes(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for the list of metadata attributes."""
+
+    id: Literal["MetadataAttributeDescriptor"] = "MetadataAttributeDescriptor"
+    metadataAttributes: Sequence[JsonMetadataAttribute] = ()
+
+    def to_model(
+        self, cs: Sequence[JsonConceptScheme], cls: Sequence[Codelist]
+    ) -> List[MetadataComponent]:
+        """Returns the list of metadata attributes."""
+        return [a.to_model(cs, cls) for a in self.metadataAttributes]
+
+    @classmethod
+    def from_model(
+        self, attributes: Sequence[MetadataComponent]
+    ) -> "JsonMetadataAttributes":
+        """Converts a pysdmx list of metadata attributes to SDMX-JSON."""
+        return JsonMetadataAttributes(
+            metadataAttributes=[
+                JsonMetadataAttribute.from_model(a) for a in attributes
+            ]
+        )
+
+
+class JsonMetadataComponents(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for the list of DSD components."""
+
+    metadataAttributeList: Optional[JsonMetadataAttributes] = None
+
+    def to_model(
+        self,
+        cs: Sequence[JsonConceptScheme],
+        cls: Sequence[JsonCodelist],
+        vls: Sequence[JsonValuelist],
+    ) -> Sequence[MetadataComponent]:
+        """Returns the components for this DSD."""
+        enums = [cl.to_model() for cl in cls]
+        enums.extend([vl.to_model() for vl in vls])
+        comps = (
+            self.metadataAttributeList.to_model(cs, enums)
+            if self.metadataAttributeList
+            else []
+        )
+        return comps
+
+    @classmethod
+    def from_model(
+        self, components: Sequence[MetadataComponent]
+    ) -> "JsonMetadataComponents":
+        """Converts a pysdmx components list to an SDMX-JSON one."""
+        attributes = JsonMetadataAttributes.from_model(components)
+        return JsonMetadataComponents(metadataAttributeList=attributes)
+
+
+class JsonMetadataStructure(MaintainableType, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for a DSD."""
+
+    metadataStructureComponents: Optional[JsonMetadataComponents] = None
+
+    def to_model(
+        self,
+        cs: Sequence[JsonConceptScheme],
+        cls: Sequence[JsonCodelist],
+        vls: Sequence[JsonValuelist],
+    ) -> MetadataStructure:
+        """Map to pysdmx model class."""
+        c = self.metadataStructureComponents.to_model(  # type: ignore[union-attr]
+            cs,
+            cls,
+            vls,
+        )
+        return MetadataStructure(
+            id=self.id,
+            name=self.name,
+            agency=self.agency,
+            description=self.description,
+            version=self.version,
+            annotations=[a.to_model() for a in self.annotations],
+            is_external_reference=self.isExternalReference,
+            valid_from=self.validFrom,
+            valid_to=self.validTo,
+            components=c,
+        )
+
+    @classmethod
+    def from_model(self, msd: MetadataStructure) -> "JsonMetadataStructure":
+        """Converts a pysdmx MSD to an SDMX-JSON one."""
+        if not msd.name:
+            raise errors.Invalid(
+                "Invalid input",
+                "SDMX-JSON metadata structures must have a name",
+                {"metadata_structure": msd.id},
+            )
+
+        return JsonMetadataStructure(
+            agency=(
+                msd.agency.id if isinstance(msd.agency, Agency) else msd.agency
+            ),
+            id=msd.id,
+            name=msd.name,
+            version=msd.version,
+            isExternalReference=msd.is_external_reference,
+            validFrom=msd.valid_from,
+            validTo=msd.valid_to,
+            description=msd.description,
+            annotations=tuple(
+                [JsonAnnotation.from_model(a) for a in msd.annotations]
+            ),
+            metadataStructureComponents=JsonMetadataComponents.from_model(
+                msd.components
+            ),
+        )
+
+
+class JsonMetadataStructures(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for metadata structures."""
+
+    metadataStructures: Sequence[JsonMetadataStructure]
+    conceptSchemes: Sequence[JsonConceptScheme] = ()
+    valuelists: Sequence[JsonValuelist] = ()
+    codelists: Sequence[JsonCodelist] = ()
+
+    def to_model(self) -> Sequence[MetadataStructure]:
+        """Returns the requested msds."""
+        return [
+            msd.to_model(
+                self.conceptSchemes,
+                self.codelists,
+                self.valuelists,
+            )
+            for msd in self.metadataStructures
+        ]
+
+
+class JsonMetadataStructuresMessage(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for /metadatastructure queries."""
+
+    data: JsonMetadataStructures
+
+    def to_model(self) -> Sequence[MetadataStructure]:
+        """Returns the requested metadata structures."""
+        return self.data.to_model()

pysdmx/io/json/sdmxjson2/messages/provider.py

@@ -9,8 +9,18 @@ from pysdmx.io.json.sdmxjson2.messages.core import (
     ItemSchemeType,
     JsonAnnotation,
 )
+from pysdmx.io.json.sdmxjson2.messages.mpa import (
+    JsonMetadataProvisionAgreement,
+)
 from pysdmx.io.json.sdmxjson2.messages.pa import JsonProvisionAgreement
-from pysdmx.model import Agency, DataflowRef, DataProvider, DataProviderScheme
+from pysdmx.model import (
+    Agency,
+    DataflowRef,
+    DataProvider,
+    DataProviderScheme,
+    MetadataProvider,
+    MetadataProviderScheme,
+)
 from pysdmx.util import parse_item_urn, parse_urn
 
 
@@ -114,3 +124,109 @@ class JsonProviderMessage(Struct, frozen=True, omit_defaults=True):
     def to_model(self) -> Sequence[DataProviderScheme]:
         """Returns the requested list of data provider schemes."""
         return self.data.to_model()
+
+
+class JsonMetadataProviderScheme(
+    ItemSchemeType, frozen=True, omit_defaults=True
+):
+    """SDMX-JSON payload for a metadata provider scheme."""
+
+    metadataProviders: Sequence[MetadataProvider] = ()
+
+    def __get_df_ref(self, ref: str) -> DataflowRef:
+        a = parse_urn(ref)
+        return DataflowRef(id=a.id, agency=a.agency, version=a.version)
+
+    def to_model(
+        self, pas: Sequence[JsonMetadataProvisionAgreement]
+    ) -> MetadataProviderScheme:
+        """Converts a JsonMetadataProviderScheme to a pysdmx one."""
+        if pas:
+            paprs: Dict[str, Set[DataflowRef]] = defaultdict(set)
+            for pa in pas:
+                df = self.__get_df_ref(pa.metadataflow)
+                ref = parse_item_urn(pa.metadataProvider)
+                paprs[f"{ref.agency}:{ref.item_id}"].add(df)
+            provs = [
+                MetadataProvider(
+                    id=p.id,
+                    name=p.name,
+                    description=p.description,
+                    contacts=p.contacts,
+                    dataflows=list(paprs[f"{self.agency}:{p.id}"]),
+                    annotations=tuple(
+                        [a.to_model() for a in self.annotations]
+                    ),
+                )
+                for p in self.metadataProviders
+            ]
+        else:
+            provs = [
+                MetadataProvider(
+                    id=p.id,
+                    name=p.name,
+                    description=p.description,
+                    contacts=p.contacts,
+                    annotations=tuple(
+                        [a.to_model() for a in self.annotations]
+                    ),
+                )
+                for p in self.metadataProviders
+            ]
+        return MetadataProviderScheme(
+            agency=self.agency,
+            description=self.description,
+            items=provs,
+            annotations=[a.to_model() for a in self.annotations],
+            is_external_reference=self.isExternalReference,
+            is_partial=self.isPartial,
+            valid_from=self.validFrom,
+            valid_to=self.validTo,
+        )
+
+    @classmethod
+    def from_model(
+        self, dps: MetadataProviderScheme
+    ) -> "JsonMetadataProviderScheme":
+        """Converts a pysdmx metadata provider scheme to an SDMX-JSON one."""
+        return JsonMetadataProviderScheme(
+            id="METADATA_PROVIDERS",
+            name="METADATA_PROVIDERS",
+            agency=(
+                dps.agency.id if isinstance(dps.agency, Agency) else dps.agency
+            ),
+            description=dps.description,
+            version="1.0",
+            metadataProviders=dps.items,
+            annotations=tuple(
+                [JsonAnnotation.from_model(a) for a in dps.annotations]
+            ),
+            isExternalReference=dps.is_external_reference,
+            isPartial=dps.is_partial,
+            validFrom=dps.valid_from,
+            validTo=dps.valid_to,
+        )
+
+
+class JsonMetadataProviderSchemes(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for the list of metadata provider schemes."""
+
+    metadataProviderSchemes: Sequence[JsonMetadataProviderScheme]
+    metadataProvisionAgreements: Sequence[JsonMetadataProvisionAgreement] = ()
+
+    def to_model(self) -> Sequence[MetadataProviderScheme]:
+        """Converts a JsonMetadataProviderSchemes to the pysdmx model."""
+        return [
+            s.to_model(self.metadataProvisionAgreements)
+            for s in self.metadataProviderSchemes
+        ]
+
+
+class JsonMetadataProviderMessage(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for /metadataproviderscheme queries."""
+
+    data: JsonMetadataProviderSchemes
+
+    def to_model(self) -> Sequence[MetadataProviderScheme]:
+        """Returns the requested list of metadata provider schemes."""
+        return self.data.to_model()

pysdmx/io/json/sdmxjson2/messages/structure.py

@@ -24,8 +24,16 @@ from pysdmx.io.json.sdmxjson2.messages.map import (
     JsonRepresentationMap,
     JsonStructureMap,
 )
+from pysdmx.io.json.sdmxjson2.messages.metadataflow import JsonMetadataflow
+from pysdmx.io.json.sdmxjson2.messages.mpa import (
+    JsonMetadataProvisionAgreement,
+)
+from pysdmx.io.json.sdmxjson2.messages.msd import JsonMetadataStructure
 from pysdmx.io.json.sdmxjson2.messages.pa import JsonProvisionAgreement
-from pysdmx.io.json.sdmxjson2.messages.provider import JsonDataProviderScheme
+from pysdmx.io.json.sdmxjson2.messages.provider import (
+    JsonDataProviderScheme,
+    JsonMetadataProviderScheme,
+)
 from pysdmx.io.json.sdmxjson2.messages.vtl import (
     JsonCustomTypeScheme,
     JsonNamePersonalisationScheme,
@@ -50,8 +58,12 @@ class JsonStructures(Struct, frozen=True, omit_defaults=True):
     hierarchyAssociations: Sequence[JsonHierarchyAssociation] = ()
     agencySchemes: Sequence[JsonAgencyScheme] = ()
     dataProviderSchemes: Sequence[JsonDataProviderScheme] = ()
+    metadataProviderSchemes: Sequence[JsonMetadataProviderScheme] = ()
     dataflows: Sequence[JsonDataflow] = ()
     provisionAgreements: Sequence[JsonProvisionAgreement] = ()
+    metadataflows: Sequence[JsonMetadataflow] = ()
+    metadataProvisionAgreements: Sequence[JsonMetadataProvisionAgreement] = ()
+    metadataStructures: Sequence[JsonMetadataStructure] = ()
     structureMaps: Sequence[JsonStructureMap] = ()
     representationMaps: Sequence[JsonRepresentationMap] = ()
     categorisations: Sequence[JsonCategorisation] = ()
@@ -89,6 +101,14 @@ class JsonStructures(Struct, frozen=True, omit_defaults=True):
             i.to_model(self.provisionAgreements)
             for i in self.dataProviderSchemes
         )
+        structures.extend(
+            i.to_model(self.metadataProvisionAgreements)
+            for i in self.metadataProviderSchemes
+        )
+        structures.extend(
+            i.to_model(self.conceptSchemes, self.codelists, self.valueLists)
+            for i in self.metadataStructures
+        )
         structures.extend(
             i.to_model(
                 self.dataStructures,
@@ -99,6 +119,10 @@ class JsonStructures(Struct, frozen=True, omit_defaults=True):
             for i in self.dataflows
         )
         structures.extend(i.to_model() for i in self.provisionAgreements)
+        structures.extend(i.to_model() for i in self.metadataflows)
+        structures.extend(
+            i.to_model() for i in self.metadataProvisionAgreements
+        )
         structures.extend(
             i.to_model(self.representationMaps) for i in self.structureMaps
         )

pysdmx/io/json/sdmxjson2/reader/__init__.py

@@ -20,4 +20,9 @@ deserializers = Deserializers(
     mapping=msg.JsonMappingMessage,  # type: ignore[arg-type]
     code_map=msg.JsonRepresentationMapMessage,  # type: ignore[arg-type]
     transformation_scheme=msg.JsonTransfoMsg,  # type: ignore[arg-type]
+    metadataflows=msg.JsonMdfsMsg,  # type: ignore[arg-type]
+    metadata_provision_agreement=msg.JsonMPAMsg,  # type: ignore[arg-type]
+    metadata_providers=msg.JsonMetadataProviderMessage,  # type: ignore[arg-type]
+    msds=msg.JsonMetadataStructuresMessage,  # type: ignore[arg-type]
+    data_structures=msg.JsonDataStructuresMessage,  # type: ignore[arg-type]
 )

pysdmx/io/serde.py

@@ -41,6 +41,11 @@ class Deserializers:
     mapping: Deserializer
     code_map: Deserializer
     transformation_scheme: Deserializer
+    metadataflows: Deserializer
+    metadata_provision_agreement: Deserializer
+    metadata_providers: Deserializer
+    msds: Deserializer
+    data_structures: Deserializer
 
 
 @dataclass

pysdmx/io/writer.py

@@ -19,11 +19,9 @@ WRITERS = {
     Format.DATA_SDMX_ML_2_1_STR: "pysdmx.io.xml.sdmx21.writer."
     "structure_specific",
     Format.STRUCTURE_SDMX_ML_2_1: "pysdmx.io.xml.sdmx21.writer.structure",
-    Format.DATA_SDMX_ML_3_0: "pysdmx.io.xml.sdmx30.writer."
-    "structure_specific",
+    Format.DATA_SDMX_ML_3_0: "pysdmx.io.xml.sdmx30.writer.structure_specific",
     Format.STRUCTURE_SDMX_ML_3_0: "pysdmx.io.xml.sdmx30.writer.structure",
-    Format.DATA_SDMX_ML_3_1: "pysdmx.io.xml.sdmx31.writer."
-    "structure_specific",
+    Format.DATA_SDMX_ML_3_1: "pysdmx.io.xml.sdmx31.writer.structure_specific",
     Format.STRUCTURE_SDMX_ML_3_1: "pysdmx.io.xml.sdmx31.writer.structure",
     Format.STRUCTURE_SDMX_JSON_2_0_0: (
         "pysdmx.io.json.sdmxjson2.writer.structure"

pysdmx/io/xml/__ss_aux_reader.py

@@ -30,8 +30,7 @@ def _reading_str_series(dataset: Dict[str, Any]) -> pd.DataFrame:
         if OBS in data:
             del keys[OBS]
             data[OBS] = add_list(data[OBS])
-            for j in data[OBS]:
-                test_list.append({**keys, **j})
+            test_list.extend([{**keys, **j} for j in data[OBS]])
         else:
             test_list.append(keys)
         test_list, df = __process_df(test_list, df)

pysdmx/io/xml/__structure_aux_reader.py

@@ -397,7 +397,7 @@ class StructureParser(Struct):
         """
         if json_fac is None:
             return
-        for key, _value in json_fac.items():
+        for key in json_fac:
             if key == TEXT_TYPE and json_fac[TEXT_TYPE] in list(DataType):
                 json_obj["dtype"] = DataType(json_fac[TEXT_TYPE])
 
@@ -907,9 +907,9 @@ class StructureParser(Struct):
         item_json_info = self.__format_name_description(item_json_info)
         if CONTACT in item_json_info and item_name_class == AGENCY:
             item_json_info[CONTACT] = add_list(item_json_info[CONTACT])
-            contacts = []
-            for e in item_json_info[CONTACT]:
-                contacts.append(self.__format_contact(e))
+            contacts = [
+                self.__format_contact(e) for e in item_json_info[CONTACT]
+            ]
             item_json_info[CONTACT.lower() + "s"] = contacts
             del item_json_info[CONTACT]
 
@@ -949,9 +949,11 @@ class StructureParser(Struct):
                         group_dimensions = [group_dimensions]
 
                     group["dimensions"] = [
-                        d[DIM_REF]
-                        if isinstance(d[DIM_REF], str)
-                        else d[DIM_REF][REF][ID]
+                        (
+                            d[DIM_REF]
+                            if isinstance(d[DIM_REF], str)
+                            else d[DIM_REF][REF][ID]
+                        )
                         for d in group_dimensions
                     ]
 
@@ -994,9 +996,12 @@ class StructureParser(Struct):
             items = []
             if item in element:
                 element[item] = add_list(element[item])
-                for item_elem in element[item]:
-                    # Dynamic
-                    items.append(self.__format_item(item_elem, item))
+                items.extend(
+                    [
+                        self.__format_item(item_elem, item)
+                        for item_elem in element[item]
+                    ]
+                )
                 del element[item]
             element["items"] = items
             element = self.__format_agency(element)

pysdmx/io/xml/__structure_aux_writer.py

@@ -462,7 +462,7 @@ def __write_components(  # noqa: C901
         )
 
     position = 1
-    for _, comps in components.items():
+    for comps in components.values():
         if comps:
             role_name = ROLE_MAPPING[comps[0].role]
             if role_name == MEASURE:
@@ -1129,9 +1129,11 @@ def _write_vtl(  # noqa: C901
             ref_codelist = (
                 item_or_scheme.codelist
                 if isinstance(item_or_scheme.codelist, Reference)
-                else parse_urn(item_or_scheme.codelist)
-                if isinstance(item_or_scheme.codelist, str)
-                else parse_short_urn(item_or_scheme.codelist.short_urn)
+                else (
+                    parse_urn(item_or_scheme.codelist)
+                    if isinstance(item_or_scheme.codelist, str)
+                    else parse_short_urn(item_or_scheme.codelist.short_urn)
+                )
             )
             if references_30:
                 data += (

pysdmx/io/xml/__write_data_aux.py

@@ -33,8 +33,7 @@ def check_dimension_at_observation(
         dimension_codes = [dim.id for dim in components.dimensions]
         if value not in dimension_codes:
             raise Invalid(
-                f"Dimension at observation {value} "
-                f"not found in dataset {key}."
+                f"Dimension at observation {value} not found in dataset {key}."
             )
     # Add the missing datasets on mapping with ALL_DIM
     for key in datasets:
@@ -54,13 +53,15 @@ def writing_validation(dataset: PandasDataset) -> None:
         for comp in dataset.structure.components
         if comp.role in (Role.DIMENSION, Role.MEASURE)
     ]
-    for att in dataset.structure.components.attributes:
+    required_components.extend(
+        att.id
+        for att in dataset.structure.components.attributes
         if (
             att.required
             and att.attachment_level is not None
             and att.attachment_level != "D"
-        ):
-            required_components.append(att.id)
+        )
+    )
     non_required = [
         comp.id
         for comp in dataset.structure.components

pysdmx/io/xml/__write_structure_specific_aux.py

@@ -198,8 +198,12 @@ def __group_processing(
             .to_dict(orient="records")
         )
 
-        for record in grouped_data:
-            out_list.append(__format_group_str(record, group["group_id"]))
+        out_list.extend(
+            [
+                __format_group_str(record, group["group_id"])
+                for record in grouped_data
+            ]
+        )
 
     return "".join(out_list)