RobotEvo “modes” for execution of basic instructions

Define how we want to “interact” with the physical robot, or what kind of output we want from

this script generator.

• Mode
• ToString: an string representation of the instructions.
• Multiple: A collection (list) of all the “modes” to be generated in a single run
• ToFile:
• Comments:
• AdvancedWorkList:
• ScriptBody:
• Script:
• iRobot: update the state of the “internal” robot to track changes produced by the execution of the instructions.

after each instruction. - AdvancedWorkList:

class evo_mode.AdvancedWorkList(filename=None, immediate=None)

Bases: evo_mode.ToFile

exec(instr)

class evo_mode.COM_automation

Bases: evo_mode.Mode

class evo_mode.Comments(identation_char=None, identattion_length=None, current_identation=None, filename=None)

Bases: evo_mode.ToFile

Create a list with all (and only with) the comments and the Groups. Useful to be shown immediately after generation, but also to the final user just before the actual physical run.

__init__(identation_char=None, identattion_length=None, current_identation=None, filename=None)

Initialize self. See help(type(self)) for accurate signature.

exec(instr)

class evo_mode.Mode

Bases: object

(Base class) Define how we want to “interact” with the physical robot, or what kind of output we want from this script generator. Some options are: A worklist; a full Evoware script; only comments, etc. One important option is to create many of this outputs from a single run.

done()

encoding = 'Latin-1'

exec(instr)

newline = '\r\n'

class evo_mode.Multiple(modes=None)

Bases: evo_mode.Mode

A collection (list) of all the “modes” to be generated in a single run

__init__(modes=None)

Initialize self. See help(type(self)) for accurate signature.

add_mode(mode)

done()

exec(instr)

class evo_mode.Script(filename=None, template=None, robot_protocol=None, robot=None)

Bases: evo_mode.ScriptBody

Create a full and executable script for the evoware soft. Take an existing script or script-template as a base.

__init__(filename=None, template=None, robot_protocol=None, robot=None)

Initialize self. See help(type(self)) for accurate signature.

add_template()

exec(instr)

set_template(template, robot_protocol)

class evo_mode.ScriptBody(filename=None, immediate=None)

Bases: evo_mode.ToFile

class evo_mode.StdOut

Bases: evo_mode.ToString

Specially useful during debugging.

exec(instr)

class evo_mode.ToFile(filename=None, immediate=None)

Bases: evo_mode.ToString

(Base class) For modes with uses a file for output

__init__(filename=None, immediate=None)

Initialize self. See help(type(self)) for accurate signature.

done()

exec(instr)

open()

set_file(filename=None)

class evo_mode.ToString

Bases: evo_mode.Mode

(Base class) Create an string representation of the instructions.

exec(instr)

class evo_mode.iRobot(index, n_tips, arms=None, tips_type=None)

Bases: evo_mode.Mode

Used to validate instructions based on an the state of an internal model af the physical robot. It will check the kind and number of tips, and the volume already aspired in each tips, and the existence and current volume in wells in labware, etc. One basic use of this, is to guarantee that the robot will be actualized once and only once even when multiple modes are used.

__init__(index, n_tips, arms=None, tips_type=None)

Initialize self. See help(type(self)) for accurate signature.

exec(instr)

set_as_current()

Robots and arms

• Arm
• Robot: track state to make organizations previous to the actual instruction call, and change that state

after each instruction.

---

class robot.Arm(n_tips, index, workingTips=None, tips_type=None)

Bases: object

Aspirate = 1

Detect = 0

DiTi = 0

Dispense = -1

Fixed = 1

__init__(n_tips, index, workingTips=None, tips_type=None)

Parameters:

• n_tips – the number of possible tips
• index – int. for example: index=Pipette.LiHa1
• workingTips – some tips maybe broken or permanently unused.
• tips_type – DITI or fixed (not implemented)

eject_tips_executed(tip_mask=None) -> (<class 'int'>, <class 'list'>)

Drop tips only if needed. Return the mask and the tips really used. :param tip_mask: int :return: the mask that can be used with, is “True” if tips actually ned to be drooped :rtype : int

eject_tips_test(tip_mask=None) -> (<class 'int'>[, <class 'int'>])

Return the mask and the tips index to be really used. :param tip_mask: int :return: the mask that can be used with, is “True” if tips actually ned to be drooped :rtype : int

getMoreTips_test(rack_type, tip_mask=None) → int

Mount only the tips with are not already mounted. Mount only one kind of tip at a time, but not necessary the same of the already mounted.

:rtype : int :param tip_mask: int :return: the mask that can be used

getTips_test(tip_mask=None) → int

Simple test that the asked positions are free for mounting new tips. :rtype : int :param tip_mask: :return: the mask that can be used :raise “Tip already in position ” + str(i):

mount_more_tips_executed(rack_type, tip_mask=None, tips=None) -> (<class 'int'>, <class 'list'>)

Mount only the tips with are not already mounted. Mount only one kind of tip at a time, but not necessary the same of the already mounted.

:rtype : int :param tip_mask: int :return: the mask that can be used

mount_tips_executed(rack_type=None, tip_mask=None, tips=None) -> (<class 'int'>, <class 'list'>)

Mount only one kind of new tip at a time or just the tips given in the list :param rack_type: :param tips: :rtype : int :param tip_mask: :return: the mask that can be used :raise “Tip already in position ” + str(i):

