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

pysdmx/io/xml/doc_validation.py

@@ -39,9 +39,7 @@ def validate_doc(input_str: str) -> None:
     doc = etree.parse(bytes_infile, parser=parser)
     if not xmlschema.validate(doc):
         log_errors = list(xmlschema.error_log)  # type: ignore[call-overload]
-        unhandled_errors = []
-        for e in log_errors:
-            unhandled_errors.append(e.message)
+        unhandled_errors = [e.message for e in log_errors]
         severe_errors = unhandled_errors.copy()
         for e in unhandled_errors:
             for allowed_error in ALLOWED_ERRORS_CONTENT:

pysdmx/io/xml/sdmx21/writer/generic.py

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

pysdmx/model/__init__.py

@@ -53,7 +53,14 @@ from pysdmx.model.map import (
     StructureMap,
     ValueMap,
 )
-from pysdmx.model.metadata import MetadataAttribute, MetadataReport
+from pysdmx.model.metadata import (
+    MetadataAttribute,
+    MetadataComponent,
+    Metadataflow,
+    MetadataProvisionAgreement,
+    MetadataReport,
+    MetadataStructure,
+)
 from pysdmx.model.organisation import (
     AgencyScheme,
     DataConsumerScheme,
@@ -131,9 +138,7 @@ def decoders(type: Type, obj: Any) -> Any:  # type: ignore[type-arg]
             target types
     """
     if type is Components:
-        comps = []
-        for item in obj:
-            comps.append(msgspec.convert(item, Component))
+        comps = [msgspec.convert(item, Component) for item in obj]
         return Components(comps)
     else:
         raise NotImplementedError(f"Objects of type {type} are not supported")
@@ -176,9 +181,13 @@ __all__ = [
     "ImplicitComponentMap",
     "ItemReference",
     "MetadataAttribute",
+    "MetadataComponent",
+    "Metadataflow",
     "MetadataProvider",
     "MetadataProviderScheme",
+    "MetadataProvisionAgreement",
     "MetadataReport",
+    "MetadataStructure",
     "MultiComponentMap",
     "MultiRepresentationMap",
     "MultiValueMap",

pysdmx/model/dataflow.py

@@ -116,6 +116,7 @@ class Component(
         id: A unique identifier for the component (e.g. FREQ).
         required: Whether the component must have a value.
         role: The role played by the component.
+        concept: The concept giving its identity to the component.
         local_dtype: The component's local data type (string, number, etc.).
         local_facets: Additional local details such as the component's minimum
             length.

pysdmx/model/map.py

@@ -500,12 +500,12 @@ class StructureMap(MaintainableArtefact, frozen=True, omit_defaults=True):
         ]
     ]:
         """Return the mapping rules for the supplied component."""
-        out = []
-        for m in self.maps:
-            if (
-                hasattr(m, "source") and (m.source == id_ or id_ in m.source)
-            ) or (isinstance(m, FixedValueMap) and m.target == id_):
-                out.append(m)
+        out = [
+            m
+            for m in self.maps
+            if (hasattr(m, "source") and (m.source == id_ or id_ in m.source))
+            or (isinstance(m, FixedValueMap) and m.target == id_)
+        ]
         if len(out) == 0:
             return None
         else:

pysdmx/model/message.py

@@ -34,8 +34,17 @@ from pysdmx.model.map import (
     RepresentationMap,
     StructureMap,
 )
-from pysdmx.model.metadata import MetadataReport
-from pysdmx.model.organisation import AgencyScheme, DataProviderScheme
+from pysdmx.model.metadata import (
+    Metadataflow,
+    MetadataProvisionAgreement,
+    MetadataReport,
+    MetadataStructure,
+)
+from pysdmx.model.organisation import (
+    AgencyScheme,
+    DataProviderScheme,
+    MetadataProviderScheme,
+)
 from pysdmx.model.submission import SubmissionResult
 from pysdmx.model.vtl import (
     CustomTypeScheme,
@@ -168,10 +177,7 @@ class StructureMessage(Struct, repr_omit_defaults=True, frozen=True):
             raise NotFound(
                 f"No {type_.__name__} found in message.",
             )
-        structures = []
-        for element in self.structures:
-            if isinstance(element, type_):
-                structures.append(element)
+        structures = [e for e in self.structures if isinstance(e, type_)]
         return structures
 
     def __get_enumerations(
@@ -224,6 +230,10 @@ class StructureMessage(Struct, repr_omit_defaults=True, frozen=True):
         """Returns the Dataflows."""
         return self.__get_elements(Dataflow)
 
+    def get_metadataflows(self) -> List[Metadataflow]:
+        """Returns the MetadataProvisionAgreements."""
+        return self.__get_elements(Metadataflow)
+
     def get_organisation_scheme(self, short_urn: str) -> AgencyScheme:
         """Returns a specific OrganisationScheme."""
         return self.__get_single_structure(AgencyScheme, short_urn)
@@ -284,6 +294,20 @@ class StructureMessage(Struct, repr_omit_defaults=True, frozen=True):
         """Returns the ProvisionAgreements."""
         return self.__get_elements(ProvisionAgreement)
 
+    def get_metadata_provider_schemes(self) -> List[MetadataProviderScheme]:
+        """Returns the MetadataProviderSchemes."""
+        return self.__get_elements(MetadataProviderScheme)
+
+    def get_metadata_provision_agreements(
+        self,
+    ) -> List[MetadataProvisionAgreement]:
+        """Returns the MetadataProvisionAgreements."""
+        return self.__get_elements(MetadataProvisionAgreement)
+
+    def get_metadata_structures(self) -> List[MetadataStructure]:
+        """Returns the MetadataStructures."""
+        return self.__get_elements(MetadataStructure)
+
     def get_structure_maps(self) -> List[StructureMap]:
         """Returns the StructureMaps."""
         return self.__get_elements(StructureMap)

pysdmx/model/metadata.py

@@ -9,21 +9,272 @@ example by providing configuration details in a metadata report.
 """
 
 from collections import defaultdict
-from typing import Any, Dict, Iterator, List, Optional, Sequence
+from typing import Any, Dict, Iterator, List, Optional, Sequence, Union
 
 from msgspec import Struct
 
-from pysdmx.model.__base import Annotation, MaintainableArtefact
-from pysdmx.model.concept import Facets
+from pysdmx.model.__base import (
+    Annotation,
+    IdentifiableArtefact,
+    ItemReference,
+    MaintainableArtefact,
+    Reference,
+)
+from pysdmx.model.code import Codelist, Hierarchy
+from pysdmx.model.concept import Concept, DataType, Facets
+from pysdmx.model.dataflow import ArrayBoundaries
 from pysdmx.model.dataset import ActionType
 
 
+class MetadataComponent(
+    IdentifiableArtefact, frozen=True, omit_defaults=True, kw_only=True
+):
+    """A component defines the expected structure of a metadata attribute.
+
+    The metadata component takes its semantic, and in some cases it
+    representation, from its concept identity. A metadata component
+    may be coded (via the local representation), uncoded (via the text
+    format), or take no value. In addition to this value, the metadata
+    component may also specify subordinate metadata components.
+
+    If a metadata component only serves the purpose of containing
+    subordinate metadata components, then the is_presentational attribute
+    should be set to True. Otherwise, it is assumed to also take a value.
+
+    If the metadata component does take a value, and a representation is
+    not defined, it will be inherited from the concept it takes its
+    semantic from. The optional id on the metadata component uniquely
+    identifies it within the metadata structured definition.
+
+    If this id is not supplied, its value is assumed to be that of the
+    concept referenced from the concept identity. Note that a metadata
+    component (as identified by the id attribute) definition must be
+    unique across the entire metadata structure definition.
+
+    Attributes:
+        id: The identifier of the component.
+        is_presentational: Whether the component is for presentation
+            purposes only (e.g. a section header), or may contain a
+            value.
+        concept: The concept giving its identity to the component.
+        local_dtype: The component's local data type (string, number, etc.).
+        local_facets: Additional local details such as the component's minimum
+            length.
+        local_codes: The expected local values for the component (e.g. currency
+            codes).
+        array_def: Any additional constraints for array types.
+        local_enum_ref: The URN of the enumeration (codelist or valuelist) from
+            which the local codes are taken.
+    """
+
+    is_presentational: bool = False
+    concept: Union[Concept, ItemReference]
+    local_dtype: Optional[DataType] = None
+    local_facets: Optional[Facets] = None
+    local_codes: Union[Codelist, Hierarchy, None] = None
+    array_def: Optional[ArrayBoundaries] = None
+    local_enum_ref: Optional[str] = None
+    components: Sequence["MetadataComponent"] = ()
+
+    @property
+    def dtype(self) -> DataType:
+        """Returns the component data type.
+
+        This will return the local data type (if any) or
+        the data type of the referenced concept (if any).
+        In case neither are set, the data type will default
+        to string.
+
+        Returns:
+            The component data type (local, core or default).
+        """
+        if self.local_dtype:
+            return self.local_dtype
+        elif isinstance(self.concept, Concept) and self.concept.dtype:
+            return self.concept.dtype
+        else:
+            return DataType.STRING
+
+    @property
+    def facets(self) -> Optional[Facets]:
+        """Returns the component facets.
+
+        This will return the local facets (if any) or
+        the facets of the referenced concept (if any), or
+        None in case neither are set.
+
+        Returns:
+            The component facets (local or core).
+        """
+        if self.local_facets:
+            return self.local_facets
+        elif isinstance(self.concept, Concept) and self.concept.facets:
+            return self.concept.facets
+        else:
+            return None
+
+    @property
+    def enumeration(self) -> Union[Codelist, Hierarchy, None]:
+        """Returns the list of valid codes for the component.
+
+        This will return the local codes (if any) or
+        the codes of the referenced concept (if any), or
+        None in case neither are set.
+
+        Returns:
+            The component codes (local or core).
+        """
+        if self.local_codes:
+            return self.local_codes
+        elif isinstance(self.concept, Concept) and self.concept.codes:
+            return self.concept.codes
+        else:
+            return None
+
+    @property
+    def enum_ref(self) -> Optional[str]:
+        """Returns the URN of the enumeration from which the codes are taken.
+
+        Returns:
+            The URN of the enumeration from which the codes are taken.
+        """
+        if self.local_enum_ref:
+            return self.local_enum_ref
+        elif isinstance(self.concept, Concept) and self.concept.enum_ref:
+            return self.concept.enum_ref
+        else:
+            return None
+
+    def __str__(self) -> str:
+        """Custom string representation without the class name."""
+        processed_output = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            processed_output.append(f"{attr}: {value}")
+        return f"{', '.join(processed_output)}"
+
+    def __repr__(self) -> str:
+        """Custom __repr__ that omits empty sequences."""
+        attrs = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            attrs.append(f"{attr}={repr(value)}")
+        return f"{self.__class__.__name__}({', '.join(attrs)})"
+
+
+class MetadataStructure(
+    MaintainableArtefact, frozen=True, omit_defaults=True, kw_only=True
+):
+    """A metadata structure definition, i.e. a collection of metadata concepts.
+
+    Attributes:
+        id: The identifier for the MSD.
+        name: The MSD name (e.g. "Frequency codelist").
+        agency: The maintainer of the MSD (e.g. SDMX).
+        description: Additional descriptive information about the MSD.
+        version: The MSD version (e.g. 1.0.1)
+        components: The MSD components, i.e. the collection of metadata
+            concepts.
+    """
+
+    components: Sequence[MetadataComponent] = ()
+
+    def __iter__(self) -> Iterator[MetadataComponent]:
+        """Return an iterator over the list of components."""
+        yield from self.components
+
+    def __len__(self) -> int:
+        """Return the number of components in the MSD."""
+        return self.__get_count(self.components)
+
+    def __getitem__(self, id_: str) -> Optional[MetadataComponent]:
+        """Return the component identified by the given ID."""
+        return self.__extract_cat(self.components, id_)
+
+    def __contains__(self, id_: str) -> bool:
+        """Whether there is a component with the supplied ID in the MSD."""
+        return bool(self.__getitem__(id_))
+
+    def __get_count(self, comps: Sequence[MetadataComponent]) -> int:
+        """Return the number of components at any levels."""
+        count = len(comps)
+        for comp in comps:
+            if comp.components:
+                count += self.__get_count(comp.components)
+        return count
+
+    def __extract_cat(
+        self, comps: Sequence[MetadataComponent], id_: str
+    ) -> Optional[MetadataComponent]:
+        if "." in id_:
+            ids = id_.split(".")
+            out = list(filter(lambda cat: cat.id == ids[0], comps))
+            if out:
+                pkey = ".".join(ids[1:])
+                return self.__extract_cat(out[0].components, pkey)
+        else:
+            out = list(filter(lambda cat: cat.id == id_, comps))
+            if out:
+                return out[0]
+        return None
+
+    def __str__(self) -> str:
+        """Custom string representation without the class name."""
+        processed_output = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            # str is taken as a Sequence, so we need to check it's not a str
+            if isinstance(value, Sequence) and not isinstance(value, str):
+                # Handle empty lists
+                if not value:
+                    continue
+                class_name = value[0].__class__.__name__
+                class_name = (
+                    class_name.lower() + "s"
+                    if attr != "components"
+                    else "components"
+                )
+                value = f"{len(value)} {class_name}"
+
+            processed_output.append(f"{attr}: {value}")
+        return f"{', '.join(processed_output)}"
+
+
+class Metadataflow(
+    MaintainableArtefact,
+    frozen=True,
+    omit_defaults=True,
+    tag=True,
+    kw_only=True,
+):
+    """A flow of reference metadata that metadata providers will provide.
+
+    Attributes:
+        structure: The MSD describing the structure of all reference
+            metadata reports for this metadataflow.
+        targets: Identifiable structures to which the reference metadata
+            reports described by the referenced MSD should be restricted to.
+            For example, to indicate that the reports can be related to
+            dataflows only, the following can be used:
+            urn:sdmx:org.sdmx.infomodel.datastructure.Dataflow=*:*(*)
+    """
+
+    structure: Optional[Union[MetadataStructure, str]]
+    targets: Union[Sequence[str], Sequence[Reference]]
+
+
+class MetadataProvisionAgreement(
+    MaintainableArtefact, frozen=True, omit_defaults=True, kw_only=True
+):
+    """Link between a metadata provider and metadataflow."""
+
+    metadataflow: str
+    metadata_provider: str
+
+
 class MetadataAttribute(
     Struct, frozen=True, omit_defaults=True, repr_omit_defaults=True
 ):
     """An entry in a metadata report.
 
-    An attribute is iterable, as it may contain other attributes.
+    An component is iterable, as it may contain other attributes.
 
     Attributes:
         id: The identifier of the attribute (e.g. "License").

pysdmx/toolkit/pd/_data_utils.py

@@ -53,15 +53,14 @@ def get_codes(
     dimension_code: str, structure: Schema, data: pd.DataFrame
 ) -> Tuple[List[str], List[str], List[Dict[str, Any]]]:
     """This function divides the components in Series and Obs."""
-    series_codes = []
     groups = structure.groups
     group_codes = []
     obs_codes = [dimension_code, structure.components.measures[0].id]
 
     # Getting the series and obs codes
-    for dim in structure.components.dimensions:
-        if dim.id != dimension_code:
-            series_codes.append(dim.id)
+    series_codes = [
+        d.id for d in structure.components.dimensions if d.id != dimension_code
+    ]
 
     # Adding the attributes based on the attachment level
     for att in structure.components.attributes:

{pysdmx-1.6.0.dist-info → pysdmx-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdmx
-Version: 1.6.0
+Version: 1.8.0
 Summary: Your opinionated Python SDMX library
 License: Apache-2.0
 License-File: LICENSE
@@ -18,7 +18,7 @@ Provides-Extra: data
 Provides-Extra: dc
 Provides-Extra: vtl
 Provides-Extra: xml
-Requires-Dist: httpx (>=0)
+Requires-Dist: httpx[http2] (>=0)
 Requires-Dist: lxml (>=5.2) ; extra == "all"
 Requires-Dist: lxml (>=5.2) ; extra == "xml"
 Requires-Dist: msgspec (>=0)