schrodinger.application.bioluminate.protein.mutator module

class schrodinger.application.bioluminate.protein.mutator.ProteinMutator(ref_struct, mutations, concurrent=1, sequential=False, idealize=True)

Bases: schrodinger.application.bioluminate.mutation.MacromoleculeMutator

Mutates a set of residues in a protein structure allowing concurrent mutations as well as the option to limit concurrent mutations to sequential residues only.

Here is an example of a mutation of a Ser residue to: Asp, Glu, Asn, & Gln (one-letter codes are D, E, N, & Q respectively). The Ser residue is in chain A and has a residue number of 22. This example will write a file named ‘mutated_structures.maegz’ that has the reference structure as the first CT and each mutation CT after that. Five total structures will be in the output file:

from schrodinger import structure
from schrodinger.application.bioluminate import protein

# Get the input structure
reference_st = structure.Structure.read('receptor.maegz')

# Create the writer for the output file and append the reference
writer = structure.StructureWriter('mutated_structures.maegz')
writer.append(reference_st)

# Define the residues and mutations
residues = ['A:22']
muts     = 'DENQ'

# Get a compatible list of mutations. The above turns into
# [('A', 22, 'DENQ')]
mutations = ProteinMutator.convert_residue_list(residues, muts)

# Construct the mutator
mutator = ProteinMutator(st, mutations)

# Loop over each mutation
for mutation in mutator.generate():
    #
    mutated_structure = mutation.struct
    residue_map       = mutation.residue_map

    res_str = ", ".join(str(res) for res in residue_map.values())
    print 'Residues affected by this mutation: %s' % res_str

    # Do something with the mutated structure (refine maybe)

    writer.append(mutated_structure)

@todo: Add logging