pipette_executed(action, volume, tip_mask=None) -> (<class 'list'>, <class 'int'>)

Check and actualize the robot Arm state to aspirate [vol]s with a tip mask. Using the tip mask will check that you are not trying to use an unmounted tip. volume values for unsettled tip mask are ignored.

:rtype : (list, int) :param action: +1:aspirate, -1:dispense :param volume: one vol for all tips, or a list of vol :param tip_mask: -1:all tips :return: a lis of vol to pipette, and the mask

class robot.Robot(index=None, arms=None, n_tips=None, workingTips=None, tips_type=0, templateFile=None)

Bases: object

Maintain an intern state. Can have more than one arm in a dictionary that map an index with the actual arm. One of the arms can be set as “current” and is returned by cur_arm() Most of the changes in state are made by the implementation of the low level instructions, while the protocols can “observe” the state to make all kind of optimizations and organizations previous to the actual instruction call

__init__(index=None, arms=None, n_tips=None, workingTips=None, tips_type=0, templateFile=None)

A Robot may have 1 or more Arms, indexes by key index in a dictionary of Arms. :param arms: :param n_tips: :param workingTips: :param tips_type:

cur_arm(arm=None)

current = None

drop_tips_executed(TIP_MASK=None, waste=None)

drop_tips_test(TIP_MASK=None)

getTips_test(rack_type, tip_mask=None) → int

get_tips_executed(rack_series, tip_mask=None) -> (<class 'int'>, <class 'list'>)

To be call from instructions.actualize_robot_state(self): actualize iRobot state (tip mounted and DiTi racks) Return the mask with will be really used taking into account the iRobot state, specially, the “reusetips” status and the number of tips already mounted. If it return mask = 0 no evo-instruction for the real robot will be generated in some cases.

Parameters:

• tip_mask –
• rack_series – the series of this king of tips.

Returns:

(int, [labware.Tip])

move_labware_executed(labware, destination)

pick_up_tips_executed(TIP_MASK, labware_selection: EvoScriPy.labware.DITIrack) → int

The low level instruction have to be generated already with almost all the information needed. Here we don’t check any more from where we really need to pick the tips and assume they are all in the same rack. Be careful by manual creation of low level instructions: they are safe if they are generated by protocol instructions (drop_tips(), and preserve and usePreserved were previously set). :param labware_selection: :param TIP_MASK:

pipette_executed(action, volume, labware_selection, tip_mask=None) -> (<class 'list'>, <class 'int'>)

preserve_tips(preserve=True) → bool

reuse_tips(reuse=True) → bool

set_allow_air(allow_air=0.0) → float

set_as_current()

set_drop_tips(drop=True) → bool

Drops the tips at THE END of the whole action? like after distribute of the reagent into various target? :param drop: :return: the previous value

set_tips_back_executed(TIP_MASK, labware_selection)

The low level instruction have to be generated already with almost all the information needed. Here we don’t check any more where we really need to put the tips. Be careful by manual creation of low level instructions: they are safe if they are generated by protocol instructions (drop_tips(), and preserve and usePreserved were previously set). :param TIP_MASK: :param labware:

set_worktable(templateFile, robot_protocol)

use_preserved_tips(usePreserved=True) → bool

use_tips_executed(tipMask, labware_selection)

where_are_preserved_tips(selected_reagents: EvoScriPy.labware.Labware, TIP_MASK, type) → list

Parameters:

• selected_reagents –
• TIP_MASK –

Returns:

Return a list of racks with the tips-wells already selected.

where_preserve_tips(TIP_MASK) → list

There are used tips in the arm, and we want to know were to put it back. Return a list of racks with the tips-wells already selected. (to set back the tips currently in the arm)

Parameters:TIP_MASK – Returns:list of racks with the tips-wells already selected.

GUI

Implement a GUI that automatically detect available protocols.

class GUI.App(master=None)

Bases: tkinter.Frame

GUI orgaization:

app = App(master = tkinter.Tk()), - tkinter.Frame.__init__(self, master). : new window

• Logo,
• DropBox (OptionMenu) protocol_selection -> protocol_selected(self, value): for the selected create:

GUI_protocol(protocol), - tkinter.Frame.__init__(self, tkinter.Tk()) : new window

• protocol.GUI = self: this is the GUI protocols refer.
• OptionMenu Versions ->

• Buttons: run: “Initialize protocol” -> command=self.run_selected,

  quit:”Synthetize script” -> command=self.quit

• Listbox Comments

• self.GUI_init = GUI4parameters[protocol.name](protocol):

  populate and update GUI_parameters to check protocol initialization parameters

• self.GUI_parameters = tkinter.Frame(self): (between Versions and buttons), for file IO, #samples, first tip, ect.
• self.GUI_CheckList = tkinter.Frame(self): Headers, reagent_frames, ReplicaFrame . self.master.mainloop()
• self.mainloop()

GUI_init (and derived GUI_init_parameters, GUI_init_pipeline):

populate and update GUI_parameters to check protocol initialization parameters

GUI_init_parameters: - WorkTable and Output file, First tip GUI_init_RNAext_parameters: add num_of_samples

GUI_init_pipeline: - self.ProtcolFrames = list of ProtocolFrame(prot) - ProtocolFrame(tkinter.Frame) - tkinter.Frame.__init__(self, prot.pipeline.GUI.GUI_CheckList) - Label protocol.name: entry run_name - Button run: run.mainloop() -> run_prot: App.GUI_protocol(self.protocol) in a new window

class DemoTwoMixes(GUI=None, num_of_samples: int = None, worktable_template_filename=None, output_filename=None, first_tip=None, run_name: str = '')

Bases: protocols.evo200_f.evo200_f.Evo200_FLI

Prepare two 1:10 serial dilutions of two different mixes each in ‘n’ 100 uL final volume wells (each in a microplate, the second one to be moved to the working position).

‘mix1’ and ‘mix2’ are diluted separately in n wells 1:10 (mix1_10 and mix2_10 respectively) using a provided “buffer”. From those wells a portion is transferred to the final 1:100 dilutions (mix1_100 and mix2_100 respectively) to fv=100 uL final volume

One way to achieve this: - Calculate how much to transfer from each mix1_10 to mix1_100. v_mix1_10_100= fv/10 and from diluent. - Calculate how much to distribute from mix1 to each mix1_10 and from diluent. - Define a reagent mix1 and mix2`in an Eppendorf rack (labware) for the calculated volume per “sample” (mix1_10 or 2). - Define a reagent `buffer in a 100 mL cubette BufferCub for the total volume per “sample”. - Generate check list - Transfer plate 2 from the original location plate2 to the final location plate2-moved - Define derived reagents for diluted mixes - Distribute mix1 and buffer into mix1_10 and similar with mix2 - Transfer from mix1_10 to mix1_100 and distribute buffer here. The same with mix2_10

V_def()

__init__(GUI=None, num_of_samples: int = None, worktable_template_filename=None, output_filename=None, first_tip=None, run_name: str = '')

Parameters:

• n_tips –
• num_of_samples –
• GUI –
• worktable_template_filename –
• output_filename –
• first_tip –
• run_name –
• tips_type –

def_versions()

Override this function to define a ‘dictionary’ of the versions for your Executable, with a name as key and a method as value, which will initialize the Executable to effectively execute that version. You don’t need to call this function. It will be used internally during initialization of your derived class.

max_s = 48.0

min_s = 1

name = 'Prefill one plate with Buffer.'

run()

Here we have accesses to the “internal robot” self.iRobot, with in turn have access to the used Work Table, self.iRobot.worktable from where we can obtain labwares with get_labware()

class GUI_init_RNAext_parameters(protocol)

Bases: GUI.GUI_init_parameters

__init__(protocol)

Initialize self. See help(type(self)) for accurate signature.

read_num_of_samples(*args)

update_parameters()

class GUI_init_parameters(protocol)

Bases: object

__init__(protocol)

Initialize self. See help(type(self)) for accurate signature.

change_O_FN(new_O_FN)

selet_O_FN()

selet_WT_FN()

set_O_FN(*args)

set_WT_FN(*args)

set_first_tip(*args)

update_parameters()

class GUI_init_pipeline(pipeline)

Bases: object

Show the parameters of the pipeline for review: a list of the protocols to run with run names

class ProtocolFrame(prot)

Bases: tkinter.Frame

Run()

__init__(prot)

Construct a frame widget with the parent MASTER.

Valid resource names: background, bd, bg, borderwidth, class, colormap, container, cursor, height, highlightbackground, highlightcolor, highlightthickness, relief, takefocus, visual, width.

run_prot()

__init__(pipeline)

Initialize self. See help(type(self)) for accurate signature.

update_parameters()

class GUI_protocol(protocol)

Bases: tkinter.Frame

Implements a GUI for the selected protocol. Each protocol receive a reference to it in .GUI Opens in a new window. Has:

• GUI_init, to review creation parameters,
• GUI_parameters for check_list prior to actually running the protocol,
• Comments that shows the run.

Alternatively, for Pipelines shows the list of protocols for sequential running

CheckPipeline(pipeline)

class ReagentFrame(check_list, reagent)

Bases: tkinter.Frame

__init__(check_list, reagent)

Construct a frame widget with the parent MASTER.

Valid resource names: background, bd, bg, borderwidth, class, colormap, container, cursor, height, highlightbackground, highlightcolor, highlightthickness, relief, takefocus, visual, width.

setVol(*args)

class ReplicaFrame(master, reply, num)

Bases: tkinter.Frame

__init__(master, reply, num)

Construct a frame widget with the parent MASTER.

Valid resource names: background, bd, bg, borderwidth, class, colormap, container, cursor, height, highlightbackground, highlightcolor, highlightthickness, relief, takefocus, visual, width.

__init__(protocol)

Construct a frame widget with the parent MASTER.

Valid resource names: background, bd, bg, borderwidth, class, colormap, container, cursor, height, highlightbackground, highlightcolor, highlightthickness, relief, takefocus, visual, width.

check_list()

run_selected()

setVariant(variant)

setVariantsMenu(value)

update_parameters()

class HelloWorld(GUI=None, output_filename=None, worktable_template_filename=None)

Bases: EvoScriPy.protocol_steps.Protocol

This is a very general protocol. Normally you will inherit from a Protocol class adapted to your real robot.

__init__(GUI=None, output_filename=None, worktable_template_filename=None)

Parameters:

• n_tips –
• num_of_samples –
• GUI –
• worktable_template_filename –
• output_filename –
• first_tip –
• run_name –
• tips_type –

name = 'Hello World'

run()

Here we have accesses to the “internal robot” self.iRobot, with in turn have access to the used Work Table, self.iRobot.worktable from where we can obtain labwares with get_labware()

