Merge 'upstream/main' into create_empty

Author: dmitriyrepin

.github/workflows/tests.yml

@@ -37,7 +37,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Set up Python ${{ matrix.python }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python }}
 

docs/requirements.txt

@@ -1,6 +1,6 @@
 aiohttp==3.12.15
 autodoc-pydantic==2.2.0
-furo==2025.7.19
+furo==2025.9.25
 linkify-it-py==2.0.3
 matplotlib==3.10.6
 myst-nb==1.3.0

src/mdio/commands/segy.py

@@ -257,17 +257,7 @@ def segy_import(  # noqa: PLR0913
         --header-names shot,cable,chan
         --header-types int32,None,int32
         --chunk-size 8,2,256,512
-        --grid-overrides '{"ChannelWrap": True, "ChannelsPerCable": 800,
-                           "CalculateCable": True}'
 
-        \b
-        If we do have cable numbers in the headers, but channels are still sequential (aka.
-        unwrapped), we can still ingest it like this.
-        --header-locations 9,213,13
-        --header-names shot,cable,chan
-        --header-types int32,int16,int32
-        --chunk-size 8,2,256,512
-        --grid-overrides '{"ChannelWrap":True, "ChannelsPerCable": 800}'
         \b
         No grid overrides are necessary for shot gathers with channel numbers and wrapped channels.
 

src/mdio/segy/geometry.py

@@ -13,7 +13,6 @@
 import numpy as np
 from numpy.lib import recfunctions as rfn
 
-from mdio.segy.exceptions import GridOverrideIncompatibleError
 from mdio.segy.exceptions import GridOverrideKeysError
 from mdio.segy.exceptions import GridOverrideMissingParameterError
 from mdio.segy.exceptions import GridOverrideUnknownError
@@ -371,12 +370,6 @@ class DuplicateIndex(GridOverrideCommand):
 
     def validate(self, index_headers: HeaderArray, grid_overrides: dict[str, bool | int]) -> None:
         """Validate if this transform should run on the type of data."""
-        if "ChannelWrap" in grid_overrides:
-            raise GridOverrideIncompatibleError(self.name, "ChannelWrap")
-
-        if "CalculateCable" in grid_overrides:
-            raise GridOverrideIncompatibleError(self.name, "CalculateCable")
-
         if self.required_keys is not None:
             self.check_required_keys(index_headers)
         self.check_required_params(grid_overrides)
@@ -434,12 +427,6 @@ class AutoChannelWrap(GridOverrideCommand):
 
     def validate(self, index_headers: HeaderArray, grid_overrides: dict[str, bool | int]) -> None:
         """Validate if this transform should run on the type of data."""
-        if "ChannelWrap" in grid_overrides:
-            raise GridOverrideIncompatibleError(self.name, "ChannelWrap")
-
-        if "CalculateCable" in grid_overrides:
-            raise GridOverrideIncompatibleError(self.name, "CalculateCable")
-
         self.check_required_keys(index_headers)
         self.check_required_params(grid_overrides)
 
