Module prime_workups

Iterator that returns the specified frames of the structures in filename {structure} By default return all frames, but if frames_to_check { list, set or anything with an "__in__" method" of integers} is set then the only frames for which their index (starting with 0) are in frames to check are returned. Note that even if a list is passed with integers out of order, the frames will always be yielded in the order that they are in the file.

Convert a string specifying a residue or atom into an asl expresion
Input should be in the form <chain>:<resnum><inscode> or
                            <chain>:<resnum><inscore>:<pdb atom name>
<chain> is the chain id or a _ or no character if space
<resnum> is the residue number (possibly negative)
<inscode> is the pdb insertion code
<pdb atom name> The 4 letter pdb atom name.  Either spaces or _ can
     be used for padding to get to 4 characters
Examples A:12 :23A B:-1 _:12

The output is a ASL expression stored as a string that corresponds
to the same atom(s) in the input.

STU workup that will check to see if a list of moved residues { string the residue names (__str__() evaluation of the structure._Residue class) separated by spaces} corresponds to the list of all residue that have an an atom that moved more than tolerance {float} between any of the frames_to_check in filename (see partial_structure_reader) and the first structure frame in reference_fn. Returns True if the lists match, False if they dont if check_bacbone_dihedrals{logical} is True then check use the residues that either their phi or psi angle moved by more than tolerance degrees are used instead of distance in cartesian space

Use the featurs in structurecheck to identify potential problems in the structure. By default this will find any instances where there is a steric clash of more than 30% of the vdW radius (set by steric delta {float}) or any bond length deviations of more than 0.15 angstroms (set by bond_length_deviation {float}) The number of allowable clashes, bond length deviations and other structual properties can be set by passing a dictionary into protein_health_kwargs {dict} as decirbed in the help for structurecheck.ProteinReportCheck. frames_to_check is descirbed above Note that protein_health_kwargs needs to have a dictionary passed to it to be useful as a STU test. Currently STU does not allow this.

For a given structure ct1 {structure.Structure} and the Plop residue or atom name name1 {string, described convert_plop_name_to_asl} and a second ct2 {structure.Structure}, name2 {string} pair following the same convention, return the minimum distance between the two. If either name matches no values in the structure then None is returned.

STU workup For the specified structure frames in a filename {string} return True if the minimum distance between the atom or residue name1 {string} is distance {float} +- tolerance{float} Angstroms. Otherwise return false (see partial_structrue_reader for description of frames_to check)

STU workup
For the specified structure frames in a filename {string} return True
if the torsion between atoms with names name1-4 {string} is
value {float} +- tolerance{float} degrees.  Otherwise return false
(see partial_structure_reader for description of frames_to check)
The format for name is <chain>:<residue number>:<pdb atom name> 
    where a _ is replaced with a space (note that the <pdb atom name>
    should be 4 characters and padded with _ for spaces ie A:12:_CA_.

STU workup
For the specified structure frames in a filename {string} return True
if the residues match the residues listed in residues {string,
   space separted list of residue names as given by the __str__
   operator of structure._Residue} then return True 
(see partial_structrue_reader for description of frames_to check)

STU workup For the specified structure frames in a filename {string} return True if all contain the specified numbers of atoms{integer}, residues{integer}, and molecules{integer}, If any of these are not set then that test is skipped. Otherwise return False. (see partial_structrue_reader for description of frames_to check)

Return a truth table as a dictionary with keys tp, tn, fp, fn &
    "no prediction" with the number of frames where the prediction is 
    a True Positive, True Negative, False Positive, False Negative 
    or no prediction was provided.  
For an input filename{string} containing one or more structures
    readable by StructureReader
property{string} the property name of predicted value stored as
    ct-level property filename
referecne property{string} the property name of true value stored as
    ct-level property filename
By default the value in property will be converted to a boolean, however
    the cutoff {variable that supports >=} is defined then a predicted
    value of True will given whenever the value is greater than this 
    cutoff.  
If reverse is True then the predicted value will be reversed (this makes
    the most sense when cutoff is also used)
frame_to_check is passed to partial_structure_reader

STU Workup that will check if the accuracy of a predictors is more
than some cutoff value and raise an assertion error otherwise
usage:
    min_accuracy {float 0.0 - 1.0},
    filename {string with path of file readable by StructureReader}     
    property{string with the property name of predicted value stored as
       ct-level property in the structures within filename }
    reference property{string with the property name of the reference value 
       stored as ct-level property filename}
    cufoff=cutoff { variable that supports >= on property (usually int or 
        float}
    reverse=reverse { Boolean}
    frame_to_check {string with the indicies of frames within filename
        to process}
By default the value in property will be converted to a boolean, however
the cutoff {variable that supports >=} is defined then a predicted
value of True will given whenever the value is greater than this 
cutoff. 
If reverse is True then the predicted value will be reversed (this makes
the most sense when cutoff is also used)

STU Workup that will check if the F1 Score of a predictors is more
than some cutoff value and raise an assertion error otherwise
usage:
    min_f1 {float 0.0 -1.0),
    filename {string with path of file readable by StructureReader}     
    property{string with the property name of predicted value stored as
       ct-level property in the structures within filename }
    reference property{string with the property name of the reference value 
       stored as ct-level property filename}
    cufoff=cutoff { variable that supports >= on property (usually int or 
        float)}
    reverse=reverse {Boolean) 
    frame_to_check {string with the indicies of frames within filename
        to process}
By default the value in property will be converted to a boolean, however
the cutoff {variable that supports >=} is defined then a predicted
value of True will given whenever the value is greater than this 
cutoff. 
If reverse is True then the predicted value will be reversed (this makes
the most sense when cutoff is also used)

STU Workup For a specified structure in a filename {string} return True if the property named property_name{string} is equal to value {any type} If tolerance is ">", "<", ">=" or "<=" than use that operation instead of equals. Otherwise is tolerance is provided and not in the above list than return True iff all frames are within tolerance of value.

Raise an assertion error if there are entries with duplicated values
of a given ct-level property.
Inputs:
    filename {string} Maestro formated structure file to read
    property_name {string} ct-level property name.  This should
       start with r_ or i_
    tolerance {float} Values within this tolerance are considered equal
    frames_to_check {list of integers} check these frames in filename
       as described in partial structure reader