class Pipeline(GUI=None, protocols=None, run_name=None)

Bases: EvoScriPy.protocol_steps.Executable

Each custom Pipeline need to implement these functions.

__init__(GUI=None, protocols=None, run_name=None)

Initialize self. See help(type(self)) for accurate signature.

check_list()

name = 'Pipeline'

run_pi()

class PreKingFisher_RNAextNucleoMag_EtOH80p(GUI=None, num_of_samples: int = None, worktable_template_filename=None, output_filename=None, first_tip=None, run_name: str = '')

Bases: protocols.evo100_f.evo100_f.Evo100_FLI

Implementation of the protocol for RNA extraction using the NucleoMag® VET kit from MACHEREY-NAGEL.

V_VL_inactivated()

V_default()

V_fill_inactivation()

V_fill_preMix_inactivation()

V_original_samples()

V_preMix_inactivated()

__init__(GUI=None, num_of_samples: int = None, worktable_template_filename=None, output_filename=None, first_tip=None, run_name: str = '')

Parameters:

• n_tips –
• num_of_samples –
• GUI –
• worktable_template_filename –
• output_filename –
• first_tip –
• run_name –
• tips_type –

def_versions()

Override this function to define a ‘dictionary’ of the versions for your Executable, with a name as key and a method as value, which will initialize the Executable to effectively execute that version. You don’t need to call this function. It will be used internally during initialization of your derived class.

max_s = 96

min_s = 1

name = 'PreKingFisher for RNA extraction modified NucleoMag MN_Vet kit and EtOH80p Plate preFill'

run()

Here we have accesses to the “internal robot” self.iRobot, with in turn have access to the used Work Table, self.iRobot.worktable from where we can obtain labwares with get_labware()

class Prefill_plates_LysisBuffer(GUI=None, run_name=None, output_filename=None)

Bases: protocols.evo100_f.evo100_f.Evo100_FLI

Prefill plates with LysisBuffer for the Implementation of the protocol for RNA extraction using the NucleoMag® VET kit from MACHEREY-NAGEL with washes in the Fischer Robot.

V_1_plate()

V_2_plate()

V_3_plate()

__init__(GUI=None, run_name=None, output_filename=None)

Parameters:

• n_tips –
• num_of_samples –
• GUI –
• worktable_template_filename –
• output_filename –
• first_tip –
• run_name –
• tips_type –

def_versions()

Override this function to define a ‘dictionary’ of the versions for your Executable, with a name as key and a method as value, which will initialize the Executable to effectively execute that version. You don’t need to call this function. It will be used internally during initialization of your derived class.

max_s = 96

min_s = 1

name = 'Prefill plates with LysisBuffer for KingFisher'

run()

Here we have accesses to the “internal robot” self.iRobot, with in turn have access to the used Work Table, self.iRobot.worktable from where we can obtain labwares with get_labware()

class Prefill_plates_LysisBuffer_and_ProtKpreMix(GUI=None, run_name=None, output_filename=None)

Bases: protocols.evo100_f.evo100_f.Evo100_FLI

Prefill plates with LysisBuffer for the Implementation of the protocol for RNA extraction using the NucleoMag® VET kit from MACHEREY-NAGEL with washes in the Fischer Robot.

V_1_plate_Cuvette()

V_1_plate_LysBuf_pK_Cuvette()

V_2_plate_Cuvette()

V_2_plate_LysBuf_pK_Cuvette()

V_3_plate_Cuvette()

V_3_plate_LysBuf_pK_Cuvette()

__init__(GUI=None, run_name=None, output_filename=None)

Parameters:

• n_tips –
• num_of_samples –
• GUI –
• worktable_template_filename –
• output_filename –
• first_tip –
• run_name –
• tips_type –

def_init(num_plates=1)

def_versions()

Override this function to define a ‘dictionary’ of the versions for your Executable, with a name as key and a method as value, which will initialize the Executable to effectively execute that version. You don’t need to call this function. It will be used internally during initialization of your derived class.

max_s = 96

min_s = 1

name = 'Prefill plates with LysisBuffer and ProtK PreMix for KingFisher'

plate_LysBuf_pK_Cuvette(num_plates=1)

plate_pK_Cuvette(num_plates=1)

run()

Here we have accesses to the “internal robot” self.iRobot, with in turn have access to the used Work Table, self.iRobot.worktable from where we can obtain labwares with get_labware()

v_1_plate()

v_2_plate()

v_3_plate()

class Prefill_plates_VEW1_ElutionBuffer_VEW2(GUI=None, num_of_samples: int = None, worktable_template_filename=None, output_filename=None, first_tip=None, run_name: str = '')

Bases: protocols.evo100_f.evo100_f.Evo100_FLI

Prefill plates with VEW1, Elution buffer and VEW2 for the Implementation of the protocol for RNA extraction using the NucleoMag® VET kit from MACHEREY-NAGEL with washes in the Fischer Robot.

V_Standard()

__init__(GUI=None, num_of_samples: int = None, worktable_template_filename=None, output_filename=None, first_tip=None, run_name: str = '')

Parameters:

• n_tips –
• num_of_samples –
• GUI –
• worktable_template_filename –
• output_filename –
• first_tip –
• run_name –
• tips_type –

def_versions()

