pysdmx 1.5.2__py3-none-any.whl → 1.7.0__py3-none-any.whl

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

@@ -1,9 +1,10 @@
 """Collection of SDMX-JSON schemas for SDMX-REST schema queries."""
 
-from typing import Dict, List, Optional, Sequence, Tuple
+from typing import Dict, List, Literal, Optional, Sequence, Tuple
 
 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 (
     JsonConcept,
@@ -11,10 +12,12 @@ from pysdmx.io.json.sdmxjson2.messages.concept import (
 )
 from pysdmx.io.json.sdmxjson2.messages.constraint import JsonDataConstraint
 from pysdmx.io.json.sdmxjson2.messages.core import (
+    JsonAnnotation,
     JsonRepresentation,
     MaintainableType,
 )
 from pysdmx.model import (
+    Agency,
     ArrayBoundaries,
     Codelist,
     Component,
@@ -23,8 +26,10 @@ from pysdmx.model import (
     DataStructureDefinition,
     DataType,
     Facets,
+    ItemReference,
     Role,
 )
+from pysdmx.model.dataflow import Group
 from pysdmx.util import parse_item_urn
 
 
@@ -38,12 +43,13 @@ def _find_concept(cs: Sequence[JsonConceptScheme], urn: str) -> JsonConcept:
     return [c for c in f[0].concepts if c.id == r.item_id][0]
 
 
-def __get_type(repr_: JsonRepresentation) -> str:
+def __get_type(repr_: JsonRepresentation) -> Optional[str]:
+    t: Optional[str] = None
     if repr_.enumerationFormat:
         t = repr_.enumerationFormat.dataType
     elif repr_.format:
         t = repr_.format.dataType
-    else:
+    if not t:
         t = "String"
     return t
 
@@ -67,14 +73,44 @@ def _get_representation(
     return (dt, facets, codes, ab)
 
 
-class JsonGroup(Struct, frozen=True):
+def _get_concept_reference(component: Component) -> str:
+    if isinstance(component.concept, ItemReference):
+        concept = (
+            "urn:sdmx:org.sdmx.infomodel.conceptscheme."
+            f"{str(component.concept)}"
+        )
+    elif component.concept.urn:
+        concept = component.concept.urn
+    else:
+        raise errors.Invalid(
+            "Missing concept reference",
+            (
+                "The full reference to the concept must be available "
+                "but could not be found. To have the full reference, "
+                "either the concept must be an ItemReference or a "
+                "concept object with a urn."
+            ),
+        )
+    return concept
+
+
+def _get_json_representation(
+    comp: Component,
+) -> Optional[JsonRepresentation]:
+    enum = comp.local_enum_ref if comp.local_enum_ref else None
+    return JsonRepresentation.from_model(
+        comp.local_dtype, enum, comp.local_facets, comp.array_def
+    )
+
+
+class JsonGroup(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for a group."""
 
     id: str
     groupDimensions: Sequence[str]
 
 
-class JsonAttributeRelationship(Struct, frozen=True):
+class JsonAttributeRelationship(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for an attribute relationship."""
 
     dataflow: Optional[Dict] = None  # type: ignore[type-arg]
@@ -96,8 +132,19 @@ class JsonAttributeRelationship(Struct, frozen=True):
         else:
             return "D"
 
+    @classmethod
+    def from_model(self, rel: str) -> "JsonAttributeRelationship":
+        """Converts a pysdmx attribute relationship to an SDMX-JSON one."""
+        if rel == "D":
+            return JsonAttributeRelationship(dataflow={})
+        elif rel == "O":
+            return JsonAttributeRelationship(observation={})
+        else:
+            dims = rel.split(",")
+            return JsonAttributeRelationship(dimensions=dims)
+
 
-class JsonDimension(Struct, frozen=True):
+class JsonDimension(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for a component."""
 
     id: str
@@ -123,6 +170,10 @@ class JsonDimension(Struct, frozen=True):
         dt, facets, codes, ab = _get_representation(
             self.id, self.localRepresentation, cls, cons
         )
+        if self.localRepresentation and self.localRepresentation.enumeration:
+            local_enum_ref = self.localRepresentation.enumeration
+        else:
+            local_enum_ref = None
         return Component(
             id=self.id,
             required=True,
@@ -134,10 +185,22 @@ class JsonDimension(Struct, frozen=True):
             description=desc,
             local_codes=codes,
             array_def=ab,
+            local_enum_ref=local_enum_ref,
         )
 
+    @classmethod
+    def from_model(self, dimension: Component) -> "JsonDimension":
+        """Converts a pysdmx dimension to an SDMX-JSON one."""
+        concept = _get_concept_reference(dimension)
+        repr = _get_json_representation(dimension)
+        return JsonDimension(
+            id=dimension.id,
+            conceptIdentity=concept,
+            localRepresentation=repr,
+        )
 
-class JsonAttribute(Struct, frozen=True):
+
+class JsonAttribute(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for an attribute."""
 
     id: str
@@ -171,6 +234,10 @@ class JsonAttribute(Struct, frozen=True):
             groups,
             self.measureRelationship,
         )
+        if self.localRepresentation and self.localRepresentation.enumeration:
+            local_enum_ref = self.localRepresentation.enumeration
+        else:
+            local_enum_ref = None
         return Component(
             id=self.id,
             required=req,
@@ -183,10 +250,28 @@ class JsonAttribute(Struct, frozen=True):
             local_codes=codes,
             attachment_level=lvl,
             array_def=ab,
+            local_enum_ref=local_enum_ref,
         )
 
+    @classmethod
+    def from_model(self, attribute: Component) -> "JsonAttribute":
+        """Converts a pysdmx attribute to an SDMX-JSON one."""
+        concept = _get_concept_reference(attribute)
+        usage = "mandatory" if attribute.required else "optional"
+        level = JsonAttributeRelationship.from_model(
+            attribute.attachment_level  # type: ignore[arg-type]
+        )
+        repr = _get_json_representation(attribute)
+        return JsonAttribute(
+            id=attribute.id,
+            conceptIdentity=concept,
+            attributeRelationship=level,
+            usage=usage,
+            localRepresentation=repr,
+        )
 
-class JsonMeasure(Struct, frozen=True):
+
+class JsonMeasure(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for a measure."""
 
     id: str
@@ -213,6 +298,10 @@ class JsonMeasure(Struct, frozen=True):
             self.id, self.localRepresentation, cls, cons
         )
         req = self.usage != "optional"
+        if self.localRepresentation and self.localRepresentation.enumeration:
+            local_enum_ref = self.localRepresentation.enumeration
+        else:
+            local_enum_ref = None
         return Component(
             id=self.id,
             required=req,
@@ -224,12 +313,27 @@ class JsonMeasure(Struct, frozen=True):
             description=desc,
             local_codes=codes,
             array_def=ab,
+            local_enum_ref=local_enum_ref,
+        )
+
+    @classmethod
+    def from_model(self, measure: Component) -> "JsonMeasure":
+        """Converts a pysdmx measure to an SDMX-JSON one."""
+        concept = _get_concept_reference(measure)
+        usage = "mandatory" if measure.required else "optional"
+        repr = _get_json_representation(measure)
+        return JsonMeasure(
+            id=measure.id,
+            conceptIdentity=concept,
+            usage=usage,
+            localRepresentation=repr,
         )
 
 
-class JsonAttributes(Struct, frozen=True):
+class JsonAttributes(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for the list of attributes."""
 
+    id: Literal["AttributeDescriptor"] = "AttributeDescriptor"
     attributes: Sequence[JsonAttribute] = ()
 
     def to_model(
@@ -242,11 +346,24 @@ class JsonAttributes(Struct, frozen=True):
         """Returns the list of attributes."""
         return [a.to_model(cs, cls, cons, groups) for a in self.attributes]
 
+    @classmethod
+    def from_model(
+        self, attributes: Sequence[Component]
+    ) -> Optional["JsonAttributes"]:
+        """Converts a pysdmx list of attributes to an SDMX-JSON one."""
+        if len(attributes) > 0:
+            return JsonAttributes(
+                attributes=[JsonAttribute.from_model(a) for a in attributes]
+            )
+        else:
+            return None
+
 
-class JsonDimensions(Struct, frozen=True):
+class JsonDimensions(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for the list of dimensions."""
 
-    dimensions: Sequence[JsonDimension]
+    id: Literal["DimensionDescriptor"] = "DimensionDescriptor"
+    dimensions: Sequence[JsonDimension] = ()
     timeDimension: Optional[JsonDimension] = None
 
     def to_model(
@@ -262,11 +379,29 @@ class JsonDimensions(Struct, frozen=True):
             dims.append(self.timeDimension.to_model(cs, cls, cons))
         return dims
 
+    @classmethod
+    def from_model(
+        self,
+        dimensions: Sequence[Component],
+    ) -> "JsonDimensions":
+        """Converts a pysdmx list of dimensions to an SDMX-JSON one."""
+        td = [d for d in dimensions if d.id == "TIME_PERIOD"]
+        ftd = None if len(td) == 0 else JsonDimension.from_model(td[0])
+        return JsonDimensions(
+            dimensions=[
+                JsonDimension.from_model(d)
+                for d in dimensions
+                if d.id != "TIME_PERIOD"
+            ],
+            timeDimension=ftd,
+        )
 
-class JsonMeasures(Struct, frozen=True):
+
+class JsonMeasures(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for the list of measures."""
 
-    measures: Sequence[JsonMeasure]
+    id: Literal["MeasureDescriptor"] = "MeasureDescriptor"
+    measures: Sequence[JsonMeasure] = ()
 
     def to_model(
         self,
@@ -277,8 +412,20 @@ class JsonMeasures(Struct, frozen=True):
         """Returns the list of measures."""
         return [m.to_model(cs, cls, cons) for m in self.measures]
 
+    @classmethod
+    def from_model(
+        self, measures: Sequence[Component]
+    ) -> Optional["JsonMeasures"]:
+        """Converts a pysdmx list of measures to an SDMX-JSON one."""
+        if len(measures) > 0:
+            return JsonMeasures(
+                measures=[JsonMeasure.from_model(m) for m in measures]
+            )
+        else:
+            return None
+
 
-class JsonComponents(Struct, frozen=True):
+class JsonComponents(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for the list of DSD components."""
 
     dimensionList: JsonDimensions
@@ -292,7 +439,7 @@ class JsonComponents(Struct, frozen=True):
         cls: Sequence[JsonCodelist],
         vls: Sequence[JsonValuelist],
         constraints: Sequence[JsonDataConstraint],
-    ) -> Components:
+    ) -> Tuple[Components, Sequence[Group]]:
         """Returns the components for this DSD."""
         enums = [cl.to_model() for cl in cls]
         enums.extend([vl.to_model() for vl in vls])
@@ -313,10 +460,27 @@ class JsonComponents(Struct, frozen=True):
                     self.groups,
                 )
             )
-        return Components(comps)
+        mapped_grps = [
+            Group(g.id, dimensions=g.groupDimensions) for g in self.groups
+        ]
+        return (Components(comps), mapped_grps)
+
+    @classmethod
+    def from_model(
+        self, components: Components, grps: Optional[Sequence[Group]]
+    ) -> "JsonComponents":
+        """Converts a pysdmx components list to an SDMX-JSON one."""
+        dimensions = JsonDimensions.from_model(components.dimensions)
+        attributes = JsonAttributes.from_model(components.attributes)
+        measures = JsonMeasures.from_model(components.measures)
+        if grps is None:
+            groups = []
+        else:
+            groups = [JsonGroup(g.id, g.dimensions) for g in grps]
+        return JsonComponents(dimensions, measures, attributes, groups)
 
 
-class JsonDataStructure(MaintainableType, frozen=True):
+class JsonDataStructure(MaintainableType, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for a DSD."""
 
     dataStructureComponents: Optional[JsonComponents] = None
@@ -330,7 +494,7 @@ class JsonDataStructure(MaintainableType, frozen=True):
         constraints: Sequence[JsonDataConstraint],
     ) -> DataStructureDefinition:
         """Map to pysdmx model class."""
-        c = self.dataStructureComponents.to_model(  # type: ignore[union-attr]
+        c, grps = self.dataStructureComponents.to_model(  # type: ignore[union-attr]
             cs,
             cls,
             vls,
@@ -348,10 +512,41 @@ class JsonDataStructure(MaintainableType, frozen=True):
             valid_to=self.validTo,
             components=c,
             evolving_structure=self.evolvingStructure,
+            groups=grps,
+        )
+
+    @classmethod
+    def from_model(self, dsd: DataStructureDefinition) -> "JsonDataStructure":
+        """Converts a pysdmx dsd to an SDMX-JSON one."""
+        if not dsd.name:
+            raise errors.Invalid(
+                "Invalid input",
+                "SDMX-JSON data structures must have a name",
+                {"data_structure": dsd.id},
+            )
+
+        return JsonDataStructure(
+            agency=(
+                dsd.agency.id if isinstance(dsd.agency, Agency) else dsd.agency
+            ),
+            id=dsd.id,
+            name=dsd.name,
+            version=dsd.version,
+            isExternalReference=dsd.is_external_reference,
+            validFrom=dsd.valid_from,
+            validTo=dsd.valid_to,
+            description=dsd.description,
+            annotations=tuple(
+                [JsonAnnotation.from_model(a) for a in dsd.annotations]
+            ),
+            dataStructureComponents=JsonComponents.from_model(
+                dsd.components, dsd.groups
+            ),
+            evolvingStructure=dsd.evolving_structure,
         )
 
 
-class JsonDataStructures(Struct, frozen=True):
+class JsonDataStructures(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for data structures."""
 
     dataStructures: Sequence[JsonDataStructure]
@@ -373,7 +568,7 @@ class JsonDataStructures(Struct, frozen=True):
         ]
 
 
-class JsonDataStructuresMessage(Struct, frozen=True):
+class JsonDataStructuresMessage(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for /datastructure queries."""
 
     data: JsonDataStructures