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

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

@@ -1,6 +1,6 @@
 """Collection of SDMX-JSON schemas for SDMX-REST schema queries."""
 
-from typing import Literal, Sequence
+from typing import Literal, Optional, Sequence, Tuple
 
 import msgspec
 
@@ -10,13 +10,11 @@ from pysdmx.io.json.sdmxjson2.messages.constraint import JsonDataConstraint
 from pysdmx.io.json.sdmxjson2.messages.core import JsonHeader
 from pysdmx.io.json.sdmxjson2.messages.dsd import JsonDataStructure
 from pysdmx.model import Components, HierarchyAssociation, Schema
+from pysdmx.model.dataflow import Group
 from pysdmx.util import parse_item_urn
 
 
-class JsonSchemas(
-    msgspec.Struct,
-    frozen=True,
-):
+class JsonSchemas(msgspec.Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload schema structures."""
 
     conceptSchemes: Sequence[JsonConceptScheme]
@@ -25,21 +23,21 @@ class JsonSchemas(
     codelists: Sequence[JsonCodelist] = ()
     contentConstraints: Sequence[JsonDataConstraint] = ()
 
-    def to_model(self) -> Components:
+    def to_model(
+        self,
+    ) -> Tuple[Components, Optional[Sequence[Group]]]:
         """Returns the requested schema."""
         comps = self.dataStructures[0].dataStructureComponents
-        return comps.to_model(  # type: ignore[union-attr]
+        comps, grps = comps.to_model(  # type: ignore[union-attr,assignment]
             self.conceptSchemes,
             self.codelists,
             self.valuelists,
             self.contentConstraints,
         )
+        return comps, grps  # type: ignore[return-value]
 
 
-class JsonSchemaMessage(
-    msgspec.Struct,
-    frozen=True,
-):
+class JsonSchemaMessage(msgspec.Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for /schema queries."""
 
     meta: JsonHeader
@@ -54,7 +52,7 @@ class JsonSchemaMessage(
         hierarchies: Sequence[HierarchyAssociation],
     ) -> Schema:
         """Returns the requested schema."""
-        components = self.data.to_model()
+        components, groups = self.data.to_model()
         comp_dict = {c.id: c for c in components}
         urns = [a.urn for a in self.meta.links]
         for ha in hierarchies:
@@ -78,4 +76,5 @@ class JsonSchemaMessage(
             comps,
             version,
             urns,  # type: ignore[arg-type]
+            groups=groups,
         )

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

@@ -4,6 +4,7 @@ from typing import Sequence
 
 from msgspec import Struct
 
+from pysdmx import errors
 from pysdmx.io.json.sdmxjson2.messages.agency import JsonAgencyScheme
 from pysdmx.io.json.sdmxjson2.messages.category import (
     JsonCategorisation,
@@ -37,7 +38,7 @@ from pysdmx.model.__base import MaintainableArtefact
 from pysdmx.model.message import StructureMessage
 
 
-class JsonStructures(Struct, frozen=True):
+class JsonStructures(Struct, frozen=True, omit_defaults=True):
     """The allowed strutures."""
 
     dataStructures: Sequence[JsonDataStructure] = ()
@@ -126,8 +127,144 @@ class JsonStructures(Struct, frozen=True):
             structures.append(rm.to_model(multi))
         return structures
 
+    @classmethod
+    def from_model(cls, msg: StructureMessage) -> "JsonStructures":
+        """Create an SDMX-JSON structures from a list of artefacts."""
+        if not msg.structures:
+            raise errors.Invalid(
+                "Invalid input",
+                "SDMX-JSON structure messages must have structures.",
+            )
+        codelists = tuple(
+            [JsonCodelist.from_model(c) for c in msg.get_codelists()]
+        )
+        valuelists = tuple(
+            [JsonValuelist.from_model(c) for c in msg.get_value_lists()]
+        )
+        agencies = tuple(
+            [JsonAgencyScheme.from_model(a) for a in msg.get_agency_schemes()]
+        )
+        dataflows = tuple(
+            [JsonDataflow.from_model(d) for d in msg.get_dataflows()]
+        )
+        agreements = tuple(
+            [
+                JsonProvisionAgreement.from_model(p)
+                for p in msg.get_provision_agreements()
+            ]
+        )
+        categorisations = tuple(
+            [
+                JsonCategorisation.from_model(c)
+                for c in msg.get_categorisations()
+            ]
+        )
+        hier_associations = tuple(
+            [
+                JsonHierarchyAssociation.from_model(ha)
+                for ha in msg.get_hierarchy_associations()
+            ]
+        )
+        category_schemes = tuple(
+            [
+                JsonCategoryScheme.from_model(cs)
+                for cs in msg.get_category_schemes()
+            ]
+        )
+        concept_schemes = tuple(
+            [
+                JsonConceptScheme.from_model(cs)
+                for cs in msg.get_concept_schemes()
+            ]
+        )
+        data_structures = tuple(
+            [
+                JsonDataStructure.from_model(ds)
+                for ds in msg.get_data_structure_definitions()
+            ]
+        )
+        data_providers = tuple(
+            [
+                JsonDataProviderScheme.from_model(dps)
+                for dps in msg.get_data_provider_schemes()
+            ]
+        )
+        representations_maps = tuple(
+            [
+                JsonRepresentationMap.from_model(rm)
+                for rm in msg.get_representation_maps()
+            ]
+        )
+        structure_maps = tuple(
+            [
+                JsonStructureMap.from_model(sm)
+                for sm in msg.get_structure_maps()
+            ]
+        )
+        custom_types = tuple(
+            [
+                JsonCustomTypeScheme.from_model(ct)
+                for ct in msg.get_custom_type_schemes()
+            ]
+        )
+        name_personalisations = tuple(
+            [
+                JsonNamePersonalisationScheme.from_model(np)
+                for np in msg.get_name_personalisation_schemes()
+            ]
+        )
+        user_operators = tuple(
+            [
+                JsonUserDefinedOperatorScheme.from_model(uo)
+                for uo in msg.get_user_defined_operator_schemes()
+            ]
+        )
+        rulesets = tuple(
+            [
+                JsonRulesetScheme.from_model(rs)
+                for rs in msg.get_ruleset_schemes()
+            ]
+        )
+        vtl_mappings = tuple(
+            [
+                JsonVtlMappingScheme.from_model(vm)
+                for vm in msg.get_vtl_mapping_schemes()
+            ]
+        )
+        transformations = tuple(
+            [
+                JsonTransformationScheme.from_model(ts)
+                for ts in msg.get_transformation_schemes()
+            ]
+        )
+        hierarchies = tuple(
+            [JsonHierarchy.from_model(h) for h in msg.get_hierarchies()]
+        )
+        return JsonStructures(
+            agencySchemes=agencies,
+            categorisations=categorisations,
+            categorySchemes=category_schemes,
+            codelists=codelists,
+            conceptSchemes=concept_schemes,
+            customTypeSchemes=custom_types,
+            dataflows=dataflows,
+            dataProviderSchemes=data_providers,
+            dataStructures=data_structures,
+            hierarchies=hierarchies,
+            hierarchyAssociations=hier_associations,
+            namePersonalisationSchemes=name_personalisations,
+            provisionAgreements=agreements,
+            representationMaps=representations_maps,
+            rulesetSchemes=rulesets,
+            structureMaps=structure_maps,
+            transformationSchemes=transformations,
+            userDefinedOperatorSchemes=user_operators,
+            valueLists=valuelists,
+            vtlMappingSchemes=vtl_mappings,
+        )
 
-class JsonStructureMessage(Struct, frozen=True):
+
+class JsonStructureMessage(Struct, frozen=True, omit_defaults=True):
     """A generic SDMX-JSON 2.0 Structure message."""
 
     meta: JsonHeader
@@ -138,3 +275,14 @@ class JsonStructureMessage(Struct, frozen=True):
         header = self.meta.to_model()
         structures = self.data.to_model()
         return StructureMessage(header, structures)
+
+    @classmethod
+    def from_model(cls, message: StructureMessage) -> "JsonStructureMessage":
+        """Creates an SDMX-JSON payload from a pysdmx StructureMessage."""
+        if not message.header:
+            raise errors.Invalid(
+                "Invalid input", "SDMX-JSON messages must have a header."
+            )
+        header = JsonHeader.from_model(message.header)
+        structs = JsonStructures.from_model(message)
+        return JsonStructureMessage(header, structs)