Override this function to define a ‘dictionary’ of the versions for your Executable, with a name as key and a method as value, which will initialize the Executable to effectively execute that version. You don’t need to call this function. It will be used internally during initialization of your derived class.

max_s = 96

min_s = 1

name = 'Prefill plates with VEW1, Elution buffer and VEW2 for KingFisher'

run()

Here we have accesses to the “internal robot” self.iRobot, with in turn have access to the used Work Table, self.iRobot.worktable from where we can obtain labwares with get_labware()

class Protocol(n_tips=4, num_of_samples=96, GUI=None, worktable_template_filename=None, output_filename=None, first_tip=None, run_name=None, tips_type=None)

Bases: EvoScriPy.protocol_steps.Executable

Base class from which each custom protocol need to be derived, directly or from one of already derived. For example from the already adapted to some generic type robot like Evo200 or from an even more especially adapted like Evo100_FLI. Each newly derived protocol have to optionally override some of the following functions, especially .run().

• High level API:
• App-Structure API:
• Context-options modifiers:
• Lower lever API & “private” functions:
• Atomic API:

__init__(n_tips=4, num_of_samples=96, GUI=None, worktable_template_filename=None, output_filename=None, first_tip=None, run_name=None, tips_type=None)

Parameters:

• n_tips –
• num_of_samples –
• GUI –
• worktable_template_filename –
• output_filename –
• first_tip –
• run_name –
• tips_type –

allow_labware(carrier_type, labwares, widht_in_grids=None)

aspirate(arm: EvoScriPy.robot.Arm = None, TIP_MASK: int = None, volume: (<class 'float'>, <class 'list'>) = None, from_wells: [<class 'EvoScriPy.labware.Well'>] = None, liq_class: str = None)

Atomic operation. Use arm (pipette) with masked (selected) tips to aspirate volume from wells. :param arm: Uses the default Arm (pipette) if None :param TIP_MASK: Binary flag bit-coded (tip1=1, tip8=128) selects tips to use in a multichannel pipette arm.

If None all tips are used. (see Robot.mask_tip[index] and Robot.mask_tips[index])

Parameters:

• volume – One (the same) for each tip or a list specifying the volume for each tip.
• from_wells – list of wells to aspirate from.
• liq_class – the name of the Liquid class, as it appears in your own EVOware database. instructions.def_liquidClass if None

aspirate_one(tip, reagent, vol=None, offset=None)

Aspirate vol with ONE tip from reagent

Parameters:

• self –
• tip –
• reagent –
• vol –
• offset –

atomic_mix()

carrier_types()

check_list()

Tipically

check_reagent_level(reagent, liq_class=None)

Select all possible replica of the given reagent and detect the liquid level, contrasting it with the current (expected) volumen in EACH well. Use the given liquid class or the reagent default.

Parameters:

• reagent –
• liq_class –

check_reagents_levels()

Will emit a liquid level detection on every well occupied by all the reagents defined so fort. Will be executed at the end of self.check_list() but only if self.check_initial_liquid_level is True

comment(text: str)

Add a text comment in the generated script :param text:

comments()

consolidate()

Volumes going to the same destination well are combined within the same tip, so that multiple aspirates can be combined to a single dispense. If there are multiple destination wells, the pipette will never combine their volumes into the same tip. :return:

delay()

dilute_primer(primer: EvoScriPy.reagent.PrimerReagent, volume: float)

Parameters:primer –

dispense(arm: EvoScriPy.robot.Arm = None, TIP_MASK: int = None, volume: (<class 'float'>, <class 'list'>) = None, to_wells: [<class 'EvoScriPy.labware.Well'>] = None, liq_class: str = None)

Atomic operation. Use arm (pipette) with masked (selected) tips to dispense volume to wells.

Parameters:

• arm – Uses the default Arm (pipette) if None
• TIP_MASK – Binary flag bit-coded (tip1=1, tip8=128) selects tips to use in a multichannel pipette arm. If None all tips are used. (see Robot.mask_tip[index] and Robot.mask_tips[index])
• volume – One (the same) for each tip or a list specifying the volume for each tip.
• to_wells – list of wells to aspirate from.
• liq_class – the name of the Liquid class, as it appears in your own EVOware database. instructions.def_liquidClass if None

dispense_one(tip, reagent, vol=None)

Dispense vol with ONE tip to reagent

Parameters:

• tip –
• reagent –
• vol –

distribute(volume: float = None, reagent: EvoScriPy.reagent.Reagent = None, to_labware_region: EvoScriPy.labware.Labware = None, optimize: bool = True, num_samples: int = None, using_liquid_class: (<class 'str'>, <class 'tuple'>) = None, TIP_MASK: int = None, num_tips: int = None)

Parameters:

• volume – if not, volume is set from the default of the source reagent
• reagent – Reagent to distribute
• to_labware_region – Labware in which the destine well are selected
• optimize – minimize zigzag of multi pipetting
• num_samples – Priorized !!!! If true reset the selection
• using_liquid_class –
• TIP_MASK –
• num_tips – the number of tips to be used in each cycle of pipetting = all

To distribute a reagent into some wells. This is a high level function with works with the concept of “reagent”. This a a concept introduced by RobotEvo that don’t exist in EVOware and other similar software. It encapsulated the name, wells occupied by each of the aliquots of the reagent, the volume corresponding to one sample (if any) and the current volume in each aliquot. This function can use multiple of those aliquots to distribute the reagent to the target wells using multiple tips (the maximum will be used if num_tips is not set).

