Uni-Lab-OS/unilabos/devices/liquid_handling/prcxi/abstract_protocol.py

import asyncio
import collections
import contextlib
import json
import socket
import time
from typing import Any, List, Dict, Optional, TypedDict, Union, Sequence, Iterator, Literal
import pprint as pp
from pylabrobot.liquid_handling import (
    LiquidHandlerBackend,
    Pickup,
    SingleChannelAspiration,
    Drop,
    SingleChannelDispense,
    PickupTipRack,
    DropTipRack,
    MultiHeadAspirationPlate, ChatterBoxBackend, LiquidHandlerChatterboxBackend,
)
from pylabrobot.liquid_handling.standard import (
    MultiHeadAspirationContainer,
    MultiHeadDispenseContainer,
    MultiHeadDispensePlate,
    ResourcePickup,
    ResourceMove,
    ResourceDrop,
)
from pylabrobot.resources import Tip, Deck, Plate, Well, TipRack, Resource, Container, Coordinate, TipSpot, Trash
from traitlets import Int

from unilabos.devices.liquid_handling.liquid_handler_abstract import LiquidHandlerAbstract




class MaterialResource:
    """统一的液体/反应器资源，支持多孔（wells）场景：
    - wells: 列表，每个元素代表一个物料孔（unit）；
    - units: 与 wells 对齐的列表，每个元素是 {liquid_id: volume}；
    - 若传入 liquid_id + volume 或 composition，总量将**等分**到各 unit；
    """
    def __init__(
        self,
        resource_name: str,
        slot: int,
        well: List[int],
        composition: Optional[Dict[str, float]] = None,
        liquid_id: Optional[str] = None,
        volume: Union[float, int] = 0.0,
        is_supply: Optional[bool] = None,
    ):
        self.resource_name = resource_name
        self.slot = int(slot)
        self.well = list(well or [])
        self.is_supply = bool(is_supply) if is_supply is not None else (bool(composition) or (liquid_id is not None))

        # 规范化：至少有 1 个 unit
        n = max(1, len(self.well))
        self.units: List[Dict[str, float]] = [dict() for _ in range(n)]

        # 初始化内容：等分到各 unit
        if composition:
            for k, v in composition.items():
                share = float(v) / n
                for u in self.units:
                    if share > 0:
                        u[k] = u.get(k, 0.0) + share
        elif liquid_id is not None and float(volume) > 0:
            share = float(volume) / n
            for u in self.units:
                u[liquid_id] = u.get(liquid_id, 0.0) + share

    # 位置描述
    def location(self) -> Dict[str, Any]:
        return {"slot": self.slot, "well": self.well}

    def unit_count(self) -> int:
        return len(self.units)

    def unit_volume(self, idx: int) -> float:
        return float(sum(self.units[idx].values()))

    def total_volume(self) -> float:
        return float(sum(self.unit_volume(i) for i in range(self.unit_count())))

    def add_to_unit(self, idx: int, liquid_id: str, vol: Union[float, int]):
        v = float(vol)
        if v < 0:
            return
        u = self.units[idx]
        if liquid_id not in u:
           u[liquid_id] = 0.0
        if v > 0:
           u[liquid_id] += v

    def remove_from_unit(self, idx: int, total: Union[float, int]) -> Dict[str, float]:
        take = float(total)
        if take <= 0: return {}
        u = self.units[idx]
        avail = sum(u.values())
        if avail <= 0: return {}
        take = min(take, avail)
        ratio = take / avail
        removed: Dict[str, float] = {}
        for k, v in list(u.items()):
            dv = v * ratio
            nv = v - dv
            if nv < 1e-9: nv = 0.0
            u[k] = nv
            removed[k] = dv

        self.units[idx] = {k: v for k, v in u.items() if v > 0}
        return removed

    def transfer_unit_to(self, src_idx: int, other: "MaterialResource", dst_idx: int, total: Union[float, int]):
        moved = self.remove_from_unit(src_idx, total)
        for k, v in moved.items():
            other.add_to_unit(dst_idx, k, v)

    def get_resource(self) -> Dict[str, Any]:
        return {
            "resource_name": self.resource_name,
            "slot": self.slot,
            "well": self.well,
            "units": [dict(u) for u in self.units],
            "total_volume": self.total_volume(),
            "is_supply": self.is_supply,
        }

def transfer_liquid(
    sources: MaterialResource,
    targets: MaterialResource,
    unit_volume: Optional[Union[float, int]] = None,
    tip: Optional[str] = None, #这里应该是指定种类的
) -> Dict[str, Any]:
    try:
        vol_each = float(unit_volume)
    except (TypeError, ValueError):
        return {"action": "transfer_liquid", "error": "invalid unit_volume"}
    if vol_each <= 0:
        return {"action": "transfer_liquid", "error": "non-positive volume"}

    ns, nt = sources.unit_count(), targets.unit_count()
    # one-to-many: 从单个 source unit(0) 扇出到目标各 unit
    if ns == 1 and nt >= 1:
        for j in range(nt):
            sources.transfer_unit_to(0, targets, j, vol_each)
    # many-to-many: 数量相同，逐一对应
    elif ns == nt and ns > 0:
        for i in range(ns):
            sources.transfer_unit_to(i, targets, i, vol_each)
    else:
        raise ValueError(f"Unsupported mapping: sources={ns} units, targets={nt} units. Only 1->N or N->N are allowed.")

    return {
        "action": "transfer_liquid",
        "sources": sources.get_resource(),
        "targets": targets.get_resource(),
        "unit_volume": unit_volume,
        "tip": tip, 
    }

def plan_transfer(pm: "ProtocolManager", **kwargs) -> Dict[str, Any]:
    """Shorthand to add a non-committing transfer to a ProtocolManager.
    Accepts the same kwargs as ProtocolManager.add_transfer.
    """
    return pm.add_transfer(**kwargs)

