How to use autoprotocol - 10 common examples

WellGroup
            WellGroup of all Wells in Container

        """
        if columnwise:
            num_cols = self.container_type.col_count
            num_rows = self.container_type.well_count // num_cols
            return WellGroup(
                [
                    self._wells[row * num_cols + col]
                    for col in range(num_cols)
                    for row in range(num_rows)
                ]
            )
        else:
            return WellGroup(self._wells)

Parameters
        ----------
        columnwise : bool, optional
            returns the WellGroup columnwise instead of rowwise (ordered by
            well index).

        Returns
        -------
        WellGroup
            WellGroup of all Wells in Container

        """
        if columnwise:
            num_cols = self.container_type.col_count
            num_rows = self.container_type.well_count // num_cols
            return WellGroup(
                [
                    self._wells[row * num_cols + col]
                    for col in range(num_cols)
                    for row in range(num_rows)
                ]
            )
        else:
            return WellGroup(self._wells)

def __init__(
        self, object, acceleration, duration, flow_direction=None, spin_direction=None
    ):
        spin_json = {
            "object": object,
            "acceleration": acceleration,
            "duration": duration,
            "flow_direction": flow_direction,
            "spin_direction": spin_direction,
        }

        super(Spin, self).__init__(op="spin", data=spin_json)