By default a number of wells equal to the number of samples set in the protocol will be auto selected in the target labware to_labware_region, but this selection can be set explicitly (setting well.selFlag=True, for example by calling to_labware_region.selectOnly(self, sel_idx_list)). If num_samples is set it will rewrite (reset) the selected wells in the target to_labware_region.

Please, carefully indicate whether to use “parallel optimization” in the pipetting order by setting optimize. (very important unless you are using a full column pipetting arm). Check that the created script don’t have conflicts in the order of the samples and the “geometry” of the labware areas (selection of wells) during each pipetting step. This is ease to “see” in the EVOware visual script editor. The generated .protocol.txt can also be used to check this. RobotEvo will detect some errors, but currently not all, assuming the areas are relatively “regular”.

The same volume will be transfer to each well. It will be dispensed in only one pass: muss fit into the current tips If the liquid classes (LC) to be used are not explicitly passed the default LC of the reagent will be used. The generated .esc and .gwl can also be used to check this.

A human readable comment will be automatically added to the script with the details of this operation.

done()

drop_tip(TIP_MASK: int = None, DITI_waste: EvoScriPy.labware.Labware = None, arm: EvoScriPy.robot.Arm = None, airgap_volume: float = 0, airgap_speed: int = None)

Parameters:

• TIP_MASK – Binary flag bit-coded (tip1=1, tip8=128) selects tips to use in a multichannel pipette arm. If None all tips are used. (see Robot.mask_tip[index] and Robot.mask_tips[index])
• DITI_waste – Specify the worktable position for the DITI waste you want to use. You must first put a DITI waste in the Worktable at the required position.
• arm – Uses the default Arm (pipette) if None
• airgap_speed – int 1-1000. Speed for the airgap in μl/s
• airgap_volume – 0 - 100. Airgap in μl which is aspirated after dropping the DITIs

drop_tips(TIP_MASK=None)

It will decide to really drop the tips or to put it back in some DiTi rack

Parameters:TIP_MASK –

get_carrier_type(carrier: (<class 'str'>, <class 'int'>))

get_labware_type(name: str)

get_liquid_class(name: str)

get_tips(TIP_MASK=None, tip_type=None, selected_samples=None)

It will decide to get new tips or to pick back the preserved tips for the selected samples

Parameters:

• TIP_MASK –
• tip_type –
• selected_samples –

Returns:

the TIP_MASK used

init_EvoMode()

initialize()

It is called “just in case” to ensure we don’t go uninitialized in lazy initializing scenarios.

labware_types()

liquid_classes()

make(what, NumSamples=None)

make_mix(mix: EvoScriPy.reagent.MixReagent, force_replies: bool = False)

A MixReagent is a mix of reagents (aka - components) which have been already defined to add some volume to this mix. Uses one new tip per component. It calculates and checks self the minimum and maximum number of aliquots of the resulting Mix

Parameters:

• mix – what to make, a predefined MixReagent
• volume – todo ??
• force_replies (bool) – use all the preMix predefined replicas

make_pre_mix(pre_mix: EvoScriPy.reagent.PreMixReagent, num_samples: int = None, force_replies: bool = False)

A preMix is just that: a premix of reagents (aka - components) which have been already defined to add some vol per sample. Uses one new tip per component. It calculates and checks self the minimum and maximum number of replica of the resulting preMix

Parameters:

• pre_mix (PreMixReagent) – what to make, a predefined preMix
• num_samples (int) –
• force_replies (bool) – use all the preMix predefined replicas

max_s = 96

min_s = 1

mix(in_labware_region: EvoScriPy.labware.Labware, using_liquid_class: str = None, volume: float = None, optimize: bool = True)

Mix the reagents in each of the wells selected in_labware_region, using_liquid_class and volume

Parameters:

• in_labware_region –
• using_liquid_class –
• volume –
• optimize –

mix_reagent(reagent: EvoScriPy.reagent.Reagent, liq_class: str = None, cycles: int = 3, maxTips: int = 1, v_perc: int = 90)

Select all possible replica of the given reagent and mix using the given % of the current vol in EACH well or the max vol for the tip. Use the given “liquid class” or the reagent default.

Parameters:

• reagent –
• liq_class –
• cycles –
• maxTips –
• v_perc – % of the current vol in EACH well to mix

move_tips(z_move, z_target, offset, speed, TIP_MASK=None)

name = ''

pick_up_tip(TIP_MASK: int = None, tip_type: (<class 'str'>, <class 'EvoScriPy.labware.DITIrackType'>, <class 'EvoScriPy.labware.DITIrack'>, <class 'EvoScriPy.labware.DITIrackTypeSeries'>) = None, arm: EvoScriPy.robot.Arm = None, airgap_volume: float = 0, airgap_speed: int = None)

Atomic operation. Get new tips. It take a labware type or name instead of the labware itself (DiTi rack) because the real robot take track of the next position to pick, including the rack and the site (the labware). It only need a labware type (tip type) and it know where to pick the next tip. Example:

self.pick_up_tip(‘DiTi 200 ul’) # will pick a 200 ul tip with every tip arm.

Parameters:

• TIP_MASK – Binary flag bit-coded (tip1=1, tip8=128) selects tips to use in a multichannel pipette arm. If None all tips are used. (see Robot.mask_tip[index] and Robot.mask_tips[index])
• tip_type – if None the worktable default DiTi will be used.
• arm – Uses the default Arm (pipette) if None
• airgap_speed – int 1-1000. Speed for the airgap in μl/s
• airgap_volume – 0 - 100. Airgap in μl which is aspirated after dropping the DITIs

