Use match; case instead of if; elif

Author: maxrjones

src/zarr/storage/_fsspec.py

@@ -213,26 +213,27 @@ async def get(
         path = _dereference_path(self.path, key)
 
         try:
-            if byte_range is None:
-                value = prototype.buffer.from_bytes(await self.fs._cat_file(path))
-            elif isinstance(byte_range, ExplicitByteRequest):
-                value = prototype.buffer.from_bytes(
-                    await self.fs._cat_file(
-                        path,
-                        start=byte_range.start,
-                        end=byte_range.end,
+            match byte_range:
+                case None:
+                    value = prototype.buffer.from_bytes(await self.fs._cat_file(path))
+                case ExplicitByteRequest(start, end):
+                    value = prototype.buffer.from_bytes(
+                        await self.fs._cat_file(
+                            path,
+                            start=start,
+                            end=end,
+                        )
                     )
-                )
-            elif isinstance(byte_range, OffsetByteRequest):
-                value = prototype.buffer.from_bytes(
-                    await self.fs._cat_file(path, start=byte_range.offset, end=None)
-                )
-            elif isinstance(byte_range, SuffixByteRequest):
-                value = prototype.buffer.from_bytes(
-                    await self.fs._cat_file(path, start=-byte_range.suffix, end=None)
-                )
-            else:
-                raise ValueError("Invalid format for ByteRangeRequest")
+                case OffsetByteRequest(offset):
+                    value = prototype.buffer.from_bytes(
+                        await self.fs._cat_file(path, start=offset, end=None)
+                    )
+                case SuffixByteRequest(suffix):
+                    value = prototype.buffer.from_bytes(
+                        await self.fs._cat_file(path, start=-suffix, end=None)
+                    )
+                case _:
+                    raise ValueError(f"Unexpected byte_range, got {byte_range}.")
         except self.allowed_exceptions:
             return None
         except OSError as e:
@@ -290,20 +291,21 @@ async def get_partial_values(
             stops: list[int | None] = []
             for key, byte_range in key_ranges:
                 paths.append(_dereference_path(self.path, key))
-                if byte_range is None:
-                    starts.append(None)
-                    stops.append(None)
-                elif isinstance(byte_range, ExplicitByteRequest):
-                    starts.append(byte_range.start)
-                    stops.append(byte_range.end)
-                elif isinstance(byte_range, OffsetByteRequest):
-                    starts.append(byte_range.offset)
-                    stops.append(None)
-                elif isinstance(byte_range, SuffixByteRequest):
-                    starts.append(-byte_range.suffix)
-                    stops.append(None)
-                else:
-                    raise ValueError("Invalid format for ByteRangeRequest")
+                match byte_range:
+                    case None:
+                        starts.append(None)
+                        stops.append(None)
+                    case ExplicitByteRequest(start, end):
+                        starts.append(start)
+                        stops.append(end)
+                    case OffsetByteRequest(offset):
+                        starts.append(offset)
+                        stops.append(None)
+                    case SuffixByteRequest(suffix):
+                        starts.append(-suffix)
+                        stops.append(None)
+                    case _:
+                        raise ValueError(f"Unexpected byte_range, got {byte_range}.")
         else:
             return []
         # TODO: expectations for exceptions or missing keys?

src/zarr/storage/_local.py

@@ -29,15 +29,16 @@ def _get(path: Path, prototype: BufferPrototype, byte_range: ByteRangeRequest |
         return prototype.buffer.from_bytes(path.read_bytes())
     with path.open("rb") as f:
         size = f.seek(0, io.SEEK_END)
-        if isinstance(byte_range, ExplicitByteRequest):
-            f.seek(byte_range.start)
-            return prototype.buffer.from_bytes(f.read(byte_range.end - f.tell()))
-        elif isinstance(byte_range, OffsetByteRequest):
-            f.seek(byte_range.offset)
-        elif isinstance(byte_range, SuffixByteRequest):
-            f.seek(max(0, size - byte_range.suffix))
-        else:
-            raise TypeError("Invalid format for ByteRangeRequest")
+        match byte_range:
+            case ExplicitByteRequest(start, end):
+                f.seek(start)
+                return prototype.buffer.from_bytes(f.read(end - f.tell()))
+            case OffsetByteRequest(offset):
+                f.seek(offset)
+            case SuffixByteRequest(suffix):
+                f.seek(max(0, size - suffix))
+            case _:
+                raise ValueError(f"Unexpected byte_range, got {byte_range}.")
         return prototype.buffer.from_bytes(f.read())
 
 

src/zarr/storage/_utils.py

@@ -53,16 +53,14 @@ def _normalize_byte_range_index(
     """
     Convert an ByteRangeRequest into an explicit start and stop
     """
-    if byte_range is None:
-        start = 0
-        stop = len(data) + 1
-    elif isinstance(byte_range, ExplicitByteRequest):
-        start = byte_range.start
-        stop = byte_range.end
-    elif isinstance(byte_range, OffsetByteRequest):
-        start = byte_range.offset
-        stop = len(data) + 1
-    elif isinstance(byte_range, SuffixByteRequest):
-        start = len(data) - byte_range.suffix
-        stop = len(data) + 1
-    return (start, stop)
+    match byte_range:
+        case None:
+            return (0, len(data) + 1)
+        case ExplicitByteRequest(start, end):
+            return (start, end)
+        case OffsetByteRequest(offset):
+            return (offset, len(data) + 1)
+        case SuffixByteRequest(suffix):
+            return (len(data) - suffix, len(data) + 1)
+        case _:
+            raise ValueError(f"Unexpected byte_range, got {byte_range}.")

src/zarr/storage/_zip.py

@@ -149,18 +149,20 @@ def _get(
         # docstring inherited
         try:
             with self._zf.open(key) as f:  # will raise KeyError
-                if byte_range is None:
-                    return prototype.buffer.from_bytes(f.read())
-                elif isinstance(byte_range, ExplicitByteRequest):
-                    f.seek(byte_range.start)
-                    return prototype.buffer.from_bytes(f.read(byte_range.end - f.tell()))
-                size = f.seek(0, os.SEEK_END)
-                if isinstance(byte_range, OffsetByteRequest):
-                    f.seek(byte_range.offset)
-                elif isinstance(byte_range, SuffixByteRequest):
-                    f.seek(max(0, size - byte_range.suffix))
-                else:
-                    raise TypeError("Invalid format for ByteRangeRequest")
+                match byte_range:
+                    case None:
+                        return prototype.buffer.from_bytes(f.read())
+                    case ExplicitByteRequest(start, end):
+                        f.seek(start)
+                        return prototype.buffer.from_bytes(f.read(end - f.tell()))
+                    case OffsetByteRequest(offset):
+                        size = f.seek(0, os.SEEK_END)
+                        f.seek(offset)
+                    case SuffixByteRequest(suffix):
+                        size = f.seek(0, os.SEEK_END)
+                        f.seek(max(0, size - suffix))
+                    case _:
+                        raise TypeError(f"Unexpected byte_range, got {byte_range}.")
                 return prototype.buffer.from_bytes(f.read())
         except KeyError:
             return None