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

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

@@ -2,18 +2,20 @@
 
 from typing import Optional, Sequence
 
-from msgspec import Struct
+import msgspec
 
+from pysdmx import errors
 from pysdmx.io.json.sdmxjson2.messages.code import JsonCodelist
 from pysdmx.io.json.sdmxjson2.messages.core import (
     ItemSchemeType,
+    JsonAnnotation,
     JsonRepresentation,
     NameableType,
 )
-from pysdmx.model import Codelist, Concept, ConceptScheme, DataType
+from pysdmx.model import Agency, Codelist, Concept, ConceptScheme, DataType
 
 
-class IsoConceptReference(Struct, frozen=True):
+class IsoConceptReference(msgspec.Struct, frozen=True, omit_defaults=True):
     """Payload for a reference to an ISO 11179 concept."""
 
     conceptAgency: str
@@ -21,7 +23,7 @@ class IsoConceptReference(Struct, frozen=True):
     conceptID: str
 
 
-class JsonConcept(NameableType, frozen=True):
+class JsonConcept(NameableType, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for concepts."""
 
     coreRepresentation: Optional[JsonRepresentation] = None
@@ -56,22 +58,62 @@ class JsonConcept(NameableType, frozen=True):
             enum_ref=cl_ref,
         )
 
+    @classmethod
+    def from_model(self, concept: Concept) -> "JsonConcept":
+        """Converts a pysdmx concept to an SDMX-JSON one."""
+        if not concept.name:
+            raise errors.Invalid(
+                "Invalid input",
+                "SDMX-JSON concepts must have a name",
+                {"codelist": concept.id},
+            )
+        if concept.codes:
+            enum_ref = (
+                "urn:sdmx:org.sdmx.infomodel.codelist."
+                f"{concept.codes.short_urn}"
+            )
+        elif concept.enum_ref:
+            enum_ref = concept.enum_ref
+        else:
+            enum_ref = None
+
+        return JsonConcept(
+            id=concept.id,
+            name=concept.name,
+            description=concept.description,
+            annotations=tuple(
+                [JsonAnnotation.from_model(a) for a in concept.annotations]
+            ),
+            coreRepresentation=JsonRepresentation.from_model(
+                concept.dtype, enum_ref, concept.facets, None
+            ),
+        )
 
-class JsonConceptScheme(ItemSchemeType, frozen=True):
+
+class JsonConceptScheme(ItemSchemeType, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for a concept scheme."""
 
     concepts: Sequence[JsonConcept] = ()
 
+    def __set_urn(self, concept: Concept) -> Concept:
+        urn = (
+            "urn:sdmx:org.sdmx.infomodel.conceptscheme.Concept="
+            f"{self.agency}:{self.id}({self.version}).{concept.id}"
+        )
+        return msgspec.structs.replace(concept, urn=urn)
+
     def to_model(self, codelists: Sequence[JsonCodelist]) -> ConceptScheme:
         """Converts a JsonConceptScheme to a standard concept scheme."""
-        cls = [c.to_model() for c in codelists]
+        cls = [cl.to_model() for cl in codelists]
+        concepts = [c.to_model(cls) for c in self.concepts]
+        concepts = [self.__set_urn(c) for c in concepts]
         return ConceptScheme(
             id=self.id,
             name=self.name,
             agency=self.agency,
             description=self.description,
             version=self.version,
-            items=[c.to_model(cls) for c in self.concepts],
+            items=concepts,
             annotations=[a.to_model() for a in self.annotations],
             is_external_reference=self.isExternalReference,
             is_partial=self.isPartial,
@@ -79,11 +121,35 @@ class JsonConceptScheme(ItemSchemeType, frozen=True):
             valid_to=self.validTo,
         )
 
+    @classmethod
+    def from_model(self, cs: ConceptScheme) -> "JsonConceptScheme":
+        """Converts a pysdmx concept scheme to an SDMX-JSON one."""
+        if not cs.name:
+            raise errors.Invalid(
+                "Invalid input",
+                "SDMX-JSON concept schemes must have a name",
+                {"concept_scheme": cs.id},
+            )
+        return JsonConceptScheme(
+            agency=(
+                cs.agency.id if isinstance(cs.agency, Agency) else cs.agency
+            ),
+            id=cs.id,
+            name=cs.name,
+            version=cs.version,
+            isExternalReference=cs.is_external_reference,
+            validFrom=cs.valid_from,
+            validTo=cs.valid_to,
+            description=cs.description,
+            annotations=tuple(
+                [JsonAnnotation.from_model(a) for a in cs.annotations]
+            ),
+            isPartial=cs.is_partial,
+            concepts=tuple([JsonConcept.from_model(c) for c in cs.concepts]),
+        )
+
 
-class JsonConceptSchemes(
-    Struct,
-    frozen=True,
-):
+class JsonConceptSchemes(msgspec.Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for the list of concept schemes."""
 
     conceptSchemes: Sequence[JsonConceptScheme]
@@ -91,8 +157,7 @@ class JsonConceptSchemes(
 
 
 class JsonConceptSchemeMessage(
-    Struct,
-    frozen=True,
+    msgspec.Struct, frozen=True, omit_defaults=True
 ):
     """SDMX-JSON payload for /conceptscheme queries."""
 

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

@@ -7,13 +7,13 @@ from msgspec import Struct
 from pysdmx.io.json.sdmxjson2.messages.core import MaintainableType
 
 
-class JsonValue(Struct, frozen=True):
+class JsonValue(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for an allowed value."""
 
     value: str
 
 
-class JsonKeyValue(Struct, frozen=True):
+class JsonKeyValue(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for the list of allowed values per component."""
 
     id: str
@@ -24,7 +24,7 @@ class JsonKeyValue(Struct, frozen=True):
         return [v.value for v in self.values]
 
 
-class JsonCubeRegion(Struct, frozen=True):
+class JsonCubeRegion(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for a cube region."""
 
     keyValues: Sequence[JsonKeyValue]
@@ -34,7 +34,7 @@ class JsonCubeRegion(Struct, frozen=True):
         return {kv.id: kv.to_model() for kv in self.keyValues}
 
 
-class JsonConstraintAttachment(Struct, frozen=True):
+class JsonConstraintAttachment(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for a constraint attachment."""
 
     dataProvider: Optional[str]
@@ -45,7 +45,7 @@ class JsonConstraintAttachment(Struct, frozen=True):
     queryableDataSources: Optional[Sequence[str]] = None
 
 
-class JsonDataConstraint(MaintainableType, frozen=True):
+class JsonDataConstraint(MaintainableType, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for a content constraint."""
 
     role: Optional[Literal["Allowed", "Actual"]] = None

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

@@ -1,7 +1,7 @@
 """Collection of SDMX-JSON schemas for common artefacts."""
 
 from datetime import datetime
-from typing import Optional, Sequence, Union
+from typing import Literal, Optional, Sequence, Union
 
 import msgspec
 
@@ -10,6 +10,7 @@ from pysdmx.model import (
     Annotation,
     ArrayBoundaries,
     Codelist,
+    DataType,
     Facets,
     Organisation,
 )
@@ -17,7 +18,7 @@ from pysdmx.model.message import Header
 from pysdmx.util import find_by_urn
 
 
-class JsonLink(msgspec.Struct, frozen=True):
+class JsonLink(msgspec.Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for link objects."""
 
     href: Optional[str] = None
@@ -29,7 +30,7 @@ class JsonLink(msgspec.Struct, frozen=True):
     hreflang: Optional[str] = None
 
 
-class JsonAnnotation(msgspec.Struct, frozen=True):
+class JsonAnnotation(msgspec.Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for annotations."""
 
     id: Optional[str] = None
@@ -57,15 +58,31 @@ class JsonAnnotation(msgspec.Struct, frozen=True):
             text=self.value if self.value else self.text,
         )
 
+    @classmethod
+    def from_model(self, annotation: Annotation) -> "JsonAnnotation":
+        """Converts a pysdmx annotation to an SDMX-JSON one."""
+        if annotation.url:
+            links = (JsonLink(rel="self", href=annotation.url),)
+        else:
+            links = ()  # type: ignore[assignment]
+
+        return JsonAnnotation(
+            id=annotation.id,
+            title=annotation.title,
+            type=annotation.type,
+            text=annotation.text,
+            links=links,
+        )
 
-class IdentifiableType(msgspec.Struct, frozen=True):
+
+class IdentifiableType(msgspec.Struct, frozen=True, omit_defaults=True):
     """An abstract base type used for all nameable artefacts."""
 
     id: str
     annotations: Sequence[JsonAnnotation] = ()
 
 
-class NameableType(msgspec.Struct, frozen=True):
+class NameableType(msgspec.Struct, frozen=True, omit_defaults=True):
     """An abstract base type used for all nameable artefacts."""
 
     id: str
@@ -75,7 +92,10 @@ class NameableType(msgspec.Struct, frozen=True):
 
 
 class MaintainableType(
-    msgspec.Struct, frozen=True, rename={"agency": "agencyID"}
+    msgspec.Struct,
+    frozen=True,
+    rename={"agency": "agencyID"},
+    omit_defaults=True,
 ):
     """An abstract base type used for all maintainable artefacts."""
 
@@ -90,16 +110,16 @@ class MaintainableType(
     annotations: Sequence[JsonAnnotation] = ()
 
 
-class ItemSchemeType(MaintainableType, frozen=True):
+class ItemSchemeType(MaintainableType, frozen=True, omit_defaults=True):
     """An abstract base type used for all item schemes."""
 
     isPartial: bool = False
 
 
-class JsonTextFormat(msgspec.Struct, frozen=True):
+class JsonTextFormat(msgspec.Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for TextFormat."""
 
-    dataType: str
+    dataType: Optional[str] = None
     minLength: Optional[int] = None
     maxLength: Optional[int] = None
     minValue: Optional[Union[int, float]] = None
@@ -114,7 +134,37 @@ class JsonTextFormat(msgspec.Struct, frozen=True):
     isMultilingual: bool = False
     sentinelValues: Optional[Sequence[str]] = None
     timeInterval: Optional[str] = None
-    interval: Optional[int] = None
+    interval: Optional[Union[int, float]] = None
+
+    @classmethod
+    def from_model(
+        self, dtype: Optional[DataType], facets: Optional[Facets]
+    ) -> Optional["JsonTextFormat"]:
+        """Converts pysdmx format details to an SDMX-JSON JsonTextFormat."""
+        if dtype is None and facets is None:
+            return None
+        else:
+            typ = dtype.value if dtype else None
+            if facets is None:
+                return JsonTextFormat(typ)
+            else:
+                return JsonTextFormat(
+                    typ,
+                    facets.min_length,
+                    facets.max_length,
+                    facets.min_value,
+                    facets.max_value,
+                    facets.start_value,
+                    facets.end_value,
+                    facets.decimals,
+                    facets.pattern,
+                    facets.start_time,
+                    facets.end_time,
+                    facets.is_sequence,
+                    facets.is_multilingual,
+                    timeInterval=facets.time_interval,
+                    interval=facets.interval,
+                )
 
 
 def get_facets(input: JsonTextFormat) -> Facets:
@@ -135,7 +185,7 @@ def get_facets(input: JsonTextFormat) -> Facets:
     )
 
 
-class JsonRepresentation(msgspec.Struct, frozen=True):
+class JsonRepresentation(msgspec.Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for core representation."""
 
     enumerationFormat: Optional[JsonTextFormat] = None
@@ -192,8 +242,44 @@ class JsonRepresentation(msgspec.Struct, frozen=True):
         else:
             return None
 
-
-class JsonHeader(msgspec.Struct, frozen=True):
+    @classmethod
+    def from_model(
+        self,
+        dtype: Optional[DataType],
+        enumeration: Optional[str],
+        facets: Optional[Facets],
+        array_def: Optional[ArrayBoundaries],
+    ) -> Optional["JsonRepresentation"]:
+        """Converts pysdmx representation details to an SDMX-JSON one."""
+        if (
+            dtype is None
+            and enumeration is None
+            and facets is None
+            and array_def is None
+        ):
+            return None
+        else:
+            fmt = JsonTextFormat.from_model(dtype, facets)
+            if array_def:
+                mino = array_def.min_size
+                maxo = array_def.max_size
+            else:
+                mino = None
+                maxo = None
+            if enumeration:
+                return JsonRepresentation(
+                    enumerationFormat=fmt,
+                    enumeration=enumeration,
+                    minOccurs=mino,
+                    maxOccurs=maxo,
+                )
+            else:
+                return JsonRepresentation(
+                    format=fmt, minOccurs=mino, maxOccurs=maxo
+                )
+
+
+class JsonHeader(msgspec.Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for message header."""
 
     id: str
@@ -202,8 +288,9 @@ class JsonHeader(msgspec.Struct, frozen=True):
     test: bool = False
     contentLanguages: Sequence[str] = ()
     name: Optional[str] = None
-    receivers: Optional[Organisation] = None
+    receivers: Optional[Sequence[Organisation]] = None
     links: Sequence[JsonLink] = ()
+    schema: Optional[str] = None
 
     def to_model(self) -> Header:
         """Map to pysdmx header class."""
@@ -213,3 +300,23 @@ class JsonHeader(msgspec.Struct, frozen=True):
             prepared=self.prepared,
             sender=self.sender,
         )
+
+    @classmethod
+    def from_model(
+        self,
+        header: Header,
+        msg_type: Literal["structure", "metadata"] = "structure",
+    ) -> "JsonHeader":
+        """Create an SDMX-JSON header from a pysdmx Header."""
+        return JsonHeader(
+            header.id,
+            header.prepared,
+            header.sender,
+            header.test,
+            receivers=(header.receiver,) if header.receiver else None,
+            schema=(
+                "https://raw.githubusercontent.com/sdmx-twg/sdmx-json/"
+                "develop/structure-message/tools/schemas/2.0.0/"
+                f"sdmx-json-{msg_type}-schema.json"
+            ),
+        )

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

@@ -4,9 +4,13 @@ from typing import List, 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 MaintainableType
+from pysdmx.io.json.sdmxjson2.messages.core import (
+    JsonAnnotation,
+    MaintainableType,
+)
 from pysdmx.io.json.sdmxjson2.messages.dsd import JsonDataStructure
 from pysdmx.io.json.sdmxjson2.messages.provider import JsonDataProviderScheme
 from pysdmx.model import (
@@ -17,10 +21,11 @@ from pysdmx.model import (
     DataProvider,
     DataStructureDefinition,
 )
+from pysdmx.model.dataflow import Group
 from pysdmx.util import parse_urn
 
 
-class JsonDataflow(MaintainableType, frozen=True):
+class JsonDataflow(MaintainableType, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for a dataflow."""
 
     structure: str = ""
@@ -59,8 +64,47 @@ class JsonDataflow(MaintainableType, frozen=True):
             valid_to=self.validTo,
         )
 
+    @classmethod
+    def from_model(self, df: Dataflow) -> "JsonDataflow":
+        """Converts a pysdmx dataflow to an SDMX-JSON one."""
+        if not df.name:
+            raise errors.Invalid(
+                "Invalid input",
+                "SDMX-JSON dataflows must have a name",
+                {"dataflow": df.id},
+            )
+        if not df.structure:
+            raise errors.Invalid(
+                "Invalid input",
+                "SDMX-JSON dataflows must reference a DSD.",
+                {"dataflow": df.id},
+            )
+        if isinstance(df.structure, DataStructureDefinition):
+            dsdref = (
+                "urn:sdmx:org.sdmx.infomodel.datastructure.DataStructure="
+                f"{df.structure.agency}:{df.structure.id}({df.structure.version})"
+            )
+        else:
+            dsdref = df.structure
+        return JsonDataflow(
+            agency=(
+                df.agency.id if isinstance(df.agency, Agency) else df.agency
+            ),
+            id=df.id,
+            name=df.name,
+            version=df.version,
+            isExternalReference=df.is_external_reference,
+            validFrom=df.valid_from,
+            validTo=df.valid_to,
+            description=df.description,
+            annotations=tuple(
+                [JsonAnnotation.from_model(a) for a in df.annotations]
+            ),
+            structure=dsdref,
+        )
 
-class JsonDataflows(Struct, frozen=True):
+
+class JsonDataflows(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for the list of dataflows."""
 
     dataflows: Sequence[JsonDataflow]
@@ -81,7 +125,12 @@ class JsonDataflows(Struct, frozen=True):
             return df.agency == agency and df.id == id_
 
     def to_model(
-        self, components: Components, agency: str, id_: str, version: str
+        self,
+        components: Components,
+        grps: Optional[Sequence[Group]],
+        agency: str,
+        id_: str,
+        version: str,
     ) -> DataflowInfo:
         """Returns the requested dataflow details."""
         prvs: List[DataProvider] = []
@@ -102,6 +151,7 @@ class JsonDataflows(Struct, frozen=True):
             version=df.version,
             providers=prvs,
             dsd_ref=df.structure,
+            groups=grps,
         )
 
     def to_generic_model(self) -> Sequence[Dataflow]:
@@ -117,19 +167,24 @@ class JsonDataflows(Struct, frozen=True):
         ]
 
 
-class JsonDataflowMessage(Struct, frozen=True):
+class JsonDataflowMessage(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for /dataflow queries (with details)."""
 
     data: JsonDataflows
 
     def to_model(
-        self, components: Components, agency: str, id_: str, version: str
+        self,
+        components: Components,
+        grps: Optional[Sequence[Group]],
+        agency: str,
+        id_: str,
+        version: str,
     ) -> DataflowInfo:
         """Returns the requested dataflow details."""
-        return self.data.to_model(components, agency, id_, version)
+        return self.data.to_model(components, grps, agency, id_, version)
 
 
-class JsonDataflowsMessage(Struct, frozen=True):
+class JsonDataflowsMessage(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for /dataflow queries."""
 
     data: JsonDataflows