pysdmx 1.3.0__py3-none-any.whl → 1.4.0rc1__py3-none-any.whl

pysdmx/model/__base.py

@@ -1,16 +1,19 @@
 from datetime import datetime
-from typing import Any, Dict, Optional, Sequence, Union
+from typing import Any, Optional, Sequence, Union
 
 from msgspec import Struct
 
 from pysdmx.errors import Invalid
 
 
-class Annotation(Struct, frozen=True, omit_defaults=True):
+class Annotation(
+    Struct, frozen=True, omit_defaults=True, repr_omit_defaults=True
+):
     """Annotation class.
 
     It is used to convey extra information to describe any
     SDMX construct.
+
     This information may be in the form of a URL reference and/or
     a multilingual text (represented by the association to
     InternationalString).
@@ -18,9 +21,9 @@ class Annotation(Struct, frozen=True, omit_defaults=True):
     Attributes:
         id: The identifier of the annotation.
         title: The title of the annotation.
-        text: The text of the annotation.
-        url: The URL of the annotation.
         type: The type of the annotation.
+        url: The URL of the annotation.
+        text: The value of the annotation.
     """
 
     id: Optional[str] = None
@@ -29,6 +32,11 @@ class Annotation(Struct, frozen=True, omit_defaults=True):
     url: Optional[str] = None
     type: Optional[str] = None
 
+    @property
+    def value(self) -> Optional[str]:
+        """Alias to text."""
+        return self.text
+
     def __post_init__(self) -> None:
         """Additional validation checks for Annotation."""
         if (
@@ -47,16 +55,27 @@ class Annotation(Struct, frozen=True, omit_defaults=True):
             )
 
     def __str__(self) -> str:
-        """Returns a human-friendly description."""
-        out = []
-        for k in self.__annotations__:
-            v = self.__getattribute__(k)
-            if v:
-                out.append(f"{k}={str(v)}")
-        return ", ".join(out)
-
-
-class AnnotableArtefact(Struct, frozen=True, omit_defaults=True, kw_only=True):
+        """Custom string representation without the class name."""
+        processed_output = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            processed_output.append(f"{attr}: {value}")
+        return f"{', '.join(processed_output)}"
+
+    def __repr__(self) -> str:
+        """Custom __repr__ that omits empty sequences."""
+        attrs = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            attrs.append(f"{attr}={repr(value)}")
+        return f"{self.__class__.__name__}({', '.join(attrs)})"
+
+
+class AnnotableArtefact(
+    Struct,
+    frozen=True,
+    omit_defaults=True,
+    repr_omit_defaults=True,
+    kw_only=True,
+):
     """Annotable Artefact class.
 
     Superclass of all SDMX artefacts.
@@ -68,22 +87,32 @@ class AnnotableArtefact(Struct, frozen=True, omit_defaults=True, kw_only=True):
 
     annotations: Sequence[Annotation] = ()
 
-    @classmethod
-    def __all_annotations(cls) -> Dict[str, Any]:
-        class_attributes = {}
-        for c in cls.__mro__:
-            if "__annotations__" in c.__dict__:
-                class_attributes.update(c.__annotations__)
-        return dict(reversed(list(class_attributes.items())))
-
     def __str__(self) -> str:
-        """Returns a human-friendly description."""
-        out = []
-        for k in self.__all_annotations():
-            v = self.__getattribute__(k)
-            if v:
-                out.append(f"{k}={str(v)}")
-        return ", ".join(out)
+        """Custom string representation without the class name."""
+        processed_output = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            # str is taken as a Sequence, so we need to check it's not a str
+            if isinstance(value, Sequence) and not isinstance(value, str):
+                # Handle non-empty lists
+                if value:
+                    class_name = value[0].__class__.__name__
+                    value = f"{len(value)} {class_name.lower()}s"
+                # redundant if check for python 3.9 and lower versions cov
+                if not value:
+                    continue
+
+            processed_output.append(f"{attr}: {value}")
+        return f"{', '.join(processed_output)}"
+
+    def __repr__(self) -> str:
+        """Custom __repr__ that omits empty sequences."""
+        attrs = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            # Omit empty sequences
+            if isinstance(value, (list, tuple, set)) and not value:
+                continue
+            attrs.append(f"{attr}={repr(value)}")
+        return f"{self.__class__.__name__}({', '.join(attrs)})"
 
 
 class IdentifiableArtefact(AnnotableArtefact, frozen=True, omit_defaults=True):
@@ -143,7 +172,9 @@ class Item(NameableArtefact, frozen=True, omit_defaults=True):
     """
 
 
