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.

after each instruction. - AdvancedWorkList:

class evo_mode.AdvancedWorkList(filename=None, immediate=None)[source]

Bases: evo_mode.ToFile

exec(instr)[source]
class evo_mode.COM_automation[source]

Bases: evo_mode.Mode

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

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)[source]

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

exec(instr)[source]
class evo_mode.Mode[source]

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()[source]
encoding = 'Latin-1'
exec(instr)[source]
newline = '\r\n'
class evo_mode.Multiple(modes=None)[source]

Bases: evo_mode.Mode

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

__init__(modes=None)[source]

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

add_mode(mode)[source]
done()[source]
exec(instr)[source]
class evo_mode.Script(filename=None, template=None, robot_protocol=None, robot=None)[source]

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)[source]

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

add_template()[source]
exec(instr)[source]
set_template(template, robot_protocol)[source]
class evo_mode.ScriptBody(filename=None, immediate=None)[source]

Bases: evo_mode.ToFile

class evo_mode.StdOut[source]

Bases: evo_mode.ToString

Specially useful during debugging.

exec(instr)[source]
class evo_mode.ToFile(filename=None, immediate=None)[source]

Bases: evo_mode.ToString

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

__init__(filename=None, immediate=None)[source]

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

done()[source]
exec(instr)[source]
open()[source]
set_file(filename=None)[source]
class evo_mode.ToString[source]

Bases: evo_mode.Mode

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

exec(instr)[source]
class evo_mode.iRobot(index, n_tips, arms=None, tips_type=None)[source]

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)[source]

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

exec(instr)[source]
set_as_current()[source]

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)[source]

Bases: object

Aspirate = 1
Detect = 0
DiTi = 0
Dispense = -1
Fixed = 1
__init__(n_tips, index, workingTips=None, tips_type=None)[source]
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'>)[source]

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'>])[source]

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[source]

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[source]

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'>)[source]

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'>)[source]

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'>)[source]

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)[source]

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)[source]

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)[source]
current = None
drop_tips_executed(TIP_MASK=None, waste=None)[source]
drop_tips_test(TIP_MASK=None)[source]
getTips_test(rack_type, tip_mask=None) → int[source]
get_tips_executed(rack_series, tip_mask=None) -> (<class 'int'>, <class 'list'>)[source]

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)[source]
pick_up_tips_executed(TIP_MASK, labware_selection: EvoScriPy.labware.DITIrack) → int[source]

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'>)[source]
preserve_tips(preserve=True) → bool[source]
reuse_tips(reuse=True) → bool[source]
set_allow_air(allow_air=0.0) → float[source]
set_as_current()[source]
set_drop_tips(drop=True) → bool[source]

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)[source]

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)[source]
use_preserved_tips(usePreserved=True) → bool[source]
use_tips_executed(tipMask, labware_selection)[source]
where_are_preserved_tips(selected_reagents: EvoScriPy.labware.Labware, TIP_MASK, type) → list[source]
Parameters:
  • selected_reagents
  • TIP_MASK
Returns:

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

where_preserve_tips(TIP_MASK) → list[source]

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.
class instructions_Te_MagS.Te_MagS_ActivateHeater(temperature, needs_allwd_lw=0, allowed_labware='')[source]

Bases: EvoScriPy.Instruction_Base.TMagInstr

A.15.10.2 ActivateHeater (Worklist: Te-MagS_ActivateHeater)

__init__(temperature, needs_allwd_lw=0, allowed_labware='')[source]

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

validate_arg()[source]
class instructions_Te_MagS.Te_MagS_DeactivateHeater(exec_parameters='', needs_allwd_lw=0, allowed_labware='')[source]

Bases: EvoScriPy.Instruction_Base.TMagInstr

A.15.10.3 DeactivateHeater (Worklist: Te-MagS_DeactivateHeater)

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

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

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

Bases: EvoScriPy.Instruction_Base.TMagInstr

A.15.10.4 Execution (Worklist: Te-MagS_Execution)

class Parametr(num)[source]

Bases: object

__init__(num)[source]

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

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

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

class command(firmware_command)[source]

Bases: object

__init__(firmware_command)[source]

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

class incub(hh, mm, ss)[source]

Bases: object

__init__(hh, mm, ss)[source]

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

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

Bases: object

__init__(cycles, hh, mm, ss, z_pos=31)[source]

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

class move(position, z_pos)[source]

Bases: object

__init__(position, z_pos)[source]

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

validate_arg()[source]
class wait(hh, mm, ss)[source]

Bases: object

__init__(hh, mm, ss)[source]

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='')[source]

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='')[source]
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()[source]

Examples: