schrodinger.application.prepwizard2.prepare module¶

Shared functionality between PrepWizard GUI and command-line PrepWizard.

class schrodinger.application.prepwizard2.prepare.HetType¶

Bases: enum.Enum

An enumeration.

METAL_OR_ION = 1¶

DETECTED_LIGAND = 2¶

NON_WATER_SOLVENT = 3¶

OTHER = 4¶

schrodinger.application.prepwizard2.prepare.retrieve_and_read_pdb(pdbid)¶: Retrieve the given PDB and return the Structure object. On error, raises RuntimeError.

schrodinger.application.prepwizard2.prepare.serialize_het_states(states_by_het, complex_st)¶: Set JSON string for all given states as a CT-level property.

schrodinger.application.prepwizard2.prepare.deserialize_het_states(complex_st)¶: Attempt to read the het states from the CT using the s_ppw_het_states property, if present.

class schrodinger.application.prepwizard2.prepare.HetState(hetnum)¶

Bases: object

Class representing an ionization/tautomeric state of a het (e.g. ligand).

__init__(hetnum)¶: Initialize self. See help(type(self)) for accurate signature.

classmethod initFromEpikOutput(hetnum, state_st)¶: Return a HetState instance for the given Epik output structure.

classmethod initFromSerializedState(hetnum, serialized_state)¶: Return a HetState instance for the given serialized state.

serialize()¶

extractStateChargesAndOrders(state_st)¶

applyState(st)¶

Apply this het state to the specified complex structure: modify the bond orders and formal charges to apply the currently selected het state.

Also calculates the score and info_str properties

Raises RuntimeError if any of the het atoms are no longer in the structure, or are not numbered correctly.

findHetAtoms(complex_st)¶: Return a list of het heavy atoms in the given complex structure.

schrodinger.application.prepwizard2.prepare.fix_common_structure_mistakes(st)¶: Fixes common problems in structures and returns a list of correction strings that are to be reported to the user.

schrodinger.application.prepwizard2.prepare.invalid_st_valences(st)¶: Will return True if any atom in the specified structure has more bonds than is allowed for that element. Het groups in the PDB sometimes have this issue.

schrodinger.application.prepwizard2.prepare.atomsasl(atoms)¶: Generates an ASL expression for the specified atoms.

schrodinger.application.prepwizard2.prepare.create_glycosylation_bonds(st, dist=1.8, verbose=True)¶

Create glycosylation bonds for N-linked or O-linked glycosilation events Identfies neutral O or N with implicit or explicit hydrogens and forms bonds to sugars ( ring with 5 aliphatic carbons and one oxygen ) at locations adjacent to the oxygen. :param st: Structure to modify. :type st: Schrodinger.structure

Parameters:	dist (float) – Atoms must be at least this close to consider for for glycosilation verbose (boolean) – Whether to print formed bonds to stdout
Rparam:	Pairs of atom ( in the output structure ) where bonds were added
Return type:	list of schrodinger atom objects

schrodinger.application.prepwizard2.prepare.create_palmitoylation_bonds(st, dist=1.8, verbose=True)¶

Create palmitoylation bonds. Identfies neutral cysteine S with implicit or explicit hydrogens and palmitoyl groups or palmitoyl groups with the OH of the acid replace by a hydrogen :param st: Structure to modify. :type st: Schrodinger.structure

Parameters:	dist (float) – Atoms must be at least this close to consider for for pamitoylation verbose (boolean) – Whether to print formed bonds to stdout
Rparam:	Pairs of atom ( in the output structure ) where bonds were added
Return type:	list of schrodinger atom objects

schrodinger.application.prepwizard2.prepare.create_disulfide_bonds(st, dist=3.2, verbose=False)¶: Create bonds between proximal Sulfurs, deleting any hydrogens on them. If verbose is True, prints log info to the termnal. Returns a list of (atom1, atom2) for ever added bond.

