all changes made for load plate

Author: caseystone

src/liconic_interface/inventory_handler.py

@@ -125,7 +125,8 @@ def add_plate(
         stack: int,
         slot: int,
         plate_id: Optional[str] = None,
-        conveyor_child_resource: Optional[Resource] = None,
+        plate_resource: Resource = None,
+        current_liconic_resource: Resource = None,
     ) -> None:
         """
         Updates the liconic inventory file when a new plate is placed into the incubator.
@@ -146,29 +147,30 @@ def add_plate(
         # Validations if function is called directly
         if not self.is_valid_plate_type(plate_type):  # SHOULD STILL WORK
             raise ValueError(f"Unsupported plate type: {plate_type}")
-        if stack not in self.find_valid_stack(plate_type):
+        if stack not in self.find_valid_stack(
+            plate_type=plate_type,
+            resource=current_liconic_resource
+        ):
             raise ValueError(f"Invalid stack {stack} for plate type {plate_type}")
-        if not self.is_valid_stack_slot(stack, slot):
+        if not self.is_valid_stack_slot(
+            stack=stack,
+            slot=slot,
+            current_liconic_resource=current_liconic_resource
+        ):
             raise ValueError(
                 f"Invalid stack/slot combination: stack {stack}, slot {slot}"
             )
-        if self.is_location_occupied(stack, slot):
+        if self.is_location_occupied(
+            stack=stack,
+            slot=slot,
+            current_liconic_resource=current_liconic_resource,
+        ):
             raise Exception("Location already occupied")
 
-        # Add the plate to the inventory file
-        self.inventory[stack][slot] = Slot(
-            occupied=True,
-            plate_id=plate_id,
-            time_added=str(datetime.datetime.now()),
-        )
-        self.update_inventory_file()
-
-        # Handle Resource Client calls
-        # Collect conveyor plate resource, if available.
-        conveyor_child_resource = self.resource_client.query_resource(resource_name=f"{self.node_name}_conveyor.nest").child
         # Push plate resource onto stack/slot nest resource
-        stack_slot_resource = self.resource_client.query_resource(resource_name=f"{self.node_name}_stack{stack}_slot{slot}.nest")
-        self.resource_client.push(resource=stack_slot_resource, child=conveyor_child_resource)
+        stack_resource = current_liconic_resource.children[str(stack)]
+        slot_resource = stack_resource.children[str(slot)]
+        self.resource_client.push(resource=slot_resource, child=plate_resource)
 
 
     def remove_plate(
@@ -216,22 +218,51 @@ def remove_plate(
         # Push plate resource onto conveyor resource
         self.resource_client.push(resource=conveyor_resource, child=stack_slot_resource_child)
 
-    def find_plate(self, plate_id: str) -> tuple[int, int]:
+    def find_plate(
+        self,
+        plate_id: str,
+        current_liconic_resource: Resource,
+    ) -> tuple[int, int]:
         """
         Returns the stack and slot a plate is located on, given the plate id
 
         Args:
             plate_type (str):  name of the plate that matches existing plate definition
+            current_liconic_resource (Resource): MADSci Resource object representing the current state of the incubator.
 
         Returns:
             tuple[int, int]: Tuple with the (stack, slot) location of the plate with the specified plate_id
         """
-        for stack_key, stack in self.inventory.stacks.items():
-            for slot_key, slot in stack.slots.items():
-                if slot.plate_id == plate_id:
-                    return stack_key, slot_key
+        # TODO: TEST THIS ONce A PLATE WITH A PLATE ID IS ADDED
+        located_stack = None
+        located_slot = None
+        for stack in current_liconic_resource.children:
+            stack_resource = current_liconic_resource.children[stack]
+            for slot in stack_resource.children:
+                slot_resource = stack_resource.children[slot]
+                # TESTING
+                print(stack)
+                print(f"\t{slot}")
+                if len(slot_resource.children) == 1:
+                    print("slot occupied")
+                    if slot_resource.children[0].attributes["liconic_plate_id"] == plate_id:
+                        print("MATCHING PLATE ID FOUND!")
+                        located_stack = int(stack)
+                        located_slot = int(slot)
+                else:
+                    print("slot empty")
+        if located_stack and located_slot:
+            return (located_stack, located_slot)
         raise ValueError("Plate not found")
 
+
+
+        # for stack_key, stack in self.inventory.stacks.items():
+        #     for slot_key, slot in stack.slots.items():
+        #         if slot.plate_id == plate_id:
+        #             return stack_key, slot_key
+        # raise ValueError("Plate not found")
+
     def get_next_free_slot(
         self,
         plate_type: str,
@@ -291,19 +322,27 @@ def get_next_free_slot(
 
         raise Exception(f"No valid stacks found for plate type '{plate_type}'")
 
-    def is_location_occupied(self, stack: int, slot: int) -> bool:
+    def is_location_occupied(
+        self,
+        stack: int,
+        slot: int,
+        current_liconic_resource: Resource
+    ) -> bool:
         """
         Given a stack and slot, determine if the location is occupied
 
         Args:
             stack (int): stack number in the incubator
             slot (int): slot number in the stack
+            current_liconic_resource: Resource object for the current incubator state
 
         Returns:
             bool: True if location occupied, False otherwise
 
         """
-        return self.inventory[int(stack)][int(slot)].occupied
+        stack_resource = current_liconic_resource.children[str(stack)]
+        slot_resource = stack_resource.children[str(slot)]
+        return len(slot_resource.children) == 1
 
     def get_plate_id(self, stack: int, slot: int) -> str:
         """
@@ -363,7 +402,12 @@ def is_valid_plate_type(self, plate_type: str) -> bool:
         """
         return plate_type in self.labware_definitions
 
-    def is_valid_stack_slot(self, stack: int, slot: int) -> bool:
+    def is_valid_stack_slot(
+        self,
+        stack: int,
+        slot: int,
+        current_liconic_resource: Resource,
+    ) -> bool:
         """
         Checks if the given stack and slot are valid for the current configuration
 
@@ -375,10 +419,13 @@ def is_valid_stack_slot(self, stack: int, slot: int) -> bool:
             bool: True if stack/slot combination is valid for the current configuration, False otherwise
         """
         valid = True
-        if stack not in self.inventory.stacks:
+        if str(stack) not in current_liconic_resource.children:
             valid = False
-        if slot not in self.inventory[stack].slots:
+        if str(slot) not in current_liconic_resource.children[str(stack)].children:
             valid = False
+
+        # TESTING
+        print(f"STACK/SLOT COMBO IS VALID?: {valid}")
         return valid
 
 

src/liconic_interface/pydantic_models.py

@@ -4,6 +4,8 @@
 
 from pydantic import BaseModel, field_validator, model_validator
 
+from madsci.common.types.resource_types import Container
+
 
 class LoadPlateModel(BaseModel):
     """Model for loading a plate into the LiCONiC incubator"""
@@ -13,6 +15,7 @@ class LoadPlateModel(BaseModel):
     stack: Optional[int] = None
     slot: Optional[int] = None
     resource_tracker: Any = None
+    current_liconic_resource: Container = None
 
     def __init__(self, **data: Any) -> None:
         """Initializes the load plate model"""
@@ -43,27 +46,42 @@ def validate_with_resource_tracker(self) -> "LoadPlateModel":
         if self.stack and self.slot:
             # 3a. Check that the stack is valid for the specified plate type
             valid_stacks = self.resource_tracker.find_valid_stack(
-                plate_type=self.plate_type
+                plate_type=self.plate_type,
+                resource = self.current_liconic_resource,
             )
             if self.stack not in valid_stacks:
                 raise ValueError(
                     f"Stack {self.stack} not valid for plate type {self.plate_type}"
                 )
             # 3b. Check that the stack/slot combination is valid
-            if not self.resource_tracker.is_valid_stack_slot(self.stack, self.slot):
+            if not self.resource_tracker.is_valid_stack_slot(
+                self.stack,
+                self.slot,
+                self.current_liconic_resource,
+            ):
                 raise ValueError(
                     f"Invalid stack/slot combination: stack {self.stack}, slot {self.slot}"
                 )
             # 3c. Check that the location is not already occupied
-            if self.resource_tracker.is_location_occupied(self.stack, self.slot):
+            print("CHECKING LOCATION OCCUPIED")
+            if self.resource_tracker.is_location_occupied(
+                self.stack,
+                self.slot,
+                self.current_liconic_resource
+            ):
                 raise ValueError(
                     f"Location stack {self.stack}, slot {self.slot} already occupied."
                 )
 
         # 4. Prevent duplicate plate ids
+        print("PREVENTING DUPLICATE PLATE IDS")
+        # TODO: TEST THIS WHEN A PLATE IS LOADED THAT HAS A PLATE ID
         if self.plate_id and str(self.plate_id).lower() != "none":
             try:
-                self.resource_tracker.find_plate(self.plate_id)
+                self.resource_tracker.find_plate(
+                    self.plate_id,
+                    self.current_liconic_resource,
+                )
             except ValueError:
                 # if we get a ValueError, then no existing plate with the same ID was found
                 return self

src/liconic_rest_node.py

@@ -95,6 +95,10 @@ def init_resource_templates(self) -> None:
             tags=["PlateNest", "ANSI/SLAS"],
         )
 
+        # TODO: microplate resource template?
+
+        # TODO: deep well plate template?
+
     def create_resources(self) -> None:
         """Create resources for the node module."""
 
@@ -421,24 +425,24 @@ def load_plate(
     ) -> None:
         """Load a plate into the incubator"""
 
+        # Collect current liconic container resource
+        liconic_resource = self.resource_client.get_resource(self.liconic_container_resource_id)
+
         # Validate arguments with pydantic model
         try:
-            # TODO: convert pydantic model checks to use rezource handler, not inventory handler!
             LoadPlateModel(
                 plate_type=plate_type,
                 plate_id=plate_id,
                 stack=stack,
                 slot=slot,
+                current_liconic_resource = liconic_resource,
                 resource_tracker=self.inventory_handler,
             )
         except Exception as err:
             # Don't put device into error state if argument validation fails, just fail action
             self.logger.log_error(f"Error validating load_plate arguments: {err}")
             return ActionFailed(errors=str(err))
 
-        # Collect current liconic container resource
-        liconic_resource = self.resource_client.get_resource(self.liconic_container_resource_id)
-
         # Find next free slot if none specified
         if stack is None and slot is None:
             stack, slot = self.inventory_handler.get_next_free_slot(
@@ -451,30 +455,45 @@ def load_plate(
             self.logger.log_error(
                 "Load_plate command cannot be completed, no plate in transfer station."
             )
-            # return ActionFailed(
-            #     "Load_plate command cannot be completed, no plate in transfer station"
-            # )
-        else: # there is a plate in the transfer location
+            return ActionFailed(
+                "Load_plate command cannot be completed, no plate in transfer station"
+            )
+        # There is a plate in the transfer location. Collect the plate resource object.
+        try:
             plate_resource = self.resource_client.get_resource(self.plate_carrier).child
+        except Exception as e:
+            self.logger.log_error("There is no plate resource on the conveyor belt to load.")
+            return ActionFailed("There is no plate resource on the conveyor belt to load.")
+
+        # we can assume a plate resource will be there (plate_id might not be listed as an attribute yet)
+        # TODO: add liconic_plate_id attribute to plate resource
+        if plate_id:
+            try:
+                existing_liconic_plate_id = plate_resource.attributes["liconic_plate_id"]
+
+                # compare to entered plate id
+                if plate_id != existing_liconic_plate_id:
+                    self.logger.log_warning(f"Existing liconic_plate_id attribute {existing_liconic_plate_id} does not match user entered plate id {plate_id}.")
+            except Exception as e:
+                self.logger.log_info("plate resource has no existing liconic_plate_id attribute.")
+            # set the plate id attribute
+            plate_resource.attributes["liconic_plate_id"] = plate_id
+            self.resource_client.add_or_update_resource(plate_resource)
 
         # # Load the plate
         # self.liconic_interface.load_plate(stack=stack, slot=slot)
         # while self.liconic_interface.is_busy:
         #     time.sleep(1)
 
         # Set plate resource as child to slot resource
-        # TODO: START HERE TOMORROW - add this method to the inventory handler
-        self.inventory_handler.load_plate_into_slot(
-            plate_resource = plate_resource,
-            stack = stack,
-            slot = slot,
+        self.inventory_handler.add_plate(
+            plate_id=plate_id,
+            stack=stack,
+            slot=slot,
+            plate_type=plate_type,
+            plate_resource=plate_resource,
+            current_liconic_resource = liconic_resource,
         )
-        # self.inventory_handler.add_plate(
-        #     plate_id=plate_id,
-        #     stack=stack,
-        #     slot=slot,
-        #     plate_type=plate_type,
-        # )
         self.logger.log_info(f"Plate loaded into LiCONiC stack {stack}, slot {slot}")
         return None