pysdmx 1.10.0__py3-none-any.whl → 1.10.0rc1__py3-none-any.whl

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

@@ -17,7 +17,6 @@ from pysdmx.io.json.sdmxjson2.messages.code import (
     JsonValuelist,
 )
 from pysdmx.io.json.sdmxjson2.messages.concept import JsonConceptScheme
-from pysdmx.io.json.sdmxjson2.messages.constraint import JsonDataConstraint
 from pysdmx.io.json.sdmxjson2.messages.core import JsonHeader
 from pysdmx.io.json.sdmxjson2.messages.dataflow import JsonDataflow
 from pysdmx.io.json.sdmxjson2.messages.dsd import JsonDataStructure
@@ -50,95 +49,90 @@ from pysdmx.model.message import StructureMessage
 class JsonStructures(Struct, frozen=True, omit_defaults=True):
     """The allowed strutures."""
 
-    agencySchemes: Sequence[JsonAgencyScheme] = ()
-    categorisations: Sequence[JsonCategorisation] = ()
+    dataStructures: Sequence[JsonDataStructure] = ()
     categorySchemes: Sequence[JsonCategoryScheme] = ()
-    codelists: Sequence[JsonCodelist] = ()
     conceptSchemes: Sequence[JsonConceptScheme] = ()
-    customTypeSchemes: Sequence[JsonCustomTypeScheme] = ()
-    dataConstraints: Sequence[JsonDataConstraint] = ()
-    dataflows: Sequence[JsonDataflow] = ()
-    dataProviderSchemes: Sequence[JsonDataProviderScheme] = ()
-    dataStructures: Sequence[JsonDataStructure] = ()
+    codelists: Sequence[JsonCodelist] = ()
+    valueLists: Sequence[JsonValuelist] = ()
     hierarchies: Sequence[JsonHierarchy] = ()
     hierarchyAssociations: Sequence[JsonHierarchyAssociation] = ()
-    metadataflows: Sequence[JsonMetadataflow] = ()
+    agencySchemes: Sequence[JsonAgencyScheme] = ()
+    dataProviderSchemes: Sequence[JsonDataProviderScheme] = ()
     metadataProviderSchemes: Sequence[JsonMetadataProviderScheme] = ()
+    dataflows: Sequence[JsonDataflow] = ()
+    provisionAgreements: Sequence[JsonProvisionAgreement] = ()
+    metadataflows: Sequence[JsonMetadataflow] = ()
     metadataProvisionAgreements: Sequence[JsonMetadataProvisionAgreement] = ()
     metadataStructures: Sequence[JsonMetadataStructure] = ()
-    namePersonalisationSchemes: Sequence[JsonNamePersonalisationScheme] = ()
-    provisionAgreements: Sequence[JsonProvisionAgreement] = ()
+    structureMaps: Sequence[JsonStructureMap] = ()
     representationMaps: Sequence[JsonRepresentationMap] = ()
+    categorisations: Sequence[JsonCategorisation] = ()
+    customTypeSchemes: Sequence[JsonCustomTypeScheme] = ()
+    vtlMappingSchemes: Sequence[JsonVtlMappingScheme] = ()
+    namePersonalisationSchemes: Sequence[JsonNamePersonalisationScheme] = ()
     rulesetSchemes: Sequence[JsonRulesetScheme] = ()
-    structureMaps: Sequence[JsonStructureMap] = ()
     transformationSchemes: Sequence[JsonTransformationScheme] = ()
     userDefinedOperatorSchemes: Sequence[JsonUserDefinedOperatorScheme] = ()
-    valueLists: Sequence[JsonValuelist] = ()
-    vtlMappingSchemes: Sequence[JsonVtlMappingScheme] = ()
 
     def to_model(self) -> Sequence[MaintainableArtefact]:
         """Map to pysdmx artefacts."""
         structures = []  # type: ignore[var-annotated]
         structures.extend(
-            i.to_model(self.dataflows) for i in self.agencySchemes
+            i.to_model(
+                self.conceptSchemes, self.codelists, self.valueLists, ()
+            )
+            for i in self.dataStructures
         )
-        structures.extend(i.to_model() for i in self.categorisations)
         structures.extend(i.to_model() for i in self.categorySchemes)
-        structures.extend(i.to_model() for i in self.codelists)
         structures.extend(
             i.to_model(self.codelists) for i in self.conceptSchemes
         )