schrodinger.application.prepwizard2.prepare.convert_selenomethionines(st)¶: Convert MSE residues to METs. Returns a list of residue strings that were converted.

schrodinger.application.prepwizard2.prepare.count_phosphates_and_sulfurs(st)¶

schrodinger.application.prepwizard2.prepare.extend_phosphate_states(st)¶

For specified structure, generates phosphate states, and returns list of output structures. Ev:78688

NOTE: Output structure has no hydrogens.

schrodinger.application.prepwizard2.prepare.extend_sulfate_states(st)¶: For specified structure, generates sulfate states, and returns list of output structures. Ev:82634

schrodinger.application.prepwizard2.prepare.get_chain_sequences(st, remove_tails=True)¶

Will read the PDB sequences from the sequence block, and will return a dictionary (keys: chain names; values: sequence strings).

If remove_tails is True, will chop off tails that are not existent in the CT, but will leave in the missing loop sections.

Will raise RuntimeError on an error, or mmerror on mmct failure.

schrodinger.application.prepwizard2.prepare.write_sequences_to_fasta(pdbid, sequences_dict, fastafile)¶

schrodinger.application.prepwizard2.prepare.does_res_have_missing_side_chains(residue)¶

Given a _Residue object, returns True if the residue is missing side-chain atoms. If at least one backbone atom is (also) missing, False is returned.

Basically only residues for which Prime missing-side-chains job can be run will return True.

schrodinger.application.prepwizard2.prepare.do_any_residues_have_missing_side_chains(st)¶: Returns True if at least one of the residue in the given structure has missing side-chain atoms (backbone atoms are ignored).

schrodinger.application.prepwizard2.prepare.fix_sulfur_charges(st)¶: Post process by fixing the charge on zero-order-bonded Sulfurs Gives -1 or -2 charge to Sulfurs as appropriate. Deletes a hydrogen from Sulfurs coordinating with metals (Ev:61622)

schrodinger.application.prepwizard2.prepare.extract_het_from_complex(complex_st, het_atoms)¶

Extract the het defined by the given ASL from the complex structure, and include receptor atoms withing 2 bonds (for covalently bound ligands).

Parameters:	complex_st (structure.Structure) – Receptor-ligand complex structure het_atoms (list(int)) – List of atom indices for the het
Returns:	Het structure, Het structure plus some receptor atoms (covalent ligands only), and het type.
Return type:	(structure.Structure, structure.Structure, HetType)

schrodinger.application.prepwizard2.prepare.extract_hets_from_complex(complex_st, het_atoms_lists)¶

Detect hets in the given complex structure, and extract them into separate substructures. For covalent ligands, receptor atoms within 2 bonds are also retained, so that Epik can account for them.

Parameters:	complex_st (structure.Structure) – Receptor-ligand complex structure het_atoms_lists (list(list(int))) – List of atoms for all hets
Returns:	Yields tuples of: Het structure, Het structure plus some receptor atoms (covalent ligands only), and het type.
Return type:	generator(structure.Structure, structure.Structure, HetType)

schrodinger.application.prepwizard2.prepare.prepare_for_epik(complex_st, types_to_process)¶

Extract hets from the given complex structure, (except het types that user requested to skip), and separate retained hets into 2 lists: Those that Epik should be run on, those that Epik doesn’t produce any states for. Atoms in the original structure will be marked with i_ppw_anum property, for matching Epik output to atoms in the input structure.

Parameters:	complex_st (structure.Structure) – Receptor-ligand complex structure types_to_process ([HetType]) – List of het types should be processed
Returns:	List of structures to run Epik on, and list of structures that should be processed, but without Epik.
Return type:	[structure.Structure], [structure.Structure]

schrodinger.application.prepwizard2.prepare.filter_undesired_states(orig_st, state_sts)¶

Returns a subset of state structures, which excludes metal-binding states for hets that are not within 5A of a metal.