class ProtocolManager:
    """Plan/track transfers and back‑solve minimum initial volumes.

    Use add_transfer(...) to register steps (no mutation).
    Use compute_min_initials(...) to infer the minimal starting volume of each liquid
    per resource required to execute the plan in order.
    """

    # ---------- lifecycle ----------
    def __init__(self):
        # queued logical steps (keep live refs to MaterialResource)
        self.steps: List[Dict[str, Any]] = []

        # simple tip catalog; choose the smallest that meets min_aspirate and capacity*safety
        self.tip_catalog = [
            {"name": "TIP_10uL",   "capacity": 10.0,   "min_aspirate": 0.5},
            {"name": "TIP_20uL",   "capacity": 20.0,   "min_aspirate": 1.0},
            {"name": "TIP_50uL",   "capacity": 50.0,   "min_aspirate": 2.0},
            {"name": "TIP_200uL",  "capacity": 200.0,  "min_aspirate": 5.0},
            {"name": "TIP_300uL",  "capacity": 300.0,  "min_aspirate": 10.0},
            {"name": "TIP_1000uL", "capacity": 1000.0, "min_aspirate": 20.0},
        ]

        # stable labels for unknown liquids per resource (A, B, C, ..., AA, AB, ...)
        self._unknown_labels: Dict[MaterialResource, str] = {}
        self._unknown_label_counter: int = 0

    # ---------- public API ----------
    def recommend_tip(self, unit_volume: float, safety: float = 1.10) -> str:
        v = float(unit_volume)
        # prefer: meets min_aspirate and capacity with safety margin; else fallback to capacity-only; else max capacity
        eligible = [t for t in self.tip_catalog if t["min_aspirate"] <= v and t["capacity"] >= v * safety]
        if not eligible:
            eligible = [t for t in self.tip_catalog if t["capacity"] >= v]
        return min(eligible or self.tip_catalog, key=lambda t: t["capacity"]) ["name"]

    def get_tip_capacity(self, tip_name: str) -> Optional[float]:
        for t in self.tip_catalog:
            if t["name"] == tip_name:
                return t["capacity"]
        return None

    def add_transfer(
        self,
        sources: MaterialResource,
        targets: MaterialResource,
        unit_volume: Union[float, int],
        tip: Optional[str] = None,
    ) -> Dict[str, Any]:
        step = {
            "action": "transfer_liquid",
            "sources": sources,
            "targets": targets,
            "unit_volume": float(unit_volume),
            "tip": tip or self.recommend_tip(unit_volume),
        }
        self.steps.append(step)
        # return a serializable shadow (no mutation)
        return {
            "action": "transfer_liquid",
            "sources": sources.get_resource(),
            "targets": targets.get_resource(),
            "unit_volume": step["unit_volume"],
            "tip": step["tip"],
        }

    @staticmethod
    def _liquid_keys_of(resource: MaterialResource) -> List[str]:
        keys: set[str] = set()
        for u in resource.units:
            keys.update(u.keys())
        return sorted(keys)

    @staticmethod
    def _fanout_multiplier(ns: int, nt: int) -> Optional[int]:
        """Return the number of liquid movements for a mapping shape.
        1->N: N moves; N->N: N moves; otherwise unsupported (None).
        """
        if ns == 1 and nt >= 1:
            return nt
        if ns == nt and ns > 0:
            return ns
        return None

    # ---------- planning core ----------
    def compute_min_initials(
        self,
        use_initial: bool = False,
        external_only: bool = True,
    ) -> Dict[str, Dict[str, float]]:
        """Simulate the plan (non‑mutating) and return minimal starting volumes per resource/liquid."""
        ledger: Dict[MaterialResource, Dict[str, float]] = {}
        min_seen: Dict[MaterialResource, Dict[str, float]] = {}

        def _ensure(res: MaterialResource) -> None:
            if res in ledger:
                return
            declared = self._liquid_keys_of(res)
            if use_initial:
                # sum actual held amounts across units
                totals = {k: 0.0 for k in declared}
                for u in res.units:
                    for k, v in u.items():
                        totals[k] = totals.get(k, 0.0) + float(v)
                ledger[res] = totals
            else:
                ledger[res] = {k: 0.0 for k in declared}
            min_seen[res] = {k: ledger[res].get(k, 0.0) for k in ledger[res]}

        def _proportions(src: MaterialResource, src_bal: Dict[str, float]) -> tuple[List[str], Dict[str, float]]:
            keys = list(src_bal.keys())
            total_pos = sum(x for x in src_bal.values() if x > 0)

            # if ledger has no keys yet, seed from declared types on the resource
            if not keys:
                keys = self._liquid_keys_of(src)
                for k in keys:
                    src_bal.setdefault(k, 0.0)
                    min_seen[src].setdefault(k, 0.0)

            if total_pos > 0:
                # proportional to current positive balances
                props = {k: (src_bal.get(k, 0.0) / total_pos) for k in keys}
                return keys, props

            # no material currently: evenly from known keys, or assign an unknown label
            if keys:
                eq = 1.0 / len(keys)
                return keys, {k: eq for k in keys}

            unk = self._label_for_unknown(src)
            keys = [unk]
            src_bal.setdefault(unk, 0.0)
            min_seen[src].setdefault(unk, 0.0)
            return keys, {unk: 1.0}

        for step in self.steps:
            if step.get("action") != "transfer_liquid":
                continue

            src: MaterialResource = step["sources"]
            dst: MaterialResource = step["targets"]
            vol = float(step["unit_volume"])
            if vol <= 0:
                continue

            _ensure(src)
            _ensure(dst)

            mult = self._fanout_multiplier(src.unit_count(), dst.unit_count())
            if not mult:
                continue  # unsupported mapping shape for this planner

            eff_vol = vol * mult
            src_bal = ledger[src]
            keys, props = _proportions(src, src_bal)

            # subtract from src; track minima; accumulate to dst
            moved: Dict[str, float] = {}
            for k in keys:
                dv = eff_vol * props[k]
                src_bal[k] = src_bal.get(k, 0.0) - dv
                moved[k] = dv
                prev_min = min_seen[src].get(k, 0.0)
                if src_bal[k] < prev_min:
                    min_seen[src][k] = src_bal[k]

            dst_bal = ledger[dst]
            for k, dv in moved.items():
                dst_bal[k] = dst_bal.get(k, 0.0) + dv
                min_seen[dst].setdefault(k, dst_bal[k])

        # convert minima (negative) to required initials
        result: Dict[str, Dict[str, float]] = {}
        for res, mins in min_seen.items():
            if external_only and not getattr(res, "is_supply", False):
                continue
            need = {liq: max(0.0, -mn) for liq, mn in mins.items() if mn < 0.0}
            if need:
                result[res.resource_name] = need
        return result

    def compute_tip_consumption(self) -> Dict[str, Any]:
        """Compute how many tips are consumed at each transfer step, and aggregate by tip type.
        Rule: each liquid movement (source unit -> target unit) consumes one tip.
        For supported shapes: 1->N uses N tips; N->N uses N tips.
        """
        per_step: List[Dict[str, Any]] = []
        totals_by_tip: Dict[str, int] = {}

        for i, s in enumerate(self.steps):
            if s.get("action") != "transfer_liquid":
                continue
            ns = s["sources"].unit_count()
            nt = s["targets"].unit_count()
            moves = self._fanout_multiplier(ns, nt) or 0
            tip_name = s.get("tip") or self.recommend_tip(s["unit_volume"])  # per-step tip may vary
            per_step.append({
                "idx": i,
                "tip": tip_name,
                "tips_used": moves,
                "moves": moves,
            })
            totals_by_tip[tip_name] = totals_by_tip.get(tip_name, 0) + int(moves)

        return {"per_step": per_step, "totals_by_tip": totals_by_tip}

    def compute_min_initials_with_tips(
        self,
        use_initial: bool = False,
        external_only: bool = True,
    ) -> Dict[str, Any]:
        needs = self.compute_min_initials(use_initial=use_initial, external_only=external_only)
        step_tips: List[Dict[str, Any]] = []
        totals_by_tip: Dict[str, int] = {}

        for i, s in enumerate(self.steps):
            if s.get("action") != "transfer_liquid":
                continue
            ns = s["sources"].unit_count()
            nt = s["targets"].unit_count()
            moves = self._fanout_multiplier(ns, nt) or 0
            tip_name = s.get("tip") or self.recommend_tip(s["unit_volume"])  # step-specific tip
            totals_by_tip[self.get_tip_capacity(tip_name)] = totals_by_tip.get(tip_name, 0) + int(moves)

            step_tips.append({
                "idx": i,
                "tip": tip_name,
                "tip_capacity": self.get_tip_capacity(tip_name),
                "unit_volume": s["unit_volume"],
                "tips_used": moves,
            })
        return {"liquid_setup": needs, "step_tips": step_tips, "totals_by_tip": totals_by_tip}

    # ---------- unknown labels ----------
    def _index_to_letters(self, idx: int) -> str:
        """0->A, 1->B, ... 25->Z, 26->AA, 27->AB ... (Excel-like)"""
        s: List[str] = []
        idx = int(idx)
        while True:
            idx, r = divmod(idx, 26)
            s.append(chr(ord('A') + r))
            if idx == 0:
                break
            idx -= 1  # Excel-style carry
        return "".join(reversed(s))

    def _label_for_unknown(self, res: MaterialResource) -> str:
        """Assign a stable unknown-liquid label (A/B/C/...) per resource."""
        if res not in self._unknown_labels:
            lab = self._index_to_letters(self._unknown_label_counter)
            self._unknown_label_counter += 1
            self._unknown_labels[res] = lab
        return self._unknown_labels[res]