@@ -469,58 +456,6 @@ def transform(
         return index_headers
 
 
-class ChannelWrap(GridOverrideCommand):
-    """Wrap channels to start from one at cable boundaries."""
-
-    required_keys = {"shot_point", "cable", "channel"}
-    required_parameters = {"ChannelsPerCable"}
-
-    def validate(self, index_headers: HeaderArray, grid_overrides: dict[str, bool | int]) -> None:
-        """Validate if this transform should run on the type of data."""
-        if "AutoChannelWrap" in grid_overrides:
-            raise GridOverrideIncompatibleError(self.name, "AutoCableChannel")
-
-        self.check_required_keys(index_headers)
-        self.check_required_params(grid_overrides)
-
-    def transform(self, index_headers: HeaderArray, grid_overrides: dict[str, bool | int]) -> NDArray:
-        """Perform the grid transform."""
-        self.validate(index_headers, grid_overrides)
-
-        channels_per_cable = grid_overrides["ChannelsPerCable"]
-        index_headers["channel"] = (index_headers["channel"] - 1) % channels_per_cable + 1
-
-        return index_headers
-
-
-class CalculateCable(GridOverrideCommand):
-    """Calculate cable numbers from unwrapped channels."""
-
-    required_keys = {"shot_point", "cable", "channel"}
-    required_parameters = {"ChannelsPerCable"}
-
-    def validate(self, index_headers: HeaderArray, grid_overrides: dict[str, bool | int]) -> None:
-        """Validate if this transform should run on the type of data."""
-        if "AutoChannelWrap" in grid_overrides:
-            raise GridOverrideIncompatibleError(self.name, "AutoCableChannel")
-
-        self.check_required_keys(index_headers)
-        self.check_required_params(grid_overrides)
-
-    def transform(
-        self,
-        index_headers: HeaderArray,
-        grid_overrides: dict[str, bool | int],
-    ) -> NDArray:
-        """Perform the grid transform."""
-        self.validate(index_headers, grid_overrides)
-
-        channels_per_cable = grid_overrides["ChannelsPerCable"]
-        index_headers["cable"] = (index_headers["channel"] - 1) // channels_per_cable + 1
-
-        return index_headers
-
-
 class AutoShotWrap(GridOverrideCommand):
     """Automatically determine ShotGun acquisition type."""
 
@@ -574,8 +509,6 @@ def __init__(self) -> None:
         self.commands = {
             "AutoChannelWrap": AutoChannelWrap(),
             "AutoShotWrap": AutoShotWrap(),
-            "CalculateCable": CalculateCable(),
-            "ChannelWrap": ChannelWrap(),
             "NonBinned": NonBinned(),
             "HasDuplicates": DuplicateIndex(),
         }

tests/unit/test_segy_grid_overrides.py

@@ -14,8 +14,6 @@
 from numpy.testing import assert_array_equal
 
 from mdio.core import Dimension
-from mdio.segy.exceptions import GridOverrideIncompatibleError
-from mdio.segy.exceptions import GridOverrideMissingParameterError
 from mdio.segy.exceptions import GridOverrideUnknownError
 from mdio.segy.geometry import GridOverrider
 
@@ -131,101 +129,6 @@ def test_non_binned(self, mock_streamer_headers: dict[str, npt.NDArray]) -> None
 class TestStreamerGridOverrides:
     """Check grid overrides for shot data with streamer acquisition."""
 
-    def test_channel_wrap(self, mock_streamer_headers: dict[str, npt.NDArray]) -> None:
-        """Test the ChannelWrap command."""
-        index_names = ("shot_point", "cable", "channel")
-        grid_overrides = {"ChannelWrap": True, "ChannelsPerCable": len(RECEIVERS)}
-
-        new_headers, new_names, new_chunks = run_override(grid_overrides, index_names, mock_streamer_headers)
-
-        assert new_names == index_names
-        assert new_chunks is None
-
-        dims = get_dims(new_headers)
-
-        assert_array_equal(dims[0].coords, SHOTS)
-        assert_array_equal(dims[1].coords, CABLES)
-        assert_array_equal(dims[2].coords, RECEIVERS)
-
-    def test_calculate_cable(
-        self,
-        mock_streamer_headers: dict[str, npt.NDArray],
-    ) -> None:
-        """Test the CalculateCable command."""
-        index_names = ("shot_point", "cable", "channel")
-        grid_overrides = {"CalculateCable": True, "ChannelsPerCable": len(RECEIVERS)}
-
-        new_headers, new_names, new_chunks = run_override(grid_overrides, index_names, mock_streamer_headers)
-
-        assert new_names == index_names
-        assert new_chunks is None
-
-        dims = get_dims(new_headers)
-
-        # We need channels because unwrap isn't done here
-        channels = unique(mock_streamer_headers["channel"])
-
-        # We reset the cables to start from 1.
-        cables = arange(1, len(CABLES) + 1, dtype="uint32")
-
-        assert_array_equal(dims[0].coords, SHOTS)
-        assert_array_equal(dims[1].coords, cables)
-        assert_array_equal(dims[2].coords, channels)
-
-    def test_wrap_and_calc_cable(
-        self,
-        mock_streamer_headers: dict[str, npt.NDArray],
-    ) -> None:
-        """Test the combined ChannelWrap and CalculateCable commands."""
-        index_names = ("shot_point", "cable", "channel")
-        grid_overrides = {
-            "CalculateCable": True,
-            "ChannelWrap": True,
-            "ChannelsPerCable": len(RECEIVERS),
-        }
-
-        new_headers, new_names, new_chunks = run_override(grid_overrides, index_names, mock_streamer_headers)
-
-        assert new_names == index_names
-        assert new_chunks is None
-
-        dims = get_dims(new_headers)
-        # We reset the cables to start from 1.
-        cables = arange(1, len(CABLES) + 1, dtype="uint32")
-
-        assert_array_equal(dims[0].coords, SHOTS)
-        assert_array_equal(dims[1].coords, cables)
-        assert_array_equal(dims[2].coords, RECEIVERS)
-
-    def test_missing_param(self, mock_streamer_headers: dict[str, npt.NDArray]) -> None:
-        """Test missing parameters for the commands."""
-        index_names = ("shot_point", "cable", "channel")
-        chunksize = None
-        overrider = GridOverrider()
-
-        with pytest.raises(GridOverrideMissingParameterError):
-            overrider.run(mock_streamer_headers, index_names, {"ChannelWrap": True}, chunksize)
-
-        with pytest.raises(GridOverrideMissingParameterError):
-            overrider.run(mock_streamer_headers, index_names, {"CalculateCable": True}, chunksize)
-
-    def test_incompatible_overrides(
-        self,
-        mock_streamer_headers: dict[str, npt.NDArray],
-    ) -> None:
-        """Test commands that can't be run together."""
-        index_names = ("shot_point", "cable", "channel")
-        chunksize = None
-        overrider = GridOverrider()
-
-        grid_overrides = {"ChannelWrap": True, "AutoChannelWrap": True}
-        with pytest.raises(GridOverrideIncompatibleError):
-            overrider.run(mock_streamer_headers, index_names, grid_overrides, chunksize)
-
-        grid_overrides = {"CalculateCable": True, "AutoChannelWrap": True}
-        with pytest.raises(GridOverrideIncompatibleError):
-            overrider.run(mock_streamer_headers, index_names, grid_overrides, chunksize)
-
     def test_unknown_override(
         self,
         mock_streamer_headers: dict[str, npt.NDArray],