Parameters:	orig_st (`structure.Structure`) – Original complex structure (receptor, ligands, metals) state_st (Iterable of `structure.Structure`) – Epik output states to filter.
Returns:	List of filtered structures.
Return type:	List of `structure.Structure`

schrodinger.application.prepwizard2.prepare.find_ppw_atom(st, anum)¶: Find the atom in the given structure whose i_ppw_anum property is set to the given value. ValueError exception is raised if such atom is not found.

schrodinger.application.prepwizard2.prepare.apply_state(complex_st, state_st)¶

Modify the het in complex_st complex (protein/ligand) structure such that its ionization state matches the output that we got from Epik (state_st).

Parameters:	complex_st (`structure.Structure`) – Original complex structure (receptor + het) state_st (`structure.Structure`) – Epik output for the het group. May include some atoms from the receptor if the ligand is covalently-bound.
Returns:	List of atom indices in complex_st that are part of the het.
Return type:	(dict, list)

schrodinger.application.prepwizard2.prepare.apply_state_and_calc_score(complex_st, state_st)¶

Apply the state <state_st> to <complex_st>, and return the score for the state in the context of the protein complex.

Parameters:	complex_st (`structure.Structure`) – Original complex structure (receptor + het) state_st (`structure.Structure`) – Epik output for the het group. May include some atoms from the receptor if the ligand is covalently-bound.
Returns:	Tuple of state score, Epik penalty, and information string. Epik penalty will be None for metal states.
Return type:	(float, float/None, str)

schrodinger.application.prepwizard2.prepare.get_state_penalties(state_st)¶: Return the Epik state penalty for this Epik output structure, as well as metal penalties for each atom that has the r_epik_Metal_State_Penalty property set.

schrodinger.application.prepwizard2.prepare.get_smallest_metal_penalty(complex_st, metal_penalties)¶: Return the lowest metal penalty of all het atoms, considering only atoms that are within 3A of a receptor metal.

schrodinger.application.prepwizard2.prepare.calc_hbond_energy(hydrogen, acceptor)¶: Calculate H-bond energy. Overly simple, to address PLDB-3337 and similar.

schrodinger.application.prepwizard2.prepare.calc_state_score(complex_st, het_atoms, state_penalty, metal_penalties)¶

Calculate the score for the current het state (must already been applies to the complex structure).

Het_atoms:	List of atoms (complex indexed) that are part of the het.

schrodinger.application.prepwizard2.prepare.generate_phosphate_and_sulfur_states(sts)¶: For each ligand state, expand states for the phosphate and sulfate groups.

schrodinger.application.prepwizard2.prepare.generate_metal_and_ion_states(sts)¶

schrodinger.application.prepwizard2.prepare.get_bridging_waters(st, min_hbonds=3)¶: Return a list of all waters in the specified structure that make at least <min_hbonds> number of H-bonds (H-bonds to other waters excluded). The list contains both oxygen and hydrogen atoms (if present).

schrodinger.application.prepwizard2.prepare.hydrogen_neighbors(st, atoms)¶

Returns the list of neighbor (bonded) atoms that are hydrogens.

Parameters:	st (`structure.Structure`) – Structure where atoms are from. atoms (list of ints) – List of atom indices for the heavy atoms.
Returns:	List of hydrogen atom indices
Return type:	list of ints.

schrodinger.application.prepwizard2.prepare.get_pdb_id(st)¶: Returns the PDB ID of the given structure. If the property does not exist, returns the string “unknown”.

schrodinger.application.prepwizard2.prepare.get_het_name(st, het_atoms, include_chain=False)¶

Return the het “name” to display for the user for the given het. Assumes all residues have the same chain name.

Example outputs:: “HEM 123a” “HEM A:123a” “GLY-VAL-PRO 110-111-112” “GLY-VAL-PRO A:110-111-112”

Parameters:	st (`structure.Structure`) – Structure containing the het het_atoms (list of ints) – Atoms from this het. include_chain (bool) – Whether the chain name should be included.