-class Contact(Struct, frozen=True, omit_defaults=True):
+class Contact(
+    Struct, frozen=True, omit_defaults=True, repr_omit_defaults=True
+):
     """Contact details such as the name of a contact and his email address.
 
     Attributes:
@@ -172,6 +203,31 @@ class Contact(Struct, frozen=True, omit_defaults=True):
     uris: Optional[Sequence[str]] = None
     emails: Optional[Sequence[str]] = None
 
+    def __str__(self) -> str:
+        """Custom string representation without the class name."""
+        processed_output = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            # str is taken as a Sequence, so we need to check it's not a str
+            if isinstance(value, Sequence) and not isinstance(value, str):
+                # Handle non-empty lists
+                if not value:
+                    continue
+                class_name = value[0].__class__.__name__
+                value = f"{len(value)} {class_name.lower()}s"
+
+            processed_output.append(f"{attr}: {value}")
+        return f"{', '.join(processed_output)}"
+
+    def __repr__(self) -> str:
+        """Custom __repr__ that omits empty sequences."""
+        attrs = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            # Omit empty sequences
+            if isinstance(value, (list, tuple, set)) and not value:
+                continue
+            attrs.append(f"{attr}={repr(value)}")
+        return f"{self.__class__.__name__}({', '.join(attrs)})"
+
 
 class Organisation(Item, frozen=True, omit_defaults=True):
     """Organisation class.
@@ -272,7 +328,9 @@ class ItemScheme(MaintainableArtefact, frozen=True, omit_defaults=True):
     is_partial: bool = False
 
 
-class DataflowRef(Struct, frozen=True, omit_defaults=True, tag=True):
+class DataflowRef(
+    Struct, frozen=True, omit_defaults=True, repr_omit_defaults=True, tag=True
+):
     """A unique reference to a dataflow.
 
     Attributes:
@@ -304,11 +362,18 @@ class DataflowRef(Struct, frozen=True, omit_defaults=True, tag=True):
         )
 
     def __str__(self) -> str:
-        """A string representating the dataflow's reference."""
+        """Short_urn representation of the dataflow reference."""
         return f"Dataflow={self.agency}:{self.id}({self.version})"
 
+    def __repr__(self) -> str:
+        """Custom __repr__ that omits empty sequences."""
+        attrs = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            attrs.append(f"{attr}={repr(value)}")
+        return f"{self.__class__.__name__}({', '.join(attrs)})"
+
 
-class Reference(Struct, frozen=True):
+class Reference(Struct, frozen=True, repr_omit_defaults=True):
     """The coordinates of an SDMX maintainable artefact.
 
     Attributes:
@@ -328,7 +393,7 @@ class Reference(Struct, frozen=True):
         return f"{self.sdmx_type}={self.agency}:{self.id}({self.version})"
 
 
-class ItemReference(Struct, frozen=True, tag=True):
+class ItemReference(Struct, frozen=True, repr_omit_defaults=True, tag=True):
     """The coordinates of an SDMX non-nested item.
 
     Attributes:

pysdmx/model/__init__.py

