Build module

PCR module

This part of the lab module is used for simulating and calculating PCR reactions.

teemi.build.PCR.Q5_NEB_PCR_program(amplicon)

Simple PCR program designed to give a quick visual representation of a PCR reaction.

Parameters

amplicon (pydna.amplicon) – pydna amplicon object

Returns

schematic representation of a Q5 program

Return type

str

teemi.build.PCR.amplicon_by_name(name: str, amplicons_lst: list)

Returns amplicon with specified name.

Parameters

• name (str) –

• amplicons_lst (list) –

Returns

amplicon

Return type

pydna.amplicon

teemi.build.PCR.calculate_elongation_time(amplicon)

Determines elongation time for an amplicon and add the elongation time to the amplicon annotations.

Parameters

amplicon (pydna.amplicon) –

Returns

Return type

Adds the elongation time to the amplicon annotations

Notes

The amplicon needs to have a dict called proc_speed shown as follows: amplicon.annotations[“proc_speed”] This dict within the annotations can be made with the function proc_speed.

teemi.build.PCR.calculate_processing_speed(amplicon)

Determines process speed based on the which polymerase is used.

Parameters

amplicon (pydna.amplicon) –

Returns

amplicon – Adds annotations to the amplicon object dependent on which polymerase was used

Return type

pydna.amplicon

Notes

The amplicon needs to have the following dict incorporated: amplicon.annotations[“polymerase”]

teemi.build.PCR.calculate_required_thermal_cyclers(amplicons: list, polymerase: str, elong_time_max_diff=15)

Determines the number of thermalcyclers that is needed based on elongation time differences

Parameters

• amplicons (list) – of pydna.amplicon objects

• polymerase (str) –

Returns

dataframe of grouped amplicons

Return type

pd.DataFrame

teemi.build.PCR.calculate_volumes(vol_p_reac=0, no_of_reactions=1, standard_reagents=[], standard_volumes=[])

Makes a reaction scheme for PCR master mixes.

Parameters

• vol_p_reac (int, optional) – Volume per reaction. Default is 0.

• no_of_reactions (int, optional) – Number of reactions. Default is 1.

• standard_reagents (list) – List of standard reagents.

• standard_volumes (list) – List of volumes for standard reagents.

Returns

volumes_df – DataFrame containing volume information.

Return type

pd.DataFrame

Examples

calculate_volumes(
    vol_p_reac = 10,
    no_of_reactions = 6,
    standard_reagents = ["DNA","Buffer, Cutsmart","H20","Enz, USER"],
    standard_volumes = [1,1,7,1]
)

The following reaction scheme will be made:

    vol_p_reac    vol_p_x_reac
DNA            1.0           6.0
Buffer, Cutsmart 1.0         6.0
H20            7.0           42.0
Enz, USER      1.0           6.0
Total          10.0          60.0

teemi.build.PCR.get_amplicons_by_column(col, amplicon_df, amplicons)

Returns a list of amplicons in a given gel column.

Parameters

• col (str) – Name of the gel column.

• amplicon_df (pandas DataFrame) – DataFrame with amplicon information, including the column ‘pcol’ indicating the gel column.

• amplicons (list of Amplicon) – List of Amplicon objects.

Returns

List of Amplicon objects in the given gel column.

Return type

list of Amplicon

teemi.build.PCR.get_amplicons_by_row(row, amplicon_df, amplicons)

Returns a list of amplicons in a given gel row.

Parameters

• row (str) – Name of the gel row.

• amplicon_df (pandas DataFrame) – DataFrame with amplicon information, including the column ‘prow’ indicating the gel row.

• amplicons (list of Amplicon) – List of Amplicon objects.

Returns

List of Amplicon objects in the given gel row.

Return type

list of Amplicon

teemi.build.PCR.grouper(iterable, max_diff)

Groups objects into distinct groups based on differences

teemi.build.PCR.nanophotometer_concentrations(path='')

Reads a CSV file with nanophotometer concentraions and returns the concentrations in a list.

Parameters

path (str) – path to file

Returns

concentrations – list of concentrations from the file as floats

Return type

list

teemi.build.PCR.pcr_locations(amplicons: list)

Obtain annotation information for amplicons.

Parameters

amplicons (list) – List of amplicon objects from pydna.amplicon()

Returns

Pandas DataFrame with amplicon locations

Return type

pd.DataFrame

teemi.build.PCR.primer_ta_neb(primer1, primer2, conc=0.5, prodcode='q5-0')

Calculates primer pair melting temp TA, from NEB.

Parameters

• primer1 (str) – first primer to be used for finding the optimal ta

• primer2 (str) – second primer to be used for finding the optimal ta

• conc (float) –

• prodcode (str) – find product codes on nebswebsite: https://tmapi.neb.com/docs/productcodes

Returns

ta – primer pair annealing temp

Return type

int

teemi.build.PCR.primer_tm_neb(primer, conc=0.5, prodcode='q5-0')

Calculates a single primers melting temp from NEB.

Parameters

• primer1 (str) –

• conc (float) –

• prodcode (str) – find product codes on nebswebsite: https://tmapi.neb.com/docs/productcodes

Returns

tm – primer melting temperature

Return type

int

teemi.build.PCR.set_plate_locations(amplicons: list)

Makes a dataframe from amplicons.

Parameters

amplicons (list) – list of pydna.amplicon objects

Returns

with overview of plate locations

Return type

pd.DataFrame

teemi.build.PCR.update_amplicon_annotations(amplicon_names: list, amplicons: list, locations: list, concentrations: list, volumes: list) → None

Updates the annotations of amplicons in the amplicon list.

Parameters

• amplicon_names (list) – List of amplicon names.

• locations (list) – List of locations for each amplicon.

• concentrations (list) – List of concentrations for each amplicon.

• volumes (list) – List of volumes for each amplicon.

Returns

Return type

None

Robot assembly module

A module to for automating biological assemblies with robots

class teemi.build.robot_assembly.LiquidHandler

Bases: teemi.build.containers_wells_picklists.Transfer

This class is a subclass of the synbiopython Transfer class and can be used to make flowbot instructions.

Parameters

None –

Returns

Return type

None

to_flowbot_instructions()

Return Flowbot instructions.

Example:

source, destination, volume
4:A3, 4:A6, 20
3:A1, 7, 50.7
2:A, 2:B-F, 100

class teemi.build.robot_assembly.RobotAssembly(Pandas_dataframe_PCR, F_primers: list, R_primers: list, Templates: list)

Bases: object

Class to generate instructions for robots on demand.

Parameters

• pandas.DataFrame – Pandas_dataframe with a PCR scheme

• F_primers (list) – list of forward primers

• R_primers (list) – list of reverse primers

• Templates (list) – list of templates

Returns

Methods include printing robot- excecutable intructions.

Return type

RobotAssembly object.

FlowbotInstructionsToCSV()

Prints flowbot instructions to csv format.

PlatesToExcelFile()

Returns an excel file of the plate setup that needs to be made before the flowbot can operate.

print_well_df_to_string()

Prints Pandas dataframe in string format.

teemi.build.robot_assembly.make_virtual_plates_fromDF(f_primers: list, r_primers: list, templates: list, Dataframe_with_PCR_contents)

Makes virtual plates from lists of primers and templates.The Pandas DataFrame is used to calculate how much pcr and h2o is needed for the reactions.

Parameters

• f_primers (list) – list of forward primers

• r_primers (list) – list of reverse primers

• templates (list) – list of templates

• Dataframe_with_PCR_contents (pandas.DataFrame) – dataframe with a PCR scheme.

Returns

Return type

Virtual 96 plates as containers.

teemi.build.robot_assembly.picklist_from_plates(F_primer_plate, R_primer_plate, Templates_plate, MM_H20_plate, PCR_dataframe)

This function can generate picklist from virtual plates and pandas dataframe with PCR components.

teemi.build.robot_assembly.well_keys_96(row=True)

If true it generates keys for a 96 well plate by row. else it does it by column

Parameters

row (bool) – if true it will generate keys horisontally for a 96 well plate. Else vertically.

Returns

keys – list of keys i.e [‘A1’, ‘A2’, ‘A3’,..]

Return type

list

Transformation module

This part of the lab module is used for making transformations

teemi.build.transformation.ODtime(initialOD: float, time: float, td: float = 0.5)

Calculates the OD based on doupling time.

Parameters

• initialOD (float) – in OD

• time (float) – in hours

• td (float) – doupling time i.e. td in h^-1

Returns

OD – the OD after a certain time()

Return type

float

teemi.build.transformation.calculate_volume_and_total_concentration(amplicons, amplicon_parts_amounts_total, n=1)

Calculates the volume and total concentration of a list of DNA parts.

Parameters

• amplicons (list) – A list of amplicon objects

• amplicon_parts_amounts_total (dict) – A dictionary of amplicon names and their respective total amounts

• n (int (optional)) – Gives the option of multiplying the volume is needed. Optional set to 1.

Returns

• volumes (list) – List of volumes of each amplicon

• ngs (list) – List of ngs of each amplicon

• total_conc (float) – Total concentration of all amplicons

teemi.build.transformation.ng_to_nmol(ng: float, bp: float)

Calculates nanogram to nanomol for transformation mixes.

To do a transformation it is important to have the right ratio of plasmid to insert. In other words this is done by calculating the nanomolar ratios and this tool can do that

Parameters

• ng (float) – eg. nanogram

• param (float) – eg. number of basepairs. Can also be an int

Returns

ng_to_nmol

Return type

float

Note

It calculates the nmol in the following way: nmol = ng/(bp*650)

teemi.build.transformation.pool_parts(amplicons: list, part_names: list, part_amounts: list, pool_names: list, pool_lengths) → dict

Pools amplicon parts and returns a dictionary of pooled volumes.

Parameters

• amplicons (list) – List of amplicon objects.

• part_names (list) – List of part names.

• part_amounts (list) – List of amounts of each part.

• pool_names (list) – List of pool names.

• pool_lengths (list) – List of pool lengths.

Returns

pooled_volumes – Dictionary containing the pooled volumes for each amplicon part.

Return type

dict

teemi.build.transformation.print_pooled_parts(pooled_volumes: dict) → None

Prints the pooled parts and calculated concentrations.

Parameters

pooled_volumes (dict) – Dictionary containing the pooled volumes for each amplicon part.

Returns

Return type

None

teemi.build.transformation.time_to_inoculate(initialOD: float, td: float, verbose: bool, transformation_time: int, target_OD: float, plot: bool = True)

Calculates when a starter culture is ready to be transformed.

Parameters

• initialOD (float) – the OD that you have you have diluted to e.g. 0.0025

• td (float) – Doubling time - you can find this online or find experimentally.

• transformation_time (int) – The time you want to transform. For example could be at 8 in the morning.

• verbose (Bool) – Provides extra information

• target_OD (float) – The target optical density that needs to be reached before transformation.

• plot (bool) – If you want to visualize the plot

Returns

Return type

A plot of cell growth at different td along with text about the transformation.

Notes

This is used to calculate when the cells should be used for transformation. For example: OD_1 = 1 * 10^7 cells / ml For a successful S.cerevisiae transformation between 1 to 2 × 10^7 cells/ml should be used Normal doubling time is between 3-6 hours

teemi.build.transformation.transformation_mix(reaction_names, reaction_participants, wanted_amounts, water_dna_p_reac, media='')

Create a pandas DataFrame for the parts needed in transformation mixes.

Parameters

• reaction_names (list) – List of reaction names.

• reaction_participants (list) – List of pydna.Dseqrecord objects or Bio.SeqRecord objects.

• wanted_amounts (dict) – Dictionary of reactant names with their calculated nmol.

• water_dna_p_reac (int) – Amount of water wanted for the reaction.

• media (list, optional) – List of names of the media used, e.g., [‘LB_AMP’].

Returns

DataFrame showing the transformation scheme for mixing parts in each reaction, including positive and negative controls.

Return type

pandas.DataFrame

Examples

# Define reaction names
reaction_names = ["insert", "n.ctr", "n.ctr", "n.ctr", "p.ctr"]

# Define reaction participants
reaction_participants = [
    [vector, gRNA1_pcr_prod, gRNA2_pcr_prod],  # the insert we want
    [vector],  # negative control
    [gRNA1_pcr_prod],  # negative control
    [gRNA2_pcr_prod],  # negative control
    [LEU_plasmid],  # positive control
]

# Calculate nmol
nmol_vector = ng_to_nmol(ng=15, bp=len(vector))
nmol_gRNA = ng_to_nmol(ng=30, bp=len(gRNA1_pcr_prod))
nmol_pctr = ng_to_nmol(ng=10, bp=len(LEU_plasmid))

# Define wanted concentrations
wanted_amounts = {
    'p0056\(pESC-LEU-ccdB-USER)': nmol_vector,
    'ATF1': nmol_gRNA,
    'CroCPR': nmol_gRNA,
    'LEU_plasmid': nmol_pctr,
}

# Define media for transformants
media = ['LB_AMP'] * 5

# Call the function
transformation_mix(
    reaction_names, reaction_participants, wanted_amounts, water_dna_p_reac=7, media=media
)

DataFrame with freezer locations:
      name  l4_I06  l4_I07  l4_I08  p1_F06  water  plate on
0       insert     0.1     0.6     0.6     NaN    5.7    LB_AMP
1       n.ctr     0.1     NaN     NaN     NaN    6.9    LB_AMP
2       n.ctr     NaN     0.6     NaN     NaN    6.4    LB_AMP
3       n.ctr     NaN     NaN     0.6     NaN    6.4    LB_AMP
4       p.ctr     NaN     NaN     NaN     0.1    6.9    LB_AMP

teemi.build.transformation.transformation_partitipants(reaction_participants, amnt=0.0005, sgRNA_plasmid_name=None, sgRNA_plasmid_conc=None)

Returns a dict with the µl amounts needed in a transformation reaction.

Parameters

• reaction_participants (list of list of Dseqrecord) – List of lists of Dseqrecord objects representing the reaction participants.

• amnt (float, optional) – Amount in µl of the reagents other than sgRNA_plasmid_name. Default is 0.0005.

• sgRNA_plasmid_name (str, optional) – Name of the sgRNA plasmid. If not provided, amnt is used for all reaction participants.

• sgRNA_plasmid_conc (float, optional) – Concentration in µl of the sgRNA plasmid. If not provided, amnt is used for all reaction participants.

Returns

Dict with the µl amounts needed for the transformation reaction, with keys being the names of the reaction participants and values being the corresponding µl amounts.

Return type

dict

teemi.build.transformation.wanted_mass(wanted_moles, size)

Calculates the mass needed from the specified amount of moles and size.

Parameters

• wanted_moles (int) – wanted moles in nmol

• size (int) – size in bp

Returns

w_mass_rounded – in ng. Mass wanted for the reaction.

Return type

int

teemi.build.transformation.wanted_volume(wanted_mass, actual_concentration)

Calculates the wanted volume from the mass and concentration.

Parameters

• wanted_mass (int) – wanted mass in ng

• actual_concentration (int) – actual_concentration in ng/ul

Returns

wanted_volume_rounded – return in ul

Return type

int

Containers module

exception teemi.build.containers_wells_picklists.NoUniqueWell

Bases: Exception

NoUniqueWell exception class.

class teemi.build.containers_wells_picklists.PickList(transfers_list=(), data=None)

Bases: object

Representation of a list of well-to-well transfers.

Parameters

• transfers_list – A list of Transfer objects that will be part of the same dispensing operation, in the order in which they are meant to be simulated.

• data – A dict with information on the picklist.

add_transfer(source_well=None, destination_well=None, volume=None, data=None, transfer=None)

Add a transfer to the picklist’s tranfers list.

You can either provide a Transfer object with the transfer parameter, or the parameters.

enforce_maximum_dispense_volume(max_dispense_volume)

Return a new picklist were every too-large dispense is broken down into smaller dispenses.

static merge_picklists(picklists_list)

Merge the list of picklists into a single picklist.

The transfers in the final picklist are the concatenation of the transfers in the different picklists, in the order in which they appear in the list.

restricted_to(transfer_filter=None, source_well=None, destination_well=None)

Return a version of the picklist restricted to transfers with the right source/destination well.

You can provide source_well and destination_well or alternatively just a function transfer_filter with signature (transfer)=>True/False that will be used to filter out transfers (for which it returns false).

simulate(content_field='content', inplace=True)

Simulate the execution of the picklist.

sorted_by(sorting_method='source_well')

Return a new version of the picklist sorted by some parameter.

The sorting_method is either the name of an attribute of the transfers, such as “source_well”, or a function f(transfer) -> value.

to_flowbot_instructions_string()

Return the list of transfers in Flowbot format.

to_plain_string()

Return the list of transfers in human-readable format.

to_plain_textfile(filename)

Write the picklist in a file in a human reable format.

total_transferred_volume()

Return the sum of all volumes from all transfers.

class teemi.build.containers_wells_picklists.Plate(name=None, wells_data=None, plate_data=None)

Bases: object

Base class for all plates.

See the builtin_containers for usage classes, such as generic microplate classes (Plate96, Plate384, etc).

Parameters

• name – Name or ID of the Plate as it will appear in strings and reports

• wells_data – A dict {“A1”: {data}, “A2”: …}. The format of the data is left free

• plate_data – plate data

find_unique_well_by_condition(condition)

Return the unique well of the plate satisfying the condition.

The condition method should have a signature of Well=>True/False.

Raises a NoUniqueWell error if 0 or several wells satisfy the condition.

find_unique_well_containing(query)

Return the unique well whose content contains the query.

get_well_at_index(index, direction='row')

Return the well at the corresponding index.

Examples:

>>> plate.get_well_at_index(1)  # well A1
>>> plate.get_well_at_index(2)  # well A2
>>> plate.get_well_at_index(2, direction="column")  # well B1

index_to_wellname(index, direction='row')

Return the name of the well at the corresponding index.

Examples:

>>> plate.index_to_wellname(1)  # "A1"
>>> plate.get_well_at_index(2)  # "A2"
>>> plate.get_well_at_index(2, direction="column")  # "B1"

iter_wells(direction='row')

Iter through the wells either by row or by column.

Examples:

>>> for well in plate.iter_wells():
>>>     print (well.name)

list_filtered_wells(well_filter)

List filtered wells.

Examples:

>>> def condition(well):
>>>     return well.volume > 50
>>> for well in myplate.list_filtered_wells(condition):
>>>     print(well.name)

list_well_data_fields()

Return all fields used in well data in the plate.

list_wells_in_column(column_number)

Return the list of all wells of the plate in the given column.

Examples:

>>> for well in plate.list_wells_in_column(5):
>>>      print(well.name)

list_wells_in_row(row)

Return the list of all wells of the plate in the given row.

The row can be either a row number (1,2,3) or row letter(s) (A,B,C).

Examples:

>>> for well in plate.list_wells_in_row("H"):
>>>      print(well.name)

return_column(column_number)

Return the list of all wells of the plate in the given column.

return_row(row)

Return the list of all wells of the plate in the given row.

The row can be either a row number (1,2,3) or row letter(s) (A,B,C).

to_dict(replace_nans_by='null')

Convert plate to dict.

to_pandas_dataframe(fields=None, direction='row')

Return a dataframe with the info on each well.

well_class

alias of teemi.build.containers_wells_picklists.Well

wellname_to_index(wellname, direction='row')

Return the index of the well in the plate.

Examples: >>> plate.wellname_to_index(“A1”) # 1 >>> plate.wellname_to_index(“A2”) # 2 >>> plate.wellname_to_index(“A1”, direction=”column”) # 9 (8x12 plate)

wells_grouped_by(data_field=None, key=None, sort_keys=False, ignore_none=False, direction_of_occurence='row')

Return wells grouped by key.

wells_sorted_by(sortkey)

Return wells sorted by sortkey

class teemi.build.containers_wells_picklists.Plate2x4(name=None, wells_data=None, plate_data=None)

Bases: teemi.build.containers_wells_picklists.Plate

Class for 8-well (2 x 4) plates such as colony plating plates

num_columns = 4

num_rows = 2

class teemi.build.containers_wells_picklists.Plate96(name=None, wells_data=None, plate_data=None)

Bases: teemi.build.containers_wells_picklists.Plate

Base class for standard 96-well plates

num_columns = 12

num_rows = 8

class teemi.build.containers_wells_picklists.Transfer(source_well, destination_well, volume, data=None)

Bases: object

Class representing a transfer from a source well to a destination well.

Parameters

• source_well – A Well object from which to transfer.

• destination_well – A Well object to which to transfer.

• volume – Volume to be transferred, expressed in liters.

• data – A dict containing any useful information about the transfer. This information can be used later e.g. as parameters for the transfer when exporting a picklist.

apply()

to_flowbot_instructions()