schrodinger.application.prepwizard2.prepare.add_prepared_props(st)¶: Adds “prepared” and “prepared with version” properties to the given structure.

schrodinger.application.prepwizard2.prepare.generate_bio_units(st)¶: If the given structure has Biounit data, generate conformations for each biounit. If multiple bio units are defined, multiple structures are returned - oner per bio unit. If no biounit data is present, original structure is returned (in list).

schrodinger.application.prepwizard2.prepare.apply_and_limit_state_sts(orig_st, state_sts, max_states, logger)¶

Apply states <state_sts> to the <orig_st> structure. Returns a list of structures with expanded states for the het groups.

Ev:94786 Make sure that each het is not expanded by a factor of more than max_states, by removing states with lowest count of H-bonds and lowest state penalties.

schrodinger.application.prepwizard2.prepare.delete_far_waters(st, angstroms=5)¶

schrodinger.application.prepwizard2.prepare.delete_non_bridging_waters(st, delwater_hbond_cutoff)¶: Delete waters that do not make at least this number of hydrogen bonds to non-waters.

schrodinger.application.prepwizard2.prepare.idealize_hydrogen_temp_factor(st)¶

Set temperature factor for hydrogens without temperature factors to that of the bonded heavy atom (if available). This is important for X-ray refinement to prevent R-factor collapse.

Parameters:	st (Schrodinger.structure) – Input Structure
Returns:	None, but alters hydrogen temperature factors in place.

schrodinger.application.prepwizard2.prepare.get_het_atom_numbers(st)¶

Get the list of het groups in a structure Inputs: :param st: Input Structure :type st: Schrodinger.structure :return: atom numbers in hetereo atom fields. Each list is

the atoms within a given hetero group

Returntype:	list of list of integers

class schrodinger.application.prepwizard2.prepare.PrepWizardSettings(default_value=<object object>, _param_type=<object object>, **kwargs)¶

Bases: schrodinger.models.parameters.CompoundParam

jobname¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

force_field¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

preprocess¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

assign_bond_orders¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

use_ccd¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

add_hydrogens¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

readd_hydrogens¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

idealize_hydrogen_tf¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

cap_termini¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

delete_far_waters¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

watdist¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

treat_metals¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

treat_disulfides¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

treat_glycosylation¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

treat_palmitoylation¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

selenomethionines¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

fillsidechains¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

fillloops¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

custom_fasta_file¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

run_epik¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

max_states¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

run_protassign¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

samplewater¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

xtal¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

pH¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

epik_pH¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

epik_pHt¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

use_propka¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

propka_pH¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

label_pkas¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

force_list¶

A Param to represent lists. Values of this param will have a mutated signal that will be emitted whenever any mutation method is called.

The constructor optionally takes a item_class keyword argument to specify what type of class the items in the list will be. This information will be used for jsonifying the list if specified.

minimize_adj_h¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

protassign_number_sequential_cycles¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

protassign_max_cluster_size¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

delwater_hbond_cutoff¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

run_impref¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

rmsd¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

fixheavy¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

DataClass¶: alias of builtins.object

__init__(default_value=<object object>, _param_type=<object object>, **kwargs)¶: Initialize self. See help(type(self)) for accurate signature.

classmethod addSubParam(name, param, update_owner=True)¶

add_hydrogensChanged¶

add_hydrogensReplaced¶

assign_bond_ordersChanged¶

assign_bond_ordersReplaced¶

blockSignals(self, bool) → bool¶

block_signal_propagation()¶

cap_terminiChanged¶

cap_terminiReplaced¶

childEvent(self, QChildEvent)¶

children(self) → List[QObject]¶

classmethod configureParam()¶: Override this class method to set up the abstract param class (e.g. setParamReference on child params.)

connectNotify(self, QMetaMethod)¶

customEvent(self, QEvent)¶

custom_fasta_fileChanged¶