# 在这一步传输目前有的物料
class LabResource:
    def __init__(self):
        self.tipracks = []
        self.plates = []
        self.trash = []

    def add_tipracks(self, tiprack: List[TipRack]):
        self.tipracks.extend(tiprack)
    def add_plates(self, plate: List[Plate]):
        self.plates.extend(plate)
    def add_trash(self, trash: List[Plate]):
        self.trash.extend(trash)
    def get_resources_info(self) -> Dict[str, Any]:
        tipracks = [{"name": tr.name, "max_volume": tr.children[0].tracker._tip.maximal_volume, "count": len(tr.children)} for tr in self.tipracks]
        plates = [{"name": pl.name, "max_volume": pl.children[0].max_volume, "count": len(pl.children)} for pl in self.plates]
        trash = [{"name": t.name, "max_volume": t.children[0].max_volume, "count": len(t.children)} for t in self.trash]
        return {
            "tipracks": tipracks,
            "plates": plates,
            "trash": trash
        }

from typing import Dict, Any

import time
class DefaultLayout:

    def __init__(self, product_name: str = "PRCXI9300"):
        self.labresource = {}
        if product_name not in ["PRCXI9300", "PRCXI9320"]:
            raise ValueError(f"Unsupported product_name: {product_name}. Only 'PRCXI9300' and 'PRCXI9320' are supported.")

        if product_name == "PRCXI9300":
            self.rows = 2
            self.columns = 3
            self.layout = [1, 2, 3, 4, 5, 6]
            self.trash_slot = 3
            self.waste_liquid_slot = 6

        elif product_name == "PRCXI9320":
            self.rows = 3
            self.columns = 4
            self.layout = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
            self.trash_slot = 16
            self.waste_liquid_slot = 12
            self.default_layout =  {"MatrixId":f"{time.time()}","MatrixName":f"{time.time()}","MatrixCount":16,"WorkTablets":
            [{"Number": 1, "Code": "T1", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 2, "Code": "T2", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 3, "Code": "T3", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 4, "Code": "T4", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 5, "Code": "T5", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 6, "Code": "T6", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 7, "Code": "T7", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 8, "Code": "T8", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 9, "Code": "T9", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 10, "Code": "T10", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 11, "Code": "T11", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 12, "Code": "T12", "Material": {"uuid": "730067cf07ae43849ddf4034299030e9", "materialEnum": 0}},  # 这个设置成废液槽，用储液槽表示
  {"Number": 13, "Code": "T13", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 14, "Code": "T14", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 15, "Code": "T15", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
  {"Number": 16, "Code": "T16", "Material": {"uuid": "730067cf07ae43849ddf4034299030e9", "materialEnum": 0}} # 这个设置成垃圾桶，用储液槽表示
]
}

    def get_layout(self) -> Dict[str, Any]:
        return {
            "rows": self.rows,
            "columns": self.columns,
            "layout": self.layout,
            "trash_slot": self.trash_slot,
            "waste_liquid_slot": self.waste_liquid_slot
        }

    def get_trash_slot(self) -> int:
        return self.trash_slot
    
    def get_waste_liquid_slot(self) -> int:
        return self.waste_liquid_slot

    def add_lab_resource(self, material_info):
        self.labresource = material_info

    def recommend_layout(self, needs: Dict[str, int]) -> Dict[str, Any]:
        """根据 needs 推荐布局"""
        for k, v in needs.items():
            if k not in self.labresource:
                raise ValueError(f"Material {k} not found in lab resources.")
        
        # 预留位置12和16不动
        reserved_positions = {12, 16}
        available_positions = [i for i in range(1, 17) if i not in reserved_positions]
        
        # 计算总需求
        total_needed = sum(needs.values())
        if total_needed > len(available_positions):
            raise ValueError(f"需要 {total_needed} 个位置，但只有 {len(available_positions)} 个可用位置（排除位置12和16）")
        
        # 依次分配位置
        current_pos = 0
        for material_name, count in needs.items():
            material_uuid = self.labresource[material_name]['uuid']
            material_enum = self.labresource[material_name]['materialEnum']
            
            for _ in range(count):
                if current_pos >= len(available_positions):
                    raise ValueError("位置不足，无法分配更多物料")
                
                position = available_positions[current_pos]
                # 找到对应的tablet并更新
                for tablet in self.default_layout['WorkTablets']:
                    if tablet['Number'] == position:
                        tablet['Material']['uuid'] = material_uuid
                        tablet['Material']['materialEnum'] = material_enum
                        break
                
                current_pos += 1
        
        return self.default_layout


if __name__ == "__main__":
    with open("prcxi_material.json", "r") as f:
        material_info = json.load(f)
    
    layout = DefaultLayout("PRCXI9320")
    layout.add_lab_resource(material_info)
    plan = layout.recommend_layout({
        "10μL加长 Tip头": 2,
        "300μL Tip头": 2, 
        "96深孔板": 2,
    })
    



# if __name__ == "__main__":
#     # ---- 资源：SUP 供液（X），中间板 R1（4 孔空），目标板 R2（4 孔空）----
# #     sup = MaterialResource("SUP", slot=5, well=[1], liquid_id="X", volume=10000)      
# #     r1  = MaterialResource("R1",  slot=6, well=[1,2,3,4,5,6,7,8])
# #     r2  = MaterialResource("R2",  slot=7, well=[1,2,3,4,5,6,7,8])

# #     pm = ProtocolManager()
# #     # 步骤1：SUP -> R1，1->N 扇出，每孔 50 uL（总 200 uL）
# #     pm.add_transfer(sup, r1, unit_volume=10.0)
# #     # 步骤2：R1 -> R2，N->N 对应，每对 25 uL（总 100 uL；来自 R1 中已存在的混合物 X）
# #     pm.add_transfer(r1, r2, unit_volume=120.0)

# #     out = pm.compute_min_initials_with_tips()
# #     # layout_planer = DefaultLayout('PRCXI9320')
# #     # print(layout_planer.get_layout())
# #     # print("回推最小需求：", out["liquid_setup"])     # {'SUP': {'X': 200.0}}
# #     # print("步骤枪头建议：", out["step_tips"]) # [{'idx':0,'tip':'TIP_200uL','unit_volume':50.0}, {'idx':1,'tip':'TIP_50uL','unit_volume':25.0}]

# # #     # 实际执行（可选）
# # #     transfer_liquid(sup, r1, unit_volume=50.0)
# # #     transfer_liquid(r1, r2, unit_volume=25.0)
# # #     print("执行后 SUP：", sup.get_resource())  # 总体积 -200
# # #     print("执行后 R1：",  r1.get_resource())   # 每孔 25 uL（50 进 -25 出）
# # #     print("执行后 R2：",  r2.get_resource())   # 每孔 25 uL


# #     from pylabrobot.resources.opentrons.tube_racks import *
# #     from pylabrobot.resources.opentrons.plates import *
# #     from pylabrobot.resources.opentrons.tip_racks import *
# #     from pylabrobot.resources.opentrons.reservoirs import *

# #     plate = [locals()['nest_96_wellplate_2ml_deep'](name="thermoscientificnunc_96_wellplate_2000ul"), locals()['corning_96_wellplate_360ul_flat'](name="corning_96_wellplate_360ul_flat")]
# #     tiprack = [locals()['opentrons_96_tiprack_300ul'](name="opentrons_96_tiprack_300ul"), locals()['opentrons_96_tiprack_1000ul'](name="opentrons_96_tiprack_1000ul")]
# #     trash = [locals()['axygen_1_reservoir_90ml'](name="axygen_1_reservoir_90ml")]

# #     from pprint import pprint

# #     lab_resource = LabResource()
# #     lab_resource.add_tipracks(tiprack)
# #     lab_resource.add_plates(plate)
# #     lab_resource.add_trash(trash)

# #     layout_planer = DefaultLayout('PRCXI9300')
# #     layout_planer.add_lab_resource(lab_resource)
# #     layout_planer.recommend_layout(out)

#     with open("prcxi_material.json", "r") as f:
#         material_info = json.load(f)
#     # print("当前实验物料信息：", material_info)

#     layout = DefaultLayout("PRCXI9320")
#     layout.add_lab_resource(material_info)
#     print(layout.default_layout['WorkTablets'])
#     # plan = layout.recommend_layout({
#     #     "10μL加长 Tip头": 2,
#     #     "300μL Tip头": 2,
#     #     "96深孔板": 2,
#     # })