class Thermocycle(Instruction):

    """
    Append a Thermocycle instruction to the list of instructions, with
    groups being a list of dicts in the form of:

    .. code-block:: python

        "groups": [{
            "cycles": integer,
            "steps": [{
              "duration": duration,
              "temperature": temperature,
              "read": boolean // optional (default true)
            },{
              "duration": duration,
              "gradient": {

def robotize_static(well_ref, well_count, col_count):
        if isinstance(well_ref, list):
            return [
                ContainerType.robotize_static(well, well_count, col_count)
                for well in well_ref
            ]

        if not isinstance(well_ref, (str, int, Well)):
            raise TypeError(
                f"ContainerType.robotize(): Well reference "
                f"({well_ref}) given is not of type 'str', 'int', "
                f"or 'Well'."
            )

        if isinstance(well_ref, Well):
            well_ref = well_ref.index
        well_ref = str(well_ref)
        m = re.match(r"([a-z])([a-z]?)(\d+)$", well_ref, re.I)
        if m:
            row = ord(m.group(1).upper()) - ord("A")
            if m.group(2):
                row = 26 * (row + 1) + ord(m.group(2).upper()) - ord("A")
            col = int(m.group(3)) - 1
            row_count = well_count // col_count
            return ContainerType.well_from_coordinates_static(
                row, row_count, col, col_count
            )
        else:
            m = re.match(r"\d+$", well_ref)
            if m:
                well_num = int(m.group(0))

def robotize_static(well_ref, well_count, col_count):
        if isinstance(well_ref, list):
            return [
                ContainerType.robotize_static(well, well_count, col_count)
                for well in well_ref
            ]

        if not isinstance(well_ref, (str, int, Well)):
            raise TypeError(
                f"ContainerType.robotize(): Well reference "
                f"({well_ref}) given is not of type 'str', 'int', "
                f"or 'Well'."
            )

        if isinstance(well_ref, Well):
            well_ref = well_ref.index
        well_ref = str(well_ref)
        m = re.match(r"([a-z])([a-z]?)(\d+)$", well_ref, re.I)
        if m:
            row = ord(m.group(1).upper()) - ord("A")
            if m.group(2):
                row = 26 * (row + 1) + ord(m.group(2).upper()) - ord("A")
            col = int(m.group(3)) - 1
            row_count = well_count // col_count

capabilities=["liquid_handle", "incubate", "cover", "dispense", "liquid_handle"],
    shortname="res-mw12-hp",
    col_count=12,
    dead_volume_ul=Unit(1.8, "milliliter"),
    safe_min_volume_ul=Unit(5, "milliliter"),
    true_max_vol_ul=Unit(21.0, "milliliter"),
    vendor="Axygen",
    cat_no="res-mw12-hp",
)

#:
FLAT96CLEARTC = ContainerType(
    name="96-well flat-bottom TC treated plate",
    well_count=96,
    well_depth_mm=None,
    well_volume_ul=Unit(340.0, "microliter"),
    well_coating=None,
    sterile=False,
    is_tube=False,
    cover_types=["low_evaporation", "standard", "universal"],
    seal_types=None,
    capabilities=[
        "liquid_handle",
        "spin",
        "absorbance",
        "fluorescence",
        "luminescence",
        "incubate",
        "gel_separate",
        "gel_purify",
        "cover",
        "dispense",

"liquid_handle",
        "incubate",
        "gel_separate",
        "mag_dry",
        "mag_incubate",
        "mag_collect",
        "mag_release",
        "mag_mix",
        "cover",
        "dispense",
    ],
    shortname="96-deep-kf",
    is_tube=False,
    col_count=12,
    dead_volume_ul=Unit(50, "microliter"),
    safe_min_volume_ul=Unit(50, "microliter"),
    vendor="Fisher",
    cat_no="22-387-031",
)

#:
V96CC = ContainerType(
    name="96-well cell culture multiple well plate, V bottom",
    well_count=96,
    well_depth_mm=10.668,
    well_volume_ul=Unit(200.0, "microliter"),
    well_coating=None,
    sterile=True,
    is_tube=False,
    cover_types=["standard", "universal", "low_evaporation", "ultra-clear", "foil"],
    seal_types=None,
    capabilities=[

RESSW96HP = ContainerType(
    name="96-well singlewell highprofile reservoir",
    well_count=1,
    well_depth_mm=None,
    well_volume_ul=Unit(170.0, "milliliter"),
    well_coating=None,
    sterile=False,
    is_tube=False,
    cover_types=["universal"],
    seal_types=None,
    capabilities=["liquid_handle", "incubate", "cover", "dispense", "liquid_handle"],
    shortname="res-sw96-hp",
    col_count=1,
    dead_volume_ul=Unit(25, "milliliter"),
    safe_min_volume_ul=Unit(30, "milliliter"),
    true_max_vol_ul=Unit(280.0, "milliliter"),
    vendor="Axygen",
    cat_no="res-sw96-hp",
)

#:
RESMW8HP = ContainerType(
    name="8-row multiwell highprofile reservoir",
    well_count=8,
    well_depth_mm=None,
    well_volume_ul=Unit(24.0, "milliliter"),
    well_coating=None,
    sterile=False,
    is_tube=False,
    cover_types=["universal"],
    seal_types=None,
    capabilities=["liquid_handle", "incubate", "cover", "dispense", "liquid_handle"],

"fragment_vol": "3:microliter",
            "water_vol": "2:microliter",
            "ligation_time": "10:minute",
            "deactivation_time": "5:minute",
            "deactivation_temp": "65:celsius",
        }
    }
    '''

    params = make_dottable_dict(params)
    refs = make_dottable_dict(params.refs)

    MM_vol = Unit.fromstring(params.backbone_vol) + Unit.fromstring(params.enzyme_vol) + Unit.fromstring(params.buffer_vol) + Unit.fromstring(params.ligase_vol) + Unit.fromstring(params.fragment_vol) + Unit.fromstring(params.water_vol)
    # make master mix
    protocol.transfer(params.backbone, params.MM_loc, Unit.fromstring(params.backbone_vol) * Unit((params.reaction_number + 2),"microliter"))
    protocol.transfer(params.T4_ligase, params.MM_loc, Unit.fromstring(params.ligase_vol) * Unit((params.reaction_number + 2),"microliter"))
    protocol.transfer(params.enzyme, params.MM_loc, Unit.fromstring(params.enzyme_vol) * Unit((params.reaction_number + 2),"microliter"))
    protocol.transfer(params.buffer, params.MM_loc, Unit.fromstring(params.buffer_vol) * Unit((params.reaction_number + 2),"microliter"))

    # distribute master mix
    protocol.distribute(params.MM_loc,
        refs.destination_plate.wells_from(params.reaction_start,
        params.reaction_number), MM_vol )

    protocol.seal("destination_plate")

    protocol.thermocycle("destination_plate", [
        {"cycles": 1, "steps": [
            {"temperature": "37:celsius", "duration": "2:minute"},
        ]},
        {"cycles": 1, "steps":[
            {"temperature": "16:celsius", "duration": "5:minute"},

#:
RESSW384LP = ContainerType(
    name="384-well singlewell lowprofile reservoir",
    well_count=1,
    well_depth_mm=None,
    well_volume_ul=Unit(35, "milliliter"),
    well_coating=None,
    sterile=False,
    is_tube=False,
    cover_types=["universal"],
    seal_types=None,
    capabilities=["liquid_handle", "incubate", "cover", "dispense", "liquid_handle"],
    shortname="res-sw384-lp",
    col_count=1,
    dead_volume_ul=Unit(10, "milliliter"),
    safe_min_volume_ul=Unit(30, "milliliter"),
    true_max_vol_ul=Unit(92, "milliliter"),
    vendor="Axygen",
    cat_no="res-sw384-lp",
)

#:
ECHO384LDV = ContainerType(
    # Compatible with Labcyte Echo 520 and 55x only
    name="384-well Echo low dead volume plate",
    well_count=384,
    well_depth_mm=None,
    well_volume_ul=Unit(14.0, "microliter"),
    well_coating=None,
    sterile=None,
    is_tube=False,
    cover_types=["universal"],