custom_fasta_fileReplaced¶

classmethod defaultValue(*args, **kwargs)¶

deleteLater(self)¶

delete_far_watersChanged¶

delete_far_watersReplaced¶

delwater_hbond_cutoffChanged¶

delwater_hbond_cutoffReplaced¶

destroyed¶: destroyed(self, object: QObject = None) [signal]

disconnect(self)¶

disconnectNotify(self, QMetaMethod)¶

dumpObjectInfo(self)¶

dumpObjectTree(self)¶

dynamicPropertyNames(self) → List[QByteArray]¶

epik_pHChanged¶

epik_pHReplaced¶

epik_pHtChanged¶

epik_pHtReplaced¶

event(self, QEvent) → bool¶

eventFilter(self, QObject, QEvent) → bool¶

fillloopsChanged¶

fillloopsReplaced¶

fillsidechainsChanged¶

fillsidechainsReplaced¶

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject¶: findChild(self, Tuple, name: str = ‘’, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]¶: findChildren(self, Tuple, name: str = ‘’, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObject] findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObject] findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObject] findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObject] findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObject]

fixheavyChanged¶

fixheavyReplaced¶

force_fieldChanged¶

force_fieldReplaced¶

force_listChanged¶

force_listReplaced¶

classmethod fromJson(json_obj)¶

A factory method which constructs a new object from a given dict loaded from a json string or file.

Parameters:	json_obj (dict) – A json-loaded dictionary to create an object from.
Returns:	An instance of this class.

:rtype : cls

classmethod fromJsonImplementation(json_dict)¶: Sets the value of this compound param value object from a JSON dict.

getAbstractParam(*args, **kwargs)¶

classmethod getJsonBlacklist()¶

Override to customize what params are serialized.

Implementations should return a list of abstract params that should be omitted from serialization.

..NOTE: Returned abstract params must be direct child params of cls, e.g. cls.name, not cls.coord.x.

classmethod getParamSignal(*args, **kwargs)¶

classmethod getParamValue(*args, **kwargs)¶

classmethod getSubParam(name)¶

Get the value of a subparam using the string name:

c = Coord()
assert c.getSubParam('x') == 0

Note

Using the string name to accss params is generally discouraged, but can be useful for serializing/deserializing param data.

Parameters:	name (str) – The name of the subparam to get the value for.

classmethod getSubParams()¶: Return a dictionary mapping subparam names to their values.

getTypeHint()¶

get_version()¶: Method to get the version of a particular object. Defaults to the current version of mmshare. This class can be overridden for custom versioning behavior.

idealize_hydrogen_tfChanged¶

idealize_hydrogen_tfReplaced¶

inherits(self, str) → bool¶

initAbstract()¶

initConcrete()¶: Override to customize initialization of concrete params.

initializeValue()¶: Override to dynamically set up the default value of the param. Useful for default values that are determined at runtime. This is called any time the param is reset.

installEventFilter(self, QObject)¶

classmethod isAbstract()¶: Whether the param is an “abstract” param.

isDefault(*args, **kwargs)¶

isSignalConnected(self, QMetaMethod) → bool¶

isWidgetType(self) → bool¶

isWindowType(self) → bool¶

jobnameChanged¶

jobnameReplaced¶

killTimer(self, int)¶

label_pkasChanged¶

label_pkasReplaced¶

max_statesChanged¶

max_statesReplaced¶

metaObject(self) → QMetaObject¶

minimize_adj_hChanged¶

minimize_adj_hReplaced¶

moveToThread(self, QThread)¶

objectName(self) → str¶

objectNameChanged¶: objectNameChanged(self, str) [signal]

classmethod owner()¶

Get the owner of the param:

# Can be called on an abstract param:
assert Coord.x.owner() == Coord

# ...or on an instance of a CompoundParam
a = Atom()
assert a.coord.owner() == a

classmethod ownerChain()¶

