Change some multi-elif statements to match/case

Author: khaeru

sdmx/convert/pandas.py

@@ -432,19 +432,20 @@ def handle_datetime(self, value: Any) -> None:
             stacklevel=2,
         )
 
-        if isinstance(value, (str, common.DimensionComponent)):
-            self.datetime_dimension = value  # type: ignore [assignment]
-        elif isinstance(value, dict):
-            # Unpack a dict of 'advanced' arguments
-            self.datetime_axis = value.pop("axis", self.datetime_axis)
-            self.datetime_dimension = value.pop("dim", self.datetime_dimension)
-            self.datetime_freq = value.pop("freq", self.datetime_freq)
-            if len(value):
-                raise ValueError(f"Unexpected datetime={tuple(sorted(value))!r}")
-        elif isinstance(value, bool):
-            self.datetime_axis = 0 if value else -1
-        else:
-            raise TypeError(f"PandasConverter(…, datetime={type(value)})")
+        match value:
+            case str() | common.DimensionComponent():
+                self.datetime_dimension = value  # type: ignore [assignment]
+            case dict():
+                # Unpack a dict of 'advanced' arguments
+                self.datetime_axis = value.pop("axis", self.datetime_axis)
+                self.datetime_dimension = value.pop("dim", self.datetime_dimension)
+                self.datetime_freq = value.pop("freq", self.datetime_freq)
+                if len(value):
+                    raise ValueError(f"Unexpected datetime={tuple(sorted(value))!r}")
+            case bool():
+                self.datetime_axis = 0 if value else -1
+            case _:
+                raise TypeError(f"PandasConverter(…, datetime={type(value)})")
 
     def __post_init__(self, datetime: Any, rtype: str | None) -> None:
         """Transform and validate arguments."""

sdmx/model/internationalstring.py

@@ -9,8 +9,7 @@
     # Types that can be converted into InternationalString
     Convertible = str | Sequence | Mapping | Iterable[tuple[str, str]]
 
-    TInternationalString: TypeAlias = "InternationalString" | "Convertible"
-    TInternationalStringInit = TInternationalString | None
+    TInternationalString: TypeAlias = "InternationalString" | Convertible
 
 # TODO read this from the environment, or use any value set in the SDMX-ML spec.
 #      Currently set to 'en' because test_dsd.py expects it.
@@ -23,14 +22,14 @@
 class InternationalString:
     """SDMX-IM InternationalString.
 
-    SDMX-IM LocalisedString is not implemented. Instead, the 'localizations' is a
-    mapping where:
+    SDMX-IM LocalisedString is not implemented. Instead, :attr:`localizations` is a
+    mapping in which:
 
     - keys correspond to the 'locale' property of LocalisedString.
     - values correspond to the 'label' property of LocalisedString.
 
-    When used as a type hint with pydantic, InternationalString fields can be assigned
-    to in one of four ways::
+    When :class:`InternationalStringDescriptor` is used as a dataclass field type, the
+    field can be assigned in one of four ways::
 
         @dataclass
         class Foo:
@@ -55,39 +54,32 @@ class Foo:
 
     Only the first method preserves existing localizations; the latter three replace
     them.
-
     """
 
     __slots__ = ("localizations",)
 
     localizations: dict[str, str]
 
-    def __init__(self, value: "Convertible" | None = None, **kwargs):
+    def __init__(self, value: "Convertible" | None = None, **kwargs) -> None:
         # Handle initial values according to type
-        if value is None:
-            # Keyword arguments → dict, possibly empty
-            value = dict(kwargs)
-        elif isinstance(value, str):
-            # Bare string
-            value = {DEFAULT_LOCALE: value}
-        elif (
-            isinstance(value, Sequence)
-            and len(value) == 2
-            and isinstance(value[0], str)
-        ):
-            # 2-tuple of str is (locale, label)
-            value = {value[0]: value[1]}
-        elif isinstance(value, Mapping):
-            # dict; use directly
-            value = dict(value)
-        else:
-            try:
-                # Iterable of 2-tuples
-                value = {  # type: ignore [misc]
-                    locale: label for (locale, label) in value
-                }
-            except Exception:
-                raise ValueError(value, kwargs)
+        match value:
+            case None:  # Keyword arguments → dict, possibly empty
+                value = dict(kwargs)
+            case str():  # Bare string
+                value = {DEFAULT_LOCALE: value}
+            case Sequence() if len(value) == 2 and isinstance(value[0], str):
+                # 2-tuple of str is (locale, label)
+                value = {value[0]: value[1]}
+            case Mapping():  # dict or similar; use directly
+                value = dict(value)
+            case _:
+                try:
+                    # Iterable of 2-tuples
+                    value = {  # type: ignore [misc]
+                        locale: label for (locale, label) in value
+                    }
+                except Exception:
+                    raise ValueError(value, kwargs)
 
         self.localizations = value
 
@@ -149,7 +141,7 @@ def __get__(self, obj, type) -> InternationalString:
 
         return obj.__dict__[self._name]
 
-    def __set__(self, obj, value: "TInternationalStringInit"):
+    def __set__(self, obj, value: TInternationalString | None) -> None:
         if not isinstance(value, InternationalString):
             value = InternationalString(value)
         setattr(obj, self._name, value)

sdmx/reader/xml/v21.py

@@ -1157,19 +1157,19 @@ def _obs(reader, elem):
     args = dict()
 
     for e in elem.iterchildren():
-        localname = QName(e).localname
-        if localname == "Attributes":
-            args["attached_attribute"] = reader.pop_single("Attributes")
-        elif localname == "ObsDimension":
-            # Mutually exclusive with ObsKey
-            args["dimension"] = dsd.make_key(
-                common.Key, {dim_at_obs.id: e.attrib["value"]}
-            )
-        elif localname == "ObsKey":
-            # Mutually exclusive with ObsDimension
-            args["dimension"] = reader.pop_single(common.Key)
-        elif localname == "ObsValue":
-            args["value"] = e.attrib["value"]
+        match QName(e).localname:
+            case "Attributes":
+                args["attached_attribute"] = reader.pop_single("Attributes")
+            case "ObsDimension":
+                # Mutually exclusive with ObsKey
+                args["dimension"] = dsd.make_key(
+                    common.Key, {dim_at_obs.id: e.attrib["value"]}
+                )
+            case "ObsKey":
+                # Mutually exclusive with ObsDimension
+                args["dimension"] = reader.pop_single(common.Key)
+            case "ObsValue":
+                args["value"] = e.attrib["value"]
 
     return reader.model.Observation(**args)