add plr_to_bioyond, and refactor bioyond stations

unilabos/resources/graphio.py

@@ -2,12 +2,13 @@ import importlib
 import inspect
 import json
 import traceback
-from typing import Union, Any, Dict, List
+from typing import Union, Any, Dict, List, Tuple
 import networkx as nx
 from pylabrobot.resources import ResourceHolder
 from unilabos_msgs.msg import Resource
 
 from unilabos.resources.container import RegularContainer
+from unilabos.resources.itemized_carrier import ItemizedCarrier
 from unilabos.ros.msgs.message_converter import convert_to_ros_msg
 from unilabos.ros.nodes.resource_tracker import (
     ResourceDictInstance,
@@ -576,13 +577,13 @@ def resource_plr_to_ulab(resource_plr: "ResourcePLR", parent_name: str = None, w
     return r
 
 
-def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: dict = {}, deck: Any = None) -> list[dict]:
+def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[str, Tuple[str, str]] = {}, deck: Any = None) -> list[dict]:
     """
     将 bioyond 物料格式转换为 ulab 物料格式
 
     Args:
         bioyond_materials: bioyond 系统的物料查询结果列表
-        type_mapping: 物料类型映射字典，格式 {bioyond_type: plr_class_name}
+        type_mapping: 物料类型映射字典，格式 {bioyond_type: [plr_class_name, class_uuid]}
         location_id_mapping: 库位 ID 到名称的映射字典，格式 {location_id: location_name}
 
     Returns:
@@ -592,7 +593,7 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: dict =
 
     for material in bioyond_materials:
         className = (
-            type_mapping.get(material.get("typeName"), "RegularContainer") if type_mapping else "RegularContainer"
+            type_mapping.get(material.get("typeName"), ("RegularContainer", ""))[0] if type_mapping else "RegularContainer"
         )
 
         plr_material: ResourcePLR = initialize_resource(
@@ -614,7 +615,7 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: dict =
                     # plr_material.unassign_child_resource(bottle)
                     plr_material.sites[number] = None
                     plr_material[number] = initialize_resource(
-                        {"name": f'{detail["name"]}_{number}', "class": type_mapping[detail["name"]]}, resource_type=ResourcePLR
+                        {"name": f'{detail["name"]}_{number}', "class": type_mapping[detail["name"]][0]}, resource_type=ResourcePLR
                     )
                 else:
                     bottle.tracker.liquids = [
@@ -645,32 +646,59 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: dict =
     return plr_materials
 
 
-def resource_plr_to_bioyond(plr_materials: list[ResourcePLR], type_mapping: dict = {}, warehouse_mapping: dict = {}) -> list[dict]:
+def resource_plr_to_bioyond(plr_resources: list[ResourcePLR], type_mapping: dict = {}, warehouse_mapping: dict = {}) -> list[dict]:
     bioyond_materials = []
-    for plr_material in plr_materials:
-        material = {
-            "name": plr_material.name,
-            "typeName": plr_material.__class__.__name__,
-            "code": plr_material.code,
-            "quantity": 0,
-            "detail": [],
-            "locations": [],
-        }
-        if hasattr(plr_material, "capacity") and plr_material.capacity > 1:
-            for idx in range(plr_material.capacity):
-                bottle = plr_material[idx]
-                detail = {
-                    "x": (idx // (plr_material.num_items_x * plr_material.num_items_y)) + 1,
-                    "y": ((idx % (plr_material.num_items_x * plr_material.num_items_y)) // plr_material.num_items_x) + 1,
-                    "z": (idx % plr_material.num_items_x) + 1,
+    for resource in plr_resources:
+        if hasattr(resource, "capacity") and resource.capacity > 1:
+            material = {
+                "typeId": type_mapping.get(resource.model)[1],
+                "name": resource.name,
+                "unit": "个",
+                "quantity": 1,
+                "details": [],
+                "Parameters": "{}"
+            }
+            for bottle in resource.children:
+                if isinstance(resource, ItemizedCarrier):
+                    site = resource.get_child_identifier(bottle)
+                else:
+                    site = {"x": bottle.location.x - 1, "y": bottle.location.y - 1}
+                detail_item = {
+                    "typeId": type_mapping.get(bottle.model)[1],
+                    "name": bottle.name,
                     "code": bottle.code if hasattr(bottle, "code") else "",
                     "quantity": sum(qty for _, qty in bottle.tracker.liquids) if hasattr(bottle, "tracker") else 0,
+                    "x": site["x"] + 1,
+                    "y": site["y"] + 1,
+                    "molecular": 1,
+                    "Parameters": json.dumps({"molecular": 1})
                 }
-                material["detail"].append(detail)
-            material["quantity"] = 1.0
+                material["details"].append(detail_item)
         else:
-            bottle = plr_material[0] if plr_material.capacity > 0 else plr_material
-            material["quantity"] = sum(qty for _, qty in bottle.tracker.liquids) if hasattr(plr_material, "tracker") else 0
+            bottle = resource[0] if resource.capacity > 0 else resource
+            material = {
+                "typeId": "3a14196b-24f2-ca49-9081-0cab8021bf1a",
+                "name": resource.get("name", ""),
+                "unit": "",
+                "quantity": sum(qty for _, qty in bottle.tracker.liquids) if hasattr(bottle, "tracker") else 0,
+                "Parameters": "{}"
+            }
+
+        if resource.parent is not None and isinstance(resource.parent, ItemizedCarrier):
+            site_in_parent = resource.parent.get_child_identifier(resource)
+            material["locations"] = [
+                {
+                    "id": warehouse_mapping[resource.parent.name]["site_uuids"][site_in_parent["identifier"]],
+                    "whid": warehouse_mapping[resource.parent.name]["uuid"],
+                    "whName": resource.parent.name,
+                    "x": site_in_parent["z"] + 1,
+                    "y": site_in_parent["y"] + 1,
+                    "z": 1,
+                    "quantity": 0
+                }
+            ],
+
+        print(f"material_data: {material}")
         bioyond_materials.append(material)
     return bioyond_materials
 

unilabos/resources/itemized_carrier.py

@@ -163,6 +163,89 @@ class ItemizedCarrier(ResourcePLR):
     if hasattr(resource, "unassign"):
       resource.unassign()
 
+  def get_child_identifier(self, child: ResourcePLR):
+    """Get the identifier information for a given child resource.
+    
+    Args:
+        child: The Resource object to find the identifier for
+        
+    Returns:
+        dict: A dictionary containing:
+            - identifier: The string identifier (e.g. "A1", "B2")
+            - idx: The integer index in the sites list
+            - x: The x index (column index, 0-based)
+            - y: The y index (row index, 0-based)  
+            - z: The z index (layer index, 0-based)
+            
+    Raises:
+        ValueError: If the child resource is not found in this carrier
+    """
+    # Find the child resource in sites
+    for idx, resource in enumerate(self.sites):
+      if resource is child:
+        # Get the identifier from ordering keys
+        identifier = list(self._ordering.keys())[idx]
+        
+        # Parse identifier to get x, y, z indices
+        x_idx, y_idx, z_idx = self._parse_identifier_to_indices(identifier, idx)
+        
+        return {
+          "identifier": identifier,
+          "idx": idx,
+          "x": x_idx,
+          "y": y_idx,
+          "z": z_idx
+        }
+    
+    # If not found, raise an error
+    raise ValueError(f"Resource {child} is not assigned to this carrier")
+
+  def _parse_identifier_to_indices(self, identifier: str, idx: int) -> Tuple[int, int, int]:
+    """Parse identifier string to get x, y, z indices.
+    
+    Args:
+        identifier: String identifier like "A1", "B2", etc.
+        idx: Linear index as fallback for calculation
+        
+    Returns:
+        Tuple of (x_idx, y_idx, z_idx)
+    """
+    # If we have explicit dimensions, calculate from idx
+    if self.num_items_x > 0 and self.num_items_y > 0:
+      # Calculate 3D indices from linear index
+      z_idx = idx // (self.num_items_x * self.num_items_y) if self.num_items_z > 0 else 0
+      remaining = idx % (self.num_items_x * self.num_items_y)
+      y_idx = remaining // self.num_items_x
+      x_idx = remaining % self.num_items_x
+      return x_idx, y_idx, z_idx
+    
+    # Fallback: parse from Excel-style identifier
+    if isinstance(identifier, str) and len(identifier) >= 2:
+      # Extract row (letter) and column (number)
+      row_letters = ""
+      col_numbers = ""
+      
+      for char in identifier:
+        if char.isalpha():
+          row_letters += char
+        elif char.isdigit():
+          col_numbers += char
+      
+      if row_letters and col_numbers:
+        # Convert letter(s) to row index (A=0, B=1, etc.)
+        y_idx = 0
+        for char in row_letters:
+          y_idx = y_idx * 26 + (ord(char.upper()) - ord('A'))
+        
+        # Convert number to column index (1-based to 0-based)
+        x_idx = int(col_numbers) - 1
+        z_idx = 0  # Default layer
+        
+        return x_idx, y_idx, z_idx
+    
+    # If all else fails, assume linear arrangement
+    return idx, 0, 0
+
   def __getitem__(
     self,
     identifier: Union[str, int, Sequence[int], Sequence[str], slice, range],