fix(api): Disposal location slot occupation collision checking (#17841)

This addresses part of EXEC-1353
Allows geometry to check for disposal locations when looking for engine slot items.

Author: CaseyBatten

api/src/opentrons/protocol_engine/state/geometry.py

@@ -76,6 +76,7 @@
     OnAddressableAreaLocationSequenceComponent,
     OnCutoutFixtureLocationSequenceComponent,
     NotOnDeckLocationSequenceComponent,
+    AreaType,
     labware_location_is_off_deck,
     labware_location_is_system,
 )
@@ -907,6 +908,32 @@ def _get_potential_fixtures_for_location_occupation(
             fixtures = None
         return fixtures
 
+    def _get_potential_disposal_location_cutout_fixtures(
+        self, slot_name: DeckSlotName
+    ) -> CutoutFixture | None:
+        for area in self._addressable_areas.get_all():
+            if (
+                self._addressable_areas.get_addressable_area(area).area_type
+                == AreaType.WASTE_CHUTE
+                or self._addressable_areas.get_addressable_area(area).area_type
+                == AreaType.MOVABLE_TRASH
+            ) and slot_name == self._addressable_areas.get_addressable_area_base_slot(
+                area
+            ):
+                # Given we only have one Waste Chute fixture and one type of Trash bin fixture it's
+                # fine to return the first result of our potential fixtures here. This will need to
+                # change in the future if there multiple trash fixtures that share the same area type.
+                potential_fixture = (
+                    deck_configuration_provider.get_potential_cutout_fixtures(
+                        area, self._addressable_areas.deck_definition
+                    )[1].pop()
+                )
+                return deck_configuration_provider.get_cutout_fixture(
+                    potential_fixture.cutout_fixture_id,
+                    self._addressable_areas.deck_definition,
+                )
+        return None
+
     def get_labware_grip_point(
         self,
         labware_definition: LabwareDefinition,
@@ -1042,6 +1069,7 @@ def get_slot_item(
             maybe_fixture = self._addressable_areas.get_fixture_by_deck_slot_name(
                 slot_name
             )
+
             # Ignore generic single slot fixtures
             if maybe_fixture and maybe_fixture["id"] in {
                 "singleLeftSlot",
@@ -1053,6 +1081,13 @@ def get_slot_item(
             maybe_module = self._modules.get_by_slot(
                 slot_name=slot_name,
             ) or self._modules.get_overflowed_module_in_slot(slot_name=slot_name)
+
+            # For situations in which the deck config is none
+            if maybe_fixture is None and maybe_labware is None and maybe_module is None:
+                # todo(chb 2025-03-19): This can go away once we solve the problem of no deck config in analysis
+                maybe_fixture = self._get_potential_disposal_location_cutout_fixtures(
+                    slot_name
+                )
         else:
             # Modules and fixtures can't be loaded on staging slots
             maybe_fixture = None

api/tests/opentrons/protocol_engine/state/test_geometry_view.py

@@ -18,7 +18,7 @@
 )
 
 from opentrons_shared_data import get_shared_data_root, load_shared_data
-from opentrons_shared_data.deck.types import DeckDefinitionV5
+from opentrons_shared_data.deck.types import DeckDefinitionV5, CutoutFixture
 from opentrons_shared_data.deck import load as load_deck
 from opentrons_shared_data.labware.types import LabwareUri
 from opentrons_shared_data.pipette import pipette_definition
@@ -45,7 +45,6 @@
     labware_definition_type_adapter,
 )
 from opentrons_shared_data.labware import load_definition as load_labware_definition
-
 from opentrons.protocol_engine import errors
 from opentrons.protocol_engine.types import (
     OFF_DECK_LOCATION,
@@ -89,6 +88,9 @@
     OnCutoutFixtureLocationSequenceComponent,
     InStackerHopperLocation,
     PotentialCutoutFixture,
+    AddressableArea,
+    AreaType,
+    AddressableOffsetVector,
 )
 from opentrons.protocol_engine.commands import (
     CommandStatus,
@@ -134,6 +136,7 @@
     mountOffset,
 )
 
+
 from .command_fixtures import (
     create_comment_command,
 )
@@ -2580,28 +2583,88 @@ def test_get_slot_item(
     decoy: Decoy,
     mock_labware_view: LabwareView,
     mock_module_view: ModuleView,
+    ot3_standard_deck_def: DeckDefinitionV5,
     subject: GeometryView,
 ) -> None:
     """It should get items in certain slots."""
     labware = LoadedLabware.model_construct(id="cool-labware")  # type: ignore[call-arg]
     module = LoadedModule.model_construct(id="cool-module")  # type: ignore[call-arg]
+    chute_fixture = CutoutFixture(
+        id="wasteChuteRightAdapterNoCover",
+        mayMountTo=["cutoutD3"],
+        providesAddressableAreas={
+            "cutoutD3": [
+                "1ChannelWasteChute",
+                "8ChannelWasteChute",
+                "96ChannelWasteChute",
+                "gripperWasteChute",
+            ]
+        },
+        displayName="Waste Chute Adapter for 96 Channel Pipette or Gripper",
+        fixtureGroup={},
+        expectOpentronsModuleSerialNumber=False,
+        height=124.5,
+    )
+    chute_area = AddressableArea(
+        area_name="1ChannelWasteChute",
+        area_type=AreaType.WASTE_CHUTE,
+        base_slot=DeckSlotName.SLOT_D3,
+        display_name="",
+        bounding_box=Dimensions(x=0, y=0, z=0),
+        position=AddressableOffsetVector(x=0, y=0, z=0),
+        compatible_module_types=[],
+    )
+    subject._addressable_areas = AddressableAreaView(
+        state=AddressableAreaState(
+            loaded_addressable_areas_by_name={
+                "1ChannelWasteChute": chute_area,
+            },
+            potential_cutout_fixtures_by_cutout_id={
+                "cutoutD3": {
+                    PotentialCutoutFixture(
+                        cutout_id="cutoutD3",
+                        cutout_fixture_id="cool_chute",
+                        provided_addressable_areas=frozenset({chute_area.area_name}),
+                    )
+                },
+                "cutoutC3": {
+                    PotentialCutoutFixture(
+                        cutout_id="cutoutC3",
+                        cutout_fixture_id="cool_trash",
+                        provided_addressable_areas=frozenset({chute_area.area_name}),
+                    )
+                },
+            },
+            deck_definition=ot3_standard_deck_def,
+            deck_configuration=[
+                ("cutoutC1", "singleLeftSlot", None),
+                ("cutoutD1", "singleLeftSlot", None),
+                ("cutoutD2", "singleCenterSlot", None),
+                ("cutoutD3", "wasteChuteRightAdapterNoCover", None),
+            ],
+            robot_type=subject._addressable_areas._state.robot_type,
+            use_simulated_deck_config=subject._addressable_areas._state.use_simulated_deck_config,
+            robot_definition=subject._addressable_areas._state.robot_definition,
+        )
+    )
 
-    decoy.when(mock_labware_view.get_by_slot(DeckSlotName.SLOT_1)).then_return(None)
-    decoy.when(mock_labware_view.get_by_slot(DeckSlotName.SLOT_2)).then_return(labware)
-    decoy.when(mock_labware_view.get_by_slot(DeckSlotName.SLOT_3)).then_return(None)
+    decoy.when(mock_labware_view.get_by_slot(DeckSlotName.SLOT_D1)).then_return(None)
+    decoy.when(mock_labware_view.get_by_slot(DeckSlotName.SLOT_D2)).then_return(labware)
+    decoy.when(mock_labware_view.get_by_slot(DeckSlotName.SLOT_C1)).then_return(None)
 
-    decoy.when(mock_module_view.get_by_slot(DeckSlotName.SLOT_1)).then_return(None)
-    decoy.when(mock_module_view.get_by_slot(DeckSlotName.SLOT_2)).then_return(None)
-    decoy.when(mock_module_view.get_by_slot(DeckSlotName.SLOT_3)).then_return(module)
+    decoy.when(mock_module_view.get_by_slot(DeckSlotName.SLOT_D1)).then_return(module)
+    decoy.when(mock_module_view.get_by_slot(DeckSlotName.SLOT_D2)).then_return(None)
+    decoy.when(mock_module_view.get_by_slot(DeckSlotName.SLOT_C1)).then_return(None)
 
     assert (
         subject.get_slot_item(
-            DeckSlotName.SLOT_1,
+            DeckSlotName.SLOT_C1,
         )
         is None
     )
-    assert subject.get_slot_item(DeckSlotName.SLOT_2) == labware
-    assert subject.get_slot_item(DeckSlotName.SLOT_3) == module
+    assert subject.get_slot_item(DeckSlotName.SLOT_D2) == labware
+    assert subject.get_slot_item(DeckSlotName.SLOT_D1) == module
+    assert subject.get_slot_item(DeckSlotName.SLOT_D3) == chute_fixture
 
 
 def test_get_slot_item_that_is_overflowed_module(