opentrons 8.7.0a7__py3-none-any.whl → 8.8.0a7__py3-none-any.whl

opentrons/protocol_api/module_contexts.py

@@ -44,7 +44,7 @@ from .module_validation_and_errors import (
 from .labware import Labware
 from . import validation
 from . import Task
-
+from opentrons.drivers.thermocycler.driver import BLOCK_VOL_MIN, BLOCK_VOL_MAX
 
 _MAGNETIC_MODULE_HEIGHT_PARAM_REMOVED_IN = APIVersion(2, 14)
 
@@ -667,16 +667,9 @@ class ThermocyclerContext(ModuleContext):
         hold_time_minutes: Optional[float] = None,
         ramp_rate: Optional[float] = None,
         block_max_volume: Optional[float] = None,
-    ) -> Task:
+    ) -> None:
         """Set the target temperature for the well block, in °C.
 
-        .. versionchanged::2.27
-            Returns a task object that represents concurrent preheating.
-            Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for
-            the preheat to complete.
-
-        On version 2.26 or below, this function returns ``None``.
-
         :param temperature: A value between 4 and 99, representing the target
                             temperature in °C.
         :param hold_time_minutes: The number of minutes to hold, after reaching
@@ -706,28 +699,77 @@ class ThermocyclerContext(ModuleContext):
         )
         if self._api_version >= APIVersion(2, 27) and block_max_volume is None:
             block_max_volume = self._get_current_labware_max_vol()
-        task = self._core.set_target_block_temperature(
+        self._core.set_target_block_temperature(
             celsius=temperature,
             hold_time_seconds=seconds,
             block_max_volume=block_max_volume,
             ramp_rate=ramp_rate,
         )
-        if self._api_version >= APIVersion(2, 27):
-            return Task(api_version=self._api_version, core=task)
-        else:
-            return cast(Task, None)
+        self._core.wait_for_block_temperature()
+
+    @publish(command=cmds.thermocycler_start_set_block_temp)
+    @requires_version(2, 27)
+    def start_set_block_temperature(
+        self,
+        temperature: float,
+        ramp_rate: Optional[float] = None,
+        block_max_volume: Optional[float] = None,
+    ) -> Task:
+        """Starts to set the target temperature for the well block, in °C.
+
+        Returns a task object that represents concurrent preheating.
+        Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for
+        the preheat to complete.
+
+        :param temperature: A value between 4 and 99, representing the target
+                            temperature in °C.
+        :param block_max_volume: The greatest volume of liquid contained in any
+                                 individual well of the loaded labware, in µL.
+                                 If not specified, the default is 25 µL.
+                                 After API version 2.27 it will attempt to use
+                                 the liquid tracking of the labware first and
+                                 then fall back to the 25 if there is no probed
+                                 or loaded liquid.
+        """
+
+        if block_max_volume is None:
+            block_max_volume = self._get_current_labware_max_vol()
+        task = self._core.start_set_target_block_temperature(
+            celsius=temperature,
+            block_max_volume=block_max_volume,
+            ramp_rate=ramp_rate,
+        )
+        return Task(api_version=self._api_version, core=task)
 
     @publish(command=cmds.thermocycler_set_lid_temperature)
     @requires_version(2, 0)
-    def set_lid_temperature(self, temperature: float) -> Task:
+    def set_lid_temperature(self, temperature: float) -> None:
         """Set the target temperature for the heated lid, in °C.
 
-        .. versionchanged::2.27
-            Returns a task object that represents concurrent preheating.
-            Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for
-            the preheat to complete.
+        Returns a task object that represents concurrent preheating.
+        Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for
+        the preheat to complete.
 