Return Flowbot instructions.

Example:

source, destination, volume
4:A3, 4:A6, 20
3:A1, 7, 50.7
2:A, 2:B-F, 100

to_plain_string()

Return “Transfer {volume}L from {source_well} into {dest_well}”.

to_short_string()

Return “Transfer {volume}L {source_well} -> {dest_well}”.

with_new_volume(new_volume)

Return a version of the transfer with a new volume.

exception teemi.build.containers_wells_picklists.TransferError

Bases: ValueError

class teemi.build.containers_wells_picklists.Well(plate, row, column, name, data=None)

Bases: object

Generic class for a well.

Parameters

• plate – The plate on which the well is located

• row – The well’s row (a number, starting from 0)

• column – The well’s column (a number, starting from 0)

• name – The well’s name, for instance “A1”

• data – A dictionary storing data on the well, used in algorithms and reports.

add_content(components_quantities, volume=None, unit_volume='L')

Add content to well.

Parameters

• components_quantities – Dictionary of components and quantities (default: gram). Example {“Compound_1”: 5}.

• volume – Volume (default: liter).

• unit_volume – Unit of volume (default: liter). Options: liter (L), milliliter (mL), microliter (uL), nanoliter (nL).

capacity = None

property coordinates

Return (well.row, well.column).

dead_volume_per_transfer_class = None

empty_completely()

Empty the well.

index_in_plate(direction='row')

Return the index of the well in the plate.

is_after(other, direction='row')

Return whether this well is located strictly after the other well.

Example: iterate over all free wells after the last non-free well:

>>> direction = 'row'
>>> last_occupied_well = plate.last_nonempty_well(direction=direction)
>>> free_wells = (w for w in plate.iter_wells(direction=direction)
>>>               if w.is_after(last_occupied_well))
>>> for well in free_wells: ...

property is_empty

Return true if the well’s volume is 0.

iterate_sources_tree()

Iterate through the tree of sources.

pretty_summary()

Return a summary string of the well.

subtract_content(components_quantities, volume=0)

Subtract content from well.

to_dict()

Convert well to dict

property volume

Return volume.

class teemi.build.containers_wells_picklists.WellContent(quantities=None, volume=0)

Bases: object

Class to represent the volume and quantities of a well.

Having the well content represented as a separate object makes it possible to have several wells share the same content, e.g. in throughs.

components_as_string(separator=' ')

Return a string representation of what’s in the well mix.

concentration(component=None, default=0)

Return concentration of component.

make_empty()

Empty the well.

to_dict()

Return a dict {volume: 0.0001, quantities: {…:…}}.

teemi.build.containers_wells_picklists.compute_rows_columns(num_wells)

Convert 96->(8,12), 384->(16,24), etc.

teemi.build.containers_wells_picklists.coordinates_to_wellname(coords)

Convert (1,1)->A1, (4,3)->D3, (12, 12)->H12, etc.

teemi.build.containers_wells_picklists.index_to_row_column(index, num_wells, direction='row')

teemi.build.containers_wells_picklists.index_to_wellname(index, num_wells, direction='row')

Convert e.g. 1..96 into A1..H12

Parameters

• index (int) – the index of the well

• num_wells (int) – number of wells on the plate

• direction (str) – the direction of counting. Either “row” or “column”.

teemi.build.containers_wells_picklists.number_to_rowname(number)

Convert 1->A 26->Z 27->AA etc.

teemi.build.containers_wells_picklists.replace_nans_in_dict(dictionary, replace_by='null')

Replace NaNs in a dictionary with a string.

Parameters

• dictionary (dict) – the dictionary

• replace_by (str) – replacement

teemi.build.containers_wells_picklists.rowname_to_number(name)

Convert A->1 Z->26 AA->27 etc.

teemi.build.containers_wells_picklists.wellname_to_coordinates(wellname)

Convert A1->(1,1), H11->(8, 11), etc.

teemi.build.containers_wells_picklists.wellname_to_index(wellname, num_wells, direction='row')

Convert e.g. A1..H12 into 1..96 direction is either row for A1 A2 A3… or column for A1 B1 C1 D1 etc.

Parameters

• wellname – the name of the well

• num_wells (int) – number of wells on the plate

• direction (str) – the direction of counting. Either “row” or “column”.