Linting

Author: BrianMichell

src/mdio/converters/segy.py

@@ -131,7 +131,7 @@ def get_compressor(lossless: bool, compression_tolerance: float = -1) -> Blosc |
     return compressor
 
 
-def segy_to_mdio(  # noqa: PLR0913, PLR0915
+def segy_to_mdio(  # noqa: PLR0913, PLR0915, PLR0912
     segy_path: str | Path,
     mdio_path_or_buffer: str | Path,
     index_bytes: Sequence[int],
@@ -398,7 +398,7 @@ def segy_to_mdio(  # noqa: PLR0913, PLR0915
     valid_mask = np.ones(grid.num_traces, dtype=bool)
     for d_idx in range(len(grid.header_index_arrays)):
         coords = grid.header_index_arrays[d_idx]
-        valid_mask &= (coords < grid.shape[d_idx])
+        valid_mask &= coords < grid.shape[d_idx]
     valid_count = int(np.count_nonzero(valid_mask))
     if valid_count != num_traces:
         for dim_name in grid.dim_names:
@@ -409,6 +409,7 @@ def segy_to_mdio(  # noqa: PLR0913, PLR0915
         raise GridTraceCountError(valid_count, num_traces)
 
     import gc
+
     del valid_mask
     gc.collect()
 
@@ -484,7 +485,7 @@ def segy_to_mdio(  # noqa: PLR0913, PLR0915
             local_idx = indexed_coords - sl.start  # remains uint32
             # Free indexed_coords immediately
             del indexed_coords
-            
+
             # Only convert dtype if necessary for indexing (numpy requires int for indexing)
             if local_idx.dtype != np.intp:
                 local_idx = local_idx.astype(np.intp)
@@ -496,16 +497,16 @@ def segy_to_mdio(  # noqa: PLR0913, PLR0915
 
         # Mark live cells in the temporary block
         block[tuple(local_coords)] = True
-        
+
         # Free local_coords immediately after use
         del local_coords
 
         # Write the entire block to Zarr at once
         live_mask_array.set_basic_selection(selection=chunk_indices, value=block)
-        
+
         # Free block immediately after writing
         del block
-        
+
         # Force garbage collection periodically to free memory aggressively
         gc.collect()
 

src/mdio/core/grid.py

@@ -7,14 +7,12 @@
 from typing import TYPE_CHECKING
 
 import numpy as np
-import zarr
 
-from mdio.constants import UINT32_MAX
 from mdio.core import Dimension
 from mdio.core.serialization import Serializer
-from mdio.core.utils_write import get_constrained_chunksize
 
 if TYPE_CHECKING:
+    import zarr
     from segy.arrays import HeaderArray
     from zarr import Array as ZarrArray
 
@@ -112,8 +110,8 @@ def build_map(self, index_headers: HeaderArray) -> None:
         """Compute per-trace grid coordinates (lazy map).
 
         Instead of allocating a full `self.map` and `self.live_mask`, this computes, for each trace,
-        its integer index along each dimension (excluding the final sample dimension) and stores them in
-        `self.header_index_arrays`. The full mapping can then be derived chunk-by-chunk when writing.
+        its integer index along each dimension (excluding the sample dimension) and stores them in
+        `self.header_index_arrays`. The full mapping can then be derived chunkwise when writing.
 
         Args:
             index_headers: Header array containing dimension indices (length = number of traces).
@@ -126,8 +124,8 @@ def build_map(self, index_headers: HeaderArray) -> None:
         # Cast to uint32.
         idx_arrays: list[np.ndarray] = []
         for dim in self.dims[:-1]:
-            hdr_vals = index_headers[dim.name]         # shape: (num_traces,)
-            coords = np.searchsorted(dim, hdr_vals)    # integer indices
+            hdr_vals = index_headers[dim.name]  # shape: (num_traces,)
+            coords = np.searchsorted(dim, hdr_vals)  # integer indices
             coords = coords.astype(np.uint32)
             idx_arrays.append(coords)
 
@@ -136,7 +134,6 @@ def build_map(self, index_headers: HeaderArray) -> None:
 
         # We no longer allocate `self.map` or `self.live_mask` here.
         # The full grid shape is `self.shape`, but mapping is done lazily per chunk.
-        return
 
     def get_traces_for_chunk(self, chunk_slices: tuple[slice, ...]) -> np.ndarray:
         """Return all trace IDs whose grid-coordinates fall inside the given chunk slices.
@@ -157,16 +154,15 @@ def get_traces_for_chunk(self, chunk_slices: tuple[slice, ...]) -> np.ndarray:
             arr = self.header_index_arrays[dim_idx]  # shape: (num_traces,)
             start, stop = sl.start, sl.stop
             if start is not None:
-                mask &= (arr >= start)
+                mask &= arr >= start
             if stop is not None:
-                mask &= (arr < stop)
+                mask &= arr < stop
             if not mask.any():
                 # No traces remain after this dimension's filtering
                 return np.empty((0,), dtype=np.uint32)
 
         # Gather the trace IDs that survived all dimension tests
-        trace_ids = np.nonzero(mask)[0].astype(np.uint32)
-        return trace_ids
+        return np.nonzero(mask)[0].astype(np.uint32)
 
 
 class GridSerializer(Serializer):

src/mdio/segy/blocked_io.py

@@ -23,8 +23,6 @@
 from mdio.segy.creation import serialize_to_segy_stack
 from mdio.segy.utilities import find_trailing_ones_index
 
-import zarr
-
 if TYPE_CHECKING:
     from numpy.typing import NDArray
     from segy import SegyFactory
@@ -98,7 +96,7 @@ def to_zarr(
     # Aggregate statistics
     chunk_stats = [stat for stat in chunk_stats if stat is not None]
     # Each stat: (count, sum, sum_sq, min, max). Transpose to unpack rows.
-    glob_count, glob_sum, glob_sum_square, glob_min, glob_max = zip(*chunk_stats)
+    glob_count, glob_sum, glob_sum_square, glob_min, glob_max = zip(*chunk_stats, strict=False)
 
     glob_count = np.sum(np.array(glob_count, dtype=np.uint64))
     glob_sum = np.sum(np.array(glob_sum, dtype=np.float64))