-        On version 2.26 or below, this function returns ``None``.
+        :param temperature: A value between 37 and 110, representing the target
+                            temperature in °C.
+
+        .. note::
+
+            The Thermocycler will proceed to the next command immediately after
+            ``temperature`` is reached.
+
+        """
+        self._core.set_target_lid_temperature(celsius=temperature)
+        self._core.wait_for_lid_temperature()
+
+    @publish(command=cmds.thermocycler_start_set_lid_temperature)
+    @requires_version(2, 27)
+    def start_set_lid_temperature(self, temperature: float) -> Task:
+        """Set the target temperature for the heated lid, in °C.
+
+        Returns a task object that represents concurrent preheating.
+        Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for
+        the preheat to complete.
 
         :param temperature: A value between 37 and 110, representing the target
                             temperature in °C.
@@ -738,11 +780,8 @@ class ThermocyclerContext(ModuleContext):
             ``temperature`` is reached.
 
         """
-        task = self._core.set_target_lid_temperature(celsius=temperature)
-        if self._api_version >= APIVersion(2, 27):
-            return Task(api_version=self._api_version, core=task)
-        else:
-            return cast(Task, None)
+        task = self._core.start_set_target_lid_temperature(celsius=temperature)
+        return Task(api_version=self._api_version, core=task)
 
     @publish(command=cmds.thermocycler_execute_profile)
     @requires_version(2, 0)
@@ -942,6 +981,10 @@ class ThermocyclerContext(ModuleContext):
                     # ignore simulated probe results
                     if isinstance(well_vol, float):
                         max_vol = max(max_vol, well_vol)
+                    if max_vol > BLOCK_VOL_MAX:
+                        max_vol = BLOCK_VOL_MAX
+                    elif max_vol < BLOCK_VOL_MIN:
+                        max_vol = BLOCK_VOL_MIN
         return max_vol
 
 
@@ -1444,7 +1487,7 @@ class FlexStackerContext(ModuleContext):
     def set_stored_labware_items(
         self,
         labware: list[Labware],
-        stacking_offset_z: float | None,
+        stacking_offset_z: float | None = None,
     ) -> None:
         """Configure the labware the Flex Stacker will store during a protocol by providing an initial list of stored labware objects. The start of the list represents the bottom of the Stacker,
         and the end of the list represents the top of the Stacker.
@@ -1537,9 +1580,15 @@ class FlexStackerContext(ModuleContext):
         :param adapter_namespace: Applies to ``adapter`` the same way that ``namespace``
             applies to ``load_name``.
 
+            .. versionchanged:: 2.26
+                ``adapter_namespace`` may now be specified explicitly. When you've specified ``namespace`` for ``load_name`` but not ``adapter_namespace``, ``adapter_namespace`` now independently follows the same search rules described in ``namespace``. Formerly, it took the exact ``namespace`` value.
+
         :param adapter_version: Applies to ``adapter`` the same way that ``version``
             applies to ``load_name``.
 
+            .. versionchanged:: 2.26
+               ``adapter_version`` may now be specified explictly. When unspecified, improved search rules prevent selecting a version that does not exist.
+
         :param lid: A lid to load the on top of the main labware. Accepts the same
             values as the ``load_name`` parameter of :py:meth:`~.ProtocolContext.load_lid_stack`. The
             lid will use the same namespace as the labware, and the API will
@@ -1548,9 +1597,18 @@ class FlexStackerContext(ModuleContext):
         :param lid_namespace: Applies to ``lid`` the same way that ``namespace``
             applies to ``load_name``.
 
+            .. versionchanged:: 2.26
+               ``lid_namespace`` may now be specified explicitly.
+               When you've specified ``namespace`` for ``load_name`` but not ``lid_namespace``,
+               ``lid_namespace`` now independently follows the same search rules
+               described in ``namespace``. Formerly, it took the exact ``namespace`` value.
+
         :param lid_version: Applies to ``lid`` the same way that ``version``
             applies to ``load_name``.
 
+            .. versionchanged:: 2.26
+               ``lid_version`` may now be specified explicitly. When unspecified, improved search rules prevent selecting a version that does not exist.
+
         :param count: The number of labware that the Flex Stacker should store. If not specified, this will be the maximum amount of this kind of
             labware that the Flex Stacker is capable of storing.
 
@@ -1573,16 +1631,61 @@ class FlexStackerContext(ModuleContext):
               - Labware with lid and adapter: the adapter (bottom side) of the upper labware unit overlaps with the lid (top side) of the unit below.
         """
 
+        if self._api_version < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE:
+            if adapter_namespace is not None:
+                raise APIVersionError(
+                    api_element="The `adapter_namespace` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+            if adapter_version is not None:
+                raise APIVersionError(
+                    api_element="The `adapter_version` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+            if lid_namespace is not None:
+                raise APIVersionError(
+                    api_element="The `lid_namespace` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+            if lid_version is not None:
+                raise APIVersionError(
+                    api_element="The `lid_version` parameter",
+                    until_version=str(
+                        validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE
+                    ),
+                    current_version=str(self._api_version),
+                )
+
+        if self._api_version < validation.NAMESPACE_VERSION_ADAPTER_LID_VERSION_GATE:
+            checked_adapter_namespace = namespace
+            checked_adapter_version = version
+            checked_lid_namespace = namespace
+            checked_lid_version = version
+        else:
+            checked_adapter_namespace = adapter_namespace
+            checked_adapter_version = adapter_version
+            checked_lid_namespace = lid_namespace
+            checked_lid_version = lid_version
+
         self._core.set_stored_labware(
             main_load_name=load_name,
             main_namespace=namespace,
             main_version=version,
             lid_load_name=lid,
-            lid_namespace=lid_namespace,
-            lid_version=lid_version,
+            lid_namespace=checked_lid_namespace,
+            lid_version=checked_lid_version,
             adapter_load_name=adapter,
-            adapter_namespace=adapter_namespace,
-            adapter_version=adapter_version,
+            adapter_namespace=checked_adapter_namespace,
+            adapter_version=checked_adapter_version,
             count=count,
             stacking_offset_z=stacking_offset_z,
         )

opentrons/protocol_api/protocol_context.py

@@ -11,6 +11,7 @@ from typing import (
     Union,
     Mapping,
     cast,
+    Tuple,
 )
 
 from opentrons_shared_data.labware.types import LabwareDefinition
@@ -468,17 +469,15 @@ class ProtocolContext(CommandPublisher):
 
             .. versionchanged:: 2.26
                ``adapter_namespace`` may now be specified explicitly.
-               Also, when you've specified ``namespace`` but not ``adapter_namespace``,
-               ``adapter_namespace`` will now independently follow the same search rules
-               described in ``namespace``. Formerly, it took ``namespace``'s exact value.
+               When you've specified ``namespace`` for ``load_name`` but not ``adapter_namespace``,
+               ``adapter_namespace`` now independently follows the same search rules
+               described in ``namespace``. Formerly, it took the exact ``namespace`` value.
 
         :param adapter_version: The version of the adapter being loaded.
             Applies to ``adapter`` the same way that ``version`` applies to ``load_name``.
 
             .. versionchanged:: 2.26
-               ``adapter_version`` may now be specified explicitly. Also, when it's unspecified,
-               the algorithm to select a version automatically has improved to avoid
-               selecting versions that do not exist.
+               ``adapter_version`` may now be specified explicitly. When unspecified, the API uses the newest version available for your protocol's API level.
 
         :param lid: A lid to load on the top of the main labware. Accepts the same
             values as the ``load_name`` parameter of :py:meth:`.load_lid_stack`. The
@@ -492,17 +491,15 @@ class ProtocolContext(CommandPublisher):
 
             .. versionchanged:: 2.26
                ``lid_namespace`` may now be specified explicitly.
-               Also, when you've specified ``namespace`` but not ``lid_namespace``,
-               ``lid_namespace`` will now independently follow the same search rules
-               described in ``namespace``. Formerly, it took ``namespace``'s exact value.
+               When you've specified ``namespace`` for ``load_name`` but not ``lid_namespace``,
+               ``lid_namespace`` now independently follows the same search rules
+               described in ``namespace``. Formerly, it took the exact ``namespace`` value.
 
         :param lid_version: The version of the adapter being loaded.
             Applies to ``lid`` the same way that ``version`` applies to ``load_name``.
 
             .. versionchanged:: 2.26
-               ``lid_version`` may now be specified explicitly. Also, when it's unspecified,
-               the algorithm to select a version automatically has improved to avoid
-               selecting versions that do not exist.
+               ``lid_version`` may now be specified explicitly. When unspecified, the API uses the newest version available for your protocol's API level.
         """
 
         if isinstance(location, OffDeckType) and self._api_version < APIVersion(2, 15):
