pysdmx 1.9.0__tar.gz → 1.10.0__tar.gz

{pysdmx-1.9.0 → pysdmx-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdmx
-Version: 1.9.0
+Version: 1.10.0
 Summary: Your opinionated Python SDMX library
 License: Apache-2.0
 License-File: LICENSE
@@ -32,8 +32,8 @@ Requires-Dist: python-dateutil (>=2.8.2) ; extra == "dc"
 Requires-Dist: sdmxschemas (>=1.0.0) ; extra == "all"
 Requires-Dist: sdmxschemas (>=1.0.0) ; extra == "json"
 Requires-Dist: sdmxschemas (>=1.0.0) ; extra == "xml"
-Requires-Dist: vtlengine (>=1.1,<2.0) ; extra == "all"
-Requires-Dist: vtlengine (>=1.1,<2.0) ; extra == "vtl"
+Requires-Dist: vtlengine (>=1.2,<2.0) ; extra == "all"
+Requires-Dist: vtlengine (>=1.2,<2.0) ; extra == "vtl"
 Requires-Dist: xmltodict (>=0.13) ; extra == "all"
 Requires-Dist: xmltodict (>=0.13) ; extra == "xml"
 Project-URL: Bug Tracker, https://bis-med-it.github.io/pysdmx/issues

{pysdmx-1.9.0 → pysdmx-1.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pysdmx"
-version = "1.9.0"
+version = "1.10.0"
 description = "Your opinionated Python SDMX library"
 license = { text = "Apache-2.0" }
 readme = "README.rst"
@@ -35,10 +35,10 @@ documentation = "https://bis-med-it.github.io/pysdmx"
 [project.optional-dependencies]
 data = ["pandas>=2.1.4"]
 dc = ["python-dateutil>=2.8.2"]
-vtl = ["vtlengine>=1.1,<2.0"]
+vtl = ["vtlengine>=1.2,<2.0"]
 json = ["sdmxschemas>=1.0.0", "jsonschema>=4.10"]
 xml = ["lxml>=5.2", "xmltodict>=0.13", "sdmxschemas>=1.0.0"]
-all = ["lxml>=5.2", "xmltodict>=0.13", "sdmxschemas>=1.0.0", "pandas>=2.1.4", "python-dateutil>=2.8.2", "vtlengine>=1.1,<2.0"]
+all = ["lxml>=5.2", "xmltodict>=0.13", "sdmxschemas>=1.0.0", "pandas>=2.1.4", "python-dateutil>=2.8.2", "vtlengine>=1.2,<2.0"]
 
 [tool.poetry]
 requires-poetry = ">=2.0"
@@ -48,7 +48,7 @@ python = ">=3.9,<4.0"
 
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.13.2"
-mypy = "^1.1.1"
+mypy = "^1.18.2"
 pytest = "^8.3.2"
 pytest-asyncio = "^0.21.1"
 pytest-cov = "^4.0.0"

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/__extras_check.py

@@ -46,7 +46,7 @@ def __check_xml_extra() -> None:
 
 def __check_vtl_extra() -> None:
     try:
-        import vtlengine  # type: ignore[import-untyped]  # noqa: F401
+        import vtlengine  # noqa: F401
     except ImportError:
         raise ImportError(
             ERROR_MESSAGE.format(

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/__init__.py

@@ -1,3 +1,3 @@
 """Your opinionated Python SDMX library."""
 
-__version__ = "1.9.0"
+__version__ = "1.10.0"

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/api/fmr/__init__.py

@@ -44,6 +44,7 @@ from pysdmx.model import (
     Metadataflow,
     MetadataProvisionAgreement,
     MetadataReport,
+    MetadataStructure,
     MultiRepresentationMap,
     ProvisionAgreement,
     RepresentationMap,
@@ -767,7 +768,7 @@ class RegistryClient(__BaseRegistryClient):
         agency: str = "*",
         id: str = "*",
         version: str = "+",
-    ) -> Sequence[Dataflow]:
+    ) -> Sequence[MetadataStructure]:
         """Get the metadata structures (MSD) matching the supplied parameters.
 
         Args:
@@ -1341,7 +1342,7 @@ class AsyncRegistryClient(__BaseRegistryClient):
         agency: str = "*",
         id: str = "*",
         version: str = "+",
-    ) -> Sequence[Dataflow]:
+    ) -> Sequence[MetadataStructure]:
         """Get the metadata structures (MSD) matching the supplied parameters.
 
         Args:

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/io/input_processor.py

@@ -29,16 +29,19 @@ def __check_xml(input_str: str) -> bool:
 
 def __check_csv(input_str: str) -> bool:
     try:
-        max_length = min(2048, len(input_str))
-        dialect = csv.Sniffer().sniff(input_str[:max_length])
+        lines = input_str.splitlines()
+
+        # Use the first N complete lines
+        # (1 should be enough)
+        max_lines = 1
+        sample = "\n".join(lines[:max_lines])
+
+        dialect = csv.Sniffer().sniff(sample)
         control_csv_format = (
             dialect.delimiter == "," and dialect.quotechar == '"'
         )
         # Check we can access the data and it is not empty
-        if (
-            len(input_str.splitlines()) > 1
-            or input_str.splitlines()[0].count(",") > 1
-        ) and control_csv_format:
+        if (len(lines) > 1 or lines[0].count(",") > 1) and control_csv_format:
             return True
     except Exception:
         return False

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/io/json/sdmxjson2/messages/__init__.py

@@ -12,6 +12,9 @@ from pysdmx.io.json.sdmxjson2.messages.code import (
     JsonHierarchyMessage,
 )
 from pysdmx.io.json.sdmxjson2.messages.concept import JsonConceptSchemeMessage
+from pysdmx.io.json.sdmxjson2.messages.constraint import (
+    JsonDataConstraintMessage,
+)
 from pysdmx.io.json.sdmxjson2.messages.dataflow import (
     JsonDataflowMessage,
     JsonDataflowsMessage,
@@ -50,6 +53,7 @@ __all__ = [
     "JsonCategorySchemeMessage",
     "JsonCodelistMessage",
     "JsonConceptSchemeMessage",
+    "JsonDataConstraintMessage",
     "JsonDataflowMessage",
     "JsonDataflowsMessage",
     "JsonDataStructuresMessage",

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/io/json/sdmxjson2/messages/code.py

@@ -231,7 +231,7 @@ class JsonCodelists(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for lists of codes."""
 
     codelists: Sequence[JsonCodelist] = ()
-    valuelists: Sequence[JsonValuelist] = ()
+    valueLists: Sequence[JsonValuelist] = ()
 
 
 class JsonCodelistMessage(Struct, frozen=True, omit_defaults=True):
@@ -244,7 +244,7 @@ class JsonCodelistMessage(Struct, frozen=True, omit_defaults=True):
         if self.data.codelists:
             return self.data.codelists[0].to_model()
         else:
-            return self.data.valuelists[0].to_model()
+            return self.data.valueLists[0].to_model()
 
 
 class JsonHierarchicalCode(Struct, frozen=True, omit_defaults=True):
@@ -329,10 +329,10 @@ class JsonHierarchicalCode(Struct, frozen=True, omit_defaults=True):
             code=code.urn,
             validFrom=code.rel_valid_from,
             validTo=code.rel_valid_to,
-            annotations=tuple(annotations),
-            hierarchicalCodes=[
-                JsonHierarchicalCode.from_model(c) for c in code.codes
-            ],
+            annotations=tuple(annotations) if annotations else None,
+            hierarchicalCodes=tuple(
+                [JsonHierarchicalCode.from_model(c) for c in code.codes]
+            ),
         )
 
 
@@ -475,6 +475,15 @@ class JsonHierarchyAssociation(
                 "SDMX-JSON hierarchy associations must reference a context",
                 {"hierarchy_association": ha.id},
             )
+        lnk = (
+            JsonLink(
+                rel="UserDefinedOperator",
+                type="sdmx_artefact",
+                urn=ha.operator,
+            )
+            if ha.operator
+            else None
+        )
         return JsonHierarchyAssociation(
             agency=(
                 ha.agency.id if isinstance(ha.agency, Agency) else ha.agency
@@ -492,6 +501,7 @@ class JsonHierarchyAssociation(
             linkedHierarchy=href,
             linkedObject=ha.component_ref,
             contextObject=ha.context_ref,
+            links=[lnk] if lnk else (),
         )
 
 

pysdmx-1.10.0/src/pysdmx/io/json/sdmxjson2/messages/constraint.py

@@ -0,0 +1,272 @@
+"""Collection of SDMX-JSON schemas for content constraints."""
+
+from datetime import datetime
+from typing import Optional, Sequence
+
+from msgspec import Struct
+
+from pysdmx import errors
+from pysdmx.io.json.sdmxjson2.messages.core import (
+    JsonAnnotation,
+    MaintainableType,
+)
+from pysdmx.model import (
+    Agency,
+    ConstraintAttachment,
+    CubeKeyValue,
+    CubeRegion,
+    CubeValue,
+    DataConstraint,
+    DataKey,
+    DataKeyValue,
+    KeySet,
+)
+
+
+class JsonValue(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for a cube value."""
+
+    value: str
+    validFrom: Optional[datetime] = None
+    validTo: Optional[datetime] = None
+
+    def to_model(self) -> CubeValue:
+        """Converts a JsonValue to a CubeValue."""
+        return CubeValue(self.value, self.validFrom, self.validTo)
+
+    @classmethod
+    def from_model(self, cv: CubeValue) -> "JsonValue":
+        """Converts a pysdmx cube value to an SDMX-JSON one."""
+        return JsonValue(cv.value, cv.valid_from, cv.valid_to)
+
+
+class JsonKeyValue(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for the list of allowed values per component."""
+
+    id: str
+    values: Sequence[JsonValue]
+    # Additional properties are supported in the model (include,
+    # removePrefix, validFrom, validTo, timeRange) but not by the FMR.
+    # Therefore, they are ignored for now.
+
+    def to_model(self) -> CubeKeyValue:
+        """Converts a JsonKeyValue to a CubeKeyValue."""
+        return CubeKeyValue(self.id, [v.to_model() for v in self.values])
+
+    @classmethod
+    def from_model(self, key_value: CubeKeyValue) -> "JsonKeyValue":
+        """Converts a pysdmx cube key value to an SDMX-JSON one."""
+        return JsonKeyValue(
+            key_value.id, [JsonValue.from_model(v) for v in key_value.values]
+        )
+
+
+class JsonCubeRegion(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for a cube region."""
+
+    # The property `components` is ignored as it's not used in the FMR`
+    keyValues: Sequence[JsonKeyValue]
+    include: bool = True
+
+    def to_model(self) -> CubeRegion:
+        """Converts a JsonCubeRegion to a CubeRegion."""
+        return CubeRegion(
+            [kv.to_model() for kv in self.keyValues], self.include
+        )
+
+    @classmethod
+    def from_model(self, region: CubeRegion) -> "JsonCubeRegion":
+        """Converts a pysdmx cube region to an SDMX-JSON one."""
+        return JsonCubeRegion(
+            [JsonKeyValue.from_model(kv) for kv in region.key_values],
+            region.is_included,
+        )
+
+
+class JsonConstraintAttachment(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for a constraint attachment."""
+
+    dataProvider: Optional[str] = None
+    dataStructures: Sequence[str] = ()
+    dataflows: Sequence[str] = ()
+    provisionAgreements: Sequence[str] = ()
+
+    def to_model(self) -> ConstraintAttachment:
+        """Converts a JsonConstraintAttachment to a ConstraintAttachment."""
+        return ConstraintAttachment(
+            self.dataProvider,
+            self.dataStructures,
+            self.dataflows,
+            self.provisionAgreements,
+        )
+
+    @classmethod
+    def from_model(
+        self, attachment: ConstraintAttachment
+    ) -> "JsonConstraintAttachment":
+        """Converts a pysdmx constraint attachment to an SDMX-JSON one."""
+        ds = attachment.data_structures if attachment.data_structures else ()
+        df = attachment.dataflows if attachment.dataflows else ()
+        pa = (
+            attachment.provision_agreements
+            if attachment.provision_agreements
+            else ()
+        )
+        return JsonConstraintAttachment(attachment.data_provider, ds, df, pa)
+
+
+class JsonDataKeyValue(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for a data key value."""
+
+    id: str
+    value: str
+
+    def to_model(self) -> DataKeyValue:
+        """Converts a JsonDataKeyValue to a DataKeyValue."""
+        return DataKeyValue(self.id, self.value)
+
+    @classmethod
+    def from_model(self, kv: DataKeyValue) -> "JsonDataKeyValue":
+        """Converts a pysdmx key value to an SDMX-JSON one."""
+        return JsonDataKeyValue(kv.id, kv.value)
+
+
+class JsonDataKey(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for a data key."""
+
+    keyValues: Sequence[JsonDataKeyValue]
+    validFrom: Optional[datetime] = None
+    validTo: Optional[datetime] = None
+
+    def to_model(self) -> DataKey:
+        """Converts a JsonDataKey to a DataKey."""
+        return DataKey(
+            [kv.to_model() for kv in self.keyValues],
+            self.validFrom,
+            self.validTo,
+        )
+
+    @classmethod
+    def from_model(self, kv: DataKey) -> "JsonDataKey":
+        """Converts a pysdmx key constraint to an SDMX-JSON one."""
+        return JsonDataKey(
+            [JsonDataKeyValue.from_model(val) for val in kv.keys_values],
+            kv.valid_from,
+            kv.valid_to,
+        )
+
+
+class JsonKeySet(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for a keyset."""
+
+    keys: Sequence[JsonDataKey]
+    isIncluded: bool
+
+    def to_model(self) -> KeySet:
+        """Converts a JsonKeySet to a KeySet."""
+        return KeySet([k.to_model() for k in self.keys], self.isIncluded)
+
+    @classmethod
+    def from_model(self, ks: KeySet) -> "JsonKeySet":
+        """Converts a pysdmx key set constraint to an SDMX-JSON one."""
+        return JsonKeySet(
+            [JsonDataKey.from_model(k) for k in ks.keys], ks.is_included
+        )
+
+
+class JsonDataConstraint(MaintainableType, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for a content constraint."""
+
+    constraintAttachment: Optional[JsonConstraintAttachment] = None
+    cubeRegions: Optional[Sequence[JsonCubeRegion]] = None
+    dataKeySets: Optional[Sequence[JsonKeySet]] = None
+
+    def to_model(self) -> DataConstraint:
+        """Converts a JsonDataConstraint to a pysdmx Data Constraint."""
+        at = self.constraintAttachment.to_model()  # type: ignore[union-attr]
+        return DataConstraint(
+            id=self.id,
+            name=self.name,
+            agency=self.agency,
+            description=self.description,
+            version=self.version,
+            annotations=tuple([a.to_model() for a in self.annotations]),
+            is_external_reference=self.isExternalReference,
+            valid_from=self.validFrom,
+            valid_to=self.validTo,
+            constraint_attachment=at,
+            cube_regions=[r.to_model() for r in self.cubeRegions]
+            if self.cubeRegions
+            else (),
+            key_sets=[s.to_model() for s in self.dataKeySets]
+            if self.dataKeySets
+            else (),
+        )
+
+    @classmethod
+    def from_model(self, cons: DataConstraint) -> "JsonDataConstraint":
+        """Converts a pysdmx constraint to an SDMX-JSON one."""
+        crs = (
+            [JsonCubeRegion.from_model(r) for r in cons.cube_regions]
+            if cons.cube_regions
+            else None
+        )
+        dks = (
+            [JsonKeySet.from_model(s) for s in cons.key_sets]
+            if cons.key_sets
+            else None
+        )
+        if not cons.name:
+            raise errors.Invalid(
+                "Invalid input",
+                "SDMX-JSON data constraints must have a name",
+                {"data_constraint": cons.id},
+            )
+        if not cons.constraint_attachment:
+            raise errors.Invalid(
+                "Invalid input",
+                "SDMX-JSON data constraints must have a constraint attachment",
+                {"data_constraint": cons.id},
+            )
+        return JsonDataConstraint(
+            id=cons.id,
+            name=cons.name,
+            agency=(
+                cons.agency.id
+                if isinstance(cons.agency, Agency)
+                else cons.agency
+            ),
+            description=cons.description,
+            version=cons.version,
+            annotations=tuple(
+                [JsonAnnotation.from_model(a) for a in cons.annotations]
+            ),
+            isExternalReference=cons.is_external_reference,
+            validFrom=cons.valid_from,
+            validTo=cons.valid_to,
+            constraintAttachment=JsonConstraintAttachment.from_model(
+                cons.constraint_attachment
+            ),
+            cubeRegions=crs,
+            dataKeySets=dks,
+        )
+
+
+class JsonDataConstraints(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for data constraints."""
+
+    dataConstraints: Sequence[JsonDataConstraint] = ()
+
+    def to_model(self) -> Sequence[DataConstraint]:
+        """Returns the requested data constraints."""
+        return [cc.to_model() for cc in self.dataConstraints]
+
+
+class JsonDataConstraintMessage(Struct, frozen=True, omit_defaults=True):
+    """SDMX-JSON payload for /dataconstraint queries."""
+
+    data: JsonDataConstraints
+
+    def to_model(self) -> Sequence[DataConstraint]:
+        """Returns the requested data constraints."""
+        return self.data.to_model()

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/io/json/sdmxjson2/messages/dsd.py

@@ -265,12 +265,17 @@ class JsonAttribute(Struct, frozen=True, omit_defaults=True):
             attribute.attachment_level  # type: ignore[arg-type]
         )
         repr = _get_json_representation(attribute)
+        # The line below will need to be changed when we work on
+        # Measure Relationship (cf. issue #467)
+        mr = ["OBS_VALUE"] if attribute.attachment_level == "O" else None
+
         return JsonAttribute(
             id=attribute.id,
             conceptIdentity=concept,
             attributeRelationship=level,
             usage=usage,
             localRepresentation=repr,
+            measureRelationship=mr,
         )
 
 
@@ -447,19 +452,42 @@ class JsonComponents(Struct, frozen=True, omit_defaults=True):
         enums = [cl.to_model() for cl in cls]
         enums.extend([vl.to_model() for vl in vls])
         comps = []
-        if constraints and constraints[0].cubeRegions:
-            cons = constraints[0].cubeRegions[0].to_map()
+        if constraints:
+            incl_cubes = []
+            for const in constraints:
+                incl_cubes.extend(
+                    [cr for cr in (const.cubeRegions or []) if cr.include]
+                )
+            if len(incl_cubes) == 1:
+                cons = {
+                    kv.id: [v.value for v in kv.values]
+                    for kv in incl_cubes[0].keyValues
+                }
+            else:
+                cons = {}
         else:
             cons = {}
-        comps.extend(self.dimensionList.to_model(cs, enums, cons))
+        comps.extend(
+            self.dimensionList.to_model(
+                cs,
+                enums,
+                cons,  # type: ignore[arg-type]
+            )
+        )
         if self.measureList:
-            comps.extend(self.measureList.to_model(cs, enums, cons))
+            comps.extend(
+                self.measureList.to_model(
+                    cs,
+                    enums,
+                    cons,  # type: ignore[arg-type]
+                )
+            )
         if self.attributeList:
             comps.extend(
                 self.attributeList.to_model(
                     cs,
                     enums,
-                    cons,
+                    cons,  # type: ignore[arg-type]
                     self.groups,
                 )
             )
@@ -556,7 +584,7 @@ class JsonDataStructures(Struct, frozen=True, omit_defaults=True):
     conceptSchemes: Sequence[JsonConceptScheme] = ()
     valuelists: Sequence[JsonValuelist] = ()
     codelists: Sequence[JsonCodelist] = ()
-    contentConstraints: Sequence[JsonDataConstraint] = ()
+    dataConstraints: Sequence[JsonDataConstraint] = ()
 
     def to_model(self) -> Sequence[DataStructureDefinition]:
         """Returns the requested dsds."""
@@ -565,7 +593,7 @@ class JsonDataStructures(Struct, frozen=True, omit_defaults=True):
                 self.conceptSchemes,
                 self.codelists,
                 self.valuelists,
-                self.contentConstraints,
+                self.dataConstraints,
             )
             for dsd in self.dataStructures
         ]

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/io/json/sdmxjson2/messages/map.py

@@ -87,19 +87,20 @@ class JsonRepresentationMapping(Struct, frozen=True, omit_defaults=True):
         self, vm: Union[MultiValueMap, ValueMap]
     ) -> "JsonRepresentationMapping":
         """Converts a value map to an SDMX-JSON JsonRepresentationMapping."""
+        fmt = r"%Y-%m-%dT%H:%M:%S"
         if isinstance(vm, ValueMap):
             return JsonRepresentationMapping(
                 [JsonSourceValue.from_model(vm.source)],
                 [vm.target],
-                vm.valid_from.strftime("%Y-%m-%d") if vm.valid_from else None,
-                vm.valid_to.strftime("%Y-%m-%d") if vm.valid_to else None,
+                vm.valid_from.strftime(fmt) if vm.valid_from else None,
+                vm.valid_to.strftime(fmt) if vm.valid_to else None,
             )
         else:
             return JsonRepresentationMapping(
                 [JsonSourceValue.from_model(s) for s in vm.source],
                 vm.target,
-                vm.valid_from.strftime("%Y-%m-%d") if vm.valid_from else None,
-                vm.valid_to.strftime("%Y-%m-%d") if vm.valid_to else None,
+                vm.valid_from.strftime(fmt) if vm.valid_from else None,
+                vm.valid_to.strftime(fmt) if vm.valid_to else None,
             )
 
 

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/io/json/sdmxjson2/messages/metadataflow.py

@@ -65,6 +65,7 @@ class JsonMetadataflow(MaintainableType, frozen=True, omit_defaults=True):
                 [JsonAnnotation.from_model(a) for a in df.annotations]
             ),
             structure=dsdref,
+            targets=df.targets,  # type: ignore[arg-type]
         )
 
 

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/io/json/sdmxjson2/messages/msd.py

@@ -15,7 +15,6 @@ from pysdmx.io.json.sdmxjson2.messages.core import (
 from pysdmx.io.json.sdmxjson2.messages.dsd import (
     _find_concept,
     _get_concept_reference,
-    _get_json_representation,
     _get_representation,
 )
 from pysdmx.model import (
@@ -28,6 +27,13 @@ from pysdmx.model import (
 from pysdmx.util import parse_item_urn
 
 
+def _get_attr_repr(comp: MetadataComponent) -> 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, None
+    )
+
+
 class JsonMetadataAttribute(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for an attribute."""
 
@@ -80,11 +86,13 @@ class JsonMetadataAttribute(Struct, frozen=True, omit_defaults=True):
     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)
+        repr = _get_attr_repr(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"
+        if cmp.array_def is None:
+            max_occurs: Union[int, Literal["unbounded"]] = 1
+        elif cmp.array_def.max_size is None:
+            max_occurs = "unbounded"
         else:
             max_occurs = cmp.array_def.max_size
 
@@ -95,9 +103,9 @@ class JsonMetadataAttribute(Struct, frozen=True, omit_defaults=True):
             minOccurs=min_occurs,
             maxOccurs=max_occurs,
             isPresentational=cmp.is_presentational,
-            metadataAttributes=[
-                JsonMetadataAttribute.from_model(c) for c in cmp.components
-            ],
+            metadataAttributes=tuple(
+                [JsonMetadataAttribute.from_model(c) for c in cmp.components]
+            ),
         )
 
 
@@ -119,9 +127,9 @@ class JsonMetadataAttributes(Struct, frozen=True, omit_defaults=True):
     ) -> "JsonMetadataAttributes":
         """Converts a pysdmx list of metadata attributes to SDMX-JSON."""
         return JsonMetadataAttributes(
-            metadataAttributes=[
-                JsonMetadataAttribute.from_model(a) for a in attributes
-            ]
+            metadataAttributes=tuple(
+                [JsonMetadataAttribute.from_model(a) for a in attributes]
+            )
         )
 
 

{pysdmx-1.9.0 → pysdmx-1.10.0}/src/pysdmx/io/json/sdmxjson2/messages/schema.py

@@ -21,7 +21,7 @@ class JsonSchemas(msgspec.Struct, frozen=True, omit_defaults=True):
     dataStructures: Sequence[JsonDataStructure]
     valuelists: Sequence[JsonValuelist] = ()
     codelists: Sequence[JsonCodelist] = ()
-    contentConstraints: Sequence[JsonDataConstraint] = ()
+    dataConstraints: Sequence[JsonDataConstraint] = ()
 
     def to_model(
         self,
@@ -32,7 +32,7 @@ class JsonSchemas(msgspec.Struct, frozen=True, omit_defaults=True):
             self.conceptSchemes,
             self.codelists,
             self.valuelists,
-            self.contentConstraints,
+            self.dataConstraints,
         )
         return comps, grps  # type: ignore[return-value]