@@ -10,6 +10,7 @@ import msgspec
 
 from pysdmx.model.__base import (
     Agency,
+    Annotation,
     Contact,
     DataConsumer,
     DataflowRef,
@@ -34,6 +35,7 @@ from pysdmx.model.dataflow import (
     Components,
     Dataflow,
     DataflowInfo,
+    DataStructureDefinition,
     ProvisionAgreement,
     Role,
     Schema,
@@ -140,6 +142,7 @@ def decoders(type: Type, obj: Any) -> Any:  # type: ignore[type-arg]
 __all__ = [
     "Agency",
     "AgencyScheme",
+    "Annotation",
     "ArrayBoundaries",
     "Categorisation",
     "Category",
@@ -163,6 +166,7 @@ __all__ = [
     "DatePatternMap",
     "DataProvider",
     "DataProviderScheme",
+    "DataStructureDefinition",
     "Facets",
     "FromVtlMapping",
     "FixedValueMap",

pysdmx/model/category.py

@@ -135,6 +135,26 @@ class CategoryScheme(ItemScheme, frozen=True, omit_defaults=True):
             flows.extend(self.__extract_flows(sub))
         return flows
 
+    def __str__(self) -> str:
+        """Custom string representation without the class name."""
+        processed_output = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            # str is taken as a Sequence, so we need to check it's not a str
+            if isinstance(value, Sequence) and not isinstance(value, str):
+                # Handle empty lists
+                if not value:
+                    continue
+                class_name = value[0].__class__.__name__
+                class_name = (
+                    class_name.lower() + "s"
+                    if attr != "items"
+                    else "categories"
+                )
+                value = f"{len(value)} {class_name}"
+
+            processed_output.append(f"{attr}: {value}")
+        return f"{', '.join(processed_output)}"
+
 
 class Categorisation(
     MaintainableArtefact, frozen=True, omit_defaults=True, kw_only=True

pysdmx/model/code.py

@@ -17,7 +17,7 @@ representation of hierarchical relationships to hierarchies only.
 """
 
 from datetime import datetime
-from typing import Iterator, Literal, Optional, Sequence
+from typing import Iterator, Literal, Optional, Sequence, Union
 
 from msgspec import Struct
 
@@ -95,7 +95,9 @@ class Codelist(ItemScheme, frozen=True, omit_defaults=True, tag=True):
         return bool(self.__getitem__(id_))
 
 
-class HierarchicalCode(Struct, frozen=True, omit_defaults=True):
+class HierarchicalCode(
+    Struct, frozen=True, omit_defaults=True, repr_omit_defaults=True
+):
     """A code, as used in a hierarchy.
 
     Hierachical codes may contain other codes.
@@ -135,11 +137,28 @@ class HierarchicalCode(Struct, frozen=True, omit_defaults=True):
         yield from self.codes
 
     def __str__(self) -> str:
-        """Returns a human-friendly description."""
-        out = self.id
-        if self.name:
-            out = f"{out} ({self.name})"
-        return out
+        """Custom string representation without the class name."""
+        processed_output = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            # str is taken as a Sequence, so we need to check it's not a str
+            if isinstance(value, Sequence) and not isinstance(value, str):
+                if not value:
+                    continue
+                # Handle non-empty lists
+                value = f"{len(value)} hierarchical codes"
+
+            processed_output.append(f"{attr}: {value}")
+        return f"{', '.join(processed_output)}"
+
+    def __repr__(self) -> str:
+        """Custom __repr__ that omits empty sequences."""
+        attrs = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            # Omit empty sequences
+            if isinstance(value, (list, tuple, set)) and not value:
+                continue
+            attrs.append(f"{attr}={repr(value)}")
+        return f"{self.__class__.__name__}({', '.join(attrs)})"
 
 
 class Hierarchy(
@@ -171,10 +190,12 @@ class Hierarchy(
             assume that the operator property references a VTL operator
             representing a sum. This can then be used for validation purposes,
             to check that A = B + C.
+        is_partial: Whether the hierarchy is partial.
     """
 
     codes: Sequence[HierarchicalCode] = ()
     operator: Optional[str] = None
+    is_partial: bool = True
 
     def __iter__(self) -> Iterator[HierarchicalCode]:
         """Return an iterator over the list of codes."""
@@ -287,7 +308,7 @@ class HierarchyAssociation(
 ):
     """Links a hierarchy to a component withing the context of a dataflow."""
 
-    hierarchy: Optional[Hierarchy] = None
+    hierarchy: Optional[Union[Hierarchy, str]] = None
     component_ref: str = ""
     context_ref: str = ""
     operator: Optional[str] = None

pysdmx/model/concept.py

@@ -24,13 +24,17 @@ class DataType(str, Enum):
     """The expected data type for a concept."""
 
     ALPHA = "Alpha"
-    """Alphabetical characters."""
+    """The alphabetic character set of A-Z, a-z.."""
     ALPHA_NUM = "AlphaNumeric"
-    """Alphabetical and numerical characters."""
+    """The character set of A-Z, a-z and 0-9."""
+    BASIC_TIME_PERIOD = "BasicTimePeriod"
+    """The ISO standard periods."""
     BIG_INTEGER = "BigInteger"
     """Immutable arbitrary-precision signed integer."""
     BOOLEAN = "Boolean"
     """True or False."""
+    COUNT = "Count"
+    """A simple incrementing integer type."""
     DATE = "GregorianDay"
     """A ISO 8601 date (e.g. ``2011-06-17``)."""
     DATE_TIME = "DateTime"
@@ -41,8 +45,12 @@ class DataType(str, Enum):
     """Immutable arbitrary-precision signed decimal number."""
     DOUBLE = "Double"
     """A decimal number (8 bytes)."""
+    DURATION = "Duration"
+    """An ISO 8601 duration."""
     FLOAT = "Float"
     """A decimal number (4 bytes)."""
+    GREGORIAN_TIME_PERIOD = "GregorianTimePeriod"
+    """This is the union of YEAR, YEAR_MONTH, and DATE."""
     INTEGER = "Integer"
     """A whole number (4 bytes)."""
     LONG = "Long"
@@ -52,24 +60,50 @@ class DataType(str, Enum):
     MONTH_DAY = "MonthDay"
     """A month day in the ISO 8601 calendar (e.g. ``--12-31``)."""
     NUMERIC = "Numeric"
-    """A numerical value (integer or decimal)."""
+    """The simple numeric character set of 0-9, treated as a string."""
     PERIOD = "ObservationalTimePeriod"
     """A reporting period. The format varies with the frequency."""
+    REP_DAY = "ReportingDay"
+    """The SDMX reporting period for daily frequency (e.g. 2025-D001)."""
+    REP_MONTH = "ReportingMonth"
+    """The SDMX reporting period for monthly frequency (e.g. 2025-M01)."""
+    REP_QUARTER = "ReportingQuarter"
+    """The SDMX reporting period for quarterly frequency (e.g. 2025-Q1)."""
+    REP_SEMESTER = "ReportingSemester"
+    """The SDMX reporting period for half-yearly frequency (e.g. 2025-S1)."""
+    REP_TRIMESTER = "ReportingTrimester"
+    """The SDMX reporting period for trimestrial frequency (e.g. 2025-T1)."""
+    REP_WEEK = "ReportingWeek"
+    """The SDMX reporting period for weekly frequency (e.g. 2025-W01)."""
+    REP_YEAR = "ReportingYear"
+    """The SDMX reporting period for yearly frequency (e.g. 2025-A1)."""
     SHORT = "Short"
     """A whole number (2 bytes)."""
+    STD_TIME_PERIOD = "StandardTimePeriod"
+    """The ISO standard periods and the SDMX reporting periods."""
     STRING = "String"
     """A string (as immutable sequence of Unicode code points)."""
     TIME = "Time"
     """An ISO 8601 time (e.g. ``12:50:42``)."""
     URI = "URI"
     """A uniform resource identifier, such as a URL."""
+    XHTML = "XHTML"
+    """XHTML (or HTML) markup."""
     YEAR = "GregorianYear"
     """An ISO 8601 year (e.g. ``2000``)."""
     YEAR_MONTH = "GregorianYearMonth"
     """An ISO 8601 year and month (e.g. ``2000-01``)."""
 
+    def __str__(self) -> str:
+        """Data Type String representation."""
+        return self.value
+
+    def __repr__(self) -> str:
+        """Data Type String representation."""
+        return f"{self.__class__.__name__}.{self._name_}"
+
 
-class Facets(Struct, frozen=True, omit_defaults=True):
+class Facets(Struct, frozen=True, omit_defaults=True, repr_omit_defaults=True):
     """Additional information about the concept expected values.
 
     The facets that apply vary with the type. For example,
@@ -104,15 +138,22 @@ class Facets(Struct, frozen=True, omit_defaults=True):
     """Indicates the ending point of a sequence."""
     is_sequence: bool = False
     """Whether the values are intended to be ordered."""
+    is_multilingual: bool = False
+    """Whether the text can be in multiple languages."""
 
     def __str__(self) -> str:
-        """Returns a human-friendly description."""
-        out = []
-        for k in self.__annotations__:
-            v = self.__getattribute__(k)
-            if v:
-                out.append(f"{k}={v}")
-        return ", ".join(out)
+        """Custom string representation without the class name."""
+        processed_output = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            processed_output.append(f"{attr}: {value}")
+        return f"{', '.join(processed_output)}"
+
+    def __repr__(self) -> str:
+        """Custom __repr__ that omits empty sequences."""
+        attrs = []
+        for attr, value, *_ in self.__rich_repr__():  # type: ignore[misc]
+            attrs.append(f"{attr}={repr(value)}")
+        return f"{self.__class__.__name__}({', '.join(attrs)})"
 
 
 class Concept(Item, frozen=True, omit_defaults=True, tag=True):