@@ -1505,8 +1502,8 @@ class ProtocolContext(CommandPublisher):
             - ``"water"``: an Opentrons-verified liquid class based on deionized water.
             - ``"glycerol_50"``: an Opentrons-verified liquid class for viscous liquid. Based on 50% glycerol.
             - ``"ethanol_80"``: an Opentrons-verified liquid class for volatile liquid. Based on 80% ethanol.
-        :param version: The version of the liquid class to retrieve. If left unspecified, the latest definition for the
-            protocol's API version will be loaded.
+        :param version: Version of the liquid class to retrieve. If left unspecified, defaults to the latest version for the
+            protocol's API level.
 
         :raises: ``LiquidClassDefinitionDoesNotExist``: if the specified liquid class does not exist.
 
@@ -1623,9 +1620,9 @@ class ProtocolContext(CommandPublisher):
 
             .. versionchanged:: 2.26
                ``adapter_namespace`` may now be specified explicitly.
-               Also, when you've specified ``namespace`` but not ``adapter_namespace``,
-               ``adapter_namespace`` will now independently follow the same search rules
-               described in ``namespace``. Formerly, it took ``namespace``'s exact value.
+                When you've specified ``namespace`` for ``load_name`` but not ``adapter_namespace``,
+               ``adapter_namespace`` now independently follows the same search rules
+               described in ``namespace``. Formerly, it took the exact ``namespace`` value.
 
         :param adapter_version: The version of the adapter being loaded.
             Applies to ``adapter`` the same way that ``version`` applies to ``load_name``.
@@ -1825,6 +1822,53 @@ class ProtocolContext(CommandPublisher):
             )
         return None
 
