schrodinger.application.prepwizard2.prepare module

Shared functionality between PrepWizard GUI and command-line PrepWizard.

Copyright Schrodinger, LLC. All rights reserved.

class schrodinger.application.prepwizard2.prepare.HetType(value)

Bases: enum.Enum

An enumeration.

METAL_OR_ION = 1
DETECTED_LIGAND = 2
NON_WATER_SOLVENT = 3
OTHER = 4
schrodinger.application.prepwizard2.prepare.get_atoms_by_orig_anum(st)

Return a dict where keys are atom indices in the original structure (prior to preparation) and values are atom indices in the given st.

schrodinger.application.prepwizard2.prepare.extract_receptor_without_hets(st: schrodinger.structure._structure.Structure) schrodinger.structure._structure.Structure

Extract the receptor from the given st, while deleting all hets. Used for detecting H-bonds between the receptor and hets. Using same CT for all hets is faster, as SSSRs are cached.

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.find_metals_in_structure(st)
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)
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, no_hets_recep_st=None, all_recep_metals=None)

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

Also calculates the score and info_str properties, even if they are already present, as user may have modified the structure since.

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.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.get_asl_for_ppw_atoms(atoms)

Return an ASL that would match the given atom numbers from input structure (prior to preparation).

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. Used by PPW1 only. PPW2 uses an optimization instead.

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

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.

  • atoms_by_anum – Dict where keys are atom numbers in original unprepared structure, and values are atom numbers in complex_st.

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(metal_penalties, all_recep_metals)

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, smallest_metal_penalty, hbonds)

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

Complex_st

Structure containing the het and receptor atoms.

Het_atoms

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

State_penalty

Output from get_state_penalties()

Smallest_metal_penalty

Output from get_smallest_metal_penalty()

Hbonds

Output from hbond.get_hydrogen_bonds()

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_num_clashes_with_metals(st, het_anums)

Returns the number of times there is a hydrogen that is clashing with a metal. For now, only hydrogens on aliphatic nitrogens that are zero- order bonded to metals are considered. Geometry is not considered, because amides are rotatable groups.

Parameters

st (structure.Structure) – Structure where atoms are from.

:param het_anumst of atom indices for the heavy atoms. :type het_anumst of ints

Returns

List of nitrogen atoms.

Return type

list(structure._StructureAtom)

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.apply_het_states(orig_st, state_sts, logger)

For each het state, generate a complex structure with that state applied, and return a list of (state score, complex structure), one for each state.

Parameters
Returns

List of state score and complex structure tuples

Return type

List[Tuple[float, structure.Structure]]

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

Parameters

st (schrodinger.structure.Structure) – Input Structure

Returns

atom numbers in hetero atom fields. Each list is the atoms within a given hetero group

Return type

list of list of integers

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

Bases: schrodinger.models.parameters.CompoundParam

jobname: str

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: str

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: bool

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: bool

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: bool

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: bool

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: bool

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: bool

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_terminal_oxygens: bool

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: bool

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_min_atoms: int

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_delete_far_waters: bool

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_watdist: float

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: bool

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: float

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: bool

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: bool

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: bool

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: bool

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: bool

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
antibody_cdr_scheme: schrodinger.infra.util.AntibodyCDRScheme
renumber_ab_residues: bool

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: bool

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: bool

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: bool

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: bool

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_epikx: bool

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: int

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: bool

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: bool

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
include_epik_states: bool

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: bool

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: float

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: float

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: float

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: bool

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: float

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: bool

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: 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: bool

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: int

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: int

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: int

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_nonbridging_waters: bool

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: bool

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: float

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: bool

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
reference_struct: schrodinger.structure._structure.Structure

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_PDB_pH: bool

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
preserve_st_titles: bool

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

This class can be used to declare a public attribute on a CompoundParam. Declared public attributes can be used without error.

Example usage:

class Coord(CompoundParam):
    x: int
    y: int
    note = NonParamAttribute()

coord = Coord()
coord.note = "hello" # No error
__init__(default_value=<object object>, _param_type=<object object>, **kwargs)
classmethod addSubParam(name, param, update_owner=True)
add_hydrogensChanged
add_hydrogensReplaced
add_terminal_oxygensChanged
add_terminal_oxygensReplaced
antibody_cdr_schemeChanged
antibody_cdr_schemeReplaced
assign_bond_ordersChanged
assign_bond_ordersReplaced
blockSignals(self, bool) bool
block_signal_propagation()
cap_terminiChanged
cap_terminiReplaced
cap_termini_min_atomsChanged
cap_termini_min_atomsReplaced
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()

Returns the default value for this abstract param:

default_atom = Atom.defaultValue()
assert Atom.coord.x == 0
deleteLater(self)
delete_far_watersChanged
delete_far_watersReplaced
delete_nonbridging_watersChanged
delete_nonbridging_watersReplaced
delwater_hbond_cutoffChanged
delwater_hbond_cutoffReplaced
destroyed

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

disconnect(QMetaObject.Connection) bool
disconnect(self) None
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: Qt.FindChildOption = Qt.FindChildrenRecursively) QObject
findChild(self, Tuple, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) QObject
findChildren(self, type, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) List[QObject]
findChildren(self, Tuple, name: str = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) List[QObject]
findChildren(self, type, QRegularExpression, options: Qt.FindChildOption = Qt.FindChildrenRecursively) List[QObject]
findChildren(self, Tuple, QRegularExpression, options: 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.

Return type

cls

classmethod fromJsonImplementation(json_dict)

Sets the value of this compound param value object from a JSON dict.

Warning

This should never be called directly.

getAbstractParam()

Return the corresponding abstract param for this instance.

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(obj, signal_type='Changed')
classmethod getParamValue(obj)

Enables access to a param value on a compound param via an abstract param reference:

a = Atom()
assert Atom.coord.x.getParamValue(a) == 0 # ints default to 0
a.coord.x = 3
assert Atom.coord.x.getParamValue(a) == 3
Parameters

param (CompoundParam) – The owner param to get a param value from

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 access 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
include_epik_statesChanged
include_epik_statesReplaced
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()

Whether the current value of this instance matches the default value.

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
preprocess_delete_far_watersChanged
preprocess_delete_far_watersReplaced
preprocess_watdistChanged
preprocess_watdistReplaced
preserve_st_titlesChanged
preserve_st_titlesReplaced
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
reference_structChanged
reference_structReplaced
removeEventFilter(self, QObject)
renumber_ab_residuesChanged
renumber_ab_residuesReplaced
reset(*abstract_params)

Resets this compound param to its default value:

class Line(CompoundParam):
    start = Coord(x=1, y=2)
    end = Coord(x=4, y=5)
line = Line()
line.start.x = line.end.x = 10
assert line.start.x == line.end.x == 10
line.reset()
assert line.start.x == 1
assert line.end.x == 4

Any number of abstract params may be passed in to perform a partial reset of only the specified params:

line.start.x = line.end.x = 10
line.reset(Line.start.x)  # resets just start.x
assert line.start.x == 1
assert line.end.x == 10

line.reset(Line.end)      # resets the entire end point
assert line.end.x == 4

line.start.y = line.end.y = 10
line.reset(Line.start.y, Line.end.y)  # resets the y-coord of both
assert line.start.y == 2
assert line.end.y == 5
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(obj, value)

Set the value of a param on an object by specifying the instance and the value:

# Setting the param value of a basic param
a = Atom()
Atom.coord.x.setParamValue(a, 5)
assert a.coord.x == 5

# setParamValue can also be used to set the value of CompoundParams
c = Coord()
c.x = 10
atom.coord.setParamValue(a, c)
assert atom.coord.x == 10
Parameters
  • param – The owner param to set a subparam value of.

  • value – The value to set the subparam value to.

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(value=None, **kwargs)

Set the value of this CompoundParam to match value.

Parameters
  • value – The value to set this CompoundParam to. It should be the same type as this CompoundParam.

  • kwargs – For internal use only.

signalsBlocked(self) bool
skip_eq_check()
startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) int
staticMetaObject = <PyQt6.QtCore.QMetaObject object>
thread(self) QThread
timerEvent(self, QTimerEvent)
toDict()

Return a dictionary version of this CompoundParam. The returned dictionary is fully nested and contains no CompoundParam instances

a = Atom()
a_dict = a.toDict()
assert a_dict['coord']['x'] == 0
assert a_dict['coord'] == {'x':0, 'y':0}
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()

Returns a JSON representation of this value object.

Warning

This should never be called directly.

tr(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_PDB_pHChanged
use_PDB_pHReplaced
use_ccdChanged
use_ccdReplaced
use_epikxChanged
use_epikxReplaced
use_propkaChanged
use_propkaReplaced
valueChanged
watdistChanged
watdistReplaced
xtalChanged
xtalReplaced
schrodinger.application.prepwizard2.prepare.update_task_from_settings(task, settings)

Update the given PPWorkflowTask with these given settings.

schrodinger.application.prepwizard2.prepare.prepare_structure(st, options, logger=None)

Prepare the given protein structure using PrepWizard.

Parameters
Returns

Prepared structures. Depending on the number of hets in the protein, up to options.max_states number of structures will be produced; by default 1.

Return type

List[structure.Structure]

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]