MUTATIONS_PROPERTY = 's_bioluminate_Mutations'
UNFOLDED_PROPERTY = 'r_bioluminate_Unfolded_Contribution'
UNFOLDED_PROPERTY_PRIME = 'r_bioluminate_Unfolded_Contribution_Prime'
RES_FILE_REGEX = re.compile('(?P<chain>[a-zA-Z0-9_]{1})\n    :\n    (?P<resnum>-?\\d+)\n    (?P<inscode>[a-zA-Z]{1})?  # optional\n    \\s?                        # optional\n    (?P<mutations>(\\S{3})(,\\S{3})*)? # optional\n  , re.VERBOSE)
MUTS_FILE_REGEX = re.compile('(?P<chain>[a-zA-Z0-9_]{1})\n    :\n    (?P<resnum>-?\\d+)\n    (?P<inscode>[a-zA-Z]{1})?  # optional\n    ->\n    (?P<new_resname>(\\S{3}))\n    ', re.VERBOSE)
GXG_DATA = {'ALA': -100.736, 'ARG': -118.478, 'ARN': -118.478, 'ASH': -149.255, 'ASN': -137.153, 'ASP': -149.255, 'CYS': -100.845, 'GLH': -143.536, 'GLN': -136.183, 'GLU': -143.536, 'GLY': -105.658, 'HID': -104.977, 'HIE': -104.977, 'HIP': -104.977, 'HIS': -104.977, 'ILE': -84.13, 'LEU': -92.4, 'LYN': -110.759, 'LYS': -110.759, 'MET': -99.708, 'PHE': -96.483, 'PRO': -66.763, 'SER': -96.365, 'THR': -98.156, 'TRP': -105.114, 'TYR': -101.858, 'VAL': -93.493}
GXG_DATA_PRIME = {'ALA': -112.635, 'ARG': -142.467, 'ARN': -142.467, 'ASH': -154.559, 'ASN': -156.375, 'ASP': -154.559, 'CYS': -113.747, 'GLH': -141.673, 'GLN': -152.611, 'GLU': -141.673, 'GLY': -116.263, 'HID': -121.6, 'HIE': -121.6, 'HIP': -121.6, 'HIS': -121.6, 'ILE': -97.541, 'LEU': -107.106, 'LYN': -123.751, 'LYS': -123.751, 'MET': -112.643, 'PHE': -113.719, 'PRO': -81.734, 'SER': -112.693, 'THR': -116.048, 'TRP': -122.407, 'TYR': -123.497, 'VAL': -109.017}
SUPPORTED_BUILD_RESIDUES = ['ALA', 'ARG', 'ASN', 'ASP', 'CYS', 'GLN', 'GLU', 'GLY', 'HIS', 'HIP', 'HIE', 'ILE', 'LEU', 'LYS', 'MET', 'PHE', 'PRO', 'SER', 'THR', 'TRP', 'TYR', 'VAL']
__init__(ref_struct, mutations, concurrent=1, sequential=False, idealize=True)
Parameters

  • ref_struct (schrodinger.structure.Structure instance) – The reference (starting) structure

  • mutations (List of tuples) – A list of the mutations to carry out on the ref_struct. Each element of the list is a tuple of (“res num.”, [“pdbnames”]) where “res num.” is the residue number being altered and “pdbnames” is a list of the standard PDB residue names to mutate it to.

  • concurrent (int) – Maximum concurrent mutations

  • sequential (bool) – Limit concurrent mutations to being sequential

  • idealize (bool) – Whether to idealize the reference structure by self-mutating the affected residues before calculating properties.

Raises

RuntimeError – If concurrent is less than 1.

See

For easy creation of mutations variable ProteinMutator.convert_residue_list

classmethod validate_mutated_residues(residues)

Method for validating the residues used in mutations passed in to the MutateProtein class.

Raises

ValueError – If the 3-letter residue name is not supported by the build,mutate method.

classmethod convert_res_file(filename, regex=re.compile('(?P<chain>[a-zA-Z0-9_]{1})\n    :\n    (?P<resnum>-?\\d+)\n    (?P<inscode>[a-zA-Z]{1})?  # optional\n    \\s?                        # optional\n    (?P<mutations>(\\S{3})(, \\S{3})*)? # optional\n, re.VERBOSE))

Shim for the mixed-case class method convertResFile

classmethod convert_res_list(reslist, regex=re.compile('(?P<chain>[a-zA-Z0-9_]{1})\n    :\n    (?P<resnum>-?\\d+)\n    (?P<inscode>[a-zA-Z]{1})?  # optional\n    \\s?                        # optional\n    (?P<mutations>(\\S{3})(, \\S{3})*)? # optional\n, re.VERBOSE), validate=True)

Shim for the mixed-case class method convertResList.

static get_3_letter_mutation(mutation)
classmethod get_3_letter_mutation_list(mutation_list)
classmethod convert_res_to_muts(res_str, regex=re.compile('(?P<chain>[a-zA-Z0-9_]{1})\n    :\n    (?P<resnum>-?\\d+)\n    (?P<inscode>[a-zA-Z]{1})?  # optional\n    \\s?                        # optional\n    (?P<mutations>(\\S{3})(, \\S{3})*)? # optional\n, re.VERBOSE), validate=True)

Shim for the mixed-case class method convertResToMuts.

classmethod convert_muts_file(muts_file, regex=re.compile('(?P<chain>[a-zA-Z0-9_]{1})\n    :\n    (?P<resnum>-?\\d+)\n    (?P<inscode>[a-zA-Z]{1})?  # optional\n    ->\n    (?P<new_resname>(\\S{3}))\n    ', re.VERBOSE))

Shim for the mixed-case class method convertMutsFile.

classmethod convert_residue_list(residues, mutations, regex=re.compile('(?P<chain>[a-zA-Z0-9_]{1})\n    :\n    (?P<resnum>-?\\d+)\n    (?P<inscode>[a-zA-Z]{1})?  # optional\n    \\s?                        # optional\n    (?P<mutations>(\\S{3})(, \\S{3})*)? # optional\n, re.VERBOSE))

Shim for the mixed-case method convertResidueList.

calculateMutationsList()

Calculate the mutations that will be performed, based on the input residues and their mutations, and the “concurrent” and “sequential” settings.

generate()

Used to loop over all mutations. Each mutation consists of the mutated structure and a residue mapping dict. The structure is raw, that is, unrefined in any way.

Returns

Generator for all mutations defined in self.mutations Each step of generator yields a mutation.

Return type

generator

getMutationFromChanges(changes)
getLoopMutation(mutated_st, res_str, new_resname)

build loop insertion or deletion