-        structures.extend(i.to_model() for i in self.customTypeSchemes)
-        structures.extend(i.to_model() for i in self.dataConstraints)
-        structures.extend(
-            i.to_model(
-                self.dataStructures,
-                self.conceptSchemes,
-                self.valueLists,
-                self.codelists,
-            )
-            for i in self.dataflows
-        )
+        structures.extend(i.to_model() for i in self.codelists)
+        structures.extend(i.to_model() for i in self.valueLists)
+        structures.extend(i.to_model(self.codelists) for i in self.hierarchies)
         structures.extend(
-            i.to_model(self.provisionAgreements)
-            for i in self.dataProviderSchemes
+            i.to_model(self.hierarchies, self.codelists)
+            for i in self.hierarchyAssociations
         )
         structures.extend(
-            i.to_model(
-                self.conceptSchemes, self.codelists, self.valueLists, ()
-            )
-            for i in self.dataStructures
+            i.to_model(self.dataflows) for i in self.agencySchemes
         )
-        structures.extend(i.to_model(self.codelists) for i in self.hierarchies)
         structures.extend(
-            i.to_model(self.hierarchies, self.codelists)
-            for i in self.hierarchyAssociations
+            i.to_model(self.provisionAgreements)
+            for i in self.dataProviderSchemes
         )
-
-        structures.extend(i.to_model() for i in self.metadataflows)
         structures.extend(
             i.to_model(self.metadataProvisionAgreements)
             for i in self.metadataProviderSchemes
         )
-        structures.extend(
-            i.to_model() for i in self.metadataProvisionAgreements
-        )
         structures.extend(
             i.to_model(self.conceptSchemes, self.codelists, self.valueLists)
             for i in self.metadataStructures
         )
         structures.extend(
-            i.to_model() for i in self.namePersonalisationSchemes
+            i.to_model(
+                self.dataStructures,
+                self.conceptSchemes,
+                self.valueLists,
+                self.codelists,
+            )
+            for i in self.dataflows
         )
         structures.extend(i.to_model() for i in self.provisionAgreements)
+        structures.extend(i.to_model() for i in self.metadataflows)
         structures.extend(
-            i.to_model(bool(len(i.source) > 1 or len(i.target) > 1))
-            for i in self.representationMaps
+            i.to_model() for i in self.metadataProvisionAgreements
         )
-        structures.extend(i.to_model() for i in self.rulesetSchemes)
         structures.extend(
             i.to_model(self.representationMaps) for i in self.structureMaps
         )
+        structures.extend(i.to_model() for i in self.categorisations)
+        structures.extend(i.to_model() for i in self.customTypeSchemes)
+        structures.extend(i.to_model() for i in self.vtlMappingSchemes)
+        structures.extend(
+            i.to_model() for i in self.namePersonalisationSchemes
+        )
+        structures.extend(i.to_model() for i in self.rulesetSchemes)
         structures.extend(
             i.to_model(
                 self.customTypeSchemes,
@@ -152,8 +146,9 @@ class JsonStructures(Struct, frozen=True, omit_defaults=True):
         structures.extend(
             i.to_model() for i in self.userDefinedOperatorSchemes
         )
-        structures.extend(i.to_model() for i in self.valueLists)
-        structures.extend(i.to_model() for i in self.vtlMappingSchemes)
+        for rm in self.representationMaps:
+            multi = bool(len(rm.source) > 1 or len(rm.target) > 1)
+            structures.append(rm.to_model(multi))
         return structures
 
     @classmethod
@@ -269,33 +264,6 @@ class JsonStructures(Struct, frozen=True, omit_defaults=True):
         hierarchies = tuple(
             [JsonHierarchy.from_model(h) for h in msg.get_hierarchies()]
         )
-        constraints = tuple(
-            [
-                JsonDataConstraint.from_model(c)
-                for c in msg.get_data_constraints()
-            ]
-        )
-        mpas = tuple(
-            [
-                JsonMetadataProvisionAgreement.from_model(c)
-                for c in msg.get_metadata_provision_agreements()
-            ]
-        )
-        mprvs = tuple(
-            [
-                JsonMetadataProviderScheme.from_model(c)
-                for c in msg.get_metadata_provider_schemes()
-            ]
-        )
-        mdfs = tuple(
-            [JsonMetadataflow.from_model(c) for c in msg.get_metadataflows()]
-        )
-        msds = tuple(
-            [
-                JsonMetadataStructure.from_model(c)
-                for c in msg.get_metadata_structures()
-            ]
-        )
         return JsonStructures(
             agencySchemes=agencies,
             categorisations=categorisations,
@@ -303,16 +271,11 @@ class JsonStructures(Struct, frozen=True, omit_defaults=True):
             codelists=codelists,
             conceptSchemes=concept_schemes,
             customTypeSchemes=custom_types,
-            dataConstraints=constraints,
             dataflows=dataflows,
             dataProviderSchemes=data_providers,
             dataStructures=data_structures,
             hierarchies=hierarchies,
             hierarchyAssociations=hier_associations,
-            metadataflows=mdfs,
-            metadataProviderSchemes=mprvs,
-            metadataProvisionAgreements=mpas,
-            metadataStructures=msds,
             namePersonalisationSchemes=name_personalisations,
             provisionAgreements=agreements,
             representationMaps=representations_maps,

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

@@ -1,6 +1,6 @@
 """Collection of SDMX-JSON schemas for VTL artefacts."""
 
-from typing import Dict, Literal, Optional, Sequence
+from typing import Literal, Optional, Sequence
 
 from msgspec import Struct
 
@@ -506,37 +506,33 @@ class JsonRulesetScheme(ItemSchemeType, frozen=True, omit_defaults=True):
 class JsonToVtlMapping(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for To VTL mappings."""
 
-    toVtlSubSpace: Dict[str, Sequence[str]]
-    method: Optional[str] = None
+    toVtlSubSpace: Sequence[str]
+    type: Optional[str] = None
 
     def to_model(self) -> ToVtlMapping:
         """Converts deserialized class to pysdmx model class."""
-        return ToVtlMapping(self.toVtlSubSpace["keys"], self.method)
+        return ToVtlMapping(self.toVtlSubSpace, self.type)
 
     @classmethod
     def from_model(cls, mapping: ToVtlMapping) -> "JsonToVtlMapping":
         """Converts a pysdmx "to VTL" mapping to an SDMX-JSON one."""
-        return JsonToVtlMapping(
-            {"keys": mapping.to_vtl_sub_space}, mapping.method
-        )
+        return JsonToVtlMapping(mapping.to_vtl_sub_space, mapping.method)
 
 
 class JsonFromVtlMapping(Struct, frozen=True, omit_defaults=True):
     """SDMX-JSON payload for from VTL mappings."""
 
-    fromVtlSuperSpace: Dict[str, Sequence[str]]
-    method: Optional[str] = None
+    fromVtlSuperSpace: Sequence[str]
+    type: Optional[str] = None
 
     def to_model(self) -> FromVtlMapping:
         """Converts deserialized class to pysdmx model class."""
-        return FromVtlMapping(self.fromVtlSuperSpace["keys"], self.method)
+        return FromVtlMapping(self.fromVtlSuperSpace, self.type)
 
     @classmethod
     def from_model(cls, mapping: FromVtlMapping) -> "JsonFromVtlMapping":
         """Converts a pysdmx "from VTL" mapping to an SDMX-JSON one."""
-        return JsonFromVtlMapping(
-            {"keys": mapping.from_vtl_sub_space}, mapping.method
-        )
+        return JsonFromVtlMapping(mapping.from_vtl_sub_space, mapping.method)
 
 
 class JsonVtlMapping(NameableType, frozen=True, omit_defaults=True):

pysdmx/io/json/sdmxjson2/reader/doc_validation.py

@@ -88,10 +88,6 @@ def validate_sdmx_json(input_str: str) -> None:
                     lambda m: f"does not match required"
                     f" pattern {m.group(1)!r}",
                 ),
-                (
-                    r"\[\]\s+is\s+too\s+short",
-                    lambda _m: "[] should be non-empty",
-                ),
             ]
 
             msg: Optional[str] = next(

pysdmx/model/__base.py

@@ -1,6 +1,5 @@
-import re
 from datetime import datetime
-from typing import Any, Literal, Optional, Sequence, Union
+from typing import Any, Optional, Sequence, Union
 
 from msgspec import Struct
 
@@ -328,50 +327,6 @@ class ItemScheme(MaintainableArtefact, frozen=True, omit_defaults=True):
     items: Sequence[Item] = ()
     is_partial: bool = False
 
-    def search(
-        self,
-        query: str,
-        use_regex: bool = False,
-        fields: Literal["name", "description", "all"] = "all",
-    ) -> Sequence[Item]:
-        """Search for items matching the query.
-
-        Args:
-            query: The substring or regex pattern to search for.
-            use_regex: Whether to treat the query as a regex (default: False).
-            fields: The fields to search in (default: all textual fields).
-
-        Returns:
-           Items that match the query.
-        """
-        if not query:
-            raise Invalid(
-                "Invalid search", "The query string cannot be empty."
-            )
-
-        # Determine which fields to search in
-        search_fields = (
-            ["name", "description"] if fields == "all" else [fields]
-        )
-
-        # Transform plain text queries into a regex
-        if not use_regex:
-            query = re.escape(query)
-
-        pattern = re.compile(query, re.IGNORECASE if not use_regex else 0)
-
-        all_items = getattr(self, "all_items", "")
-        items = all_items if all_items else self.items
-
-        return [
-            item  # type: ignore[misc]
-            for item in items
-            if any(
-                pattern.search(str(getattr(item, field, "")))
-                for field in search_fields
-            )
-        ]
-
 
 class DataflowRef(
     Struct, frozen=True, omit_defaults=True, repr_omit_defaults=True, tag=True

pysdmx/model/__init__.py

@@ -29,16 +29,6 @@ from pysdmx.model.code import (
     HierarchyAssociation,
 )
 from pysdmx.model.concept import Concept, ConceptScheme, DataType, Facets
-from pysdmx.model.constraint import (
-    ConstraintAttachment,
-    CubeKeyValue,
-    CubeRegion,
-    CubeValue,
-    DataConstraint,
-    DataKey,
-    DataKeyValue,
-    KeySet,
-)
 from pysdmx.model.dataflow import (
     ArrayBoundaries,
     Component,
@@ -171,16 +161,9 @@ __all__ = [
     "ComponentMap",
     "Concept",
     "ConceptScheme",
-    "ConstraintAttachment",
     "Contact",
-    "CubeKeyValue",
-    "CubeRegion",
-    "CubeValue",
     "DataConsumer",
     "DataConsumerScheme",
-    "DataConstraint",
-    "DataKey",
-    "DataKeyValue",
     "Dataflow",
     "DataflowInfo",
     "DataflowRef",
@@ -197,7 +180,6 @@ __all__ = [
     "HierarchyAssociation",
     "ImplicitComponentMap",
     "ItemReference",
-    "KeySet",
     "MetadataAttribute",
     "MetadataComponent",
     "Metadataflow",

pysdmx/model/category.py

@@ -91,15 +91,6 @@ class CategoryScheme(ItemScheme, frozen=True, omit_defaults=True):
             flows.update(self.__extract_flows(cat))
         return list(flows)
 
-    @property
-    def all_items(self) -> Sequence[Category]:
-        """Get all the categories in the category scheme as a flat list.
-
-        Returns:
-            A flat list of all the categories present in the category scheme.
-        """
-        return self.__get_categories(self.categories)
-
     def __iter__(self) -> Iterator[Category]:
         """Return an iterator over the list of categories."""
         yield from self.categories
@@ -169,14 +160,6 @@ class CategoryScheme(ItemScheme, frozen=True, omit_defaults=True):
             processed_output.append(f"{attr}: {value}")
         return f"{', '.join(processed_output)}"
 
-    def __get_categories(self, cats: Sequence[Category]) -> Sequence[Category]:
-        out = []
-        for cat in cats:
-            out.append(cat)
-            if cat.categories:
-                out.extend(self.__get_categories(cat.categories))
-        return out
-
 
 class Categorisation(
     MaintainableArtefact, frozen=True, omit_defaults=True, kw_only=True

pysdmx/model/message.py

@@ -23,7 +23,6 @@ from pysdmx.model.__base import MaintainableArtefact, Organisation
 from pysdmx.model.category import Categorisation, CategoryScheme
 from pysdmx.model.code import Codelist, Hierarchy, HierarchyAssociation
 from pysdmx.model.concept import ConceptScheme
-from pysdmx.model.constraint import DataConstraint
 from pysdmx.model.dataflow import (
     Dataflow,
     DataStructureDefinition,
@@ -221,20 +220,10 @@ class StructureMessage(Struct, repr_omit_defaults=True, frozen=True):
             "Could not find the requested element.",
         )
 
-    # Return collection of a certain type
-
     def get_agency_schemes(self) -> List[AgencyScheme]:
         """Returns the AgencySchemes."""
         return self.__get_elements(AgencyScheme)
 
-    def get_categorisations(self) -> List[Categorisation]:
-        """Returns the Categorisations."""
-        return self.__get_elements(Categorisation)
-
-    def get_category_schemes(self) -> List[CategoryScheme]:
-        """Returns the CategorySchemes."""
-        return self.__get_elements(CategoryScheme)
-
     def get_codelists(self) -> List[Codelist]:
         """Returns the Codelists."""
         return self.__get_enumerations(Codelist, False)
@@ -243,10 +232,6 @@ class StructureMessage(Struct, repr_omit_defaults=True, frozen=True):
         """Returns the Concept Schemes."""
         return self.__get_elements(ConceptScheme)
 
-    def get_custom_type_schemes(self) -> List[CustomTypeScheme]:
-        """Returns the CustomType Schemes."""
-        return self.__get_elements(CustomTypeScheme)
-
     def get_data_structure_definitions(
         self,
     ) -> List[DataStructureDefinition]:
@@ -257,13 +242,57 @@ class StructureMessage(Struct, repr_omit_defaults=True, frozen=True):
         """Returns the Dataflows."""
         return self.__get_elements(Dataflow)
 
-    def get_data_constraints(self) -> List[DataConstraint]:
-        """Returns the DataConstraints."""
-        return self.__get_elements(DataConstraint)
+    def get_metadataflows(self) -> List[Metadataflow]:
+        """Returns the MetadataProvisionAgreements."""
+        return self.__get_elements(Metadataflow)
 
-    def get_data_provider_schemes(self) -> List[DataProviderScheme]:
-        """Returns the DataProviderSchemes."""
-        return self.__get_elements(DataProviderScheme)
+    def get_organisation_scheme(self, short_urn: str) -> AgencyScheme:
+        """Returns a specific AgencyScheme."""
+        return self.__get_single_structure(AgencyScheme, short_urn)
+
+    def get_codelist(self, short_urn: str) -> Codelist:
+        """Returns a specific Codelist."""
+        return self.__get_single_structure(Codelist, short_urn)
+
+    def get_concept_scheme(self, short_urn: str) -> ConceptScheme:
+        """Returns a specific Concept Scheme."""
+        return self.__get_single_structure(ConceptScheme, short_urn)
+
+    def get_data_structure_definition(
+        self, short_urn: str
+    ) -> DataStructureDefinition:
+        """Returns a specific DataStructureDefinition."""
+        return self.__get_single_structure(DataStructureDefinition, short_urn)
+
+    def get_dataflow(self, short_urn: str) -> Dataflow:
+        """Returns a specific Dataflow."""
+        return self.__get_single_structure(Dataflow, short_urn)
+
+    def get_provision_agreement(self, short_urn: str) -> ProvisionAgreement:
+        """Returns a specific Provision Agreement."""
+        return self.__get_single_structure(ProvisionAgreement, short_urn)
+
+    def get_transformation_schemes(self) -> List[TransformationScheme]:
+        """Returns the TransformationSchemes."""
+        return self.__get_elements(TransformationScheme)
+
+    def get_user_defined_operator_schemes(
+        self,
+    ) -> List[UserDefinedOperatorScheme]:
+        """Returns the UserDefinedOperatorSchemes."""
+        return self.__get_elements(UserDefinedOperatorScheme)
+
+    def get_ruleset_schemes(self) -> List[RulesetScheme]:
+        """Returns the RulesetSchemes."""
+        return self.__get_elements(RulesetScheme)
+
+    def get_category_schemes(self) -> List[CategoryScheme]:
+        """Returns the CategorySchemes."""
+        return self.__get_elements(CategoryScheme)
+
+    def get_value_lists(self) -> List[Codelist]:
+        """Returns the Codelists."""
+        return self.__get_enumerations(Codelist, True)
 
     def get_hierarchies(self) -> List[Hierarchy]:
         """Returns the HierarchyCodelists."""
@@ -273,9 +302,13 @@ class StructureMessage(Struct, repr_omit_defaults=True, frozen=True):
         """Returns the HierarchyAssociations."""
         return self.__get_elements(HierarchyAssociation)
 
-    def get_metadataflows(self) -> List[Metadataflow]:
-        """Returns the MetadataProvisionAgreements."""
-        return self.__get_elements(Metadataflow)
+    def get_data_provider_schemes(self) -> List[DataProviderScheme]:
+        """Returns the DataProviderSchemes."""
+        return self.__get_elements(DataProviderScheme)
+
+    def get_provision_agreements(self) -> List[ProvisionAgreement]:
+        """Returns the ProvisionAgreements."""
+        return self.__get_elements(ProvisionAgreement)
 
     def get_metadata_provider_schemes(self) -> List[MetadataProviderScheme]:
         """Returns the MetadataProviderSchemes."""
@@ -291,15 +324,9 @@ class StructureMessage(Struct, repr_omit_defaults=True, frozen=True):
         """Returns the MetadataStructures."""
         return self.__get_elements(MetadataStructure)
 
-    def get_name_personalisation_schemes(
-        self,
-    ) -> List[NamePersonalisationScheme]:
-        """Returns the NamePersonalisationSchemes."""
-        return self.__get_elements(NamePersonalisationScheme)
-
-    def get_provision_agreements(self) -> List[ProvisionAgreement]:
-        """Returns the ProvisionAgreements."""
-        return self.__get_elements(ProvisionAgreement)
+    def get_structure_maps(self) -> List[StructureMap]:
+        """Returns the StructureMaps."""
+        return self.__get_elements(StructureMap)
 
     def get_representation_maps(
         self,
@@ -310,59 +337,23 @@ class StructureMessage(Struct, repr_omit_defaults=True, frozen=True):
         out.extend(self.__get_elements(MultiRepresentationMap))
         return out
 
-    def get_ruleset_schemes(self) -> List[RulesetScheme]:
-        """Returns the RulesetSchemes."""
-        return self.__get_elements(RulesetScheme)
-
-    def get_structure_maps(self) -> List[StructureMap]:
-        """Returns the StructureMaps."""
-        return self.__get_elements(StructureMap)
-
-    def get_transformation_schemes(self) -> List[TransformationScheme]:
-        """Returns the TransformationSchemes."""
-        return self.__get_elements(TransformationScheme)
-
-    def get_user_defined_operator_schemes(
-        self,
-    ) -> List[UserDefinedOperatorScheme]:
-        """Returns the UserDefinedOperatorSchemes."""
-        return self.__get_elements(UserDefinedOperatorScheme)
+    def get_categorisations(self) -> List[Categorisation]:
+        """Returns the Categorisations."""
+        return self.__get_elements(Categorisation)
 
-    def get_value_lists(self) -> List[Codelist]:
-        """Returns the Codelists."""
-        return self.__get_enumerations(Codelist, True)
+    def get_custom_type_schemes(self) -> List[CustomTypeScheme]:
+        """Returns the CustomType Schemes."""
+        return self.__get_elements(CustomTypeScheme)
 
     def get_vtl_mapping_schemes(self) -> List[VtlMappingScheme]:
         """Returns the VTL Mapping Schemes."""
         return self.__get_elements(VtlMappingScheme)
 
-    # Return individual items
-
-    def get_codelist(self, short_urn: str) -> Codelist:
-        """Returns a specific Codelist."""
-        return self.__get_single_structure(Codelist, short_urn)
-
-    def get_concept_scheme(self, short_urn: str) -> ConceptScheme:
-        """Returns a specific Concept Scheme."""
-        return self.__get_single_structure(ConceptScheme, short_urn)
-
-    def get_dataflow(self, short_urn: str) -> Dataflow:
-        """Returns a specific Dataflow."""
-        return self.__get_single_structure(Dataflow, short_urn)
-
-    def get_data_structure_definition(
-        self, short_urn: str
-    ) -> DataStructureDefinition:
-        """Returns a specific DataStructureDefinition."""
-        return self.__get_single_structure(DataStructureDefinition, short_urn)
-
-    def get_organisation_scheme(self, short_urn: str) -> AgencyScheme:
-        """Returns a specific AgencyScheme."""
-        return self.__get_single_structure(AgencyScheme, short_urn)
-
-    def get_provision_agreement(self, short_urn: str) -> ProvisionAgreement:
-        """Returns a specific Provision Agreement."""
-        return self.__get_single_structure(ProvisionAgreement, short_urn)
+    def get_name_personalisation_schemes(
+        self,
+    ) -> List[NamePersonalisationScheme]:
+        """Returns the NamePersonalisationSchemes."""
+        return self.__get_elements(NamePersonalisationScheme)
 
 
 class MetadataMessage(Struct, frozen=True):

{pysdmx-1.10.0.dist-info → pysdmx-1.10.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdmx
-Version: 1.10.0
+Version: 1.10.0rc1
 Summary: Your opinionated Python SDMX library
 License: Apache-2.0
 License-File: LICENSE