+    @requires_version(2, 27)
+    def capture_image(
+        self,
+        home_before: Optional[bool] = False,
+        filename: Optional[str] = None,
+        resolution: Optional[Tuple[int, int]] = None,
+        zoom: Optional[float] = None,
+        contrast: Optional[float] = None,
+        brightness: Optional[float] = None,
+        saturation: Optional[float] = None,
+    ) -> None:
+        """Capture an image using the camera. Captured images get saved as a result of the protocol run.
+
+        :param home_before: Boolean to home the pipette before capturing an image.
+        :param filename: Filename to use when saving the captured image as a file.
+        :param resolution: Width/height tuple to determine the resolution to use when capturing an image.
+        :param zoom: Optional zoom level, with minimum/default of 1x zoom and maximum of 2x zoom.
+        :param contrast: Contrast level to be applied to an image, range is 0% to 100%.
+        :param brightness: Brightness level to be applied to an image, range is 0% to 100%.
+        :param saturation: Saturation level to be applied to an image, range is 0% to 100%.
+
+        .. versionadded:: 2.27
+
+        """
+        if home_before is True:
+            self._core.home()
+
+        with publish_context(
+            broker=self.broker,
+            command=cmds.capture_image(
+                resolution=resolution,
+                zoom=zoom,
+                contrast=contrast,
+                brightness=brightness,
+                saturation=saturation,
+            ),
+        ):
+            self._core.capture_image(
+                filename=filename,
+                resolution=resolution,
+                zoom=zoom,
+                contrast=contrast,
+                brightness=brightness,
+                saturation=saturation,
+            )
+        return None
+
 
 def _create_module_context(
     module_core: Union[ModuleCore, NonConnectedModuleCore],

opentrons/protocol_api/robot_context.py

@@ -15,7 +15,6 @@ from opentrons.legacy_commands import publisher
 from opentrons.hardware_control import SyncHardwareAPI
 from opentrons.protocols.api_support.util import requires_version
 from opentrons.protocols.api_support.types import APIVersion
-from opentrons_shared_data.pipette.types import PipetteNameType
 
 from . import validation
 from .core.common import ProtocolCore, RobotCore
@@ -125,7 +124,7 @@ class RobotContext(publisher.CommandPublisher):
 
         """
         instrument_on_left = self._core.get_pipette_type_from_engine(Mount.LEFT)
-        is_96_channel = instrument_on_left == PipetteNameType.P1000_96
+        is_96_channel = validation.is_pipette_96_channel(instrument_on_left)
         axis_map = validation.ensure_axis_map_type(
             axis_map, self._protocol_core.robot_type, is_96_channel
         )
@@ -162,7 +161,7 @@ class RobotContext(publisher.CommandPublisher):
         :param float speed: The maximum speed with which to move all axes in mm/s.
         """
         instrument_on_left = self._core.get_pipette_type_from_engine(Mount.LEFT)
-        is_96_channel = instrument_on_left == PipetteNameType.P1000_96
+        is_96_channel = validation.is_pipette_96_channel(instrument_on_left)
 
         axis_map = validation.ensure_axis_map_type(
             axis_map, self._protocol_core.robot_type, is_96_channel
@@ -313,7 +312,7 @@ class RobotContext(publisher.CommandPublisher):
 
         """
         instrument_on_left = self._core.get_pipette_type_from_engine(Mount.LEFT)
-        is_96_channel = instrument_on_left == PipetteNameType.P1000_96
+        is_96_channel = validation.is_pipette_96_channel(instrument_on_left)
 
         return validation.ensure_axis_map_type(
             axis_map, self._protocol_core.robot_type, is_96_channel

opentrons/protocol_api/validation.py

@@ -99,11 +99,18 @@ class InvalidFixtureLocationError(ValueError):
     """An error raised when attempting to load a fixture in an invalid cutout."""
 
 
+def is_pipette_96_channel(pipette: Optional[PipetteNameType]) -> bool:
+    """Return if this pipette type is a 96 channel."""
+    if pipette is not None:
+        return pipette in [PipetteNameType.P1000_96, PipetteNameType.P200_96]
+    return False
+
+
 def ensure_mount_for_pipette(
     mount: Union[str, Mount, None], pipette: PipetteNameType
 ) -> Mount:
     """Ensure that an input value represents a valid mount, and is valid for the given pipette."""
-    if pipette in [PipetteNameType.P1000_96, PipetteNameType.P200_96]:
+    if is_pipette_96_channel(pipette):
         # Always validate the raw mount input, even if the pipette is a 96-channel and we're not going
         # to use the mount value.
         if mount is not None:
@@ -370,7 +377,7 @@ def ensure_definition_is_not_lid_after_api_version(
         and api_version >= LID_STACK_VERSION_GATE
     ):
         raise APIVersionError(
-            f"Labware Lids cannot be loaded like standard labware in Protocols written with an API version greater than {LID_STACK_VERSION_GATE}."
+            f"Labware Lids cannot be loaded like standard labware in Protocols written with an API version of {LID_STACK_VERSION_GATE} or higher."
         )
 
 
@@ -570,6 +577,40 @@ class LocationTypeError(TypeError):
 ValidTarget = Union[WellTarget, PointTarget, DisposalTarget]
 
 
+def validate_dynamic_locations(
+    location: Optional[Union[Location, Well, TrashBin, WasteChute]],
+    end_location: Location,
+) -> None:
+    """Given that we have an end_location we check that they're a vaild dynamic pair."""
+    if location is None:
+        raise ValueError("Location must be supplied if using an End Location.")
+    if not isinstance(location, Location):
+        raise ValueError(
+            "Location must be a point within a well when dynamic pipetting."
+        )
+    # Shouldn't be true ever if using typing but a customer protocol may not check
+    if not isinstance(end_location, Location):
+        raise ValueError(
+            "End location must be a point within a well when dynamic pipetting."
+        )
+    if not location.labware.is_well:
+        raise ValueError("Start location must be within a well when dynamic pipetting")
+    if not end_location.labware.is_well:
+        raise ValueError("End location must be within a well when dynamic pipetting")
+    (
+        _,
+        start_well,
+    ) = location.labware.get_parent_labware_and_well()
+    (
+        _,
+        end_well,
+    ) = end_location.labware.get_parent_labware_and_well()
+    if start_well != end_well:
+        raise ValueError(
+            "Start and end locations must be within the same well when dynamic pipetting"
+        )
+
+
 def validate_location(
     location: Optional[Union[Location, Well, TrashBin, WasteChute]],
     last_location: Optional[Union[Location, TrashBin, WasteChute]],

opentrons/protocol_engine/__init__.py

@@ -41,6 +41,8 @@ from .types import (
     DeckType,
     DeckSlotLocation,
     InStackerHopperLocation,
+    WASTE_CHUTE_LOCATION,
+    AccessibleByGripperLocation,
     ModuleLocation,
     OnLabwareLocation,
     AddressableAreaLocation,
@@ -120,6 +122,8 @@ __all__ = [
     "ModuleLocation",
     "OnLabwareLocation",
     "AddressableAreaLocation",
+    "WASTE_CHUTE_LOCATION",
+    "AccessibleByGripperLocation",
     "InStackerHopperLocation",
     "OFF_DECK_LOCATION",
     "SYSTEM_LOCATION",

opentrons/protocol_engine/actions/__init__.py

@@ -21,6 +21,7 @@ from .actions import (
     AddLabwareOffsetAction,
     AddLabwareDefinitionAction,
     AddLiquidAction,
+    AddCameraSettingsAction,
     SetDeckConfigurationAction,
     AddAddressableAreaAction,
     AddModuleAction,
@@ -51,6 +52,7 @@ __all__ = [
     "FailCommandAction",
     "AddLabwareOffsetAction",
     "AddLabwareDefinitionAction",
+    "AddCameraSettingsAction",
     "AddLiquidAction",
     "SetDeckConfigurationAction",
     "AddAddressableAreaAction",

opentrons/protocol_engine/actions/actions.py

@@ -24,6 +24,7 @@ from ..error_recovery_policy import ErrorRecoveryPolicy, ErrorRecoveryType
 from ..errors import ErrorOccurrence
 from ..notes.notes import CommandNote
 from ..state.update_types import StateUpdate
+from ..resources.camera_provider import CameraSettings
 from ..types import (
     LabwareOffsetCreateInternal,
     ModuleDefinition,
@@ -236,6 +237,13 @@ class AddLabwareDefinitionAction:
     definition: LabwareDefinition
 
 
+@dataclasses.dataclass(frozen=True)
+class AddCameraSettingsAction:
+    """Add Camera settings to be used in place of the Camera Provider accessible settings."""
+
+    enablement_settings: CameraSettings
+
+
 @dataclasses.dataclass(frozen=True)
 class AddLiquidAction:
     """Add a liquid, to apply to subsequent `LoadLiquid`s."""
@@ -305,6 +313,7 @@ Action = Union[
     AddLabwareOffsetAction,
     AddLabwareDefinitionAction,
     AddModuleAction,
+    AddCameraSettingsAction,
     SetDeckConfigurationAction,
     AddAddressableAreaAction,
     AddLiquidAction,

opentrons/protocol_engine/commands/__init__.py

@@ -451,6 +451,14 @@ from .identify_module import (
     IdentifyModuleCommandType,
 )
 
+from .capture_image import (
+    CaptureImage,
+    CaptureImageParams,
+    CaptureImageCreate,
+    CaptureImageResult,
+    CaptureImageCommandType,
+)
+
 __all__ = [
     # command type unions
     "Command",
@@ -796,4 +804,10 @@ __all__ = [
     "WaitForTasksParams",
     "WaitForTasksResult",
     "WaitForTasksCommandType",
+    # capture image command bundle
+    "CaptureImage",
+    "CaptureImageCreate",
+    "CaptureImageParams",
+    "CaptureImageResult",
+    "CaptureImageCommandType",
 ]

opentrons/protocol_engine/commands/absorbance_reader/read.py

@@ -7,14 +7,15 @@ from typing_extensions import Literal, Type
 from pydantic import BaseModel, Field
 from pydantic.json_schema import SkipJsonSchema
 
+from opentrons_shared_data.data_files import MimeType
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ...errors import CannotPerformModuleAction, StorageLimitReachedError
+from ...errors import CannotPerformModuleAction
 from ...errors.error_occurrence import ErrorOccurrence
 
 from ...resources.file_provider import (
     PlateReaderData,
     ReadData,
-    MAXIMUM_CSV_FILE_LIMIT,
+    ReadCmdFileNameMetadata,
 )
 from ...resources import FileProvider
 from ...state import update_types
@@ -93,21 +94,6 @@ class ReadAbsorbanceImpl(
                 "Absorbance Plate Reader can't read a plate with the lid open. Call `close_lid()` first."
             )
 
-        # TODO: we need to return a file ID and increase the file count even when a moduel is not attached
-        if (
-            params.fileName is not None
-            and abs_reader_substate.configured_wavelengths is not None
-        ):
-            # Validate that the amount of files we are about to generate does not put us higher than the limit
-            if (
-                self._state_view.files.get_filecount()
-                + len(abs_reader_substate.configured_wavelengths)
-                > MAXIMUM_CSV_FILE_LIMIT
-            ):
-                raise StorageLimitReachedError(
-                    message=f"Attempt to write file {params.fileName} exceeds file creation limit of {MAXIMUM_CSV_FILE_LIMIT} files."
-                )
-
         asbsorbance_result: Dict[int, Dict[str, float]] = {}
         transform_results = []
         # Handle the measurement and begin building data for return
@@ -172,15 +158,28 @@ class ReadAbsorbanceImpl(
             )
 
             if isinstance(plate_read_result, PlateReaderData):
+                this_cmd_id = self._state_view.commands.get_running_command_id()
+                prev_cmd = (
+                    self._state_view.commands.get_most_recently_finalized_command()
+                )
+                prev_cmd_id = prev_cmd.command.id if prev_cmd is not None else None
+
                 # Write a CSV file for each of the measurements taken
                 for measurement in plate_read_result.read_results:
-                    file_id = await self._file_provider.write_csv(
-                        write_data=plate_read_result.build_generic_csv(
-                            filename=params.fileName,
-                            measurement=measurement,
-                        )
+                    csv_bytes = plate_read_result.build_csv_bytes(
+                        measurement=measurement,
+                    )
+                    file_info = await self._file_provider.write_file(
+                        data=csv_bytes,
+                        mime_type=MimeType.TEXT_CSV,
+                        command_metadata=ReadCmdFileNameMetadata(
+                            base_filename=params.fileName,
+                            wavelength=measurement.wavelength,
+                            command_id=this_cmd_id or "",
+                            prev_command_id=prev_cmd_id or "",
+                        ),
                     )
-                    file_ids.append(file_id)
+                    file_ids.append(file_info.id)
 
                 state_update.files_added = update_types.FilesAddedUpdate(
                     file_ids=file_ids