Returns a list of param owners starting from the toplevel param and ending with self. Examples:

foo.bar.atom.coord.ownerChain() will return [foo, bar, atom, coord] where every item is a concrete param.

Foo.bar.atom.coord.x.ownerChain() will return [Foo, Foo.bar, Foo.atom.coord, Foo.atom.coord.x] where every item is an abstract params.

pHChanged¶

pHReplaced¶

classmethod paramName()¶

Get the name of the param:

# Can be called on an abstract param:
print(Coord.x.paramName()) # 'x'

# ...or on an instance of a CompoundParam
a = Atom()
a.coord.paramName() # 'coord'

parent(self) → QObject¶

preprocessChanged¶

preprocessReplaced¶

property(self, str) → Any¶

propka_pHChanged¶

propka_pHReplaced¶

protassign_max_cluster_sizeChanged¶

protassign_max_cluster_sizeReplaced¶

protassign_number_sequential_cyclesChanged¶

protassign_number_sequential_cyclesReplaced¶

pyqtConfigure(...)¶: Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

readd_hydrogensChanged¶

readd_hydrogensReplaced¶

receivers(self, PYQT_SIGNAL) → int¶

removeEventFilter(self, QObject)¶

reset(*args, **kwargs)¶

rmsdChanged¶

rmsdReplaced¶

run_epikChanged¶

run_epikReplaced¶

run_imprefChanged¶

run_imprefReplaced¶

run_protassignChanged¶

run_protassignReplaced¶

samplewaterChanged¶

samplewaterReplaced¶

selenomethioninesChanged¶

selenomethioninesReplaced¶

sender(self) → QObject¶

senderSignalIndex(self) → int¶

setObjectName(self, str)¶

classmethod setParamValue(*args, **kwargs)¶

setParent(self, QObject)¶

setProperty(self, str, Any) → bool¶

classmethod setReference(param1, param2)¶

Call this class method from configureParam to indicate that two params should be kept in sync. The initial values will start with the default value of param1. Example:

class Square(CompoundParam):
    width: float = 5
    height: float = 10

    @classmethod
    def configureParam(cls):
        super().configureParam()
        cls.setReference(cls.width, cls.height)

square = Square()
assert square.width == square.height == 5 # Default value of width
                                          # takes priority
square.height = 7
assert square.width == square.height == 7
square.width = 6
assert square.width == square.height == 6

Parameters:	param1 – The first abstract param to keep synced param2 – The second abstract param. After instantiation, this param will take on the value of param1.

setValue(*args, **kwargs)¶

signalsBlocked(self) → bool¶

skip_eq_check()¶

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int¶

staticMetaObject = <PyQt5.QtCore.QMetaObject object>¶

thread(self) → QThread¶

timerEvent(self, QTimerEvent)¶

toDict(*args, **kwargs)¶

toJson(_mark_version=True)¶

Create and returns a data structure made up of jsonable items.

Return type:	An instance of one the classes from NATIVE_JSON_DATATYPES

toJsonImplementation(*args, **kwargs)¶

tr(self, str, disambiguation: str = None, n: int = -1) → str¶

treat_disulfidesChanged¶

treat_disulfidesReplaced¶

treat_glycosylationChanged¶

treat_glycosylationReplaced¶

treat_metalsChanged¶

treat_metalsReplaced¶

treat_palmitoylationChanged¶

treat_palmitoylationReplaced¶

use_ccdChanged¶

use_ccdReplaced¶

use_propkaChanged¶

use_propkaReplaced¶

valueChanged¶

watdistChanged¶

watdistReplaced¶

xtalChanged¶

xtalReplaced¶

schrodinger.application.prepwizard2.prepare.tag_st_het_num_prop(sts)¶: Set the hetero atom number property to the sequence number in sts on the structures :param sts: the structures to tag :type sts: List[structure.Structure]

Previous topic

Next topic

schrodinger.application.prepwizard2.prepare module¶