preserve_tips(preserve=True) → bool

preserveing_tips() → bool

reuse_tips(reuse=True) → bool

Reuse the tips or drop it and take new after each action?

Parameters:reuse (bool) – Returns:

reuse_tips_and_drop(reuse=True, drop=True) -> (<class 'bool'>, <class 'bool'>)

run()

Here we have accesses to the “internal robot” self.iRobot, with in turn have access to the used Work Table, self.iRobot.worktable from where we can obtain labwares with get_labware()

set_EvoMode()

set_allow_air(allow_air=0.0) → float

set_defaults()

Set initial values that will not be rest during secondary initializations. The “primary initialization” maybe a light one, like defining the list of versions available. Here, for example, initialize the list of reagents. # todo: make private

set_drop_tips(drop=True) → bool

Drops the tips at THE END of the whole action? like after distribution of a reagent into various targets :param drop: :return:

set_first_tip(first_tip: (<class 'int'>, <class 'str'>) = None, tip_type: (<class 'str'>, <class 'EvoScriPy.labware.DITIrackType'>) = None)

Optionally set the Protocol.first_tip, a position in rack, like 42 or ‘B06’ (optionally including the rack self referenced with a number, like ‘2-B06’, were 2 will be the second rack in the worktable series of the default tip type). Currently, for a more precise set, use directly:

instructions.set_DITI_Counter2(labware=rack, posInRack=first_tip).exec()

set_paths()

show_check_list()

Will show a user prompt with a check list to set all defined reagents: Name, position in the worktable, wells and initial volume (on every well occupied by all the reagents defined so fort. Will be executed at the end of self.check_list() but only if self.show_runtime_check_list is True

tips(tips_mask=None, tip_type=None, reuse=None, drop=None, preserve=None, use_preserved=None, drop_first=False, drop_last=False, allow_air=None, selected_samples: EvoScriPy.labware.Labware = None)

A contextmanager function which will manage how tips will be used during execution of the dependant instructions

Parameters:

• tips_mask –
• tip_type – the type of the tips to be used
• reuse (bool) – Reuse the tips already mounted? or drop and take new BEFORE each individual action
• drop (bool) – Drops the tips AFTER each individual action? like after one aspiration and distribute of the reagent into various targets
• preserve (bool) – puts the tip back into a free place in some rack of the same type
• use_preserved – pick the tips back from the previously preserved
• selected_samples –
• allow_air –
• drop_first (bool) – Reuse the tips or drop it and take new once BEFORE the whole action
• drop_last (bool) – Drops the tips at THE END of the whole action

transfer(from_labware_region: EvoScriPy.labware.Labware, to_labware_region: EvoScriPy.labware.Labware, volume: (<class 'int'>, <class 'float'>), using_liquid_class: (<class 'str'>, <class 'tuple'>) = None, optimize_from: bool = True, optimize_to: bool = True, num_samples: int = None) -> (<class 'EvoScriPy.labware.Labware'>, <class 'EvoScriPy.labware.Labware'>)

Parameters:

• from_labware_region (Labware) – Labware in which the source wells are located and possibly selected
• to_labware_region (Labware) – Labware in which the target wells are located and possibly selected
• volume (float) – if not, volume is set from the default of the source reagent
• using_liquid_class – LC or tuple (LC to aspirate, LC to dispense)
• optimize_from (bool) – use from_labware_region.parallelOrder() to aspirate?
• optimize_to (bool) – use to_labware_region.parallelOrder() to aspirate?
• num_samples (int) – Prioritized. If used reset the well selection

Returns:

a tuple of the labwares used as origin and target with the involved wells selected.

To transfer reagents (typically samples or intermediary reactions) from some wells in the source labware to the same number of wells in the target labware using the current LiHa arm with maximum number of tips (of type: self.worktable.def_DiTi_type, which can be set ‘with self. tips() (tip_type = myTipsRackType)’). # todo: count for ‘broken’ tips

The number of “samples” may be explicitly indicated in which case will be assumed to begin from the first well of the labware. Alternatively the wells in the source or target or in both may be previously directly “selected” (setting well.selFlag=True, for example by calling from_labware_region.selectOnly(self, sel_idx_list)), in which case transfer the minimum length selected. If no source wells are selected this function will auto select the protocol’s self.num_of_samples number of wells in the source and target labwares. Please, carefully indicate whether to use “parallel optimization” in the pipetting order for both source and target by setting optimizeFrom and optimizeTo. (very important unless you are using a full column pipetting arm). Check that the created script don’t have conflicts in the order of the samples and the “geometry” of the labware areas (selection of wells) during each pipetting step. This is ease to “see” in the EVOware visual script editor. The generated .protocol.txt can also be used to check this. RobotEvo will detect some errors, but currently not all, assuming the areas are relatively “regular”.

The same volume will be transfer from each well. It will be aspirated/dispensed in only one pass: muss fit into the current tips todo ?! If no volume is indicated then the volume expected to be in the first selected well will be used.

If the liquid classes (LC) to be used are not explicitly passed the default LC in the first well of the current pipetting step will be used. The generated .esc and .gwl can also be used to check this.

A human readable comment will be automatically added to the script with the details of this operation.

Warning: modify the selection of wells in both source and target labware to reflect the wells actually used

use_preserved_tips(usePreserved=True) → bool

user_prompt(text: str, sound: bool = True, close_time: int = -1)

Interrupt pippeting to popup a message box to the operator.

Parameters:

• text – the text in the box
• sound – Should add an acustic signal?
• close_time – time to wait for automatic closing the box: the operator can “manually”

close this box at any time, and this will be the only way to close it if the default -1 is used,

which cause no automatic closing.

class RNAextr_MN_Vet_Kit(GUI=None, num_of_samples: int = None, worktable_template_filename=None, output_filename=None, first_tip=None, run_name: str = '')

Bases: protocols.evo100_f.evo100_f.Evo100_FLI

Implementation of the protocol for RNA extraction using the NucleoMag® VET kit from MACHEREY-NAGEL.

__init__(GUI=None, num_of_samples: int = None, worktable_template_filename=None, output_filename=None, first_tip=None, run_name: str = '')

Parameters:

• n_tips –
• num_of_samples –
• GUI –
• worktable_template_filename –
• output_filename –
• first_tip –
• run_name –
• tips_type –

def_versions()

Override this function to define a ‘dictionary’ of the versions for your Executable, with a name as key and a method as value, which will initialize the Executable to effectively execute that version. You don’t need to call this function. It will be used internally during initialization of your derived class.

max_s = 48

min_s = 1

name = 'RNA extraction with the MN_Vet kit'

run()

Here we have accesses to the “internal robot” self.iRobot, with in turn have access to the used Work Table, self.iRobot.worktable from where we can obtain labwares with get_labware()

ver_VL_inactivated()

ver_fill_inactivation()

ver_fill_preMix_inactivation()

ver_original_samples()

ver_preMix_inactivated()

versions_defaults()

wash_in_TeMag(reagent, wells=None, using_liquid_class=None, vol=None)

Parameters:

• reagent –
• wells –
• using_liquid_class – dict
• vol –

__init__(master=None)

Construct a frame widget with the parent MASTER.

Valid resource names: background, bd, bg, borderwidth, class, colormap, container, cursor, height, highlightbackground, highlightcolor, highlightthickness, relief, takefocus, visual, width.

protocol_selected(value)

class instructions_Te_MagS.Te_MagS_ActivateHeater(temperature, needs_allwd_lw=0, allowed_labware='')

Bases: EvoScriPy.Instruction_Base.TMagInstr

A.15.10.2 ActivateHeater (Worklist: Te-MagS_ActivateHeater)

__init__(temperature, needs_allwd_lw=0, allowed_labware='')

Initialize self. See help(type(self)) for accurate signature.

validate_arg()

class instructions_Te_MagS.Te_MagS_DeactivateHeater(exec_parameters='', needs_allwd_lw=0, allowed_labware='')

Bases: EvoScriPy.Instruction_Base.TMagInstr

A.15.10.3 DeactivateHeater (Worklist: Te-MagS_DeactivateHeater)

__init__(exec_parameters='', needs_allwd_lw=0, allowed_labware='')

Initialize self. See help(type(self)) for accurate signature.

validate_arg()

class instructions_Te_MagS.Te_MagS_Execution(exec_parameters=[], needs_allwd_lw=0, allowed_labware='')

Bases: EvoScriPy.Instruction_Base.TMagInstr

A.15.10.4 Execution (Worklist: Te-MagS_Execution)

class Parametr(num)

Bases: object

__init__(num)

Initialize self. See help(type(self)) for accurate signature.

__init__(exec_parameters=[], needs_allwd_lw=0, allowed_labware='')

Initialize self. See help(type(self)) for accurate signature.

class command(firmware_command)

Bases: object

__init__(firmware_command)

Initialize self. See help(type(self)) for accurate signature.

class incub(hh, mm, ss)

Bases: object

__init__(hh, mm, ss)

Initialize self. See help(type(self)) for accurate signature.

class mix(cycles, hh, mm, ss, z_pos=31)

Bases: object

__init__(cycles, hh, mm, ss, z_pos=31)

Initialize self. See help(type(self)) for accurate signature.

class move(position, z_pos)

Bases: object

__init__(position, z_pos)

Initialize self. See help(type(self)) for accurate signature.

validate_arg()

class wait(hh, mm, ss)

Bases: object

__init__(hh, mm, ss)

Initialize self. See help(type(self)) for accurate signature.

class instructions_Te_MagS.Te_MagS_MoveToPosition(position, z_pos=31, needs_allwd_lw=0, allowed_labware='')

Bases: EvoScriPy.Instruction_Base.TMagInstr

A.15.10.1 MoveToPosition (Worklist: Te-MagS_MoveToPosition)

Aspirate = 1

Dispense = 0

Incubation = 3

Re_suspension = 2

__init__(position, z_pos=31, needs_allwd_lw=0, allowed_labware='')

Parameters:

• position –

  Aspirate Position - Carrier above the magnet block, magnet block raised. Dispense Position - Carrier above the magnet block, magnet block lowered. Incubation Position - Carrier above the heating block, heating block raised. Re-suspension Position - Carrier above the heating block, heating block lowered.

  Use this position to carry out re-suspension by mixing the liquid with the pipetting tips (e.g. with the LiHa - Mix script command).

• z_pos –
• needs_allwd_lw –
• allowed_labware –

validate_arg()

Examples: